Guida per Istituti Tecnici Industriali

Transcript

1 Manuale di Arduino Guida per Istituti Tecnici Industriali

2 Data Mar 2017 Ver. 1.3 Pag 2/137 SOMMARIO INTRODUZIONE... 5 La storia... 5 Microcontrollori e microprocessori... 6 Hardware... 8 Arduino Hardware Software: ambiente IDE Lo sketch TEORIA: Dichiarazione delle variabili input/output digitali Lampeggio LED: il primo sketch TEORIA: Strutture di controllo - Operatore di scelta if Controllare un LED con pulsante Controllare un LED con un pulsante v TEORIA: resistenze di pull-up e pull-down Progetto: Semaforo Progetto: semaforo con Array Progetto: semaforo con chiamata I/O analogici TEORIA: uscite analogiche Led in dissolvenza Leggere un segnale analogico Teoria: La Fotoresistenza Misura del valore di una fotoresistenza Teoria: strutture di controllo Esempio di struttura switch case Teoria: funzione map led (LED RGB) e 3 potenziometri LCD Display con Arduino SENSORI Sensore di temperatura LM35: termometro con display

3 Data Mar 2017 Ver. 1.3 Pag 3/137 Sensore di temperatura e umidità DHT Sensore ad ultrasuoni PIR sensor Pulsanti multipli su ingresso analogico ATTUATORI Controllo motori in CC Modalità di pilotaggio LAP: Locked Anti-Phase Modalità di pilotaggio SM: Sign-Magnitude (Modulo e segno) Ponte H commerciale: L293D Ponte H commerciale: L Servo motori: come controllare un servo motore Servo motori: controllare un servo da potenziometro Servo motori: pilotare più di un servo Progetto: inseguitore solare con Arduino Teoria: motori passo-passo, cosa sono Pilotare un motore passo passo con un ponte H Controllo motori brushless Comunicazione Bluetooth La tecnologia Bluetooth Il moduli Bluetooth: accendiamo un led via bluetooth Bluetooth: alla pressione di un pulsante inviamo un carattere Bluetooth con Appinventor WiFi: Internet of Things Modulo ESP Tecnologia RFID Modulo RFID APPENDICE Appendice 1: programmazione Arduino Appendice 2: Come trovare la giusta resistenza da mettere in serie ai LED Appendice 3: Come cambiare nome al modulo bluetooth HC

4 Data Mar 2017 Ver. 1.3 Pag 4/137 Appendice 4: Frequenza PWM su Arduino e Duty Cycle Avanzato Multitasking con arduino: lampeggio senza delay Funzione Interrupt (interruzioni esterne hardware) Funzione Interrupt (interruzioni esterne software) Gestione LCD 16x2 con shift register (solo 3 pins) Arduino: Termostato Igrostato regolabile con display Come collegare molti pulsanti usando solo un pin di Arduino

5 Data Mar 2017 Ver. 1.3 Pag 5/137 INTRODUZIONE LA STORIA Arduino nasce presso l Interaction Design Institute di Ivrea, un istituto di formazione avanzata, post universitario, fondato da Olivetti e Telecom. Nasce in un posto particolare... in un paese che ha visto nascere (e tramontare) la grande industria elettronica italiana, che per un momento ci ha fatto sognare in grande. Purtroppo in Italia è rimasto poco di quelle grandi aziende e di quell ingegno che sapeva competere con le grandi potenze mondiali e con le multinazionali. Abbiamo inventato il personal computer, siamo stati competitor di grandi aziende come IBM e poi qualcosa si è rotto. Il nostro sistema politico ed economico ha consumato lentamente, quanto costruito da quelle grandi aziende nate nel dopoguerra. Gli imprenditori hanno lasciato il posto a manager specializzati in finanza che hanno spolpato le nostre grandi aziende. Nel 2003, Hernando Barragan ha sviluppato a Ivrea un progetto originale per avvicinare designer e creativi all elettronica. Sarebbe meglio dire: per facilitare l utilizzo dell elettronica per la realizzazione di prodotti innovativi e interattivi. Il lavoro di Barragan si chiamava Wiring ed è un progetto ancora attivo. Wiring è una piccola scheda elettronica dotata di un chip che può essere programmato semplicemente con un computer e un programma derivato da Processing (un editor per semplificare la programmazione e l apprendimento del linguaggio Java). Processing è un progetto Open Source che è stato modificato per programmare Wiring e per funzionare con il linguaggio C richiesto dalla scheda elettronica. Wiring e Processing «modificato» costituiscono un sistema o frame work per la progettazione rapida di circuiti elettronici. La scrittura del codice non è fatta in C «puro» ma con una forma semplificata, nascondendo i dettagli della programmazione a basso livello, tutto per facilitarne l utilizzo da parte di persone non esperte. Massimo Banzi si interessò al lavoro di Barragan e nel 2005 decise di sviluppare una nuova scheda partendo dall idea molto originale di Wiring, cercando di semplificare maggiormente l'utilizzo del sistema e abbassando il costo della scheda. Il nuovo progetto fu battezzato Arduino, il nome del bar di Ivrea, dove il team del progetto si trovava per bere l aperitivo. Il team che realizzò Arduino era composto da Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. Da allora il progetto ha riportato notevole successo in tutto il mondo dei maker e non solo. La piccola schedina di Ivrea è stata adottata per innumerevoli progetti e ha permesso la realizzazione di cose fino a poco tempo prima impensabili... soprattutto da parte di persone che non avevano conoscenze elettroniche. Nasce così Arduino, una piccola scheda con un microcontrollore, che chiunque può imparare a utilizzare in breve tempo per realizzare circuiti elettronici interattivi. Per programmare Arduino è sufficiente collegarlo al proprio computer con un cavo USB, scrivere qualche istruzione, collegare qualche componente elettronico e premere il tasto «Upload». Si procede per tentativi ed errori, correggendo il programma di volta in volta. Le istruzioni sono abbastanza semplici e comprensibili. Il software di programmazione, chiamato anche IDE (Ambiente Integrato di Sviluppo), contiene numerosi esempi da cui prendere spunto per scrivere i propri listati. Per facilitare la costruzione dei circuiti elettrici sono state inventate delle piccole schede chiamate shield che s impilano su Arduino. 5

6 Data Mar 2017 Ver. 1.3 Pag 6/137 Esistono shield con: Display Bluetooth Controllori per motori GPS Schede di rete Moduli audio Etc. Arduino ha successo perché è semplice e funziona sempre. Perché trovate spesso quello che vi serve, senza dovervi scervellare troppo. Perché è un prodotto ben fatto e continuamente curato. La scheda è stata sempre prodotta in Italia e continua a esserlo e si può considerare un vero prodotto «made in Italy». Ma soprattutto, Arduino ha successo per le seguenti 3 caratteristiche: 1. Open Source: chiunque può intervenire sulla modifica del progetto elettrico, del bootloader, del software in generale. La scheda 2. Low Cost: è una diretta conseguenza dell Open Source. Una volta che le schede e le shield possono essere realizzate da aziende di terze parti, la concorrenza ha reso possibile accedere a prezzi molto bassi alla portata di tutti. 3. Community: l immensa community in rete permette di scambiare idee, pensieri, progetti. Il progetto didattico si è trasformato in prodotto mantenendo la caratteristica «Open Source». Non c è nulla di segreto o di nascosto. Gli schemi dell hardware sono liberamente scaricabili da Internet, così come tutto il software necessario per costruirsi in casa, autonomamente, il proprio Arduino. Le aziende sono spesso abbastanza paranoiche sul tema sicurezza e se possibile terrebbero tutto sotto chiave. È inimmaginabile diffondere su Internet i piani del proprio prodotto di punta. Arduino ha dimostrato che con le opportune accortezze si possono creare aziende di successo basate su prodotti Open Source. La tutela è sul marchio e la protezione non sta in un brevetto ma sulla rispettabilità del nome e del prodotto. Rispettabilità costruita online grazie alla collaborazione e al coinvolgimento di migliaia di maker. MICROCONTROLLORI E MICROPROCESSORI Il microprocessore è un circuito integrato (anche chiamato chip), specializzato nell esecuzione di operazioni matematiche, nel trasferimento e nella manipolazione d informazioni. Questi chip sono il «cervello» dei nostri computer e per funzionare hanno bisogno di memorie, dischi, periferiche di vario tipo, mouse, tastiera, display. Il primo microprocessore è stato costruito attorno agli anni 70 da Intel. Il circuito prodotto da Intel si chiamava 4004, conteneva qualche manciata di transistor e sapeva svolgere semplici operazioni matematiche a quattro bit, con frequenze di qualche KHz. I microprocessori di oggi sono delle grandi metropoli se paragonate al 4004: hanno centinaia di migliaia di transistor e lavorano a frequenze di GHz. Un microcontrollore è un chip che contiene un piccolo microprocessore e il minimo indispensabile per il suo funzionamento: della memoria, qualcosa che possa funzionare da disco (flash memory), una memoria a lungo termine (EEPROM), un generatore di frequenza, dei convertitori analogico- digitali e delle semplici periferiche per permettergli di interagire con il mondo. 6

7 Data Mar 2017 Ver. 1.3 Pag 7/137 Molti microcontrollori hanno potenza limitata, ma anche costi molto bassi. Per questo motivo li troviamo in molti dispositivi che utilizziamo quotidianamente. Grazie a una serie d innovazioni introdotte da ATMEL e Microchip attorno agli anni 90 il loro utilizzo è diventato molto semplice, contribuendo alla loro diffusione. Un microcontrollore moderno non richiede speciali apparati per essere programmato e il firmware può essere trasferito al suo interno anche se è già stato saldato su un circuito stampato. Prima di queste innovazioni per utilizzare un microcontrollore era necessario, esporlo a dei raggi UV per cancellarlo e poi programmarlo con kit di sviluppo molto costosi. I microcontrollori moderni hanno la possibilità di ospitare un piccolo programma, chiamato bootloader, residente in un area di memoria speciale. Il bootloader è un programma che può scrivere direttamente le istruzioni nella memoria del chip. In questo modo non serve un programmatore particolarmente complicato: con una semplice porta seriale è possibile programmare il chip con il software che abbiamo scritto. Esistono diverse famiglie di microcontrollori, ognuna contraddistinta da un proprio nome e dall organizzazione tipica dei suoi circuiti interni, cioè l'architettura del chip. La programmazione di questi chip era fatta in codice macchina, scrivendo lunghi programmi che poi erano convertiti in sequenze di numeri. Inizialmente il numero di comandi e di operazioni era limitato, si potevano eseguire semplici operazioni logiche, trasferimenti di dati e test, ma con l aumentare della complessità dei chip, i progettisti iniziarono a inserire delle operazioni più specifiche e sempre più complesse. 7

8 Titolo Data Manuale di Arduino Mar 2017 ITIS GEYMONAT Note Ver. 1.3 Dispense del dipartimento di elettronica Pag 8/137 Questi chip con un set d istruzioni molto numeroso si chiamano CISC, che sta per Complex Instruction Set Computer. Sono circuiti di grosse dimensioni, molto costosi da progettare e da realizzare. I programmatori però usavano raramente tutte queste istruzioni complesse e a volte, compiere la stessa operazione in più passaggi e con comandi base era più veloce! Per questo motivo sono nati i chip RISC (Reduced Instruction Set Computer), in cui il set d istruzioni è stato ridotto al minimo indispensabile. I più noti processori RISC sono i PIC, gli AVR, gli ARM o gli SPARC. Il chip utilizzato da Arduino UNO è un ATMega328 della famiglia AVR. Avrete spesso sentito nominare i chip ARM (Advanced RISC Machine), che sono circuiti impiegati nella realizzazione di telefoni, tablet e dispositivi portatili con bassi consumi e ottime prestazioni. HARDWARE Una scheda Arduino consiste di un microcontrollore a 8-bit AVR prodotto dalla Atmel, con l aggiunta di componenti complementari che ne facilitano l utilizzo con altri circuiti. Le schede ufficiali usano i chip della serie megaavr (nello specifico, i modelli ATmega8, ATmega168, ATmega328, e ATmega1280) ma i loro cloni sono disponibili anche con altri microcontrollori. Molte schede includono un regolatore lineare di tensione a 5 volt ed un oscillatore a quarzo da 16 MHz (o, in alcune varianti, un risuonatore ceramico), sebbene alcuni casi, come ad esempio LilyPad, girino ad 8 MHz e facciano a meno dello stabilizzatore di tensione. La scheda Arduino è pre-programmata con un bootloader che semplifica il caricamento dei programmi nella memoria Flash incorporata nel chip, rispetto ad altri dispositivi che richiedono, solitamente, un programmatore esterno. Le recenti versioni di Arduino vengono gestite via USB, grazie a un implementazione che usa un chip adattatore USB-seriale come l FT232 della FTDI. Alcune varianti, come la Arduino Mini e la versione non ufficiale Boarduino, usano una scheda o un cavo adattatore USB-to-serial separato. Prima di addentrarci nella descrizione dell hardware, è bene conoscere la famiglia dei prodotti Arduino. Esistono differenti versioni in relazione alle specifiche necessità di ogni utente. La scheda Arduino 2009, prodotta nell anno 2009, è stata la progenitrice di Arduino UNO. Prima della 2009 ci furono altri modelli come la e la NG. Queste schede non sono state solo dei prototipi, ma erano in vendita fino a poco tempo fa. La «diecimila» prende il suo nome dal fatto di aver venduto diecimila schede. Un vero successo per una «piccola» start-up italiana di nome Arduino! Utilizzavano tutte un chip ATMega168 che fu sostituito solo nelle ultime serie delle «2009» con l ATMega328, perché dotato di maggiori risorse. Le differenze maggiori sono nella comunicazione con il computer necessario per la programmazione e nei continui miglioramenti apportati al design del circuito e del prodotto. Le prime schede utilizzavano una porta seriale RS232 di quelle con il connettore a nove pin, una volta abbastanza diffusa su tutti i PC, ma ormai introvabile. La porta seriale è stata sostituita da una porta USB, che richiede un chip specializzato (FT232), impiegato nei primi modelli di Arduino e poi anch esso rimpiazzato da un semplice microcontrollore ATMEL ATMega8U2, programmato opportunamente. Le versioni originali sono diverse, nella tabella seguente daremo le specifiche di quelle più utilizzate. 8

9 Titolo Data Manuale di Arduino Mar 2017 Nome UNO ITIS GEYMONAT Note Ver. 1.3 Immagine Dispense del dipartimento di elettronica Pag 9/137 Descrizione MCU: Atmega328P VOLTAGE: 5V PIN: 14 PWM: 6 ANALOG: 6 CLOCK: 16 MHz MEMORY: 32 KB E la versione più comune di Arduino, la descriveremo in dettaglio più avanti. MCU: ATMEGA32U4 8 bit VOLTAGE: 5V PIN: 20 PWM: 7 ANALOG: 6 Clock: 16 MHz Leonardo MEGA 2560 DUE Mini ATMEGA32U4 è dotato di comunicazione diretta USB, quindi niente processore secondario: questo permette alla scheda di essere vista dal computer anche come una normale periferica. MCU: ATMEGA32U4 8 bit VOLTAGE: 5V PIN: 54 PWM: 14 ANALOG: 16 Clock: 16 MHz E la seconda versione maggiorata di Arduino UNO. MCU: ATMEL SAM3X8E CPU Cortex-M3 32 bit VOLTAGE: 3.3V PIN: 54 PWM: 12 ANALOG: 12 Clock: 84 MHz DAC: 2 A differenza di altre schede però la Due possiede un processore a 32 bit, funziona a 3.3V, è anche la tensione massima che i pin possono sopportare. MCU: ATMEGA bit VOLTAGE: 5V PIN: 14 PWM: 6 ANALOG: 8 Clock: 12 MHz Come Arduino UNO ma dalle dimensioni molto ridotte. 9

10 Data Mar 2017 Ver. 1.3 Pag 10/137 Di seguito, invece, una tabella che riassume tutte le versioni di Arduino in base alla tipologia. Infine riportiamo la tabella con le differenze delle specifiche di ogni versione ufficiale di Arduino. Name Processor Operating Input CPU Analog I Digital EEPROM SRAM Flash Voltage Speed O IO PWM [KB] [KB] [KB] USB UART ArduinoBT ATmega328P 5 V V 16 MHz Due ATSAM3X8E 3.3 V 7-12 V 84 MHz Micro 4 Esplora ATmega32U4 5 V 7-12 V 16 MHz Micro - Ethernet ATmega328P 5 V 7-12 V 16 MHz Regular - Fio ATmega328P 3.3 V V 8 MHz Mini 1 Gemma ATtiny V 4-16 V 8 MHz Micro 0 Leonardo ATmega32U4 5 V 7-12 V 16 MHz Micro 1 LilyPad ATmega168V V ATmega328P V 8MHz LilyPad V ATmega328P SimpleSnap V 8 MHz LilyPad USB ATmega32U4 3.3 V V 8 MHz Micro - Mega 2560 ATmega V 7-12 V 16 MHz Regular 4 Mega ADK ATmega V 7-12 V 16 MHz Regular 4 Micro ATmega32U4 5 V 7-12 V 16 MHz Micro 1 Mini ATmega328P 5 V 7-9 V 16 MHz Nano ATmega V 7-9 V 16 MHz ATmega328P Mini 1 Pro ATmega V V 8 MHz ATmega328P 5 V 5-12 V 16 MHz Pro Mini ATmega328P 3.3 V V 8 MHz 5 V 5-12 V 16 MHz Uno ATmega328P 5 V 7-12 V 16 MHz Regular 1 Yùn ATmega32U4 16 MHz Micro 1 5 V AR9331 Linux 400MHz 16MB 64MB 10

11 Data Mar 2017 Ver. 1.3 Pag 11/137 Zero ATSAMD21G V 7-12 V 48 MHz Micro 2 ARDUINO HARDWARE Descriveremo di seguito in dettaglio i componenti Hardware della scheda Arduino UNO partendo dal connettore USB e procedendo in senso antiorario. Connettore USB: ha un duplice scopo: principalmente è utilizzato per trasferire i programmi sul processore e comunicare in tempo reale tramite monitor seriale; la presenza dei 5 V a 500 ma permettono di alimentare la scheda ed una eventuale breadboard (considerare il limite di corrente). Alimentazione: è possibile inserire un jack da cinque millimetri (con diametro interno da 2,1 mm) per alimentare la scheda con una tensione da 7-12 V. La tensione fornita sarà poi livellata a cinque volt da un regolatore di voltaggio. Molte persone collegano una batteria da nove volt con una clip fornita di jack, per alimentare Arduino quando non c è un computer nelle vicinanze. RESET: La scheda è dotata di un tasto per eseguire il reset. Se lo premerete, l esecuzione del programma si fermerà e tutto ripartirà da capo, come se la Arduino fosse stato appena acceso. Potete collegare un pulsante esterno per pilotare il RESET. 3.3V: molti chip e sensori moderni si alimentano a 3,3 V, una tensione inferiore rispetto ai cinque volt, che produce meno calore. Non tutti hanno nel cassetto dei propri componenti un regolatore a 3.3 volt, ecco perché ne trovate uno su Arduino. 5V: questo pin fornisce la tensione a cinque volt regolata e stabilizzata da Arduino. Lo stabilizzatore interno può fornire fino a circa 1 A di corrente. GND: GND significa Ground, cioè «terra» o «massa». È il polo negativo di alimentazione, anche chiamato il «comune» o «zero volt». Tra gli header di Arduino avete a disposizione ben tre posizioni in cui infilare delle connessioni a massa. V in : questo pin è collegato direttamente all ingresso di alimentazione e si può utilizzare per prelevare una tensione di alimentazione più elevata necessaria per far funzionare componenti collegati ad Arduino. Potreste avere dei motori che funzionano a 12 V: per utilizzarli, alimenterete Arduino a dodici volt attraverso la presa di alimentazione e porterete la tensione di dodici volt ai motori, prelevandola dal pin Vin. Può essere inoltre utilizzato per alimentare Arduino da breadboard. Analog pin A0-A5: Arduino ha sei pin in grado di leggere livelli analogici e di convertirli in un numero che si potrà utilizzare all interno degli sketch. Questi particolari ingressi sono posti a parte e con- 11

12 Data Mar 2017 Ver. 1.3 Pag 12/137 trassegnati dalle sigle: A0, A1, A2, A3, A4, A5. ICSP: vicino alla piccola scritta ICSP trovate sei piedini che si possono utilizzare per comunicare con l ATMega328. I piedini costituiscono un interfaccia seriale usata da periferiche e altri microcontrollori. I pin ICSP si possono usare per programmare direttamente Arduino (usando una speciale «pennetta»). Il sistema di comunicazione si chiama SPI, cioè Serial Peripheral Interface, e prevede un circuito principale che conduce la comunicazione (master) e uno o più periferiche (slave). Due dei sei pin sono utilizzati per l alimentazione (cinque e zero volt), una linea serve per selezionare la periferica con cui comunicare e gli altri tre fili sono: o MISO (Master In Slave Out) per inviare dati al master, o MOSI (Master Out Slave In) - su cui passano i dati per lo slave, o o SCK (Serial Clock) il segnale di sincronizzazione (clock) per la comunicazione. In modo non troppo intuitivo, per comunicare con uno slave, si deve mettere il suo piedino a livello basso (zero volt o GND). PIN 0-13: Arduino ha quattordici pin che possono essere configurati per funzionare da ingressi o uscite. La configurazione si fa nel software. Arduino è un dispositivo digitale, quindi i pin possono generare o leggere un valore alto o basso, e quindi pari a zero o 5V. Un pin digitale configurato come uscita non potrà mai fornire, per esempio, un valore di 2,5 volt, ma unicamente zero o cinque volt. Alcuni pin riportano accanto al numero identificativo una piccola «serpentina» chiamata «tilde» (~): questi pin possono generare un segnale particolare molto utile per pilotare motori elettrici o per regolare a piacere l intensità luminosa di un LED. Questo segnale elettrico speciale è chiamato Pulse Width Modulation (PWM) e lo descriveremo più avanti. I pin in grado di fornire un segnale PWM sono: 3, 5, 6, 9, 10, 11. I pin 0 e 1 sono contrassegnati anche con TX0 e RX0 e sono collegati alla porta seriale del chip: possono essere utilizzati per collegare Arduino a qualsiasi altro dispositivo che disponga di una porta seriale. AREF: Arduino può leggere delle tensioni analogiche comprese tra 0 e 5 V che trasformerà poi in un numero tra 0 e Il passo minimo, cioè la precisione della misura sarà pari a cinque volt diviso per 1024, cioè 4,88 mv. Arduino usa sempre una tensione di riferimento interna, prelevata dalla tensione di alimentazione che potrebbe non essere molto precisa e che dovrebbe valere cinque volt (ma potreste trovare 4,8 volt). Se volete misurare qualcosa con grande precisione, potreste usare una tensione di riferimento molto stabile e precisa che applicherete su AREF. Se la massima tensione analogica che volete leggere arriva a tre volt, potreste ottenere una maggiore precisione se, su AREF, applicaste tre volt. In questo modo il passo minimo sarà di tre volt diviso per 1024, e cioè di 2,93 millivolt. La tensione applicata a AREF non deve mai essere superiore a 5 V, altrimenti si rischierebbe di danneggiare Arduino. 12

13 Data Mar 2017 Ver. 1.3 Pag 13/137 SOFTWARE: AMBIENTE IDE Arduino non è solo una scheda che è possibile programmare a piacimento, ma un sistema formato da: un circuito stampato con microcontrollore, un software per programmarlo, una vasta comunità on-line con cui interagire per ricevere e fornire supporto. Il punto di partenza è il sito internet dove si possono trovare molte informazioni utili per iniziare. La prima cosa da fare dopo aver spacchettato il vostro Arduino è visitare il sito e scaricare il software necessario per far funzionare la scheda. Il programma per utilizzare Arduino con il vostro computer si chiama Arduino IDE, o più brevemente «Arduino». Un IDE è un ambiente di sviluppo integrato (Integrated Development Environment), un editor avanzato arricchito da molti strumenti utili per scrivere del software, per testarlo e per pubblicarlo o impacchettarlo (deploy). Alcuni IDE «famosi», usati da molti programmatori sono Eclipse, NetBeans, Xcode o VisualStudio. Sono programmi complessi e specializzati per scrivere codice Java, C, php... Un IDE gestisce un compilatore, cioè il programma che riceve un listato e lo traduce nei bit comprensibili a microprocessori e microcontrollori. L IDE di Arduino è scritto in linguaggio Java ed è basato su Processing ( Processing è un ambiente di sviluppo nato con scopi didattici. Si programma con un linguaggio molto simile a Java, arricchito di alcune funzioni ad alto livello per produrre grafica in due e tre dimensioni. Il software è Open Source con licenza GNU e si può utilizzare su Mac OSX, Windows e Linux. I programmi scritti in Processing possono dialogare con Arduino e si possono combinare le due piattaforme, per esempio creando un controller hardware che interagisce con un videogioco in esecuzione sul vostro computer.. Processing è stato utilizzato come punto di partenza per creare l'ambiente di programmazione per Arduino infatti, la finestra principale dei due programmi è molto simile. In Arduino non troverete il termine «listato», ma «sketch», che è stato ereditato da Processing. Dallo sketch di Processing quello di Arduino eredita anche la struttura caratterizzata da due blocchi ben distinti, chiamati setup e loop. Mentre in Processing non è obbligatorio utilizzare dei blocchi in cui inserire le istruzioni, negli sketch di Arduino dovrete sempre includere le due sezioni: setup in cui inserire tutte le istruzioni che devono essere eseguite una sola volta all accensione di Arduino; loop con le istruzioni che saranno ripetute fino a che Arduino è alimentato. Ecco gli strumenti dell IDE di sviluppo: 13

14 Data Mar 2017 Ver. 1.3 Pag 14/137 Verifica: verifica la correttezza delle sketch, qualora vengano riscontrati degli errori verrà individuata la linea corrispondente Carica: verifica e carica lo sketch all interno del microcontrollore Nuovo: permette di aprire una nuova finestra per scrivere un nuovo sketch Apri: permette di aprire uno sketch salvato in memoria Salva: permette di salvare l attuale sketch Monitor Seriale: è possibile far trasmettere delle informazioni attraverso la porta seriale di Arduino e quindi leggerle dal vostro PC. Quando la porta seriale non è impegnata nella programmazione del microcontrollore, potete utilizzarla per scambiare informazioni che si possono visualizzare su una finestra del computer. Se ci sono errori in fase di verifica, oppure durante l upload, nell'area inferiore appariranno dei messaggi di colore arancione che forniranno delle indicazioni utili per risolvere il problema. Nel caso di errori di scrittura del codice troverete indicata la riga in cui è stato rilevato l'errore. Caricando uno sketch su Arduino potreste incappare in problemi di trasferimento. Solitamente questi errori sono dovuti alla porta seriale che potrebbe bloccarsi, oppure al cavo che non fa bene contatto o anche a qualche problema con il circuito che avete collegato ad Arduino. In questi casi provate a scollegare la scheda, salvare il listato, chiudere del tutto Arduino e ripartire da capo. A volte potrebbe anche essere necessario riavviare il computer per risolvere la situazione. Un errore comune si ha quando il vostro circuito utilizza i pin numero 0 e 1, che sono condivisi con la porta seriale collegata al computer. Per caricare correttamente lo sketch dovrete scollegare temporaneamente i componenti che avete collegato a questi pin. Apriamo l IDE di Arduino: 14

15 Data Mar 2017 Ver. 1.3 Pag 15/137 In automatico, l ide, ci suggerisce il nome del nostro primo programma, i programmi che scriveremo si chiamano sketch per cui verranno chiamati indifferentemente programmi o sketch nei prossimi articoli; il nome che ci propone è semplice: sketch_nov06a ( programma, _, mese corrente nov, giorno corrente 06, lettera del programma a in quanto è il primo della giornata, i prossimi saranno b, c, d, z ). Per il resto il nostro foglio è vuoto, vediamo un po di sintassi utile per scrivere i primi programmi: Comando Significato * Commento monoriga es.: Apertura commento multiriga; es.: * * Questo è il mio primo * programma per Arduino * Il mio primo programma per Arduino * Chiusura commento Multiriga; es.: vedi sopra void dichiarazione di funzione senza ritorno, ossia la funzione esegue delle operazioni ma non restituisce alcun valore dopo l elaborazione setup() loop() int pinmode(pin,mode) digitalwrite(pin,level) delay(second) funzione base (obbligatoria) di ogni programma Arduino funzione base (obbligatoria) di ogni programma Arduino dichiarazione di variabile di tipo integer (intero); utilizzato anche per dichiarare le funzioni che restituiscono valori interi funzione di configurazione di un piedino Arduino, in modo che sia utilizzabile come INPUT o come OUTPUT invia un comando di output sul piedino selezionato (pin) di tipo digitale, pe cui 0 o 1; in sostituzione dello 0 e dell 1 si possono utilizzare le costanti LOW (0) e HIGH (1) funzione utile per introdurre un dalay (attesa) tra una istruzione e la successiva, il paramerosecond è esperesso in millesimi di secondo. 15

16 Data Mar 2017 Ver. 1.3 Pag 16/137 LO SKETCH Il punto di partenza di ogni progetto con Arduino è lo sketch, cioè il listato, che è organizzato in due sezioni principali: setup: eseguito solo all'accensione della scheda o dopo la pressione del tasto RESET; loop: che contiene le istruzioni che saranno ripetute in continuazione fino che Arduino è alimentato. Impostate lo sketch in questo modo: void setup() codice eseguito all'avvio, ad esempio dichiarazioni di input e output void loop() codice ripetuto Dovete assicurarvi che siano sempre presenti le due sezioni setup e loop, altrimenti appariranno degli errori. Setup e loop sono due funzioni che non restituiscono nessun risultato e non richiedono parametri, per questo vanno precedute dalla parola «chiave» void. Potete caricare uno sketch «vuoto» cliccando sulla voce del menu File: Esempi > Basic > BareMinimum. È obbligatorio creare uno sketch con loop e setup, ma non è necessario inserire del codice all interno delle due sezioni. Potreste avere uno sketch in cui è presente del codice solo nella sezione loop, oppure solo nella parte setup (così che sia eseguito una volta sola). Potreste anche caricare uno sketch «vuoto» su Arduino, per ripulirlo da programmazioni precedenti. TEORIA: DICHIARAZIONE DELLE VARIABILI Come in ogni linguaggio di programmazione, è necessario dichiarare le variabili anche per programmare il processore Atmega 328. Di seguito una lista di tipologie di variabili: boolean: è 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. 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). 16

