Duda de como declarar una variable

[Marttyn]

Estoy haciendo un programita que usa dispositivos I2C. Estuve leyendo sobre I2C y decidi escribir mi propio codigo y no usar uno ya hecho de CCS.
En concreto, quiero adaptar el codigo de control...
explico rapidamente, los dispositivos I2C necesitan un byte de control para poder identificar si la trama que viene a continuacion esta dirigida a ellos o no.
por ejemplo, para manejar una memoria 1024K el byte de control tiene que comenzar por "1010" que es lo que identifica a las memorias i2c, el siguiente bit que especifica a cual de los 2 bancos de memoria se accedera, luego 2 bits para la direccion del dispositivo, y por ultimo un bit que indica si se leera (1) o escribira (0) en la memoria. entonces un byte de control "10101001" indica que esta dirigido a una memoria i2c, con direccion "00", y que se leera en el segundo banco de memoria.

lo que quiero hacer es algo asi como lo que se hace para manejar los pines del micro como memoria, es decir, si el puerto B es un byte en la direccion 0x06, por ejemplo declarar una variable como #bit y asignarla a 0x06.1 (PIN_B1)
lo que quiero es declarar un byte y poder modificar los bits de manera independiente. asi podria declarar un controlbyte y segun a quien vaya dirigido modificarle solo lo necesario, pero con nombres significativos.
algo asi como:

Código: C

1. #byte ControlByte
2. Device = ControlByte.0
3. Bank = ControlByte.4
4. Address = ControlByte.5
5. RW = ControlByte.7

asi luego me quedaria un codigo bastante mas comprensible y facil de modificar
no se si deberia buscar algo de memoria libre en cuadro de organizacion de memoria del micro y declarar una variable como #byte en esa direccion (valdria cualquier direccion libre?), o tal vez crear una estructura... que seria mas eficiente?
gracias, espero que se haya entendido
salu2

[omix]

Puedes hacer uso de las uniones para conseguirlo. Por ejemplo:

Código: C

1. typedef union {
2.     unsigned int8 valor;  //campo de tamaño de un byte
3.     unsigned Bit0:1;       //campos de tamaño de un bit
4.     unsigned Bit1:1;
5.     unsigned Bit3:1;
6.     unsigned Bit4:1;
7.     unsigned Bit5:1;
8.     unsigned Bit6:1;
9.     unsigned Bit7:1;
10. }Puerto;
11.  
12. //declaramos una variable de tipo Puerto
13. Puerto PortA;
14.  
15. //y ya podemos acceder a dicha variable a nivel de bits o de byte
16. PortA = 0x32;
17. PortA.Bit5 = 1;
18. PortA.Bit1 = 0;

Saludos.

[aitopes]

Buenisimo Omix!
No habia usado aun el tema de las uniones. Es barbaro!

Gracias por el dato. 

[Nocturno]

Omix, ¿esa sintaxis es correcta?
Según creo, las uniones declaran todas las variables que vienen detrás como sinónimas, y apuntando a la misma información. si eso es así, todos los bitX serían el mismo, y equivalentes al Bit0 de valor, ¿no?

[Menta]

Primero quería aclarar algo: no todas las memorias están divididas en bancos, yo usé sólo las 24FC1025 de 1Mbit y esas sí están divididas en 2 bancos. Las demás de la serie (menores) sólo tienen un único banco, esto es porque cualquier memoria de menos de 512 Kbits se puede direccionar con 16bits y no necesita dividirse en bancos.

En la librería de manejo de lcd se usa lo siguiente:

struct lcd_pin_map {                   // This structure is overlayed
           BOOLEAN enable;             // on to an I/O port to gain
           BOOLEAN rs;                   // access to the LCD pins.
           BOOLEAN rw;                  // The bits are allocated from
           BOOLEAN unused;           // low order up.  ENABLE will
           int     data : 4;              // be pin B0.
        } lcd;

se pueden asignar constantes:

struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in

y se usa así:

      set_tris_lcd(LCD_READ);
      lcd.rw = 1;
      lcd.enable = 1;
      high = lcd.data;
      lcd.enable = 0;
      lcd.enable = 1;
      low = lcd.data;
      lcd.enable = 0;
      set_tris_lcd(LCD_WRITE);


Yo he implementado las estructuras en mi programa de central meteorológica:

struct alarma_map {
           BOOLEAN error_lluvia;                // bit 0
           BOOLEAN error_dir_viento;
           BOOLEAN error_viento;
           BOOLEAN error_presion;
           BOOLEAN error_temperatura;
           BOOLEAN falla_grabacion;
           BOOLEAN memoria_completa;
           BOOLEAN bateria_baja;                // bit 7
        } alarma;

int alarmero;
#byte alarma = alarmero    // direcciono la estructura a la variable alarmero

y después la uso:

if (alarma.error_temperatura) ....

o puedo hacer:

switch (alarmero)
   {
   case  16: printf(lcd_putc,"!!! FALLA\nSENSOR TEMPERAT."); break;
   case  32: printf(lcd_putc,"!!! FALLA\nGRAB. EN MEMORIA"); break;
   case  64: printf(lcd_putc,"!!!\n  MEMORIA LLENA");       break;
   case 128: printf(lcd_putc,"!!! %4.1fV\n  BATERIA BAJA",tension_bateria); break;
   }

FELIZ AÑO

[aitopes]

Omix, ¿esa sintaxis es correcta?
Según creo, las uniones declaran todas las variables que vienen detrás como sinónimas, y apuntando a la misma información. si eso es así, todos los bitX serían el mismo, y equivalentes al Bit0 de valor, ¿no?

¿O quedaría una estructura de 16 bits de largo? ( 8 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 )

[Nocturno]

Quedarían 16 bits si quitas la cláusula "union", pero al tenerla creo que debería dejarlo todo agrupado.

[omix]

Omix, ¿esa sintaxis es correcta?
Según creo, las uniones declaran todas las variables que vienen detrás como sinónimas, y apuntando a la misma información. si eso es así, todos los bitX serían el mismo, y equivalentes al Bit0 de valor, ¿no?

umm, creo que me colé. Tienes razón Nocturno deberia de haberlo puesto así:

Código: C

1. #
2. typedef union {
3.    unsigned int8 valor;  //campo de tamaño de un byte
4.    struct {
5.       unsigned Bit0:1;       //campos de tamaño de un bit, que apuntan a cada uno de los bits del byte anterior
6.       unsigned Bit1:1;
7.       unsigned Bit3:1;
8.       unsigned Bit4:1;
9.       unsigned Bit5:1;
10.       unsigned Bit6:1;
11.       unsigned Bit7:1;
12.   };
13. }Puerto;

De la otra forma (como bien comentaba Nocturno) todos los campos de un bit estan apuntando a la misma zona de memoria.

Saludos.

[Marttyn]

GRACIAS A TODOS POR LAS RESPUESTAS!!!
Bueno, analizando lo que comentais, el tema de la estructura me parece que sera la mas simple... porque lo de la union la verdad que no lo entendi muy bien.... todo lo que declare dentro de la union seran "sinonimos"?
consume mas recursos? salu2

[omix]

hola Marttyn, lo que hace la union es agruparte las distintas variables que declares en ella, en la misma zona de memoria, para que puedas acceder a dicha zona como mejor de convenga en cada momento, ya sea por byte, word, bits, etc. Pongo un ejemplo para que se vea más claro.

Código: C

1. typedef union{
2.     unsigned valor1 int8;
3.     unsigned valor2 int16;
4.     struct{
5.         unsigned bits0_2:3;
6.         unsigned bits3_7:5;
7.         unsigned bits8_15:8;
8.     };
9. }VariableUnion;

