controllo di flusso

if

L'istruzione if è composta da un blocco "condizione" che verifica se una deterniata condizione logica si verifica. Se la "condizione" risulta "Vera", viene eseguita un blocco "istruzioni", se la "condizione" risulta "Falsa", non viene eseguito il blocco "istruzioni" e l'esecuzione del programma prosegue oltre l'istruzione if.

In altro modo, se la condizione di controllo, costituita ad esempio dal superamento di un valore analogico rispetto ad un valore dato, risulta vera, verrà eseguito il codice incluso tra le parentesi graffe che seguono il controllo, altrimenti se la condizione di controllo risulta falsa, non vengono eseguite le istruzioni dell'if e l'esecuzione del programma continua con la porzione di codice che segue.

if (someVariable ?? value)
{
   doSomething;
}

(con ?? indichiamo l'operatore logico usato dalla condizione di controllo e può essere: =, ==, !=)

L'esempio sopra confronta la variabile someVariable con il valore contenuto in value che può essere una variabile o una costante. Se il confronto o la condizione all'interno delle parentesi tonde risulta vera, verrà eseguita la porzione di codice inclusa tra le parentesi graffe, doSomething, altrimenti se la condizione risulta falsa viene saltata la porzione tra parentesi graffe e l'esecuzione prosegue dopo l'ultima parentesi graffa.

Nota: fate attenzione che se accidentalmente usate '=', ad esempio if(x=10), tecnicamente è un'operazione valida, l'operazione assegna alla variabile x il valore 10 che è un'operazione sempre vera, quindi lo sketch si comporterà diversamente da come avevamo progettato. Invece se usiamo "==" (doppio uguale) in if(x==10) viene verificato se la variabile x è uguale al numero 10.

Pensate a "=" come ad un'operazione di assegnamento e "==" come ad una operazione di confronto ("è uguale a").

if…else

Come rappresentato dal diagramma di flusso che segue, la struttura if…else è composta da tre sezioni, la prima è costituita da un blocco "condizione" che controlla il verificarsi di una determinata condizione logica, se la condizione risulta "Vera" viene eseguito il blocco "istruzioni" altrimenti, se "Falso" viene eseguito il blocco "altre istruzioni"

La condizione logica da verificare è inclusa tra parentesi tonde. Il ramo che viene eseguito nel caso di risultato "Vero" è racchiuso tra il primo gruppo di parentesi graffe, mentre il secondo gruppo di codice, incluso tra le parentesi graffe dopo l'istruzione "else", viene eseguito se "condizione" risulta "Falso":

if (inputPin == HIGH)
{
   doThingA;
}
else
{
   doThingB;
}

Nota: una istruzione if verifica semplicemente se la condizione all'interno delle parentesi tonde è vera o falsa. Nell'esempio, se if (inputPin == HIGH) risulta vera, cioè inputPin ha un valore HIGH (+5V) viene eseguita la porzione di codice doTingA, in caso contrario viene eseguita la porzione di codice che segue l'else: doThingB

L'else può anche precedere altre istruzioni if e test mutualmente esclusivi possono essere eseguiti nello stesso momento. Quindi potrete avere molte istruzioni if annidate.
Potete avere un numero illimitato di rami else. Ricordate che in funzione del valore logico del blocco di controllo, solo un insieme di istruzioni verrà eseguito.

if (inputPin < 500)
{
   doThingA;
}
else if (inputPin >= 1000)
{
   doThingB;
}
else
{
   doThingC;
}

for

L'istruzione for è usata per ripetere, per un determinato numero di volte, una serie di istruzioni, la ripetizione avviene se risulta vera una certa condizione logica, nel caso risulti falsa si esce dal ciclo.

Per poter eseguire l'iterazione è indispensabile inizializzare una variabile usata come contatore che verrà incrementata o decrementata dopo l'esecuzione delle istruzioni all'interno del for. Ad ogni ciclo viene controllato, all'interno del blocco "condizione", se la variabile contatore soddisfa una determinata condizione logica in modo che si possa proseguire attraverso il ramo "Vero" oppure il ramo "Falso".

L'istruzione for è usata per ripetere, per un determinato numero di volte, il blocco di istruzioni che segue il for, racchiuse tra parentesi graffe. Per ripetere e concludere il ripetersi dell'esecuzione delle istruzioni tra parentesi graffe, viene utilizzato una variabile usata come contatore che viene incrementata o decrementata.
La parte iniziale del for, detta anche header, è costituito da tre parti separate da un punto e virgola (;) e racchiuse tra parentesi tonde:

for (initialization;
     condition;
     expression)
{
   doSomething;
}

"initialization" è una variabile locale che viene incrementata o decrementata da una espressione "expression" ad ogni ciclo di del loop. Ad ogni ciclo la condizione "condition" viene verificata, se risulta VERA vengono eseguite le istruzioni incluse nelle parentesi graffe che seguono il for e successivamente viene nuovamente verificata "condition", quando "condition" risulta FALSA il loop termina

Nell'esempio che segue viene inizializzata una variabile intera i a 0, viene verificato se è minore di 20 e se la condizione risulta vera la variabile viene incrementata di 1 ed eseguito il blocco di istruzioni tra parentesi graffe:

for (int i=0; i < 20; i++)
// dichiara i, verifica se
// minore di 20, incrementa i di 1
{                         
  digitalWrite(13, HIGH);
  // pin 13 a on
  
  delay(250);
  // pausa per 1/4 di secondo
  
  digitalWrite(13, LOW);
  // pin 13 a off
  
  delay(250);
  // pausa per 1/4 di secondo
}

Nota: In C il ciclo for è molto flessibile rispetto ai cicli for di altri linguaggi di programmazione incluso il BASIC. Qualsiasi degli elementi presenti nell'intestazione (quelli inclusi tra parentesi tonde) possono essere omessi, anche tutti e tre, purchè siano presenti i punti e virgola di separazione anche se non sono presenti elementi. L'inizializzazione, la condizione e l'espressione possono essere sostituite da istruzioni valide in C con variabili indipendenti, cioè ogniuno degli elementi dell'intestazione del for può essere costituito da funzioni definite in altre sezioni del programma che accettano valori di input.
L'uso del for in questa modalità è inusuale ma può essere usato in casi particolari per risolvere problemi specifici.

while

Il ciclo while esegue il blocco "istruzioni" fini a quando risulta vera l'espressione logica presente in "condizione", quando l'esperessione risulta falsa si esce dal ciclo while.

Il ciclo while esegue all'infinito le istruzioni incluse tra parentesi graffe, fino a quando la condizione racchiusa tra le parentesi tonde non risulta vera.
Per far si che il while non cicli all'infinito la variabile di test (all'interno delle parentesi tonde) deve cambiare. Il cambiamento di stato della variabile di controllo potrebbe avvenire mediante una variabile che viene incremetata o decrementata all'interno delle parentesi graffe del while, oppure potrebbe essere il risultato di un cambiamento di stato di un sensore.