17 Data Mar 2017 Ver. 1.3 Pag 17/137 short: come "int" ma anche per "Arduini" con architettura ARM (es. Arduino Due) 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. unsigned long: come long ma solo numeri positivi, quindi da 0 a 4'294'967'295. float: può memorizzare numeri con la virgola. double: contiene un numero fino a 1' x10^308. char: contiene un singolo carattere di testo. string: contiene più caratteri di testo. Es: char Str1[] = "esempio"; L ultima tipologia di variabile richiede una trattazione particolare. Tutte le seguenti dichiarazioni sono valide: char Str1[15]; dichiarare un array di caratteri senza inizializzazione char Str2[8] = 'a', 'r', 'd', 'u', 'i', 'n', 'o'; dichiarare un array di caratteri (con un carattere extra) ed il compilatore aggiungerà automaticamente un carattere nullo char Str3[8] = 'a', 'r', 'd', 'u', 'i', 'n', 'o', ' 0'; viene esplicitato il carattere nullo char Str4[ ] = "arduino"; inizializza con una stringa costante nel dimensionamento della variabile. Il compilatore dimensionerà l array in maniera tale da inserire la stringa char Str5[8] = "arduino"; inizializza l array con una dimensione data e una stringa costante char Str6[15] = "arduino"; inizializza l array lasciando spazio per stringhe più grandi Terminazione con carattere nullo: solitamente, le stringhe vengono terminate con un carattere nullo (ASCII code 0). Questo permette alle funzioni, quale Serial.print(), di dire dov è la fine della stringa. Altrimenti, la funzione continuerebbe a leggere bytes di memoria che non fanno parte della stringa. Senza carattere nullo è necessario leggere intenzionalmente una determinata lunghezza di stringa. Le costanti Sono 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. AVVERTENZE Prima di prendere dimestichezza con la board, sembra doveroso elencare alcune avvertenze del caso: Evitare di utilizzare Arduino a contatto di una superficie elettricamente conduttiva (ferro, acqua, ambienti umidi, etc..) Utilizzare Arduino con 5V o al massimo 12V, si può fare ma richiede qualche nozione aggiuntiva per evitare di friggere la scheda Se non funziona fare riferimento alle FAQ, tra cui i più comuni problemi di installazione e errori di upload del codice (il 99% dei problemi) Iniziare con progetto molto semplici ed evitare i progetti più complicati. Prima di imbattervi in progetti di una certa importanza cercate nei forum. Ormai migliaia di progetti sono stati fatti, nulla vi vieta di prendere spunto e personalizzare ciò che vi serve Se siete insicuri su collegamenti, tensioni e metodi vari chiedete. Anche se la domanda non riguarda Arduino in particolare, molti saranno disposti ad aiutarvi. 17

18 Data Mar 2017 Ver. 1.3 Pag 18/137 INPUT/OUTPUT DIGITALI LAMPEGGIO LED: IL PRIMO SKETCH Il primo programma da realizzare è molto semplice: far lampeggiare il led presente su Arduino con un intervallo di un secondo. Per il calcolo della resistenza opportuna si invita il lettore a prendere visione dell appendice 2. Arduino presenta un LED già incorporato connesso al piedino n.13. La figura accanto mostra la collocazione fisica del LED1. Se invece si vuole collegare un LED esterno è necessario inserire una resistenza per limitare la corrente. Per un diodo LED rosso si può collegare una resistenza del valore da 220 Ω da ¼ di Watt. Vediamo lo sketch: 1. int ledpin = 13; LED connesso al pin void setup() pinmode(ledpin, OUTPUT); imposta il pin come output void loop() digitalwrite(ledpin, HIGH); accende il led 9. delay(1000); attende un secondo (1000 millisecondi) 10. digitalwrite(ledpin, LOW); spegne il led 11. delay(1000); attende un secondo prima di ripartire 12. Descrizione del listato: linea 01: definisce una nuova variabile di tipo intero (integer) ledpin il cui valore sarà il pin che desidero utilizzare per far lampeggiare il led. Arduino presenta già un led sul pin 13 con la dovuta resistenza di protezione. linee 02-05: definisce la funzione setup(), la prima delle funzioni obbligatorie per Arduino. In questa funzione si possono inserire le definizioni necessarie al programma, ad esempio definire che il pin 13 sarà utilizzato come pin di tipo OUTPUT, alla linea 14 con il comando pinmode indico ad Arduino di utilizzare ledpin (in questo caso 13) come pin di OUTPUT. Nota che tutte le definizioni interne alla funzione setup() sono racchiuse tra parentesi graffe ( ) questa sintassi è identica per tutte le funzioni che vedremo, da cui possiamo dire che una nuova funzione sarà definita con la sintassi: 18

19 Data Mar 2017 Ver. 1.3 Pag 19/137 definizione_di_funzione nome_funzione( eventuali parametri ) istruzioni e definizioni void setup() pinmode( ledpin,output ); linea 06: definisce la seconda funzione obbligatoria per Arduino loop. Anche questa funzione non prevede la restituzione di alcun valore, per cui può essere dichiarata di tipo void e non attende parametri in input. Arduino eseguirà questa funzione di continuo per tutta la durata del programma. linea 08: utilizza il comando: digitalwrite impostando il pin 13 a livello logico alto. Il comando digitalwrite accetta due parametri: il pin e il valore da inviare, in particolare, poiché è un comando di tipo digitale si potrà utilizzare, come valore per il secondo parametro solo 0 o 1 (LOW o HIGH). Nel caso avessimo avuto bisogno di inviare valori differenti al pin, si sarebbe dovuto utilizzare un altro comando come ad esempio: analogwrite. linea 09: utilizzando il comando delay e inserendo come parametro 1000 in millisecondi, si ottiene una pausa di un secondo prima che Arduino esegua il comando della riga successiva. linea 10: utilizzando nuovamente il comando digitalwrite, si imposta a 0 ( o LOW ) il valore del pin 13, ottenendo lo spegnimento del led. linea 11: attende un secondo prima di eseguire nuovamente tutto il blocco contenuto nella funzione loop. Non resta che cliccare sul pulsante per eseguire un test di sintassi del nostro programma, se il test risulta corretto e non ci sono errori leggeremo in basso un messaggio di ok e l indicazione del peso in byte del nostro programma. Inviamo il nostro programma ad Arduino, utilizzando il pulsante di upload TEORIA: STRUTTURE DI CONTROLLO - OPERATORE DI SCELTA IF If - è il "se" in linguaggio C, 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); L istruzione if else consente di prendere delle decisioni in funzione del fatto che una determinata condizione logica sia VERA o FALSA. Nel caso in cui la condizione sia VERA viene eseguito il primo blocco di istruzioni, nel caso in cui la condi- 19

20 Data Mar 2017 Ver. 1.3 Pag 20/137 zione sia FALSA, viene eseguito il secondo blocco di memoria. La condizione logica espressa tra parentesi tonde, segue la parola if Esempio: 1. if (x < 100) blocco A else blocco B 8. Se la condizione X<100 è vera viene eseguito il blocco di istruzioni del blocco A, se la condizione X<100 è falsa viene eseguito il blocco di istruzioni del blocco B. CONTROLLARE UN LED CON PULSANTE Per controllare lo stato di un pulsante utilizzeremo l istruzione digitalread(), questa istruzione legge il valore su uno specifico pin digitale che può assumere due valori, HIGH o LOW, detto in modo meno informatico e più elettronico, verifica se su un determinato pin è applicata una tensione di +5V (definito HIGH) o 0V (definito LOW). Con la nuova istruzione digitalread() siamo in grado di eseguire qualcosa di più evoluto, l accensione di un led solamente se cambia una situazione esterna, in questo esercizio, lo stato di un pulsante. Quindi con digitalread() possiamo leggere uno stato di un sensore e memorizzare questo stato nella memoria di Arduino per fare qualcosa. Per procedere con questa lezione abbiamo necessità di un po di hardware elettronico: 1 breadboard 1 pulsante 1 diodo led 1 resistenza da 10 K Ohm filo elettrico per breadboard Il circuito che deve essere realizzato è il seguente: 20

21 Data Mar 2017 Ver. 1.3 Pag 21/137 Ricordate di collegare il catodo del diodo LED su GND e l anodo all uscita digitale 13. NB: in questo caso non è stata inserita la resistenza di limitazione della corrente. Sarebbe sempre meglio inserirla ma abbiamo voluto intenzionalmente dimostrare che per usi che non richiedono molto tempo di accensione è possibile collegare direttamente il diodo alla scheda). Questo è il codice usato per controllare il LED: 1. Accendi il led appena è premuto il pulsante 2. int LED = 13; LED collegato al pin digitale int BUTTON = 7; pin di input dove è collegato il pulsante 4. int val = 0; si userà val per conservare lo stato del pin di input 5. void setup() 6. pinmode(led, OUTPUT); imposta il pin digitale come output 7. pinmode(button, INPUT); imposta il pin digitale come input void loop() 10. val = digitalread(button); legge il valore dell'input e lo conserva 11. controlla che l'input sia HIGH (pulsante premuto) 12. if (val == HIGH) 13. digitalwrite(led, HIGH); accende il led else 16. digitalwrite(led, LOW); spegne il led Come potete constatare, oltre all istruzione digitalread() in grado di leggere lo stato di un sensore esterno abbiamo anche l istruzione if e if else. CONTROLLARE UN LED CON UN PULSANTE V.2 Lo scopo di questa nuova lezione è quello di realizzare un circuito simile a quello di un impianto di illuminazione: premo il pulsante accendo la luce, premo una seconda volta e spengo la luce, l esempio 1, ci costringe a mantenere il dito sul pulsante per mantenere acceso il led. Questa è la prima versione del programma che risolve il problema: 1. Accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia 2. premendo una seconda volta il pulsante spegne il led int LED = 13; LED collegato al pin digitale 13 21

22 Data Mar 2017 Ver. 1.3 Pag 22/ int BUTTON = 7; pin di input dove è collegato il pulsante 6. int val = 0; si userà val per conservare lo stato del pin di input 7. int stato = 0; ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso void setup() 10. pinmode(led, OUTPUT); imposta il pin digitale come output 11. pinmode(button, INPUT); imposta il pin digitale come input void loop() 15. val = digitalread(button); legge il valore dell'input e lo conserva controlla che l'input sia HIGH (pulsante premuto) 18. e cambia lo stato del led 19. if (val == HIGH) 20. stato=1-stato; if (stato == 1) 24. digitalwrite(led, HIGH); accende il led else 27. digitalwrite(led, LOW); spegne il led Questo programma merita maggiore attenzione, analizziamolo per passi: Passo 1: pulsante non premuto LED spento Il valore assunto da val è 0 in quanto il pulsante non è premuto (l istruzione digitalread(button); restituisce 0), la condizione logica val == HIGH del primo if restituisce falso e la variabile stato resta al valore iniziale 0. Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l else in cui è presente l istruzione digitalwrite(led, LOW); che spegne il diodo led. Passo 2: pulsante premuto LED acceso Il valore assunto da val è 1 in quanto il pulsante è premuto (l istruzione digitalread(button); restituisce 1), la condizione logica val == HIGH del primo if restituisce vero e la variabie stato viene impostata a stato = 1 0, cioè a 1. Poiché il confronto stato == 1 del secondo if restituisce vero, viene eseguita l istruzione che segue, cioè: digitalwrite(led, HIGH); che accende il diodo led. Passo 3: pulsante premuto LED spento Il valore assunto da val è 1 in quanto il pulsante è premuto (l istruzione digitalread(button); restituisce 1), la condizione logica val == HIGH del primo ifrestituisce vero e la variabie stato viene impostata a stato = 1 1 (stato è stato impostato ad 1 nel passo precedente), cioè a 0. Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l else in cui è presente l istruzione digitalwrite(led, LOW); che spegne il diodo led. ATTENZIONE!: se provate il programma noterete un funzionamento molto strano, potrebbe capitare che premendo e rilasciando il pulsante il led non si accende e si spegne correttamente, ad esempio premo e non si accende oppure se acceso premendo il pulsante non si spegne il led. Ciò è dovuto al fatto che il microcontrollore legge le istruzioni del vostro programma ad una velocità di milioni di istruzioni al secondo ciò vuol dire che la lettura dello stato del pulsante viene letta moltissime volte al secondo e l accensione e lo spegnimento del diodo led potrebbe essere imprevedibile. Per comprendere questa situazione immaginate che al Passo 3 precedente si continui a mantenere premuto il pulsante, noterete che la variabile stato ad ogni ciclo, assume valori diversi che possono portare ad una situazione di accensione o spegnimento del diodo. 22

23 Data Mar 2017 Ver. 1.3 Pag 23/137 Per ovviare a questo problema bisogna riuscire a identificare il momento esatto in cui il pulsante viene premuto e questo può essere fatto conservando in una variabile lo stato del pulsante al passo precedente: 1. Antirimbalzo 2. accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia 3. premendo una seconda volta il pulsante spegne il led int LED = 13; //LED collegato al pin digitale int BUTTON = 7 //pin di input dove è collegato il pulsante 7. int val = 0; //si userà val per conservare lo stato del pin di input 8. int vecchio_val = 0; //si userà vecchio_val per conservare lo stato del pin di input al passo precedente 9. int stato = 0; //ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acces void setup() 12. pinmode(led, OUTPUT); //imposta il pin digitale come output 13. pinmode(button, INPUT); //imposta il pin digitale come input void loop() 17. val = digitalread(button); //legge il valore dell'input e lo conserva //controlla se è accaduto qualcosa 20. if ((val == HIGH) && (vecchio_val == LOW)) 21. stato = 1 - stato; vecchio_val = val; //ricordiamo il valore precedente di val if (stato == 1) 27. digitalwrite(led, HIGH); //accende il led else 30. digitalwrite(led, LOW); //spegne il led In questo caso usiamo la variabile vecchio_val per conservare lo stato al ciclo precedente, in questo modo verifichiamo lo stato effettivo del pulsante verificando se lo stato attuale è pulsante premuto E pulsante non premuto al passo precedente, se la condizione è vera viene modificato lo stato. L operatore booleano utilizzato è AND che nel linguaggio di programmazione si indica con &&. La cosa più bella nell applicare l informatica al mondo reale e che è indispensabile far i conti con le caratteristiche fisiche dei dispositivi su cui operiamo. Non appena aumentiamo la frequenza con cui si preme il pulsante, si ricade in una situazione di incongruenza per cui il LED non risponde più ai comandi. Questo problema avviene perché il pulsante è un apparato meccanico costituito da contatti elettrici ed una molla, quando premiamo e rilasciamo, si manifestano situazioni di rimbalzo del contatto che creano dei segnali non corretti, detti spuri, che modificano lo stato del diodo led. Per risolvere il problema è sufficiente attendere che questi rimbalzi spuri si concludano e quindi bisogna attendere una certa quantità di tempo dopo che è stato rilevato un cambiamento di stato, provate con valori non superiori a 50 millisecondi, nell esempio ho introdotto un valore di 15 millisecondi di ritardo. 1. /*Antirimbalzo2:accendi il LED appena è premuto il pulsante mantenendolo acceso quando si rilascia 2. premendo una seconda volta il pulsante spegne il led */ int LED = 13; //LED collegato al pin digitale int BUTTON = 7; //pin di input dove è collegato il pulsante 6. int val = 0; //si userà val per conservare lo stato del pin di input 23

24 Data Mar 2017 Ver. 1.3 Pag 24/ int vecchio_val = 0; //si userà vecchio_val per conservare lo stato del pin di input al passo prec edente 8. int stato = 0; ricor//da lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso void setup() 11. pinmode(led, OUTPUT); //imposta il pin digitale come output 12. pinmode(button, INPUT); //imposta il pin digitale come input void loop() 16. val = digitalread(button); //legge il valore dell'input e lo conserva //controlla se è accaduto qualcosa 19. if ((val == HIGH) && (vecchio_val == LOW)) 20. stato = 1 - stato; 21. delay(15); //attesa di 15 millisecondi vecchio_val = val; //ricordiamo il valore precedente di val if (stato == 1) 27. digitalwrite(led, HIGH); //accende il led else 30. digitalwrite(led, LOW); //spegne il led Ora come esercizio uniamo ciò che abbiamo imparato nelle prime lezioni. Esercizio Realizzare un programma che esegue questa funzione: quando si preme un pulsante il diodo LED lampeggia, quando premo una seconda volta il pulsante il led termina di lampeggiare: 1. //Esempio 05: led lampeggia se premo il pulsante 2. //premendo una seconda volta il pulsante si spegne il led int LED = 13; // LED collegato al pin digitale int BUTTON = 7; // pin di input dove è collegato il pulsante 6. int val = 0; //si userà val per conservare lo stato del pin di input 7. int vecchio_val = 0; //si userà vecchio_val per conservare lo stato del pin di input al p asso precedente 8. int stato = 0; ricor//da lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso void setup() 11. pinmode(led, OUTPUT); // imposta il pin digitale come output 12. pinmode(button, INPUT); //imposta il pin digitale come input void loop() 16. val = digitalread(button); //legge il valore dell'input e lo conserva controlla se è accaduto qualcosa 19. if ((val == HIGH) && (vecchio_val == LOW)) 20. stato = 1 - stato; 21. delay(15); // attesa di 15 millisecondi vecchio_val = val; //ricordiamo il valore precedente di val if (stato == 1) 27. digitalwrite(led, HIGH); //accende il LED 24

25 Data Mar 2017 Ver. 1.3 Pag 25/ delay(1000); aspetta un secondo 29. digitalwrite(led, LOW); spegne il LED 30. delay(1000); aspetta un secondo else 33. digitalwrite(led, LOW); spegne il led ATTENZIONE: che problema riscontrate? Come potreste risolverlo? TEORIA: RESISTENZE DI PULL-UP E PULL-DOWN Le resistenze di pull-up e pull-down sono usate nei circuiti elettronici per forzare un determinato stato logico in un punto, per eliminare fluttuazioni di corrente o ancora per evitare cortocircuiti quando si usano i pulsanti. Ad esempio vediamo il caso più comune di applicazione di queste resistenze: RESISTENZA DI PULL-UP: in uscita avremo lo stato logico HIGH senza premere il pulsante, premendo il pulsante avremo lo stato logico LOW RESISTENZA DI PULL-DOWN: in uscita avremo lo stato logico LOW senza premere il pulsante, premendo il pulsante avremo lo stato logico HIGH 25

26 Data Mar 2017 Ver. 1.3 Pag 26/137 Il valore tipico della resistenza d ingresso è di 10KOhm. Resistenza di pull-up interna Con Arduino è possibile evitare l uso di resistenze d ingresso ed attivare le resistenze interne, senza necessariamente collegarne una esterna. Di seguito lo schema: Come potete notare non c è la solita resistenza da 10k collegata al pulsante perché sfruttiamo quella interna all'atmega 328. Questo può essere utile nel caso dell'utilizzo di molti ingressi digitali, riducendo la complessità e facilitando lo sbroglio delle piste in un circuito stampato. Per attivare la resistenza di pull-up interna è sufficiente portare a livello alto il pin d ingresso utilizzato: digitalwrite(pin, HIGH); Ecco di seguito un esempio di sketch che utilizza la resistenza interna di pull-up di Arduino. 1. int BUTTON = 7; pin di input dove è collegato il pulsante 2. int LED = 13; pin dove è collegato il led 3. void setup() 4. pinmode(pushbutton, INPUT); modalità input del pulsante 5. digitalwrite(button, HIGH); attivazione della resistenza di pull-up 6. pinmode(led, OUTPUT); definizione del led come output void loop() 9. int buttonstate = digitalread(pushbutton); leggi il pin di ingresso e salvalo nella variabile "buttonstate": 10. if (buttonstate == HIGH) se la variabile "buttonstate" è a livello "alto" accendi il led, altrimenti spegnilo. 11. digitalwrite(led, HIGH); 12. else digitalwrite(led, LOW); 13. delay(100);

27 Data Mar 2017 Ver. 1.3 Pag 27/137 PROGETTO: SEMAFORO Prenderemo in esame la realizzazione di un semaforo utilizzando 4 stati (standard inglese): Ogni lampada deve essere accesa nella sequenza indicata con tempistiche differenti: i LED rosso e verdi verranno mantenuti accesi per 10 sec mentre il giallo 2 sec. Materiale necessario e collegamenti: 1 x Breadboard 1 x LED Rosso 1 x LED Giallo 1 x LED Verde 3 x Resistori 220 Ω Jumper Nello schema di collegamento è possibile vedere che gli anodi dei LED sono collegati ai PIN (8, 9, 10) di Arduino. L uscita alta corrisponderà ad una erogazione di una corrente poiché il circuito è chiuso a massa. 27

28 Data Mar 2017 Ver. 1.3 Pag 28/137 Codice 1. /*Semaforo 2. Rosso pin 8, Giallo pin 9 Verde pin * / const int ledr=8,ledg=9,ledv=10; //dichiarazione variabili void setup() pinmode(ledr, OUTPUT); 10. pinmode(ledg, OUTPUT); 11. pinmode(ledv, OUTPUT); void loop() digitalwrite(ledr, HIGH); //rosso on 18. digitalwrite(ledg, LOW); //giallo off 19. digitalwrite(ledv, LOW); //verde off 20. delay(5000); //attesa di 5000 millisecondi digitalwrite(ledr, HIGH); //rosso on 23. digitalwrite(ledg, HIGH); //giallo on 24. digitalwrite(ledv, LOW); //verde off 25. delay(2000); //attesa di 2000 millisecondi digitalwrite(ledr, LOW); //rosso off 28. digitalwrite(ledg, LOW); //giallo off 29. digitalwrite(ledv, HIGH); //verde on 30. delay(5000); //attesa di 5000 millisecondi digitalwrite(ledr, LOW); //rosso off 33. digitalwrite(ledg, HIGH); //giallo on 34. digitalwrite(ledv, LOW); //verde off 35. delay(2000); //attesa di 2000 millisecondi PROGETTO: SEMAFORO CON ARRAY In questa variante del precedente programma, si è voluto implementare un array per la dichiarazione dei pin di uscita. 1. /*Semaforo 2. Rosso pin 8, Giallo pin 9 Verde pin */ 4. int tempo = 2000; //Tempo di ritardo 5. int led[] = 8, 9, 10; //array dei pin 6. int numeropin = 3; // numero dei pin (lunghezza dell array) 7. void setup() //gli elementi dell array sono numerati da 0 a (numeropin - 1) 10. //ciclo for per impostare i pin come output: 11. for (int i = 0; i < numeropin; i++) pinmode(led[i], OUTPUT); void loop() 18. digitalwrite(led[0], HIGH); //rosso on 28

29 Data Mar 2017 Ver. 1.3 Pag 29/ digitalwrite(led[1], LOW); //giallo off 20. digitalwrite(led[2], LOW); //verde off 21. delay(5000); //attesa di 5000 millisecondi digitalwrite(led[0], HIGH); // rosso on 24. digitalwrite(led[1], HIGH); // giallo on 25. digitalwrite(led[2], LOW); // verde off 26. delay(tempo); // attesa di 2000 millisecondi digitalwrite(led[0], LOW); // rosso off 29. digitalwrite(led[1], LOW); // giallo off 30. digitalwrite(led[2], HIGH); // verde on 31. delay(5000); // attesa di millisecondi digitalwrite(led[0], LOW); // rosso off 34. digitalwrite(led[1], HIGH); // giallo on 35. digitalwrite(led[2], LOW); // verde off 36. delay(tempo); // attesa di 2000 millisecondi PROGETTO: SEMAFORO CON CHIAMATA Rispetto al progetto N 1 si vuole integrare un semaforo pedonale con chiamata manuale. Sarà aggiunto quindi un tasto per la chiamata e due ulteriori LED. L Arduino reagirà alla pressione del tasto cambiando lo stato delle luci in maniera tale da fermare le auto e permettere ai pedoni di attraversare la strada. In questo progetto si interagirà con Arduino con la pressione del tasto. Questo evento modificherà lo stato del tasto e sarà subito visibile un cambiamento. Vediamo il materiale occorrente: Breadboard 2 x LED Rosso 1 x LED Giallo 3 x LED Verde 5 x Resistori 3220 Ω Jumper Switch Schema di collegamento: 29

30 Data Mar 2017 Ver. 1.3 Pag 30/137 In questo caso si sono spostati i PIN (che stavolta sono 12, 11, 10) dei LED relative al semaforo per le auto e si sono aggiunti ulteriori due PIN (12 e 11) per i LED del semaforo pedonale. Inoltre, il pulsante è stato collegato al PIN 2. Il codice è molto simile al precedente. Quando il programma viene avviato, il semaforo per le auto è sul verde mentre il semaforo pedonale è sul rosso. Quando viene premuto il pulsante, il programma controlla che siano passati almeno 5 secondi dall ultima volta anche avvenuto un cambiamento di stato. Questo per permettere al traffico di scorrere. Codice 1. /* 2. Semaforo con chiamata pedonale 3. Rosso pin 8, Giallo pin 9 Verde pin 10 RP pin 11 VP pin */ int led[] = 8, 9, 10, 11, 12 ; //array dei pin 7. int numeropin = 5; //numero dei pin (lunghezza dell array) 8. const int button = 2; 9. int stato = 0; void setup() //gli elementi dell array sono numerati da 0 a (numeropin - 1) 14. //ciclo for per impostare i pin come output for (int i = 0; i < numeropin; i++) pinmode(led[i], OUTPUT); pinmode(button, INPUT); void loop() digitalwrite(led[0], LOW); //rosso off 26. digitalwrite(led[1], LOW); //giallo off 27. digitalwrite(led[2], HIGH); //verde on 28. digitalwrite(led[3], HIGH); //RP on 29. digitalwrite(led[4], LOW); //VP off stato = digitalread(button); if (stato == LOW)

31 Data Mar 2017 Ver. 1.3 Pag 31/ digitalwrite(led[0], LOW); //rosso off 36. digitalwrite(led[1], HIGH); //giallo on 37. digitalwrite(led[2], LOW); //verde off 38. delay(2000); //attesa di 1000 millisecondi digitalwrite(led[0], HIGH); //rosso on 41. digitalwrite(led[1], LOW); //giallo off 42. digitalwrite(led[2], LOW); //verde off 43. delay(500); 44. digitalwrite(led[3], LOW); //RP off 45. digitalwrite(led[4], HIGH); //VP on 46. delay(3000); //attesa di 2000 millisecondi digitalwrite(led[0], HIGH); //rosso on 49. digitalwrite(led[1], HIGH); //giallo on 50. digitalwrite(led[2], LOW); //verde off 51. delay(3000); 52. digitalwrite(led[3], HIGH); //RP on 53. digitalwrite(led[4], LOW); //VP off 54. delay(500); //attesa di 1000 millisecondi Alternativa N 2: presentiamo qui di seguito un codice alternativo che introduce due elementi essenziali: attende 5 secondi prima che il pulsante possa essere premuto nuovamente il verde pedonale lampeggia 10 volte prima di passare al rosso 1. int carred = 8; // assegnazione pin per il semaforo 2. int caryellow = 9; 3. int cargreen = 10; 4. int pedred = 11; //assegnazione pin per il semaforo pedonale 5. int pedgreen = 12; 6. int button = 2; //button pin 7. int crosstime = 5000; //tempo concesso per l attraversamento 8. unsigned long changetime; //tempo trascorso dalla pressione del tasto 9. void setup() 10. pinmode(carred, OUTPUT); 11. pinmode(caryellow, OUTPUT); 12. pinmode(cargreen, OUTPUT); 13. pinmode(pedred, OUTPUT); 14. pinmode(pedgreen, OUTPUT); 15. pinmode(button, INPUT); 16. digitalwrite(cargreen, HIGH); 17. digitalwrite(pedred, HIGH); void loop() 20. int state = digitalread(button); //controlla se il pulsante è premuto 21. if (state == HIGH && (millis() - changetime) > 5000) 22. //cambia lo stato solo se sono passati 5 sec dall ultima volta changelights(); //chiama la funzione per l avvio della funzionalità semaforo void changelights() 30. digitalwrite(cargreen, LOW); 31. digitalwrite(caryellow, HIGH); 32. delay(2000); 33. digitalwrite(caryellow, LOW); 34. digitalwrite(carred, HIGH); 35. delay(1000); 36. digitalwrite(pedred, LOW); 37. digitalwrite(pedgreen, HIGH); 38. delay(crosstime); 39. for (int x=0; x<10; x++) //lampeggia il verde pedonale 40. digitalwrite(pedgreen, HIGH); 41. delay(250); 31

32 Data Mar 2017 Ver. 1.3 Pag 32/ digitalwrite(pedgreen, LOW); 43. delay(250); digitalwrite(pedred, HIGH); //accende il rosso pedonale 46. delay(500); 47. digitalwrite(caryellow, HIGH); 48. digitalwrite(carred, LOW); 49. delay(1000); 50. digitalwrite(cargreen, HIGH); 51. digitalwrite(caryellow, LOW); 52. changetime = millis(); //registra il tempo dall ultimo cambiamento semaforico //ritorno al programma principale in loop

33 Data Mar 2017 Ver. 1.3 Pag 33/137 I/O ANALOGICI TEORIA: USCITE ANALOGICHE Quasi tutte le schede Arduino hanno 14 pin digitali: sono pin che puoi utilizzare sia in modo INPUT (ingresso), per acquisire il valore di un pulsante ad esempio o di un interruttore a leva, sia in modo OUTPUT (uscita) per inviare segnali logici ad una scheda aggiuntiva, ad un led, ecc Poiché si tratta di impulsi di tipo digitale il valore che si può ricevere inviare è il classico 0 1 o, in linguaggio, Arduino LOW HIGH. Rilevare un valore LOW (0) equivale a dire che sul pin che si sta controllando è arrivato un segnale logico basso di 0 V, viceversa ricevere HIGH (1) equivale a dire che il pin ha ricevuto un segnale logico alto 5 V. Il ragionamento appena fatto è valido anche in caso di utilizzo dl pin come OUTPUT, ossia per inviare segnali. Come abbiamo già visto, per definire un dato pin si usa il seguente comando: pinmode(pin, modalità) dove pin indica il numero del pin che vogliamo settare con la modalità definita nel secondo parametro, modalità: INPUT o OUTPUT. Per inviare un segnale al pin si utilizza il comando: digitalwrite(pin,level) dove pin indica sempre il numero del pin a cui vogliamo inviare il segnale definito nel secondo parametro, level: LOW o HIGH (0 o 1). Per leggere un valore digitale, magari quello di un interruttore collegato a massa, si utilizza il comando pin- Mode con modalità INPUT, ed il comando digitalread(pin) dove pin indica il numero del pin di cui vogliamo conoscere il valore. Alcuni degli pin digitali presentano la sigla PWM, identificata con un segno di tilde (~), I PWM sono segnali impulsivi nei quali è possibile variare il duty cycle (percentuale del periodo che viene mantenuta al livello logico alto). Con tali segnali si possono pilotare dei servocomandi da modellismo oppure LED con dissolvenza. Il segnale PWM accetta come valori da 0 a 255, per ciascun valore varia il duty-cycle generato, ad esempio con il valore 0 si ottiene un valore di duty-cycle dello 0% ossia sempre 0 in modo analogo a quello ottenuto utilizzando digitalwrite(pin,low). Ricordate sempre di settare la modalità del pin prima di eseguire l invio dei comandi, in questo esempio si è utilizzato il pin 11 scrivendo: pinmode(11,output) indicando ad Arduino di utilizzarlo in modo OUTPUT si può quindi inviare il segnale con duty-cycle al 50%: analogwrite(11,127), il valore 127 è esattamente a metà della scala (0 255), quindi il duty-cycle generato sarà del 50%. Per comprendere meglio la questione duty-cycle osserviamo la seguente immagine: Se invece volessimo leggere un segnale analogico, Arduino ha N 6 pin dedicati (A0-A5). Tali pin sono solo di input, ossia questi pin servono principalmente per acquisire dei segnali provenienti da sensori di tipo analogico: trimmer, potenziometri, fororesistenze, ultrasuoni, IR, ecc tutti quei sensori che possono generare un segnale analogico in funzione della loro stimolazione (luminosa, meccanica, ecc). Non è necessario settare questi pin con la modalità essendo solo pin di input Arduino sa già come utilizzarli. Per leggere il valore presente sul pin 5, ad esempio, si utilizza il comando: analogread(pin) à analogread(5) Il convertitore analogico digitale su Arduino UNO è da 10 bit, per cui il valore rilevato, che può variare da 0 V a 5 V, verrà convertito in un valore numerico da 0 a All interno del range indicato ogni variazione del segnale sarà indicata con una variazione di tale valore. 33

