GUIDA ARDUINO 4: STRUTTURE SOFTWARE

Nella Quarta Parte della Guida verranno Illustrate le Strutture Software della Programmazione Arduino e le Variabili…

 

 

 
 



 

INTRO

Per la scrittura dei codici esecutivi serve una minima conoscenza del linguaggio di C. Arduino infatti usa un linguaggio di programmazione C per la compilazione degli scratch. Alcuni costrutti sono particolari del linguaggio Arduino, come ad esempio la scrittura dei pin di I/O.

Questo articolo cerca di fornire una base sulle strutture e la sintassi per la programmazione di Arduino.  Verrà illustrata la struttura base dello scratch, le funzioni , le strutture per il controllo del flusso come gli “if”, “else”, “for”, “while” e il “do-while” e le variabili e i loro possibili tipi, come i floating point (numeri con la virgola) oppure i byte (numeri a 8 bit).

 

LA STRUTTURA DEL CODICE

La struttura base della programmazione Arduino è molto semplice ed è divisa in due parti, una prima parte di inizializzazione e una seconda parte dove inserire le funzioni da eseguire. I due blocchi sono i seguenti:

void setup() {
  "Inizializzazioni"
}
void loop() {
  "Funzioni"
}

“void setup” è la funzione di inizializzazione, tra le parentesi graffe si inizializzano le porte di I/O oppure variabili e viene eseguita una volta sola. Nel “void loop”  tra le parentesi graffe vengono inserite le funzioni e li vari controlli da ripetere ciclicamente.

A volte per semplicità di scrittura, per evitare di scrivere più volte funzioni simili o più semplicemente perché si copiano parti di codice, vengono usate le funzioni. Le funzioni sono parti di codice con uno specifico nome nella quale inferire istruzioni da eseguire. Queste funzioni poi vengono richiamate nel “void loop”. La funzione viene così inizializzata:

type nome_funzione (parametri){
  "Istruzioni"
}

Il nome della funzione “nomefunzione” è arbitrario mentre i parametri tra parentesi tonde sono le variabili da inviare alla funzione. Ad esempio se la funzione deve eseguire la somma tra due numeri, i parametri saranno gli addendi divisi da una virgola (a,b) mentre nella funzione da eseguire vi sarà c=a+b;. Visto che in questo caso dalla funzione deve esserci in uscita il valore di c allora bisogna aggiungere “return c;”.

Le parentesi graffe {} si usano per racchiudere blocchi di funzioni .

Per ogni linea di codice bisogna usare alla fine il punto e virgola, ad esempio “int x = 0;”. In questo esempio si inizializza il valore della variabile x a 0 e con il punto e virgola fi chiude la linea di codice.

Per commentare il codice si usa /* Commento */ ovvero si inserisce il commento tra slash e asterisco. L’altra soluzione è usare due slash ovvero “//Commento”.

 




 
LE VARIABILI, I TIPI NUMERICI E LE COSTANTI

Le variabili sono modi per immagazzinare valori numerici da usare in linee successive del codice. Sono numeri che possono essere variati all’interno del codice. Una variabile deve essere inizializzata indicando che tipo numerico è nel “setup” mentre il valore può essere cambiato senza re-indicare il tipo numerico. Ad esempio per inizializzare una variabile e per cambiargli valore si usano le seguenti linee di codice:

int variabile = 0;
variabile_new = 10;

Per quanto riguarda l’inizializzazione e il tipo numerico da specificare, si può scegliere tra:

Per quanto riguarda gli array essi possono essere composti da diversi tipi numerici, ad esempio un vettore di interi, di byte o di long, ad esempio “int vettore [3] = {10, 20, 40}” dove viene inizializzato un vettore di 3 elementi con valori 10, 20 e 40.

È importante utilizzare correttamente i tipi numerici, ad esempio se devo contare fino a 20, non ha senso usare una variabile long, crea solo inutile occupazione di ram. Al contrario usare tipi numerici poco capienti può creare overflow.

