paolo macchi ARDUINO primi calci paolo macchi - Arduino primi calci - rel

Transcript

1 paolo macchi ARDUINO primi calci 1

2 Arduino L ambiente di sviluppo Esercitazioni Esercitazione 1 : LED blink (OUT digitale) Esercitazione 2: Pulsante premuto (Input digitale) Esercitazione 3: Potenziometro (Input analogico) Esercitazione 4 PWM - (Output analogico) Sitografia minima Arduino Arduino è una piattaforma hardware programmabile con cui è possibile creare applicazioni che si interfacciano con l ambiente esterno ricevendo informazioni da un grande numero di sensori e potendo controllare attuatori. La scheda hardware si basa su un microcontrollore costituito da un singolo circuito integrato contenente il processore, la memoria e le unità di In/Out programmabili. Un ambiente di sviluppo integrato ( Integrated Development Environment, IDE) permette di scrivere le applicazioni ( sketch ). L hardware e software di Arduino sono open source e distribuiti con licenza GNU. Numerose sono le versioni di Arduino che sono state distribuite. Nel nostro caso faremo riferimento ad Arduino1. Uno degli elementi caratterizzanti di Arduino è la facilità con cui è possibile interagire con il mondo esterno per la raccolta di segnali provenienti da sensori (da semplici pulsanti a fotoresitenze, a sensori di temperatura) e il pilotaggio di attuatori (LED, motori passo passo, relè ecc.) Arduino è dotato di connettori che dispongono piedini di Ingresso/Uscita (I/O) molto utili per collegamenti con breadboard esterne senza necessità di effettuare saldature. Gli I/O possono essere sia di tipo digitale, sia analogico (fig. ard1). La direzione di funzionamento dei pin dei connettori in input o output, è regolata da apposite istruzioni da inserire nello sketch durante la fase di setup ( pinmode ), mentre i dati sono gestiti dalle istruzioni di digitalread e digitalwrite. I 5 pin di ingresso analogici sono collegati a convertitori analogico-digitale (ADC), che ricevuti i valori di tensione continua compresi tra 0V e 5V, li convertono in 1024 valori discreti (da 0 a 1023). 2

3 i fig. ard1 - I pin digitali sono quelli che vanno dal n.2 al n.13.questi pin non possono essere utilizzati ij IN o in OUT. I pin 0 e 1 corrispondono ai fili RX e TX per la trasmissione seriale. I pin da 0 a 5 sono ingressi analogici 0-5 (immagine: ) Arduino, al contrario, non possiede un convertitore digitale-analogico e usa alcuni dei canali di uscita digitali per emettere segnali PWM ( Pulse-Width Modulation ). Sono disponibili schede di espansione ("shields") che diverse casi produttrici mettono a disposizione per la gestione di attuatori e sensori, relays, motori, collegamenti seriali ecc. NOTA Per la didattica sono spesso utilizzati dei kit ex SparkFun Inventor s Kit L ambiente di sviluppo L'ambiente di sviluppo integrato (IDE) di Arduino contiene, oltre a una serie di menu e pulsanti per il caricamento dei programmi, una console per i messaggi di stato e un editor di testo per scrivere agevolmente il codice e strumenti necessari per il caricamento di programmi e la comunicazione con la scheda hardware.l'angolo inferiore destro della finestra mostra lo stato della porta seriale (COM). La struttura di uno skatch contiene almeno due entità: la funzione setup() eseguita una volta sola e utilizzata per il settaggio di parametri, variabili e funzioni di libreria, e loop() il cui codice è ripetuto all infinito (fig. xx3). Gli sketch vengono salvati con l'estensione di file.ino. 3

4 fig. xx3 - l IDE di Arduino con le principali funzionalità e la struttura basilare di uno skatch. Di notevole interesse, anche ai fini del debug, è la possibilità di aprire il monitor seriale (fig xx4). xx4- Il Monitor Seriale usato per mostrare i valori rilevati da una fotoresistenza Il monitor seriale consente di leggere i dati che Arduino invia tramite la porta seriale, a una velocità predefinita, al computer (fig.xx3). Per impostare la velocità della porta seriale e 4