34 Data Mar 2017 Ver. 1.3 Pag 34/137 LED IN DISSOLVENZA In questo esempio si utilizza uno degli sketch forniti ad esempio dall IDE Arduino: Fade. Per trovare questo esempio basta andare nel menu File -> Esempi -> Basics -> Fade. Il circuito è lo stesso relativo all esempio del blink, stavolta abbiamo collegato il LED al pin 9 in quanto avremo bisogno del segnale PWM. Come è possibile notare, il piedino 13 non mostra la tilde ~. Il file mostra il seguente listato: 1. /* 2. Fade This example shows how to fade an LED on pin 9 5. using the analogwrite() function This example code is in the public domain. 8. * / int led = 9; //the pin that the LED is attached to 11. int brightness = 0; //how bright the LED is 12. int fadeamount = 5; //how many points to fade the LED by //the setup routine runs once when you press reset: 15. void setup() 16. //declare pin 9 to be an output: 17. pinmode(led, OUTPUT); //the loop routine runs over and over again forever: 21. void loop() 22. //set the brightness of pin 9: 23. analogwrite(led, brightness); //change the brightness for next time through the loop: 26. brightness = brightness + fadeamount; //reverse the direction of the fading at the ends of the fade: 29. if (brightness == 0 brightness == 255) 30. fadeamount = -fadeamount ; //wait for 30 milliseconds to see the dimming effect 33. delay(30); Analizziamo riga per riga il codice: linee 1-9: commento multilinea, indica lo scopo del programma e definisce sempre in ultima riga la possibilità di utilizzare liberamente questo codice. linea 10: imposta una variabile di tipo intero (integer) in cui memorizzerà il valore di luminosità raggiunto del led nel corso del ciclo di loop, la definizione di una variabile di questo tipo (integer) do- 34

35 Data Mar 2017 Ver. 1.3 Pag 35/137 vrebbe essere chiaro, utilizza int nome_variabile = valore; linea 11: imposta una variabile per l intensità luminosa iniziale del LED linea 12: imposta una variabile di tipo intero (integer) preimpostata a 5 che rappresenta l incremento di luminosità che il led raggiungerà ad ogni ciclo (loop) linee 15-18: definizione della funzione setup() in cui imposta il pin 9 come pin di tipo OUTPUT: pin- Mode(9, OUTPUT) linea 21: definizione della funzione loop() linea 23: il comando analogwrite imposta il duty-cycle 0 al piedino 9, il duty-cycle è 0 in quanto brightness non è stato ancora variato dalla sua inizializzazione. linea 26: incrementa il valore della variabile brightness del valore di fadeamount ad ogni ciclo la variabile brightness si incrementa di un valore 5 fino a raggiungere il valore 255, come vedrai alla linea 26. linea 29: esegue un doppio test sulla variabile brightness confrontandola sia con il valore 0 che con il valore massimo che possiamo passare al comando analogwrite: 255; il confronto in Arduino si può effettuare con il comando if e utilizzando l operatore OR la cui rappresentazione nella sintassi del linguaggio Arduino è il ; al raggiungimento del valore 0 o del valore 255 esegue quanto alla linea successiva. linea 30: inverte il segno della variabile fadeamount, questo trucco comporta che ai successivi cicli quando eseguirà i comandi alla linea 26: brightness = brightness + fadeamount; in realtà esegue una operazione del tipo brightness = brightness + ( -fadeamount ); decrementando invece di incrementare il valore di luminosità (brightness) al raggiungimento della soglia 0 il valore di fadeamount viene nuovamente invertito. linea 33: introduce un tempo di attesa di 30 millisecondi prima di ripetere il ciclo. Il circuito realizzato è molto semplice, il terminale positivo di un led è collegato al pin 9 della scheda Arduino, ed il terminale negativo del led alla massa (GND) della scheda Arduino interponendo una resistenza da 470 ohm per proteggere il led. LEGGERE UN SEGNALE ANALOGICO Con questo esempio impareremo a leggere lo stato analogico da un potenziometro collegato all alimentazione di Arduino. Il potenziometro sarà collato all ingresso A2 analogico, il risultato della conversione analogico digitale sarà rappresentata tramite monitor seriale. Come si vede in figura il collegamento del potenziometro è molto semplice: si collegano gli estremi del potenziometro (quelli su cui è sempre presente una resistenza di 10K ohm indipendentemente dalla posizione della manopola) rispettivamente al +5V e GND di Arduino, non è importante quale va al +5V e quale al pin GND. Collegare, quindi, il terminale centrale del potenziometro al pin A2 (ossia il pin 2 analogico). Il codice che utilizzeremo per i nostri esperimenti è il seguente: 35

36 Data Mar 2017 Ver. 1.3 Pag 36/ /* AnalogReadSerial Reads an analog input on pin 2, prints the result to the serial monitor This example code is in the public domain. */ void setup() Serial.begin(9600); void loop() int sensorvalue = analogread(a2); Serial.println(sensorValue, DEC); Analizziamo le linee di codice: linea 11: si inizializza la comunicazione seriale a 9600 baud linea 15: utilizzando una sintassi compressa (dichiarazione delle variabili all interno della riga), si dichiara la variabile sensorvalue impostandone il valore con il risultato letto sul pin 2 analogico. Per leggere il valore del pin 0 analogico si utilizza il comando analogread(a2), NOTA: il comando analogread leggerà ad ogni ciclo della funzione loop il valore analogico rilevato sul pin A2; tale valore varia tra 0 e linea 16: il comando Serial.println(sensorValue, DEC) scrive sul canale seriale di Arduino che mostra i risultati nel monitor seriale. Non resta che inviare lo sketch ad Arduino, aprire il monitor seriale dell IDE e provare a spostare la manopola del potenziometro tutta da un lato leggendo il valore rilevato (ad es: 0) e ruotando la manopola osservare il valore aumentare fino a 1023 giungendo alla fine dell escursione del potenziometro. TEORIA: LA FOTORESISTENZA Le fotoresistenze (o fotoresistori) sono resistenze composte da uno strato semiconduttore che reagisce alla radiazione luminosa, sia quest ultima emessa dal sole o da altra fonte luminosa. Il funzionamento di una fotoresistenza è piuttosto intuitivo: varia il suo valore da 0Ω alla sua resistenza massima 10, 50, 100KΩ, in base al tipo di fotoresistenza, quando passa dalla condizione di illuminazione piena a buio. In pratica se la luce è sufficientemente forte il suo valore in ohm è 0, via via che la luce diminuisce il suo valore aumenta fino alla resistenza massima. Alcuni modelli, come la LDR 2-20KΩ o la LDR 20-50KΩ, dopo 10 secondi di buio arrivano a livelli di resistenza molto elevati, quasi una interruzione di continuità: 36

37 Data Mar 2017 Ver. 1.3 Pag 37/137 e la LDR KOhm: Ecco come utilizzare una fotoresistenza. Prima di tutto occorre realizzare un partitore di tensione: Il principio di funzionamento è il seguente: due resistenze, di eguale valore, collegate come nello schema dividono in parti uguali la tensione erogata dalla batteria, nel punto B si misurerà Va 2, in questa configurazione R 1 ed R 2 devono essere identiche. Se al posto di R 1 si inserisce la LDR 20-50KΩ e al posto di R 2 una resistenza fissa da 50KΩ, si realizza un partitore di tensione in cui uno dei due elementi è variabile, e varia in funzione della luce che lo irradia. Quando la fotoresistenza è colpita dalla massima luce, ai suoi capi presenterà la minima resistenza, per cui al punto B si troverà esattamente quasi Va (lavorando con Arduino diremo +5V), d altra parte quando ci sarà buio al punto B ci sia aspetta di avere Va 2 = 5V 2 = 2,5V. 37

38 Data Mar 2017 Ver. 1.3 Pag 38/137 MISURA DEL VALORE DI UNA FOTORESISTENZA Questo tutorial riguarda la possibilità di misurare l intensità della luce con una semplice fotoresistenza, Arduino ed una resistenza di 50KΩ o simile. Il risultato della lettura verrà mostrato sul monitor seriale. Materiale necessario: 1 Arduino Uno 1 fotoresistenza da 50KΩ (LDR 20-50KΩ) 1 resistenza da 50KΩ 1 breadboard cavetti per breadboard Collegare tutto come nello schema sopra dove al posto della resistenza R 1 si inserisce la fotoresistenza, al posto di R 2 la resistenza fissa da 50KΩ e si collega il punto A al +5V di Arduino, B al pin A0 (Analogic input 0 di Arduino) e il negativo alla massa di Arduino. Lo sketch: 1. int analogpin = A0; //dichiarazione della variabile con ingresso analogico 2. int sensorvalue = 0; //impostazione della variabile del sensore a livello void setup() 5. Serial.begin(9600); //inizializzazione della porta seriale 6. pinmode(analogpin, INPUT); //impostazione di A0 come input, potrebbe essere omesso void loop() 10. sensorvalue = analogread(analogpin); //legge il segnale all ingresso analogico Serial.print("Sensor = " ); //Stampa una frase sul monitor seriale 13. Serial.println(sensorValue); //stampa il valore dopo la conversione digitale 14. delay(1000); //attende 1 sec prima di effettuare una nuova lettura 15. In particolare: linea 10: con la funzione analogread(pin) leggi il segnale presente sul pin A0 e assegnalo alla variabile definita alla linea 09; linea 13: scrivi sul monitor seriale il valore letto dal pin A0, la differenza tra il metodo print ed il metodo println è che quest ultimo dopo aver scritto il contenuto sul monitor seriale invia anche un segnale di a capo che sposta il cursore sulla linea successiva del monitor seriale; 38

39 Data Mar 2017 Ver. 1.3 Pag 39/137 Come funziona e cosa si leggerà sul monitor seriale Dopo aver caricato lo sketch su Arduino, aprire il monitor seriale e rivolgere la fotoresistenza verso una forte fonte di luce, il valore che si leggerà è il seguente: sensor = 1023 o poco meno, questo perché con la radiazione luminosa massima la resistenza è 0 Ω e il valore convertito dall ADC di Arduino è corrispondente al +5V ossia il valore in bit massimo Se si sposta la fonte luminosa o si copre la fotoresistenza in modo che percepisca il buio si vedrà che il valore rilevato si abbassa fino a raggiungere circa 512, ossia (vedi descrizione del partitore sopra). TEORIA: STRUTTURE DI CONTROLLO 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 - 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); 39

40 Data Mar 2017 Ver. 1.3 Pag 40/137 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; ESEMPIO DI STRUTTURA SWITCH CASE In questo tutorial verrà mostrato come utilizzare la funzione switch per accendere diversi led dalla ricezione di informazioni seriali. Lo sketch ascolta dati in ingresso seriali e accende diversi led per i caratteri a, b, c, d, oppure e. Cinque led sono collegati ai piedini 2, 3, 4, 5, and 6 in serie con resistenze da 220 Ω. 40

41 Data Mar 2017 Ver. 1.3 Pag 41/137 Ecco il codice: 1. int pin; 2. int inbyte void setup() Serial.begin(9600); //inizializza la comunicazione seriale 7. for (pin = 2; pin < 7; pin++) //inizializza il pin di uscita con un ciclo for 8. pinmode(pin, OUTPUT); void loop() 12. if (Serial.available() > 0) //legge l input seriale 13. inbyte = Serial.read(); //legge il valore dell ingresso seriale switch (inbyte) //avvio della struttura switch case 16. case 'a': 17. digitalwrite(2, HIGH); //attiva il led sul pin break; 19. case 'b': 20. digitalwrite(3, HIGH); //attiva il led sul pin break; 22. case 'c': 23. digitalwrite(4, HIGH); //attiva il led sul pin break; 25. case 'd': 26. digitalwrite(5, HIGH); //attiva il led sul pin break; 28. case 'e': 29. digitalwrite(6, HIGH); //attiva il led sul pin break; for (pin = 2; pin < 7; pin++) //ciclo che spegne tutti i LED 33. digitalwrite(thispin, LOW); 34. TEORIA: FUNZIONE MAP La funzione map rimappa un numero da un intervallo ad un altro. La sintassi è la seguente: map(value, fromlow, fromhigh, tolow, tohigh) Si indica il valore dalla variabile che conterrà il valore da rimappare (value), poi si scrive il valore minimo (fromlow) e massimo (fromhigh), a seguire il valore minimo (tolow) e massimo (tohigh) dopo la rimappatura. Tutti i valori intermedi saranno automaticamente calcolati dalla funzione map. Facciamo un esempio. Supponiamo di voler usare un potenziometro per regolare il fade di un LED. Poichè il potenziometro restituirà valori da 0 a 1023 (int potvalue) mentre il valore PWM va da 0 a 255, possiamo usare la funzione map per rimappare il valore della variabile (int ledvalue) che poi verrà utilizzata per accendere il LED. ledvalue = map(potvalue, 0, 1023, 0, 255) 41

42 Data Mar 2017 Ver. 1.3 Pag 42/137 3 LED (LED RGB) E 3 POTENZIOMETRI Il funzionamento è semplice ma il risultato empirico che ne deriva è molto utile e servirà in molti progetti con i led RGB. Lo scopo di questo esperimento è individuare il bianco composto dalla combinazione dei 3 colori RGB (Red, Green, Blu), si potrebbe procedere per tentativi successivi modificando i valori PWM che invii ad Arduino ma ogni cambio comporterebbe un nuovo upload, riducendo il numero complessivi di esperimenti possibili con Arduino in futuro e costringendoti a lunghe attese tra una prova e l altra. Occorrente: 1 arduino UNO 1 led RGB a catodo ( ) comune 1 resistenza da 470Ω 3 potenziometri da 10KΩ 1 breadboard cavetti per realizzare il circuito Il LED RGB è collegato con una sola resistenza da 470Ω in serie al catodo e inviando +5v a tutti e tre i pin RGB la risultante è rossa e non bianco. Lo sketch è il seguente: 1. void setup() Serial.begin( 9600 ); pinmode( A0, INPUT ); //impostazione dei pin analogici come input 6. pinmode( A1, INPUT ); 7. pinmode( A2, INPUT ); 8. pinmode( 3, OUTPUT ); //impostazione dei pin PWM di uscita 9. pinmode( 5, OUTPUT ); 10. pinmode( 6, OUTPUT ); void loop() int R = map( analogread( A0 ),0,1023,0,255 ); //funzione map per i potenziometri 16. int G = map( analogread( A1 ),0,1023,0,255 ); 17. int B = map( analogread( A2 ),0,1023,0,255 ); Serial.print( "R: " ); //visualizzazione dei valori letti dal potenziomentro 20. Serial.print( R ); 21. Serial.print( " G: " ); 22. Serial.print( G ); 23. Serial.print( " B: " ); 24. Serial.println( B ); analogwrite( 3, R ); //scrittura dei valori letti dal potenziometro 27. analogwrite( 5, G ); 28. analogwrite( 6, B ); 42

43 Data Mar 2017 Ver. 1.3 Pag 43/ delay(500); Poichè vi è una sola resistenza sul LED RGB, non è banale che il colore bianco si raggiunga con la massima intensità di tutti e tre i LED. Infatti, è possibile notare, che qualora tutti i valori delle uscite analogiche siano al massimo, il colore risultante è tendente al rosso. In diverse prove si è constatato che il colore bianco si raggiunge con i seguenti valori: Red = 100; Green=255; Blue=255; e che proporzionalmente è possibile ottenere un effetto dissolvenza del bianco riducendo proporzionalmente i tre valori fino allo 0; LCD DISPLAY CON ARDUINO LCD 16X2 Con Arduino è possibile pilotare un display LCD di diverse dimensioni. Il più utilizzato ha sigla ACM1602B della Zettler (XIAMEN ZETTLER ELECTRONIC Co.) e fornito nello starter kit con Arduino UNO Rev 3. Per far funzionare il display avremo bisogno di richiamare una libreria che lavora con tutti gli LCD che sono compatibili con il driver HITACHI HD44780 Di seguito lo schema di collegamento del display LCD: Ecco la piedinatura riportata sul datasheet: Pin Utilizzo - BL - + BL + 14 DB7 13 DB6 12 DB5 11 DB4 10 DB3 9 DB2 8 DB1 7 DB0 6 E (Enable) 43

44 Data Mar 2017 Ver. 1.3 Pag 44/137 Pin Utilizzo 5 R W (modalità di funzionamento Read Write) 4 RS 3 V0 (Contrasto) 2 VCC (+5v) 1 VSS ( Gnd) Il datasheet mostra una sequenza dei pin da 1 a 14 e poi i successivi due per la retroilluminazione, nella realtà i pin per la retroilluminazione sono i primi due a destra, invertiti rispetto al datasheet, e poi si parte con il pin 1 e non con il 14. Si può collegare l LCD facilmente ad Arduino seguendo lo schema, partendo da destra il primo pin si può collegare al positivo +5V, il secondo al polo negativo. pin 1: è da collegare a massa ( GND ); pin 2: all alimentazione VCC (+5v); pin 3: va collegato al cursore del potenziometro da 10KΩ i cui estremi vanno collegati uno al polo positivo ed uno al polo negativo; pin 4: è il pin RS che va collegato al pin 12 di Arduino; pin 5: definisce se la modalità di funzionamento deve essere di lettura o scrittura, si collega a massa (GND) per metterlo in modalità scrittura; pin 6: abilita il funzionamento del display, va collegato al pin 11 di Arduino; pin 11-14: sono i pin del segnale Data 4,5,6 e 7 e vanno collegati rispettivamente ai pin 5,4,3 e 2 di Arduino, ovviamente si può collegare sia questi che i pin 4 e 6 del display ad altri pin di Arduino se il progetto costringe a non poter utilizzare quelli suggeriti, tale modifica si deve variare anche nello sketch di esempio quando si inizializza l oggetto LCD. Si riporta per completezza l esempio Hello World dell IDE Arduino: #include <LiquidCrystal.h> //include la libreria specifica per il controllo del display LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() //inizializza la libreria con i pin corrispondenti lcd.begin(16, 2); //setta il numero di colonne e di righe relative all LCD scelto lcd.print("hello, world!"); //stampa un messaggio sull LCD void loop() lcd.setcursor(0, 1); //setta il cursore sulla colonna 0 e la riga 1 lcd.print(millis() 1000); //stampa il numero di secondi dall ultimo reset 44

45 Data Mar 2017 Ver. 1.3 Pag 45/137 SENSORI SENSORE DI TEMPERATURA LM35: TERMOMETRO CON DISPLAY Una volta conosciuti gli ingressi analogici e l installazione di un display, lo scopo del progetto è realizzare un termometro digitale con Arduino. La temperatura verrà prelevata con il sensore di temperatura LM35 e dovrà essere visualizzata su un display LCD e aggiornata ogni secondo. Il sensore utilizzato è un LM35 che presenta n.3 terminali: uno per l alimentazione, uno di massa e uno per l uscita della tensione proporzionale alla temperatura rilevata che è pari a 10mV per ogni grado centigrado. Precisione ±0.5 C Sensibilità 10 mv/ C Temperatura Massima 155 C Temperatura minima -55 C Tensione tipica di funzionamento Tipo di uscita 4-30 V Analogica Come abbiamo già visto, Arduino è dotato di un convertitore AD a 10bit (1024 bit) e alla tensione di alimentazione di 5V corrisponde una risoluzione di 5/1024= v (cioè circa 5mV). Poiché l LM35 fornisce in uscita 10mV per grado, si può dedurre che la max precisione è di circa 0.5 gradi (5 10). Per ottenere la temperatura in gradi Celsius si determinano dapprima i millivolts con la formula: millivolt = (sensor/1024)*5000 sensor: è il valore sul pin analogico dove è collegato il sensore; 5000: è il valore della tensione di alimentazione in millivolt; 1023: è il valore fornito dal convertitore AD alla tensione di 5V Poi si determinano i gradi Celsius con la formula: 45

46 Data Mar 2017 Ver. 1.3 Pag 46/137 celsius = millivolt/10 questo poiché come detto l LM35 fornisce 10mV per grado. (10mV à 1 C). Vediamo come scrivere il programma: #include <LiquidCrystal.h> #define LM35 A0 //Libreria per pilotare il display LCD //Dichiarazione della variabile di lettura analogica float val; //Dichiarazione della variabile associata alla lettura analogica float temp; //Variabile di conversione in gradi Celsius LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Inizializzazione dei piedini dell'lcd void setup() analogread(lm35); lcd.begin(16, 2); Prima lettura a vuoto per stabilizzare l'adc //inizializzazione dell LCD 16x2 void loop() val = analogread(lm35); temp = (val/1023) * 5000; temp = temp/10; //si effettua la proporzione tra la scala di 1024 e i 5 V lcd.clear(); //pulisce lo schermo LCD lcd.setcursor(0,0); //cursore in posizione di home: prima colonna, prima riga lcd.print("temperatura "); lcd.setcursor(0,1); lcd.print(temp,1); //Stampa la parte intera e un decimale della variabile temp lcd.print(' '); //Stampa uno spazio lcd.print((char)223); //Stampa ' ' lcd.print('c'); delay(500); Per migliorare la conversione analogico-digitale è meglio adoperare una tensione di riferimento di 1,1 V. Ciò significa che bisogna dividere il valore massimo di 1,1 V per 1024, quindi si avranno passi di circa 1,0742. Per cui, se ogni grado centigrado di variazione corrisponde a 10 mv è necessario compiere la divisione 10 1,0742 = 9,31. Questo rappresenta il passo di variazione della temperatura di un grado centigrado. In tal modo avremo na migliore accuratezza della conversione. In Arduino, per avere un riferimento analogico possiamo intraprendere due strade: 1. Riferimento esterno: si utilizza il piedino AREF (sopra il piedino 13) con un potenziale esterno 2. Riferimento interno: tramite il comando analogreference(internal) che per default corrisponde a 1,1V (ATTENZIONE: vale solo per Arduino UNO) La porzione modificata di sketch è la seguente: float temp; //dichiarazione della variabile con virgola mobile int sensore; //dichiarazione di variabile per la lettura dal sensore int lm35 = 0; //inizializzazione del pin A0 per la lettura analogica (come #define) void setup() analogreference(internal); //riferimento interno a 1,1V void loop() sensore = analogread(lm35); //lettura del sensore temp=sensore/9.31; //conversione in gradi centigradi Un altro esempio di programma che prende in considerazione il riferimento interno è il seguente (a meno delle dichiarazioni iniziali): 46

47 Data Mar 2017 Ver. 1.3 Pag 47/137 void setup() lcd.begin(16, 2); //impostazione del numero di colonne e righe del display LCD lcd.setcursor(0, 0); //sposta il cursore sulla 1 riga (0) e sulla 1 colonna lcd.print("temperatura:"); //stampa il messaggio 'Temperatura:' /*Imposta Vref dell'adc a 1,1V (per una maggiore precisione nel calcolo della temperatura) IMPORTANTE: se si utilizza Arduino Mega sostituisci INTERNAL con INTERNAL1V1 */ analogreference(internal); void loop() //Calcolo la temperatura temp = 0; for (byte i = 0; i < 5; i++) //Esegue l'istruzione successiva 5 volte temp += (analogread(pintemp) 9.31); //Calcola la temperatura e la somma a 'temp' temp /= 5; //Calcola la media matematica dei valori di temperatura /*===========================================* *Visualizzo la temperatura sul display LCD =============================================*/ lcd.setcursor(0, 1); //Sposto il cursore sulla prima colonna e sulla seconda //riga del display LCD lcd.print(temp); //Stampo sul display LCD la temperatura lcd.print(" "); //Stampo uno spazio lcd.print((char)(223)); //Stampo il carattere lcd.print("c"); //Stampo il carattere 'C' *===========================================* delay(1000); Ritardo di un secondo SENSORE DI TEMPERATURA E UMIDITÀ DHT11 Il DHT11 è un sensore di temperatura e umidità con uscita dei dati in formato digitale. Il sensore è munito di un piccolo involucro ed è disponibile montato su basetta (3 pin) oppure nudi (4 pin). Il sensore utilizza una tecnica digitale esclusiva che unita alla tecnologia di rilevamento dell'umidità, ne garantisce l'affidabilità e la stabilità. I suoi elementi sensibili sono connessi con un processore 8-bit singlechip. Ogni sensore di questo modello è compensato in temperatura e calibrato in un'apposita camera di calibrazione che determina in modo preciso il valore di calibrazione il cui coefficiente viene salvato all'interno della memoria OTP. Le sue piccole dimensioni e suo basso consumo unite alla lunga distanza di trasmissione (20 m) permettono al sensore DHT11 di essere adatto per molti tipi di applicazioni. Il package con quattro pin in linea ne rendono facile la connessione. 47

48 Data Mar 2017 Ver. 1.3 Pag 48/137 Il sensore, per funzionare ha bisogno della libreria DHT.h, inclusa nell IDE Arduino. Per connettere il sensore ad Arduino bisogna eseguire il cablaggio seguente collegando una resistenza da 10 KW: Di seguito un esempio di sketch: #include "DHT.h" //viene inclusa la libreria per utilizzare il sensore DHT11 #define DHTPIN 2 //pin di arduino a cui connetto il sensore #define DHTTYPE DHT11 //DHT 11 DHT dht(dhtpin, DHTTYPE); //definisce pin e tipo di sensore void setup() Serial.begin(9600); //inizializzo la comunicazione seriale Serial.println("Test Sensore DHT11!"); Serial.println(""); //vado a capo grazie all'aggiunta di ln dopo Serial.println dht.begin(); //inizializzo la comunicazione del sensore void loop() //La lettura di temperatura e umidità richiede circa 250 millisecondi! //Con sensori vecchi puo capitare di richiedere tempi fino a 2 secondi float h = dht.readhumidity(); //attribuisco alla variabile h l'umidità float t = dht.readtemperature(); // attribuisco alla variabile t la temperatura /*controllo l'avvenuta comunicazione, ed avvio la scrittuta dei dati sulla seriale, ed in cas o negativo scrivo che è fallita /* if (isnan(t) isnan(h)) Serial.println("Errore lettura sensore DHT FALLITA"); else Serial.print("Umidita': "); //Scrivo Umidita': Serial.print(h); //scrivo il valore di umidità Serial.print(" % t"); //scrivo la % e faccio in modo, tramite t, che il prossimo valore sia scritto più staccato a dx Serial.print("Temperatura: "); //scrivo Temperatura: Serial.print(t); //scrivo il valore di temperatura Serial.println(" *C"); //scrivo l'unita' di misura Serial.println(""); //vado a capo grazie all'aggiunta di ln dopo Serial.println delay(2000); //ricomincio il ciclo dopo 2 secondi 48

49 Data Mar 2017 Ver. 1.3 Pag 49/137 SENSORE AD ULTRASUONI Misurare la distanza con un sensore ad ultrasuoni hc-sr04 può essere utile in molte occasioni, ad esempio in un sistema anti-intrusione che deve far suonare un allarme o un sistema robotizzato che deve evitare ostacoli. In questo tutorial viene utilizzato il sensore ad ultrasuoni HC-SR04, dispositivo economico e con un buon range operativo. I sensori ad ultrasuoni non forniscono direttamente la misura della distanza dell oggetto più vicino, ma misurano il tempo impiegato da un segnale sonoro a raggiungere l oggetto e ritornare al sensore. L impulso ad ultrasuoni inviato dal HC-SR04 è di circa 40KHz il tempo viene misurato in microsecondi, la tensione di funzionamento è di 5V, quindi potremo alimentarlo direttamente utilizzando Arduino. Il sensore HC-SR04 dispone di 4 pin: 1. Vcc (+5V) 2. Trigger 3. Echo 4. GND Si invia un impulso alto sul pin Trigger per almeno 10 microsecondi, a questo punto il sensore invierà il ping sonoro e aspetterà il ritorno delle onde riflesse, il sensore risponderà sul pin Echo con un impulso alto della durata corrispondente a quella di viaggio delle onde sonore, dopo 38 millisecondi si considera che non sia stato incontrato alcun ostacolo. Per sicurezza si aspettano in genere millisec per far si che non vi siano interferenze con la misura successiva. Per convertire l'intervallo di tempo misurato in una lunghezza, bisogna ricordare che la velocità del suono è di 331,5 m/s a 0 C e di 343,4 m/s a 20 C ed in generale varia secondo la relazione v = 331,4 + 0,62 T dove la temperatura T è misurata in C. Per la realizzazione del nostro metro elettronico assumiamo di lavorare ad una temperatura ambiente di 20 C e quindi la velocità del suono sarà di 343 m/s (approssimiamo) che vuol dire anche 0,0343 cm/microsecondi. Quindi, ricordando che v=s/t (v: velocità, s: spazio, t: tempo) allora lo spazio percorso sarà: da cui s = v * t s = 0,0343 * t però, per calcolare lo spazio percorso, bisogna tener conto che il suono percorre due volte la distanza da misurare (giunge sull'oggetto e ritorna indietro al sensore) quindi il valore di t ottenuto deve essere diviso per 2. La formula corretta per la misura dello spazio percorso è: eseguendo la divisione di 0,0343/2 possiamo scrivere: oppure: s = 0,0343 * t/2 s = 0,01715 * t s = t/58,31 49

50 Data Mar 2017 Ver. 1.3 Pag 50/137 approssimando s = t/58 formula più semplice da ricordare. Per calcolare la distanza dell'oggetto dal sensore sarà sufficiente dividere il tempo t (tempo impiegato dal segnale per giungere sull'oggetto e tornare al sensore) per 58. Montaggio del circuito: Vediamo lo sketch: int triggerport = 7; int echoport = 8; long duration; long r; void setup() pinmode( triggerport, OUTPUT ); pinmode( echoport, INPUT ); Serial.begin( 9600 ); Serial.println( "Sensore ultrasuoni: "); void loop() digitalwrite( triggerport, LOW ); //porta bassa l'uscita del trigger digitalwrite( triggerport, HIGH ); //invia un impulso di 10microsec su trigger delaymicroseconds( 10 ); digitalwrite( triggerport, LOW ); duration = pulsein( echoport, HIGH ); r = * duration/2; Serial.print( "durata: " ); Serial.print( duration ); Serial.print( ", " ); Serial.print( "distanza: " ); if( duration > ) //dopo 38ms è fuori dalla portata del sensore Serial.println( "fuori portata"); else Serial.print( r ); Serial.println( "cm" ); delay( 1500 ); //aspetta 1.5 secondi 50

51 Data Mar 2017 Ver. 1.3 Pag 51/137 PIR SENSOR Questo sensore è in grado di rilevare un oggetto in movimento in una stanza all interno del range operativo. Sul mercato possono essere reperiti molto piccoli, economici, a bassissimo consumo e semplici da utilizzare. PIR significa: Passive InfraRed, è un sensore passivo a infrarossi, cioè rileva i livelli della radiazione infrarossa. Ogni oggetto emette della radiazione infrarossa, in particolar tanto più caldo è l oggetto e maggiore sarà la radiazione emessa. Il sensore è diviso in due parti, sensibili all in quanto l obbiettivo è quello di rilevare il cambiamento di radiazione piuttosto che la radiazione media. Quando il sensore è a riposo, entrambe le parti rilevano la stessa quantità di raggi infrarossi, quella emanata dalla stanza o dalla pareti. Quando un corpo caldo, come ad esempio un essere umano o un animale, attraversa l area sensibile di una delle due parti, si verifica una differenza positiva delle due rivelazioni. Stessa cosa accade quando succede il contrario, se qualcuno lascia la stanza si verifica una differenza negativa. In entrambi i casi viene rilevato un cambiamento di stato. Solitamente il rivelatore ha un costo fisso ed è uguale per tutti i sensori PIR, ciò che cambia sono le lenti che vengono applicate sopra il sensore e differenziano il PIR in base alla sua sensibilità. Le lenti vengono fabbricate in plastica ma hanno lo stesso funzionamento di una lente per macchine fotografiche: hanno lo scopo di riportare una grande area tridimensionale in un piccolo spazio rettangolare piano. Per collegare un sensore PIR bastano tre pin: due per l alimentazione a 5 V(anche da Arduino va bene in quanto il suo assorbimento è di 50µA) e uno per il segnale d uscita: 51

