Gli operatori in Arduino

Durante lo sviluppo dei nostri sketch per Arduino, ci troveremo spesso a fare i conti con la manipolazione di variabili (cfr. articolo precedente), su cui effettueremo operazioni aritmetiche, confronto tra i valori e implementazioni di condizioni logiche. A tal fine la piattaforma Arduino ci mette a disposizione un certo numero di operatori, in particolare operatori aritmetici, relazionali e logici.

Operatori aritmetici

Gli operatori aritmetici, detti anche binari in quanto permettono di eseguire operazioni su due operandi, sono quelli delle quattro operazioni fondamentali, come illustrato nella seguente tabella:

OperazioneOperatore
Addizione+
Sottrazione
Moltoplicazione*
Divisione/
Modulo%
tabella degli operatori aritmetici in Arduino

Tramite questi operatori possiamo sommare, sottrarre, moltiplicare, dividere e ottenere il resto del contenuto di due o più variabili tramite espressioni come mostrato nel seguente esempio di codice:

int operando1, operando2, risultato; //dichiarazione delle variabili variabili

//assegnazione
operando1 = 10;
operando2 = 3;

//addizione
risultato = operando1 + operando2;

//sottrazione
risultato = operando1 - operando2;

//moltiplicazione
risultato = operando1 * operando2;

//divisione
risultato = operando1 / operando2;

//modulo, ottiene il resto della divisione
risultato = operando1 % operando2;

Come esercizio per il lettore, prima di passare al test del codice riportato più avanti nell’articolo, si può provare a immaginare quale sia di volta in volta il valore della variabile risultato dopo ogni riassegnazione e, soprattutto, nelle ultime due operazioni di divisione e modulo.

Operatori aritmetici composti

Spesso si ha necessità di eseguire un’operazione aritmetica applicando ad una variabile una quantità fissa come nell’esempio seguente:

int numero = 3;
numero = numero + 5;

Abbiamo prima dichiarato la variabile numero, assegnandole contestualmente il valore 3 e, successivamente, le abbiamo sommato 5. Esiste tuttavia una forma contratta, con la quale possiamo ottenere lo stesso risultato in maniere più rapida ed elegante, applicando l’operatore composto +=:

numero += 5; //operatore unario di addizione

L’operatore unario si può applicare a tutti gli operatori aritmetici, come mostrato nella tabella sotto:

OperatoreEspressione standardEspressione contratta
+=numero = numero + 5;numero += 5;
-=numero = numero – 5;numero -= 5;
*=numero = numero * 5;numero *= 5;
/=numero = numero / 5;numero /= 5;
%=numero = numero % 5;numero %= 5;
tabella degli operatori aritmetici composti in Arduino

Operatori unari

A sottrazione ed addizione corrisponde un operatore unario, denominazione che sta ad indicare che si applicano ad un solo operando. Gli operatori unari sono di due tipi:

  • Incremento, aggiunge un’unità al valore di una variabile: ++
  • Decremento, sottrae un’unità al valore di una variabile —

Essi possono essere sia prefissi alla variabile a cui si applicano, sia postfissi. Nel primo caso, all’interno di un’espressione con più operandi, viene prima incrementato/decrementato di un’unità il valore della variabile e poi viene eseguita l’operazione successiva; nel secondo caso, l’incremento/decremento avviene dopo l’operazione successiva. Il codice seguente mostra alcuni esempi di utilizzo dell’operatore unario:

int variabile = 7;

++variabile; //incremento di un'unità con operatore prefisso
variabile++; //incremento di un'unità con operatore postfisso

--variabile; //decremento di un'unità con operatore prefisso
variabile--; //decremento di un'unità con operatore postfisso

int risultato = ++variabile - 4;
risultato = variabile++ + 4;

Esercizio per il lettore: quali valori assumono ad ogni operazione le variabili variabile e risultato?

Operatori relazionali

Alcune operazioni di controllo che mettono a confronto due operandi, sono molto utili per gestire il flusso di esecuzione di un programma Arduino. In particolare potremmo voler stabilire se il valore di una variabile è maggiore, minore, uguale, maggiore o uguale, minore o uguale, diverso da quello di un’altra. Per far questo ci serviremo degli operatori relazionali schematizzati come segue:

