c# - sistema - tabla bcd

La manera más eficiente de convertir BCD a binario

Question

Tengo el siguiente código para convertir un valor de BCD de 32 bits (suministrado en dos mitades de uint) a un valor binario uint.

Los valores suministrados pueden ser hasta 0x9999, para formar un valor máximo de 0x99999999.

¿Hay una forma mejor (es decir, más rápida) de lograr esto?

 /// <summary>
/// Convert two PLC words in BCD format (forming 8 digit number) into single binary integer.
/// e.g. If Lower = 0x5678 and Upper = 0x1234, then Return is 12345678 decimal, or 0xbc614e.
/// </summary>
/// <param name="lower">Least significant 16 bits.</param>
/// <param name="upper">Most significant 16 bits.</param>
/// <returns>32 bit unsigned integer.</returns>
/// <remarks>If the parameters supplied are invalid, returns zero.</remarks>
private static uint BCD2ToBin(uint lower, uint upper)
{
uint binVal = 0;
if ((lower | upper) != 0)
{
int shift = 0;
uint multiplier = 1;
uint bcdVal = (upper << 16) | lower;
for (int i = 0; i < 8; i++)
{
uint digit = (bcdVal >> shift) & 0xf;
if (digit > 9)
{
binVal = 0;
break;
}
else
{
binVal += digit * multiplier;
shift += 4;
multiplier *= 10;
}
}
}
return binVal;
}

Answer 1

Tu código parece bastante complicado; ¿necesita la verificación de errores específicos?

De lo contrario, podría usar el siguiente código, que no debería ser más lento, de hecho, es más o menos lo mismo:

uint result = 0;
uint multiplier = 1;
uint value = lo | hi << 0x10;
while (value > 0) {
uint digit = value & 0xF;
value >>= 4;
result += multiplier * digit;
multiplier *= 10;
}
return result;

Answer 2

Si tiene espacio de sobra para una matriz de elementos de 39,322, siempre puede mirar el valor hacia arriba.

Answer 3

Supongo que podrías desenrollar el bucle:

value = ( lo & 0xF);
value+= ((lo>>4) & 0xF) *10;
value+= ((lo>>8) & 0xF) *100;
value+= ((lo>>12)& 0xF) *1000;
value+= ( hi & 0xF) *10000;
value+= ((hi>>4 & 0xF) *100000;
value+= ((hi>>8) & 0xF) *1000000;
value+= ((hi>>12)& 0xF) *10000000;

Y puede verificar si hay dígitos BCD inválidos como este:

invalid = lo & ((lo&0x8888)>>2)*3

Esto establece la invalidez en un valor distinto de cero si hay un único dígito hexadecimal> 9.

Answer 4

Si desenrolla el ciclo, recuerde mantener el bit shift.

value = ( lo & 0xF);
value += ((lo >> 4 ) & 0xF) * 10;
value += ((lo >> 8 ) & 0xF) * 100;
value += ((lo >> 12) & 0xF) * 1000;
value += ( hi & 0xF) * 10000;
value += ((hi >> 4 ) & 0xF) * 100000;
value += ((hi >> 8 ) & 0xF) * 1000000;
value += ((hi >> 12) & 0xF) * 10000000;

Answer 5

Por supuesto, hay un método más eficiente. esto es solo un ejemplo, por supuesto, así que puedes sintonizarlo como una lección ^^

function bcd_to_bin ($bcd) {
$mask_sbb = 0x33333333;
$mask_msb = 0x88888888;
$mask_opp = 0xF;
for($i=28;$i;--$i) {
$mask_msb <<= 1;
$mask_opp <<= 1;
$mask_sbb <<= 1;
for($j=0;$j<$i;$j+=4) {
$mask_opp_j = $mask_opp << $j;
if ($bcd & $mask_msb & $mask_opp_j ) {
$bcd -= $mask_sbb & $mask_opp_j;
}
}
}
return $bcd; 

}

Answer 6

Prueba esto:

public static int bcd2int(int bcd) {
return int.Parse(bcd.ToString("X"));
}

Answer 7

public static uint BCDToNum(int num)
{
return uint.Parse(num.ToString(), System.Globalization.NumberStyles.HexNumber);
}