52 Data Mar 2017 Ver. 1.3 Pag 52/ Nero: GND o massa ( polo negativo di alimentazione ) 2. Rosso: 5V ( polo positivo di alimentazione ) 3. Verde: segnale digitale Il funzionamento è semplice: quando rileva un movimento l uscita del segnale passa da LOW ad HIGH, secondo le specifiche del costruttore l uscita passa da 0,4v a 4v, quindi da una soglia inferiore ai 2,5v ad una superiore. Il sensore presenta anche un potenziometro per regolare il tempo di eccitazione dopo aver rilevato il movimento, ossia il tempo in cui il pin del segnale digitale resta a HIGH prima che, in assenza di movimento, torni a LOW. Potremmo collegare il PIR solo ad una resistenza per verificarne il funzionamento: una volta attivato la resistenza si accende: Una volta collegata l alimentazione, sono necessari dai 30 ai 60 secondi affinchè il PIR si stabilizzi. Durante questo tempo il LED potrebbe accendersi o lampeggiare. Attendere fino a quando il LED rimane spento. Dopodichè testare il funzionamento passando una mano davanti al sensore. Il PIR può essere regolato in differenti modi per evitare che il LED (e quindi l uscita digitale) lampeggi se non rimanga fermo in una posizione. Nella parte posteriore sono presenti dei potenziometri e un jumper. 52

53 Data Mar 2017 Ver. 1.3 Pag 53/ Jumper: nella posizione L il PIR è non-retriggeing, nella posizione H è retriggering. Nella maggior parte dei casi è auspicabile tenere il jumper nella posizione H in quanto la rivelazione è migliore 2. Potenziometro sensibilità: regola la sensibilità (e o la distanza) del PIR per compensare i cambiamenti di temperatura in inverno ed in estate 3. Potenziometro tempo: quando una fonte di calore passa davanti al sensore, l uscita digitale viene commutata e rimane allo stato alto per il tempo impostato da questo potenziometro. Tempi tipici dei PIR sono dai 10 secondi ai 5 minuti. Proviamo adesso a collegare il PIR ad Arduino. L operazione è molto semplice. Abbiamo visto che il sensore attiva un uscita digitale: da 0V passa a 5V per un tempo regolabile. E un po come premere un pulsante collegato a +Vcc. Collegare il PIR ai 5 V di Arduino ed il pin centrale al pin 2 come mostrato in figura. Il codice è molto semplice. Faremo accendere il pin 13 di Arduino, collegato ad un LED integrato, quando il sensore rileva il movimento. Copy Code here int ledpin = 13; int inputpin = 2; //ingresso per il segnale del PIR int pirstate = LOW; //cambiamento di stato del PIR assumendo che non c' 'e8 movimento int val = 0; //variabile per la lettura dello stato del PIR void setup() pinmode(ledpin, OUTPUT); pinmode(inputpin, INPUT); Serial.begin(9600); void loop() val = digitalread(inputpin); if (val == HIGH) //legge il valore di input //verifica se l'ingresso 'e8 alto 53

54 Data Mar 2017 Ver. 1.3 Pag 54/137 digitalwrite(ledpin, HIGH); //accende il led if (pirstate == LOW) //situazione di partenza Serial.println("Movimento rilevato!"); pirstate = HIGH; //cambiamento di stato else digitalwrite(ledpin, LOW); if (pirstate == HIGH) Serial.println("Movimento terminato!"); pirstate = LOW; Non dimenticate che per alcuni casi non è necessario utilizzare un microcontrollore. Un PIR può essere collegato direttamente ad un transistor o ad un relè. PULSANTI MULTIPLI SU INGRESSO ANALOGICO Poichè l ingresso analogico di Arduino è in grado di discriminare 1024 diversi livelli di tensione, è possibile risparmiare ingressi digitali per ricondurre una serie di bottoni direttamente ad un solo ingresso analogico. L unica limitazione è quella relativa al tipo di connessione che verrà fatta: sarà possibile premere un solo tasto alla volta. Nello schema sottostante viene raffiugurato un partitore di tensione con resistenze tutte uguali da 2 kω. Premendo i differenti pulsanti si hanno diversi valori di resistenza visti all ingresso del pin analogico. Per calibrare ogni pulsante si dovrebbe leggere il valore letto singolarmente e scrivere il programma apposito. Utilizzando le resistenze indicate, da sinistra verso destra, si ha quanto segue: 1023: nessun pulsante premuto 454: primo pulsante 382: secondo pulsante 291: terzo pulsante 168: quarto pulsante 0: quinto pulsante Per quanto riguarda il codice: #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 2, 3); int a = 0; 54

55 Data Mar 2017 Ver. 1.3 Pag 55/137 void setup() lcd.begin(20, 4); pinmode(a5, INPUT_PULLUP); //settaggio dell input analogico con resistenza di pullup int readbuttons(int pin) int b,c = 0; c=analogread(pin); if (c>1000) b=0; else if (c>440 && c<470) b=1; else if (c<400 && c>370) b=2; else if (c>280 && c<310) b=3; else if (c>150 && c<180) b=4; else if (c<20) b=5; return b; //nessun pulsante è premuto //pulsante 1 premuto //pulsante 2 premuto //pulsante 3 premuto //pulsante 4 premuto //pulsante 5 premuto //restituisce il numero del pulsante premuto, //zero se nessuno è premuto //preleva il valore analogico void loop() a=readbuttons(a5); lcd.clear(); if (a==0) //nessun pulsante è premuto lcd.setcursor(0,1); lcd.print("press a button"); else if (a>0) //alcuni pulsanti sono premuti lcd.setcursor(0,2); lcd.print("pressed button "); lcd.print(a); delay(1000); //tempo di attesa CELLE DI CARICO La cella di carico è un sensore o un trasduttore che converte un carico o un forza in un segnale elettrico. Questo segnale può essere un cambiamento di tensione, di corrente o di frequenza, in dipendenza del tipo di cella e del circuito adoperato. Solitamente in commercio si trovano celle di carico resistiva ma esistono anche quelle capacitive. Una cella di carico lavora secondo il principio della piezo-resistività. Quando una forza è applicata al sensore, esso cambia la sua resistenza. Tale cambiamento induce una variazione di tensione allorchè una tensione d ingresso è applicata al circuito. Una cella di carico è realizzata tramite una membrana elastica (con un elevato indice di deflessione) alla quale è collegata un estensimetro (strain gauge), uno strumento di misura per rilevare piccole deformazioni di un corpo che, solitamente, è un metallo duro. Le celle di carico commerciali sono di diversa tipologia (singolo punto, pulsante, etc) e vengono adoperate in diversi contesti (applicazioni industriali, misure di precisione, elettrodomestici, etc). 55

56 Data Mar 2017 Ver. 1.3 Pag 56/137 Nella cella di carico seguente, sono presenti 4 differenti estensimetri, due in alto e due in basso: Quanto un carico è applicato al corpo di una cella di carico resistiva, la membrana elastica viene deflessa modificando la sua forma. Il risultato è quello di avere due estensimetri in compressione e due in tensione. In questo modo la resistenza viene modificata fin tanto che le membrane rimangono deformate. Il ponte di Wheastone I quattro estensimetri sono collegati tra loro nella configurazione del Ponte di Wheastone con 4 differenti resistori. Una tensione di alimentazione (solitamente di 10 V) è applicata a due angoli (A e C), mentre negli altri due angoli (B e D) si misura la differenza di potenziale. Senza applicare forza, si ha l equilibrio (ponte bilanciato), per cui la differenza di potenziale risulta essere uguale a zero (o molto vicina allo zero). Quindi il bilanciamento del ponte consiste nell ottenere la configurazione per cui, a carico nullo, la tensione d uscita è nulla. Per ottenere questo risultato è necessario disporre di resistenze in grado di equiparare le tensioni tra i rami. Quando invece, il corpo metallico della cella viene sottoposto ad uno sforzo, gli estensimetri variano la loro resistenza registrando una variazione di potenziale (solitamente dell ordine di 20 mv) misurata ai capi B e D. Vista l esigua entità della variazione di tensione, è necessario amplificare il segnale per ottenere variazioni da 0 a 5 V o da 0 a 10 V. Celle di carico a tre fili Nelle comuni bilance domestiche digitali, è possibile ricavare n.4 celle di carico che solitamente presentano 3 fili, bianco, rosso e nero. Queste bilance sono molto economiche e si riescono a reperire facilmente in qualunque negozio per casalinghi. La tensione di alimentazione è di circa 10 V mentre il carico massimo supportato è di 50 Kg. Va da sé che ai fini del funzionamento circuitale sarà necessario riprodurre la teoria precedemente esposta del ponte di Weastone. I collegamenti interni della cella sono rappresentanti nella figura sottostante: 56

57 Data Mar 2017 Ver. 1.3 Pag 57/137 Per poter far funzionare correttamente la cella bisogna inserire ulteriori due resistenze dello stesso valore, creando così un ponte bilanciato: Amplificatori si segnale INA125 Poiché la variazione di tensione è molto debole (qualche mv), è necessario amplicare il segnale di almeno un migliaio di volte per avere un range di varizione che possa andare dagli 0 ai 5 V (range d ingresso dell ADC del microcontrollore presente in Arduino UNO). Uno degli amplificatori che possono essere utilizzati a tal scopo è quello proposto in questa sezione. Si tratta di un amplificatore a bassa potenza molto accurato per strumentazione e perfetto per i nostri scopi. Le tensioni di riferimento sono molto precise e possono essere scelte secondo il seguente range: 10, 5 e 2,5 V. Un singolo resistore esterno può impostare un guadagno tra 4 e Lavora su singole alimentazioni tra 2,7 e 36 V o alimentazioni duali tra ±1,35 V e ± 18 V. La modalità si sospensione (SLEEP) consente la messa fuori servizio e il funzionamento in ciclo di lavoro per il risparmio energetico. HX711 In questo caso l amplicazione di segnale viene restituita in forma digitale e trasferita in via seriale. Questo modulo utilizza un convertitore ADC a 24 bit ad alta precisione. Presenta due ingressi analogici Descrizione PIN L integrato HX711 accetta 5 fili dalla cella di carico. Questi pin sono etichettati con: RED, BLK, WHT, GRN e YLW. I colori corrispondono ai colori convenzionali delle celle di carico. YLW e una massa opzionale utile a diminuire le interferenze elettromagnetiche. A volte, al posto del cavo giallo è possibile trovare un cavo nero più grosso. 57

58 Data Mar 2017 Ver. 1.3 Pag 58/137 ATTUATORI CONTROLLO MOTORI IN CC I motori a corrente continua (CC oppure DC dall'inglese direct current) hanno soltanto due fili (positivo e negativo). Per farli girare è sufficiente alimentarli con una piccola batteria (in genere 5V sono sufficienti). Al loro interno è presente un magnete permanente situato sul corpo cilindrico (1), un'elettrocalamita situata sull'asse (2) e dei contatti struscianti (spazzole) che alimentano l'elettrocalamita (3). Applicando una tensione, l'elettrocalamita si polarizza in maniera opposta al magnete e tende a ruotare per allineare il suo Nord con il Sud del magnete e viceversa. I contatti struscianti sono disposti in modo tale da invertire la polarità dell'elettrocalamita ogni mezzo giro, quando essa si allinea col magnete. Questo fa sì che l'asse continui a ruotare, finché riceve corrente, senza mai stabilizzarsi. Le spazzole comportano una spesa in energia, infatti i motori DC assorbono una corrente che Arduino non è in grado di erogare dai suoi pin: per questo si usano uno o più componenti di collegamento fra il microcontrollore e l'attuatore: un transistor oppure un ponte H. Metodo 1: transistor Il modo più semplice per far girare un motore DC è usare un transistor, ad esempio un darlington TIP120, oppure un generico NPN (PN2222). Un transistor ha tre terminali: base, collettore ed emittore. La maggior parte della corrente scorre tra il collettore e l emettitore, ciò accade solo se una piccola quantità di corrente scorre attraverso la giunzione di base. Questa piccola corrente può essere erogata da un pin di Arduino. Un piccolo transistor, come il PN2222, può essere usato come un interruttore. Nello schema proposto, il pin 9 è connesso tramite un resistore che ha il compito di limitare la corrente che scorre all interno del transistor attravero la base. E un po come limitare la corrente all interno di un diodo LED. Per il calcolo della resistenza opportuna si rimanda all appendice dedicata. Solitamente, il valore della resistenza si aggira attorno a 1 kω. Il diodo collegato ai capi del motore, che si presenta elettricamente come un induttanza, permette di far scorrere la corrente in una sola direzione ed evitare dannosi picchi di corrente inversa. Infatti, quando si spegne il motore, si hanno dei picchi negativi di tensione che può danneggiare Arduino o il transistor. Vediamo lo schema di collegamento su breadboard: 58

59 Data Mar 2017 Ver. 1.3 Pag 59/137 Come è possibile vedere nello schema, la base del transistor va collegata al pin 9 attraverso una resistenza, l'emettitore a massa e il collettore ad un terminale del motore, L'altro terminale va connesso ad un'alimentazione esterna, come una batteria o un alimentatore (NO AI 5V DI ARDUINO!). Il transistor così collegato, funziona da interruttore elettronico: applicando tensione sulla base, emettitore e collettore vengono "connessi". Questo metodo è vantaggioso perché richiede un solo pin di Arduino, ma può far girare il motore in una sola direzione. Vediamo lo sketch nel caso in cui viene collegato un pulsante al pin 2: 1. const int pulsante = 2; //inzializza il pin di ingresso del pulsante 2. const int motore = 9; //imposta il pin che verrà collegato alla base del transistor void setup() pinmode(motore, OUTPUT); //inizializza il pin di uscita 7. pinmode(pulsante, INPUT); //inizializza il pin di ingresso void loop() 11. digitalwrite(motore, digitalread(bottone)); //se il pulsante viene premuto, il motore gira Seguendo lo schema proposto in precedenza e collegando un potenziometro sul piedino A0, è invece possibile modulare la velocità dei motori tramite l ausilio di segnali PWM. Per questo esempio faremo uso della funzione map() già descritta. Ecco lo sketch: 1. const int potenziometro = 0; //imposta l ingresso A0 del potenziometro 2. const int motore = 9; //imposta il pin che verrà collegato alla base del transistor 3. const int velocita; //variabile di supporto per scrivere il valore letto dal potenziometro void setup() 6. pinmode(motore, OUTPUT); //inizializza il motore come output void loop() 10. velocita = map(analogread(potenziometro),0,1023,0,255); 11. //il motore gira con velocità proporzionale alla rotazione del potenziometro 12. analogwrite(motore, velocita); 13. Nel caso in cui volessimo controllare la velocità tramite monitor seriale, si propone il seguente sketch: 1. const int motore = 9; //imposta il pin che verrà collegato alla base del transistor 59

60 Data Mar 2017 Ver. 1.3 Pag 60/ const int velocita; //variabile di supporto per scrivere per la lettura seriale void setup() 5. pinmode(motore, OUTPUT); //inizializza il motore come output 6. Serial.begin(9600); 7. while (! Serial); 8. Serial.println("Velocità da 0 a 255"); void loop() 12. if (Serial.available()) 13. valore = Serial.parseInt(); //legge il valore inserito tramite tastiera in intero 14. if (velocita >= 0 && velocita <= 255) //se il valore inserito è compreso tra 0 e analogwrite(motore, velocita); //avvia il motore alla velocità letta dal potenziometro 16. Metodo 2: invertire il senso di rotazione con un ponte H I motori in corrente continua possono invertire il senso di marcia in dipendenza della polarità dell'alimentazione (principio comune a tutti i motori cc). Per poterne comandare anche l'arresto si può pensare di utilizzare due interruttori. Vediamo ora di sostituire gli interruttori con dispositivi elettornici integrati. Come abbiamo visto precedentemente, il modo più semplice per ottenere un interruttore è quello di sfruttare il funzionamento di un transistor BJT o un MOS. Il diodo in parallelo al motore DC (diodo di ricircolo), viene utilizzato per proteggere la giunzione dei transistor dalle sovratensioni che si vengono a creare nel momento dello spegnimento del transistor stesso. Nel caso di motori DC dotati di spazzole, ovvero gran parte dei motori DC presenti nei piccoli azionamenti, spesso vengono installati dei condensatori al fine di ridurre gli effetti elettromagnetici nocivi dovuti allo sfre- 60

61 Data Mar 2017 Ver. 1.3 Pag 61/137 gamento delle spazzole. Questi risultano spesso saldati tra i terminali di alimentazione e il contenitore del motore. La configurazione appena descritta, se pur semplice, oltre a permettere di attivare e disattivare il transistor, ovvero il motore, permette, se abbinata ad un segnale PWM (Pulse Width Modulation) di controllare la velocità del motore stesso. Proviamo ora a combinare insieme i due circuiti della figura D, per ottenerne uno solo grazie al quale sia anche possibile invertire il senso di rotazione di uno stesso motore. Quello che si ottiene è il circuito riportato nella figura E che presenta quattro interruttori comandati disposti a formare una lettera H: per questo tale configurazione viene detta 'a ponte H'. Il funzionamento del motore dipende ora da quattro valori logici (A, B, C e D). La tabella a destra dello schema riassume i possibili comportamenti del motore in dipendenza delle diverse configurazioni degli ingressi. Dalla tabella risulta che, se si attivano (ponendo il valore 1) coppie di ingressi incrociati (A e D oppure B e C, si realizza una delle due situazioni rappresentate dagli schemi della figura C, in cui il motore gira in senso orario oppure antiorario. Quando invece si attivano le coppie di ingressi allineati (A e B oppure C e D), il motore resta fermo poiché scollegato dall'alimentazione (V) o dalla terra (Gnd). Infine, le configurazioni che attivano le coppie di ingressi dello stesso lato (A e C oppure B e D) determinano, nello stesso punto dei circuito, valori di tensione diversi, che provocano un cortocircuito, molto dannoso per il circuito. Per evitare tali configurazioni pericolose, dette di 'fuse test', il circuito deve essere modificato ulteriormente, riducendo i valori logici di comando del ponte H da quattro a due. E' quello che si può osservare nel circuito schematizzato nella figura F dove è stato inserito un nuovo componente chiamato 'porta NOT'. La porta NOT è una porta logica con funzione di negazione, in grado di garantire che gli ingressi degli inter- 61

62 Data Mar 2017 Ver. 1.3 Pag 62/137 ruttori, posti sullo stesso lato, abbiano sempre e solo valori opposti: se per esempio A è 1 l'interruttore in alto a sinistra riceverà tale valore, mentre quello in basso a sinistra riceverà la negazione dei valore di A, cioè 0. Qualora si faccia uso di un'alimentazione singola, l'inversione dell'alimentazione del motore, quale valida alternativa al controllo lineare, può essere ottenuta per mezzo di un ponte H. Il ponte H non è altro che un circuito composto da 4 transistor, la cui configurazione somiglia molto ad una H (da cui il nome). Vediamo il caso in cui il ponte H sia realizzato tramite dei transistor MOS. Il suo funzionamento, considerando i transistor come degli interruttori ideali, è riportato di seguito: a) Motore disattivo, b) Rotazione in un verso, c) Rotazione verso opposto. Si noti che due soli transistor alla volta, risultano attivi (chiusi). In particolare i due transistor attivi non risultano mai dello stesso ramo altrimenti si avrebbe un corto circuito delle alimentazioni. Lasciando tutti i transistor in interdizione il motore risulta non alimentato, mentre chiudendoli opportunamente, caso (b) e (c), è possibile ottenere i due versi di rotazione oraria e antioraria. Oltre alle configurazioni finora descritte ce ne sono altre due valide che vengono utilizzate in maniera equivalente al fine di frenare un motore in movimento che descriveremo successivamente nella descrizione dei ponti H commerciali. L'utilizzo di un ponte H permette di controllare facilmente il verso di rotazione del motore pur avendo un'alimentazione singola. Se il ponte H viene controllato per mezzo di un segnale PWM è inoltre possibile variare la velocità del motore stesso. 62

63 Data Mar 2017 Ver. 1.3 Pag 63/137 MODALITÀ DI PILOTAGGIO LAP: LOCKED ANTI-PHASE Il pilotaggio di un motore CC mediante l utilizzo della PWM è una tecnica molto utilizzata poiché permette di regolare la velocità e soprattutto la sua frenatura. Supponiamo di avere un integrato con un segnale di enable per attivare e disattivare le uscite. Il verso di rotazione e la velocità sono controllati per mezzo di un segnale PWM, mentre il segnale di enable è usato per attivare e disattivare l'integrato. Quando il duty-cycle è 0% si ha una rotazione in un verso mentre quando si ha il duty-cycle pari al 100% si ha una rotazione nel verso opposto. Nel caso in cui il duty-cycle sia del 50% il motore risulta fermo. Questo discende dal fatto che avere un duty-cycle del 50% equivale a ruotare in un senso e subito dopo nell altro senso...ovvero rimanere fermi! Nel caso di duty-cycle inferiore al 50% si ha una rotazione con velocità che aumenta all'avvicinarsi del dutycycle allo 0%. Allo stesso modo per duty-cycle maggiori del 50% la rotazione avviene in senso opposto con velocità crescente al crescere del duty cycle (fino al 100%). Riportiamo le tabelle di configurazione: D.C. Motore 0% Massima velocità antioraria 50% Fermo 100% Massima velocità oraria Enable 5V GND Ponte ON OFF Esempio con ponte integrato L298: 63

64 Data Mar 2017 Ver. 1.3 Pag 64/137 MODALITÀ DI PILOTAGGIO SM: SIGN-MAGNITUDE (MODULO E SEGNO) L SM (Sign-Magnitude) consiste nell inviare il segnale PWM all ingresso di Enable per variare la velocità e di pilotare separatamente gli ingressi del ponte per stabilire il verso di rotazione, che, dovendo essere comandati con segnali invertiti, utilizza una porta NOT riducendo il numero segnali di controllo per ogni motore. Regolando il duty-cycle del segnale PWM a 0% il motore risulta disattivato. Il verso di rotazione viene impostato per mezzo del segnale ON-OFF (Right-Left) attivando opportunamente i rami del ponte H. La funzione della porta NOT, è quella di invertire il segnale di controllo, attivando la sequenza corretta dei transistor. Riportiamo di seguto le tabelle di configurazione. Enable Motore PWM 0% Fermo 50% ½ di regime 100% Massimo regime IN1 IN2 Rotazione 5V GND Oraria GND 5V Antioraria Esempio con ponte L298: 64

65 Data Mar 2017 Ver. 1.3 Pag 65/137 PONTE H COMMERCIALE: L293D La configurazione configurazione a ponte H è ottenibile tramite un circuito integrato che va sotto il nome di L293D. Il chip è uno degli elementi che compongono la scheda di controllo motori e che funge da intermediario tra i motori e il microcontrollore il quale invia i comandi di controllo. Per questo motivo il chip L293D è chiamato driver. I driver L293D sono costituiti da 4 mezzi ponti H e sono progettati per fornire corrente bidirezionale fino a 600mA a tensioni tra 4,5V e 36V. Progettato per pilotare carichi induttivi come relè, solenoidi, motori in CC e motori bipolari passo passo. Tutti gli ingressi sono compatibili con la logica TTL. Lavorano a temperature da 0 C fino a 70. Vediamo la sua piedinatura. Analizziamo i pin del circuito integrato: PIN Etichetta Descrizione 1 1,2EN lo stato basso (LOW) disabilita il ponte 1,2 (di sinistra, A), lo stato alto (HIGH) lo abilita 2 1A segnale di input per il ponte A 3 1Y segnale di output per il ponte A; la corrente scorre sul carico connesso tra 1Y e 2Y 4 Ground massa e dissipatore 5 Ground massa e dissipatore 6 2Y segnale di output per il ponte A; la corrente scorre sul carico connesso tra 1Y e 2Y 7 2A segnale di input per il ponte A 8 V CC2 segnale di alimentazione per il motore 9 3,4EN lo stato basso (LOW) disabilita il ponte 3,4 (di destra, B), lo stato alto (HIGH) lo abilita 10 3A segnale di input per il ponte B 11 3Y segnale di output per il ponte B; la corrente scorre sul carico connesso tra 3Y e 4Y 12 Ground massa e dissipatore 13 Ground massa e dissipatore 14 4Y segnale di output per il ponte B; la corrente scorre sul carico connesso tra 3Y e 4Y 15 4A segnale di input per il ponte B 16 V CC1 alimentazione per il circuito integrato da 5V 65

66 Data Mar 2017 Ver. 1.3 Pag 66/137 E interessante sapere che i pin 1 e 9 dell integrato possono essere usati sia come abilitazione alla rotazione oppure, applicando un segnale modulato in PWM, per regolare la velocità del motore. Con le coppie di pin 2-7 e si sceglie il senso di rotazione, inoltre portandoli allo stesso livello possiamo bloccare il motore in frenatura rapida. Rigurardiamo la tabella: Azione 1 0 Ruota a dx 0 1 Ruota a sx 0 0 Fermata rapida 1 1 Fermata rapida Dal datasheet dell integrato possiamo vedere alcuni esempi di configurazioni circuitali: Il ponte di sinistra viene utilizzato per comandare un motore con la possibilità di variare la direzione di marcia, sul ponte di destra sono stati invece collegati due motori distinti che ruotano solo in un senso. Inoltre, l integrato L293D ha il vantaggio di integrare già i diodi di protezione rispetto ad altri ponti (es. L298). A partire da questa configurazione proviamo a realizzare il circuito mostrato in figura per il pilotaggio di un singolo motore: 66

67 Data Mar 2017 Ver. 1.3 Pag 67/137 Vediamo lo sketch per ruotare il motore in un senso e nell altro in maniera automatica: 1. int enable = 3; //regola la velocita' con PWM 2. int in1 = 2; //connesso a IN1 del L293D 3. int in2 = 7; //connesso a IN2 del L293D void setup() //dichiarazione dei pin di uscita 8. pinmode(enable, OUTPUT); 9. pinmode(in1, OUTPUT); 10. pinmode(in2, OUTPUT); void loop() int velocita = 128; //imposta la velocita' di rotazione del motore 16. analogwrite(enable, velocita); //scrive la velocita' sul pin di enable 17. digitalwrite(in1, LOW); //attiva la rotazione in un senso 18. digitalwrite(in2, HIGH); 19. delay(3000); 20. ferma(); //richiama la funzione di arresto del motore digitalwrite(in1, HIGH); //attiva la rotazione nell'altro senso 23. digitalwrite(in2, LOW); 24. delay(3000); 25. ferma(); void ferma() digitalwrite(in1, LOW); 31. digitalwrite(in2, LOW); 32. delay(3000); ESERCIZIO: collegare un potenziometro e variare la velocità e il senso di rotazione di un motore in continua. PONTE H COMMERCIALE: L298 L L298 possiede due ponti H integrati e permette il controllo di motori DC o stepper (passo-passo bipolare). E' realizzato per mezzo di transistor bipolari (BJT). Esso è meno efficiente rispetto ai ponti realizzati per mezzo di transistor MOS, infatti la R on dei transistor è relativamente alta e molta energia viene dissipata internamente. Risulta utile per il controllo di robot medio-piccoli dal momento che possiede due ponti H capaci 67

68 Data Mar 2017 Ver. 1.3 Pag 68/137 di controllare correnti fino a 2A per ponte ed una tensione operativa fino a 48V. L'integrato possiede una protezione interna in caso di temperatura eccessiva, situazione che si può verificare in caso di stallo di un motore. I ponti H possono essere pilotati con livelli in logica TTL. Ciascun ponte può essere disabilitato o abilitato tramite il relativo piedino di Enable. Di seguito alcune importanti informazioni dal datasheet. 68

69 Data Mar 2017 Ver. 1.3 Pag 69/137 Ogni semiponte può sopportare una corrente di 2 A. La configurazione con singolo motore può essere dedotta direttamente dal datasheet. Se invece il motore da controllare assorbe più di 2 A, è possibile adottare una configurazione in parallelo che permette di sfruttare i due ponti insieme. Di seguito si propone la configurazione circuitale del caso. 69

70 Data Mar 2017 Ver. 1.3 Pag 70/137 I pin corrispondenti dei due stadi sono: Stadio A Stadio B Azione 10 5 Ruota a dx 12 7 Ruota a sx 11 6 Abilitazione 13 2 Out Out Comune negativo I pin 11-6 dell'integrato possono essere usati come abilitazione alla rotazione oppure applicandovi un segnale modulato in PWM per regolare la velocità del motore. Con i pin 10-5 e 12-7 si sceglie il senso di rotazione, inoltre portandoli allo stesso livello possiamo bloccare il motore in frenatura rapida. Questa è la tabella che spiega le funzioni di questi pin: Azione 1 0 Ruota a dx 0 1 Ruota a sx 0 0 Fermata rapida 1 1 Fermata rapida 70

71 SERVO MOTORI: COME CONTROLLARE UN SERVO MOTORE I servo motori, sono attuatori speciali muniti di un sistema di feedback che permette di controllarne la posizione angolare. In altri termini, sono un tipo particolare di motori che generalmente non ruotano in modo continuo (sebbene esistano alcuni modelli capaci di ruotare di 360 ), e che è possibile controllare in modo da ruotarli in una posizione specifica e mantenerla fino a che lo si desidera. Contengono tutta l elettronica che serve per comandarli: sistema di feedback, logica e stadio di potenza. Possono ruotare in entrambi i sensi, e l elettronica che li comanda è in grado di variarne la velocità in modo efficiente per garantire una buona precisione nel posizionamento. La maggior parte dei servomotori può ruotare di 180, ma esistono modelli da 45, 90 ed anche 360. All interno dei servomotori si trovano diverse parti meccaniche ed elettroniche. Eccone un elenco: 1. Motore DC: è un semplice motore in continua con spazzole. 2. Un potenziometro: è collegato all albero di uscita così da ottenere un valore resistivo proporzionale all angolo della posizione attuale. 3. Elettronica di controllo (sistema retroazionato): utilizza il valore resistivo per decidere la direzione di rotazione e fermarla quando raggiunge la posizione desiderata. Sempre questo sistema è responsabile della scelta della velocità che è proporzionale alla distanza da percorrere. 4. Motor driver (stadio di potenza): è una parte di elettronica che si occupa di alimentare il motore in modo corretto a seconda della direzione, ed è in grado di fornire e dissipare tutta la potenza necessaria all operazione. 5. Un set di ingranaggi e un meccanismo di demoltiplica: servono ad aumentare la precisione, ridurre l inerzia ed aumentare la coppia. Grazie a questa meccanica integrata i servomotori sono in grado di esercitare forze considerevoli utilizzando un motore poco potente e mantenendo i consumi bassi. Il segnale di controllo è un segnale PWM a 50Hz con impulsi lunghi da un minimo di 1 ms ad un massimo di 2 ms dove 1ms corrisponde a 0 e 2 ms a 180. Il segnale di controllo deve essere mantenuto almeno fino a quando il motore è completamente in posizione. Al contrario, interrompere gli impulsi in modo prematuro comporterà un posizionamento non accurato e la possibilità che l albero possa ruotare per forze esterne. Il connettore dei servomotori è composto da 3 fili, due sono per l alimentazione ed uno è per il segnale di controllo. Sembra scontato dirlo, ma l alimentazione dei servo va rispettata. Non è possibile invertire massa e positivo perchè vengono usati per alimentare l elettronica di controllo. Inoltre, ogni dispositivo viene prodotto per lavorare in un determinato range di tensione, non bisogna eccedere nè sottoalimentare il servo. Tensioni tipiche sono 5-6 V. Un altra osservazione che sembra superflua ma è doveroso fare è che i motori consumano una corrente che non è bene ottenere ad esempio da Arduino alimentato dalla porta USB. Questo dipende molto dal servo utilizzato, però in generale, è meglio alimentare il tutto con un alimentatore esterno in grado di erogare le correnti necessarie. Come già discusso precentemente, Arduino dispone, secondo i modelli, di uscite PWM ossia pin digitali in grado di generare un duty-cycle utilizzabile per far muovere un servo. Il modo più semplice per pilotare i servo è utilizzare una libreria, che traduca angoli in segnali. La libreria è la Servo.h. Questa libreria mette a disposizione alcuni comandi che semplificano di molto il pilotaggio di un servo motore: attach(): permette di specificare su quale pin è connesso il nostro servo e legarlo all oggetto Servo; attached(): controlla che un oggetto di tipo Servo sia collegata ad un pin; detach(): rimuove il collegamento tra l oggetto Servo e il pin a cui era legata;

