La Lingua Di Arduino

Questo è il mio piccolo dizionario Arduino / Italiano - Italiano / Arduino.
La pagina contiene i principali elementi di codice divisi principalmente in tre gruppi: le variabili, le strutture e le funzioni di Arduino.



le VARIABILI DI ARDUINO:
i TIPI DI DATI

Sono dei contenitori di dati, il loro valore è modificabile durante l'esecuzione del programma




boolean - E' una variabile booleana, quindi il suo valore è vero o falso.

byte - Contiene un numero tra 0 e 255.

int - Contiene un numero intero compreso tra -32'768 e 32'767 (16 bit, 2 byte). Mettendo davanti ad int "const" diventa una costante, quindi dopo che è stata dichiarata non può più cambiare. (viene usata ad esempio per assegnare un nome ad un pin).

short - Come "int" ma anche per "Arduini" con architettura Arm (es. Arduino Due, int in queste schede è di 4 byte)

unsigned int - Come int ma solo numeri positivi, quindi tra 0 e 65'535.

word - Come "unsigned int" ma anche per "Arduini" con architettura Arm.

long - Contiene un numero tra -2'147'483'648 e 2'147'483'647 (32 bit, 4 byte.

unsigned long - Come long ma solo numeri positivi, quindi da 0 a 4'294'967'295.

float - Può memorizzare numeri con la virgola.

double -  Nelle schede con architettura Arm contiene un numero fino a 1'7976931348623157x10^308 (8 byte).

char - Contiene un singolo carattere di testo cioè il numero corrispondente nella tabella ASCII (1 byte).

string - Contiene più caratteri di testo. Es: char Str1[] = "esempio"; 




le COSTANTI

Le costanti sono le variabili preimpostate nel linguaggio di Arduino




INPUT e OUTPUT - sono usate per definire se uno specifico Pin deve essere di ingresso o di uscita. 

HIGH e LOW - sono usati per esempio quando si vuole accendere o spegnere un Pin di Arduino. 

true e false - indicano che la condizione può essere vera o falsa.



le STRUTTURE:
le STRUTTURE PRINCIPALI

La struttura base di un programma Arduino si sviluppa in almeno due parti





void setup ( ) 
{Qui mettiamo la parte dello sketch che deve essere eseguita una sola volta (ad esempio dichiarazioni di input e output).}

void loop ( ) 
{Qui mettiamo la parte dello sketch che deve essere eseguita fino allo spegnimento di Arduino. In pratica è dove si scrive il programma vero e proprio.}




le STRUTTURE DI CONTROLLO

Le strutture di controllo servono a far eseguire al nostro Arduino delle operazioni di logica





If - è il "se" di Arduino, tramite questa struttura è possibile prendere delle decisioni all’interno del programma.

Esempio: se a è maggiore di b accendi "led1". Se non é maggiore il "led1" rimarrà spento.

if (a > b) 
   digitalWrite(led1, HIGH); 


If...else - come if ma se la condizione messa tra parentesi è falsa verrà eseguito tutto il codice che segue else.

Esempio: se a è maggiore di b accendi "led1". Altrimenti accendi "led2".

if
 (a > b) 
   digitalWrite(led1, HIGH); 
else 
   digitalWrite(led2, HIGH); 
}


for - Ripete il codice per il numero di volte inserito.

Esempio: scrivi 3 volte “esempio” sul monitor seriale.

for (int i=0;i<3;i++) 
   Serial.print(“esempio”); 



switch case - Vengono eseguiti diversi blocchi di programma a seconda del valore della variabile posta tra parentesi.

Esempio: se il valore di "sensore1" è uguale a 600 accendi "led1", se è uguale a 700 accendi "led2".
Se il valore di "sensore1" è diverso sia da 600 che da 700, spegni "led1" e "led2".

switch (sensore1) 
   case 600:
      digitalWrite(led1, HIGH); 
      break
   case 700:
      digitalWrite(led2, HIGH);
      break;
   default:
      digitalWrite(led1, LOW);
      digitalWrite(led2, LOW); 
}


while - Esegue un blocco di codice infinite volte fino a quando la condizione posta tra le parentesi diventa vera.
(se lo è già all'inizio non viene eseguito)
Esempio: tieni acceso "led1" finchè "sensore1" diventa più piccolo di 600.

while (sensore1 < 600) 
   digitalWrite (led1, HIGH); 
}


