Manejo de estructuras en C30

[Nocturno]

Tengo una duda con C30 al manejar una variable de tipo struct.
Se trata de esta variable:

Codigo:typedef struct Tipo_Byte1_Raton {
        unsigned BotonIzdo      :1;
        unsigned BotonDcho      :1;
        unsigned BotonCentral      :1;
        unsigned Control      :1;
        unsigned SentidoX      :1;
        unsigned SentidoY      :1;
        unsigned OverflowX      :1;
        unsigned OverflowY      :1;
} RATON_Byte1;

Como véis, es un byte descompuesto en sus ocho bits. Pues bien, tengo en la variable Lectura, de tipo CHAR (=Byte), un valor y me gustaría asignarlo a la variable RATON_Byte1 para luego poder usar cada bit simplemente haciendo referencia a su nombre.

Si hago: RATON_Byte1=Lectura;    me da error de sintaxis.
Si hago: RATON_Byte1.BotonIzdo=0;     también me da error de sintaxis

Finalmente lo he resuelto con una solución poco elegante basada en if...else pero me gustaría saber si existe una solución elegante de asignación de valores a una estructura.

Gracias

[cucaracha]

Mira, yo lo estoy haciendo de este otro modo en CCS:

Codigo:long  MUX;
   #bit  PDN1  = MUX.14
   #bit  PDN0  = MUX.13
   #bit  SEL0  = MUX.12
   #bit  EN0   = MUX.11
   #bit  M0_1  = MUX.10
   #bit  M0_0  = MUX.9
   #bit  M1_1  = MUX.8
   #bit  M1_0  = MUX.7
   #bit  DIV1  = MUX.6

A ver si te sirve...
También lo intenté con una estructura al principio.. pero me quedé igual que tú.

Saludos!!

[Sispic]

No se si funcionara , pero tiene sentido .

Codigo:
volatile unsigned char Raton ;  /* se define Raton como un byte */

typedef struct  Raton {        /* la estructura del raton*/ 
        unsigned BotonIzdo      :1;
        unsigned BotonDcho      :1;
        unsigned BotonCentral   :1;
        unsigned Control      :1;
        unsigned SentidoX      :1;
        unsigned SentidoY      :1;
        unsigned OverflowX      :1;
        unsigned OverflowY      :1;

} RATON_BitsL;

volatile  RATON_BitsL   RATON_Bits; /* RATON_Bits  */

   int main(void) 
  { 

   Raton=PORTB;  
   if(RATON_Bits.OverflowY == 0){ Roedor();}
   RATON_Bits.SentidoX=1;
  }

[Modulay]

Primero tienes que crear una variable del tipo RATON_Byte1:

RATON_Byte1 variable;

Después puedes escribir los campos:

variable.Control  = 0;

Con punteros quizá se pueda hacer tb,prueba con esto:

RATON_Byte1 reg;
char byte;
RATON_Byte1 *registro;
*registro = reg;  
registro = byte;

[Modulay]

Lo del mensaje anterior estaba mal.Lo he modificado,simulado y ya parece que funciona:

Codigo:

typedef struct Tipo_Byte1_Raton {
        unsigned BotonIzdo      :1;
        unsigned BotonDcho      :1;
        unsigned BotonCentral   :1;
        unsigned Control      :1;
        unsigned SentidoX      :1;
        unsigned SentidoY      :1;
        unsigned OverflowX      :1;
        unsigned OverflowY      :1;
} RATON_Byte1;

//////////////////////////////////////////////////////////