72 Data Mar 2017 Ver. 1.3 Pag 72/137 read(): legge la posizione angolare del nostro servo, restituisce l ultimo valore passato con write(); write(): impartisce al servo l angolo a cui posizionarsi, su servo a rotazione continua imposta la velocità di rotazione 0=velocità massima in un senso, 90=fermo, 180=velocià massima nella direzione inversa; writemicroseconds(): imposta la velocità di rotazione del servo; in un servo standard il valore va da 1000 a 2000, in un servo a rotazione continua si comporta allo stesso modo della write(). Passiamo a realizzare uno sketch di esempio. Immaginiamo di aver collegato il nostro servo come nella seguente figura: Il servo ha il positivo e il negativo collegati rispettivamente al +5V e Gnd di Arduino e il segnale al pin 9. E importante che si tenga conto che la libreria Servo può utilizzare 12 pin digitali di Arduino e non solo le uscite di tipo PWM, questo disabilita la funzione analogwrite() normalmente utilizzabile con le uscite PWM di Arduino. Il primo esempio riportato sul sito arduino.cc ha il nome di Sweep e permette di far ruotare il servo da una parte all altra: 1. #include <Servo.h> //richiama la libreria dedicata ai servo 2. Servo myservo; //crea un oggetto per controllare il servo 3. //possono essere creati fino a 12 oggetti servo nella maggior parte delle schede 4. int pos = 0; //variabile che memorizza la posizione del servo void setup() myservo.attach(9); //collega il servo su pin 9 all oggetto creato void loop() for(pos = 0; pos <= 180; pos += 1) //varia la posizione da 0 a 180 gradi 14. //con passi di un grado 15. myservo.write(pos); //comunica al servo di andare alla posizione 'pos' 16. delay(15); //attende 15ms affinchè il servo raggiunga la posizione 17. for(pos = 180; pos>=0; pos-=1) varia la posizione da 180 a 0 gradi myservo.write(pos); //comunica al servo di andare alla posizione'pos' 20. delay(15); //attende 15ms affinchè il servo raggiunga la posizione

73 Data Mar 2017 Ver. 1.3 Pag 73/137 SERVO MOTORI: CONTROLLARE UN SERVO DA POTENZIOMETRO In questo esercizio si impartiranno i comandi di rotazione su un servo utilizzando un potenziometro. Nello schema in alto si può osservare come eseguire i collegamenti. Il servo è di tipo modellistico funzionante a 4-6v per cui prevede un alimentazione di +5 V di Arduino, se i servo dovessero essere più di uno si deve calcolare il loro assorbimento sapendo che la corrente erogata da Arduino NON è illimitata. Il potenziometro è da 10KΩ, collegando i pin esterni, quelli ai cui capi misuri una resistenza di 10KΩ indipendentemente dalla rotazione dell alberino, al positivo (+5V) e al negativo (Gnd) di Arduino. Il collegamento centrale del potenziometro, quello che varia in funzione della rotazione dell albero rispetto ad entrambi i contatti esterni, aumentando la resistenza dall uno e diminuendola dall altro, si collega ad uno dei pin analogici di Arduino, nello schema il pin scelto è A0. Vediamo lo sketch che è reperibile negli esempi sotto il nome di Knob: 1. #include <Servo.h> 2. Servo myservo; int potpin = 0; //ingresso analogico per leggere il potenziometro 5. int val; //variabile per registrare il valore letto dall ingresso analogico void setup() myservo.attach(9); void loop() val = analogread(potpin); //legge il valore del potenziometro (tra 0 and 1023) 15. val = map(val, 0, 1023, 0, 180); //ridefinisce l intervallo dell ingresso analogico con 16. //l intervallo accettato dal servo (valore compreso tra 0 e 180) 17. myservo.write(val); //comunica al servo di andare alla posizione 'val' 18. delay(15); 19. Considerazione: sull ultima linea di codice vista (18), il tempo impostato è generico ed è stato fissato su un valore abbastanza grande da consentire il corretto funzionamento con la maggior parte dei servo modellistici in commercio. Tuttavia, se il servo utilizzato fosse di quelli molto rapidi a raggiungere un determinato angolo, si consiglia di ridurre questo tempo per avere delle variazioni più immediate. Per calcolare il tempo di ritardo si fa riferimento alle caratteristiche del servo, solitamente è indicata la velocità angolare. Ad esempio, sulla pagina del servo Futaba S3016 mini, le caratteristiche tecniche relative alla velocità sono: Speed: 0.25 sec 4.8V che a 4,8 V ( 5V) indica una velocità di rotazione di 0,25 sec per 60 che corrisponde a 1 4 di secondo per 60 e nel caso di rotazione a 180 0,75 sec ( = 3 -> 0,25 x 3 = 0,75) e quindi 0, sec per ciascun grado che corrisponde a circa 4 millesimi di secondo per grado. Considerando le dovute approssi- 73

74 Data Mar 2017 Ver. 1.3 Pag 74/137 mazioni, sia in alimentazione che per arrotondamenti, possiamo dire che il nostro servo, alimentato a 5V, si muove di un grado ogni 5 millesimi di secondo. SERVO MOTORI: PILOTARE PIÙ DI UN SERVO Vediamo come pilotare 6 servomotori: Nella costruzione di un robot, ad esempio, è necessario pilotare più di un servo contemporaneamente. Dopo aver eseguito i collegamenti mostrati in figura (ATTENZIONE: è preferibile utilizzare un alimentazione esterna per alimentare tutti i servo), analizziamo il seguente sketch: 1. #include <Servo.h> Servo servomotor2; //inizializza 6 variabili come istanze della classe Servo 4. Servo servomotor3; 5. Servo servomotor4; 6. Servo servomotor5; 7. Servo servomotor6; 8. Servo servomotor7; int grad = 0; //variabile di supporto per registrare il valore inserito da seriale 11. int gradmin=0; //imposta una variabile di finecorsa inferiore 12. int gradmax=180; //imposta una variabile di finecorsa superiore int servopin2 = 2; 15. int servopin3 = 3; 16. int servopin4 = 4; 17. int servopin5 = 5; 18. int servopin6 = 6; 19. int servopin7 = 7; void setup() 22. servomotor2.attach(servopin2); 23. servomotor3.attach(servopin3); 24. servomotor4.attach(servopin4); 25. servomotor5.attach(servopin5); 26. servomotor6.attach(servopin6); 27. servomotor7.attach(servopin7); Serial.begin(9600); //inizializza la comunicazione seriale void loop() grad = Serial.read(); //leggi dalla comunicazione seriale il valore 35. //in gradi impartita ai servomotori 36. Serial.println("Gradi: " + grad); invia al monitor seriale il valore appena inviato if (grad < gradmin) grad = gradmin; //controlla che siano rispettati i finecorsa 39. //inferiore e superiore 40. if (grad > gradmax) grad = gradmax; 41. int _grad = (gradmax - grad); //imposta una nuova variabile per muovere i servo a 3 a servomotor2.write( grad ); //scrive il valore dei gradi ai vari servo 44. servomotor3.write( grad ); 45. servomotor4.write( grad ); 46. servomotor5.write( _grad ); 74

75 Data Mar 2017 Ver. 1.3 Pag 75/ servomotor6.write( _grad ); 48. servomotor7.write( _grad ); 49. delay(15); Considerazione: la linea 41 permette di impartire un ordine in gradi ai servo e vedere la loro rotazione uguale solo a 3 a 3 e non per tutti e 6, ossia al comando 20 si ottiene che i primi 3 servo si posizioneranno a 20 mentre i 3 restanti si posizioneranno a 160, giusto per rompere la monotonia del movimento, per farlo si utilizza la formula matematica banale: gradmax grad: quando impartisci 0 il risultato è 3 servo a 0 e 3 servo a 180 (180 0 = 180), impartendo 90 tutti si posizionano al medesimo angolo di rotazione 90 ( = 90) e impartendo 180 otterrai l opposto dello 0. Questo è solo un semplice esempio di come si pilotano più servo. La libreria Servo.h è in grado di pilotare 12 motori contemporaneamente con Arduino UNO e 23 con Arduino Mega. PROGETTO: INSEGUITORE SOLARE CON ARDUINO L inseguitore solare è un dispositivo in grado di simulare il meraviglioso moto che madre natura ha dato al girasole. Questo progetto può essere utilizzato, ad esempio, per sfruttare al massimo l energia prodotta da un impianto a pannelli fotovoltaici. Materiale necessario: 1. n.1 Arduino Uno; 2. n.2 fotoresistenze LDR 20-50Kohm; 3. n.1 servomotore; 4. n.1 breadboard; 5. n.10 cavetti per breadboard; L importante, ed anche il trucco, sta nell inclinare ogni fotoresistenza di 45 rispetto all asse verticale (asse Y) del pannello. Le due fotoresistenze, poste a 90 l una rispetto all altra, fanno in modo che solo quando il sole è verticale rispetto ad esse le due resistenze siano identiche. In questo caso il partitore fornirà esattamente metà del valore di tensione posto ai capi delle due fotoresistenze. Al muoversi del sole da Est ad OVEST una delle due rileverà più luce dell altra e incrementerà la propria resistenza sbilanciando il circuito e facendo rilevare ad Arduino una variazione rispetto al punto iniziale. In questa condizione Arduino inizierà a seguire il sole ossia a spostare il servo, che sarà collegato al pannello su cui è fissato il sensore, per ribilanciare il valore letto dalle due foto resistenze. 75

76 Data Mar 2017 Ver. 1.3 Pag 76/137 Lo Sketch: 1. #include <Servo.h> //includi la libreria Servo.h int sensorpin = A0; //identifica il pin collegato alle due fotoresistenze 4. int servopin = 9; //identifica il pin dedicato al servo motore int sensorvalue = 0; //inizializza la variabile dedicata alla lettura delle fotoresistenze 7. int servograd = 90; //imposta a 90 la posizione del servo 8. int tolleranza = 40; //tolleranza entro la quale il servo non deve ruotare Servo myservo; //inizializza l oggetto myservo della libreria void setup() 13. pinmode( sensorpin, INPUT); //imposta il pin delle fotoresistenze come input 14. myservo.attach( servopin ); //indica quale pin è collegato il servo 15. myservo.write( servograd ); //imposta i gradi del servo void loop() 19. sensorvalue = analogread(sensorpin); //lettura delle fotoresistenze 20. if ( sensorvalue < (512-tolleranza) ) //se il valore è inferiore alla metà meno la 21. //tolleranza esegui il resto 22. if (servograd < 180) 23. servograd++; //condizione che incrementa la variabile del servo if ( sensorvalue > (512+tolleranza) ) //se il valore è superioe alla metà più la tolleranza if (servograd > 0) servograd--; //condizione che decrementa la variabile del servo myservo.write( servograd ); //scrive la variabile sul pin dell uscita del servo delay(100); //permette al servo di raggiungere la posizione indicata In particolare: linea 20: esegue il primo controllo se il valore letto è minore della differenza tra 512 e la tolleranza impostata, siamo nella condizione in cui il pannello non è più orientato di fronte al sole, una delle due foto resistenze sta rilevando una intensità maggiore dell altra, dipende da come sono state collegate le resistenze, nell esempio è la fotoresistenza destra e per adeguare la posizione del pannello si deve ruotare oltre i 90 gradi iniziali, tra 90 e 180 ; linea 22: esegue una ulteriore verifica, il valore in gradi assunto dal servo non sia > di 180 in quanto il servo che si sta utilizzando non sarebbe comunque in grado si andare oltre, se l angolo del servo è < di 180 allora puoi incrementare i gradi di rotazione. L espressione servograd++ indica di incrementare di un grado il valore di servograd da 90 a 91,92,93 ecc ad ogni loop(); linea 25: verifica una condizione simile a quella della linea 29. In questo caso il valore letto dal sensore è confrontato con la somma tra tolleranza; linea 27: verifica che l angolo il cui il servo si trova non sia inferiore a 0, anche in questo caso non sarebbe possibile per il servomotore eseguire lo spostamento richiesto. Decrementa quindi il valore di servograd un grado per ogni loop() in cui si verificano le condizioni descritte; 76

77 Data Mar 2017 Ver. 1.3 Pag 77/137 TEORIA: MOTORI PASSO-PASSO, COSA SONO I motori passo-passo sono particolari motori in corrente continua la cui rotazione è ottenuta mediante l eccitazione in sequenza degli avvolgimenti in esso contenuti. Si parla dunque di alimentazione con forme d onda impulsive. Sono anche chiamati step-to-step o stepper per indicarne il caratteristico movimento per step (passi) successivi. Ad ogni impulso picevutp corrisponde una rotazione del motore di un angolo fisso (step). La differenze maggiori con i comuni motori in corrente continua sono: 1. la mancanza di spazzole; 2. la presenza di un maggior numero di fili; 3. la possibilità di conoscere la posizione dell albero senza bisogno di encoder; Si possono dedurre quindi degli svantaggi e dei vantaggi: Vantaggi Adatti per il controllo di posizione e/o velocità in sistemi a catena aperta (senza retroazione) Affidaili e robusti Facile controllo via computer Nessuna usura, elevata durata Svantaggi Bassa potenza specifica Basso rendimento energetico Necessità di scheda di alimentazione elettronica Bassa velocità massima Le caratteristiche di un motore, solitamente riportate dal costruttore, ci permettono di valutarne l impiego. Ad esempio un motore come in figura, riporta lo spostamento in gradi (1.8 DEG = risoluzione) dell albero per ciascun passo; da questa informazione possiamo dedurre agilmente che si tratta di un motore da 200 passi ( 360 / 1.8 = 200). Allo stesso modo se avessimo avuto indicazione in merito al numero di passi avremmo potuto calcolare lo spostameto dell asse con la formula: 360 / numero di giri = grado di spostamento per step. Un parametro molto importante è quindi la risoluzione del motore che è in generale calcolabile secondo la formula: 360 Risoluzione = Numero di passi Sull etichetta è possiile leggere anche l assorbimento di 0.44 A (Ampere) per fase, ossia per step del motore. Inoltre, i motori passo passo sono classificati in due tipologie distinte: 1. unipolari: la corrente nelle bobine scorre solo in un verso. Sono più semplici da pilotare in quanto la sequenza della rotazione è esperessa dal succedersi dell eccitazione delle bobine di cui è composto. 2. bipolari: la corrente scorre in entrambi i versi all interno delle bobine. Sono di maggiore complessià perché richiedono delle schede di pilotaggio ma forniscono una coppia maggiore rispetto ai motori unipolari. Il numero di fili di cui un motore passo-passo possono essere 4, 5, 6 o 8 e sono direttamente legati alla caratteristica unipolare (5,6 o 8 conduttori) o bipolare (4 o 8 conduttori) del motore stesso. Per meglio comprendere come i fili sono relazionati alle bobine si riportano degli schemi: 77

78 Data Mar 2017 Ver. 1.3 Pag 78/137 I motori a 4 fili sono di tipo bipolare, come deducibile dallo schema seguente: Pilotare questi motori è possibile facendo percorrere alla corrente gli avvolgimenti in entrambi i versi in modo alternato, inducendo la produzione del campo magnerico necessario alla corretta rotazione. Per la loro stessa costruzione non sono pilotabili in altro modo a differenza dei motori a 8 fili che possono essere utilizzati sia in modalità unipolare che bipolare. I motori a 5 fili sono di tipo unipolare. Pilotare questi motori è possibile semplicemente alternando l alimentazione delle bobine nel senso desiderato. Ad esempio per una rotazione in senso orario dell albero, partendo da una situazione come quella illustrata, dovremmo applicare la tensione (positiva o negativa a seconda della corrispettiva applicata al terminale common) nella sequenza: B+, A+, B-, A-, per ottenere la rotazione in senso antiorario: B-,A+,B+,A- I motori a 6 fili sono di tipo unipolare. La figura ne mostra lo schema costruttivo evidenziando come gli avvolgimenti siano connessi tra loro. Pilotare questi motori è possibile con una tecnica simile a quella già vista per i motori a 5 fili, in quanto i comuni delle due fasi (A e B) possono essere connesi assieme, rendendolo del tutto simile all unipolare a 5 fili. E tuttavia possibile gestire le singole fasi (A e B) in modo indipendente non solo attraverso i terminali A+, 78

79 Data Mar 2017 Ver. 1.3 Pag 79/137 A-, B+ e B- ma applicando corrente su A e B in modo indipendente. I motori a 8 fili possono essere utilizzati sia in configurazione unipolare sia in configurazione bipolare. Lo schema di costruzione riportato in figura mostra le bobine ciascuna con due terminali indipendenti. L utilizzo di tali motori in modalità unipolare o bipolare deve essere eseguito in funzione della complessità del progetto, delle forze in gioco e dell ambito applicativo in cui il motore va collocato. I motori passo-passo sono facilmente reperibili nelle fiere o smontandoli da vecchie stampanti e scanner, il passaggio successivo a procurarsene uno è comprendere come utilizzarli, sopratutto in mancanza dello schema di connessione rilasciato dal produttore. Tecniche di pilotaggio Le seguenti tecniche si applicano a tutti i tipi di motori: FULL STEP o Wave Drive Mode (One Phase-ON): alimentazione di una fase per volta o Normal Drive Mode (Two Phase-ON): alimentazione di due fasi per volta HALF STEP: mediante alternanza di One Phase-ON e Two Phase-ON MICROSTEPPING: mediante modulazione della corrente PILOTARE UN MOTORE PASSO PASSO CON UN PONTE H La figura seguente mostra, in maniera semplificata, il principio di costruzione di un motore passo passo. Il movimento del rotore avviene alimentando le bobine in modo consecutivo. Eccitando solo la bobina A1 il rotore si posiziona verso NORD, eccitando solo la bobina B1 il rotore si posiziona in direzione EST, eccitando solo la bobina A2 il rotore si posiziona in direzione SUD ed infine eccitando solo la bobina B2 il rotore si posiziona in direzione OVEST. La tabella seguente riassume la sequenza. Fasi di Alimentazione A1 A2 B1 B2 Fase 1 + Fase 2 + Fase 3 + Fase 4 + Seguendo le fasi di alimentazione A1-B1-A2-B2 il rotore si sposterà in senso orario, invertendo la sequenza B2-A2-B1-A1 il rotore si sposterà in senso antiorario. E importante alimentare le bobine in modo sequenziale perché il rotore deve seguire in maniera lineare il campo elettromagnetico generato dalle bobine. 79

80 Data Mar 2017 Ver. 1.3 Pag 80/137 Naturalmente nei motori passo passo reali la sequenza delle 4 fasi fa girare l albero di un solo passo (step). Il numero dei passi è una caratteristica costruttiva del motore, solitamente ha un valore di 200 step giro, ma ne esistono anche da 20, 24, 48 e 400 step giro. Il numero di step può essere espresso in gradi sessagesimali, ad esempio un motore da 7.5 equivale ad uno con 48 step giro ( =48). Le 4 fasi di alimentazione delle bobine (considerando un ipotetico motore da 4 step giro), viene rappresentata dalla figura seguente: La sequenza di alimentazione è solitamente gestita da un integrato a logica programmabile mentre il compito di fornire l energia è demandato ad un ponte ad H. Per essere più precisi, avendo 4 fili, dobbiamo usare due ponti H uno che alimenta le bobine A1 e A2 e l altro che alimenta le bobine B1 e B2. Il circuito elettrico che permette di pilotare il motore è rappresentato nella figura seguente: Riassumiamo i collegamenti tramite la tabella seguente: Motore Passo Passo Integrato L298N Arduino GND VCC 5Vdc

81 Data Mar 2017 Ver. 1.3 Pag 81/ A1 14 A2 13 B1 3 B2 2 Alimentazione Motore 12Vdc 4 I diodi in contro fase servono per proteggere le uscite dell integrato L298N da eventuali sovratensioni generate durante l alimentazione delle bobine. Vediamo lo sketch per far semplicemente girare il motore in un senso: void setup() //i pin sono //configurati come uscite pinmode(2, OUTPUT); pinmode(3, OUTPUT); pinmode(4, OUTPUT); pinmode(5, OUTPUT); //forza le uscite a livello logico basso digitalwrite(2, LOW); digitalwrite(3, LOW); digitalwrite(4, LOW); digitalwrite(5, LOW); void loop() //FASE 1 //Alimenta solo la prima bobina digitalwrite(2, HIGH); digitalwrite(3, LOW); digitalwrite(4, LOW); digitalwrite(5, LOW); delay(10); //FASE 2 //Alimenta solo la seconda bobina digitalwrite(2, LOW); digitalwrite(3, LOW); digitalwrite(4, HIGH); digitalwrite(5, LOW); delay(10); //FASE 3 //Alimenta solo la terza bobina digitalwrite(2, LOW); digitalwrite(3, HIGH); digitalwrite(4, LOW); digitalwrite(5, LOW); delay(10); //fase 4 //Alimento solo la quarta bobina digitalwrite(2, LOW); digitalwrite(3, LOW); digitalwrite(4, LOW); digitalwrite(5, HIGH); delay(10); Un altro modo per pilotare il motore è quello di utilizzare la libreria Stepper.h di Arduino. Al suo interno possiamo trovare l esempio MotorKnob. In questo esempio è collegato un potenziometro ed il motore segue l andamento del potenziometro: #include <Stepper.h> //include la libreria dedicata ai motori passo passo #define STEPS 100 // variabile che individua gli step del motore utilizzato int val = 0; //setta una variabile per la lettura dell ingresso analogico int previous = 0; //variabile per la lettura precedente dall'ingresso analogico Stepper stepper(steps, 2, 3, 4, 5); //crea un'instanza della classe specificando //i pin di uscita void setup() 81

82 Data Mar 2017 Ver. 1.3 Pag 82/137 stepper.setspeed(30); void loop() val = analogread(0); stepper.step(val - previous); previous = val; //imposta la velocità del motore a 30 giri al minuto //legge il valore del potenziometro //sposta il motore di un numero di passi uguale //al cambiamento letto da A0 //registara il valore precedente letto dal sensore 82

83 Data Mar 2017 Ver. 1.3 Pag 83/137 CONTROLLO MOTORI BRUSHLESS Brushless significa senza spazzole, elementi che invece risultano presenti nei motori in CC per inviare corrente agli avvolgimenti rotorici. I motori classici in corrente continua presentano un rotore interno su cui sono realizzati degli avvolgimenti in filo elettrico che ruota tra due magneti di polarità opposta. Quando è percorso da corrente elettrica, l avvolgimento genera un campo magnetico che interagisce con i magneti e genera il movimento rotatorio. Nei motori brushless, invece, i magneti sono sul rotore, mentre gli avvolgimenti sono realizzati all esterno e sono fissi. In questo caso i poli sono tre anziché due e vanno alimentati a coppie per dare corrente agli avvolgimenti del motore. Sarà compito di un regolatore sincronizzare la tensione corrente con la posizione del rotore per assicurare il funzionamento corretto. Dal punto di vista funzionale i motori brushless possono essere considerati motori c.c. a magneti permanenti con commutatore elettronico (inverter). Non avendo le spazzole, i motori brushless sprecano meno potenza rispetto ai brushed, quindi a parità di batterie e spiraggio erogano una potenza maggiore a tutti i regimi. Inoltre, il fatto che l'accensione degli avvolgimenti sia gestita dal regolatore e non da un dispositivo meccanico (spazzole), fa sì che il funzionamento di questi motori sia controllabile sotto diversi parametri, consentendo di ottimizzarne il funzionamento in base al tipo di utilizzo. Per contro, proprio per lo stesso motivo, i regolatori brushless devono essere molto più complessi di quelli per motori a spazzole, in quanto oltre a regolare la tensione erogata al motore, devono anche sapere quali poli attivare in base alla posizione del rotore, e ad alti regimi questo compito è molto impegnativo. Il motore brushless, essendo trifase, non è possibile alimentarlo con una normale linea in tensione continua come per in normali motori DC. Per la commutazione della tensione da mandare agli avvolgimenti dello statore ci si deve affidare ad un circuito elettronico apposito che si chiama ESC (Electronic Speed Control), cioè controllo elettronico della velocità o semplicemente variatore. Si tratta di un circuito elettronico che ha lo scopo di variare la velocità di un motore elettrico, di controllare la sua direzione e anche di agire come un freno dinamico. Ogni ESC riceve la tensione di alimentazione dalla batteria ausiliaria e la distribuisce elettronicamente sulla linea trifase del motore brushless. Oltre ai due fili dell alimentazione dalla batteria, l ESC è dotato di un connettore a tre fili che va collegato opportunamente: Negativo: marrone Positivo: rosso Controllo: Arancio 83

84 Data Mar 2017 Ver. 1.3 Pag 84/137 Il controllo va collegato ad un opportuno segnale PWM. Se l ESC lo consente, è possibile alimentare anche Arduino con la batteria al litio. Basterà collegare il cavetto rosso che arriva dall'esc al pin 5V di Arduino, ma fate attenzione che sull ESC ci sia scritto BEC 5V e non valori di tensione più alti perchè altrimenti rischierete di bruciare Arduino. L unità di misura utilizzata per i motore elettrici brushless è il KV, ossia il numero di giri a minuto per Volt a vuoto, senza elica o carico installato. Il motore è in grado di girare fino al limite indicato e non oltre. Per esempio, un motore da 1500 KV alimentato da una batteria Li-Po da 2 celle (7,4V) girerà a vuoto a giri al minuto. Se la batteria ha 3 celle(11,1v) il numero di giri sarà invece di giri al minuto. Un motore con un KV maggiore, per esempio 4300 KV girerà rispettivamente a (7,4 x 4300) giri al minuto o a (11,1 x 4300) giri al minuto con le stesse batterie. Un motore non va valutato dalle dimensioni esterne bensì dalle caratteristiche dichiarate. La scelta del motore dal giusto KV è molto importante ed è altrettanto importante effettuare i propri calcoli che devono essere basati sul voltaggio della batteria sotto carico e non sul voltaggio nominale. In generale un motore a basso KV assorbe meno corrente di un motore ad elevato KV. La scelta non è facile e di solito si usa un metodo empirico o l esperienza. Di seguito un esempio di collegamento per pilotare il motore brushless. L idea di base è quella di variare la velocità del motore tramite un potenziometro collegato ad un ingresso analogico. Utilizzando la funzione map verrà modulata la velocità rispettando i valori consentiti dalla libreria servo (0, 180). Il segnale PWM letto dall ESC è dello stesso tipo del segnale utilizzato per i servo motori, ciò significa che è possibile utilizzare la stessa libreria Servo.h. Il range di segnale di default per la maggior parte dei motori brushless varia tra 1000 e 2000 microsecondi su una ripetizione periodica di 20 millisecondi (assumendo quindi un segnale PWM da 50 Hz). Vediamo un esempio di sketch: #include <Servo.h> int potpin = A0; int val; Servo brushless; void setup() brushless.attach(9); delay(1000); void loop() 84

85 Data Mar 2017 Ver. 1.3 Pag 85/137 val = analogread(potpin); val = map(val, 0, 1023, 0, 180); brushless.write(val); Qualora dovessero sorgere problemi nella regolazione della velocità del motore (ad esempio il motore inizia a girare solo quando avete ruotato quasi tutto il potenziometro) è probabile che dobbiate eseguire la taratura dell ESC. Per fare questo la procedura da seguire è questa: Collegate l'arduino, il potenziometro e l'esc come nello schema sopra (il motore e la batteria lasciateli scollegati) Alimentate l'arduino (ad esempio con il cavo usb) e ruotate il potenziometro nella posizione massima Alimentate l'esc collegandolo alla batteria lipo, a questo punto l'esc dovrà emettere dei beep. Ora ruotate il potenziometro nella posizione minima (si dovranno sentire altri segnali acustici) Scollegate la batteria LiPo, a questo punto il vostro ESC sarà calibrato Proponiamo di seguito uno sketch per la calibrazione dell ESC: #include <Servo.h> #define MAX_SIGNAL 2000 #define MIN_SIGNAL 700 #define MOTOR_PIN 9 Servo motor; void setup() Serial.begin(9600); Serial.println("Program begin..."); Serial.println("This program will calibrate the ESC."); motor.attach(motor_pin); Serial.println("Now writing maximum output."); Serial.println("Turn on power source, then wait 2 seconds and press any key."); motor.writemicroseconds(max_signal); // Wait for input while (!Serial.available()); Serial.read(); // Send min output Serial.println("Sending minimum output"); motor.writemicroseconds(min_signal); void loop() Calibrare il motore il controllo ESC è piuttosto semplice. Il segnale massimo del servo (2000 microsecondi) è inviato all ESC, in questo modo è acceso per due secondi. Quindi è inviato il segnale minimo (700 microsecondi). Una volta che l ESC emette una serie di beep di conferma, significa che è calibrato. La programmazione e la calibrazione può dipendere dai vari tipi di ESC reperibili in commercio. Si rimanda ai rispettivi manuali per un migliore utilizzo. 85

86 Data Mar 2017 Ver. 1.3 Pag 86/137 COMUNICAZIONE BLUETOOTH LA TECNOLOGIA BLUETOOTH Il Bluetooth è una specifica industriale per reti personali senza fili (WPAN, Wireless Personal Area Network). Provvede un metodo standard, economico e sicuro per scambiare informazioni tra dispositivi diversi attraverso una frequenza radio sicura a corto raggio. Questi dispositivi possono essere ad esempio palmari, telefoni cellulari, personal computer, computer portatili, stampanti, fotocamere digitali, console per videogiochi. Bluetooth `e gestito dalla Bluetooth Special Interest Group (SIG), un gruppo di compagnie che operano in diverse aree: telecomunicazione, computer, networking ed elettronica di consumo. L IEEE ha inoltre standardizzato il protocollo con il codice IEEE Questo standard è stato progettato con l'obiettivo primario di ottenere bassi consumi, un corto raggio d'azione (da 10 a 100 metri) e un basso costo di produzione per i dispositivi compatibili. Ogni dispositivo Bluetooth è in grado di gestire la comunicazione con altri 7 dispositivi sebbene essendo un collegamento di tipo master-slave solo un dispositivo per volta può comunicare col server. Un master puo` comunicare con un massimo di 7 slave, costruendo una rete detta piconet. Bluetooth lavora nelle frequenze libere ISM (Industrial, Scientific and Medical) a 2,4 GHz. In particolare gli scambi di dati avvengono su frequenze comprese tra 2,402 GHz e 2,480 GHz. Su esse sono stabiliti diversi canali di comunicazione: 79 canali con larghezza di banda di 1 MHz per le prime versioni oppure 40 con larghezze di banda di 2 MHz per la versione 4.0. La versione 1.1 e 1.2 del Bluetooth gestisce una velocità di trasferimento fino a 723,1 kbit/s, mentre la versione 2.0 gestisce una modalità ad alta velocità che consente fino a 10 Mbit/s, aumentando però la potenza assorbita. La nuova versione utilizza segnali più brevi e quindi riesce a dimezzare la potenza richiesta rispetto al Bluetooth 1.2 (a parità di traffico inviato). Il Bluetooth non è uno standard comparabile al WiFi, dato che quest'ultimo è un protocollo nato per fornire elevate velocità di trasmissione con raggio d'azione maggiore, a costo di una maggior potenza dissipata e di un hardware molto più costoso. Infatti il Bluetooth crea una Personal Area Network (PAN), mentre il WiFi crea una Local Area Network (LAN). Il Bluetooth può essere paragonato al bus USB mentre il WiFi può essere paragonato allo standard ethernet. Ogni dispositivo Bluetooth in modalità discoverable (ovvero in grado di essere rilevato da altri dispositivi) trasmette, ad intervalli regolari, pacchetti contenenti: Nome del dispositivo Classe del dispositivo Lista dei servizi offerti Altre informazioni (es. marca o altre caratteristiche del dispositivo) Questa operazione è detta advertising. Altri dispositivi possono effettuare la ricerca per rilevare device in modalità discoverable e ottenere informazioni su di essi tramite la ricezione dei messaggi di advertising. IL MODULI 86

