Procedura bitwise complessa.

[harpefalcata]

Buongiorno a tutti.

Stò sviluppando un codice per un microcontrollore e, per farlo, ho bisogno che i bit contenuti all'interno di un particolare registro, in un'ooportuna posizione, assumano delle costanti ben defiite, che devo imporre io, scolpendole nel codice.

A questo scopo ho elaborato una sequenza di operazioni bitwise, abbastanza complessa. Pur avendola controllata più volte, la riporto qui di seguito sperando in un aiuto da parte della comunity.

Codice: Seleziona tutto

1) Carico nel registro di appoggio R1 un valore a piacere di 32 bit.
2) Carico nel registro di appoggio R2 il valore esadecimale 0x041.
3) Eseguo un'operazione di shift logico verso sinistra (LSL = Logical Shift Left) di esattamente 4 posizioni, ed il risultato lo metto in R2 sovrascrivendo qualunque precedente valore.
4) Il risultato della precedente lo inverto bit-a-bit (logical-NOT) e lo sposto nel registro di appoggio R3.
5) Eseguo un'operazione di AND-bit-a-bit tra il risultato della precedente, ed il valore di R1 rimasto immutato dall'inizio. Il risultato lo inserisco in R3, sovrascrivendo qualunque precedente valore.
6) Eseguo un'operazione OR-bit-a-bit  tra l'attuale valore di R3 ed il valore di R2, rimasto invariato dalla 3. Il risultato di questa operazione lo metto in R3 sovrascrivendo qualunque precedente valore.
7) In R3 ho ora il risultato che mi interessa


Lo scopo ultimo di questa procedura è di ottenere che tutti i bit dalla posizione bit 11, fino alla bit 4, assumano questo valore: 0100 0001, ovvero:

bit11 bit10 bit9 bit8 bit7 bit6 bit5 bit4
0 1 0 0 0 0 0 1

A voi risulta che la mia procedura sia corretta?

Prima di sottoporre tutto a debugger vorrei avere una conferma logica.

Vi ringrazio

[GuidoB]

No, non funziona.

Di solito si definiscono una maschera e uno shift:

Codice: Seleziona tutto

#define FIELD_MASK  0x00000FF0 // Tutti i bit occupati dal campo messi a 1
#define FIELD_SHIFT 4          // Di quante posizioni il campo è spostato a sinistra

e poi:

Codice: Seleziona tutto

reg = (reg & ~FIELD_MASK) | (field << FIELD_SHIFT);


e hai finito.

~ è il NOT bit a bit, & è l'AND bit a bit, | è l'OR bit a bit, << è l'operatore di shift a sinistra.

Nel tuo caso field vale sempre 0x41. Se lo definisci come una costante (#define FIELD_VALUE 0x41), puoi scrivere:

Codice: Seleziona tutto

reg = (reg & ~FIELD_MASK) | (FIELD_VALUE << FIELD_SHIFT);

Così il compilatore potrà precalcolare alcune parti dell'espressione e produrre codice più ottimizzato.

[harpefalcata]

In effetti ha qualche problema. Il problema credo che sia quando io faccio la NOT. In seguito allo shift che precede la not, io mi aspettavo che tutte le posizioni via via vacanti a causa dello shift stesso venissero riempite da uno, mentre, come è normale sono riempite dagli zero di padding. E' qui che l'intera procedura cade.

L'ho già sostituita con una coppia di maschere, una per la ANd ed una per la OR, ma ero curioso di sapere se funzionava.

Non ho problemi di far ottimizzare codice al compilatore. Io sviluppo direttamente in assembly.

Grazie comunque.

Saluti.