Programmare Arduino
| Sito: | Materiali Didattici |
| Corso: | (Classe 2a) - Scienze e Tecnologie Applicate |
| Libro: | Programmare Arduino |
| Stampato da: | Utente ospite |
| Data: | domenica, 5 maggio 2024, 18:44 |
Sommario
- 1. Introduzione
- 2. L'IDE di Arduino
- 3. Ortografia, grammatica e sintassi
- 4. Le parole chiave
- 5. Le istruzioni
- 6. Le variabili
- 7. Le istruzioni di struttura
- 8. Le istruzioni di controllo
- 9. Operatori matematici
- 10. Operatori di comparazione o di condizione
- 11. Operatori booleani
- 12. Operatori computazionali
- 13. Librerie e funzioni
- 14. Funzioni di INPUT e di OUTPUT
- 15. Funzioni di comunicazione seriale
- 16. Funzioni di tempo
- 17. Funzioni matematiche
- 18. Funzioni di generazione di numeri a caso (random)
- 19. Arduino Reference
1. Introduzione
La programmazione è formalmente ispirata al linguaggio C da cui deriva.
I programmi in ARDUINO sono chiamati “Sketch”.
Un programma è una serie di istruzioni che vengono lette dall’alto verso il basso e convertite in eseguibile e poi trasferite sulla scheda Arduino.
Linguaggio C: Struttura di un programma
main {
// istruzioni di programma da eseguire
}
Linguaggio Arduino: Struttura di un programma
void setup()
// istruzioni da eseguire una sola volta
void loop()
// istruzioni da eseguire ciclicamente
}
Linguaggio C: Compilazione ed esecuzione
Per eseguire un programma in linguaggio C è necessario compilarlo.
Il processo di compilazione trasforma le istruzioni scritte in linguaggio naturale in una serie di istruzioni macchina eseguibili dal calcolatore.
Questa operazione converte il “codice sorgente” in “codice oggetto” eseguibile dalla macchina (codice macchina)
Per ARDUINO avviene la stessa cosa ma la fase di compilazione si traduce e completa essenzialmente nella fase di caricamento del codice sulla scheda stessa.
Nella sezione “aiuto” è anche presente un’esaustiva spiegazione (in inglese) di ogni singolo elemento di programmazione (variabili, funzioni, istruzioni e relativa sintassi).
2. L'IDE di Arduino
Come facciamo a scrivere i nostri programmi per far funzionare Arduino? e come facciamo poi ad inserirli nella nostra scheda per farli eseguire?
Per eseguire queste funzioni gli ideatori di Arduino hanno realizzato un ambiente di sviluppo che semplifica molto queste operazioni. Questo ambiente di sviluppo può funzionare su tutti i moderni sistemi operativi: windows, linux e mac.
Il file da scaricare è un’archivio zip e una volta scaricato dobbiamo scompattarlo, fatto questo non abbiamo nemmeno bisogno di installarlo per poterlo eseguire.
Adesso che abbiamo il nostro ambiente di sviluppo pronto possiamo lanciarlo per cominciare a conoscerlo.
Nell’immagine sopra possiamo vedere come nell’IDE di Arduino possiamo distinguere tre zone principali: la più evidente, al centro, di colore bianco è l’area che contiene il nostro codice ed anche quindi dove andremo a scriverlo essendo un vero e proprio editor di testo un po’ come quelli a cui siamo abituati (in questo caso preciso editor di codice).
Sopra abbiamo una barra di pulsanti, la barra dei pulsanti per le operazioni principali, che ci permette di effettuare le operazioni necessarie per eseguire il nostro codice nella scheda Arduino.
Infine sotto l’area del codice infine abbiamo una zona dove il software ci potrà comunicare eventuali errori nel nostro codice o altri messaggi necessari.
Se andiamo a guardare più in dettaglio la barra dei pulsanti principale possiamo distinguere le cinque funzioni che essa ci permette:
- Verifica lo Sketch con questo pulsante possiamo avviare un controllo completo del nostro sketch (programma per Arduino) per vedere se ci sono errori da correggere prima di compilarlo per essere inviato alla scheda
- Compila e carica lo Sketch questo pulsante serve per compilare (tradurre lo sketch in un codice comprensibile ad Arduino) e caricare sulla scheda il nostro programma per poterlo poi eseguire (naturalmente il nostro Arduino Uno deve essere collegato al pc :D)
- Nuovo Sketch serve per creare un nuovo sketch da zero
- Apri Sketch Apre un programma che avevamo precedentemente salvato sul disco
- Salva Sketch Salva il nostro programma sul disco per futuri riutilizzi
Infine nella parte bassa dell’IDE vediamo la “consolle degli errori” ovvero quella parte dove potremo controllare tutti gli errori che vengono rilevati prima della compilazione.
Vicino la consolle degli errori possiamo trovare altre piccole ma col tempo preziose informazioni ad esempio il modello di scheda Arduino che abbiamo collegato al pc, il nome che il sistema operativo da alla porta USB dove abbiamo collegato Arduino ed il numero di riga corrente del cursore nell’editor del codice.
Per compilare, caricare e lanciare un programma si deve:⦁ Collegare Arduino al pc mediante un cavo usb. Appena inserito il cavo alcune spie di Arduino si illumineranno, a conferma dell’avvenuto collegamento.
⦁ Copiare (o digitare) il programma nella zona di editing dell’IDE, parzialmente gia’ occupata da alcune istruzioni predefinite (che dovranno essere cancellate e sostituite dal programma copiato).
⦁ Premere il pulsante di compilazione (la freccia rivolta a destra, piazzata nella riga dei comandi, in alto a sinistra)
⦁ Attendere il completamento della compilazione, rilevabile dalle scritte bianche che compaiono nella parte bassa dell’IDE e dal pulsare, per pochi attimi, dei led di Arduino.
Il programma, una volta compilato viene automaticamente caricato sulla scheda ed a questo punto Arduino inizia immediatamente a lavorare e a compiere le azioni per le quali e’ stato programmato.
Se durante la compilazione appaiono delle segnalazioni di colore rosso/arancione nella zona bassa dell’IDE, significa che qualcosa non è andata bene per cui bisogna interpretare le segnalazioni e provvedere alle necessarie azioni correttive.
Qualche volta, soprattutto al primo utilizzo della scheda, viene proposta una segnalazione di errore poichè la porta usb alla quale è collegato Arduino non è stata correttamente indirizzata dal pc.
Per rimediare è normalmente sufficiente sconnettere e riconnettere il cavo USB e poi rilanciare la compilazione.
Un programma altro non è che un elenco di istruzioni elementari, che il computer esegue, uno dopo l’altra, in maniera acritica. Nello scrivere un programma si devono rispettare alcune regole ortografiche, grammaticali e sintattiche e si devono mettere in fila le istruzioni in maniera che il computer arrivi, passo dopo passo, esattamente al risultato voluto.
Questo significa che prima di scrivere un programma è indispensabile non solo avere un’idea ben chiara di quale sia l’obiettivo, ma anche di quale sia il percorso per raggiungerlo. Si deve quindi “progettare” un programma, magari dividendolo in parti come ad esempio:
⦁ Acquisizione dati dai sensori: quali sensori analizzare, in quale sequenza e con quali modalità
⦁ Decisioni da prendere, sulla base dei dati provenienti dai sensori
⦁ Attivazione o disattivazione degli attuatori: quali attuatori attivare/disattivare ed in quale sequenza
/* -----( note esplicative sulle finalita’ e sul funzionamento del programma ) -----*/
/*-----( dichiarazione delle eventuali librerie utilizzate dal programma )-----*/
/*-----( dichiarazione degli oggetti utilizzati, ad esempio display a cristalli liquidi o servomotori )---*/
/*-----( dichiarazione delle costanti )-----*/
/*-----( dichiarazione delle variabili )-----*/
/*-----( codifica di eventuali routine )-----*/
void setup() /* seconda parte o parte di setup, eseguita solo all’avvio del programma*/
{ /* ----( inizio del setup )------*/
/* ----( dichiarazione delle porte di input e di output )----*/
/* ----( eventuali istruzioni da eseguire all’avvio del programma )----*/
}/* ----( fine del setup )---*/
void loop() /*terza parte o parte di loop, parte principale del programma, che viene eseguita e ripetuta fino al termine dell’alimentazione o fino alla pressione del pulsante reset*/
{ /* ----( inizio del loop )----*/
/* ----( istruzioni di programma )-----*/
} / *----( fine del loop )----*/
3. Ortografia, grammatica e sintassi
⦁ Ogni istruzione termina con un “;”
⦁ Le parentesi tonde e quadre delimitano gli operatori di un’istruzione mentre le parentesi graffe delimitano una serie di istruzioni riferibili ad una condizione, a una routine o a una parte di programma. Se da un’istruzione dipende l’esecuzione di altre istruzioni, le istruzioni “subordinate” sono di norma racchiuse tra parentesi graffe;
⦁ Ad ogni parentesi aperta deve corrispondere una parentesi chiusa. L’assenza di una parentesi di chiusura o di apertura qualche volta impedisce la compilazione (e quindi l’esecuzione) del programma ed in ogni caso ne rende imprevedibile i funzionamento;
⦁ La combinazione di caratteri /* indica l’inizio di una zona di note, che puo’ estendersi su piu’ righe e che deve necessariamente essere chiusa dalla combinazione */
⦁ La combinazione // indica l’inizio di una zona di note che si protrae fino alla fine della riga;
⦁ Le indentazioni, non obbligatorie, sono comunque utili per rendere piu’ facilmente comprensibile un programma. Nella sezione “strumenti” dell’IDE esiste la funzione “formattazione automatica”, utile appunto per ottenere l’indentazione automatica del codice;
⦁ Le variabili e le costanti devono essere dichiarate prima (in termini di posizione fisica nel programma) del loro utilizzo. Per questo motivo e’ buona norma concentrare la loro definizione in testa al programma, prima del setup e delle eventuali routine.
4. Le parole chiave
⦁ HIGH e LOW sono parole chiave utilizzate nella gestione delle porte di Arduino e nella gestione “digitale” di una varibile. LOW implica che alla variabile (o alla porta) sia associato il valore 0 mentre HIGH implica che sia associato il valore 1.
⦁ INPUT e OUTPUT sono parole chiave utilizzate per definire se una specifica porta deve essere considerata di entrata (una porta alla quale e’ collegato un sensore) o di uscita (una porta alla quale e’ collegato un attuatore).
⦁ true e false sono parole chiave utilizzate per verificare l’esito di una condizione.
5. Le istruzioni
Nella scrittura di un programma sono normalmente utilizzate:
⦁ variabili e cioe’ zone di memoria in cui sono depositati i dati
⦁ istruzioni e cioe’ i comandi, a loro volta classificabili in
⦁ istruzioni di struttura e controllo
⦁ operatori matematici, booleani e computazionali
⦁ funzioni, a loro volta classificabili in:
⦁ funzioni di input/output
⦁ funzioni di comunicazione
⦁ funzioni di tempo
⦁ funzioni matematiche
⦁ funzioni di generazione di numeri a caso
6. Le variabili
Sono aree di memoria ove vengono memorizzati i dati necessari al funzionamento del programma. Il programmatore assegna ad ogni variabile un nome ed un codice, che ne definisce la tipologia.
Come già detto, in un programma le variabili devono essere definite prima delle istruzioni che le utilizzano ed e’ pertanto opportuno definirle tutte nella zona iniziale, prima del void setup () e prima delle routine.
Le piu’ comuni tipologie di variabili sono:
byte occupa un byte di memoria e puo’ contenere un numero tra 0 e 255 non segnato.
int usa 2 byte di memoria e puo’ contenere un numero compreso tra -32768 e 32767. unsigned int Ha la stessa funzione di int, ma puo’ contenere solo numeri positivi tra 0 e 65535. long usa 4 byte e puo’ contenere un numero compreso tra -2.147.483.648 a 2.147.483.647.
unsigned long Versione senza segno di long e puo’ contenere un numero che va da 0 a 4.294.967.295.
float Può memorizzare numeri con la virgola. Utilizza 4 bytes.
double può contenere numeri a doppia precisione in virgola mobile, con valore massimo di 17976931348623157x10^308.
char occupa un byte di memoria. Se la si usa come un numero puo’ contenere un valore che va da -128 a +127 se invece la si usa come testo puo’ contenere un qualunque carattere ASCII. Se si aggiungono due parentesi quadre char[] diventa una variabile di tipo string nella quale e’ possibile memorizzare un testo. Utilizza un byte per ogni carattere di testo più un carattere NULL che indica la fine del testo.
array Non si tratta di un tipologia di variabile, ma del nome utilizzato per indicare una tabella, e cioe’ un elenco di variabili accessibili tramite un indice.
Un array e’ una variabile di tipo int o char seguita da una parentesi quadra aperta, un valore numerico (il numero di elementi) ed una parentesi quadra chiusa. Si utilizza la parola chiave int quando si vuole definire una tabella che conterrà dei numeri interi di valore compreso tra -32768 e 32767, mentre si utilizza la parola chiave char se si vuole definire una tabella che conterrà dei caratteri. E’ anche possibile definire preventivamente i valori di ogni elemento della tabella, facendo seguire alle parole chiave int o char le parentesi quadre con il numero di elementi, il segno di uguale ed i valori, separati da una virgola e racchiusi tra parentesi graffe.
7. Le istruzioni di struttura
setup () che associata alla definizione void indica l’inizio della zona di inizializzazione del programma
loop () che associata alla definizione void indica l’inizio della zona dedicata al corpo del programma
Tra le istruzioni di struttura dovrebbe anche essere annoverata la definizione void che, pur essendo classificata come una tipologia di dati, contrassegna di fatto l’inizio di una routine.
In quest’ultimo caso la sua struttura e’:
void nome_della_routine (void)
{….. istruzioni della routine ….. ; /* la routine viene eseguita solo nel momento in cui il percorso seguito dal programma incontra l’istruzione di lancio della routine (e cioe’ nome_della_routine (); ). A questo punto il programma esegue le istruzioni della routine e, al termine, ritorna al normale iter eseguendo le istruzioni immediatamente successive all’istruzione di lancio della routine */
}
Per chiamare (o meglio lanciare) una routine e’ sufficiente scriverne il nome seguito da una parentesi aperta ed una chiusa.
nome_della_routine ();
Nota: al momento del lancio, all’interno delle parentesi può essere inserito il nome di una variabile che la routine utilizza o modifica. Quest’opzione non sembra particolarmente utile in un programma che non nasce dall’assemblaggio di routine e funzioni estratte da altri programmi e pertanto viene di fatto ignorata in queste note.
8. Le istruzioni di controllo
Sono istruzioni che, al verificarsi di una condizione, lanciano l’esecuzione di specifiche parti di programma.
if.. else…
Permette di prendere delle decisioni. L’istruzione if deve essere seguita da una condizione racchiusa parentesi e da una o piu’ istruzioni racchiuse tra parentesi graffe. Se la condizione è vera verranno eseguite le istruzioni contenute tra parentesi graffe mentre se la condizione e’ falsa verranno eseguite le istruzioni (sempre tra parentesi graffe) contenute immediatamente dopo la parola chiave else. In entrambi i casi verranno poi eseguite le istruzioni successive alla fine delle istruzioni dipendenti dalla else. E’ possibile usare l’istruzione if anche senza la parola chiave else. In quest’ultimo caso se la condizione e’ vera verranno eseguite le istruzioni racchiuse tra le parentesi graffe che seguono la if, se invece e’ falsa e si passera’ direttamente alle istruzioni successive alla parentesi graffa di chiusura.
Struttura:
If (..condizione..)
{ ..codice da eseguire solo se la condizione e’ vera..; }
else
{ ..codice da eseguire solo se la condizione e’ falsa..; }
…. codice che verra’ eseguito in ogni caso….
L’istruzione if puo’ essere utilizzata anche senza le parentesi graffe; in questo caso, se la condizione e’ vera, viene eseguita l’istruzione immediatamente successiva alla condizione mentre se e’ falsa viene saltata la prima l’istruzione successiva ed eseguita la seconda successiva.
============================================
for…
l’istruzione for ripete una serie di istruzioni fino a quando una condizione risulta vera. Struttura:
for (..inizializzazione di una variabile..; ..condizione..; ..modifica della variabile.. )
{ .. codice da eseguire e ripetere fino a quando la condizione e’ vera.. }
===================================
switch… case… break… default
E’ un’istruzione composta da piu’ istruzioni elementari. E’ utilizzata per eseguire parti di programma a seconda del valore contenuto in una variabile il cui nome e’ indicato, tra parentesi, subito dopo la parola switch.
Struttura:
switch ( ..nome di una variabile.. )
{ case XX: …codice.. ; break; case YY: ..codice.. ; break; default: ..codice.. }
=====================================================
while…
Esegue una serie di istruzioni racchiuse tra parentesi graffe e le ripete fino a quando una condizione è vera.
Struttura:
While ( ..condizione.. )
{ .. codice da ripetere sino a quando la condizione risulta vera.. }
================================================
do…while
E’ un’istruzione identica alla istruzione while, solo che il codice viene eseguito anche prima che la condizione sia verificata. Si usa quando si vuole eseguire il codice almeno una volta prima che la condizione sia valutata.
Struttura:
do
{ ..codice da ripetere fino a quando la condizione di while risulta vera.. } while ( ..condizione.. );
==================================================
Break
Questa istruzione consente di bloccare un ciclo di for.., do.. oppure while… e continuare ad eseguire il codice fuori dal ciclo. Viene anche utilizzato nell’istruzione switch per interrompere l’analisi delle condizioni.
Continue
Usato in un ciclo do.., for.. o while… consente di interrompere l’esecuzione del codice interno al ciclo e tornare alla verifica della condizione.
9. Operatori matematici
Nella scrittura di un programma possono essere utilizzati i normali operatori matematici:
+ per le addizioni
- per le sottrazioni
/ per le divisioni
* per le moltiplicazioni
= per l’assegnazione del risultato
C’è anche uno strano operatore, il “%“che anziche’ calcolare una percentuale (come ci si potrebbe aspettare), restituisce il resto di una divisione.
10. Operatori di comparazione o di condizione
== uguale a (il doppio segno di uguale e’ indispensabile per differenziare una condizione da un’assegnazione)
> maggiore di
< minore di
!= diverso da
<= minore o uguale di
>= maggiore o uguale di
11. Operatori booleani
Esistono tre tipi di operatori booleani:
&& corrisponde alla “and”,
|| corrisponde alla “or”,
! corrisponde al “not”.
12. Operatori computazionali
sono operatori utilizzati per semplificare alcune operazioni elementari, come ad esempio incrementare o decrementare una variabile.
++ somma 1 alla variabile che precede l’operatore
-- sottrae 1 alla variabile che precede l’operatore
Esempio:
val++ corrisponde all’operazione val = val + 1 (incrementa di 1 il valore di val)
val-- corrisponde all’operazione val = val – 1 (decrementa di 1 il valore di val)
Qualora si voglia utilizzare un valore diverso da 1 si dovranno utilizzare i seguenti operatori computazionali
+=, -=, *=, /=
13. Librerie e funzioni
Oltre a quelle standard, previste dal manuale di programmazione di Arduino, esistono una miriade di altre funzioni gestite da librerie, spesso scritte da utenti, che possono essere utilizzate per svolgere particolari attivita’, soprattutto in presenza di sensori o attuatori di utilizzo complesso (come ad esempio un motore passo passo o un display lcd).
Per utilizzare una libreria e le funzioni da essa gestite bisogna dichiararla (includerla) nella parte iniziale del programma (prima del setup e prima delle routine).
Per includere una libreria in un programma bisogna innanzi tutto inserirla (se non gia’ presente) nell’archivio delle librerie di arduino e poi richiamarla nel programma attraverso la definizione
#include <nome_della_libreria.h>
da posizionare, come gia’ detto, in testa al programma.
Per inserire una nuova libreria nell’archivio delle librerie bisogna andare nell’IDE, seguire il percorso Sketch->importa libreria->add library, selezionare la cartella od il file compresso (zippato) che contiene la libreria e quindi premere il pulsante “apri”.
Una volta caricata una nuova libreria in archivio e’ opportuno chiudere e riaprire l’IDE per essere certi che la libreria e le sue nuove funzioni siano “visibili” al programma.
Come gia’ detto esistono molte librerie, specifiche per quasi ogni tipo di device (per ogni tipo di sensore o di attuatore). Dette librerie sono normalmente reperibili on line, e sono rintracciabili semplicemente ricercando informazioni (datasheet o anche esempi e note di utilizzo) sul device che si intende utilizzare.
14. Funzioni di INPUT e di OUTPUT
Il linguaggio di programmazione comprende le funzioni per la gestione delle porte di Arduino. Attraverso queste funzioni e’ possibile indicare il senso di utilizzo di una porta (INPUT oppure OUTPUT), attivare o disattivare una porta digitale, rilevare il segnale fornito da una porta analogica o attivare una porta digitale in modalita’ PWM, una modalita’ che simula l’emissione di un segnale analogico.
pinMode(porta,utilizzo);
questa istruzione e’ utilizzata per configurare una delle 14 porte digitali; nella variabile porta deve essere inserito il numero della porta digitale (da 0 a 13) che si intende definire mentre in utilizzo deve essere indicato il tipo di utilizzo (INPUT oppure OUTPUT).
digitalWrite(porta,valore);
attiva (HIGH) o disattiva (LOW) una porta digitale di OUTPUT. L’attivazione implica che la porta in oggetto venga alimentata con una tensione di 5 volt mentre la disattivazione implica che attraverso la porta non circoli alcuna tensione (in pratica attiva o disattiva l’attuatore collegato alla porta)
variabile = digitalRead(numero della porta);
rileva lo stato di una porta digitale di INPUT. Inserisce il valore 1 (HIGH) in variabile se sulla porta rileva una tensione superiore a 3 volt, inserisce 0 (LOW) se rileva una tensione inferiore a 1,5 volt e lascia inalterato il valore di variabile se rileva una tensione compresa tra 1,5 e 3 volt.
variabile = analogRead(porta);
rileva la tensione presente su di una porta analogica e inserisce in variabile un numero, compreso tra 0 e 1023, proporzionale alla tensione rilevata. 0 corrisponde ad una tensione pari a 0 mentre 1023 corrisponde ad una tensione pari a 5 volt.
analogWrite(porta,valore);
Con questa istruzione e’ possibile utilizzare una porta digitale in maniera PWM e cioe’ come una porta analogica di OUTPUT. L’istruzione e’ in grado di fornire in uscita sulla porta in questione una tensione (tra 0 e 5 volt) proporzionale al numero (compreso tra 0 e 255) inserito nella variabile valore.
Nota: su Arduino Uno le porte digitali utilizzabili come porte analogiche di OUTPUT sono solo le porte: 11, 10, 9, 6, 5, e 3.
15. Funzioni di comunicazione seriale
Esistono numerose funzioni seriali (l’elenco completo e’ presente nella guida reperibile nel menu’ aiuto dell’IDE) e tra queste le piu’ diffuse sono:
Serial.begin(velocita); // istruzione da utilizzare in fase di setup, prepara Arduino a mandare
// e a ricevere dati tramite la porta seriale. In “velocita” si inserisce
// normalmente il valore 9600 (9600 bit per secondo) ma e’ possibile
// utilizzare anche altri valori, fino ad un massimo di 115200
Serial.print(valore); // Invia al monitor seriale il contenuto della variabile valore e
// mantiene il cursore del monitor sulla linea corrente, in attesa
// di un nuovo valore.
Serial.println(valore); // invia al monitor seriale il contenuto della variabile valore seguito
// dal segnale di ritorno a capo, in modo da esporre i successivi
// messaggi su di una nuova riga
val = Serial.available(); // inserisce in val (una variabile intera) la lunghezza della parola digitata
// sulla tastiera collegata serialmente ad Arduino (normalmente la tastiera
// del monitor seriale e cioe’ la tastiera del pc collegato con il cavo usb)
val = Serial.read(); // legge (inserisce in val, una variabile normalmente di tipo chr) cio' che
// e' stato battuto sulla tastiera collegata serialmente ad arduino
Come abbiamo visto dalle istruzioni sopra riportate, la porta seriale opera sia in entrata che in uscita e quindi attraverso questa porta e’ possibile non solo esportare dati e messaggi ma anche ricevere dati utilizzabili dal programma operante su Arduino.
16. Funzioni di tempo
Wiring include alcune funzioni di gestione del tempo.
millis();
Fornisce i millisecondi trascorsi dall’inizio del programma. Esempio:
tempo=millis(); // inserisce nella variabile tempo i millisecondi trascorsi dal momento
// dell’accensione della scheda
delay(pausa);
Mette in pausa il programma per un numero di millisecondi specificato in pausa.
17. Funzioni matematiche
il linguaggio include funzioni matematiche alcune delle quali sono qui’ rappresentate. L’elenco completo delle istruzioni e delle funzioni e’ reperibile nella sezione “aiuto” dell’ambiente di sviluppo.
gamma = min (alfa,beta);
inserisce in gamma il valore minore tra i due valori contenuti nelle variabili alfa e beta
Esempio:
val=min(50,30); // in val sara’ presente il valore 30
Analogo ragionamento vale per le seguenti funzioni
val = max(x,y); // inserisce in val il valore maggiore tra i valori contenuti in x e y.
val = abs(x); // inserisce in val il valore assoluto di x (toglie il segno a x)
val = constrain(x,a,b); // x e’ un valore variabile; a e’ il minimo valore accettabile e b e’ il
// massimo valore accettabile.
// inserisce in val il valore x se x e’ compreso tra a e b;
// inserisce in val il valore a se x è minore di a;
// inserisce in val il valore b se x è maggiore di b.
val = pow(base,esponente); // calcola una potenza e cioe’ inserisce in val la base elevata
// all’esponente. Attenzione: val deve essere una variabile di tipo double
val = sqrt(x); // calcola la radice quadrata di x. Attenzione, val deve essere una
// variabile di tipo double.
val =map( x, daMinimo, daMassimo, aMinimo, aMassimo); // inserisce in val un valore
// compreso tra aMinimo e aMassimo, calcolato mantenendo la
// proporzione esistente tra il valore x e daMinimo e daMassimo.
// In pratica riparametra il valore x (compreso tra daMinimo e
// daMassimo) su di una scala diversa e compresa tra aMinimo
// ed aMassimo
18. Funzioni di generazione di numeri a caso (random)
val = random (max) // inserisce in val un numero a caso compreso tra 0 ed il
// valore contenuto in max
Poiche’ i numeri generati sono in realta’ pseudo casuali (fanno cioe’ parte di una enorme sequenza predefinita), per evitare di ripetere la medesima sequenza di numeri ad ogni avvio del programma e’ opportuno inizializzare il generatore di numeri a caso utilizzando l’istruzione:
randomSeed(seme); // inizializza il generatore di numeri a caso
Inserendo in seme un numero sempre diverso e quindi derivato, ad esempio, da una funzione di tempo applicata ad un’azione umana (come il tempo intercorso tra l’avvio del programma e la pressione di un pulsante) oppure il valore fornito da una porta analogica non utilizzata. In questo modo ad ogni avvio del sistema l’istruzione random () restituira’ numeri a caso in sequenze sempre diverse.