87 Data Mar 2017 Ver. 1.3 Pag 87/137 I moduli bluetooth sono una comodissima via di comunicazione se non si vuole trasmettere dati attraverso un collegamento tramite cavi; hanno davvero molte potenzialità, poichè è possibile trasmettere semplicemente numeri, numeri decimali, stringhe di caratteri e tutto ciò che ci serve. Il moduli blutooth permettono di trasformare una porta UART USART, più comunemente conosciuta come seriale, in una porta Bluetooth, generalmente con profilo SPP(Serial Port Profile), diventando cosi una seriale tramite Bluetooth. Normalmente questo dispositivo viene usato quando si vuole far comunicare un microprocessore (Arduino nel nostro caso) con il mondo esterno, dove il mondo esterno può essere un Computer, uno Smartphone, un Tablet o quant altro la tecnologia possa fornire con una connessione Bluetooth. Esistono varie versioni di questi moduli, anche se in alcuni casi sono identici per aspetto (HC05 e HC06 con stesso CSR BC417). La differenza risiede nel firmware e quindi nelle loro funzionalità e modalità di programmazione. I moduli HC05 sono universali, configurabili sotto molti aspetti, tra cui anche la modalità (principalmente Master o Slave). I moduli HC06 sono invece più limitati, e vengono distribuiti in modalità Slave, senza la possibilità di passare da una all altra. Il firmware è noto come linvor che è comunque aggiornabile e ne esistono anche versioni opensource che ne incrementano le funzionalità. I PIN destinati alla comunicazione sono i seguenti: pin TX (1): connesso al pin RX di Arduino; pin RX (2): connesso al pin TX di Arduino mediante resistenza (o partitore di tensione), per abbassare il voltaggio dai 5v a 3.3v; E possibile utilizzare invece dei pin RX e TX di Arduino, la libreria NewSoftwareSerial (nell IDE 1.0 la SoftwareSerial) e un altra coppia di pin, lasciando i questo modo disponibile la seriale hw per debug o altri scopi. Analizziamo i PIN dei moduli HC-05 e HC-06: 87

88 Data Mar 2017 Ver. 1.3 Pag 88/137 STATE: informa se il modulo è connesso o no. Questo pin non è presente nel modulo HC-06. RX: Receive Serial Data, è il piedino che riceve i dati dal piedino di trasmissione del microcontrollore. TX: Transmit Serial Data, GND: piedino di connessione a massa VCC: piedino per la connessione al +5V KEY: serve per la configurazione del modulo tramite i comandi AT. In alcuni moduli è presente un pulsante per forzare la configurazione. Questo piedino non è presente nel modulo HC-06. In figura viene mostrato il collegamento ideale del modulo bluetooth. Con alcuni adattatori USB2UART, non è necessario utilizzare alcun paritore di tensione/ resistenza, in quanto il segnale TX è già a 3.3V. In caso di utilizzo con device sprovvisti di alimentazione 3.3V, è necessario provvedere tramite regolatore di tensione, a fornire il corretto voltaggio al modulo BT. Il modulo ha due modalità di funzionamento: Command Mode: dove è possibile inviare i comandi AT per configuare il dispositivo Data mode: trasmette e riceve le informazioni da un altro dispositivo bluetooth. La modalità di default è il DATA con le seguenti caratteristiche: Baud Rate: 9600 bps Data : 8 bits Stop Bits: 1 bit Parity : None Handshake: None Passkey: 1234 Device Name: HC-05 In appendice è mostrata la procedura per cambiare pin e nome al dispositivo. BLUETOOTH: ACCENDIAMO UN LED VIA BLUETOOTH Il termine Bluetooth si riferisce ad una specifica aperta per una tecnologia in grado di abilitare le comunicazioni voce e dati wireless a corto raggio. Il modulo bluetooth permette di comunicare in modo semplice con dispositivi dotati di bluetooth, come smartphone e pc. Primo esempio: Accendiamo un LED da uno smartphone Android. 88

89 Data Mar 2017 Ver. 1.3 Pag 89/137 Realizzate il circuito come sopra con il modulo bluetooth HC-06 oppure JY-MCU. Ora che è tutto pronto, si carica questo semplice sketch, ricordatevi di tenere scollegato il modulo bluetooth durante il caricamento altrimenti l'ide vi darà errore. void setup () Serial.begin(9600); pinmode (2, OUTPUT); void loop () char c = Serial.read(); if (c == 'F') digitalwrite (2, HIGH); if (c == 'S') digitalwrite (2, LOW); Ora dovete scaricare sul vostro smartphone un'applicazione che vi consente di inviare delle stringhe via bluetooth (ad esempio blueserial per Android ma ne esistono centinaia su Google Play). Alimentate il circuito, aprite l'app e collegatevi al modulo bluetooth (se vi chiede una passkey provate 1234). Ora inviate H e il led si accenderà, con L lo spegnerete (attenzione: il programma riconosce maiuscole e minuscole). Naturalmente qui accendiamo un semplice led, ma con pochi componenti potremo ad esempio accendere una presa di corrente o aprire la porta del garage. BLUETOOTH: ALLA PRESSIONE DI UN PULSANTE INVIAMO UN CARATTERE Con questo tutorial sarete in grado di collegare un modulo bluetooth ad Arduino ed utilizzarlo per inviare un carattere ad uno smartphone alla pressione di un pulsante. Esempio: Riceviamo un carattere sullo smartphone alla pressione di un pulsante 89

90 Data Mar 2017 Ver. 1.3 Pag 90/137 Bene, ora realizzate il circuito che vedete sopra e caricate questo sketch: int bottone = 2; int statobottone; int statobottoneprecedente; int contatore; int led = 13; void setup () Serial.begin(9600); pinmode (bottone, INPUT); pinmode (led, OUTPUT); void loop () statobottoneprecedente = statobottone; statobottone = digitalread(bottone); if (statobottone!= statobottoneprecedente) if (statobottone == LOW) Serial.print ("A"); digitalwrite (led, LOW); else digitalwrite (led, HIGH); Adesso aprite l'app e connettetevi al modulo bluetooth, appena premerete il pulsante vedrete arrivare il carattere "A" sul vostro smartphone. BLUETOOTH CON APPINVENTOR Dopo aver utilizzato un modulo Bluetooth per controllare un LED a distanza, sarebbe bello sviluppare la propria applicazione su uno smartphone. Come già detto in precedenza, per controllare questo modulo Bluetooth ci servirà un dispositivo Android, dato che non è possibile utilizzare un dispositivo ios. Per programmare con Android, bisogna scaricare Eclipse, installare Java e avere una solida base di partenza: conoscere la programmazione OOP, applicare il pattern MVC, saper leggere il debug, e altro ancora. Ma esiste un metodo più semplice: il MIT ha rilasciato un applicazione gratuita, molto intuitiva, per creare app per Android senza avere nessuna conoscenza specifica: tutto quello che occorre è un account Google e un po di curiosità. L applicazione si chiama AppInventor e può essere utilizzata online gratuitamente. 90

91 Data Mar 2017 Ver. 1.3 Pag 91/137 Per cominciare a creare la nostra applicazione, andiamo sul sito del progetto, entriamo con il nostro account e clicchiamo su New per creare un nuovo progetto. Chiamiamo il nuovo progetto Bluetooth, e direttamente dal browser andiamo a creare l interfaccia. Sulla sinistra troviamo gli elementi principali utilizzati per disegnare l aspetto dell app. Trasciniamo sullo schermo: N.3 Button N.1 ListPicker N.1 BluetoothClient Rinominiamo i pulsanti e la lista, in modo che abbiano un significato comprensibile; quindi aggiungiamo il testo dettagliato: la lista dovrà mostrare l elenco dei dispositivi bluetooth disponibili, un pulsante dovrà accendere il nostro led, un altro spegnerlo, e infine l ultimo dovrà disconnettere il bluetooth. Per cui avremo: Listpicker1: Selezione Bluetooth Button1: ON Button2: OFF Label1: non connesso Button3: disconnetti Il componente non visibile sarà il BluetoothClient1 che permetterà di utilizzare l hardware bluetooth del telefono. Per migliorare l aspetto grafico, si possono spostare i bottoni dentro un HorizontalArrangement con width impostata a fillparent. Il risultato dovrebbe essere grosso modo come quello che vedete accanto. Appinventor permette di personalizzare l aspetto grafico come meglio credete aggiungendo anche immagini per ogni pulsante oppure una immagine di sfondo. Una volta preparata la nostra interfaccia, apriamo l editor per creare la logica dell app: facciamo clic in alto a destra su: Open the Blocks Editor. Una volta aperto l editor, non dobbiamo fare altro che trascinare, dal menu a sinistra, gli elementi della nostra interfaccia e andare a combinarli tra loro. Quello che vogliamo fare, molto semplicemente, è poter scegliere il dispositivo bluetooth collegato ad Arduino e far in modo che cliccando su ON si accenda il LED, su OFF si spegna. 91

92 Data Mar 2017 Ver. 1.3 Pag 92/ Sullo Screen1 si clicca su ListPicker1 e si selezionano i primi due blocchi presenti nell immagine in alto: il primo individua il comportamento prima della selezione, il secondo identifica gli elementi del modulo che però deve attingere le informazioni da una sorgente esterna. Successivamente da Bluetooth1 si selezione il blocco con all interno AddressesAndName. In questo modo si associa il comportamento per il pulsante di listpicher, cioè un pulsante che permette di effettuare una scelta, in particolare si sceglierà uno dei moduli bluetooth presenti. È importante notare che il modulo Bluetooth, per funzionare con questo esempio, deve già essere associato al dispositivo Android dalle impostazioni del telefono. 2. Adesso il blocco funzionale permette di definire il comportamento dopo aver selezionato l elemento desiderato. Si connette il client bluetooth alla selezione effettuata. Nel frattempo si cambia il colore (verde) all etichetta Label1 e si cambia anche il testo che sarà Connesso. 3. In questi due blocchi vengono definiti i comportamenti una volta premuti i due pulsanti Button1 e Button2. Il blocco viola identifica il comando che invia un testo tramithe bluetooth. Ricordare che il soft- 92

93 Data Mar 2017 Ver. 1.3 Pag 93/137 ware è case sensitive, quindi riconosce maiuscole e minuscole. Se H e L sono maiuscole lo dovranno essere anche sul firmware su Arduino. 4. Nell ultimo blocco si prevede la pressione del pulsante di disconnessione. Anche questa volta si cambia il colore (rosso) e si cambia il testo in disconnesso Il firmware da caricare su Arduino è molto semplice e può essere modificato a proprio piacimento: void setup () Serial.begin(9600); pinmode (2, OUTPUT); void loop () char c = Serial.read(); if (c == 'H') digitalwrite (2, HIGH); if (c == 'L') digitalwrite (2, LOW); 93

94 Data Mar 2017 Ver. 1.3 Pag 94/137 WIFI: INTERNET OF THINGS La tecnologia WiFi propone due modalità operative: Una rete senza fili permette di connettere più apparecchiature o più computer in rete, senza alcun collegamento filare. Grazie alle tecnologie wireless, è quindi possibile accedere a delle risorse condivise, soprattutto a internet, partendo da luoghi differenti: si parla così di mobilità. La tecnologia WiFi (detta anche ) è la tecnologia di rete locale senza fili più in uso. Questa tecnologia permette di connettere dei computer, o apparecchiature diverse, su distanze di un centinaio di metri circa ad una banda condivisa che può arrivare da diversi megabits al secondo (Mbps) fino a centinaia di Mbps. Ad hoc: una modalità peer to peer che permette di collegare fra loro dei computer dotati di adattatori senza fili; Infrastruttura: permette di collegare dei computer ad una rete filare attraverso un'apparecchiatura detta punto d'accesso, talvolta siglato AP per Access point. Una rete senza fili (in inglese wireless network) è, come indica il suo nome, una rete in cui almeno due terminali (computer portatile, PDA, ecc.) possono comunicare senza collegamento filare. Negli ultimi anni, grazie all evoluzione tecnologica, si sono verificati alcuni eventi interessanti che hanno mutato la nostra vita quotidina: la rete internet è diventata diffusa praticamente ovunque, nel frattempo i costi di connessione si sono ridotti notevolemte, sono stati creati molti dispositivi con capacità di connessione wireless e, non ultimo, la penetrazione nel mercato degli smartphone registra incrementi di anno in anno. Tutto ciò ha creato una nuova opportunità chiamata Internet of Things. Internet of Things, in italiano Internet delle cose o Internet degli oggetti, cambierà tutto, compresi noi stessi. La possibilità di controllare gli oggetti di casa, dell auto e dell ufficio sarà porterà ad una rivoluzione senza precedenti. Potrà sembrare un'affermazione azzardata, ma basta pensare all'impatto che Internet ha già avuto su istruzione, comunicazioni, economia, scienza, amministrazione pubblica e sull'umanità. Si tratta chiaramente di una delle invenzioni più importanti e potenti di tutta la storia dell'uomo. L'Internet delle cose rappresenta la prossima evoluzione di Internet, con un notevole miglioramento della capacità di raccogliere, analizzare e distribuire dati convertibili in informazioni, conoscenza e, in ultima istanza, saggezza. In questo scenario l'internet delle cose diventa incredibilmente importante. ciò che potrà aiutare a ottenere. Attualmente l'internet delle cose è costituito da una serie di reti eterogenee, non collegate tra loro e appositamente create per scopi specifici. Le automobili di oggi, ad esempio, dispongono di più reti per gestire il funzionamento del motore, le funzioni di sicurezza, i sistemi di comunicazione, etc.. Anche gli edifici commerciali e residenziali hanno vari sistemi di controllo per HVAC (Heating, Ventilation and Air Conditioning: riscaldamento, aerazione e condizionamento dell'aria), servizi di telefonia, sicurezza e illuminazione. Con l'evoluzione dell'internet delle cose, queste reti (e molte altre) avranno accesso a ulteriori funzionalità di sicurezza, analisi e gestione (vedere la figura 2). In questo modo l'internet delle cose diventerà ancora più potente in termini di Per poter intuire l'importanza dell'internet delle cose è necessario comprendere le differenze tra Internet e il World Wide Web (o semplicemente Web), termini che vengono spesso utilizzati come sinonimi. Internet è il 94

95 Data Mar 2017 Ver. 1.3 Pag 95/137 livello fisico (o rete) composto da switch, router e altre apparecchiature. La sua funzione principale è trasportare informazioni da un punto a un altro in modo rapido, affidabile e sicuro. Il Web, invece, è un livello applicativo sovrapposto a Internet. Il suo ruolo specifico è fornire un'interfaccia che renda utilizzabili le informazioni disponibili in Internet. Nel mondo dell'internet delle cose, persino le mucche saranno connesse. Un servizio speciale pubblicato su The Economist con il titolo "Augmented Business" (L'impresa aumentata) ha descritto come verranno monitorate le mucche (vedere la figura 4). Sparked, una startup olandese, impianta sensori nelle orecchie dei bovini per consentire agli allevatori di tenere sotto controllo le loro condizioni di salute e di monitorarne gli spostamenti. Il risultato? Una fornitura di carne più sicura e abbondante per i consumatori. In media ogni mucca genera circa 200 MB di informazioni all'anno. PROTOCOLLI WIFI La norma definisce gli strati inferiori del modello OSI per una connessione senza fili che utilizza delle onde elettromagnetiche, cioè: Il livello fisico (siglato talvolta livello PHY), che propone tre tipi di codifica dell'informazione; Il livello collegamento di dati, costituito dal due substrati: il controllo di collegamento logico (Logical Link Control, o LLC) e il controllo di accesso al supporto (Media Access Control, o MAC); Il livello fisico definisce la modulazione delle onde radio-elettriche e le caratteristiche della segnaletica per la trasmissione dei dati, mentre il livello collegamento di dati definisce l'interfaccia tra il bus del terminale e il livello fisico, soprattutto un metodo di accesso vicino a quello usato nello standard ethernet e le impostazioni di comunicazione tra le diverse stazioni. La norma propone in realtà tre strati fisici, che definiscono delle modalità di trasmissione alternative: Livello Collegamento di dati (MAC) È possibile usare qualsiasi protocollo di alto livello su una rete senza fili WiFi come su una rete ethernet. Riepilogo di protocollo Wi-Fi IEEE Protocollo Frequenza Segnale Velocità massima Legacy ,4 GHz FHSS o DSSS 2 Mbps a 5 GHz OFDM 54 Mbps b 2,4 GHz RISORSE UMANE-DSSS 11 Mbps g 2,4 GHz OFDM 54 Mbps n 5 o di 2,4 GHz OFDM 600 Mbps (teorici) AC 5 GHz 256 QAM 1,3 Gbps Legacy Rilasciato nel 1997 Due velocità 2 e 1 Mbps Frequency hopping spread spectrum (FHSS) o direct-sequence spread spectrum (DSSS) Tre canali non sovrapposti industriale, scientifico, medico (ISM) a frequenza sulla banda a 2,4 GHz Rilevamento della accesso di più con un'elusione di collisione (CSMA-CA) originariamente portante definita 95

96 Data Mar 2017 Ver. 1.3 Pag 96/ a Lanciato nel 1999 Velocità di dati con diversi tipi di modulazione: 6, 9, 12, 18, 24, 36, 48 e 54 Mbps Orthogonal frequency-division multiplexing (OFDM) con i canali sottoportante non sovrapposti canali sprovvisti di licenza national infrastruttura informatica (UNII) nella banda di frequenza da 5 GHz b 1 Lanciato nel Velocità di dati con diversi tipi di modulazione: 1, 2, 5,5 e 11 Mbps 3 Alta-velocità-direct sequence spread spectrum (risorse Umane-DSSS) 4 Tre canali non sovrapposti industriale, scientifico, medico (ISM) a frequenza sulla banda a 2,4 GHz g Lanciato nel 2003 Velocità di dati con diversi tipi di modulazione: 6, 9, 12, 18, 24, 36, 48 e 54 Mbps; può essere tornato a 1, 2, 5.5 e 11 Mbps utilizzando DSSS e CCK Orthogonal frequency-division multiplexing (OFDM) con i canali sottoportante 52; compatibile con b utilizzando DSSS e CCK Tre canali non sovrapposti industriale, scientifico, medico (ISM) a frequenza sulla banda a 2,4 GHz n Lanciato nel 2004 Velocità di dati con diversi tipi di modulazione: 1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54 Mbps (vedere la tabella riportata di seguito) Orthogonal frequency-division multiplexing (OFDM) utilizzando multiple-input/multiple-output (MIMO) e channel bonding, unione (CB) Tre canali non sovrapposti industriale, scientifico, medico (ISM) a frequenza sulla banda a 2,4 GHz 12 non sovrapposti canali sprovvisti di licenza national infrastruttura informatica (UNII) nella banda di frequenza da 5 GHz con e senza CB AC Rilasciato a gennaio 2014 Velocità di trasferimento dati svariate esigenze di tipi di modulazione; 200 Mbps, 400 Mbps, 433 Mbps, 600 Mbps, 867 Mbps, 1,3 Gbps. 24 non sovrapposti canali sprovvisti di licenza national infrastruttura informatica (UNII) nella banda di frequenza da 5 GHz MODULO ESP8266 Tra i vari disposivi presenti nel mercato, un modulo molto economico che permette di collegare Arduino ad internet è l ESP8266, in particolare la versione ESP-01. Il modulo permette di stabilire una connessione WiFi diretta tra pc e Arduino una volta stabilita la connessione e aprendo la pagina html creata ad hoc. In questo modo potremo inviare comandi all'arduino premendo i pulsanti direttamente da un browser sul nostro pc. All interno del chip ESP8266 si trova un microcontrollore a 32 bit completo di ROM, RAM e SRAM per programma e dati. Il chip dispone di linee I/O digitali ed ingressi analogici, oltre che porte di comunicazione come I2C, SPI e UART. 96

97 Data Mar 2017 Ver. 1.3 Pag 97/137 L'ESP8266 è un System-On-a-Chip a 32 bit, cioè un sistema completo integrato su un chip, infatti incorpora nativamente le funzionalità Wi-Fi, inclusa la gestione intelligente dell'interfaccia radio, e rende disponibili anche una serie di risorse e di periferiche che gli permettono di assolvere pure i compiti di un comune microcontrollore, da usare seguendo tre ben distinte modalità operative: 1) un suo primo utilizzo come mero modulo di comunicazione Wi-Fi, collegabile alla porta seriale di un microcontrollore qualsiasi, da comandare per mezzo di comandi AT che vengono richiamati dall'mcu esterno. Ciò è reso possibile dal caricamento di un firmware apposito, che rimane residente nell'esp8266; 2) può essere usato come microcontrollore autonomo abilitato al WI-FI, programmabile in modo interattivo e immediato mediante il linguaggio di scripting, interpretato Lua (il Python del mondo embedded). E' infatti disponibile un interprete Lua per ESP8266 e anche un semplice IDE ad esso dedicato, di complessità e con funzionalità intermedie fra l'ide di Arduino e quelli basati su Eclipse o Visual Studio. Lua, tanto per fare un esempio, è comunemente utilizzato in ambito OpenWrt e, in pratica, in questa modalità, l'esp8266 diventa una Yùn da 5-10 USD, a seconda della piedinatura della scheda; 3) infine può essere utilizzato sempre come MCU autonomo abilitato al WI-FI, ma programmabile in modo tradizionale in C/C++. Esso infatti supporta una toolchain completa basata su GCC e integrata in Eclipse, di cui - per ora - manca solo un supporto concreto al debugging, per il quale si brancola ancora nel buio. Con alcuni accorgimenti è programmabile anche dall IDE di Arduino. Di seguito ci occuperemo specificamente della prima modalità, usando l'esp8266 come una sorta di interfaccia da seriale a Wi-Fi, con la particolarità davvero interessante: esso si può configurare non solo come client, ma anche come access point wireless, o persino come entrambe le cose allo stesso tempo, in modalità bridge tra due reti. Come ciliegina sulla torta, per chi utilizza prevalentemente Arduino e il suo linguaggio semplificato, vi è la presenza di una serie di librerie al momento non ufficiali che rendono l'accesso a Internet dall'interno di uno sketch un gioco da ragazzi. A tutti coloro che magari preferiscono programmare i propri microcontrollori preferiti in C/C++ o addirittura in Assembly, posso già anticipare che il tutto è ugualmente riconducibile al banale utilizzo di semplici comandi AT sulla porta seriale. Le capacità di questo modulo sono veramente ampie ed includono: Protocollo b/g/n WiFi Direct (P2P) Protocollo TCP/IP integrato Molto importante da ricordare: il modulo richiede un alimentazione di 3,3 V, non alimentarlo a 5V! Proponiamo lo schema del modulo. PIN Nome Descrizione 1 GND Massa 2 TX UART0 di Trasmissione 3 GPIO2 Ha una pull-up interna 4 CH_PD Chip enable, stato HIGH 5 GPIO0 Ha una pull-up interna 6 RESET Segnale di reset esterno 7 RX UART0 in ricezione 8 VCC +3.3V alimentazione Il modulo offre la possibilità di essere connesso facilmente tramite i 2 pin seriali TX ed RX ed interagire con lo sketch medianti comandi AT, uno specifico insieme di comandi per la comunicazione tra modem. Il modulo può essere controllato dalla rete locale WiFi e collegato tramite un opportuna pagina web dedicata. Il pin GPIO (General Purpose Input/Output) può essere programmato per accendere un led o un relè. In questa maniera, da qualsiasi parte del mondo dove è possibile accedere ad internet, sarà possibile controllare un utilizzatore anche senza l aulidio di ulteriore microcontrollore. 97

98 Data Mar 2017 Ver. 1.3 Pag 98/137 COLLEGAMENTO DEL MODULO Mostriamo un semplice schema di connessione diretta ai pin TX e RX di Arduino: Nel primo test effettueremo una semplice comunicazione con il modulo. Su Arduino è necessario caricare uno sketch vuoto, con le funzioni void setup() e void loop() totalmente vuote. Adesso proviamo ad utilizzare i comandi AT. Aprire il monitor seriale dell IDE configurandolo come segue Inviare il comando AT+RST per resettare il modulo ed avere ulteriori informazioni 98

99 Data Mar 2017 Ver. 1.3 Pag 99/137 Impostare la modalità desiderata tramite il comando AT+CWMODE=1, dopo l uguale va inserito il numero corrispondente alla modalità desiderata 1. 1 Sta (Station-Client) 2. AP (Access Point) 3. Both (entrambe) Tramite il comando AT+CWLAP è possibile vedere quali reti WiFi sono nel raggio d azione del modulo Adesso con il comando AT+CWJAP ci si può collegare alla rete WiFi desiderata. Questo comando accetta come primo parametro l SSID della rete e come secondo parametro la password di accesso. Infine co il comando AT+CIFSR si può conoscere l indirizzo IP assegnato da router ed il MAC Address del modulo. CONTROLLARE UN PIN DIGITALE DA UNA PAGINA WEB Questo tutorial mostra come inviare informazioni da una pagina web al modulo WiFi finora descritto e permettere di abilitare un pin digitale di Arduino. Vediamo il collegamento hardware: 99

100 Data Mar 2017 Ver. 1.3 Pag 100/137 Il secondo Arduino è opzionale, serve solo per leggere le informazioni provenienti dal modulo ESP8266. Il doppio collegamento all alimentazione dei 3.3 V serve a garantire più corrente al modulo. Prima di tutto bisogna caricare uno sketch che permetta di inizializzare il modulo e prepararlo alla ricezione di comandi da internet. La descrizione delle varie righe è rimandata ai commenti. Ed ecco lo sketch da caricare: #include <SoftwareSerial.h> #define DEBUG true SoftwareSerial myserial(9, 10); //creazione di una porta seriale software per il collegamento con l'altro Arduino (facoltativa, serve solo per il debugging) void setup() Serial.begin(115200); //inizializza la comunicazione con il modulo ESP8266 (cambiare la velocità se quella del modulo è differente, di solito è o o myserial.begin(9600); //inizializza la comunicazione con l'atra Arduino (facoltativa, serve solo per il debugging) pinmode(11, OUTPUT); digitalwrite(11, LOW); pinmode(12, OUTPUT); digitalwrite(12, LOW); pinmode(13, OUTPUT); digitalwrite(13, LOW); senddata("at+rst r n", 2000, DEBUG); //resetta modulo senddata("at+cwmode=2 r n", 1000, DEBUG); // configura come access point senddata("at+cifsr r n", 1000, DEBUG); // ottieni un indirizzo ip senddata("at+cipmux=1 r n", 1000, DEBUG); // configura per connessioni multiple senddata("at+cipserver=1,80 r n", 1000, DEBUG); // avvia server sulla porta 80 void loop() if (Serial.available()) //controlla se il modulo ESP sta inviando un messaggio if (Serial.find("+IPD,")) //Cerca nella comunicazione seriale la stringa di testo "+IPD," questa è una stringa che viene inviata quando viene premuto il pulsante nella pagina html delay(1000); int connectionid = Serial.read() - 48; //Ottieni il connection id, sottrai 48 perchè nella tabella ASCII lo zero è il 48. Serial.find("pin="); adesso cerca "pin=" int pinnumber = (Serial.read() - 48) * 10; //leggi il primo numero e moltiplicalo per 10, es per il pin 13 leggi 1 e moltiplicalo per 10 pinnumber += (Serial.read() - 48); // leggi il secondo numero e sommalo al primo, es per il pin 13 leggi 3 e sommalo a quello che avevamo prima (10) 100

101 Data Mar 2017 Ver. 1.3 Pag 101/137 digitalwrite(pinnumber,!digitalread(pinnumber)); l'opposto di quello che c'è sul pin 13 stesso) //cambia di stato il pin 13 (impostando //componi il comando di chiusura da inviare al modulo String closecommand = "AT+CIPCLOSE="; closecommand += connectionid; // attacca il connection id closecommand += " r n"; senddata(closecommand, 1000, DEBUG); // invia il comando di chiusura /*Funzione usata per inviare i dati al modulo ESP8266 Parametri: command - il dato comando da inviare timeout - il tempo massimo di attesa per una risposta debug - attiva o disattiva l'invio di dati per il serial monitor (true = si, false = no) Returns: la risposta dell' esp8266 (se c' 'e8 una risposta) */ String senddata(string command, const int timeout, boolean debug) String response = ""; Serial.print(command); //invia il comando all'esp8266 long int time = millis(); while ((time + timeout) > millis()) while (Serial.available()) char c = Serial.read(); //componi la risposta coi caratteri ricevuti dal modulo response += c; if (debug) myserial.print(response); return response; Questo invece è il codice Html per creare la pagina da dove controllare l'arduino, quello si deve fare è: creare una nuova cartella creare all'interno della cartella un nuovo documento di testo copiare le righe di codice che vedete qui sotto nel documento e salvarlo rinominare il file e modificarne l'estensione in ".html" (ad esempio "myesp8266control.html") il codice html usa la libreria Javascript JQuery, quindi abbiamo ne abbiamo bisogno. Per ottenerla basta scaricarla da questo link: ed inserirla nella stessa cartella del file html precedentemente creato <html> <head> </head> <body> <title>esp8266 LED Control</title> <!-- in the <button> tags below the ID attribute is the value sent to the arduino --> <button id="11" class="led">toggle Pin 11</button> <!-- button for pin 11 --> <button id="12" class="led">toggle Pin 12</button> <!-- button for pin 12 --> <button id="13" class="led">toggle Pin 13</button> <!-- button for pin 13 --> <script src="jquery.min.js"></script> <script type="text/javascript"> $(document).ready(function() $(".led").click(function() var p = $(this).attr('id'); get id value (i.e. pin13, pin12, or pin11) send HTTP GET request to the IP address with the parameter "pin" and value "p", then execute the function $.get(" pin:p); execute get request ); </script> ); 101

