Publicado por: akydes_ en 04 de Diciembre de 2004, 11:12:00
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 :)
Publicado por: gfp en 04 de Diciembre de 2004, 13:02:00
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.
}
Publicado por: akydes_ en 04 de Diciembre de 2004, 13:17:00
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
Publicado por: pocher en 04 de Diciembre de 2004, 13:39:00
#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
Publicado por: gfp en 04 de Diciembre de 2004, 13:48:00
esplazamiento a la derecha: ">>"Desplazamiento a la izquierda: "<<".
gfp
Publicado por: akydes_ en 04 de Diciembre de 2004, 14:00:00
Publicado por: Nocturno en 05 de Diciembre de 2004, 02:40:00
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 & 8)!=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
}
Publicado por: akydes_ en 05 de Diciembre de 2004, 03:18:00
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!
Publicado por: pacalaconcurso en 05 de Diciembre de 2004, 12:30:00
de la ayura del ccs
int32 x;
int y;
y = make8(x,3); // Gets MSB of x
saludos
Publicado por: gauchosuizo en 06 de Diciembre de 2004, 09:41:00
yo propongo otro ejemplo:
unsigned int8 highbyte, lowbyte;
unsigned int16 word;
lowbyte = word & 0xFF;
highbyte = (word >> 8) & 0xFF;
Aloha