enteros de 12 bits

[integeroverflow]

Hola no entiendo esto.
A ver tu tienes un array ejemplo:
int arr [2];

Y le asignas dos valores:
arr[0] = 0110 1010
arr[1] = 1100 0001

Código [Seleccionar] Expandir

((short)arr[0])    //casteando a short nos quedaria el byte dentro de 2 bytes, es asi?

Eso quiere decir que tu cadena se alarga en 16 bits.

en realidad no estamos hablando de una cadena, si no de numeros enteros. lo que sucede al castear es que el compilador va a tratar ese numero como si fuesen 2 bytes. no se alarga en 16 bits, si no que en 8.
es como el siguiente ejemplo en decimal (es ilustrativo, nada que ver con programacion):
15 // el 15 expresado en un supuesto tipo de datos de 2 digitos
0015 // el 15 expresado en un supuesto tipo de datos de 4 digitos. mismo numero, mayor cantidad de digitos disponibles

Pero porqué este valor?

Código [Seleccionar] Expandir

0000 0000 0110 1010 // quedando este valor


queda ese valor porque los tipos de datos que yo manejo al principio son CHAR, o sea, 1 byte (8 bits). al castearlo a short (2 bytes, 16 bits), me queda un numero de 16 digitos, como el valor es el mismo que antes los 8 nuevos digitos quedan en 0

Aqui dices esto:

Código [Seleccionar] Expandir

"<< 4" desplazaria los bits 4 veces hacia la izquierda, correcto?
0000 1010 0110 0000 // quedando este valor

Pero lo correcto seria¿Porque este número de donde lo sacaron?:

Código [Seleccionar] Expandir

0000 1100 0000 0000

si tengo este numero: 0000 0000 1010 0110, y muevo 4 posiciones a la izq, queda 0000 1010 0110 0000, el numero que pusiste ahi le estan faltando 4 bits, 0110

Lo usastes en la posicion 1¿?

Código [Seleccionar] Expandir

arr[1] >> 4

Y porque devuelve este valor?:

Código [Seleccionar] Expandir

0000 1100 0000 0000

Aplicando esto:

Código [Seleccionar] Expandir

0000 0000 0110 1010 | 0000 1100 0000 0000

esto no es una division, es el operador OR. lo que hace, si miramos la tabla:

INPUT    OUTPUT
A    B    A OR B
0    0    0
0    1    1
1    0    1
1    1    1

devuelve 1 si alguno de los 2 digitos es 1, caso contrario devuelve 0. entonces se puede usar para copiar un conjunto de bits.
ejemplo:

 1101
 0001
=1101 (uno y cero da 1, 0 y 0 da 0, 1 y 1 da 1)

Cuanto devolvería y porque? A vale es una division ok.
En cuanto esto sería una simple suma es correcto?
  1101 1001 1100 1000
  0000 0000 1111 1111
= 0000 0000 1100 1000

Hace tiempo que no repasaba las operaciones en binario tendré que repasarlas si me podeis aclarar alguno de estos puntos me seria util gracias.

Por otro lado porque
0xFF valdria 0000 0000 1111 1111 ?

0xFF tiene ese valor porque la F en hexadecimal vale 15. si hacemos la cuenta:

Código [Seleccionar] Expandir

0 = 0
1 = 1
10 = 2
11 = 3
100 = 4
101 = 5
110 = 6
111 = 7
1000 = 8
1001 = 9
1010 = 10
1011 = 11
1100 = 12
1101 = 13
1110 = 14
1111 = 15

entonces teniendo 0xFF nos quedaria el siguiente valor

1111 1111

el grupo del ceros al principio es porque estamos hablando de un short, o sea 2 bytes o 16 bits. quedando:

0000 0000 1111 1111.

espero se haya entendido.

[integeroverflow]

Código (c) [Seleccionar] Expandir


#include <stdio.h>

// Enteros de 12 bit
// 000111001001
// 000111001010
// 000111001011
// 000111001100
// 000111001101
// 000111001110

// 457 458 459 460 461 462

unsigned char a[9] = {
0b00011100,
0b10010001,
0b11001010,
0b00011100,
0b10110001,
0b11001100,
0b00011100,
0b11010001,
0b11001110
};

int main()
{


for(int i=0; i<9; i++)
{
if(i % 2){
short y = 0;
y = ((a[i] & 0xF) << 8);
y |= ((a[i+1] & 0xFF));
printf("%d\n", y);

} else {

short x = 0;
x = (a[i] << 4) | ((a[i+1] >> 4) & 0xF);
printf("%d\n", x);
}
}
}


dejo mi codigo a ver si me podes ayudar.
si te fijas arriba del todo, hay una lista de enteros de 12 bits. abajo su valor en decimal.
luego tenemos un array de bytes que contiene estos enteros de 12 bits en enteros de 8 bits.
es decir, cada elemento par del array contiene 2 tercios del entero que representa, y cada elemento impar contiene 1 tercio del entero representado por el elemento anterior y 1 tercio del entero que representa el elemento siguiente.

para verlo con mas claridad:

unsigned char a[9] = {
0b00011100,
0b10010001,
0b11001010,
0b00011100,
0b10110001,
0b11001100,
0b00011100,
0b11010001,
0b11001110
};

en el codigo lo que hago es ir elemento por elemento y chequear si es par o impar. si es par, shifteo a la izquierda 4 bits y tomo los primeros  4 bits del elemento siguiente. si es impar, elimino los primeros 4 bits, shifteo a la izquierda 8 bits, y copio el contenido del elemento siguiente.
ese codigo funciona bien, lo pruebo y me devuelve el valor decimal que tiene que devolver.

