Byte más significativo, menos significativo y bits individuales

[akydes_]

¡¡Hola amigos!!
Pues, veréis, que como soy bastante torpe  , he empezado a meterle mano al C para programar PIC (concretamente, estoy probando con "CCS C"), y resulta que me han surgido unas cuantas dudas que no consigo encontrar ni en la ayuda ni en el manual en español que hay enlazado en el hilo del "microcursillo" (lo mismo es que soy torpe hasta para buscar ). Bueno, las cuestiones son las siguientes:

1)  ¿Cómo accedo al byte más significativo de una variable de tamaño  16 bits? Es decir, si tengo:

     A = 1010 0111 1111 0100
¿¿¿ cómo hago para que B = HighByte(A) = 1010 0111 ???

2) Idem, pero para el byte menos significativo ???

     B = Lowbyte(A) = 1111 0100                      

3) Si tengo una variable cualquiera, de un byte por ejemplo, cómo hago para acceder a cada bit de forma individual??? es decir:

     A = 1010 0111    =>  Cómo hago  B = A.0 (que sería "1")?
     o B = A.6 (que sería "0") ????

Del mismo modo, ¿cómo hago

VARIABLE.5 = 1 por ejemplo??


Perdonad por haberme extendido tanto para estas preguntas tan simples, pero es que quería que quedase lo más claro posible.

Muchas gracias por leerme, y perdonad las molestias

[gfp]

He realizado un corto programa y espero que con este código pueda resolver tus inquietudes.

gfp


#include <18F452.h>
#use delay(clock=20000000)
#fuses NOWDT,WDT128,HS, NOPROTECT, NOOSCSEN, NOBROWNOUT, BORV20, PUT, NOSTVREN, NODEBUG, NOLVP, NOWRT, NOWRTD, NOWRTB, NOWRTC, NOCPD, NOCPB, NOEBTR, NOEBTRB
#zero_ram
#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#use fast_io(D)
#use fast_io(E)


   long   A =0b1010011111110100;
   int      B;                  //HighByte(A)
   int      C;                  //LowByte(A)


void main()
{
B=A/256;   //Copias a "B" el byte mas significativo de "A"
C=A;      //Copias a "C" el byte menos significativo de "A"

/*HASTA AQUI HEMOS SEPARADO EN DOS REGISTROS LA PARTE ALTA Y BAJA DE "A"*/
/*AHORA VAMOS A LAS INSTRUCCIONES DE MANIPULACION DE BITS*/

while(1)
{
   if( bit_test(B,0))   //EL BIT 0 DEL REGISTRO B ESTA EN "1"?
   {
      bit_clear(B,0);   //SI ESTA EN "1" LO COLOCAMOS A "0".
   }
   else
   {
      bit_set(B,0);   //SI ESTA EN "0" LO COLOCAMOS A "1".
   }
}
//NOTA QUE AL DIVIDIR UN REGISTRO CUALQUIERA POR 2,4,8,16,32,64,128,256,...,ETC LO DESPLAZAS A LA DERECHA UNA, DOS, CUATRO, U OCHO POSICIONES RESPECTIVAMENTE.
//SI MULTIPLICAS UN REGISTRO CUALQUIERA POR 2,4,8,16,32,64,..ETC. LO ESTAS DESPLAZANDOA LA IZQUIERDA UNA, DOS CUATRO U OCHO POSICIONES.
}

[akydes_]