102 Data Mar 2017 Ver. 1.3 Pag 102/137 </html> </body> Adesso dovrete cercare il modulo tra le connessioni WiFi disponibili, connettervi, e aprire la pagina html che avete creato, premendo il pulsante relativo al pin 13 il led presente sul vostro Arduino dovrà cambiare di stato, quindi si accenderà o spegnerà (fonte: TECNOLOGIA RFID L acronimo RFID significa Radio Frequency InDentification. Tale tecnologia utilizza campi elettromagnetici a radiofrequenza per facilitare la comunicazione dei dati con lo scopo di indentificare, localizzare o analizzare lo stato di oggetti. Un dispositivo RFID utilizza un etichetta che viene attaccata all oggetto che deve essere identificato. Un altro dispositivo ha il compito di ricevere o trasmettere un segnale opportuno per l identificazione. Solitamente un lettore RFID viene collegato ad un computer con installato un software di gestione per elaborare i dati letti. La comunicazione tra l etichetta (che può essere contenuta anche in una card) ed il lettore avviene attraverso una tensione di alimentazione che solitamente è sul lettore. In questo caso, quindi, l eticchetta è passiva. Per la regolamentazione delle frequenze esistono degli standard ISO (International Standardization for Organization) al fine di definire le proprietà fisiche e le caratteristiche comunicative delle etichette e dei lettori. MODULO RFID Lo standard internazionale ISO definisce le interfacce elettriche e i protocolli di comunicazione per gli utilizzatori RFID. La frequenza adoperata è di 13,56 MHz e si ha una distanza operativa di circa 10 cm. Il modulo RFID RC522 permette di poter leggere facilmente le varie tessere magnetiche con Arduino. In commercio si trovano tanti tipi di etichette e di carte. La più diffusa è la tecnologia Mifare. In questa sezione mostreremo come collegare il modulo MFRC522 della casa produttrice Mifare. Il collegamento da effettuare dal dispositivo di lettura delle tessere ed Arduino è abbastanza semplice, basta collegare i PIN come riportato nella seguente tabella: RFID-RC522 Module Arduino Uno 1 - SDA Digital SCK Digital MOSI Digital MISO Digital IRQ --unconnected GND Gnd 7 - RST Digital V 3.3v Come è possibile notare, il modulo deve essre alimentato a 3,3 V e non a 5 V. Su Arduino possiamo prelevare la tensione richiesta dal pin opportuno. Proponiamo si seguito lo schema di collegamento ricordando che su Arduino molti pin non sono intercambiabili (PWM), per cui i collegamenti proposti devono rimanere come quelli proposti. 102

103 Data Mar 2017 Ver. 1.3 Pag 103/137 Per il corretto funzionamento del RFID reader, è necessario scaricare la libreria ufficiale del dispositivo: RFID.h oppure AddicoreRFID. Per gli esempi mostrati di seguito abbiamo utilizzato la libreria chiamata rfidmaster.h. 1 Programma: Mostriamo nel monitor seriale la card letta Con questo programma, sarà possibile leggere il codice delle tessera magnetica, che viene passato sopra il dispositivo. #include <SPI.h> #include <RFID.h> //Vengono definiti PIN del RFID reader #define SDA_DIO 10 //53 per Mega #define RESET_DIO 9 #define delayread 1000 //Time of delay //Viene creata una istanza della libreria RFID RFID RC522(SDA_DIO, RESET_DIO); void setup() Serial.begin(9600); //Abilita SPI SPI.begin(); //Viene inizilizzato RFID reader RC522.init(); Serial.println("Setup"); void loop() //Temporary loop counter byte i; //Se viene letta una tessera if (RC522.isCard()) //Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); //Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); delay(delayread); Serial.println(); Serial.println(); 103

104 Data Mar 2017 Ver. 1.3 Pag 104/137 Il codice riportato precedentemente è abbastanza semplice da capire, sopratutto con i commenti presenti. Nel loop(), viene effettuato un controllo, sulla presenza di una tessera magnetica sopra il dispositivo; se il risultato è true, viene caricato in una stringa, il codice delle tessera magnetica e mostrato successivamente nel seriale. Ed ecco il risultato: 2 Programma: Verifichiamo l identità di una tessera In questo programma, vedremo come poter stabilire se una tessera è abilitata a compiere una certa azione, ad esempio accendere una luce, oppure aprire una porta. #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 //53 per Mega #define RESET_DIO 9 #define delayread 1000 //Time of delay #define delayled 2000 #define ledverde 3 #define ledrosso 4 /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); String codiceautorizzato = "EC40E03478"; void setup() Serial.begin(9600); /* Abilita SPI*/ SPI.begin(); /* Viene inizilizzato RFID reader */ RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop() /* Temporary loop counter */ byte i; //Se viene letta una tessera if (RC522.isCard()) //Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); //Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); if(verificacodice(codiceletto)) Serial.println("Tessera autorizzata"); accendiled(ledverde); else Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); 104

105 Data Mar 2017 Ver. 1.3 Pag 105/137 //Questa funzione verifica se il codice letto è autorizzato boolean verificacodice(string codiceletto) if(codiceletto.equals(codiceautorizzato)) return true; else return false; //Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin) digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); Il metodo verificacodice, non fa altro che prendere il codice delle tessera che viene letta e confrontato con quello salvato in memoria. Se la tessera è autorizzata, viene accesso un LED verde, mentre se la tessera non è autorizzata, viene accesso il LED rosso. 3 Programma: Versione 2.0 del lettore di autorizzazioni Come avete potuto notare precedentemente, il codice è stato realizzato per la lettura di una sola tessera autorizzata; ma come possiamo fare per avere un numero maggiore di tessere abilitate? In questa seconda versione, verrà data una prima soluzione. In pratica i codici letti verranno trasformati in interi e sommati. La somma del codice, dovrebbe rappresentare il codice vero e proprio, ma potrebbe capitare che ci posso sono essere due tessere diverse con la stessa somma di cifre. Comunque i codici autorizzati sono inseriti in un array di interi. Vediamo il codice: /*Questo programma permette effettuare la lettura di una tessera magnetica e stabilire se quest'ultima 'e8 stata autorizzata. PINOUT: RC522 MODULE Uno Nano SDA D10 SCK D13 MOSI D11 MISO D12 IRQ N A GND GND RST D9 3.3V 3.3V Autore Giacomo Bellazzi Versione 2.0 Novit 'e0: *Possibilit 'e0 di inserire pi 'f9 di una tessera autorizzata * */ #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 //53 per Mega #define RESET_DIO 9 #define delayread 1000 //Time of delay #define delayled 2000 #define ledverde 3 #define ledrosso 4 /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); long uno = 696; //rappresenta la somma delle 4 cifre int due = 450; int codiciautorizzati[] = uno,due ; //contiene i codici autorizzati void setup() Serial.begin(9600); //Abilita SPI SPI.begin(); 105

106 Data Mar 2017 Ver. 1.3 Pag 106/137 // Viene inizilizzato RFID reader RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop() // Temporary loop counter byte i; //Se viene letta una tessera if (RC522.isCard()) //Viene letto il suo codice RC522.readCardSerial(); int codiceletto = 0; Serial.println("Codice delle tessera letto:"); //Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) codiceletto+=rc522.sernum[i]; Serial.println(codiceLetto); if(verificacodice(codiceletto)) Serial.println("Tessera autorizzata"); accendiled(ledverde); else Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); //Questa funzione verifica se il codice Letto 'e8 autorizzato boolean verificacodice(int codiceletto) boolean autorizzato = false; for(int i = 0; i < sizeof(codiciautorizzati) ; i++) if(codiceletto==codiciautorizzati[i]) autorizzato = true; return autorizzato; //Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin) digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); 4 Programma: utilizzare più codici autorizzati nello stesso programma In questo quarto e ultimo programma vedremo come inserire diversi codice pre-autorizzati all interno del nostro programma, per verificare a run-time se il codice letto è effettivamente autorizzato: * Questo programma permette effettuare la lettura di una tessera magnetica e stabilire se quest'ultima è stata autorizzata. PINOUT: RC522 MODULE Uno Nano SDA D10 SCK D13 MOSI D11 MISO D12 IRQ N A GND GND RST D9 3.3V 3.3V Autore Giacomo Bellazzi Versione 1.0 * 106

107 Data Mar 2017 Ver. 1.3 Pag 107/ #include <SPI.h> #include <RFID.h> * Vengono definiti PIN del RFID reader* #define SDA_DIO per Mega #define RESET_DIO 9 #define delayread 1000 Time of delay #define delayled 2000 #define ledverde 3 #define ledrosso 4 * Viene creata una istanza della RFID libreria * RFID RC522(SDA_DIO, RESET_DIO); String codiceautorizzato1 = "EC40E03478"; String codiceautorizzato2 = "EC40E03479"; String codiceautorizzato3 = "EC40E03480"; void setup() Serial.begin(9600); * Abilita SPI* SPI.begin(); * Viene inizilizzato RFID reader * RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop() * Temporary loop counter * byte i; Se viene letta una tessera if (RC522.isCard()) Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); if(verificacodice(codiceletto,codiceautorizzato1) verificacodice(codiceletto,codiceautorizzato2) verificacodice(codiceletto,codiceautorizzato3)) Serial.println("Tessera autorizzata"); accendiled(ledverde); else Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); Questa funzione verifica se il codice Letto è autorizzato boolean verificacodice(string codiceletto, String codiceautorizzato) if(codiceletto.equals(codiceautorizzato)) return true; else return false; Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin) digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); La chiave del programma è quella di utilizzare una funzione che verifica se due strings sono uguali, cioè se 107

108 Data Mar 2017 Ver. 1.3 Pag 108/137 due codici delle tessere magnetiche sono uguali e l operatore logico or. Per entrare nell if, basterà che almeno uno dei tre codici sia uguale. I codici riportati in questo capitolo, sono elementi basi per costruire progetti più interessanti, come sistemi di antifurto, controllo di accessi e uscite in un luogo etc.. Vedremo come questi progetti nei prossimi capitoli. I codici dei programmi presenti in questo capitolo, sono scaricabili dalla repo di Github: 108

109 Data Mar 2017 Ver. 1.3 Pag 109/137 AVANZATO MULTITASKING CON ARDUINO: LAMPEGGIO SENZA DELAY Arduino elabora un processi software senza l ausilio di un sistema operativo. Può dunque eseguire un programma alla volta. Ciò non significa che non è possibile gestire operazioni multiple contemporaneamente. E necessario un approccio differente rispetto a quello utilizzato finora. Prima di tutto non bisogna utilizzare il comando delay(). Tale comando, oltre a monopolizzare l intero processore, è uno dei primi che vengono imparati nel linguaggio di programmazione per Arduino. Durante una chiamata di delay(), non è possibile rilevare i segnali agli ingressi o azionare un uscita, tantomeno eseguire delle elaborazioni. Per cui vediamo come sostituire il comando delay() con un altro che permetta l esecuzione contemporanea di altre funzioni. Come esempio partiremo dal primo sketch della guida, il blink di un led. Per i nostri scopi, prenderemo in considerazione anche lo sketch relativo allo sweep di un servo motore. In entrambi i casi viene utilizzata la funzione delay(). Una semplice tecnica per implementare la temporarizzazione è programmare e mantenere sotto controllo un orologio. Invece di sospendere ogni operazione, sarà sufficiente osservare regolarmente un orologio e decidere quando agire. Così facendo il processore sarà libero per altre operazioni. E possibile attingere all esempio direttamente dall IDE di Arduino. Sotto File à Esempi à 02. Digital possiamo aprire BlinkWithoutDelay: const int ledpin = 13; //Variabili che cambieranno: int ledstate = LOW; //il numero del pin del LED //stato del LED //Generalmente, si dovrebbe usare "unsigned long" per variabili che memorizzano il tempo //Il valore diverrà rapidamente molto grande per essere contenuto in un int unsigned long previousmillis = 0; //registrerà l ultimo tempo del LED unsigned long currentmillis; costanti che non cambieranno : const long interval = 1000; //intervallo del lampeggio (in millisecondi) void setup() //settare il pin digitale come output: pinmode(ledpin, OUTPUT); void loop() //si deve controllare se è passato il tempo per far lampeggiare il LED; in questo caso //se la differenza tra in tempo attuale e l ultimo tempo dell accensione //è maggiore dell intervallo al quale si vuole accendere il LED currentmillis = millis(); //registra nella variabile il tempo trascorso dall accensione if (currentmillis - previousmillis >= interval) //effettua il confronto //registra l ultima volte che è stato acceso il LED previousmillis = currentmillis; //se il LED è spento lo accende e: if (ledstate == LOW) ledstate = HIGH; else ledstate = LOW; //setta il LED con lo stato della variabile ledstate: digitalwrite(ledpin, ledstate); 109

110 Data Mar 2017 Ver. 1.3 Pag 110/137 A prima vista questo metodo potrebbe sembrare un modo più complicato per far lampeggiare un LED. L esempio precedente mette in evidenza un concetto più ampio: lo Stato Macchina. Infatti, lo sketch ricorda lo stato corrente del LED e il tempo nel quale è stato commutato. Ad ogni passo del ciclo, osserva l orologio con la funzione millis() per vedere se è il caso di cambiare lo stato del LED nuovamente. Vediamo quindi una variante più interessante che ha un differente tempo di accensione e di spegnimento, chiamiamo il programma FlashWithoutDelay. int ledpin = 13; int ledstate = LOW; unsigned long previousmillis = 0; long OnTime = 250; //millisecondi del tempo di ON long OffTime = 750; //millisecondi del tempo di OFF void setup() pinmode(ledpin, OUTPUT); void loop() //controlla se è si è raggiunto il tempo per cambiare lo stato del LED unsigned long currentmillis = millis(); if((ledstate == HIGH) && (currentmillis - previousmillis >= OnTime)) ledstate = LOW; spegni il LED previousmillis = currentmillis; //ricorda il tempo digitalwrite(ledpin, ledstate); //aggiorna lo stato del LED else if ((ledstate == LOW) && (currentmillis - previousmillis >= OffTime)) ledstate = HIGH; //accendi il LED previousmillis = currentmillis; //ricorda il tempo digitalwrite(ledpin, ledstate); //aggiorna l attuale stato del LED Ciò che è stato creato è il cosidetto stato macchina. Nell esempio precedente sono state create delle variabili che tengono traccia dello stato del LED. Inoltre, ci sono delle variabili che tracciano l ultimo cambiamento del LED. Questo descritto è lo stato dello stato macchina. D altra parte, nel codice è presente un comando che guarda lo stato e decide quando e come è necessario cambiare. Qui siamo di fronte alla macchina. Ogni volta che si passa dal loop viene eseguita la macchina che tiene congo degli stati aggiornati. Per combinare stati macchina multipli, osserviamo un progetto che prevede la gestione il lampeggio indipendente di due LED contemporaneamente: E necessario creare un altro stato della macchina per il secondo LED che lampeggia in maniera completamente differente dal primo. Usando due differenti stati macchina, sarà possibile far lampeggiare i due LED in 110

111 Data Mar 2017 Ver. 1.3 Pag 111/137 maniera indipendente l uno dall altro, vediamo lo sketch. int ledpin1 = 12; //primo LED int ledstate1 = LOW; // stato del primo LED unsigned long previousmillis1 = 0; long OnTime1 = 250; long OffTime1 = 750; int ledpin2 = 13; //secondo LED int ledstate2 = LOW; unsigned long previousmillis2 = 0; long OnTime2 = 330; long OffTime2 = 400; void setup() //dichiarazione delle uscite pinmode(ledpin1, OUTPUT); pinmode(ledpin2, OUTPUT); void loop() unsigned long currentmillis = millis(); if((ledstate1 == HIGH) && (currentmillis - previousmillis1 >= OnTime1)) ledstate1 = LOW; //parte con lo stato basso previousmillis1 = currentmillis; //ricorda il tempo digitalwrite(ledpin1, ledstate1); //aggiorna lo stato del LED1 else if ((ledstate1 == LOW) && (currentmillis - previousmillis1 >= OffTime1)) ledstate1 = HIGH; //accendi il led previousmillis1 = currentmillis; //ricorda il tempo digitalwrite(ledpin1, ledstate1); //aggiorna lo stato del LED if((ledstate2 == HIGH) && (currentmillis - previousmillis2 >= OnTime2)) ledstate2 = LOW; spegni previousmillis2 = currentmillis; //ricorda il tempo digitalwrite(ledpin2, ledstate2); //aggiorna lo stato del LED else if ((ledstate2 == LOW) && (currentmillis - previousmillis2 >= OffTime2)) ledstate2 = HIGH; previousmillis2 = currentmillis; digitalwrite(ledpin2, ledstate2); Nella stessa maniera è possibile aggiungere tanti stati macchina quante sono le uscite a disposizione su Arduino. Ogni stato macchina può avere il suo tempo indipendente dal resto. ESERCIZIO: aggiungere un terzo stato macchina. SUGGERIMENTO: si duplichino tutti gli stati delle variabili e il codice da uno degli stati macchina. Rinominare tutte le variabili per evitare coflitti con il primo stato macchina. Utilizzare le classi Come è possibile notare, il codice precedente è molto ripetitivo. L unica cosa che cambia è il nome della variabile. A questo punto, potremmo utilizzare la potenza del linguaggio C++ che supporta la programmazione orientata a oggetti. Utilizzando questa capacità, sarà possibile mettere insieme tutte le variabili di stato e le funzioni per il lampeggio di un LED all interno di una classe. Vediamo come definire una classe: class Flasher //definizione della classe denominata Flasher int ledpin; //il numero dei pin dei LED long OnTime; //tempo di ON long OffTime; //tempo di OFF 111

112 Data Mar 2017 Ver. 1.3 Pag 112/137 int ledstate; //variabile usata per settare il LED unsigned long previousmillis; //registrer è l'ultimo tempo del cambiamento di stato //Constructor - ha lo stesso nome della classe, per inizializzare tutte le variabili e gli stati public: Flasher(int pin, long on, long off) ledpin = pin; pinmode(ledpin, OUTPUT); OnTime = on; OffTime = off; ledstate = LOW; previousmillis = 0; //si crea una funzione, del tutto simile a loop() void Update() controllo se è ora di cambiare lo stato del LED unsigned long currentmillis = millis(); if((ledstate == HIGH) && (currentmillis - previousmillis >= OnTime)) ledstate = LOW; spegni il LED previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna il LED attuale else if ((ledstate == LOW) && (currentmillis - previousmillis >= OffTime)) ledstate = HIGH; //accendi il LED previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna l'attuale LED Sistemando il vecchio codice in una classe denominata Flasher, abbiamo incapsulato tutte le variabili e le funzioni per far lampeggiare un LED. Adesso vediamo come utilizzare la classe per far lampeggiare ogni flash. Creeremo un istanza per ogni classe Flasher richiamando un costructor. Per ogni passaggio di loop basterà richiamare la funzione Update() per ogni istanza del Flasher. Non è necessario replicare l intero stato macchina. class Flasher //definizione della classe denominata Flasher //vengono elencate le variabili contenute nella classe int ledpin; //il numero dei pin dei LED long OnTime; //tempo di ON long OffTime; //tempo di OFF int ledstate; //variabile usata per settare il LED unsigned long previousmillis; //registrer è l'ultimo tempo del cambiamento di stato Constructor - ha lo stesso nome della classe, per per inizializzare tutte le variabili e gli stati public: Flasher(int pin, long on, long off) ledpin = pin; pinmode(ledpin, OUTPUT); OnTime = on; OffTime = off; ledstate = LOW; previousmillis = 0; //si crea una funzione, del tutto simile a loop() void Update() // controllo se è ora di cambiare lo stato del LED unsigned long currentmillis = millis(); if((ledstate == HIGH) && (currentmillis - previousmillis >= OnTime)) ledstate = LOW; //spegni il LED previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna il LED attuale else if ((ledstate == LOW) && (currentmillis - previousmillis >= OffTime)) ledstate = HIGH; //accendi il LED 112

113 Data Mar 2017 Ver. 1.3 Pag 113/137 previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna l'attuale LED Flasher led1(12, 100, 400); Flasher led2(13, 350, 350); void setup() void loop() led1.update(); led2.update(); Multitasking con servo Applicheremo lo stesso principio finora esposto per gestire dei servo contemporaneamente al lampeggio di alcuni LED. Rispetto al problema di prima aggiungiamo un ulteriore LED e due servo. Per gestire il servo ricordiamo il codice standard fornito dalla libreria servo.h del IDE di Arduino, in particolare l esempio sweep: #include <Servo.h> Servo myservo; int pos = 0; void setup() myservo.attach(9); void loop() for (pos = 0; pos <= 180; pos += 1) myservo.write(pos); delay(15); for (pos = 180; pos >= 0; pos -= 1) myservo.write(pos); delay(15); Ovviamente, in questo codice appare l ormai superata funzione delay(). Scriveremo di seguito la classe Sweeper che incapsulerà la funzione sweep, ma verrà utilizzata la funzione millis() per la temporizzazione. Inoltre saranno necessarie le funzioni Attach() e Detach() da associare ai servo collegati a pin specifici. 113

114 Data Mar 2017 Ver. 1.3 Pag 114/137 class Sweeper Servo servo; int pos; int increment; int updateinterval; //intervallo tra gli aggiornamenti unsigned long lastupdate; //ultimo aggiornamento della posizione public: Sweeper(int interval) updateinterval = interval; increment = 1; //definizione dell'incremento della posizione void Attach(int pin) servo.attach(pin); //inizializzazione della funzione Attach() con variabile void Detach() servo.detach(); void Update() if((millis() - lastupdate) > updateinterval) //tempo da aggiornare lastupdate = millis(); pos += increment; servo.write(pos); Serial.println(pos); if ((pos >= 180) (pos <= 0)) //fine dello sweep increment = -increment; //inverte la direzione Adesso è possibile creare le istanze per per le classi di Flasher e Sweepers. Ogni istanza di un Flasher richiede 2 linee di codice: 1. Per dichiarare l istanza 2. Per aggiornare il ciclo Ogni istanza di uno Sweeper richiede 3 linee di codice: 1. Per dichiarare l istanza 2. Per associarla al pin nel setup 3. Per richiamare l update nel ciclo #include <Servo.h> class Flasher int ledpin; //il numero dei pin dei LED long OnTime; //tempo di ON long OffTime; //tempo di OFF int ledstate; //variabile usata per settare il LED unsigned long previousmillis; //registrera l'ultimo tempo del cambiamento di stato //Constructor - ha lo stesso nome della classe, per per inizializzare tutte le variabili e gli stati public: Flasher(int pin, long on, long off) ledpin = pin; pinmode(ledpin, OUTPUT); OnTime = on; OffTime = off; 114

115 Data Mar 2017 Ver. 1.3 Pag 115/137 ledstate = LOW; previousmillis = 0; void Update() //controlla se è ora di cambiare lo stato del LED unsigned long currentmillis = millis(); if((ledstate == HIGH) && (currentmillis - previousmillis >= OnTime)) ledstate = LOW; //spegni il LED previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna il LED attuale else if ((ledstate == LOW) && (currentmillis - previousmillis >= OffTime)) ledstate = HIGH; //accendi il LED previousmillis = currentmillis; //registra il tempo digitalwrite(ledpin, ledstate); //aggiorna l'attuale LED class Sweeper Servo servo; int pos; int increment; int updateinterval; //intervallo tra gli aggiornamenti unsigned long lastupdate; //ultimo aggiornamento della posizione public: Sweeper(int interval) updateinterval = interval; increment = 1; //definizione dell'incremento void Attach(int pin) servo.attach(pin); void Detach() servo.detach(); void Update() if((millis() - lastupdate) > updateinterval) //tempo da aggiornare lastupdate = millis(); pos += increment; servo.write(pos); Serial.println(pos); if ((pos >= 180) (pos <= 0)) //fine dello sweep increment = -increment; //inverte la direzione Flasher led1(11, 123, 400); Flasher led2(12, 350, 350); Flasher led3(13, 200, 222); Sweeper sweeper1(15); Sweeper sweeper2(25); void setup() Serial.begin(9600); sweeper1.attach(9); sweeper2.attach(10); void loop() sweeper1.update(); sweeper2.update(); 115

116 Data Mar 2017 Ver. 1.3 Pag 116/137 led1.update(); led2.update(); led3.update(); Adesso si hanno 5 azioni indipendenti che vengono eseguiti in continuazione senza nessuna interferenza. All interno della funzione loop() ci sono solo 5 linee di codice. FUNZIONE INTERRUPT (INTERRUZIONI ESTERNE HARDWARE) Capita spesso di avere la necessità di controllare lo stato di diversi pin di input, in questa situazione potrebbe capitare che il programma non si accorga del cambiamento di stato su uno dei pin, utilizzando gli interrupt evitiamo questo tipo di errore. Con il termine interrupt (interruzione) intendiamo un segnale asincrono che indica la necessità di attenzione da parte di una periferica collegata ad Arduino. L interrupt viene generato quando si verifica una variazione di stato su uno dei piedini di Arduino. Normalmente il microcontrollore esegue all interno del loop() in modo sequenziale e ripetitivo le istruzioni in esso inserite, ma quando si verifica un interrupt viene interrotto il flusso delle istruzioni all interno del loop() ed invocate altre routine (create dall utente). Quando le routine terminano il flusso del programma prosegue normalmente. L utilizzo dell interrupt è particolarmente utile quando abbiamo la necessità di gestitire in background alcune routine ovvero eseguire istantaneamente un operazione nel caso si manifesti un evento asincrono esterno. L'ATMEGA328 possiede una potente e flessibile gestione di 26 differenti sorgenti dell'interrupt. Due interrupt sono generati da un segnale esterno mentre i rimanenti 24 interrupt supportano in modo efficiente le periferiche disponibili all interno del chip del microcontrollore. Utilizzare la tabella 1 per consultare l'elenco degli interrupt disponibili. L'elenco è visualizzato in ordine discendente del livello di priorità per la gestione dell'interrupt. Vettore Indirizzo Sorgente (vector) (address) (source) Descrizione 1 0x0000 RESET Pin esterno, Power-on reset, 2 0x0002 INT0 richiesta 0 di interrupt esterno (pin 4 del microcontrollore) INT0_vect 3 0x0004 INT1 richiesta 1 di interrupt esterno (pin 5 del microcontrollore) INT1_vect 4 0x0006 PCINT0 richiesta 0 di interrupt del cambio livello (pin 14 del micro) PCINT0_vect 5 0x0008 PCINT1 richiesta 1 di interrupt del cambio livello (pin 15 del micro) PCINT1_vect 6 0x000A PCINT2 richiesta 2 di interrupt del cambio livello (pin 16 del micro) PCINT2_vect 7 0x000C WDT interrupt dovuto all'overflow (time-out) del watchdog WDT_vect Nome utilizzato nell Interrupt Service Routine con il compilatore AVR-GCC 8 0x000E TIMER2COMPA interrupt dovuto al confronto A con il TIMER COUNTER 2 TIMER2_COMPA_vect 9 0x0010 TIMER2COMPB interrupt dovuto al confronto B con il TIMER COUNTER 2 TIMER2_COMPB_vect 10 0x0012 TIMER2OVF interrupt dovuto all'overflow del TIMER COUNTER 2 TIMER2_OVF_vect 11 0x0014 TIMER1CAPT interrupt dovuto alla cattura evento con il TIMER COUN- TER 1 TIMER1_CAPT_vect 12 0x0016 TIMER1COMPA interrupt dovuto al confronto A con il TIMER COUNTER 1 TIMER1_COMPA_vect 13 0x0018 TIMER1COMPB interrupt dovuto al confronto B con il TIMER COUNTER 1 TIMER1_COMPB_vect 14 0x001A TIMER1OVF interrupt dovuto all'overflow del TIMER COUNTER 1 TIMER1_OVF_vect 15 0x001C TIMER0COMPA interrupt dovuto al confronto A con il TIMER COUNTER 0 TIMER0_COMPA_vect 16 0x001E TIMER0COMPB interrupt dovuto al confronto B con il TIMER COUNTER 0 TIMER0_COMPB_vect 17 0x0020 TIMER0OVF interrupt dovuto all'overflow del TIMER COUNTER 0 TIMER0_OVF_vect 18 0x0022 SPI, STC interrupt della periferica SPI Serial Transfer Complete SPI_STC_vect interrupt della periferica USART con ricezione Rx completata 19 0x0024 USART, RX USART_RX_vect 20 0x0026 USART, UDRE 21 0x0028 USART, TX interrupt della periferica USART con il Data Register vuoto (Empty) interrupt della periferica USART con trasmissione Tx completata USART_UDRE_vect USART_TX_vect 22 0x002A ADC interrupt generato dalla conversione A D completata ADC_vect 23 0X002C EE READY interrupt della EEPROM disponibile (Ready) EE_READY_vect 24 0x002E ANALOG COMP interrupt generato dal comparatore analogico (analog ANALOG_COMP_vect 116

117 Data Mar 2017 Ver. 1.3 Pag 117/ x0030 TWI 26 0x0032 SPM READY Comparator) interrupt generato dall'interfaccia seriale a 2 fili (2-wire Serial Interface) interrupt generato dalla memorizzazione nella memoria di programma (Store Program Memory Ready) TWI_vect SPM_READY_vect Come risulta disponibile l'interrupt denominato "RESET" che possiede il livello massimo di priorità, seguito dalla richiesta di interrupt relativo al pin 4 denominato "INT0" e al pin 5 denominato "INT1". I rimanenti interrupt sono riferiti al chip interno dell ATMEGA328. Quando interviene un evento la corrispondente periferica genera un interrupt e il microcontrollore, completata l'istruzione corrente che stava eseguendo, memorizza l'indirizzo dell'istruzione successiva nello stack (area di memoria RAM del tipo LIFO, ovvero Last In First Out) ed inizia l'esecuzione tramite l'isr corrispondente al particolare interrupt generato. Durante tutta l'esecuzione del programma di interrupt viene disabilitato l'interrupt stesso in modo da evitare che ogni ulteriore gestione dello stesso possa mandare in overflow la memoria riservata allo stack (si consideri che sono pochi byte a disposizione 16 o 32). L'esecuzione della gestione relativa all'interrupt termina quando il microcontrollore esegue l'istruzione in assembly RETI (RE- Turn from Interrupt). In tal caso il flusso del programma riprende nel programma principale dall istruzione successiva a dove era stato interrotto. Nel compilatore Arduino esistono 4 funzioni predefinite per supportare gli interrupt esterni alla scheda: 1. interrupts(): serve per abilitare l'interrupt globale. 2. nointerrupts(): serve per disabilitare l'interrupt globale 3. attachinterrupt(interrupt, function, mode): serve per collegare l'interrupt alla tabella dei vettori dell'interrupt 4. detachinterrupt(interrupt): serve per disabilitare l'interrupt specificato. La scheda Arduino UNO gestisce 2 differenti interrupt esterni: INT0 collegato al pin 2 (digitale della scheda Arduino) e INT1 collegato al pin 3 (digitale della scheda Arduino). La funzione attachinterrupt(interrupt, function, mode) è utilizzata per collegare il pin hardware all'appropriata gestione del software di interrupt. I tre argomenti della funzione devono essere configurati nel seguente modo: interrupt à specifica il numero dell'interrupt. Valori possibili sono 0 oppure 1. function à specifica il nome della routine di gestione dell'interrupt. Questa funzione non deve avere parametri e non deve restituire alcun valore. All interno di questa funzione delay() non funziona, millis() non verrà incrementato, i dati seriali ricevuti potrebbero essere alterati, qualsiasi variabile modificabile all interno della funzione attached devono essere dichiararte come volatili. mode à specifica quale tipo di attività deve essere valutata quando si verifica l'evento che genera l'interrupt. I valori che può assumere sono i seguenti: LOW: genera un interrupt quando il pin è a livello basso. CHANGE: genera un interrupt quando il pin passa da un livello all'altro, cioè quando si passa da HIGH a LOW e viceversa. RISING: genera un interrupt solo quando il pin passa dal livello LOW al livello HIGH. FALLING: genera un interrupt solo quando il pin passa dal livello HIGH al livello LOW. Esempio: int pin = 8; volatile int state = LOW; void setup() pinmode(pin, OUTPUT); //definisco il pin8 come uscita digitalwrite(pin, LOW); //inizializzo l'uscita a livelo basso attachinterrupt(1, GestInt, LOW); //Creo un gestore di interrupt e lo associo al pin3 void loop() 117

118 Data Mar 2017 Ver. 1.3 Pag 118/137 fai qualcosa delay(10); void GestInt() state =!state; //inverti lo stato digitalwrite(pin, state); //scrivi lo stato del LED Esaminiamo un altro esempio. In questo caso collegheremo 3 LED di diverso colore con lo scopo di far lampeggiare alternatamente i due led rosso e verde con una frequenza di 300 millisecondi tra l uno e l altro, alla pressione del pulsante si accende il led giallo e resta accesso fino a quando la funzione loop() non ha eseguito i suoi 10 cicli. Collegando il pulsante al pin 2, che sarà in nostro interrupt 0 (1 se fosse stato il pin 3), alla pressione del pulsante il valore letto sul pin 2 sarà HIGH in quanto la pressione dl pulsante mette in contatto il pin 2 di arduino con il polo positivo +5V. //Dichiarazione della variabili I O int ledred=8; int ledgreen=7; int ledyellow=12; int interrcount=0; void setup() pinmode(ledred, OUTPUT); pinmode(ledgreen, OUTPUT); pinmode(ledyellow, OUTPUT); digitalwrite(ledred, LOW); digitalwrite(ledgreen, LOW); digitalwrite(ledyellow, LOW); //funzione di interrupt sul pin 2 con moda- attachinterrupt(0, interruptgiallo, RISING); lità RISING void loop() interrcount++; //incrementa il contatore digitalwrite(ledred, HIGH); digitalwrite(ledgreen, LOW); delay(300); digitalwrite(ledred, LOW); digitalwrite(ledgreen, HIGH); delay(300); if ( interrcount == 10 ) //controlla se il contatore 'e8 arrivato a 10 interrcount = 0; //reset del contatore digitalwrite(ledyellow, LOW); 118

