¿Como puedo seleccionar los bits que me interesan dentro de una palabra?

[AngelGris]

  Que pena pero no puedo ver la captura de imagen.

  El shift es sencillo de entender, tenés que verlo del punto de vista de un desplazamiento. Veamos un ejemplo con 4 bits para que sea más entendible

  Número original  (binario) 1110, (decimal) 14, (hexadecimal) 0x0E

  Al aplicar un shift right (desplazamiento a la derecha) el valor 1110 pasa a ser 0111. Esto es desplazar los bits a la derecha, se mueven todos un lugar. El Bit 3 quedaría vacío, y en su lugar se coloca un 0.
  Otro ejemplo (binario) 1001, después del shif 0100. Se desplazan todos una posición hacia la derecha (el bit de menor peso se pierde) y el bit de mayor peso queda en 0.

  El mismo criterio se emplea para el shift left, solo que el desplazamiento es hacia la izquierda.

  ¿Qué compilador estás usando y cuales son los errores que aparecen? (pnelo en modo texto para que los podamos ver, o en todo caso algún otro servidor de imágnes) Creo que el ejemplo que puso Suky funciona en CCS

[ppyote]

void main(){
   int cuenta;
   long valor1=0b1100101110001010;
   long valor2=0;

   for(cuenta=15;cuenta<=15;cuenta--){
      if(bit_test(valor1,cuenta))bit_set(valor2,15-cuenta);
      else bit_clear(valor2,15-cuenta);
   }
}

yo lo hago asi...

[Thulsa Doom]

El compilador es CCS pero me lo compila bien y no da error, el error lo da en el simulador proteus, y esos datos yo los saco por pantalla LCD para comprobar que esta haciendo bien el desplazamiento.

Yo entiendo lo de desplazar a la izquierda y derecha, lo que no entiendo es la sintaxis de la función, por ejemplo en el manual de ccs c pone esto:

Tiene un ejemplo y todo pero lo aplico y no me funciona, lo que he dicho error de memoria en el proteus, buscando por la red he encontrado otros ejemplos utilizando punteros pero no lo entiendo.
me esta costado de entender el C, porque aplico lo que leo en los libros y foros y no me funciona,(estoy frustrado). a ver si con el tiempo y la ayuda lo voy comprendiendo

[AngelGris]

  Por lo que yo entiendo de la sintaxis, address es la la variable a la cual le quieras hacer el shift, bytes es la cantidad de bytes que tiene tu variable y value es el valor que se va a utilizar en los lugares "vacios" (o sea, el relleno que se va agregando)

[Thulsa Doom]

¿Y donde se supone que se guarda el resultado?

[AngelGris]

¿Y donde se supone que se guarda el resultado?

  En la propia variable que se le pasa a la función shift

[Thulsa Doom]

void main(){
   int cuenta;
   long valor1=0b1100101110001010;
   long valor2=0;

   for(cuenta=15;cuenta<=15;cuenta--){
      if(bit_test(valor1,cuenta))bit_set(valor2,15-cuenta);
      else bit_clear(valor2,15-cuenta);
   }
}

yo lo hago asi...

Gracias , esto si me funciono.

 En la propia variable que se le pasa a la función shift

Gracias AngelGris por la respuesta



Hay una cosa que no entiendo, es lo de la marcara, si yo le hago a un palabra esto:

Código: [Seleccionar]

int16 dato1 = 0b0011111111111111;
dato = (dato1 & 0b00000011111111);
como el dato1 no es una palabra constante si no que cambia dependiendo del momento que este midiendo (el dispositivo conectado es un detector de temperatura que pasa el dato a digital automáticamente generando el dato de 16 bits) si la palabra cambia por ejemplo dato1 = 0b0001111000000000; como le está haciendo un and continuamente al dato1 y como todos sabemos que

   AND
00 | 0
01 | 0
10 | 0
11 | 0
¿Al cambiar los 1 por los 0 en dato1, ese o esos bits no se anula al pasar a 0, quedando el dato incompleto?

[ppyote]

void main(){
   int cuenta;
   long valor1=0b1100101110001010;
   long valor2=0;

   for(cuenta=15;cuenta<=15;cuenta--){
      if(bit_test(valor1,cuenta))bit_set(valor2,15-cuenta);
      else bit_clear(valor2,15-cuenta);
   }
}

