Accedere ai singoli bit di una variabile C18

[emacar]

Come ti avevo scritto potresti cercare info su google sulle struct. Ad esempio:
http://www.html.it/pag/15410/struct-typedef-e-union/
Per quanto riguarda la domanda rivolta a me, purtroppo non so di preciso come viene implementato il tutto. Forse il codice si trova nel file .h (che ora non ho modo di aprire).
In ogni caso immagino che LATD e LATDbits siano nomi mnemonici assegnati ai registri e siano definiti il primo come variabile a 8 bit ed il secondo come struct di 8 elementi ciascuno costituito da 1 bit.
Emanuele

[bobina]

Hai 2 modi per fare quello che vuoi, seguire quello che ti hanno detto gli altri, usi una variabile da 8 bit (unsigned char) e poi con gli operatori logici imposti o rimuovi i singoli oppure usi un esempio del genere:

Codice: Seleziona tutto

typedef union   {
  unsigned char       INFO;
  struct    {
        unsigned LCD:1;
        unsigned UP:1;
        unsigned DWN:1;
        unsigned OK:1;
        unsigned MN:1;
            };
} INFObits;

int main()
{
    INFObits b;

    b.INFO = 0xff;

    printf("%d %d %d %d %d\n",b.LCD,b.UP,b.DWN,b.OK,b.MN);
}


Output:

Codice: Seleziona tutto

1 1 1 1 1


Io l'ho provato con il gcc ma sono abbastanza certo che funziona anche sul C18, poi con XC8 che ti consigli di cominciare ad usare, ci sono degli alias/puntatori a memoria, così accedendo con una variabile struct o al suo alias accedi sempre alla stessa area di memoria.

[StefDrums]

Ciao bobina, emacar, WALTERmwp, JAndrea,
Il modo di fare quello che serve esiste.
E' un po' macchinoso, ma alla fine è lo stesso che usa Microchip e Atmel per controllare bit a bit i vari registri (ad es: PORT, LAT, TRIS, ecc).

Codice: Seleziona tutto

// qui dichiari la tua struct per l'accesso ai bit, una volta sola per qualsiasi variabile ti serva:

typedef struct {
   unsigned bit0:1;
   unsigned bit1:1;
   unsigned bit2:1;
   unsigned bit3:1;
   unsigned bit4:1;
   unsigned bit5:1;
   unsigned bit6:1;
   unsigned bit7:1;
} BitField;


// adesso definisci ogni variabile alla quale ti serve accedere bit per bit in modo che possa essere usata come tipo struct che hai definito prima:

#define variabile1 (*((volatile BitField*)(&VARIABILE1)))
#define variabile2 (*((volatile BitField*)(&VARIABILE2)))

// nota: in questo modo se la tua variabile è: "VARIABILE1", potrai accedere al suo terzo bit in questo modo: "foo = variabile1.bit2;"


Consiglio a tutti di segnarsi questa soluzione, perché può essere molto comoda in alcuni casi (soprattutto se il compilatore in uso non prevede una struttura di "gestione a bit" dei registri)

[WALTERmwp]

Ciao StefDrums, è certo questo ...

Il modo di fare quello che serve esiste.

... e rende il codice più leggibile; tuttavia, rimanendo a quanto richiesto da JAndrea ...

vorrei dichiarare una variabile ad 8 bit, ai quali poter accedere singolarmente, così come vorrei poter assegnare un valore all' intera variabile.

... credo possa restare valido quanto inserito nel Post [10].
Intervengo probabilmente un po in ritardo ma, comunque, nel caso l'OP avesse poca confidenza con il codice in "C", potrebbe fare qualche prova con quanto di seguito suggerito:

Codice: Seleziona tutto

//--- dichiarazioni ---
unsigned byte valore_byte;
unsigned byte maschera_bitpos_uno;
unsigned byte maschera_bitpos_due;
unsigned byte maschera_bitpos_tre;
unsigned byte maschera_otto;
unsigned byte valore_bit_tre;
unsigned byte temp;

//--- inizializzazioni ---
maschera_bitpos_uno = 0x01;
maschera_bitpos_due = 0x02;
maschera_bitpos_tre = 0x04;

//--- esecuzione, qui valore_bit_tre varrà 1 ---
valore_byte = 7;
temp = valore_byte & maschera_bitpos_tre;
if(temp!=0) valore_bit_tre = 1; else valore_bit_tre = 0;

//--- esecuzione, qui valore_bit_tre varrà 0 ---
valore_byte = 19;
temp = valore_byte & maschera_bitpos_tre;
if(temp!=0) valore_bit_tre = 1; else valore_bit_tre = 0;

//--- esecuzione, qui valore_bit_tre varrà 0 ---
valore_byte = 8;
temp = valore_byte & maschera_bitpos_uno;
if(temp!=0) valore_bit_tre = 1; else valore_bit_tre = 0;

//--- esecuzione, qui valore_bit_tre varrà ? ---
valore_byte = 45;
temp = valore_byte & maschera_bitpos_tre;
if(temp!=0) valore_bit_tre = 1; else valore_bit_tre = 0;


... confido nel non avere riportato inesattezze.
Se operi con questo criterio utilizzi, come memoria (registro), un solo byte.

Saluti