(con ?? indichiamo l'operatore logico usato dalla condizione di controllo e può essere: =, ==, !=)

while (someVariable ?? value)
{
   doSomething;
}

L'esempio che segue verifica se la variabile "someVariable" è minore di 200 e se vera esegue le istruzioni tra parentesi graffe. L'esecuzione delle istruzioni all'interno delle parentesi graffe verrà eseguite ciclicamente fino a quando "someVariable", ovvero fino a quando "someVariable" non diventa maggiore o ugale a 200.

while (someVariable < 200)
// verifica se minore di 200

{
   doSomething;
   // esegue le istruzioni
   
   someVariable++;
   // incrementa la variabile di 1
}

do...while

Il ciclo do si comporta in modo simile al ciclo while ma con la differenza che la "condizione" di test viene eseguita alla fine del ciclo, così facendo le istruzioni vengono eseguite almeno una volta prima di verificare la condizione:

La sintassi del do...while prevede che vi sia dopo l'istruzione do il blocco "istruzioni" incluso tra parentesi graffe e dopo l'istruzione while, a cui segue la condizione di controllo:

do
{
  doSomething;
} while (someVariable ?? value);

(con ?? indichiamo l'operatore logico usato dalla condizione di controllo e può essere: =, ==, !=)

Nell'esempio che segue viene assegnato il valore di "readSensor()" alla variabile "x", si ferma per 50 millisecondi, dopo di che il ciclo continua indefinitivamente fino a quando x è minore di 100:

do
{
  x=readSensor();
  // assegna il valore di
  // readSensor() a x
  
  delay(50);
  // pausa di 50 millisecondi

} while (x<100);
  // cicla fino a quando x < 100