Hola gente, tengo un problema para pasar un numero de byte a entero o bien a long
El numero en byte es el siguiente:
byte buffer[]={0x04,0x1C};
Vendria a ser 1052 en decimal
Como lo podría pasar?
Muchas gracias
cada byte se pondera por 256
El byte LSB va como esta y se suma a los siguientes y cada vez con una potencia de 256.
Si pasas a int y supongo buffer[0] como LSB Less Significant Byte y buffer[1] como MSB More Significant Byte
int int_numero = buffer[1]*256^1 + buffer[0]*256^0;
Expreso con el ^potencia para que veas la secuencia
Si fuera un long entonces
long long_numero = buffer[3]*256^3 + buffer[2]*256^2 + buffer[1]*256^1 + buffer[0]*256^0;
Por supuesto faciilita las cosas no usar las potencias y hacerlo mas simple pero te lo muestro para que sepas de donde sale.
surbyte:
cada byte se pondera por 256El byte LSB va como esta y se suma a los siguientes y cada vez con una potencia de 256.
Si pasas a int y supongo buffer[0] como LSB Less Significant Byte y buffer[1] como MSB More Significant Byte
int int_numero = buffer[1]*256^1 + buffer[0]*256^0;Expreso con el ^potencia para que veas la secuencia
Si fuera un long entonces
long long_numero = buffer[3]*256^3 + buffer[2]*256^2 + buffer[1]*256^1 + buffer[0]*256^0;Por supuesto faciilita las cosas no usar las potencias y hacerlo mas simple pero te lo muestro para que sepas de donde sale.
Hola, muchas gracias por tu respuesta
En realidad el MSB es el buffer[0].
Probe con:
int int_numero = buffer[0]*256^1 + buffer[1]*256^0;
Serial.println(int_numero);
y el resultado obtenido es: 6145
Mientras que deberia ser:
Lo que te ha dicho surbyte es la teoría. Lo de las potencias era para que vieras de dónde sale. En la práctica se trabaja con operaciones a nivel de bit. Con desplazamientos a la izquierda y la operación OR, ambos a nivel de bits. Para un int se hace así:
byte buffer[] = {0x04, 0x1C};
int int_numero = (byte)buffer[0] << 8 | (byte)buffer[1];
Serial.println(int_numero);
Serial.println(int_numero, HEX); // Para mostrarlo en hexadecimal y ver fácilmente que el valor es correcto
Y para un long así:
long long_numero = (long)buffer[0] << 24 | (long)buffer[1] << 16 | (long)buffer[2] << 8 | (long)buffer[3];
Serial.println(long_numero);
Serial.println(long_numero, HEX); // Para mostrarlo en hexadecimal y ver fácilmente que el valor es correcto
En realidad el MSB es el buffer[0].
Entonces inviertelo!!
numero = 0x04 * 256 + 0x1C = 1024 + 28 = 1052
Esto no funciona:
int int_numero = buffer[1] * 256^1 + buffer[0] * 256^0;
Porque el circunflejo ^ no significa "elevado a", sino que es el operador XOR a nivel de bits. En todo caso debería de usarse la función pow():
int int_numero = buffer[1] * pow(256, 1) + buffer[0] * pow(256, 0);
Pero como en este caso 256 elevado a 1 es 256 y 256 elevado a 0 es 1, bastaría con:
int int_numero = buffer[1] * 256 + buffer[0] * 1;
O simplemente nos ahorramos el multiplicar por 1 y lo dejamos así:
int int_numero = buffer[1] * 256 + buffer[0];
¿Pero de dónde sale el 6145? Volvamos al ejemplo inicial y a la operación:
int int_numero = buffer[1] * 256^1 + buffer[0] * 256^0;
Teniendo en cuenta que en base 10 el valor de 0x04 es 4 y el de 0x1C es 28, y para que quede más claro sustituyo con la palabra XOR la operación del ^. Lo que se está haciendo es:
4 * 256 XOR 1 + 28 * 256 XOR 0
Siendo orden de precedencia de los operadores de mayor a menor: la multiplicación, la suma y la operación XOR. Siguiendo este critero ponemos paréntesis para que quede todo más claro:
(4 * 256) XOR (1 + (28 * 256)) XOR 0
Realizamos primero las operaciones de multiplicación y nos queda:
(1024) XOR (1 + (7168)) XOR 0
Ahora realizamos la suma:
(1024) XOR (7169) XOR 0
El cero es el elemento neutro de la operación XOR, con lo que realizar o no realizar un XOR 0 no nos cambia el resultado. Esto nos deja:
1024 (10000000000)
XOR 7169 (1110000000001)
= 6145 (1100000000001)
Y así es como se obtiene en 6145. He puesto al lado, entre paréntesis, el número en binario para que "se vea mejor" la operación XOR.
E insisto. Esto de las potencias de dos es la teoría. En la práctica se hace con operaciones de desplazamiento de bits, nunca con la función pow().
Muchas gracias a todos, ya lo solucione (El problema que tenia era que no me tomaba el signo de elevado)
Saludos