5 scrivere il dato da inviare sono previste, rispettivamente, le funzioni di Serial.begin() e Serial.print(). Esercitazioni Di seguito vengono mostrate alcune esercitazioni con i quattro casi principali in cui possono essere fatti rientrare la maggior parte dei controlli su sensori e attuatori : OUTPUT DIGITALE (blink di un LED) INPUT DIGITALE (lettura di un pulsante) INPUT ANALOGICO (lettura di un potenziometro) OUTPUT ANALOGICO (Pulse-Width Modulation) Esercitazione 1 : LED blink (OUT digitale) Il primo programma è quello che mostra come pilotare un output digitale. Il più classico degli esercizi è l accensione di un LED (fig. l1) collegato al pin 13 di Arduino (fig. l2). Il primo programma è quello che mostra come pilotare un output digitale. Il più classico degli esercizi è l accensione di un LED (fig. l1) collegato al pin 13 di Arduino (fig. l2). In realtà, sulla scheda, al pin 13, è già collegato un LED, ma qui vogliamo far lampeggiare un LED esterno. Collegarlo direttamente tra un pin e la massa potrebbe danneggiare l uscita digitale ( che può erogare al massimo solo 40 ma, ma conviene restare entro i 20 ma), perchè la resistenza del LED è molto bassa e la corrente che passerebbe molto elevata. E' necessario, perciò, limitare la corrente di alimentazione aggiungendo una resistenza in serie al diodo LED che calcoleremo applicando la legge di Ohm: R = (Vcc - Vd) / I R e' la resistenza, Vcc e' la tensione in continua dell'alimentatore, Vd e' la caduta di tensione del Led e I è la corrente che si vuole far transitare nel Led. Ad esempio per un diodo LED di colore rosso alimentato con alimentazione di 5V e in cui vogliamo far passare una corrente di 10mA, si ha: R = (5V -1,8V) / 10x10^-3 A = 320 Ohm fig. l1 il led ( Light Emitting Diode) è un diodo a semiconduttore che, attraversato dalla corrente, emette luce. Ce ne sono diversi tipi, di colori diversi. 5

6 fig. l2 - Lo schema elettrico e quello pratico con breadboard (frealizzato con Fritzing ) /* Esercitazione 1 : LED blink Accendere, in ciclo continuo, un LED, associato al pin 13, per 2 secondi e spegnerlo per un secondo*/ const int LED_13=13; //costante che associa il pin13 void setup() pinmode(led_13, OUTPUT); //pin 13 in OUT void loop() digitalwrite(led_13, HIGH); //LED ON delay(2000); // 2s digitalwrite(led_13, LOW); // LED OFF delay(1000); // 1s Il programma esegue un ciclo infinito accendendo il LED per 2s (2000ms) e tenendolo spento per 1s. Il LED da accendere e spegnere è collegato al pin 13 (la costante LED_13 viene associata al pin 13) che viene programmato in OUT nel setup(). L uso della costante non è strettamente necessario, ma rende più intuitivo e modificabile il programma. Esercitazione 2: Pulsante premuto (Input digitale) Premendo un pulsante il led si illumina. Il pulsante è collegato, da un lato a massa (GND), dall altro all ingresso digitale (pin 2) di Arduino. Quando il pulsante viene premuto il pin viene portato a massa e viene letto il valore logico LOW. Nel contempo viene portato a stato logico ON il LED collegato al pin 13 (fig p3). 6

7 fig p3 - lo schema elettrico e quello pratico con breadboard /* Esercitazione 2 : PushButton_01 *********************************************************** * Il pulsante è collegato, da un lato a massa (GND), dall altro a un ingresso digitale * Quando il pulsante viene premuto il pin digitale di Arduino viene portato a massa * e viene letto il valore logico LOW ***********************************************************/ const int BUTTON_1 = 2; // Pulsante 1: pin 2 const int LED_1 = 13; // LED: pin 13 int StateButton1; //variabile di stato associata al pulsante void setup() // Set Pulsante pin input: pinmode(button_1, INPUT); // Set LED pin output: pinmode(led_1, OUTPUT); void loop() StateButton1 = digitalread(button_1); if (StateButton1 == LOW) // LOW= pulsante premuto! digitalwrite(led_1, HIGH); // LED ON else digitalwrite(led_1, LOW); // LED OFF 7