do while -  Il ciclo "Do While" funziona nello stesso modo del ciclo While, con l'eccezione che viene provata la condizione solo al termine del ciclo, in questo modo il ciclo "Do While" verrà eseguito sempre almeno una volta.

Esempio: attendi finchè il valore di un sensore diventa stabile, aspetta 50 millisecondi infinite volte, finchè il valore del sensore diventa più basso di 100.

do
{
 
   delay(50);
 
   x = readSensors();
 
}
 
while
 (x < 100);


Break
 - Questa struttura serve a bloccare un ciclo "for", "while" o "do". Viene utilizzato anche per
separare le varie condizioni nella funzione "switch case".


Continue - Questo comando fa saltare il resto del codice all’interno del ciclo, e riavvia il ciclo. 

Esempio: Crea un salto tra l'incremento del valore di "x"

for (x = 0; x < 255; x ++)
   if ( ( x > 120 ) && ( x < 180 ) ) 
   { 
      continue
   }
   analogWrite ( PWMpin, x ); 
   delay (50); 
}


Return
 - Termina una funzione che si sta eseguendo e ne restituisce un risultato.



Esempio: se la lettura è maggiore di 400 restituisci 1, altrimenti 0

int checkSensor ( )
{
   if ( analogRead(0) > 400 )
 
   {
 
     
 return 1;
   } 
   else
   { 
       return
 0; 
   }
}


goto
 - Permette di saltare un pezzo di programma fino al "bailout". Questa struttura è generalmente sostituibile con altre già illustrate in precedenza.

Esempio: se il valore del sensore è minore di 250 esegui il resto del codice, altrimenti passa al bailout. 