Muchas gracias gfp!!
Me encanta tu solución, porque es realmente simple (aún así, no se me había ocurrido, ni de coña   , y además potente. Sobre todo en lo del byte más y menos significativo.

Con respecto a la forma de asignar/obtener valores de bits ¿no hay forma de hacerlo sin emplear bucles ni bifurcaciones?

muchas gracias por la solución  

PD: Ahora que caigo, tal vez empleando punteros y el operador "." se pueda resolver... voy a probar y ya pongo por aquí lo que saque.

Lo dicho, muchas gracias de nuevo

[pocher]

Puedes también hacerlo así:

#byte Etapas = 0x20

#bit E0 = 0x20.0
#bit E1 = 0x20.1
#bit E2 = 0x20.2
#bit E3 = 0x20.3
#bit E4 = 0x20.4
#bit E5 = 0x20.5
#bit E6 = 0x20.6
#bit E7 = 0x20.7

Una vez asignadas las variables ya puedes usarlas con sus nombres en el programa: Etapas, E0, E1 .. E7

Un saludo

[gfp]

Intenta con la  instrucción: INPUT_STATE(), pero solo es soportada desde la version 3.206 del CCS. Por otra parte, respecto a la separación o bien la union de registros de ocho bit a uno de 16 bit te pueden ser útiles las siguiemntes instrucciones: ROTATE_RIGHT(address, bytes), ROTATE_LEFT(address, bytes), SHIFT_LEFT(address, bytes, value), SHIFT_RIGHT(address, bytes, value) o tambien los operadores de desplazamiento de bitsesplazamiento a la derecha: ">>"
Desplazamiento a la izquierda: "<<".

gfp

[akydes_]

Muchas gracias gfp y pocher. Con vuestra ayuda he conseguido resolver el problema que tenía.  

[Nocturno]

Otra forma simple de hacerlo es usando comparaciones binarias.

Si cualquier byte lo comparas, por ejemplo, con el valor 00010000 usando el comparador AND, el resultado será un 1 si en el bit5 había un 1 o un 0 si no lo había. Por lo que el resultado será el valor que había en el bit5 original.

Te pongo un ejemplo que extrae los 8 bits y donde lo verás más claro:

Codigo:#include <16F876a.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7) 

void main() {
   int8 valor;
   
   valor=230; // 11100110
   
   printf("Bit 0: %u
", (valor & 1)!=0);   // 00000001
   printf("Bit 1: %u
", (valor & 2)!=0);   // 00000010
   printf("Bit 2: %u
", (valor & 4)!=0);   // 00000100
   printf("Bit 3: %u
", (valor & !=0);   // 00001000
   printf("Bit 4: %u
", (valor & 16)!=0);  // 00010000
   printf("Bit 5: %u
", (valor & 32)!=0);  // 00100000
   printf("Bit 6: %u
", (valor & 64)!=0);  // 01000000
   printf("Bit 7: %u
", (valor & 128)!=0); // 10000000
   
}

[akydes_]

De nuevo, muchas gracias por vuestras ideas. Es increíble lo que cualquier cosa puede dar de sí, y lo mucho que se aprende en este foro

Al final lo he hecho así, que es básicamente como me dijísteis:

Codigo:
// ACCESO A LOS BITS DE UNA VARIABLE.
int variable = 0b10101111;
short bit;

// bit = Bit_Test(variable,bit_que_queramos); Dará 0 o 1 dependiendo del valor que
// tenga el bit correspondiente al que se accede.

bit = Bit_Test(variable,5);  // bit valdrá 1 en este caso.
// que es lo mismo que hacer:
bit = ((var & (1 <<5)) != 0);
bit = Bit_Test(variable,4);  // bit valdrá 0 en este caso.
// que es lo mismo que hacer:
bit = ((var & (1 <<4)) != 0);

// "ESTABLECIMIENTO" DE LOS BITS DE UNA VARIABLE.
// Para poner a 0 o a 1 un bit determinado de una variable, 
// análogo al método Variable.5 = 1 o Variable.5 = 0 usado en Basic.

// queremos poner un 1 por ejemplo en el bit 5 de "variable".
Bit_Set(variable,5);
// que es lo mismo que hacer:
variable | = (1 << 5);

// Si lo queremos limpiar:
Bit_Clear(variable,5);
// que es lo mismo que hacer:
variable & = ~(1 << 5);

Con respecto a la obtención del byte más y menos significativo de una variable de 16 bits, la solución propuesta por gfp es impecable.

Un saludo a todos, y nuevamente... ¡muchas gracias!

[pacalaconcurso]

para obtener los diferentes bytes puedes usar make8...es lo mismo que te apunta gfp pero se entiende mejor al interpretar el codigo que escribistes

de la ayura del ccs

int32 x;

int y;

 

y = make8(x,3);  // Gets MSB of x

saludos

[gauchosuizo]

hola gente

yo propongo otro ejemplo:

unsigned int8 highbyte, lowbyte;
unsigned int16 word;

lowbyte = word & 0xFF;
highbyte = (word >> & 0xFF;


Aloha