Per quanto riguarda le costanti vi sono “LOW” e “HIGH” che rispettivamente sono 0 logico e 1 logico e “False” e “True” che hanno lo stesso valore logico rispettivamente.

 

COSTRUTTI DI CONTROLLO

I costrutti di controllo sono funzioni proprie del linguaggio C utilizzate per controllare condizioni logiche ed eseguire linee di codice, ad esempio un costrutto di controllo può controllare se una variabile i=10 e se è uguale a 10 ad esempio va ad accendere un LED.

Il primo dei costrutti che andremo a vedere è il costrutto “IF” che funziona nel seguente modo:

if ( condizione ){
  "istruzioni da eseguire"}
if (i==10){
  digitalWrite(LED, HIGH);
}

Serve quindi a controllare una condizione e ad eseguire una istruzione o una serie di istruzioni tra le parentesi graffe solo finché la condizione ritorna un valore booleano vero.

Il costrutto “IF…ELSE” è simile all’IF visto prima ma introduce il costrutto “ELSE” che permette di eseguire un altro gruppo di istruzioni (o una sola) se la condizione del primo “IF” non è vera. Il costrutto “IF…ELSE” e un suo esempio è così scritto:

if ( condizione ){
  "istruzioni da eseguire se condizione vera"
}
else {
  "istruzioni da eseguire se condizione falsa" 
}
//esempio
if (i==10){
  digitalWrite(LED, HIGH);
}
else{
  digitalWrite(LED, LOW);
}

Quindi il primo “IF” controlla se “i” è uguale a 10, se è uguale a 10 accende il LED , mentre se l’istruzione è falsa il LED viene spento. Viene eseguita quindi un istruzione o un’altra.

Una istruzione utile a ripetere un blocco di istruzioni è il “FOR”, che esegue le istruzioni un certo numero di volte che dipende da una condizione. Si avrà:

for( inizializzazione ; condizione; espressione ){
 "Istruzioni da eseguire"
}
//esempio
for ( int i = 0 ; i < 10 ; i++){
    digitalWrite(LED, HIGH);
    delay(1000);
    digitalWrite(LED, LOW);
    delay(1000);     
}

Illustrando l’esempio si ha tra le parentesi tonde l’inizializzazione della variabile “i” al valore 0, poi la condizione è che i sia minore di 10 e ad ogni iterazione si va ad incrementare il valore della variabile “i”. all’interno del FOR vi sono 4 istruzioni che accendono un LED, aspettano 1 secondo e poi spengono il LED aspettando un altro secondo. L’istruzione viene ripetuta 10 volte perché alla prima iterazione “i = 0” e alla fine di ogni iterazione viene incrementata.

Il ciclo “WHILE” e il ciclo “DO… WHILE” sono tra loro simili, cambia solo che il ciclo “WHILE” controlla la condizione e poi esegue le istruzioni di continuo finché la condizione è vera mentre il ciclo “DO… WHILE” esegue le istruzioni indipendentemente dalla condizione, poi la controlla e in caso la condizione sia vera riesegue le istruzioni. Questi due costrutti sono così usati:

while( condizione ){
  "Istruzioni da eseguire"
}
do{
  "Istruzioni da eseguire"
}
while( condizione )
//esempio uso "WHILE"
while( i == 10 ){
  digitalWrite(LED, HIGH);
}
//esempio uso "DO...WHILE"
do{
  digitalWrite(LED, HIGH);
}
while( i == 10 )

Nel primo caso accendo il LED se “i” è uguale a 10 e lo vado a riaccendere finché “i” è uguale a 10. Nel secondo esempio accendo il LED, quindi eseguo in ogni caso l’istruzione, e poi se “i” è uguale a 10 vado a rieseguire l’istruzione.

 

OPERATORI MATEMATICI, DI CONFRONTO E LOGICI