if ( analogRead(0) > 250 )
{ 
   goto bailout;
// altro codice 
bailout;




gli OPERATORI ARITMETICI

Questi operatori vengono utilizzati per cambiare il valore contenuto in una variabile.




=  -  Assegnazione: assegna ad una variabile un valore.


Esempio: assegna alla variabile "valoresensore" il valore di tensione presente in ingresso al pin analogico 0

valoresensore = analogRead(0);


 -   Addizione: aggiungi un valore ad una variabile.
Esempio: somma al valore di "Y" il valore 3. 

Y = Y
 + 3;

-   -  Sottrazione: sottrai un valore ad una variabile.

*   -  Moltiplicazione: moltiplica una variabile per un valore.

/   -  Divisione: dividi una variabile per un valore.

%  -  Modulo: assegna alla variabile il valore del resto di una divisione.


Esempio: 7 diviso 5 uguale 1 con resto 2. La variabile x ora avrà valore 2.

X = 7 % 5;



gli OPERATORI COMPARATIVI 
e gli OPERATORI BOOLEANI

Questi operatori vengono usati all'interno degli "if" per testare i valori delle variabili.




==  -  Uguale a 

Esempio: se "variabile1" è uguale a 10, accendi "led1". 

if ( variabile1
 == 10)
{
   digitalWrite (led1, HIGH);
}


!=  -  Diverso da

<  -  Minore di

>  -  Maggiore di

<=  -  Minore o uguale a

>=  -  Maggiore o uguale a
Se si vogliono testare più condizioni nello stesso "if" si devono usare gli operatori booleani:

&&  - "and" testa se la condizione 1 e la condizione 2 sono vere

Esempio: se "valoresensore" è compreso tra 100 e 200, esegui il codice successivo.

if ( valoresensore >= 100)
 && (valoresensore <= 200)
{
   \\inserire il codice da eseguire
}


||  
- "or" testa se la condizione 1 o la condizione 2 sono vere

Esempio: se "valoresensore1" o "valoresensore2" sono maggiori di "100", 
esegui il codice successivo.

if ( valoresensore1 > 100) || (valoresensore2 > 100)
{
   \\inserire il codice da eseguire
}


!  - "not" testa se la condizione è falsa

Esempio: se "x" vale "falso" (quindi zero) esegui il codice successivo.

if ( !x) 
{
   \\inserire il codice da eseguire
}




gli OPERATORI COMPOSTI


Servono a eseguire operazioni come incrementare il valore di una variabile.




++  - Incremento.

Esempio: incrementa di uno il valore di "val" (val++ è come scrivere val = val+1)

val++;


--  -  Decremento.


+=  -  Addizione composta.

Esempio: incrementa di "y" il valore "val" (val += y è come scrivere val = val+y)

val += y;

-=  -  Sottrazione composta.


*=  -  Moltiplicazione composta.


/=  -  Divisione composta.




le FUNZIONI:
INPUT E OUTPUT

Sono le funzioni necessarie all'utilizzo dei pin I/O di Arduino.




pinMode ( )  -  Serve a definire se intendiamo utilizzare un pin come ingresso o come uscita.

Esempio: classico esempio di lampeggio di un led, in questo caso definisco il pin "ledPin" come uscita (OUTPUT) perchè devo collegarci un led che è un dispositivo di uscita.
Se avessi dovuto collegargli un pulsante avrei dovuto definirlo come ingresso (INPUT)

int ledPin = 13;

void setup()
{
pinMode ( ledPin,
 OUTPUT );
}

void loop()
{
digitalWrite ( ledPin, HIGH );
delay ( 1000 );
digitalWrite ( ledPin, LOW );
delay ( 1000 );
}


digitalWrite ( )  -  Permette di scrivere un valore su un pin digitale. Tipicamente viene usato per portare un pin di uscita a livello alto (5 Volt su Arduino Uno) o basso (0 Volt).
Può anche essere usato per forzare un pin di ingresso a livello alto o basso, tramite le resistenze di pull-up interne ad Arduino.

Esempio di utilizzo delle resistenze di Pull-up: clicca qui


digitalRead ( )  -  Consente di leggere il valore di un pin, essendo digitale il valore può assumere solo 2 valori: alto (HIGH) o basso (LOW)

Esempio: leggi lo stato di un pulsante, successivamente accendi un led se il pulsante è premuto, spegnilo se il pulsante è a riposo.

int ledPin = 13;
int pulsantePin = 3;
int val = 0;

void setup()
{
pinMode ( ledPin, OUTPUT );
pinMode ( pulsantePin, INPUT );
}

void loop()
{
val =
 digitalRead ( pulsantePin );
digitalWrite ( ledPin, val );
}


analogRead ( )  -  Legge la tensione applicata su un pin di ingresso analogico. 
Il valore di questa tensione può andare da 0 a 5V e viene acquisita da Arduino come un valore su una scala tra 0 e 1023.


analogWrite ( )  -  Manda in uscita una tensione 0 - 5 Volt modulata in PWM. Questa tensione viene vista da molti utilizzatori (ad esempio un led) come una tensione variabile.
Per ottenere ciò dobbiamo scrivere nel campo del valore un numero tra 0 e 255, dove 0 è il led spento e 255 è il led accesso alla massima luminosità.

Esempio: leggendo il valore analogico di un potenziometro collegato al pin 3 si otterrà un valore con un range da 0 a 1023.
Dividiamo questo numero per 4 (quindi circa 255) e portiamolo in uscita ad un led collegato su un pin pwm (ad esempio il 9).
Otterremo una regolazione della luminosità del led girando il potenziometro.


int ledPin = 9;
int potenziometroPin = 3;
int val = 0;

void setup()
{
   pinMode ( ledPin, OUTPUT );
}

void loop()
{
   val =
 analogRead ( potenziometroPin );
   analogWrite ( ledPin, val / 4 );
}




le FUNZIONI TEMPORALI

Queste funzioni sono quelle che ci permettono di mettere in pausa il programma o di conoscerne il tempo trascorso dal suo avvio




millis ( ) - Restituisce il numero in millisecondi trascorsi da quando il programma è partito. 

Esempio: stampa sul monitor seriale il tempo trascorso dall'avvio del programma

unsigned long tempo; 

void setup()
   Serial.begin(9600); 
void loop()
   Serial.print("Time: "); 
   tempo = millis()
   Serial.println(time);
   delay(1000); 
}


micros ( ) - Stessa cosa di millis ma in microsecondi.


delay ( ) - Mette in pausa il programma per il valore (in millisecondi) che inseriamo tra parentesi.

Esempio: anche qui metto l'esempio di un lampeggio di un led.
Il led viene acceso, passano 1000 millisecondi (1 secondo) poi si spegne, 
passano altri 1000 millisecondi e il loop riparte.

int ledPin = 13;

void setup()
{
   pinMode(ledPin, OUTPUT); // sets the digital pin as output
}