8 Esercitazione 3: Potenziometro (Input analogico) Il potenziometro è un sensore di tipo resistivo e la variazione di resistenza e, forse, costituisce il più semplice sensore elettrico di posizione. E` disponibile sia in versione lineare che rotativa. Da un punto di vista elettrico si tratta di un partitore di tensione con resistenza variabile: il valore della resistenza viene ripartito e secondo la legge di Ohm, la tensione di uscita risulta essere una frazione di quella di alimentazione (fig. r1). (a) (b) (c) fig. r1 - (a) Simbolo elettrico del potenziometro (b) Circuito elettrico: x indica la posizione del cursore con 0 x 1 (c) L uscita del potenziometro è collegata al pin 1 analogico di Arduino L uso del potenziometro è particolarmente importante per due ragioni. La prima perchè, sotto svariate forme, lo si ritrova in moltissime applicazioni, la seconda perchè ci consente di utilizzare un ingresso analogico di Arduino. I dispositivi di interfaccia che abbiamo usato finora, come LED o pulsanti, hanno solo due stati: HIGH (5V) e LOW (0V). Anche le comunicazioni, come molte altre applicazioni, prevedono la trasmissione di segnali (0,1) corrispondenti a due valori di tensione definiti. Esistono però un infinità di elementi (come le variabili fisiche) che non possono essere classificate come ON e OFF. Se pensiamo alla temperatura di un ambiente o a un suono che arriva a un microfono ci rendiamo conto che il loro valore varia in modo continuo. In questi casi se un trasduttore riporta la variabile fisica in un livello di tensione dovremmo essere in grado di leggere il suo valore analogico che verrà convertito in un valore discreto, manipolabile dal microprocessore. Arduino offre 6 input analogici (A0,..A5) che accettano un valore di tensione compreso tra 0V e 5V e forniscono un range numerico compreso, rispettivamente, tra 0 e 1023 (la conversione è ottenuta da un ADC-convertitore analogico digitale- a 10 bit, pari a 2^10=1024 valori). Il programma legge, tramite il pin analogico 1 (fig. pot01), il valore analogico del potenziometro ( analogread ) e, con il valore restituito ( PotValue ), controlla la velocità di lampeggiamento di un LED, inserendo delle pause pari al valore letto (fig potenziometro1). 8

9 fig potenziometro1 - lo schema elettrico e quello pratico con breadboard con il potenziometro /* Esercitazione 3 : Potenziometro_01 *********************************************************** * Il programma legge il valore del potenziometro e, con il valore restituito, * controlla la velocità di lampeggiamento di un LED. *********************************************************** */ int PotSensor = A1; // Il potenziometro è collegato al pin 1 analogico const int LED_1 = 13; // LED: pin 13 int PotValue; // variabile con il valore del potenziometro void setup() pinmode(led_1, OUTPUT); Serial.begin(9600); void loop() PotValue = analogread(potsensor); //legge la tensione di PotSensor Serial.print(PotValue); //DEBUG Serial.print("\n"); //oppure serial.println() digitalwrite(led_1, HIGH); // LED on delay(potvalue); // Pausa con il valore (in ms) letto dal potenziometro digitalwrite(led_1, LOW); // LED off delay(potvalue); // Pausa con il valore (in ms) letto dal potenziometro Spesso nei programmi come questo è comodo, come è stato fatto, utilizzare un led, o altri dispositivi come buzzer o display, per valorizzare i dati in ingresso. L introduzione dell interfaccia seriale ( Serial.begin e della funzione di stampa Serial.print ) permette molto di più: mostrare sul monitor del PC i valori rilevati in tempo reale (fig. Arduino_potenziometro1) consente di disporre di uno strumento di debug incredibilmente utile e apprezzato dai programmatori! 9

10 fig. Arduino_potenziometro1- Serial.print permette di mostrare a video, tramite Monitor Seriale, i valori rilevati in tempo reale da Arduino, dal valore minimo (0) al valore massimo usata per fare comunicare arduino e il computer attraverso specifici comandi. Sulla scheda sono presenti due led con la scritta RX e TX che lampeggiano a seconda delle istruzioni scritte nel nostro programma. Approfondimento - La libreria Serial. Tutte le schede Arduino dispongono, almeno, di una porta seriale (UART) che permette la comunicazione sui pin digitali 0 (RX) e 1 (TX) oppure, via USB, direttamente con il computer. La libreria Serial contiene una serie di procedure che permettono la comunicazione seriale con il computer o altri dispositivi. La funzione Serial.begin(baud) imposta la velocità di trasferimento dei dati seriali (data rate) in bit al secondo (baud). La sintassi è così definita: nome libreria. nome procedura (parametri) ; Serial. begin (baud) ; Per default la velocità è di 9600 bps, più che sufficiente per la scarsa mole di dati inviati, ma sono accettate velocità dai 300 bps fino a bps. La funzione accetta anche un secondo argomento, opzionale, atto a configurare anche il numero di bit del dato, la parità e il numero di stop bit. Il default è 8 bit, no parity, uno stop bit (8,N,1) (fig. 8n1). 10

11 fig 8n1 - Il formato tipico per la trasmissione dei dati: 8 bit per dato, 1 stop bit, nessuna parità e, sempre, uno start bit. Alla velocità di 9600 bps, un bit ha la durata di 104 microsecondi (1/9600). Ad esempio il valore ASCII del carattere N è 78 (4E in esadecimale), che corrisponde al numero binario, a 8 bit, In linea vengono trasmessi, oltre al bit di Start (0) e Stop (1), i bit del carattere ( ), a partire dal bit meno significativo: Oltre alle funzioni citate, sono disponibili anche: Serial.read() che legge i dati inviati dal Monitor Seriale Serial.available() che ottiene il numero di byte (caratteri) disponibili per la lettura. I dati arrivati sono memorizzati nel buffer di ricezione seriale che contiene 64 byte Serial.flush() attende la trasmissione completa dei dati seriali in uscita Esercitazione 4 PWM - (Output analogico) Abbiamo visto che Arduino può leggere valori analogici (valori di tensione compresi tra 0V e 5V) utilizzando la funzione analogread() che sfrutta un convertitore analogico-digitale. Esiste in Arduino la funzione complementare, cioè un modo per emettere segnali analogici? Un convertitore digitale-analogico (DAC) è già integrato in Arduino? La risposta è negativa, ma non dobbiamo disperare. Andiamo con ordine. Approfondimento Digitale vs Analogico DIGITALE ANALOGICO I calcolatori lavorano con sistemi digitali basati sui valori 0 e 1 I segnali analogici vanno necessariamente convertiti in digitale. Si tratta, sostanzialmente, di metodi che permettono di tradurre I fenomeni naturali (suoni, pressioni, temperature) sono tipicamente analogici Un segnale analogico è fatto di infinite variazioni 11

12 un fenomeno analogico in una sequenza di due soli elementi: 1 e 0, on e off, acceso e spento La ricchezza di un suono viene convertita in una stringa di bit applicando semplici funzioni matematiche che permettono di approssimare numericamente la curva che rappresenta, istante per istante, la pressione dell aria Un suono ha infinite variazioni. La sola pressione dell aria è in grado di trasmettere una stupenda sinfonia, gli infiniti timbri della voce o il rumore di una cascata Un immagine viene convertita in pixel, cioè in una serie di punti di cui si memorizza il valore numerico del colore e della quantità di luce Un immagine possiede infinite variazioni di intensità di colore Nell esercitazione 1, avevamo realizzato il blink di un LED agendo sul tempo della funzione delay(). Se il tempo diminuisse molto (dell ordine dei 10ms) non ci accorgeremmo quasi più del blink del LED e la sua luminosità risulterebbe leggermente diminuita. In pratica la velocità con cui il LED si accende e spegne darebbe al nostro occhio l illusione che lo stiamo pilotando con un segnale analogico! Il motivo sta nel fatto che abbiamo fatto lampeggiare un LED ad una frequenza elevata, cambiando il rapporto tra il tempo in cui sta acceso ed il tempo in cui sta spento. In questo modo abbiamo applicato la tecnica PWM ( Pulse-Width Modulation ): l uscita digitale viene utilizzata per creare un'onda quadra, un segnale commutato tra gli stati di ON e OFF, in cui il rapporto tra la durata del segnale quando è a ON varia rispetto al periodo totale (duty cycle). In altre parole, trucchiamo un uscita digitale facendola apparire analogica! L utilizzo della funzione delay() non è però una scelta premiante perchè ritarderebbe l intero ciclo di polling dello sketch impedendo la lettura immediata di altri sensori o dispositivi. Per questo Arduino mette a disposizione la funzione analogwrite(pin, valore) che, permette di sfruttare i pin 3, 5, 6, 9, 10, 11 per ottenere un duty cycle variabile in funzione del valore passato come parametro, da 0 (0%, sempre OFF) a 255 (100%, sempre ON). La fig. PW1 mostra i due valori corrispondenti a un duty cycle del 25% (64) e del 50% (127). 12

13 fig. PW1- Duty Cycle (ciclo di lavoro) - La modulazione della larghezza di impulsi, o PWM, permette di variare il tempo dello stato ON del segnale rispetto al periodo totale. Lo sketch (fig PW2) utilizza un componente che contiene tre diodi LED (Red, Green, Blue) che, opportunamente pilotati, possono combinare i colori in modo creare vari effetti luminosi. Il nostro esempio utilizza questi LED in modo esclusivamente didattico, assegnando loro una successione continua di valori, ma può essere usato come base per lavori più interessanti. fig. PW2 schema del pilotaggio dei LED RGB //****************************************************************** * PWM_prova_rgbLED *****************************************************************/ const int RED_LED = 9; const int GREEN_LED = 10; const int BLUE_LED = 11; void setup() //OUT pin for RGB LED pinmode(red_led, OUTPUT); pinmode(green_led, OUTPUT); pinmode(blue_led, OUTPUT); void loop() for (int x = 0; x <=255; x++) //increments x value to get the color palette 13

14 showpwm(x); // mix colors delay(10); for (int x = 255; x >=0; x--) //decrements x value to get the color palette showpwm(x); // mix colors delay(10); /****************************************************************** * showpwm(int color) * Mix RGB color from 0 to 255 /*****************************************************************/ void showpwm(int color) int RValue; int GValue; int BValue; RValue = color; // set red intensity GValue = color; // set green intensity BValue = color; // set blue intensity // set intensity values (Red, Green, Blue pin) using analogwrite() analogwrite(red_led, RValue); analogwrite(green_led, GValue); analogwrite(blue_led, BValue); Sitografia minima