Operazione di confrontoOperatore
Uguale a==
Maggiore di>
Minore di<
Diverso da!=
Maggiore o uguale a>=
Minore o uguale a<=
tabella degli operatori relazionali in Arduino

Assegnando ad una variabile booleana il risultato di un’espressione di confronto, saremo in grado di stabilire se l’operazione restituisce vero o falso, come nel codice seguente:

int operando1, operando2;
bool risultato;

operando1 = 65;
operando2 = 34;

risultato = operando1 == operando2; //operando1 è uguale a operando2?
risultato = operando1 != operando2; //operando1 è diverso a operando2?
risultato = operando1 >= operando2; //operando1 è maggiore o uguale a operando2?
risultato = operando1 <= operando2; //operando1 è minore o uguale a operando2?
risultato = operando1 > operando2; //operando1 è maggiore di operando2?
risultato = operando1 < operando2; //operando1 è minore di operando2?

Il lettore può esercitarsi provando a rispondere alle domande nei commenti al codice. Qual è di volta in volta il valore della variabile risultato?

Operatori logici

Gli operatori logici ci consentono di confrontare due o più espressioni booleane, ottenute con gli operatori di confronto. Possono essere molto utili in un progetto Arduino, ad esempio per far scattare un alert se i valori di due sensori diversi sono al di sotto di una certa soglia. La tabella seguente mostra la sintassi degli operatori logici utilizzabili negli sketch per Arduino:

OperatoreDescrizione
&&AND
||OR
!NOT

L’operatore AND restituisce true se e solo se entrambi gli operandi sono true.

L’operatore OR restituisce true se uno dei due operandi è true, altrimenti restituisce false.

L’operatore NOT inverte il valore del suo operando, non a caso viene definito operatore di negazione.

Vediamo alcuni esempi di operazioni logiche in Arduino:

bool op1 = true;
bool op2 = true;
bool op3 = false;

bool risultato;

risultato = op1 && op2;
risultato = op1 && op3;
risultato = op1 || op2;
risultato = op1 || op3;
risultato = !op1;
risultato = !op3;
risultato = op1 && !op3;
risultato = op1 || !op3;

Sketch per testare gli operatori in Arduino

Siamo pronti per riunire tutti gli esempi di utilizzo degli operatori in Arduino visti finora in un unico programma riepilogativo, che ci aiuterà anche a capirne il comportamento (e a verificarne i risultati se abbiamo fatto gli esercizi suggeriti sopra!).