int main (void)
  {   
  static int byte;
  RATON_Byte1 *ptr_reg,*reg2; // ptr_reg será nuestra variable registro

  byte = 255;
  ptr_reg = &byte; // ptr_reg apuntando a byte (ya hemos volcado los datos sobre el registro)
  
  // La asignación por campos con un puntero sería asi:
  ptr_reg->BotonIzdo = 0;
  ptr_reg->BotonDcho = 1;
  ptr_reg->BotonCentral = 1;
  ptr_reg->Control = 1;
  ptr_reg->SentidoX = 1;
  ptr_reg->SentidoY = 0;
  ptr_reg->OverflowX = 0;
  ptr_reg->OverflowY = 0;  

  reg2 = ptr_reg; // Copiamos sobre un segundo registro
 
  for(; {}
  return 0;
  }

[wqtrp]

hola, lo mejor para no usar los punteros q es una buena solucion pero consume recursos es usar los typecasts, esto es al asignar una variables otra de distinto tpo, debes decirle de q tipo es, algo asi como

RATON_Byte1 = (Tipo_Byte1_Raton ) Lectura

y otra alternativa q yo usa pq es mas facil, es definir uniones, con lo cual defines los 8 bits pero en forma paralela define el byte y accedes tan to a uno como a otro con nombres distintos....

Suerte.

[Modulay]

wqtrp ya intenté lo del casting pero me daba error:

registro = (RATON_Byte1) byte;

Lo de las uniones suena bien
¿Como se haría?

[Nocturno]

Finalmente, y gracias a vuestra ayuda, he conseguido que funcione.
La solución que me ha funcionado ha sido la de los punteros, y el código ha quedado así:

Definiciones

Codigo:typedef struct RATON_Byte1{
        unsigned BotonIzdo      :1;
        unsigned BotonDcho      :1;
        unsigned BotonCentral   :1;
        unsigned Control      :1;
        unsigned SentidoX      :1;
        unsigned SentidoY      :1;
        unsigned OverflowX      :1;
        unsigned OverflowY      :1;
} Tipo_Byte1_Raton;

Tipo_Byte1_Raton *RATON_Byte1;

Uso de la estructura

Codigo:RATON_Byte1=&DatosRecibidos[0];

if (!RATON_Byte1->SentidoX)
    { bla, bla, bla ...}

Sisco, he probado la opción que indicas pero no consigo asignar un Char a la estructura, da error al compilar. Date cuenta que en tu ejemplo, la asignación de PORTB la haces sobre un char, no sobre una estructura.

También he probado la opción del typecast anunciada por wqtrp pero falla al compilar.

Y bien, ¿qué es eso de las uniones?, ¿una especie de "alias"?

[wqtrp]

Hola Modulay, aqui va un ejemplo de como uso las uniones para el F452, la verdad q me es muy comodo y propuse hacer algo asi para todos los registros y todos los micros , pero yo aun no lo he completado
espero te sirva para copiar la idea..

union {
  int8  reg;
  struct {
    unsigned RA0:1;
    unsigned RA1:1;
    unsigned RA2:1;
    unsigned RA3:1;
    unsigned RA4:1;
    unsigned RA5:1;
    unsigned RA6:1;
  }b;
  struct {
    unsigned AN0:1;
    unsigned AN1:1;
    unsigned AN2:1;
    unsigned AN3:1;
    unsigned x:1;
    unsigned AN4:1;
    unsigned OSC2:1;
  }a;
  struct {
    unsigned x:2;
    unsigned VREFM:1;
    unsigned VREFP:1;
    unsigned T0CKI:1;
    unsigned SS:1;
    unsigned CLK0:1;
  };
  struct {
    unsigned x:5;
    unsigned LVDIN:1;
  };
} PORTA;

[Modulay]

Está interesante wqtrp.Veo que se pueden manejar los bits por separado.Pero no veo que se pueda acceder al puerto y volcarle un byte de una sola vez ¿se puede? ¿como sería?

[wqtrp]

si si,
   el int8 q esta luego de la union soluciona eso

pones

PORTA.reg= lo q quieras y listo, los 8 bits

suerte

[Modulay]

Me contesto a mi mismo.Parece que la unión no define una estructura tal cual la escribimos,si no que la implementa como si fueran diferentes "capas" que se superponen de forma simultánea,siendo cada uno de los elementos de la unión una capa por sí solo.Así,si quiero volcar un byte sobre PORTA,hago referencia a la capa "reg":

PORTA.reg = 180 ; // por ejemplo.

Si quiero acceder a nivel de bit,accedo a cualquiera de las capas de bits que tenemos:

PORTA.AN0 = 0;

¿Es esa la idea?

Edito el mensaje para añadir que funciona realmente bien.
Manolo ya tienes una forma verdaderamente eficaz de solventar tu problema.
Compilado y simulado
Gracias wqrtp

Codigo:
typedef union Tipo_Byte1_Raton {
        int reg;
        struct {
            unsigned BotonIzdo      :1;
            unsigned BotonDcho      :1;
            unsigned BotonCentral                :1;
            unsigned Control      :1;
            unsigned SentidoX      :1;
            unsigned SentidoY      :1;
            unsigned OverflowX      :1;
            unsigned OverflowY      :1;
            };
} RATON_Byte1;

//////////////////////////////////////////////////////////

int main (void)
  {   
  RATON_Byte1 registro; 
  int variable = 15;
  registro.reg = variable;
  registro.Control = 1;
  return 0;
  }

jeje te me adelantaste wqtrp
Saludos

[Nocturno]

Pues sí que queda bien. Muchas gracias

[Enrique_86]

Hola, de gran ayuda su aporte, yo lo uso de la siguiente manera:

file.h
typedef union regFLAGS {
        unsigned int reg;
        struct
       {
           unsigned F0:1;
           unsigned F1:1;
           unsigned F2:1;
           unsigned F3:1;
           unsigned F4:1;
           unsigned F5:1;
           unsigned F6:1;
           unsigned F7:1;
           unsigned F8:1;
           unsigned F9:1;
           unsigned F10:1;
           unsigned F11:1;
           unsigned F12:1;
           unsigned F13:1;
           unsigned F14:1;
           unsigned F15:1;
        };
} FLAGSbits;
FLAGSbits FLAGS;

main.c
#include file.h
int main(void)
{
       //asignacion
       FLAGS.F0=1;
       //test del flag
       if(FLAGS.F0==1)
       {
             //codigo aqui
        }

}


                                                                                                                                     Saludos..