119 Data Mar 2017 Ver. 1.3 Pag 119/137 void interruptgiallo() //funzione da richiamare in interrupt digitalwrite(ledyellow, HIGH); FUNZIONE INTERRUPT (INTERRUZIONI ESTERNE SOFTWARE) Un interrupt seriale è un tipo di interruzione che è causata sia da una speciale istruzione che da una condizione particolare dello stesso processore. Un interrupt software è richiamato dal software a differenza di un interrupt hardware ed è considerata una via per comunicare con il kernel o richiamare una chiamata di sistema, specialemente durante un errore. I processori a 8bit AVR, come quelli utilizzati dalla maggior parte delle schede Arduino, sono sono capaci di effettuare interruzioni software. Nonostante tutto è possibile emulare le interruzioni tramite il cambiamento di stato di un pin. MONITOR TFT TOUCH SCREEN 2.8 Si tratta di una shield, con le stesse dimensioni di Arduino, che presenta un monitor touch screen TFT a colori (2.8 di diagonal) e retroilluminazione LED. La risoluzione è di 240x320 pixel con un controllo indiviudale di ogni pixel. Inoltre è presente un lettore di microsd sul retro per caricare eventuali foto da visualizzare. GESTIONE LCD 16X2 CON SHIFT REGISTER (SOLO 3 PINS) Come abbiamo visto in precedenza, collegare un display 16x2 ad Arduino può essere effettuato in due modi differenti: direttamente ai pin di Arduino occupandone ben 7, o tramite il modulo aggiuntivo I2C per la comunicazione seriale che utilizza soltanto 2 pin. Un terzo modo di collegare il display consiste nell adozione di un solo integrato in più: il 74HC595. Il costo di tale integrato è davvero irrisorio e permette di utilizzare solo 3 pin anziché 6. Il 74HC595 è uno shift register, un registro a scorrimento che permette di controllare 8 pin di uscita alla volta usando pochi pin da parte del microcontrollore. E possibile collegare più registri insieme per estendere ancora di più le uscite. Il registro è caratterizzato da celle di memoria da un bit interconesse tra loro. Ad ogni impulso di clock, avviene lo scorrimento dei bit da una cella a quella immediatamente adiacente. Lo scorirmento piò avvenire verso destra o verso sinistra o in entrambi i versi (registri bidirezionali). può mantenere 8 stati di memoria, ognuno dei quali può essere 1 o 0. Per settare ogni pin, si inviano i dati tramite un pin Data e un pin Clock. Quest ultimo richiede 8 impulsi se il pin di Data è alto, quindi un 1 è inserito nel registro, altrimenti è uno 0. Quando tutti gli 8 impulsi sono ricevuti, abilitando il pin di Latch gli 8 valori saranno copiati nel registro di latch. Il chip presenta anche un pin denominato OE (output enable) che è utilizzato per abilitare o disabilitare tutti i pin contemporaneamente. Si può collegare un segnale PWM per controllare la luminosità dei LED. 119

120 Data Mar 2017 Ver. 1.3 Pag 120/137 Quindi, utilizzando 3 pin digial, di cui uno PWM, si possono pilotorare 8 uscite, aggiungendo un secondo registro a scorrimento sarà possibile ampliare le uscite a 16 utilizzando sempre 3 uscite digitali. Per collegare dunque un LCD 16x2 sarà necessario disporre di: 1 x 74HC595 shift register 1 x BC547 NPN transistor 1 x 10k potenziometro 6 x header maschi 16 x header femmine Osserviamo il collegamento su breadboard: E lo schema elettrico: 120

121 Data Mar 2017 Ver. 1.3 Pag 121/137 Per quanto riguarda lo sketch, c è da dire che, ovviamente, è necessaria una nuova libreria per gestire il display con il registro a scorrimento. La libreria si trova sotto il nome di LiquidCrystal595. Lo sketch è il seguente: * * 3-pin Arduino interface for HD44780 LCDs via 74HC595 Shift Register * by Rowan Simms code@rowansimms.com * License: Creative Commons - Attribution. * Full Documentation and Description: http: rowansimms.com article.php lcd-hookup-inseconds * * This sketch allows Arduinos to use a shift register to control an LCD, allowing * a reduction in pins it requires from 6 to 3 while still retaining full control * including backlight on off. * This requires the use of the LiquidCrystal595 library * available at: http: code.google.com p arduino-lcd-3pin * #include <LiquidCrystal595.h> LiquidCrystal595 lcd(7,8,9); void setup() lcd.begin(16,2); //include the library //datapin, latchpin, clockpin //16 characters, 2 rows lcd.clear(); lcd.setcursor(0,0); lcd.print("wow. 3 pins!"); lcd.setcursor(0,1); lcd.print("fabulous"); void loop() //not used. Per ulteriori informazioni o approfondimenti, si consiglia di visitare il sito ufficiale: https: en Tutorial ShiftOut Inoltre, data la semplicità del circuito e l economicità dei componenti, si può pensare di costruire una shield ad hoc per la connessione del display. 121

122 Data Mar 2017 Ver. 1.3 Pag 122/137 DISPLAY 16X2 I2C Come tutti sanno, uno schermo LCD, o altri display, arricchiscono l interazione tra uomo e macchina. Tutti però hanno una debolezza in comune. Quando sono connessi ad un controller utilizzano molti piedini di I/O. Ciò comporta una restrizione nell utilizzo del controller stesso (Arduino, PIC, etc). and some other displays greatly enrich the man-machine interaction, they share a common weakness. Per ovviare a questo problema, è possibile utilizzare dei dispositivi che prevedono l utilizzo di un interfaccia con bus I2C (Inter-Integrated Circuit). I2C Il bus I2C è una tipologia di bus seriale inventata da PHILIPS negli anni 80. Si effettua una comunicazione seriale ad alte prestazione sfruttando delle regole per dispositivi ad alta e bassa velocità di sincronizzazione richieta da un sistema che riesce a controllare più dispositivi simultaneamente. Nella comunicazione seriale classica le porte sono asincrone (non è trasmesso nessun dato di clock), i dispositivi che intendono comunicare con questo sistema devono aderire a monte ai tempi della trasmissione dei dati. Non solo, la comunicazione seriale è possibile solo tra due dispositivi, un terzo non è previsto. Una soluzione della comunicazione seriale classica potrebbe essere il protocollo SPI (Serial Peripheral Interface), sviluppato da Motorola. La comunciazione avviene tra un dispositivo Master e uno o più Slave. Il master controlla il bus ed emette il segnale di clock necessario a sincronizzare la comunciazione. In questa comunicazione sono necessari 4 fili differenti. Ogni dispositivo slave addizionale ha bisogno di un chip per la selzione dei corretti I/O da parte del master. Va da sé che più dispositivi sono presenti con il master e più complesso sarò il circuito da realizzare. Il protocollo SPI è ideale per comunicazioni molto veloci in full-duplex, supportando frequenze di clock fino a 10 MHz, l hardware si riduce all utilizzo shift register multipli, il software è anch esso molto semplice. Il protocollo I2C ha bisogno di soli 2 fili, come la comunicazione seriale semplice, ma è possibile supportare fino a 1008 dispositivi slave. Inoltre, I2C supporta più dispositivi master simultaneamente. La maggior parte dei dispositivi I2C può comunicare ad una frequenza compresa tra 100kHz e 400kHz. 122

123 Data Mar 2017 Ver. 1.3 Pag 123/137 L hardware necessario è un po più complesso rispetto all SPI, ma meno che della comununicazione asincrona seriale. Tra l altro è possibile implementare tale protocollo tramite sofware evitando di appensantire la componentistica elettronica. Il modulo In commercio si trovano moduli già pronti da saldare direttamente su un display LCD 16x2. Ultimamente i display stessi sono acquistabili con comunicazione I2C. Nel figura sovrastante abbiamo proposto la soluzione del modulo I2C di Funduino. Il potenziometro blu è usato per regolare il contrasto del display. Sulla sinistra del modulo è possibile osservare un jumper utile ad attivare il LED per la retroilluminazione. Il protocollo I2C utilizza solo due fili bidirezionali, Serial Data Line (SDA) e Serial Clock Line (SCL), portate a Vcc tramite dei resistori. Tensioni tipiche sono +5 V o +3.3 V Esempio Nel seguente esempio vedremo come collegare un display I2C LCD1602 ad Arduino visualizzando il classico messaggio Hello world. Step 1: Connessioni circuito I2C LCD1602 GND VCC SDA SCL Arduino UNO GND 5V A4 A5 Step 2: installare la libreria LiquidCrystal_I2C scaricabile sia dall IDE Arduino che siti terzi, basta cercare la libreria su Google. Step 3: compilare e caricare il seguente sketch #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x27,16,2); // setta l'indirizzo a 0x27 per un diplay 16x2 void setup() 123

124 Data Mar 2017 Ver. 1.3 Pag 124/137 lcd.init(); // inizializza l LDC, in base alla libreria potrebbe essere necessario usare lcd.begin lcd.backlight(); //accende la retroilluminazione lcd.print("hello, world!"); //stampa il messaggio void loop() Nell esempio successivo introduciamo alcune nuove funzioni #include <Wire.h> #include <LiquidCrystal_I2C.h> char array1[]=" SunFounder char array2[]="hello, world! int tim = 500; //tempo di ritado "; //stringa da stampare su LCD "; //stringa da stampare su LCD LiquidCrystal_I2C lcd(0x27,16,2); // setta l'indirizzo a 0x27 per un diplay 16x2 void setup() lcd.init(); //inizializza l'lcd, in base alla libreria potrebbe essere necessario usare lcd.begin lcd.backlight(); //accende la retroilluminazione void loop() lcd.setcursor(15,0); // imposta il cursore sulla colonna 15, linea 0 for (int positioncounter1 = 0; positioncounter1 < 26; positioncounter1++) lcd.scrolldisplayleft(); //scorre il contenuto del display uno spazio sulla sinistra. lcd.print(array1[positioncounter1]); // stampa il messaggio sull'lcd delay(tim); // attende lcd.clear(); //pulisce lo scehrmo e posizione il cursoe nell'angolo in alto a sinistra lcd.setcursor(15,1); // imposta il cursore sulla colonna 15, lina 1 for (int positioncounter = 0; positioncounter < 26; positioncounter++) lcd.scrolldisplayleft(); //scorre il contenuto del display uno spazio sulla sinistra. lcd.print(array2[positioncounter]); // stampa il messaggio sull'lcd delay(tim); // attende lcd.clear(); //pulisce lo schermo e posiziona il cursore nell'angolo in alto a sinistra 124

125 Data Mar 2017 Ver. 1.3 Pag 125/137 PROGETTO: TERMOSTATO/IGROSTATO REGOLABILE CON DISPLAY Questo progetto ci consente di gestire, ad esempio, una teca contenente delle piante tropicali o delle tartarughe, controllandone temperatura e umidità direttamente su un display tramite dei pulsanti. Impostando una temperatura di soglia di 30 gradi, qualora nell ambiente ci fossero soltanto 25 C, scatterà un relè al quale potremo collegare un riscaldatore. Raggiunta la temperatura impostata il riscaldatore si staccherà automaticamente. Lo stesso vale per l'umidità. Qui di seguito lo schema di collegamento: Essendo a corto di porte digitali sono state usate le porte A0 e A1, basta dichiararle come 14 e 15. N.B.: anche in questo caso è possibile ridurre l utilizzo delle porte necessarie al diplay utilizzando un modulo I2C. Di seguito lo schema elettrico: 125

126 Data Mar 2017 Ver. 1.3 Pag 126/137 Nel video si vede accendere un led al superamento della soglia, ma voi probabilmente avrete bisogno di un relè come disegnato nello schema. Per ulteriori info sui relè guarda qui Ed infine ecco lo sketch: #include <LiquidCrystal.h> #include "DHT.h" #define DHTPIN 8 // è il pin di Arduino a cui collego il sensore di temperatura #define DHTTYPE DHT11 //dht11 è il tipo di sensore utilizzato DHT dht(dhtpin, DHTTYPE); /dichiarazione nella libreria di pin e tipologia LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //connessione display (pin) //dichiarazione pulsanti const int tsu = 6; //pulsante per regolare la temperatura su const int tgiu = 7; //pulsante per regolare la temperatura gi 'f9 const int hsu = 9; //pulsante per regolare l'umidit 'e0 su const int hgiu = 10; //pulsante per regolare l'umidit 'e0 gi 'f9 const int tout = 14; const int hout = 15; int statotsu = 0; int statotgiu = 0; int statohsu = 0; int statohgiu = 0; int tempimpostata = 0; int umidimpostata = 0; void setup() lcd.begin(16, 2); //imposto il tipo di display (colonne, righe) lcd.print("temp"); lcd.setcursor(10, 0); lcd.print("set"); lcd.setcursor(0, 1); lcd.print("umid"); lcd.setcursor(10, 1); lcd.print("set"); pinmode(tout, OUTPUT); 126

127 Data Mar 2017 Ver. 1.3 Pag 127/137 pinmode(hout, OUTPUT); void loop() //impostazione della temperatura statotsu = digitalread (tsu); if ( statotsu == HIGH) tempimpostata++; statotgiu = digitalread (tgiu); if ( statotgiu == HIGH) tempimpostata--; statohsu = digitalread (hsu); if ( statohsu == HIGH) umidimpostata++; statohgiu = digitalread (hgiu); if ( statohgiu == HIGH) umidimpostata--; //Visualizzazione temperatura e umidità int t = dht.readtemperature(); int h = dht.readhumidity(); lcd.setcursor(5, 0); //posiziona il cursore alla colonna 5 e riga 0 lcd.print(t); lcd.setcursor(14, 0); lcd.print(tempimpostata); lcd.setcursor(5, 1); lcd.print(h); lcd.setcursor(14, 1); lcd.print(umidimpostata); if (tempimpostata > -1 && tempimpostata < 10) // non visualizza nulla se la temperatura è bassa lcd.setcursor (15, 0); lcd.print (" "); if (umidimpostata > -1 && umidimpostata < 10) // non visualizza nulla se l umidità è bassa lcd.setcursor (15, 1); lcd.print (" "); //attivazione del termostato if ( t < tempimpostata ) digitalwrite ( tout, HIGH ); else digitalwrite (tout, LOW); if ( h < umidimpostata ) digitalwrite ( hout, HIGH ); else digitalwrite (hout, LOW); Per poter compilare lo sketch è necessario scaricare la libreria DHT.h che potete trovare nell apposita senzione dell IDE di Arduino, in alternativa provate con un motore di ricerca. 127

128 Data Mar 2017 Ver. 1.3 Pag 128/137 COME COLLEGARE MOLTI PULSANTI USANDO SOLO UN PIN DI ARDUINO Questo piccolo trucco vi servirà nei casi siate a corto di pin liberi nei vostri progetti con Arduino. Infatti con un solo pin analogico riuscirete a leggere quanti pulsanti volete! vediamo subito come, ecco lo schema di collegamento: Ecco fatto, 4 pulsanti ed un solo pin analogico, ma con lo stesso sistema potete aggiungerne molti altri! il principio è semplice, quando nessun pulsante è premuto Arduino legge i 5 volt che "arrivano" dalla resistenza da 4,7 K. Quando il pulsante S1 è premuto Arduino legge 0 Volt, perchè il pin A0 viene collegato direttamente a GND. Quando il pulsante S2 è premuto Arduino legge un valore di tensione un po' più alto. (dato dal partitore resistivo della resistenza da 4,7KΩ e dalla prima da 1 KΩ) Quando il pulsante S3 è premuto Arduino legge un valore di tensione ancora più alto. (dato dal partitore resistivo della resistenza da 4,7KΩ e dalla serie di 2 resistenze da 1 KΩ) Con il pulsante S4 otterrò un valore ancora più alto, e via di seguito. Facciamo una prova pratica utilizzando l'esempio di Arduino "ReadAnalogVoltage" 1 * 2 ReadAnalogVoltage 3 Reads an analog input on pin 0, converts it to voltage, and prints the result to the serial monitor. 4 Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground. 5 6 This example code is in the public domain. 7 * 8 9 the setup routine runs once when you press reset: 10 void setup() 11 initialize serial communication at 9600 bits per second: 12 Serial.begin(9600); the loop routine runs over and over again forever: 16 void loop() 17 read the input on analog pin 0: 18 int sensorvalue = analogread(a0); 19 Convert the analog reading (which goes from ) to a voltage (0-5V): 20 float voltage = sensorvalue * ( ); 21 print out the value you read: 22 Serial.println(voltage); 23 Se avete collegato tutto nel modo giusto otterrete un valore di tensione diverso premendo i vari pulsanti, questo è il principio su cui si basa il nostro trucchetto. Infatti poi qiuando leggeremo un diverso valore di tensione sul pin A0 faremo fare un'operazione diversa al nostro Arduino. 128

129 Data Mar 2017 Ver. 1.3 Pag 129/137 Vediamo ora uno sketch di esempio per capire come utilizzare questo sistema nei nostri progetti: int led=13; void setup() Serial.begin(9600); pinmode (led, OUTPUT); void loop() int pulsante = lettura_pulsante(); Serial.println(pulsante); switch (pulsante) case 0: digitalwrite (led, LOW); break; case 1: digitalwrite (led, HIGH); delay (100); digitalwrite (led, LOW); delay (100); break; case 2: digitalwrite (led, HIGH); delay (200); digitalwrite (led, LOW); delay (200); break; case 3: digitalwrite (led, HIGH); delay (300); digitalwrite (led, LOW); delay (300); break; case 4: digitalwrite (led, HIGH); delay (400); digitalwrite (led, LOW); delay (400); break; delay(10); int lettura_pulsante() int Value = analogread(a0); if (Value > 1000) return 0; if (Value < 100) return 1; if (Value < 200) return 2; if (Value < 350) return 3; if (Value < 500) return 4; Questo esempio fa lampeggiare in modo diverso il led di Arduino in base al pulsante premuto. Per fare qualcosa di diverso alla pressione dei diversi pulsanti vi basterà cambiare i comandi nel ciclo Switch Case. 129

130 Data Mar 2017 Ver. 1.3 Pag 130/137 APPENDICE APPENDICE 1: PROGRAMMAZIONE ARDUINO Funzione Una funzione è un blocco di codice che viene eseguito nel momento in cui essa viene chiamata. Dichiarazione di funzione La funzione è dichiarata tramite la specificazione del tipo di funzione. Questo è il valore che restituisce (return) la funzione stessa. Se non deve essere restituito alcun valore la funzione sarà del tipo void. Dopo la dichiarazione del tipo si dichiara il nome e si fa seguire le parentesi tonde entro cui vanno inseriti i parametri che devono essere passati alla funzione se necessari. Sintassi tipo nomefunzione(parametro1, parametro2,..., parametro n) istruzioni da eseguire; Esempio: funzione che effettua la somma tra due numeri interi num1 e num2 dove: int x=somma(4,6); esempio di chiamata di una funzione denominata somma int somma(int num1, int num2) int numerosomma=num1+num2; return numerosomma; int specifica il tipo di funzione; somma è il nome della funzione num1 e num2 sono i parametri che vengono passati alla funzione stessa numerosomma è il valore di tipo int che la funzione restituisce in caso di chiamata. Se la funzione non deve restituire alcun valore sarà dichiarata di tipo void come accade per le funzioni setup() e loop(). La presenza dei parametri non è obbligatoria: la chiamata ad una funzione si può fare anche senza parametri. Le costanti Le costanti sono variabili predefinite nel linguaggio per Arduino e vengono utilizzate per rendere il programma più semplice da leggere. Le costanti sono classificate in diversi gruppi. Costanti booleane Le costanti booleane definiscono i livelli logici di vero ( true ) e falso ( false ). false è più semplice da utilizzare in quanto rappresenta lo zero (0) ; true invece rappresenta una condizione di non-zero (non solo significato di uno ) per cui anche -1, 2,-200 (valori diversi da 0) sono definite tutte condizioni di vero in senso booleano. Importante: true e false sono scritte in minuscolo. 130

131 Data Mar 2017 Ver. 1.3 Pag 131/137 Costanti INPUT e OUTPUT Queste costanti definiscono il comportamento da associare ai pin quali: INPUT e OUTPUT Un pin digitale può essere configurato sia come INPUT che come OUTPUT. Scegliere la modalità INPUT o OUTPUT significa scegliere il comportamento del pin. INPUT: Arduino configura un pin come INPUT con pinmode(), mettendo quel pin in una configurazione di alta impedenza. In questa condizione il pin si presta meglio a leggere un sensore, un valore di tensione, che ad alimentare un circuito (per es con led) OUTPUT: un pin è impostato come OUTPUT quando Arduino lo pone in condizione di bassa impedenza tramite il pinmode(). Questo significa che questo pin può fornire una certa quantità di corrente. L'ATMEGA può fornire o assorbire da un circuito esterno una corrente fino a 40mA. I pin configurati come output possono essere danneggiati o distrutti se cortocircuitati verso massa o verso la linea di alimentazione a 5V. La quantità di corrente fornita dai pin dell'atmega non è abbastanza potente per poter alimentare relè e motori per cui vengono richiesti circuiti di interfaccia. Costanti HIGH e LOW Costanti che definiscono il livello di un pin: HIGH e LOW HIGH: ha diversi significati a seconda se il pin è settato come INPUT o OUTPUT o INPUT: legge con il comando digitalread un valore superiore a 3V il microcontrollore restituirà un valore HIGH. Un pin può essere settato come INPUT con il pinmode, in seguito reso alto HIGH con digitalwrite, questo imposterà la resistenza interna di pullup a 20K che porterà il pin allo stato HIGH a meno che esso non venga costretto a LOW da qualche circuito esterno. o OUTPUT: se viene settato a valore HIGH con digitalwrite, il pin si troverà al valore di 5V. Esso diventa una sorgente di corrente sia verso un carico tipo LED con resistori verso massa che verso un pin. LOW: anche in questo caso si distinguono due casi o INPUT: il microcontrollore legge valore LOW, tramite readanalog, se la tensione è inferiore ai 2V. o OUTPUT: il pin è posto a 0V. In questa modalità il pin assorbe corrente ad es. da un circuito esterno o da un pin impostato come OUTPUT ma HIGH. APPENDICE 2: COME TROVARE LA GIUSTA RESISTENZA DA METTERE IN SERIE AI LED In quasi tutte le applicazioni di elettronica ciò che non manca mai sono i diodi LED. Specialmente quando si inizia con i primi progetti i LED la fanno da padrone stante la semplicità che richiede il loro utilizzo. Per calcolare la resistenza da mettere in serie ad un LED un primo dato che dobbiamo conoscere è il loro assorbimento di corrente (I): LED a basso consumo: 3 10 ma LED normali: ma LED Flash: ma LED di potenza: ma Di seguito useremo, nei calcoli di esempio, i LED normali, ma il tutto avrà una validità trasversale a tutti i LED. 131

132 Data Mar 2017 Ver. 1.3 Pag 132/137 Fondamentale è anche la conoscenza della caduta di tensione ai capi del LED (V led ): colore rosso: 1,8 V colore giallo: 1,9 V colore verde: 2,0 V colore arancio: 2,0 V colore blu: 3,0 V colore bianco: 3,0 V Nota la caduta di tensione ai capi del LED ed il suo assorbimento, l ultimo dato mancante è la tensione di alimentazione (V al ). Ipotizzando che la nostra applicazione preveda l alimentazione del LED tramite l Arduino questa risulta essere pari a 5V. Lo schema dei collegamenti è veramente semplice implicando solo l inserimento di una resistenza in serie: Per il calcolo della resistenza basta applicare la seguente formula: Con questa formuletta sarete in grado di calcolare il valore della resistenza da mettere in serie al led. Ovviamente non sempre vi verrà fuori un valore intero o di una resistenza esistente in commercio. Dovrete scegliere il valore della resistenza commerciale immediatamente superiore a quello risultante dai calcoli (nel nostro caso 213, ). APPENDICE 3: CALCOLARE LA RESISTENZA DI UN BJT IN MODALITÀ ON/OFF Per alimentare degli attuatori che consumano più di 40 ma (limite massimo per microcontrollori), è necessario introdurre un elemento in grado di poter pilotare pià corrente. Un semplice transistor BJT può fare al caso nostro. Nella figura accanto è n transistor BJT può essere utilizzato come un interruttore analogico pilotandolo tramite la corrente di base. Semplicemente si transita dalla sua zona di interdizione (corrente di collettore = 0) a quella di saturazione (corrente di collettore massima consentita). Per ottenere tale funzionamento è necessario aumentare la corrente di base per spostare il punto di funzionamento statico Q. Si ricorda che il guadagno in corrente costante di un transistor BJT è dato dal parametro: h FE =I C /I B Ci si accorge di trovarsi in saturazione quando un ulteriore aumento di I b non comporta l aumento di I C, in questo caso la massima corrente di collettore raggiunta viene chiamata I Cmax. Per cui si ha: 132

133 Data Mar 2017 Ver. 1.3 Pag 133/137 I Cmax < h FE I B In un circuito reale, a causa delle cadute di tensione interne al transistor (come quella tra il collettore e l emettitore denominata V CEsat ) e di tolleranze dei componenti, la saturazione potrebbe discostarsi dal valore calcolato, perciò per essere sicuri che si verifichi la saturazione si può attribuire al h FE (ha il difetto di variare con la temperatura) il suo valore minimo che si trova nel datasheet del transistor: I B > I Cmax /h FEmin Per ottenere una saturazione sicura,considerando anche le possibili tolleranze delle resistenze, si aumenta la I B di un 20% (chiamata I bsat ), si ha: I B > 1.2 I Cmax /h FEmin Tenendo presente che I E =I B +I C, fissando la corrente di collettore e trovando la corrente di base si può trovare la resistenza di base che permette di ottenere la corrente di collettore desiderata. Ad esempio, se si vuole alimentare un carico (R L ), che assorbe 80mA. Supponiamo di avere una h FE di 200, la IB necessaria affinchè ci sia una IC da 80mA sarà: I B = I C /h FE =0,08/200=400µA In pratica con una corrente di base da 400mA, sarà possibile avere una corrente massima IC di 80 ma. Si sarà portato il BJT dalla zona di interdizione a quella di saturazione. Per le considerazioni precedenti, a causa delle fluttuazioni dovute alle condizioni ambientali, è necessario intervenire con un fattore di sicurezza che limita questo problema: I B =1.2 I C /h FE = APPENDICE 4: COME CAMBIARE NOME AL MODULO BLUETOOTH HC-06 Tramite dei comandi da monitor seriale è possibile cambiare alcuni parametri dei moduli di comunicazione wireless blutooth HC-06. In realtà si modifica il firmware del modulo stesso. Il modo più semplice per passare comandi AT con Arduino, è utilizzare uno sketch che inoltri al modulo i comandi impartiti da Serial monitor. Per poter utilizzare il Serial monitor (e quindi la seriale hw), e contemporaneamente instaurare una connessione seriale con il modulo BT, si ricorre ad una Software Serial, ovvero una seriale sw. Di seguito lo sketch: #include <SoftwareSerial.h> const int rxpin = 2; const int txpin = 3; const int atpin = 4; SoftwareSerial bluetooth(rxpin, txpin); void setup() Serial.begin(9600); bluetooth.begin(9600); pinmode(atpin, OUTPUT); Serial.println("Seriali attive..."); digitalwrite(atpin, HIGH); void loop() if (bluetooth.available()) Serial.write(bluetooth.read()); 133

134 Data Mar 2017 Ver. 1.3 Pag 134/137 if (Serial.available()) bluetooth.write(serial.read()); E lo stesso esempio che si trova nella libreria con l aggiunta di qualche modifica. Una volta collegato il modulo correttamente e caricato il firmware si apre il monitor seriale (per moduli HC-06 selezionare no line endig nella finestra del modulo seriale) e si invia il seguente comando: AT+VERSION Si riceve la risposta corrispondente: la versione del firmware contenuto nel modulo bluetooth (es. LinvorV1.n). Di seguito una tabella con i comandi più importanti: Comando Si riceve Test di comunicazione AT OK Cambiare il baud rate AT+BAUD1 OK1200 Cambiare il nome AT+NAMEnome OKsetname Cambiare il pin AT+PIN1234 OKsetpin E i numeri corrispondenti ai diversi baud rate: (Default) A B C APPENDICE 5: FREQUENZA PWM SU ARDUINO E DUTY CYCLE Arduino è in grado di gestire segnali PWM attraverso le sue uscite digitali, ma è anche in grado di regolare la frequenza PWM di tali pin: La frequenza di lavoro dei pin PWM su Arduino non è la stessa per tutti i pin. Ad esempio, nell Arduino Uno (o qualsiasi altro Arduino basato sull Atmega328) sono presenti 6 uscite, individuabili grazie al simbolo ~, utilizzabili come PWM: 134

135 Data Mar 2017 Ver. 1.3 Pag 135/137 ma non tutte lavorano alla stessa frequenza. Arduino dispone di tre timer distinti definiti Timer0, Timer1 e Timer2 gestiti dall Atmega328. A ciascun Timer sono collegati 2 comparatori (Output Compare OC) definiti OCxA e OCxB, in cui x vale 0,1 e 2 ciascun numero corrisponde ad uno dei timer, ad ogni comparatore è collegato un pin Arduino, ed ecco i 6 pin PWM: Guardando la tabella si nota che i 3 timer sono riportati con la dicitura TCCRx in cui x vale 0,1 e 2 e che il Timer0 ha una frequenza doppia rispetto agli altri due che si ripercuote alla fine della tabella sulla frequanza PWM di default in cui la frequenza PWM dei pin 5 e 6 è doppia rispetto a quella dei pin 3,9,10 e 11. Differenza di Frequenza PWM La differenza di frequenza PWM tra la coppia di pin 5 e 6 e gli altri ti porta a fare delle considerazioni: se vuoi collegare due motori o servo motori da controllare in PWM scegli i pin con frequenza uguale; la frequenza PWM di default è alquanto bassa; Se consideri che la frequenza PWM del Timer è ad esempio 31250Hz come è possibile che la frequenza PWM di default sia di soli 488Hz? La risposta è nel fatto che ciascun Timer (TCCRx) possiede due registri denominati A e B, rispettivamente per il Timer0 sono TCCR0A e TCCR0B il cui compito è definire le modalità di funzionamento e altri parametri dei Timer stessi. In particolare il Registo B ( TCCR0B, TCCR1B, TCCR2B ) ha anche il compito di impostare un prescaler che puoi immaginare come una sorta di dividendo della frequenza PWM. I prescaler sono 5 per i pin connessi ai Timer 0 ed 1: 1,8,64,256,1024 e 7 per il Timer2: 1,8,32,64,128,256,1024 ed il valore di prescaler di default è 64 per tutti i Timer da cui: 31250Hz 64 = 488Hz 62500Hz 64 = 976Hz Modificando quindi il prescaler di un Timer puoi variare la Frequenza PWM dei pin collegati ad esso. Ricorda che la frequenza non è il Duty Cycle, variando la frequenza PWM otterrai un periodo inferiore ma non un duty cycle differente. In questo modo la variazione del Timer 1 connesso ai pin 9 e 10 ti permette di continuare a impostare il duty cycle differente sui due pin con il comando analogwrite( pin, val ); Il Timer0 di Arduino Il Timer0, a cui sono collegati i pin 5 e 6, è collegato anche alle funzioni di ritardo interne al micro controllore 135