Al declarar la unión anterior, lo que estamos haciendo es agrupando los 3 campos (valor1, valor2 y la estructura anonima) a la misma zona de memoria y por lo tanto la unión ocupa el espacio del mayor de los campos (valor2), es decir, en este caso el tamaño de la unión seria de 16bits (2Bytes). Cuando accedamos al campo valor1 en realidad estaremos accediendo al primer byte de la zona de memoria, que coincide con el byte bajo (esto depende si el micro es little endian o bigendian) del campo valor2. Si accedemos por campo bits0_2 en realidad estamos accediendo a los bits 0-2 del campo valor2 y asi sucesivamente.

Espero que se vea algo más claro.

Un saludo.

[RedPic]

Y aparece, como no, el viejo que llevo dentro. 

Esto de las unions es como cuando hace veinticinco años trabajaba en COBOL y utilizábamos los REDEFINES.

01 DUMB.
  10 VAR1 PICTURE 9( 16 ).
  10 VAR2 REDEFINES VAR1.
    12  VAR21 PICTURE 9( 8 ).
    12  VAR22 PICTURE 9( 8 ).

VAR1 es una variable de 16 de largo, y VAR2 también y ocupa exactamente el mismo área de memoria por lo que al acceder a sus componentes, VAR21 y VAR22, estamos accediendo a sus compoinentes de 8 alto y bajo respectivamente.

[Marttyn]

uyyy, ¿COBOL? yo hace tanto tiempo no estaba ni en planes de fecundacion creo... 
omix, lo de bits0_2, bits3_7, etc son una constante del compilador o simplemente son nombres representativos que les pones a las variables? y luego de los dos puntos ":" el numero que indicas es el numero de bits que ocupara? como es esa manera de declarar variables? no la conocia. por poner un ejemplo, podria declarar un INT como "unsigned Entero:8"? esto esta bien para declarar variables del tamaño que quiera! por ejemplo, el otro dia queria hacer un contador hasta de 0 a 7, y por no usar tres INT1 y andar con IF para saber por cual voy, use un INT8; usando una variable de 3 bits estaria hecho, con menos memoria y mas facil.
salu2!

[MGLSOFT]

El COBOL lo usaron para mover las piedras de las piramides ??

[omix]

uyyy, ¿COBOL? yo hace tanto tiempo no estaba ni en planes de fecundacion creo... 
omix, lo de bits0_2, bits3_7, etc son una constante del compilador o simplemente son nombres representativos que les pones a las variables?

Son nombres que yo le pongo, puedes llamarlo como prefieras.

y luego de los dos puntos ":" el numero que indicas es el numero de bits que ocupara? como es esa manera de declarar variables? no la conocia. por poner un ejemplo, podria declarar un INT como "unsigned Entero:8"? esto esta bien para declarar variables del tamaño que quiera! por ejemplo, el otro dia queria hacer un contador hasta de 0 a 7, y por no usar tres INT1 y andar con IF para saber por cual voy, use un INT8; usando una variable de 3 bits estaria hecho, con menos memoria y mas facil.
salu2!

Si los ':' y el número que viene a continuación es el número de bits que ocupara, pero que no te lleve a confusión si declaras una variable unsigned entero:4, no quiere decir que vaya a ocupar esa variable solamente 4 bits, en realidad ocupa un byte completo, pero solo estarias usando los 4 primeros bits cuando accedes a ella. De todas formas este tipo de declaración queda restrigido su uso solamente en estructuras y uniones (por lo menos en los compiladores de C que yo conozco).

Por cierto cuando pongo unsigned es equivalente a poner unsigned char o unsigned int8, ya que por defecto en la mayoria de compiladores de C unsigned hace referencia a un entero de 8 bits sin signo.

Saludos.

[Marttyn]

todo entendido!
hay un dicho popular que dice "no te acostaras sin haber aprendido algo nuevo"... eso no se aplica a este foro.... deberia ser "no te acostaras sin haber aprendido MUCHAS COSAS nuevas" 
salu2