void loop()
{
   digitalWrite(ledPin, HIGH);
   delay(1000);
   digitalWrite(ledPin, LOW);
   delay(1000);
}


delayMicroseconds ( ) - Stessa cosa di delay ma in microsecondi.



le FUNZIONI MATEMATICHE

Chi ha detto che la matematica non serve a niente?




min ( x, y )  -   Calcola il valore più piccolo fra x e y. 

Esempio: assegna alla variabile "Val" il valore più piccolo tra 3 e 10

Val =
 min ( 3, 10 ); 


max ( x, y )  -  Calcola il valore più grande fra x e y.


abs ( x )  -  Calcola il valore assoluto di x.


constrain ( x, a, b )  -  Restituisce il valore "x" solo se è compreso tra i valori "a" e "b".
Se "x" è più piccolo di "a" restituisce "a" se invece è più grande di "b" restituisce "b".

Esempio: limita il valore di un sensore "sensVal" tra 10 e 150, se "sensVal" è compreso tra i due valori allora lascia "sensVal" invariato.

sensVal = constrain ( sensVal, 10, 150 );


map ( value, fromLow, fromHigh, toLow, toHigh )  -  Cambia il range di un valore.

Esempio: converti un valore con range 0 - 1000 in un valore con range 0 - 200.
Se "variabile" vale 10, "valore" sarà 2.

valore =
 map ( variabile, 0, 1000, 0, 200);


pow ( base, exponent )  -  Indicando la base e l’esponente, esegue l'elevazione a potenza di un numero. Funziona anche con una frazione come esponente.

sqrt ( x )  -  Calcola la radice quadrata del numero x.



le FUNZIONI TRIGONOMETRICHE

La trigonometria nel codice di Arduino




sin ( rad )  -  Calcola il seno di un angolo (in radianti).


cos ( rad )  -  Calcola il coseno di un angolo (in radianti).


tan ( rad )  -  Calcola il valore della tangente di un angolo (in radianti).




i NUMERI CASUALI

Ottenere numeri "random" da Arduino




randomSeed (seed)  -  La sequenza di numeri casuali di arduino è una catena di numeri, molto lunga ma limitata. 
Infatti pur essendo i numeri non collegati tra di loro ha la limitazione che l'ordine di questi numeri casuali è sempre lo stesso. 
Il comando randomSeed avvia la sequenza in un punto ben preciso, infatti al posto di "seed" va inserito un numero.
Se si vuole partire da un punto casuale basta inserire la lettura di un pin analogico non collegato a nulla, l'instabilità su quel pin genererà ad ogni loop un valore di lettura diverso.


random ( min, max )  -  Questa funzione restituisce un numero intero, di valore compreso fra min e max-1. Se min non è specificato il valore minimo restituito sarà 0. 

Esempio: stampa su monitor seriale un numero casuale, compreso tra 0 e 299.

long randNumber; 
void setup()
   Serial.begin (9600); 
   randomSeed ( analogRead (0) ); 

void loop()
   randNumber = random (300); 
   Serial.println (randNumber); 
   delay(50); 
}




la COMUNICAZIONE SERIALE

Inviare e ricevere dati tra Arduino e il PC




Serial.begin ( speed )  -  Serve ad impostare la velocità della comunicazione seriale tra arduino e pc.
Generalmente si usa 9600 bps ma si possono impostare anche altre velocità, fino a 115.200 bps.

Esempio: inizializza la porta seriale a 9600 bps

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

void loop() {}



Serial.print ( val, format )  -  Invia un valore al pc tramite la comunicazione seriale. Il formato indica il sistema numerico utilizzato.

Esempio: Stampa sul serial monitor 32.
stampa 32 in decimale (32)
stampa 32 in esadecimale (20)
stampa 32 in ottale (40)
stampa 32 in binario (100000)
stampa il valore associato al numero 32 nella tabella ASCII ( carattere spazio)

Serial.print(32);
 
Serial.Print(32, DEC); 
Serial.Print(32, HEX);
Serial.Print(32, OCT);
Serial.Print(32, BIN);
Serial.Print(32, BYTE);

 FINE


Queste sono i principali elementi sintattici di Arduino, ma potreste avere bisogno di ulteriori funzioni.
Per tutto ciò vi rimando alla pagina Reference (in inglese) del forum ufficiale di Arduino.



Segui Daniele Alberti su Google+
Related Posts Plugin for WordPress, Blogger...