void setup() {
  Serial.begin(9600); //impostiamo il baudrate della porta seriale
  
  int operando1, operando2, risultato; //dichiarazione delle variabili variabili

  //assegnazione
  operando1 = 10;
  operando2 = 3;
  
  //addizione
  risultato = operando1 + operando2;
  Serial.print("Addizione: ");
  Serial.println(risultato);
  
  //sottrazione
  risultato = operando1 - operando2;
  Serial.print("sottrazione: ");
  Serial.println(risultato);
  
  //moltiplicazione
  risultato = operando1 * operando2;
  Serial.print("moltiplicazione: ");
  Serial.println(risultato);
  
  //divisione
  risultato = operando1 / operando2;
  Serial.print("divisione: ");
  Serial.println(risultato);
  
  //modulo, ottiene il resto della divisione
  risultato = operando1 % operando2;
  Serial.print("modulo: ");
  Serial.println(risultato);
  
  int variabile = 7;

  ++variabile; //incremento di un'unità con operatore prefisso
  Serial.print("incremento con operatore prefisso: ");
  Serial.println(variabile);
  
  variabile++; //incremento di un'unità con operatore postfisso
  Serial.print("incremento con operatore postfisso: ");
  Serial.println(variabile);
  
  --variabile; //decremento di un'unità con operatore prefisso
  Serial.print("decremento con operatore prefisso: ");
  Serial.println(variabile);
  
  variabile--; //decremento di un'unità con operatore postfisso
  Serial.print("decremento con operatore prefisso: ");
  Serial.println(variabile);
  
  risultato = ++variabile - 4;
  Serial.print("incremento con operatore prefisso in una espressione: ");
  Serial.println(risultato);
  
  risultato = variabile++ + 4;
  Serial.print("incremento con operatore postfisso in una espressione: ");
  Serial.println(risultato);
    
  operando1 = 65;
  operando2 = 34;

  bool risultatoBool; //dichiarazione di una variabile bool per gli output delle operazioni logiche e relazionali
  
  risultatoBool = operando1 == operando2; //operando1 è uguale a operando2?
  Serial.print("operando1 è uguale a operando2: ");
  Serial.println(risultatoBool);
  
  risultatoBool = operando1 != operando2; //operando1 è diverso a operando2?
  Serial.print("operando1 è diverso a operando2? ");
  Serial.println(risultatoBool);
  
  risultatoBool = operando1 >= operando2; //operando1 è maggiore o uguale a operando2?
  Serial.print("operando1 è maggiore o uguale a operando2? ");
  Serial.println(risultatoBool);
  
  risultatoBool = operando1 <= operando2; //operando1 è minore o uguale a operando2?
  Serial.print("operando1 è minore o uguale a operando2? ");
  Serial.println(risultatoBool);
  
  risultatoBool = operando1 > operando2; //operando1 è maggiore di operando2?
  Serial.print("operando1 è maggiore di operando2? ");
  Serial.println(risultatoBool);
  
  risultatoBool = operando1 < operando2; //operando1 è minore di operando2?
  Serial.print("operando1 è minore di operando2? ");
  Serial.println(risultatoBool);

  bool op1 = true;
  bool op2 = true;
  bool op3 = false;
  

  Serial.println("Operatori logici: ");
  risultatoBool = op1 && op2;
  Serial.println(risultatoBool);
  risultatoBool = op1 && op3;
  Serial.println(risultatoBool);
  risultatoBool = op1 || op2;
  Serial.println(risultatoBool);
  risultatoBool = op1 || op3;
  Serial.println(risultatoBool);
  risultatoBool = !op1;
  Serial.println(risultatoBool);
  risultatoBool = !op3;
  Serial.println(risultatoBool);
  risultatoBool = op1 && !op3;
  Serial.println(risultatoBool);
  risultatoBool = op1 || !op3;
  Serial.println(risultatoBool);

}

void loop() {
  // put your main code here, to run repeatedly:

}

Ecco l’output dello sketch sul monitor seriale (come di consueto, per questi primi esempi introduttivi, non inseriamo alcun codice nella funzione loop):

Addizione: 13
sottrazione: 7
moltiplicazione: 30
divisione: 3
modulo: 1
incremento con operatore prefisso: 8
incremento con operatore postfisso: 9
decremento con operatore prefisso: 8
decremento con operatore prefisso: 7
incremento con operatore prefisso in una espressione: 4
incremento con operatore postfisso in una espressione: 12
operando1 è uguale a operando2: 0
operando1 è diverso a operando2? 1
operando1 è maggiore o uguale a operando2? 1
operando1 è minore o uguale a operando2? 0
operando1 è maggiore di operando2? 1
operando1 è minore di operando2? 0
Operatori logici: 
1
0
1
1
0
1
1
1

Da notare che la funzione Serial.println() stampa un intero quando le viene passato un valore bool. Questo avviene perché Serial.println() prova a stampare il byte di dati della variabile risultatoBool in formato ASCII.

Conclusione

Abbiamo visto come Arduino ci permette di manipolare il contenuto delle variabili dei nostri sketch tramite l’uso di alcuni operatori e ne abbiamo testato il funzionamento tramite un programma di esempio. Adesso che siamo in grado di utilizzare variabili, tipi e operatori per costruire delle operazioni più o meno complesse, possiamo approcciarci alla creazione di qualcosa di più interessante, che magari abbia a che fare con qualche sensore e attuatore. Non prima però di avere avuto un assaggio di elettronica, quel tanto che basta per costruire qualche semplice circuito, ad esempio per accendere un led o per acquisire la temperatura da un sensore apposito.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.