Operatori per spostare i bit (bitwise)

Marco Lai — Mon, 06 Feb 2012 22:22:19 +0000

Usare Arduino per spostare i bit di una variabile

Oltre alle funzioni viste nel precedente articolo, Arduino è capace di eseguirne altre ed in particolare lo spostamento a destra o a sinistra bit a bit. L’operatore per lo spostamento a destra si esprime con questo operatore >> mentre per lo spostamento a sinistra viene usato questo operatore <<.
Per capire meglio cosa avviene utilizziamo delle immagini che semplificano la spiegazione. In questo caso ho una variabile di tipo byte (8 bit) il cui valore è 255. All’interno del chip atmega328 viene allocata, nella memoria ram, uno spazio di 8 bit i cui valori sono settati a 1

Eseguendo uno spostamento a sinistra <<, tutti i bit si spostano di una posizione verso sinistra e nel bit meno significativo (LSB) viene scritto uno zero:

Quindi il valore della variabile passa da 255 (in binario 11111111) a 254 (in binario 11111110).

Continuando ad eseguire uno spostamento a sinistra, di una posizione, otteniamo i seguenti valori

252	11111100
248	11111000
240	11110000
224	11100000
192	11000000
128	10000000
0	00000000

Il codice che esegue quanto detto è il seguente

[c]
//Variabile di tipo byte
byte MiaVar;

void setup()
{
//init seriale
Serial.begin(9600);
//init variabile 11111111
MiaVar= 255;
}

void loop()
{
//eseguo uno spostamento a sinistra di 1 posizione
//memorizzo il valore nella stessa variabile
MiaVar = MiaVar << 1;

//invio il dato al serial monitor
Serial.println(MiaVar);

//1 secondo di pausa tra una operazione e l’altra
delay (1000);

}

[/c]

Allo stesso modo lo spostamento a destra >> esegue un movimento dei bit dal più significativo al meno significativo:

in questo modo otteniamo i seguenti valori:

127	01111111
63	00111111
31	00011111
15	00001111
7	00000111
3	00000011
1	00000001
0	00000000

Gli operatori >> e << possono spostare i bit anche di diverse posizioni a seconda di come gestiamo l’operatore, ad esempio se voglio spostare i bit di quattro posizioni a sinistra dovrò scrivere:

[c]
MiaVar = MiaVar << 4;
[/c]

in questo modo la variabile MiaVar passerà dal valore 255 al 240.

Generalmente le operazioni bit a bit vengono usate perché sono eseguite molto velocemente da Arduino. Possono anche essere usate per semplici calcoli matematici, ad esempio moltiplicare o dividere un numero, come di seguito:

[c]
//Moltiplica * 2
Risultato = Miavar << 1;
//Moltiplica * 4
Risultato = Miavar << 2;
//Moltiplica * 8
Risultato = Miavar << 3;
//divide / 2
Risultato = Miavar >> 1;
//divide / 4
Risultato = Miavar >> 2;
//divide / 8
Risultato = Miavar >> 3;
[/c]

Questo metodo non è molto intuitivo ma quando ci troviamo ad ottimizzare il nostro codice per essere eseguito nel minor tempo possibile, lavorare con i bit è sempre una risorsa.

The post Operatori per spostare i bit (bitwise) appeared first on Esperimenti con logiche programmabili.

Arduino, lavorare con i bit

Marco Lai — Tue, 10 Jan 2012 13:46:41 +0000

Come usare gli operatori per manipolare i bit

Lavorare con i microcontrollori, incluso Arduino, è divenuto abbastanza semplice grazie all’impiego di linguaggi ad alto livello che permettono di imparare in modo semplice e veloce la programmazione di questi device. Nonostante l’uso di funzioni che gestiscono variabili complesse, molte volte si ha la necessità di gestire i singoli bit. Arduino implementa dei metodi per accedere direttamente ai bit di una variabile e di poterne leggerne e cambiare il valore.

I bit è l’unità più piccola capace di esprimere un informazione (valori 1 e 0). L’unione di più bit forma altre unità come il byte (composto da 8 bit). Il byte è stato il primo sistema per codificare un carattere ed è capace di esprimere 256 valori (2^8 = 256).
Per accedere ai singoli bit che compongono il byte possiamo usare le funzioni seguenti:

Leggere un singolo bit

Per leggere il valore di un singoli bit usiamo la funzione bitRead(Val, Posizione); dove Val è il valore della variabile e Posizione è il numero del bit da leggere, con indice zero. Eccovi alcuni esempi di utilizzo

[c]

byte Data = 0;

void setup()
{
Serial.begin(9600);
}