sin embargo, falla en algunos elementos.
que puede estar causando el problema?

output:

Código [Seleccionar] Expandir


457
458
3233
3249
2844
3100
461
462
3296


[ivancea96]

No depende de si el byte es par o impar. Depende del resto de dividir entre 3:

Código (c) [Seleccionar] Expandir

int main()
{
for(int i=0; i<9; i++)
{
if(i % 3 == 1){
short x = ((a[i] & 0xF) << 8);
x |= ((a[i+1] & 0xFF));
printf("%d\n", x);

} else if(i % 3 == 0) {

short x = (a[i] << 4) | ((a[i+1] >> 4) & 0xF);
printf("%d\n", x);
}
}
}

[integeroverflow]

No depende de si el byte es par o impar. Depende del resto de dividir entre 3:

Código (c) [Seleccionar] Expandir

int main()
{
for(int i=0; i<9; i++)
{
if(i % 3 == 1){
short x = ((a[i] & 0xF) << 8);
x |= ((a[i+1] & 0xFF));
printf("%d\n", x);

} else if(i % 3 == 0) {

short x = (a[i] << 4) | ((a[i+1] >> 4) & 0xF);
printf("%d\n", x);
}
}
}

ahora si, funciona perfecto.

pero no me quedo claro, que tiene que ver el resto de la division con 3? me podrias explicar asi logro entenderlo?

te agradezco

[ivancea96]

unsigned char a[9] = {
0b00011100, // 0 (entero 1)
0b10010001, // 1 (entero 2)
0b11001010, // 2 (nada)
0b00011100, // 0 (entero 1)
0b10110001, // 1 (entero 2)
0b11001100, // 2 (nada)
0b00011100, // 0 (entero 1)
0b11010001, // 1 (entero 2)
0b11001110 // 2 (nada)
};

Tienes 2 enteros cada 3 bytes.
En el primer bytes, obtienes el primer entero (accediendo, además, al siguiente byte)
En el segundo byte, obtienes el segundo entero (accediendo también al siguiente byte)
El tercer byte es, en su totalidad, parte del anterior entero. Aquí no hay anda que hacer

Y repites. 3 bytes, 2 acciones.

[integeroverflow]

Tienes 2 enteros cada 3 bytes.
En el primer bytes, obtienes el primer entero (accediendo, además, al siguiente byte)
En el segundo byte, obtienes el segundo entero (accediendo también al siguiente byte)
El tercer byte es, en su totalidad, parte del anterior entero. Aquí no hay anda que hacer

Y repites. 3 bytes, 2 acciones.

ahora si, lo entiendo perfectamente.

esto sucedia si chequeaba par o impar:

1111 1111 // byte 0 = 1111 1111 1001
1001 0110 // byte 1 = 0110 1011 1011
1011 1011 // byte 2 = 1011 1011 1100
1100 0011

ahora cada 3 bytes el byte es salteado.

muchas gracias por tu ayuda amigo !!!

[MAFUS]

A ver, he encontrado esto: http://www.disc.ua.es/~gil/FAT12Description.pdf

Según el paper los 12 bits se consiguen de esta forma:

Suponiendo que 3 bytes consecutivos tienen la siguiente información (supongamos también que cada bit del byte puede alojar un número decimal):

Posición	Byte
0	76543210
1	54321098
2	32109876

Bien, pues el primer número de 12 bits sería el 109876543210
y el segundo número de 12 bits sería el 321098765432

Esto es así porque la FAT se hizo para máquinas IBM, y esas son little-endian, lo que quiere decir que el LSB se encuentra en la parte baja de la memoria. Traducido:
Para formar la representación de los 12 bits del primer número debes tomar
· Del 2º byte los 4 bits menos significativos : 1098
· Del 1er byte todos los bits : 76543210

Para formar la representación de los 12 bits del segundo número debes tomar
· Del 3er byte todos los bits : 321098765432
· Del 2º byte los 4 bits más significativos

[integeroverflow]

A ver, he encontrado esto: http://www.disc.ua.es/~gil/FAT12Description.pdf

Según el paper los 12 bits se consiguen de esta forma:

Suponiendo que 3 bytes consecutivos tienen la siguiente información (supongamos también que cada bit del byte puede alojar un número decimal):

Posición	Byte
0	76543210
1	54321098
2	32109876

Bien, pues el primer número de 12 bits sería el 109876543210
y el segundo número de 12 bits sería el 321098765432

Esto es así porque la FAT se hizo para máquinas IBM, y esas son little-endian, lo que quiere decir que el LSB se encuentra en la parte baja de la memoria. Traducido:
Para formar la representación de los 12 bits del primer número debes tomar
· Del 2º byte los 4 bits menos significativos : 1098
· Del 1er byte todos los bits : 76543210

Para formar la representación de los 12 bits del segundo número debes tomar
· Del 3er byte todos los bits : 321098765432
· Del 2º byte los 4 bits más significativos

que tal hermano
gracias por tu respuesta. ya habia visto ese PDF, la informacion sobre el formato FAT12 ya la tenia, mi duda era sobre las operaciones binarias en c lo cual ya lo solucione.

claro que la operacion que yo hago en el codigo que publique recientemente parte el segundo byte al reves, es decir:

XXXX XXXX
XXXX XXXX
XXXX XXXX

pero ahora que tengo en claro como hacer operaciones con bits, solo queda modificar el codigo para leerlo de la manera correcta y arreglar mi funcion que lee la FAT. o sea

XXXX XXXX
XXXX XXXX
XXXX XXXX