Gli operatori matematici includono sottrazione, somma, moltiplicazione e divisione. Il risultato dipende dal tipo logico, ovvero se sommo 200 + 100 e il risultato è inizializzato come byte avrò come risultato 45, questo perché 200+100=300 però il massimo valore è 255 quindi avrò un overflow e 45 come risultato. Stessa cosa succede se ho 20/3, il risultato è 6.66 però se ho un intero, un long o un byte il risultato sarà 6, la parte decimale. I vari operandi matematici sono:

risultato = valore1 + valore2;  //somma valore1 a valore2 e inserisce in risultato il valore
risultato = valore1 - valore2;  //sottrai valore1 a valore2 e inserisce in risultato il valore
risultato = valore1 * valore2;  //moltiplica valore1 per valore2 e inserisce in risultato il valore
risultato = valore1 / valore2;  //dividi valore1 per valore2 e inserisce in risultato il valore
risultato ++;                   //incrementa risultato
risultato --;                   //decrementa risultato
risultato += valore1;           //somma valore1 a risultato e inserisce in risultato il valore
risultato -= valore1;           //sottrai valore1 a risultato e inserisce in risultato il valore   
risultato *= valore1;           //moltiplica valore1 per risultato e inserisce in risultato il valore
risultato /= valore1;           //dividi valore1 per risultato e inserisce in risultato il valore

 

Gli operatori di confronto servono a confrontare due variabili, o una variabile e una costante e sono operatori che ritornano un valore booleano o vero o falso, che tradotto in livelli logici è 0 o 1. Alcuni li abbiamo visti prima e servono a confrontare se una variabile è maggiore, maggiore uguale, minore, minore uguale, non uguale o uguale ad una costante o variabile. Essi sono:

 x == y  //Ritorna True se x è uguale a y
 x != y  //Ritorna True se x è diverso da y
 x <  y  //Ritorna True se x è minore di y
 x >  y  //Ritorna True se x è maggiore di y
 x <= y  //Ritorna True se x è minore uguale a y
 x >= y  //Ritorna True se x è maggiore uguale a y
 if ( x >= y ) {
  "Istruzioni"
 }

Gli operatori di confronto vengono usati nei costrutti di controllo come si può vedere nell’ultima parte dell’esempio sovrastante.

Gli operatori logici sono solitamente operandi utili ad eseguire operazioni tra due espressioni booleane, ovvero due o più espressioni formate dagli operatori di confronto. Questi operatori logici ritornano TRUE o FALSE e sono tre come mostrati nel seguente esempio:

if( x > 0 && y > 10 ) {     //AND logico
  "Istruzioni"
}
if( x > 0 || y > 10 ) {     //OR logico
  "Istruzioni"
}
if( ! x > 0 ) {             //NOT logico
  "Istruzioni"
}

Nel primo caso l’operatore logico AND (&&) lega insieme le espressioni logiche “x > 0” e “Y > 10”. L’operatore logico AND ritorna TRUE solo se tutte le espressioni sono TRUE, altrimenti FALSE in tutti i casi. Nell’esempio si andranno ad eseguire le istruzioni all’interno dell’IF solo se “x” è maggiore di 0 e “y” è maggiore di 10.

Nel secondo caso l’operatore logico OR (||) lega insieme le due espressioni logiche tra parantesi. L’operatore logico OR ritorna TRUE se almeno una  delle espressioni è TRUE, altrimenti FALSE se tutte le espressioni sono FALSE. Nell’esempio si andranno ad eseguire le istruzioni all’interno dell’IF se “x” è maggiore di 0 oppure se “y” è maggiore di 10.

Il terzo e ultimo caso illustra l’uso dell’operatore logico NOT che inverte il valore dell’espressione. Se l’espressione “X > 0” ritorna TRUE, usando l’operatore NOT (!) si avrà come valore FALSE. Supponiamo che ”x” è minore di 0, grazie al NOT si andranno ad eseguire le istruzioni nel ciclo IF.
 


[Voti Totali: 1 Media Voti: 5]
GUIDA ARDUINO 4: STRUTTURE SOFTWARE ultima modifica: 2018-01-29T11:14:05+00:00 da ne555
Segui la Nostra Pagina Facebook: Facebook

Lascia un commento

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