void loop()
{
Data = 0; //in binario 00000000

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Data = 255; //in binario 11111111

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Data = 127; //in binario 11111110

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Settare un bit

La funzione che permette di mettere a 1 un singolo bit è la seguente bitSet(Val, Posizione); dove Val esprime il valore del byte e Posizione è l’indice del bit da settare.

[c]

byte Data = 0;

void setup()
{
Serial.begin(9600);
}

void loop()
{
Data = 0; //in binario 00000000

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//setta il bit 0
bitSet(Data, 0);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//setta il bit 7
bitSet(Data, 7);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Resettare un bit

la funzione che invece permette di mettere a zero un singolo bit è la seguente bitClear(Val, Posizione); dove Val è il solito valore in byte e Posizione rappresenta l’indice del bit da settare a 0.

[c]
byte Data = 0;

void setup()
{
Serial.begin(9600);
}

void loop()
{
Data = 255; //in binario 11111111

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//resetta il bit 0
bitClear(Data, 0);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//resetta il bit 5
bitClear(Data, 5);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Settare o resettare con la stessa funzione

Esiste una funzione capace di eseguire sia le operazione di settaggio dei bit sia le operazioni di reset, il suo prototipo è bitWrite(Val, Posizione, ValBit); dove Val è il byte che vogliamo modificare, Posizioe rappresenta l’indice del bit da modificare e ValBit è il valore del bit (1 0 0)

[c]
byte Data = 0;

void setup()
{
Serial.begin(9600);
}

void loop()
{
Data = 255; //in binario 11111111

Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//resetta il bit 0
bitWrite(Data, 0, 0);
//resetta il bit 3
bitWrite(Data, 2, 0);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

//setta il bit 1
bitWrite(Data, 0, 0);
//setta il bit 3
bitWrite(Data, 2, 1);
//resetta il bit 5
bitWrite(Data, 4, 0);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

La funzione bit();

La funzione bit(x); ci permette di calcolare il valore decimale del bit specificato, l’esempio chiarisce meglio il concetto

[c]

void setup()
{
Serial.begin(9600);
}

void loop()
{
//valori decimali dei singoli bit
Serial.println(bit(0)); 2^0 = 1
Serial.println(bit(1)); 2^1 = 2
Serial.println(bit(2)); 2^2 = 4
Serial.println(bit(3)); 2^3 = 8
Serial.println(bit(4)); 2^4 = 16
Serial.println(bit(5)); 2^5 = 32
Serial.println(bit(6)); 2^6 = 64
Serial.println(bit(7)); 2^7 = 128

Serial.println();
delay(2000);

}
[/c]

Negli esempi è stato analizzato il singolo byte ma è possibile lavorare anche con gli altri tipi. Ad esempio possiamo effettuare delle operazioni su una variabile unsigned int (composta da 16 bit (2^16)-1 da 0 a 65535)

[c]
unsigned int Data = 65535;

void setup()
{
Serial.begin(9600);
}

void loop()
{

//valore decimale del bit 12
Serial.print(“valore decimale del bit 12 “);
Serial.print(bit(12)); // 2^12 = 4096
Serial.println();

Data = 65535;

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

Serial.print(bitRead(Data, 0)); //bit meno significativo
Serial.print(bitRead(Data, 1));
Serial.print(bitRead(Data, 2));
Serial.print(bitRead(Data, 3));
Serial.print(bitRead(Data, 4));
Serial.print(bitRead(Data, 5));
Serial.print(bitRead(Data, 6));
Serial.print(bitRead(Data, 7));
Serial.print(bitRead(Data, 8));
Serial.print(bitRead(Data, 9));
Serial.print(bitRead(Data, 10));
Serial.print(bitRead(Data, 11));
Serial.print(bitRead(Data, 12));
Serial.print(bitRead(Data, 13));
Serial.print(bitRead(Data, 14));
Serial.print(bitRead(Data, 15)); //bit più significativo
Serial.println();
delay(2000);

//setta il bit 1
bitWrite(Data, 0, 0);
//resetta il bit 3
bitWrite(Data, 10, 0);
//resetta il bit 5
bitWrite(Data, 15, 0);

//visualizza il valore di Data
Serial.print(“Valore in bit della variabile Data(“);
Serial.print(Data);
Serial.println(“):”);

}
[/c]

Manipolare i bit sembra macchinoso ma il vantaggio è che Arduino esegue molto velocemente questo tipo di operazioni, vedremmo successivamente come sia possibile eseguire semplici operazioni lavorando con i singoli bit.

[facebook_ilike]

The post Arduino, lavorare con i bit appeared first on Esperimenti con logiche programmabili.

Bit Archives - Esperimenti con logiche programmabili

Operatori per spostare i bit (bitwise)

Usare Arduino per spostare i bit di una variabile

Arduino, lavorare con i bit

Come usare gli operatori per manipolare i bit

Leggere un singolo bit

Settare un bit

Resettare un bit

Settare o resettare con la stessa funzione

La funzione bit();