BCD Hex stringa a intero

Question

sono stato in grado di modificare la soluzione fornita da Brad Christie per ottenere i risultati che mi aspetto per ore, minuti, secondi, mesi, giorni e anni che sono tutti in BCD Formato:

static Int32 GetYearFromBCD(Int32 time) 
{ 
int length = time.ToString().Length -1;
List<Int32> YearList = new List<Int32>(); 
for (Int32 i = length; i >= 0; i --) 
{ 
Int32 place = i * 4; 
Int32 val = 0x01 << place; 

Int32 curVal = (Int32)(time / val); 
if (curVal > 9 && YearList.Count > 0) 
{ 
Int32 delta = (Int32)(curVal / 10); 
YearList[YearList.Count - 1] += delta; 
curVal -= delta * 10; 
} 
YearList.Add(curVal); 
time -= curVal << place; 
} 
Int32 Year = 0; 
for (Int32 y = 0; y < YearList.Count; y++) 
Year += YearList[y] * (Int32)Math.Pow(10,(length+1 - y)-1); 
return Year; 
} 

Ho voluto fornire un aggiornamento a questa domanda. Dopo che il dispositivo è stato in funzione per diversi giorni attraverso Capodanno, ero in grado di piena confermano che la soluzione codice di Brad postato fa esattamente quello che avrà bisogno.

Sono stato in grado di confermare i miei sospetti che il valore atteso è stato davvero un Binary Coded Decmial, sono stato in grado di confermare che il valore atteso funziona solo ha un valore esadecimale. Un collega è stato in grado di confermare in modo indipendente la data e l'ora, utilizzando la tabella per lo standard, quindi mi sento a mio agio mettere questo a letto.

Sono stato in grado di confermare che per qualsiasi motivo il valore decmial dei dati non funziona, posso solo concludere i dati vengono inviati come un valore esadecimale da parte del dispositivo, la mia unica preoccupazione è saranno altre applicazioni lavorare in un simile metodo.

Apprezzo l'aiuto di tutti a capire questo fuori, alcuni dei commenti mi portano giù un percorso che mi permettono di capire.

Answer 1

Bene, anche se i numeri non sembrano dare un senso, questo è ciò che mi è venuta (dando i risultati voi sono in attesa (dagli esempi forniti). Prendete questo attraverso la strizzatore e vedere se viene fuori con tutti i risultati che vi aspettate:

static Int32 GetYearFromBCD(Int32 time)
{
    List<Int32> YearList = new List<Int32>();
    for (Int32 i = 3; i >= 0; i --)
    {
        Int32 place = i * 4;
        Int32 val = 0x01 << place;

        Int32 curVal = (Int32)(time / val);
        if (curVal > 9 && YearList.Count > 0)
        {
            Int32 delta = (Int32)(curVal / 10);
            YearList[YearList.Count - 1] += delta;
            curVal -= delta * 10;
        }
        YearList.Add(curVal);
        time -= curVal << place;
    }
    Int32 Year = 0;
    for (Int32 y = 0; y < 4; y++)
        Year += YearList[y] * (Int32)Math.Pow(10,(4 - y)-1);
    return Year;
}

Sono davvero solo prendendo un colpo al buio a questo come i numeri hai dato non è quello che definirei tipica. Detto questo, si deve fare quello che stai ricevendo il lavoro, in modo da: scrollata di spalle:.

Answer 2

Se si desidera convertire il numero di rappresentazione esadecimale basta usare ToString con "x" come param:

2010.ToString("x")  output: "7da"

Comunque, io non capisco che cosa si vuole raggiungere, se si dice che per il 2010, ci si aspetta 200A.

Answer 3

Sei davvero sicuro che il vostro esempio è corretto? Perché si ha un hex-serie, in cui la prima parte è con la base 10 e la seconda parte è base 16?

Normal sarebbe uno di questi:

• 2010 => 0x07DA
  • completa hex
• 2010 => 0x140A
  • il numero è rotto a metà strada e ciascuna parte esagono
• 2010 => 0x2010
  • BCD codificato come trovato su wikipedia (dove altro); -)

Dopo un po 'googling e pensare qui è la mia prima idea:

• Mettere il tutto in una BinaryReader .
• Ottieni tutti i valori individualmente fuori di esso chiamando BinaryReader .ReadByte () e gettalo via ad un int
• Moltiplicare ogni valore prima del 10, poi dividere per 16
• Mettere tutto questo i singoli valori in un List<int>
• uso Math.Pow(value, 10 * (List.Count - indexOfValue)) di aggregare tutti questi valori