Como pasar de Byte a Int o long

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 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.

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