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.
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)
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);
{
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;
}
}
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;
}
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);
valoresensore = analogRead(0);
+ - Addizione: aggiungi un valore ad una variabile.
Esempio: somma al valore di "Y"
il valore 3.
Y = Y + 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;
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.
+= - Addizione composta.
Esempio: incrementa di "y" il valore
"val" (val += y è come scrivere val = val+y)
val += y;
-= - Sottrazione composta.
*= - Moltiplicazione composta.
/= - Divisione composta.
-= - 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 );
}
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.
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 );
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 );
}
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 );
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);
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.
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);
Serial.Print(32, BIN);
Serial.Print(32, BYTE);
FINE
Queste sono i principali elementi sintattici di Arduino,
ma potreste avere bisogno di ulteriori funzioni.