yo lo hago asi...

Gracias , esto si me funciono.

me alegro que te funcionase... un saludo

[AngelGris]

  No entiendo bien el planteo respecto de las máscaras. Que un bit sea 0 no significa que se anule. Veamos si con un par de ejemplos se entiende mejor el tema

  Imaginemos que se reciben 16 bits pero sólo nos interesan desde el 0 hasta el 11.. Llamaremos "dato1" a la variable en la cual se almacena lo recibido y "dato_con_mascara" (que original!  ) a la variable a la cual ya le apliqué la máscara. La máscara tiene que ser 0b0000111111111111 (sólo tienen que estar en 1 los bits que nos interesen).

  En primera instancia dato1 = 0b1010101010101010. Ahora, al aplicar la máscara quedaría así....

dato_con_mascara = dato1 & 0b0000111111111111 --> dato_con_mascara = 0000101010101010

dato1                   0b1010101010101010
mascara               0b0000111111111111
dato_con_mascara 0b0000101010101010        // lo puse en esa forma para que se lea mejor el resultado de la AND

como verás los bits 0..11 siguen manteniendo el valor original de la variable dato1

si ahora dato1 = 1111000011001100

dato_con_mascara = dato1 & 0b0000111111111111 --> dato_con_mascara = 0b0000000011001100

dato1                   0b1111000011001100
mascara               0b0000111111111111
dato_con_mascara 0b0000000011001100

como verás los bits 0..11 siguen manteniendo el valor original de la variable dato1

[Thulsa Doom]

aa vale, yo lo veía desde el punto de vista de puertas lógica, de que cuando multiplicabas dos números binarios el resultado que daba es  de una puerta AND, por eso puse los valores de una AND en mensajes anteriores, no lo había visto como una formula en un compilador.

[AngelGris]

aa vale, yo lo veía desde el punto de vista de puertas lógica, de que cuando multiplicabas dos números binarios el resultado que daba es  de una puerta AND, por eso puse los valores de una AND en mensajes anteriores, no lo había visto como una formula en un compilador.

  Es que justamente hace una AND, no es que sea una fórmula del compilador. El problema es que, al menos en la última tabla que mostrás, está mal.... La tabla de verdad de una AND es..

00 0
01 0
10 0
11 1

 Es decir que el resultado será 1 sólo cuando todas sus entradas sean 1.

[Thulsa Doom]

¿pero eso funcionará?, es que los datos no son fijos si no que cambian, date cuenta que un and es.

   AND
 
 00 | 0    
 01 | 0
 10 | 0
 11 | 1

con lo cual si son 1 si me los pillara pero si son 0 los desechara

  OR

 00 | 0
 01 | 1
 10 | 1
 11 | 1

estas técnicas las he utilizado para hacer que en un mismo puerto tenga patillas de entrada y patillas de salida.
pero si dices que funciona....estudiaré el tema.
gracias

Si es cierto, estoy un poco cansado y se me fue el dedo, pero en otras tablas anteriores si lo pongo bien

Lo que dije anteriormente es por que si tu haces na multiplicación de dos valores por ejemplo

                                     001101
                                 x  000111
                                    -------------
                                     010100  creo que este es el resultado de una multiplicación lógica
con lo cual si cambias el numerador o el denominador el resultado es diferente, por eso decía que como el dato capturado cambia y el dato que introducimos a mano para hacer el and permanece fijo, pues no entendía como cambiando una de las dos palabras, permanecía fijo la cantidad de bits que designaba con la palabra que introducimos a mano.

Uffff que rollo al igual estoy liandolo un poco mas de lo debido 

[AngelGris]

  Ah perdón, pensé que capaz tu confusión venía por ese lado.

[pocher]

Lo que has hecho aquí es una suma logica:

                                     001101
                                 x  000111
                                    -------------
                                     010100

... no una multiplicación a nivel de bits cuyo resultado seria:

                                     001101
                                 x  000111
                                    -------------
                                     000101

[Thulsa Doom]

Jo es verdad, uyyy estoy oxidado.
bueno pero mi pregunta sigue siendo la misma