Arduino a scuola

[Link]
Surfa sulla onda di Arduino e impara le basi
dell'elettronica e della programmazione.

Frédéric Genevey. Illustrazioni: Fanny Conus

info@[Link]
Edizione febbraio 2020 – V6.2
Arduino a scuola

A proposito di questo corso

Questo corso è pubblicato per la comunità Arduino di [Link] tramite il suo sito [Link] Si tratta di
di una risorsa educativa libera1, open source, con licenza CC BY-NC-SA2L'utilizzo gratuito di questo corso
nell'ambito di una formazione a pagamento è tollerata. Un avviso all'autore è comunque gradito. Le scuole
pubblici, licei, palestre, università, le associazioni e i FabLab possono richiedere gratuitamente
una versione Word di questo documento, per adattarlo più facilmente alle loro esigenze o a quelle di studenti con disabilità.

Questo corso può anche servire da base per i genitori che desiderano scoprire il mondo di Arduino e
l'elettronica con i loro figli. Ma per pietà: non costringete i vostri figli a leggerlo! Quello è il vostro lavoro. Abbiate
un approccio ludico e per progetti.

Storico di questo corso

Ho iniziato questo corso allo stesso tempo in cui ho cominciato a usare l'Arduino con i miei studenti nel 2012.
Quest'anno abbiamo colto l'occasione per hackare l'albero di Natale del direttore della scuola3. Prima destinato a studenti
di un'opzione VSO dell'istituto scolastico vodese, questo corso è ora adattato a studenti di una OCOM MITIC o
Tecnologie, dalle 10H.

Puoi inviare i tuoi commenti, le tue idee e correzioni a info@[Link].

Un ringraziamento particolare a Sophie Caré e Jean-Pierre Dulex per la revisione e i test effettuati con essi.
studenti così come al professor Jean-Daniel Nicoud.

Alya, la nostra mascotte, è una creazione di Fanny Conus.

Sostenere la creazione di questo corso

Apprezzi questo corso e ti piacerebbe sostenere la sua creazione e i suoi aggiornamenti? Le tue donazioni sono benvenute.
Serviranno a finanziare l'hosting dei siti e all'acquisto di materiale Arduino. Infine, come questo corso
è una risorsa educativa libera, open source, contribuirai a mantenerne la gratuità.

Puoi fare una donazione tramite PayPal o con una carta di credito a questo indirizzo: [Link]

1[Link]

2 [Link]
3 [Link]

2
Arduino a scuola

I codici utilizzati in questo corso possono essere scaricati da

l'indirizzo seguente:
[Link]

Istruzioni di sicurezza

L'elettricità può essere mortale! Per evitare qualsiasi rischio, in particolare con gli studenti, è opportuno non lavorare
con bassa tensione molto bassa (TBT). La tensione di funzionamento dell'Arduino si aggira attorno a 5 Volt.

Alcune regole elementari di sicurezza

Non collegare mai l'Arduino direttamente alla rete elettrica (230 Volt in corrente alternata).
Per l'alimentazione dei progetti, utilizzare trasformatori conformi alle norme di sicurezza in vigore.
Non smontare apparecchi elettronici senza supervisione. Alcuni componenti, come i
I condensatori possono erogare scariche elettriche mortali, anche quando non sono
connessi al settore.
Ce cours ne permet PAS d'acquérir les compétences et notions de sécurité nécessaires pour travailler
con il settore (230 V), né con l'elettricità automobilistica (12V).

3
Arduino a scuola

Table des matières

A PROPOS DI QUESTO CORSO...................................................................................................................................................... 2

STORIA DI QUESTO CORSO.............................................................................................................................................2

SOSTENERE LA CREAZIONE DI QUESTO CORSO
NORME DI SICUREZZA.................................................................................................................................................... 3
ALGUNE REGOLE ELEMENTARI DI SICUREZZA........................................................................................................3
INDICE........................................................................................................................................................... 4
PREFAZIONE................................................................................................................................................................................... 7
INTRODUZIONE........................................................................................................................................................................ 8
RIFERIMENTI.........................................................................................................................................................8
BIBLIOGRAFIA...............................................................................................................................................................9
I MIGLIORI CORSI ONLINE.................................................................................................................................12
A PROPOS DEGLI SCHEMI ELETTRONICI.................................................................................................................13
MATERIALE NECESSARIO...................................................................................................................................................... 14
DÉCOUVERTE DE LA PLATEFORME ARDUINO............................................................................................................... 15

SCHEMA DI UNA PLATINAARDUINUUNO.......................................................................................................................16

IL MICROCONTROLLER
L'ALIMENTAZIONE
LA CONNESSIONE
Esplorazione dei pin Arduino
LA PLATINE D’EXPERIMENTATION (BREADBOARD).......................................................................................................19
IL SOFTWARE ARDUINO IDE
LE BASI DELL'ELETTRONICA..................................................................................................................................... 21
PICCOLO PROMEMORIA SULL'ELETTRICITÀ...............................................................................................................................21
Alcune risorse per comprendere l'elettricità:.........................................................................................21
PROGETTO 1: IL CIRCUITO ELETTRICO................................................................................................................................ 22
Elenco dei componenti............................................................................................................................................22
Osservazioni...........................................................................................................................................................22
IL CIRCUITO ELETTRICO...............................................................................................................................................23
LE DIODI .................................................................................................................................................................. 24
LE RESISTENZE
PROGETTO 2: FAR FLUTTUARE UN LED........................................................................................................................... 27
Liste des composants............................................................................................................................................27
IL SOFTWARE ARDUINOIDE...........................................................................................................................................28
Il menu..................................................................................................................................................................28
CODE1: FARE FLICKARE UN LED SULLA PIN 13..........................................................................................29
Osservazioni...........................................................................................................................................................29
Debuggare................................................................................................................................................................29
Introduzione al codice..............................................................................................................................................30
Analisi del codice 1.................................................................................................................................................32
Modifichiamo il codice...................................................................................................................................................33
Suggerimento:.....................................................................................................................................................................34
ESERCIZIO: LANCIARE UNSOS........................................................................................................................................34
CODICE DELL'ESERCIZIO
PROGETTO 3: FAR FLASHARE QUATTRO LED................................................................................................................ 36
4
Arduino a scuola

Elenco dei componenti............................................................................................................................................36

CODICE2: FARE CLIGNOTARE 4 LED.................................................................................................37
CODE3:REALIZZARE UN CHENILLARD A4 LEDS............................................................................................................38
PROGETTO 4: INTRODUZIONE ALLE VARIABILI
UNA VARIABILE, COS'È?......................................................................................................................39
Il nome di una variabile...........................................................................................................................................39
Definire una variabile................................................................................................................................................39
DEFINIRE I PIN DEL MICROCONTROLLER
PROGETTO 5: I SEMAFORI........................................................................................................................... 42
Elenco dei componenti............................................................................................................................................43
CODICE4: IL SEMAFORO................................................................................................................................43
VARIANTES...................................................................................................................................................................45
Variante 1
Variante 2
Variante 3................................................................................................................................................................45
PROGETTO 6: L'INCREMENTO
ELENCO DEI COMPONENTI:.............................................................................................................................................46
Analisi del codice.....................................................................................................................................................47
CODE6: REALIZZARE UN CHENILLARD SULLE BROCCHE 10A13 CON UNFOR.........................................................48
Analisi del codice.....................................................................................................................................................49
PROGETTO 7: PWM, REGOLAZIONE DELLA LUMINOSITÀ DI UN LED............................................................................................... 50

CODE7: VARIARE LA LUMINOSITÀ DI UN LED MODIFICANDO IL VALORE PWM................................................51

Analisi del codice.....................................................................................................................................................51
CODE8: FARE VARIARE LA LUMINOSITÀ DI UN LED IN DOLCEZZA................................................................................51
Analisi del codice.....................................................................................................................................................52
CODICE9:ALTERNATIVA PER VARIARE LA LUMINOSITÀ DI UN LED....................................................................53
PROGETTO 8: GLI INPUT NUMERICI.............................................................................................................................. 54
PROTEGGERE L'ARDUINO
RESISTENZA TRASCINAMENTO/DAL SU..........................................................................................................................54
Circuit con una resistenza pull-down.........................................................................................................54
Circuit avec une résistance pull-up.....................................................................................................................55
Resistenza pull-down o pull-up?........................................................................................................................55
CIRCUITO6:MONTAGGIO CON RESISTENZA PULL-DOWN (RICORDO ALMENO)................................................................56
Elenco dei componenti:..........................................................................................................................................56
CODE10: ACCENDERE UN LED IN BASE ALLO STATO DEL PULSANTE.........................................................57
Analizziamo il codice:.........................................................................................................................................................58
CODE11: UN CODICE PIÙ ELEGANTE.............................................................................................................................59
PICCOLI ESERCIZI: PULSANTE E LED CHE FISCHIA.................................................................................60
LE BARGRAPHE
Elenco dei componenti............................................................................................................................................62
CODE12:LE BARGRAPHE............................................................................................................................................63
Video........................................................................................................................................................................64
Analisi del codice:....................................................................................................................................................65
DEPARASITER A L'AIDE DE CONDENSATORI..............................................................................................................67
Che cos'è un condensatore?
VARIAZIONE: IL BARGRAPHE A10 LEDS......................................................................................................................69
CODICE13: IL BARCHART A10 LEDS.........................................................................................................................69
VARIAZIONE: L'AFFICHEUR NUMÉRIQUE.........................................................................................................................72
Identificazione della posizione dei LED..................................................................................................................73
SINTESI: IMPARARE A CONTARE...........................................................................................................................77
Obiettivo....................................................................................................................................................................77
Schema elettronico del montaggio.......................................................................................................................77
5
Arduino a scuola

CODICE15:APPRENDERE A CONTARE.............................................................................................................................79
PROJET 9: LES INPUTS ANALOGIQUES............................................................................................................................ 83

LA PHOTORESISTENZA
CIRCUIT11:DIVISORE DI TENSIONE..............................................................................................................................84
Elenco dei componenti............................................................................................................................................84
CODE16: VALORE DI SOGLIA.........................................................................................................................................85
CODE17:VARIAZIONE DELLA LUMINOSITÀ DI UN ELEMENTO IN FUNZIONE DELLA LUCE AMBIENTE.................................86
Analisi del codice.....................................................................................................................................................87
CODE18: MAPPAGE DE DONNÉES...............................................................................................................................87
PROGETTO 10: IL POTENZIOMETRO...................................................................................................................................... 89
CIRCUITO12: USARE IL POTENZIOMETRO PER VARIARE LA LUMINOSITÀ DI UN LED....................................90
Elenco dei componenti............................................................................................................................................91
CIRCUITO13: UTILIZZARE IL POTENTIOMETRO PER VARIARE LA LUMINOSITÀ DI UN LED....................................91
CODE19: VARIARE LA LUMINOSITÀ DEL LEDENPWMA CON L'AiUTO DI UN POTENZIOMETRO...........................................92
CIRCUIT14: ACCENDERE LE LED DI UN BARGRAPHE UTILIZZANDO UN POTENZIOMETRO................................................93
Elenco dei componenti............................................................................................................................................93
CODE20: VISUALIZZARE IL VALORE DI UN POTENZIOMETRO UTILIZZANDO UNISTOGRAMMA..................................................94
VARIANTE1:UTILIZZARE UN GRAFICO A BARRE 10 LEDS........................................................................................................96
VARIANTE2: UTILIZZARE UN AFFICHEUR LED 8 DIGIT...................................................................................................97
PROJET 11 : CONSTRUIRE UNE STATION MÉTÉO.......................................................................................................... 98
CODE21: ACQUISIRE I DATI DEL SENSORE E VISUALIZZARLI........................................................................100
Liste des composants :.......................................................................................................................................102
CODE22: VISUALIZZARE I DATI SULLO SCHERMO LCD............................................................................................103
PROGETTO 12 : UTILIZZARE UN SERVOMOTORE.....................................................................................................................105
CODICE23: FAR MUOVERE IL BRACCIO DI UN SERVOMOTORE IN ENTRAMBE LE DIREZIONI......................................................107
CODE24: SERVOMOTORE E GESTIONE DEI COMPITI................................................................................................108
CODE25:COMANDARE UN SERVOMOTORE CON UN POTENZIOMETRO...................................................................109
CODE26: COMANDARE DUE SERVOMOTORI CON UN JOYSTICK.................................................................110
CONCLUSIONE (PROVVISORIA)..............................................................................................................................................112

6
Arduino a scuola

Prefazione

Quando Massimo Banzi e i suoi colleghi dell'Interaction Design Institute di Ivrea, in Italia, hanno sviluppato
l'Arduino, l'obiettivo era quello di permettere agli studenti di avere a disposizione una piattaforma del valore di una
pizza per realizzare progetti interattivi4.
Così, l'Arduino è stato progettato fin dall'inizio con uno scopo educativo, per essere economico, dotato di una grande
quantità di ingressi e uscite, compatibile con Mac, Windows e Linux, programmabile con un linguaggio molto
semplice e open source. Ci sono solo vantaggi per il mondo scolastico, soprattutto perché l'Arduino
si situa all'incrocio tra informatica, elettronica e lavori manuali5.

L'approccio pedagogico dell'Arduino è particolare. Non si tratta di affrontare la materia in un modo

lineare, ma lavorando e 'smanettando': si collega, si attacca e si guarda cosa ne viene fuori. È
un approccio pratico e sperimentale che si adatta molto bene a studenti, anche (e soprattutto) poco
scolastici. C'è naturalmente il rischio di "bruciare" un Arduino; ma si tratta solo di 30 franchi di materiale, e non
di un computer a 1200 franchi! L'Arduino è un ottimo strumento per l'apprendimento pratico e basato su progetti
learning. Une approche par la théorie, même si elle reste possible, serait contre-productive.

La migliore prova che l'Arduino è perfettamente adatto agli studenti è che in poche lezioni, sono già
pronti a realizzare progetti concreti.

Questo corso è stato pensato per studenti (e insegnanti) che non hanno alcuna nozione di programmazione e in
elettronica. Rispetto al gigantesco potenziale dell'Arduino, è volutamente limitato, ma si sforza
essere progressivo e soprattutto incentrato sulla pratica. Questo corso non è fatto per essere seguito in modo lineare.
Serve infatti da quadro teorico. Dopo le basi acquisite, l'insegnante ha tutto l'interesse a lavorare in
progetto basato su questo corso.

Nota: fai attenzione alle copie cinesi di Arduino. Quelle più economiche possono presentare problemi.
d'utilizzo abbastanza importanti (driver necessari, cablature con contatti difettosi...).

Illustrazione 1 Diduino, compatibile Arduino, sviluppato a Losanna

Storia dell'Arduino:[Link]
4

5Riferimenti:[Link] e
[Link]
7
Arduino a scuola

Introduzione

Riferimenti
Questo documento è una compilation e un'adattamento di testi e esercizi, provenienti dalle seguenti fonti:

Fonti principali:

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

Fonti annesse:

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

Questo corso offre solo un'introduzione all'elettronica. Un corso molto più completo e ben fatto è
disponibile qui:

[Link]

Inoltre, è importante notare il seguente eccellente wiki, che propone un gran numero di esperimenti su Arduino.
Ideale per laboratori o per organizzare sfide agli studenti:

[Link]

8
Arduino a scuola

Bibliografia
Esistono molti libri su Arduino e sull'elettronica. Ecco una selezione di libri che abbiamo
valutati e selezionati.

Nota: vi incoraggiamo a ordinare questi libri presso il vostro libraio. Ma se desiderate farlo
ordinare su Amazon, vi saremmo grati di utilizzare i link sponsorizzati qui sotto. Essi
mi permettono di guadagnare abbastanza per ordinare uno o due libri Arduino all'anno.

Elettronica:

L'elettronica in pratica, di Charles Platt

ISBN: 978-2212135077

L'approccio pedagogico di questo libro è l'apprendimento attraverso la pratica.

Si inizia con l'esperimento e la scoperta, e solo dopo
viene la teoria per rafforzare ed esplicitare le scoperte. Questo ne fa
quindi un'opera di riferimento per l'apprendimento dell'elettronica a
la scuola; in particolare in complemento agli Arduino e Raspberry Pi. Lui
si tratta quindi di un eccellente libro per l'insegnante.

Sfogliare questo libro su [Link]

Comandare su [Link]

L'elettronica per i Bambini, di Øyvind Nydal Dahl

ISBN:978-2212118629

A volte è difficile affrontare e far capire le nozioni

d'elettricità e di elettronica agli studenti. È lì che il
L'elettronica per i bambini porta un approccio
interessante: non ci si imbarazza con Arduino e programmazione.
L'intero del primo terzo del libro, cioè la parte 1, è dedicato a
l'elettricità. In modo semplice e pedagogico, il bambino comprende questo
che cos'è l'elettricità. La seconda parte permette la scoperta dei
diversi componenti elettronici attraverso piccoli circuiti, di cui
alcuni sono saldati. Infine, la terza parte è un approccio al
monde digitale, ma per l'elettronica. E questa parte, è
geniale! Affrontiamo i circuiti logici, il binario…

Sfogliare questo libro su [Link]

Comandare su [Link]

9
Arduino a scuola

Arduino:

Il grande libro di Arduino, di Erik Bartmann

ISBN: 978-2212137019

Questo libro è senza dubbio uno dei migliori per iniziare con Arduino. Esso
offre una breve introduzione all'elettronica e soprattutto il codice è molto
ben spiegato, arricchito da schemi. Non si limita infine a
alcune nozioni di base, ma va abbastanza lontano.

Sfogliare su [Link]
Comandare su [Link]

Démarrez avec Arduino – 2e édition: Principes di base e primi

montaggi, di Massimo Banzi

ISBN: 978-2100701520

Massimo Banzi è uno dei principali creatori di Arduino. Tanto per dire
che conosce il suo argomento! L'accento di quest'opera è messo su un'iniziazione
alla programmazione dell'Arduino, più che sull'elettronica. A
consigliare a tutti i principianti.

Comandare il libro su [Link]

A l'avventura con Arduino – Da 10 anni, di Becky Stewart

ISBN: 978-2212143140

Il sottotitolo; « dai 10 anni in su » implica che questo libro manca

completamente il suo obiettivo: grossi blocchi di testo, presentazione densa,
touffue e un po' triste così come dover attendere la pagina 41 prima di
realizzare il proprio primo montaggio (una resistenza, un LED…
Ora, questo libro ha comunque alcuni vantaggi certi, per un
insegnante o un genitore che accompagnerà i bambini: gli esercizi
sono ben organizzati, le spiegazioni sono chiare e semplici da
comprendere. Gli obiettivi sono ambiziosi, poiché si arriverà fino a
affrontare i registri a scostamento e i servocomandi.

Comandare il libro su [Link]

10
Arduino a scuola

Programmare con Arduino divertendosi per i principianti, di Olivier

Engler

ISBN: 978-2412023877

Tutti conoscono la serie di libri Per dummies. Il nome della

la collezione è ingannevole; ogni libro va a studiare un argomento a fondo; ma esso
prendere per mano il lettore, passo dopo passo.
È indicato sulla copertina: 20 progetti da realizzare a partire dai 10 anni.
Allora? Insomma, non ci si diverte; e a 10 anni, avremo di meglio da fare
che di immergersi in questo libro. Eppure, rimane uno dei
migliori libri per scoprire il mondo di Arduino, ma destinati
adolescenti appassionati o adulti che non hanno alcuna nozione di
programmazione o di Arduino e che sono interessati a scoprire questo
mondo... o accompagnare un giovane. Di fatto, è un eccellente libro per
tutti gli insegnanti che non hanno anni di programmazione alle spalle
lui/lei e chi desidera coinvolgere i propri alunni nell'avventura Arduino.
condizione di accettare il tu alla moda Ikea... e le manie
linguistiche dell'autore, che si sforza à appelermikonun
microcontrollore.
Il primo montaggio elettronico interviene solo poco prima della pagina
100. Prima di ciò, ci sono pochi pratici. Avremo perso tutti i
giovani molto prima di questo. Ma allora, cosa succede durante i 100
premières pages? Et bien une présentation, claire, didactique, de
l'Arduino, come non l'ho mai visto in altri libri. Si affronta
anche il linguaggio assembly (brevemente, ma ne parliamo, con
anche un esempio). È anche il primo libro che presenta
semplicemente e chiaramente cos'è un microcontrollore e a cosa serve.
Ogni elemento della scheda Arduino Uno è così presentato. È
completo, semplice, comprensibile.
Ogni concetto è così presentato. Normalmente, in un corso
Arduino, iniziamo a fare dei collegamenti sui pin
numerici. Lì no; si inizia con i pin analogici.
Sorprendente. Rinfrescante. E non così stupido. Tutti noi comprendiamo una
variazione di un valore analogico.

Ordinare il libro su [Link]

50 montaggi pedagogici con Arduino, di Alexis Dumont e

Benoit Yernaux

ISBN: 979-1027501441

Ecco finalmente un libro esplicitamente destinato agli insegnanti. Qui, niente di

teoria, ma immediatamente dalla pratica. Come il suo titolo indica,
il libro è un catalogo di progetti Arduino, sempre più complessi e
destinati alla classe. Non si tratta qui di lavorare solo sulla
programmazione, ma anche utilizzare Arduino in matematica,
fisica, biologia... Una buona base per lavori pratici o
progetti degli studenti. Questo libro non è destinato ai principianti nel
monde Arduino, ma bene all'insegnante, che avendo già buone
bases, cherche des projets pour ses élè[Link] lien avec les différentes
le discipline scolastiche sono il vero valore aggiunto di questo libro.

Commander le livre sur [Link]

11
Arduino a scuola

Sylvia presenta: super progetti Arduino, di Sylvia Todd

ISBN: 978-2412023891

Non è comune che un libro su Arduino sia scritto da una giovane

fanciulla. Ma non è una qualsiasi fanciulla; è già
una figura riconosciuta nel movimento maker. Questo piccolo libro, molto
colorato, splendidamente illustrato, si rivolge chiaramente ai bambini; ma i
gli adulti principianti su Arduino troveranno altrettanto soddisfacente.
Come il titolo indica, non si tratta di imparare a programmare su
Arduino, ma avvicinarsi a questo mondo con piccoli progetti che, in effetti
di nulla, a volte vanno abbastanza lontano. Un successo.

Comandare il libro su [Link]

Quaderno di attività Arduino per bambini: Dai 8 anni, di Frédéric

Dolore

ISBN: 978-2212675696

È anche possibile programmare Arduino utilizzando Scratch e del

software mBlock. Questo libro è molto chiaro e ben illustrato. Ci guida a
attraverso sette passaggi per arrivare alla creazione di una mini-stazione
meteo. La programmazione avviene tramite Scratch, quindi senza codice e il tutto
in francese. Ideale quindi per permettere ai giovani curiosi di scoprire
il mondo Arduino.
Resto comunque dubbioso sul montaggio "pluviometro". Con il mio
esperienza, cercherò di evitare di far coabitare dell'acqua con
l'elettronica e un computer...

Comandare il libro su [Link]

I migliori corsi online

[Link]
[Link]

12
Arduino a scuola

A proposito degli schemi elettronici

Per realizzare gli schemi elettronici, utilizziamo i seguenti strumenti, disponibili gratuitamente su Mac
et PC:

Fritzing: [Link]
Risolvere Elec: [Link]
Fido Cadj: [Link]
QElectroTech[Link]
iCircuit[Link]

Esiste anche una soluzione molto elegante online6[Link] Questo sito consente di creare
schemi elettrici e realizzazione di circuiti elettronici.

Un simulatore Arduino è disponibile anche a questo indirizzo: [Link] Permette di

realizzazione di schemi di impiantazione dei componenti sulle schede di sperimentazione, proprio come
Fritzing, ma anche la realizzazione di schemi e circuiti elettronici.

Illustrazione 2 Simulatore Arduino di Tinkercad

6Sarà la soluzione utilizzata principalmente in questo corso. Per ulteriori informazioni: [Link]
13
Arduino a scuola

Materiale necessario

Ecco l'elenco minimo del materiale necessario per seguire questo corso:

Una scheda Arduino o compatibile Arduino

Una protoboard
Cavi di collegamento (jumper)
6 LED rossi
2 LED verdi
2 LED gialli o arancioni
1 LED RGB anodo o catodo comune
10 resistenze da 220 a 470Ω
2 resistenze da 1 a 10kΩ
2 condensatori 10nF
2 pulsanti
1 fotoreistenza
1 bargraphe 10 LED*
1 multimetro
1 potenziometro (resistenza variabile) di 10 o 20kΩ
1 servo
1 joystick*

Per poter andare oltre, ecco i componenti necessari:

Sensore di temperatura e umidità DHT11

1 schermo LED 2x12

(*opzionale)

Nota: questa lista evolverà insieme al corso

14
Arduino a scuola

Scoperta della piattaforma Arduino

Arduino fa parte della famiglia delle schede di sviluppo. A differenza del Raspberry Pi7, non possiede
nessun OS basato su Linux. È quindi necessario un computer. Rimane però uno dei più accessibili e
dei più diffusi. Una scheda di sviluppo è in generale un circuito stampato dotato di un
microprocessore o di un microcontrollore. Poiché Arduino è open source, esiste un gran numero di
cloni e di schede compatibili, proprio come esistono molti modelli ufficiali di Arduino, con
funzioni particolari:

Illustrazione 3 Diversi modelli di Arduino

Per questo corso, ci baseremo sul più conosciuto: l'Arduino Uno. Ma un altro modello o un clone andrà bene.
anche l'affare.

7[Link]

15
Arduino a scuola

Schema di un'unità Arduino Uno

Il microcontrollore
È il cervello della nostra mappa. Contiene:

• Un processore per elaborare i dati e

fare i calcoli
• Uno spazio di archiviazione dei dati
• Porti per comunicare (i pin)

Riceverà il programma che stiamo per creare e

deve memorizzarlo prima di eseguirlo.
Grazie a questo programma, saprà fare delle cose,
qui peuvent essere: far lampeggiare un LED, visualizzare dei
caratteri su uno schermo, inviare dati a un
computer, accendere o spegnere un motore...

Il existe deux modèles d’Arduino Uno: l’un avec un

microcontrollore di grande dimensione, e un altro con un
microcontrollore detto SMD (SMD: Montato a Superficie
Dispositivo, ovvero componenti montati in superficie, in
opposizione ai componenti che attraversano la scheda
elettronica e che sono saldati dal lato opposto). Di un
dal punto di vista dell'uso, non c'è differenza tra
i due tipi di microcontrollori.
Illustration 4: un processeur ATmega328 au microscope

16
Arduino a scuola

Arduino Uno Arduino Uno SMD

Quando si osserva una scheda Arduino Uno ai raggi X, si nota che il grande chip contiene in realtà
una piccola scheda, come quella della versione SMD. Nota anche le piste che collegano i pin al
microcontrôleur:

Mathew Schwartz

17
Arduino a scuola

L'alimentazione
Per funzionare, una scheda Arduino ha bisogno di un'alimentazione. Il microcontrollore funziona a 5V, la
la scheda può essere alimentata direttamente a 5V tramite la porta USB o tramite un'alimentazione esterna che è
comprende tra 7V e 12V. Un regolatore si occupa poi di ridurre la tensione a 5V per il buon
funzionamento della carta.

Attenzione: le carte Arduino Due insieme ad altre schede recenti funzionano con un
tensione di 3.3V ai livelli delle uscite! La tensione di alimentazione è simile a quella dell'Arduino
Uno. In questo corso, partiamo dal presupposto che la tensione dei circuiti sia di 5 Volt.

La connettività
A parte una LED sul pin 13, la scheda Arduino non
non possiede alcun componente (resistenze, diodi,
motori...) che possono essere utilizzati per un programma. Esso
è necessario aggiungerli. Ma per questo, è necessario che li
collegare alla mappa. È qui che intervengono i
connettori, detti anche spine.

Sugli Arduino e su molte schede compatibili

Arduino, i pin si trovano nello stesso posto. Questo
permette di fissare delle schede di espansione, chiamate shield
impilandoli.

Esplorazione delle pin Arduino

0 a 13 Entrées/sorties digitali
A0 a A5 Entrate/uscite analogiche
GND Terra o massa (0V)
5V Alimentazione +5V
3,3V Alimentazione +3,3V
Vino Alimentazione non stabilizzata (= lo stesso voltaggio di quello in ingresso alla scheda)

Le connessioni tra i componenti sono realizzate tramite dei jumper, una sorta di piccoli cavi.

18
Arduino a scuola

La breadboard
Una piastra di sperimentazione (chiamata breadboard) permette di realizzare prototipi di montaggi
elettronici senza saldatura e quindi poter riutilizzare i componenti.

Tutti i connettori in una fila di 5 sono collegati tra loro. Quindi se colleghiamo due elementi in un
gruppo di cinque connettori, saranno collegati tra loro. Lo stesso vale per gli allineamenti dei connettori
rossi (per l'alimentazione) e blu (per la terra). Così, i legami possono essere schematizzati così:

Le lunghe file sono utilizzate per connettere la massa (GND), in blu e il +5V, in rosso

I connettori sono elettricamente collegati tra loro da 5

Non c'è alcun collegamento elettrico attraverso la linea di separazione

Tutti i connettori di una linea esterna sono elettricamente collegati tra loro

Les composants doivent ainsi être placés à cheval sur des connecteurs qui n'ont pas de liens électriques entre
loro, come nello schema a fianco.

19
Arduino a scuola

Il software Arduino IDE

Il software Arduino IDE funziona su Mac, Windows e Linux. È grazie a questo software che creeremo,
testare e inviare i programmi sull'Arduino.

L'IDE è scaricabile all'indirizzo seguente: [Link]

Una versione online dell'editor di codice è disponibile a questo indirizzo: [Link]

20
Arduino a scuola

Le basi dell'elettronica
Piccolo promemoria sull'elettricità

L'elettricità (o più precisamente corrente elettrica) è uno spostamento di elettroni in un mezzo

conduttore. Possiamo immaginarlo come un movimento d'acqua in un tubo o in una diga.
idroelettrico.

Gli elettroni sarebbero l'acqua

Il generatore sarebbe il serbatoio d'acqua
I conduttori sono naturalmente le condotte forzate
Il consumatore (una lampadina o un diodo, per esempio) è la turbina, che sfrutta l'energia del
déplacement des électrons

Su una diga, più è grande la differenza tra l'altitudine del livello del serbatoio e quella della turbina,
più la pressione dell'acqua sarà importante. Per una diga si chiama questa differenza di altitudine altezza di
caduta. Ciò equivale, in un circuito elettrico, alla differenza di potenziale, che si misura in Volts (V) e si annota
U.
Il debito d'acqua (= la quantità d'acqua che scorre per unità di tempo) corrisponde all'intensità, chiamata anche
corrente, che è quindi il flusso di elettroni. Si misura in Ampère (A) e si nota I.
La potenza elettrica si nota Pet e si misura in Watt (W). Essa esprime la quantità di corrente (I),
trasformata in calore o in movimento. Su una diga, corrisponde all'energia prodotta dalla turbina.

La potenza P è il prodotto della tensione V in volt e dell'intensità I in ampere.

!=#∙%
Affinché questi elettroni si muovano tutti nella stessa direzione, è necessario che ci sia una differenza nel numero.
di elettroni tra le due estremità del circuito elettrico.
Per mantenere questa differenza nel numero di elettroni, si utilizza un generatore (batteria, accumulatore,
alternatore...
La differenza di quantità di elettroni tra due parti di un circuito si chiama differenza di potenziale.
si misura in Volts (V).

Alcune risorse per comprendere l'elettricità:

Non è un mistero sull'elettricità: [Link]

Non è magia sul trasporto dell'elettricità: [Link]
Non è magia sulle batterie e sulle pile: [Link]
Sito educativo sull'elettricità Hydro-Québec:[Link]
La battaglia dell'elettricità
21
Arduino a scuola

Progetto 1: il circuito elettrico

Realizza il circuito seguente:

Nota: il colore dei fili elettrici importa poco, così come la loro posizione sulla piastra di sperimentazione.

Circuito 1

Liste des composants

1 LED
1 resistenza da 220 a 470Ω
2 cavi

Osservazioni

+5V Ecco cosa significa a livello dello schema elettronico.

RESISTENZA
220 Quando si collega l'Arduino al computer tramite il cavo USB, esso
c'è il 50% di possibilità che il LED si accenda. Infatti, se non
non si accende, è necessario girare il LED nell'altro verso. Sua
la particolarità è che l'elettricità può attraversarla solo in
D1 un senso.
LED

22
Arduino a scuola

Il circuito elettrico
Per avere una corrente elettrica, abbiamo bisogno di una fonte, di un ricevitore e di un percorso.

La fonte fornisce la forza che muove gli elettroni: una batteria, un accumulatore, un generatore...
Il ricevitore utilizzerà la forza di spostamento degli elettroni: una lampadina, un motore…
Il conduttore permette agli elettroni di muoversi dalla sorgente al ricevitore: spesso si tratta di
fils de cuivre.

Insieme, formano un circuito elettrico. È quello che è stato realizzato durante l'esercizio: hai collegato una sorgente
di elettroni verso la terra. Questo ha creato una tensione e quindi una corrente elettrica: gli elettroni si sono mossi.
Il loro spostamento ha così permesso al LED di accendersi. L'Arduino serve solo per l'alimentazione elettrica, come
una pila.

Una batteria è costituita da un mezzo contenente numerosi elettroni in eccesso e da un secondo mezzo in deficit.
di elettroni. Quando si collegano i due poli della batteria (il + e il -) con un filo elettrico (il conduttore), i
gli elettroni si sposteranno quindi dal mezzo ricco di elettroni verso il mezzo povero. Se posizioniamo una lampada
elettrica tra i due, il passaggio degli elettroni genererà luce.

Circuito elettrico

Ecco lo schema elettrico del circuito qui sopra:

Interruttore
S1

Ampolla L1 V1 Mazzo
5

Quando l'interruttore è attivato, si dice che il circuito è chiuso. Gli elettroni inizieranno quindi a muoversi e
l'énergie de ce déplacement pourra être exploitée pour allumer une lampe ou faire fonctionner un moteur, par
esempio.

Quando l'interruttore è attivato, si dice che il circuito è aperto. Il polo positivo non è più collegato al
polo negativo, gli elettroni non possono più muoversi.

23
Arduino a scuola

Les diodes
L'abbiamo visto: la corrente elettrica si muove in un senso; ha un senso di spostamento. È possibile di
sostituire la lampadina con un diodo a emissione luminosa, comunemente chiamato LED8Ha la particolarità di non
lascia passare la corrente elettrica solo in una direzione.

La corrente elettrica può attraversare il diodo solo nel senso dell'anodo verso il catodo.

Si riconosce l'anodo, poiché è il pin più lungo. Quando i due pin sono
di uguale lunghezza, si può distinguere l'anodo dal catodo, grazie a una superficie piana su un lato di
quest'ultima. Il simbolo del LED è il seguente:

Attenzione: la corrente prodotta dall'Arduino è troppo elevata per collegarvi direttamente un LED.
L'utilizzo di una resistenza è obbligatorio, per non bruciare il LED.

Utilizzando vari materiali semiconduttori, si fa variare il colore della luce emessa dal LED.
existe enfin une grande variété de formes de LEDs.

8[Link]

24
Arduino a scuola

Le resistenze

L'unrésistance è un componente elettronico o elettrico la cui principale

caratteristica è quella di opporre una resistenza più o meno grande (misurata in ohm:
Ω) alla circolazione della corrente elettrica.

Si può allora confrontare, il flusso d'acqua con la corrente elettrica I (che è peraltro il flusso
d'elettroni), la differenza di pressione alla differenza di potenziale elettrico (che è la
tensione U) e, infine, il restringimento alla resistenza R.

Pertanto, per una tensione fissa, minore è la resistenza, maggiore è la corrente che la attraversa. Questa proporzione
è verificata dalla legge di Ohm:

& &
& = ' ∙ % )* +,-. ' = )* % =
% '
Una resistenza è un mezzo poco conduttore; gli elettroni faticano a muoversi in esso. La loro energia
si dissipa quindi generalmente sotto forma di calore. È questo il principio utilizzato per i bollitori
elettriche o le lampadine a filamento.

Il valore della resistenza si misura in Ohm (Ω). Il valore di una resistenza è determinato da
i suoi nastri colorati.

È anche possibile utilizzare una resistenza come riduttore di tensione. Infatti, basta recuperare una
fonte di corrente elettrica prima e dopo la resistenza.

25
Arduino a scuola

Oltre alla tabella qui sopra, possiamo aiutarci con il piccolo manuale che si trova qui:
[Link]

La resistenza è schematizzata in questi due modi (europeo a sinistra e americano a destra):

Un calcolatore di valori di resistenze è disponibile a questo indirizzo: [Link]

26
Arduino a scuola

Progetto 2: far lampeggiare un LED

Come primo programma, faremo lampeggiare un LED D1, connesso al pin 13. Ecco il
schema di cablaggio:

Circuito 2

U1
ARDUINO

AREF
GND
D13
D12
D11
RESET D10 R1 D1
3V D9 220 LED
5V D8
GND2
GND1 D7
VIN D6
D5
A0 D4
A1 D3
A2 D2
A3 D1
A4 D0
A5

Liste des composants

1 Led
1 resistenza da 220 a 470Ω
2 cavi

27
Arduino a scuola

Il software Arduino IDE

La programmazione avviene nel software Arduino IDE:

Menu

Finestra di programmazione

Finestra di controllo

Il menu

Pulsante 1: Questo pulsante consente di controllare il programma, attiva un modulo che cerca gli errori.
nel programma
Pulsante 2: Invio del programma su Arduino
Pulsante 3: Crea un nuovo file
Pulsante 4: Apri un file esistente
Pulsante 5: Salva un file

Cominciamo subito con un piccolo codice. Lo analizzeremo poi.

Una volta scritto (o incollato) il codice nella finestra di programmazione, è necessario inviarlo all'Arduino. Per fare ciò,
dopo aver collegato l'Arduino al computer, è necessario selezionare la porta (tty_usbmodemXXXXX) e il tipo di
carte (Arduino Uno, nel nostro caso). Queste due impostazioni si trovano nel menu Strumenti.

Clicca infine sul pulsante carica.

28
Arduino a scuola

Codice 1: far lampeggiare un LED sul pin 13

/*
Codice 1 - [Link], destinato all'Arduino
Obiettivo: far lampeggiare il LED montato sul pin 13
*/

//***** FUNZIONE DI SETUP = Codice di inizializzazione *****

// La funzione setup() viene eseguita per prima e una sola volta, all'avvio del programma

void setup() // début de la fonction setup()

{
pinMode(13, OUTPUT); // Inizializza il pin 13 come uscita
[Link](9600); // Apre la porta seriale a 9600 baud
} // fine della funzione setup()

//***** FUNZIONE LOOP = Ciclo infinito = cuore del programma *****

// la funzione loop() viene eseguita indefinitamente in loop finché l'Arduino è sotto
tensione

void loop() // inizio della funzione loop()

{
digitalWrite(13, ALTO); // Imposta il pin 13 a livello alto = accende il LED
ritarda(500); // Pausa di 500 ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegni il LED
ritarda(500); // Pausa 500ms
} // fin de la fonction loop()

Osservazioni

Questo codice consente di far lampeggiare il LED D1 situato sul pin 13. Un LED, saldato sull'Arduino e collegato
alla broche 13 lampeggia anche lei. La resistenza R1 di 220Ω serve ad abbassare la tensione e a evitare che il LED non
griglia.

Debuggare

Ci sono molti errori possibili in un programma Arduino. La lettura e la comprensione di questi

erreurs dans Arduino IDE ne sont pas évidentes. Vous trouverez de précieux conseils ici:

[Link]

29
Arduino a scuola

Introduzione al codice

Lo svolgimento del programma

Il programma si svolge nel seguente modo:

1. Considerazione delle istruzioni della parte dichiarativa

2. Esecuzione della parte configurazione (funzione setup())
3. Esecuzione del ciclo infinito (funzione loop ( )): il codice incluso nel ciclo infinito viene eseguito
indefinitamente.

Vedremo passo dopo passo i vari elementi presenti nello schema. L'importante per il momento è di
sapere che un programma è suddiviso in tre parti: intestazione dichiarativa, funzione setup e funzione loop.

La suite ci permetterà di entrare nel codice minimale: le funzioni setup e loop.

Il codice minimale

Con Arduino, dobbiamo utilizzare un codice minimale quando creiamo un programma. Questo codice permette di dividere
il programma in due parti.

void setup()
{
}

vuoto ciclo()
{
}

Abbiamo quindi davanti a noi il codice minimo che deve essere inserito nel nostro programma. Ma cosa può realmente
significare per qualcuno che non ha mai programmato?

30
Arduino a scuola

La fonction

Nel codice 1, si trovano due funzioni. Le funzioni sono in realtà porzioni di codice.

Prima funzione:

void setup()
{
}

Questa funzione setup() viene chiamata una sola volta quando inizia il programma. È per questo che si trova in
questa funzione che scriveremo il codice che deve essere eseguito solo una volta. La chiamiamo questa
fonction : "fonction d'initialisation". On y retrouvera la mise en place des différentes sorties et quelques autres
impostazioni.

Una volta che si è inizializzato il programma, è necessario poi creare il suo 'cuore', in altre parole il programma stesso.
stesso.

Seconda funzione:

void loop()
{
}

È quindi nella funzione loop() che scriveremo il contenuto del programma. È importante sapere che questa
la funzione viene chiamata continuamente, cioè viene eseguita una volta, poi quando la sua esecuzione è
terminata, la rieseguiamo, ancora e ancora. Parliamo di ciclo infinito.

Le istruzioni

Ora che abbiamo visto la struttura delle funzioni, diamo un'occhiata a ciò che possono contenere.

Le istruzioni sono delle righe di codice che dicono al programma: "fai questo, fai quello..." Quindi sono le
ordini che saranno eseguiti dall'Arduino. È molto importante rispettare esattamente la sintassi; in caso contrario
cosa, il codice non potrà essere eseguito.

I punti e virgola ;

I punti e virgola terminano le istruzioni. Se per esempio diciamo nel nostro programma: "chiama il
funzione mangiareIlGatto", dobbiamo mettere un punto e virgola dopo la chiamata a questa funzione.

Quando il codice non funziona, spesso è perché manca un punto e virgola. È quindi necessario essere molto
attento a non dimenticarli!

Le parentesi graffe { }

Le parentesi graffe sono i "contenitori" del codice del programma. Sono specifiche per le funzioni, le condizioni
e ai cicli. Le istruzioni del programma sono scritte all'interno di queste parentesi graffe.
Per aprire una graffa su Mac, premere alt-8 e alt-9 per chiuderla.

I commenti

I commenti sono righe di codice che verranno ignorate dal programma. Non servono a nulla.
Durante l'esecuzione del programma. Permettono di annotare e commentare il programma.

Linea unica di commento:

31
Arduino a scuola

//questa riga è un commento su UNA SOLA riga

Linea o paragrafo su più righe:

/*questa riga è un commento, su PIÙ righe

qui sarà ignorato dal programma, ma non da colui che legge il codice ;)

Gli accenti

È formalmente vietato mettere accenti nella programmazione! Tranne nei commenti...

Analisi del codice 1

Torniamo ora al nostro codice.

La ligne pinMode(13, OUTPUT); inizializza il pin 13 del microcontrollore come uscita, cioè che
Dati saranno inviati dal microcontrollore verso questo pin (invieremo elettricità).

La ligne [Link](9600); inizializza la porta seriale che consente all'Arduino di inviare e ricevere
informazioni al computer. È consigliato, ma funziona anche senza.

Con l'istruzione digitalWrite(13, HIGH);, il microcontrollore collega il pin D13 a +5V che ha come
effetto di accendere il LED (l'elettricità esce dal pin D13).

L'instructiondelay(500);indique au microcontrôleur de ne rien faire pendant 500 millisecondes, soit½

secondi.

Con l'istruzione digitalWrite(13, LOW);, il microcontrollore collega il pin D13 alla massa (Gnd) questo
che ha l'effetto di spegnere il LED (si interrompe l'alimentazione elettrica).

L'istruzione delay(500); indica al microcontrollore di non fare nulla per 500 ms cioè ½
secondi.

Il risultato è quindi che il LED si accende per ½ secondo, poi si spegne per un secondo poi
si accende per mezzo secondo... quindi lampeggia.

32
Arduino a scuola

Approfittiamo ora per vedere cosa significa il termine Output. Si tratta di specificare se il pin è un ingresso
o un'uscita. Infatti, il microcontrollore ha la capacità di utilizzare alcune delle sue porte in ingresso (INPUT)
o in output. È sufficiente semplicemente scambiare una riga di codice per dire che è necessario utilizzare una
broche in ingresso (recupero dei dati) o in uscita (invio dei dati).

Questa riga di codice deve trovarsi nella funzione setup(). La funzione è pinMode(), come nell'esempio
qui sotto:

void setup()
{
pinMode(13, OUTPUT);
[Link](9600);
}

Modifichiamo il codice

Facciamo variare i valori dell'istruzione delay e modifichiamo il codice secondo gli esempi qui sotto.

Prova 1:

digitalWrite(13, ALTO);
ritardo(50);
digitalWrite(13, BASSO);
ritarda(50);

Essai 2:

digitalWrite(13, ALTO);
ritarda(500);
digitalWrite(13, BASSO);
ritardo(2000);

Essai 3:

digitalWrite(13, ALTO);
ritardo(50);
digitalWrite(13, BASSO);
ritardo(50);
digitalWrite(13, ALTO);
ritarda(1000);
digitalWrite(13, BASSO);
ritardo(1000);

33
Arduino a scuola

Suggerimento:

Poiché c'è già una resistenza e un LED saldati all'Arduino e collegati al pin 13, è
possibile installare direttamente un LED tra il pin e la terra (GND).

Esercizio: lanciare un SOS

In codice Morse, le lettere sono codificate utilizzando una

successione di impulsi corti e lunghi. Si utilizza il
codice morse per trasmettere un SOS, ad esempio sotto
forme di segnali luminosi con una torcia.

L'esercizio consiste nel programmare l'Arduino e il suo LED affinché

trasmette un segnale di SOS luminoso. Ecco a cosa
somiglia a un SOS in morse:

▄ ▄ ▄ ▄▄▄ ▄▄▄ ▄▄▄ ▄ ▄ ▄

Attenzione: non ci sono spazi tra le lettere di un

SOS.

Un video con il risultato è visibile qui:

[Link]

34
Arduino a scuola

Codice dell'esercizio SOS

/*
Esercizio Codice SOS - [Link], destinato all'Arduino
Obiettivo: far lampeggiare il LED montato sul pin 13 per inviare un SOS
*/

//***** FUNZIONE DI INIZIALIZZAZIONE = Codice di inizializzazione *****

// La funzione setup() viene eseguita per prima e una sola volta, all'avvio del programma

void setup() // inizio della funzione setup()

{
pinMode(13, OUTPUT); // Inizializza il pin 13 come uscita
[Link](9600); // Apre la porta seriale a 9600 baud
} // fine della funzione setup()

//***** FUNZIONE LOOP = Ciclo infinito = cuore del programma *****

// la funzione loop() si esegue senza fine in ciclo finché l'Arduino è sotto
tensione

void loop() // début de la fonction loop()

{
digitalWrite(13, ALTO); // Metti la broche 13 al livello alto = accendi il LED
ritardo(200); // Pausa di 200ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritardo(200); // Pausa 200ms

digitalWrite(13, ALTO); // Imposta il pin 13 a livello alto = accende il LED

ritardo(200); // Pausa di 200 ms
digitalWrite(13, BASSO); // Imposta il pin 13 su livello basso = spegne il LED
ritardo(200); // Pausa 200ms

digitalWrite(13, ALTO); // Metti la broche 13 al livello alto = accendi il LED

ritardo(200); // Pausa di 200ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritarda(200); // Pausa 200ms

digitalWrite(13, ALTO); // Metti il pin 13 al livello alto = accende il LED

ritardo(600); // Pausa di 600ms
digitalWrite(13, LOW); // Imposta il pin 13 su livello basso = spegne il LED
ritardo(200); // Pausa 200ms

digitalWrite(13, ALTO); // Metti la broche 13 al livello alto = accendi il LED

ritardo(600); // Pausa di 600 ms
digitalWrite(13, BASSO); // Imposta la broche 13 a livello basso = spegne il LED
ritarda(200); // Pausa 200ms

digitalWrite(13, ALTO); // Imposta il pin 13 su alto = accende il LED

ritarda(600); // Pausa di 600 ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritardo(200); // Pausa 200ms

digitalWrite(13, ALTO); // Metti il pin 13 a livello alto = accendi il LED

ritardo(200); // Pausa di 200 ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritarda(200); // Pausa 200ms

digitalWrite(13, ALTO); // Imposta il pin 13 alto = accende il LED

ritardo(200); // Pausa di 200ms
digitalWrite(13, LOW); // Metti il pin 13 su basso = spegni il LED
ritarda(200); // Pausa 200ms

digitalWrite(13, HIGH); // Imposta il pin 13 a livello alto = accende il LED

ritardo(200); // Pausa di 200 ms
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritardo(1000); // Pausa 1000ms
} // fine della funzione loop()
35
Arduino a scuola

Progetto 3: far lampeggiare quattro LED

Ecco il montaggio da realizzare. I LED sono collegati ai pin 10 a 13.

Circuito 3

U1
ARDUINO

D1
R1 LED
AREF 220
GND
D13
D12 D2
D11 R2 LED
RESET D10 220
3V D9
5V D8
GND2 D3
GND1 D7 R3 LED
VIN D6 220
D5
A0 D4
A1 D3 D4
A2 D2 R4 LED
A3 D1 220
A4 D0
A5

Liste des composants

4 LED
4 resistenze da 220 a 470Ω
6 cavi

36
Arduino a scuola

Codice 2: far lampeggiare 4 LED

Questo codice fa lampeggiare i 4 LED contemporaneamente.

/*
Codice 2 - [Link], destinato all'Arduino
Objectif: faire clignoter les 4 LEDs montées sur les broches 10 à 13
*/

//***** FUNZIONE SETUP = Codice di iniziializzazione *****

// La funzione setup() viene eseguita per prima e una sola volta, all'avvio del programma

void setup() // inizio della funzione setup()

pinMode(10, OUTPUT); // Inizializza il pin 10 come uscita

pinMode(11, USCITA); // Initialise la broche 11 comme sortie
pinMode(12, OUTPUT); // Inizializza il pin 12 come uscita
pinMode(13, OUTPUT); // Inizializza il pin 13 come uscita

[Link](9600); // Apre la porta seriale a 9600 baud

} // fine della funzione setup()

//***** FUNZIONE LOOP = Ciclo infinito = cuore del programma *****

// La funzione loop() viene eseguita senza fine in loop finché l'Arduino è sotto
//tensione

vuoto ciclo() // inizio della funzione loop()

digitalWrite(10, ALTO); // Imposta il pin 10 al livello alto = accende il LED

digitalWrite(11, ALTO); // Imposta il pin 11 su livello alto = accende il LED
digitalWrite(12, ALTO); // Imposta il pin 12 su livello alto = accende il LED
digitalWrite(13, ALTO); // Imposta il pin 13 a livello alto = accende il LED
ritardo(500); // Pausa di 500ms
digitalWrite(10, BASSO); // Imposta il pin 10 a livello basso = spegne il LED
digitalWrite(11, BASSO); // Metti la broche 11 a livello basso = spegni il LED
digitalWrite(12, BASSO); // Imposta il pin 12 a livello basso = spegne il LED
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED
ritardo(500); // Metti in pausa 500ms

} // fine della funzione loop()

37
Arduino a scuola

Codice 3: realizzare un chenillard a 4 LED.

L'obiettivo è accendere un LED dopo l'altro, secondo la tabella seguente:

Sequenza LED 1 LED 2 LED 3 LED 4

1 x
2 x
3 x
4 x

/*
Codice 3 - [Link], destinato ad Arduino
Obiettivo: fare un chenillard a 4 LED montati sui pin da 10 a 13
*/

void setup() // inizio della funzione setup()

{
pinMode(10, OUTPUT); // Inizializza il pin 10 come uscita
pinMode(11, USCITA); // Inizializza il pin 11 come uscita
pinMode(12, OUTPUT); // Inizializza il pin 12 come uscita
pinMode(13, OUTPUT); // Inizializza il pin 13 come uscita

[Link](9600); // Apre la porta seriale a 9600 baud

} // fine della funzione setup()

void loop() // inizio della funzione loop()

{
digitalWrite(10, HIGH); // Imposta il pin 10 a livello alto = accende il LED
digitalWrite(11, BASSO); // Imposta il pin 11 a livello basso = spegne il LED
digitalWrite(12, BASSO); // Metti il pin 12 su livello basso = spegni il LED
digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED

ritardo(100); // Pausa di 100ms

digitalWrite(10, LOW); // Imposta il pin 10 a livello basso = spegne il LED

digitalWrite(11, ALTO); // Met la broche 11 au niveau haut = allume la LED

delay(100); // Pausa di 100ms

digitalWrite(11, LOW); // Imposta il pin 11 a livello basso = spegne il LED

digitalWrite(12, ALTO); // Metti la broche 12 al livello alto = accendi il LED

delay(100); // Pausa di 100ms

digitalWrite(12, BASSO); // Imposta il pin 12 a livello basso = spegne il LED

digitalWrite(13, ALTO); // Metti il pin 13 a livello alto = accende il LED

delay(100); // Pausa di 100ms

digitalWrite(13, BASSO); // Imposta il pin 13 a livello basso = spegne il LED

digitalWrite(12, ALTO); // Metti la broche 12 al livello alto = accendi il LED

delay(100); // Pausa di 100ms

digitalWrite(12, BASSO); // Imposta il pin 12 su livello basso = spegne il LED

digitalWrite(11, ALTO); // Imposta il pin 11 a livello alto = accende il LED

ritardo(100); // Pausa di 100ms

} // fine della funzione loop

38
Arduino a scuola

Progetto 4: introduzione alle variabili

Una variabile, che cos'è?
Immaginiamo un numero di cui dobbiamo ricordarci. Questo numero è memorizzato in uno spazio di archiviazione
della memoria volatile (RAM) del microcontrollore. Ogni spazio di archiviazione è identificato in modo univoco.

Il numero memorizzato ha la particolarità di cambiare valore. Infatti, la variabile non è che un contenitore. Sua
Il contenuto potrà quindi essere modificato. E questo contenitore verrà memorizzato in una posizione della memoria. Se noi
materializza questa spiegazione con uno schema, questo darebbe:

nombre➞variable➞mémoire

il simbolo "➞" significa: "è contenuto in..."

Immaginiamo di immagazzinare il numero in un contenitore (la variabile). Ogni contenitore è a sua volta depositato
in uno spazio ben preciso, per poterlo ritrovare. Ogni contenitore (variabile) è anche identificato da un nome
unico.

Il nome di una variabile

Il nome della variabile accetta solo l'alfabeto alfanumerico ([a-z], [A-Z], [0-9]) e _ (underscore). È unico;
Quindi non possono esserci due variabili con lo stesso nome.

Definire una variabile

Immaginiamo di voler memorizzare il numero 4 in una variabile. Entrerebbe in una piccola scatola. Ma noi
potrebbe essere conservato in un grande contenitore. Sì... ma no! Un microcontrollore non è un computer
Processore multicore da 3GHz, 8GB di RAM! Qui si tratta di un sistema che funziona con una CPU a 16MHz (cioè 0,016
GHz) e 2 Ko di SRAM per la memoria volatile. Ci sono quindi almeno due motivi per scegliere le sue variabili di
maniera giudiziosa

1. La RAM non è espandibile, quando non c'è più, non c'è più! In un certo volume, si possono memorizzare
Molto più piccoli cartoni che grandi container. Bisogna quindi ottimizzare lo spazio.
39
Arduino a scuola

2. Il processore è di tipo 8 bit (su un Arduino UNO), quindi è ottimizzato per effettuare elaborazioni su
Delle variabili di dimensione 8 bit, un trattamento su una variabile di 32 bit richiederà quindi (molto) più tempo.
Se le variabili della dimensione di un container sono su 32 bit, tanto vale prendere una scatola che occupa solo 8 bit.
quando la variabile ci sta dentro!

Tipo di Tipo di numero Valori massimi del numero memorizzato Numero su X bit Numero di byte
variabile immagazzinato

intero intero -32'768 a +32'767 16 bit 2 ottetti

lungo intero -[Link] a +[Link] 32 bit 4 ottetti

carattere intero -128 a +127 8 bit 1 ottetto

float decimale -3.4 x 1038à +3,4 x 1038 32 bits 4 ottetti

doppio decimale -3,4 x 1038à +3,4 x 1038 32 bit 4 ottetti

Prendiamo ora una variabile che chiameremo «x». Ad esempio, se la nostra variabile "x" non prende
per valori decimali, useremo i tipi int, long o char. Se ora la variabile "x" non supera
non il valore 64 o 87, quindi utilizzeremo il tipochar.

char x = 0;

Se invece x = 260, allora utilizzeremo il tipo superiore (che accetta una quantità maggiore di numeri)
a char, in altre parole intoulong.

int x = 0;

Si à présent notre variable "x" ne prend jamais une valeur négative (-20, -78, ...), alors on utilisera un type
non firmato. Vale a dire, nel nostro caso, unchar il cui valore non è più da -128 a +127, ma da 0 a 255.

Di seguito è riportata la tabella dei tipi non firmati, riconosciamo questi tipi dalla parola unsigned (dall'inglese: non firmato) che
le precede:

Tipo di variabile Tipo di numero Valori massimi del numero memorizzato Numero su X bit Numero di byte
immagazzinato

char non firmato intero non negativo 0 a 255 8 bit 1 ottetto

float non firmato intero non negativo 0 a 65.535 16 bits 2 ottetti

doppio non firmato intero non negativo 0 a 4'294'967'295 32 bit 4 ottetti

40
Arduino a scuola

Definire i pin del microcontrollore

Fino ad ora, abbiamo identificato i pin del microcontrollore utilizzando i loro numeri, come
nell'esempio seguente: pinMode(13, OUTPUT);. Questo non causa problemi quando si hanno uno o due
LED connesse. Ma non appena abbiamo dei montaggi più complicati, diventa difficile sapere chi fa
Cosa. È quindi possibile rinominare ogni pin del microcontrollore.

Per prima cosa, definiamo il pin utilizzato del microcontrollore come variabile.

const int led1 = 13;

Il termine const significa che si definisce la variabile come costante. Di conseguenza, si cambia la natura
dalla variabile che diventa allora costante.
Il termine corrisponde a un tipo di variabile. In una variabile di questo tipo, è possibile memorizzare un numero che va
da -2147483648 a +2147483647, il che sarà sufficiente! Quindi, il pin 13 si chiamerà led1.

Siamo quindi di fronte a una variabile, chiamata led1, che è in realtà una costante, che può assumere
un valore compreso tra -2147483648 e +2147483647. Nel nostro caso, questa costante è assegnata al numero
13.
Concretamente, cosa significa questo? Osserviamo la differenza tra i due codici.

Spilla non definita Spilla definita

void setup() { const int led1 = 13;
pinMode(13, OUTPUT); //La broche 13 diventa led1
// Inizializza il pin 13 come uscita
[Link](9600); void setup() {
} pinMode(led1, OUTPUT);
// Inizializza led1 come pin di uscita
void loop() { [Link](9600);
digitalWrite(13, ALTO); }
ritardo(500);
digitalWrite(13, BASSO); void loop() {
ritarda(500); digitalWrite(led1, ALTO);
} ritardo(500);
digitalWrite(led1, LOW);
ritardo(500);
}

Si può pensare che definire le pin allunghi il codice. Ma quando avremo molte pin
in base a ciò, ci permetterà di identificarli più facilmente. Quindi, se abbiamo più LED, noi
Possiamo chiamarli Led1, Led2, Led3,... e se utilizziamo LED di vari colori, potremo
le chiamerò rosso, verde, blu,...
Infine (e soprattutto!), se vogliamo cambiare la piastra utilizzata, basta correggere la variabile all'inizio, senza dover
correggi tutto il codice.
Come per le variabili, possiamo dare qualsiasi nome ai pin.

41
Arduino a scuola

Progetto 5: I semafori
Per mettere in pratica l'uso delle variabili, ecco un piccolo esercizio. Possiamo basarci sul codice 3 per
iniziare.

L'obiettivo di questo esercizio è creare due semafori e farli funzionare in modo sincronizzato.

Ecco le fasi di due semafori che devi ricreare:

Fuoco 1
phases 1 2 3 4

Feu 2
6 sec 2 sec 6 sec 2 sec

Per aiutarsi, il video di presentazione è disponibile qui: [Link]

Circuito 4

42
Arduino a scuola

UNO R3
U1
ARDUINOR3
ARDUINO

R1 R2 R3 R4 R5 R6
220 220 220 220 220 220

D1 D2 D3 D4 D5 D6
R1 J1 V1 R2 J2 V2

Elenco dei componenti

2 LED rossi
2 LED gialli o arancioni
2 LED verdi
6 résistances de 220 à 470Ω

Afin de faciliter l'identification de chaque LED, nous allons renommer les broches comme suit:

Fuoco 1:

LED rossa collegata al pin 4 e rinominata R1

LED gialla collegata al pin 5 e rinominata J1
LED verde collegata al pin 6 e rinominata V1

Feu 2:

LED rossa collegata al pin 8 e rinominata R2

LED gialla collegata al pin 9 e rinominata J2
LED verde connessa al pin 10 e rinominata V2

Infine, utilizzeremo due variabili timer1 e timer2 per definire i tempi di accensione. Prima di guardare
il codice alla pagina successiva, prova a fare l'esercizio da solo.

Codice 4: il semaforo
/*
Code 4 - [Link], destiné à l'Arduino

43
Arduino a scuola

Obiettivo: gestire i semafori

*/

// Si definiscono le variabili per ogni pin

//FEU 1
const int R1 = 4; La broche 4 diventa il fuoco rosso 1
const int J1 = 5; La broche 3 diventa il fuoco giallo 1
const int V1 = 6; La broche 2 diventa il segnale verde 1
//FEU2
const int R2 = 8; La broche 8 diventa il semaforo rosso 2
const int J2 = 9; La broche 9 diventa il fuoco giallo 2
const int V2 = 10; La broche 10 diventa il semaforo verde 2
//TEMPI
int timer1 = 2000; Il tempo è fissato a 2 secondi
int timer2 = 6000; Il tempo è fissato a 6 secondi

void setup() {

//Inizializziamo le uscite
pinMode(R1, OUTPUT);
pinMode(J1, OUTPUT);
pinMode(V1, OUTPUT);

pinMode(R2, USCITA);
pinMode(J2, OUTPUT);
pinMode(V2, OUTPUT);
}

void loop() {

//Fase 1: R1 e V2 sono accesi, R2, J1 e J2 sono spenti

digitalWrite(R2, BASSO); //R2 spento
digitalWrite(J1, BASSO); //J1 spento
digitalWrite(J2, BASSO); //J2 spento
digitalWrite(R1, ALTO); //R1 acceso
digitalWrite(V2, ALTO); //V2 acceso
ritardo(timer2); //durata: 6'000 millisecondi, ovvero 6 secondi

//Fase 2: R1, J1, J2 accesi e V2 spento

digitalWrite(V2, BASSO); //V2 spento
digitalWrite(J1, ALTO); //J1 allumé
digitalWrite(J2, ALTO); //J2 acceso
ritarda(timer1); //durata: 2'000 millisecondi, ovvero 2 secondi

//Fase 3: R1, J1, J2 spenti e V1 e R2 accesi

digitalWrite(R1, BASSO); //R1 éteint
digitalWrite(J1, LOW); //J1 spento
digitalWrite(J2, BASSO); //J2 spento
digitalWrite(V1, HIGH); //V1 allumé
digitalWrite(R2, ALTO); //R2 acceso
ritardo(timer2);

//Fase 4: V1 spento e J1, J2 e R2 accesi

digitalWrite(V1, BASSO); //V1 spento
digitalWrite(J1, ALTO); //J1 acceso
digitalWrite(J2, ALTO); //J2 acceso
digitalWrite(R2, ALTO); //R2 acceso
ritardo(timer1);
}

44
Arduino a scuola

Varianti

Variante 1

C'è spesso un ritardo tra il passaggio di un semaforo rosso e il passaggio al verde dell'altro semaforo. È in
particolare il caso per i cantieri. Ciò consente alle auto ancora impegnate nella zona di cantiere
di lasciarla, prima di dare spazio alle auto in arrivo.

Descrivere le fasi dei fuochi e programmarli tenendo conto del ritardo.

Variante 2
Integrare un terzo semaforo, che passa dal rosso al verde in alternanza con gli altri due semafori.

Realizzare lo schema elettronico e programmare i semafori.

Variante 3

Realizzare i semafori per un incrocio:

45
Arduino a scuola

Progetto 6: L'incremento
È possibile applicare ai valori delle variabili diverse operazioni matematiche. Iniziamo tutto
di seguito un piccolo esempio: l’incremento. Si tratta semplicemente di sommare 1 alla variabile. Ogni volta
che ripetiamo il codice, prendiamo il valore della variabile e aggiungiamo 1.

Questo avviene grazie a questo codice (variando una variabile a scelta): var++;

var++; torna a scrivere: "var = var + 1;".

Il circuito sarà dei più classici: riprenderemo il nostro chenillard.

Circuito 5

U1
ARDUINO

D1
R1 LED
AREF 220
GND
D13
D12 D2
D11 R2 LED
RESET D10 220
3V D9
5V D8
GND2 D3
GND1 D7 R3 LED
VIN D6 220
D5
A0 D4
A1 D3 D4
A2 D2 R4 LED
A3 D1 220
A4 D0
A5

Elenco dei componenti:

4 LED rossi
4 resistenze da 220 a 470Ω

46
Arduino a scuola

Codice 5: far lampeggiare 10 volte il LED 13

/*
Code 5 - [Link], destiné à l'Arduino
Obiettivo: far lampeggiare 10 volte il LED montato sulla porta 13
*/

//***** INTESTAZIONE DICHIARATIVA *****

// Dichiariamo le variabili, le costanti...

byte contatore; //Si definisce la variabile "compteur"

const int led1= 13; Rinominiamo il pin 10 in "led1"

//***** FUNZIONE SETUP = Codice di inizializzazione *****

// La funzione setup() viene eseguita prima e solo una volta, all'avvio del programma

void setup()

{
pinMode(led1, OUTPUT); // Inizializza il pin 13 come uscita

[Link](9600); // Apre la porta seriale a 9600 baud

Esegui il programma tra le parentesi graffe partendo da zero e incrementando ogni volta.
//valore di +1: 0+1/2+1/3+1... fino a quando la variabile “contatore“ non è uguale a 9 (più //
// piccolo che 10).

per(compteur=0 ; compteur<10 ; compteur++)

{ // inizio del programma eseguito 10 volte

digitalWrite(led1, HIGH); // accende il LED
ritardo(500); // attendi 500ms
digitalWrite(led1, LOW); // spegne il LED
ritarda(500); // attendi 500 ms
}
} // fine del programma eseguito 10 volte

vuoto ciclo() {
} // video, programma auto già eseguito in setup

Analisi del codice9

Torniamo al nostro codice e analizziamolo.

La ligne byte compteur; permette di creare una variabile chiamata compteur. Byte indica il tipo della variabile,
cioè il tipo di dati che potremo memorizzare in questa variabile. Come abbiamo già visto, il
Il tipo byte permette di memorizzare valori compresi tra 0 e 255.

La riga const int led1 = 13; permette di creare una costante (una variabile) chiamata led1 nella quale si
memorizza il valore 13.

La riga for(compteur=0 ; compteur<10 ; compteur++) serve a far variare la variabile compteur da 0 a 9 (in
l'aumenta ogni volta di 1: è ciò che fa l'istruzione contatore++

Guardiamo questa linea da un po' più vicino:

per(compteur=0 ; compteur<10 ; compteur++)

9[Link]

47
Arduino a scuola

La dichiarazione forestalmente usata per ripetere un blocco di istruzioni circondato da parentesi. Si

Lo uso spesso con un contatore incrementale, che consente di terminare un ciclo dopo un certo numero
a volte.

La suite, a sapere contatore=0; contatore<10; contatore++ deve essere compresa come segue: «il valore della
la variabile computazionale è compresa tra 0 e 9 (<10 significa "minore di 10") e aggiunge uno al valore di
contatore(c’è il contatore++).

In conclusione, questa riga significa:

«All'inizio, la variabile contatore è uguale a zero. Eseguiremo il codice in loop. Ogni volta,
si aggiunge +1 alla tua variabile contatore, finché non si arriva a 9. A quel punto, ci fermiamo.

Il codice che viene eseguito ogni volta è quello compreso fino a parentesi graffa } . Nel nostro caso, è e
codice seguente che viene eseguito 10 volte:

digitalWrite(Led1, ALTO);
ritarda(500);
digitalWrite(Led1, BASSO);
ritarda(500);

Ecco le parti di una dichiarazione:

Dichiarazione della variabile

(opzionale)

Inizializzazione Test della condizione Incremento/decremento

per(intcompteur=0;compteur<10;compteur++)
L'inizializzazione viene eseguita per prima e una sola volta. Ad ogni passaggio del ciclo, la condizione è
testata. Se è "vera", il contenuto del ciclo forestale verrà eseguito (ad esempio far lampeggiare un LED), e
l'incremento della variabile è eseguito. Poi, la condizione viene testata di nuovo. Non appena il risultato del test di
la condizione è "falsa", il ciclo si ferma

Codice 6: Realizzare un chenillard sui pin 10 a 13 con unfor

Possiamo senza problemi utilizzare un'incrementazione e un for per realizzare il pinMode delle Leds che si
seguente, ad esempio per realizzare un chenillarde:

/*
Codice 6 - [Link], destinato all'Arduino
Obiettivo: fare un chenillard a 4 LED montati sui porti 10 a 13
*/

//***** INTESTAZIONE DICHIARATIVA *****

// Definizione della variabile "tempo"

int timer = 100; // Durata, in millisecondi

//***** FUNZIONE SETUP = Codice di inizializzazione *****

void setup() {

48
Arduino a scuola

// Dichiarazione dei pin da 10 a 13 utilizzando un for e un incremento.

per (int thisPin = 10; thisPin < 14; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}

vuoto ciclo() {
// ciclo da pin 10 a pin 13:

per (int questoPin = 10; questoPin < 14; questoPin++) { //Incremento che fa passare la variabile
questo Pin da 10 a 13
digitalWrite(thisPin, HIGH); Accendere il LED
ritarda(timer); //Durée
digitalWrite(thisPin, LOW); Spegnere il LED
}

// ciclo da pin 13 a pin 10:

per (int thisPin = 13; thisPin >= 10; thisPin--) { //Decremento che fa passare la variabile
thisPin de 13 à 10
digitalWrite(thisPin, HIGH); Accendere il LED
ritardo(timer); Durata
digitalWrite(thisPin, LOW); //Spegnere il LED;
}
}

Analyse du code

Guardiamo ora un po' questo codice, in particolare:

per (int thisPin = 10; thisPin < 14; thisPin++) {
pinMode(thisPin, OUTPUT);
}

La sua prima particolarità è il modo di definire i pin. Invece di accumulare il pinMode (xxx,
OUTPUT);, si crea una variabile di tipo int che chiamiamo thisPin10e quindi il valore iniziale è di 10. Unfor
con un incremento (++) consente di incrementare il valore della variabile da 10 a 14. Basta quindi
sostituire nel pinModele numero della prossima con la variabile thisPin. Così, i pin 10, 11, 12, 13 e
14 sono definite in output. Naturalmente, ciò funziona solo se i pin utilizzati si susseguono (per
esempio: 10, 11, 12, 13. Non funzionerà per i pin 3, 5, 7, 8, 10).

Passiamo ora alla seconda parte:

per (int questoPin = 10; questoPin < 14; questoPin++) {

digitalWrite(thisPin, HIGH);
ritardo(timer);
digitalWrite(thisPin, LOW);
}

Come per la definizione dei pin in OUTPUT, si usa la funzione for per incrementare la variabile
accende le LED collegate ai pin 10 a 13 una dopo l'altra.

Infine, nella terza parte del codice, accenderemo i LED dal pin 13 al pin 10 con una
fonctionforet una decremento. Per fare ciò, si sostituisce il++con un--.

per (int thisPin = 13; thisPin >= 10; thisPin--) {

digitalWrite(thisPin, ALTO);
ritarda(timer);
digitalWrite(thisPin, LOW);

10Ma avremmo potuto chiamarla anche piccola_fiore...

49
Arduino a scuola

Progetto 7: PWM, variazione graduale di un LED

Il modo più semplice per variare la luminosità di un LED è variare la corrente che lo attraversa.
Ma quando è collegata al pin di un Arduino, non è possibile: i pin da 1 a 13 sono in
effetti numerici. Cioè hanno solo due stati: 0 o 1; acceso o spento. Quindi per far variare la
luminosità di un LED, useremo una funzione chiamata PWM: Modulazione della larghezza dell'impulso, ossia modulazione di
larghezza degli impulsi. Si tratta di far variare i periodi alti (acceso) e bassi (spento) dei pin a
grande frequenza. Così, durante un ciclo del 25% in posizione alta e del 75% in posizione bassa, il LED sarà meno
brillante che per un ciclo al 50%/50%.

In altre parole, significa che faremo lampeggiare molto velocemente i LED; così velocemente che l'occhio non percepirà.
quella luce continua. Ma più aumenterà la durata dei periodi in cui il LED è spento, meno ci sarà
di luce emessa; e quindi meno la LED sembrerà brillante.

Le pin capaci di supportare il PWM sono identificate da un "~". Si tratta dei pin 3, 5, 6, 9, 10, 11.

Per distinzione, invece di utilizzare l'instructionDigitalWrite, per utilizzare il PWM, si utilizza AnalogWrite.

Il valore del PWM si estende su 256 livelli, da 0 (=0%) a 255 (=100%). Si può così definire il valore PWM
desiderata con la seguente formula:

#/0)12 !34 =56789:;<=> : ?67@=A<é∙ 255 #/0)12 )-% = H=I:78 5JK∙ 100
CDD LMM

50
Arduino a scuola

Codice 7: far variare la luminosità di un LED modificando il valore PWM

/*
Codice 7 - [Link], destinato all'Arduino
Obiettivo: variare la luminosità di un LED sul pin 10 modificando il valore PWM
*/

//***** INTESTAZIONE DICHIARATIVA *****

int ledPin = 10; //Rinominiamo il pin 10 in "ledPin"

int timer = 100; //Si definisce una durata di 0,1 secondi per la variabile timer

//***** CONFIGURAZIONE *****

vuota setup() {

pinMode(ledPin, OUTPUT);

//***** CICLO *****

vuoto ciclo() {

// LED al 0%.
analogWrite(ledPin, 0);
ritardo(timer);

// LED à 19.6%.
analogWrite(ledPin, 50);
delay(timer);

// LED al 39,2%.
analogWrite(ledPin, 100);
ritarda(timer);

// LED al 58.8%.
analogWrite(ledPin, 150);
ritarda(timer);

// LED al 78.4%.
analogWrite(ledPin, 200);
ritardo(timer);

// LED al 100%.
analogWrite(ledPin, 255);
ritarda(timer);
}

Analisi del codice

Nessuna sorpresa per questo codice, se non per l'uso di analogWrite al posto di digitalWrite. La luminosità
la LED progresse per scaglioni di 50. Se si vuole livellare la progressione della luminosità, è necessario aumentare il
numero di livelli, il che appesantirà notevolmente il codice. È per questo motivo che è preferibile
di utilizzare una funzione for, come vedremo nel codice seguente.

Codice 8: far variare delicatamente la luminosità di un LED

/*
Codice 8 - [Link], destinato all'Arduino
Obiettivo: variare la luminosità di un LED sul pin 10
Adattato da David A. Mellis e Tom Igoe
*/

51
Arduino a scuola

//***** INTESTAZIONE DICHIARATIVA *****

int ledPin = 10; //On renomme la broche 10 en "ledPin"

//***** CONFIGURAZIONE *****

void setup() {

//***** CICLO *****

void loop() {

// Variazione dal minimo al massimo per aggiunta di 5 fino a 256

per (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5)

{
Definizione del valore di luminosità (da 0 a 255)
analogWrite(ledPin, fadeValue);

// Attesa di 30 millisecondi tra ogni livello per vedere l'effetto.

ritarda(30);
}

Variante dal massimo al minimo sottraendo 5 da 256

per (int fadeValue = 255; fadeValue >= 0; fadeValue -= 5)

{
// Definizione del valore di luminosità (da 0 a 255)
analogWrite(ledPin, fadeValue);

// Attesa di 30 millisecondi tra ogni gradino per vedere l'effetto.

ritarda(30);
}

Analisi del codice

La funzione for, cominciamo a conoscerla bene. Altrimenti, ecco un piccolo promemoria:

Dichiarazione della variabile
(opzionale)

Inizializzazione Test della condizione Incremento/decremento

per(int compteur=0; compteur<10; compteur++)

Nel nostro codice, iniziamo con un for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5).

Si crea quindi una variabile fadeValue di tipo int, che memorizza il numero 0. Il test della condizione più piccolo o
uguale a 255(fadeValue <= 255) consente un'uscita dalla funzione non appena raggiungiamo il numero 256. Infine; e questo è
La novità è che non facciamo un'incremento (++), ma sommiamo 5 a fadeValue con la formula +=5.

Il comando analogWrite(ledPin, fadeValue); consente quindi di inviare il valore di fadeValue al LED ledPin.
CommefadeValue aumenta ogni volta di +5, la luminosità del LED aumenta poco a poco. Infine, il
delay consente di configurare la velocità di aumento della luminosità. Ogni livello di 5 richiede 30
millisecondes. Il faut 51 paliers de 5 pour passer de 0 à 255. Ainsi, il faudra 51∙ 30= 1530millisecondi per
passare dal LED spento al LED alla sua massima luminosità, ovvero circa un secondo e mezzo.

Ensuite, une fois la LED à sa luminosité maximum, il s'agit de baisser sa luminosité jusqu'à l'éteindre, grace
au code for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5). Le+=5 è sostituito da un-=5, affinché
sottrarre 5 alla variabile fadeValue ogni volta.

52
Arduino à l'école

Codice 9: alternativa per variare la luminosità di un LED

Con il codice 8, abbiamo variato la luminosità di un LED da 0 a 255 a passi di 5. Possiamo altrettanto
ben usare un incremento++ per arrivare allo stesso risultato. Ecco cosa produce:

/*
Codice 9 - [Link], destinato ad Arduino
Obiettivo: variare la luminosità di un LED sul pin 10
*/

//***** INTESTAZIONE DICHIARATIVA *****

int ledPin = 10; //Rinominiamo il pin 10 in "ledPin"

//***** INSTALLAZIONE *****

void setup()
{
}

//***** CICLO *****

vuoto ciclo()
{

// Variazione dal minimo al massimo per incremento

per (int fadeValue =0; fadeValue <= 255; fadeValue ++) {

analogWrite(ledPin, fadeValue);
ritarda(10);
}

Variazione dal massimo al minimo per decremento

per (int fadeValue = 255; fadeValue >= 0; fadeValue--) {

analogWrite(ledPin, fadeValue);
ritarda(10);
}
}

53
Arduino a scuola

Progetto 8: gli input numerici

Fino ad ora, abbiamo trattato delle uscite, cioè un segnale usciva dal microcontrollore sotto la
forme di un corrente elettrica (ALTA) o della sua assenza (BASSA) grazie al comando DigitalWrite. Si ha
utilizzato finora questo segnale (una corrente elettrica) per accendere LED.
Allo stesso modo, è possibile inviare un segnale al microcontrollore, da un sensore ad esempio. Questo segnale
è una corrente elettrica che entra nel pin. A seconda del segnale ricevuto, il microcontrollore effettuerà una
compito previsto (accendere la luce quando un sensore di movimento rileva una presenza, per esempio). Per
cela, nous utiliserons les commandesDigitalReadetAnalogRead.

Proteggere l'Arduino
Fino ad ora, ci siamo sempre accontentati di far circolare corrente dal microcontrollore a
la massa.
Invece di utilizzare i pin del microcontrollore solo come uscita (OUTPUT), utilizzeremo anche
utilizzarli sotto forma di input; vale a dire che invece di essere collegato a terra, il pin lo sarà.
au +5V. Tutto andrà bene, se a livello di programma, il pin è configurato come input. Ma se essa
doveva essere configurato in output per errore, è quasi certo che il microcontrollore finirà immediatamente
nel paradiso dei chip elettronici bruciati.

Così, per evitare di condannare il nostro microcontrollore alla sedia elettrica, dovremo proteggerlo.
Questo può essere fatto collegando una resistenza di 100 sulla pin del microcontrollore utilizzato come input.
a 200Ω.
R1
100
D4

ATTENZIONE!

Quando colleghi l'Arduino al computer, l'ultimo programma ricevuto viene eseguito. Prima di cominciare
un nuovo montaggio, è più che consigliato inviare un programma di inizializzazione, simile a questo:

void setup() {
}

vuota ciclo() {
}

Ora che questo punto è risolto, vediamo come utilizzare il pulsante con il microcontrollore.

Resistenza Pull-Down / Pull-Up

Circuit con una resistenza pull-down

Osserviamo questo schema:

Quando si preme il pulsante, si invia una corrente

elettrico sul pin 4, che sarà interpretato come un1.
Quando si rilascia il pulsante, non arriva più corrente su
la broche 4, che sarà interpretata come un0. Abbiamo quindi un
signal binaire: allumé/éteint (on/off).

54
Arduino a scuola

Questo montaggio contiene una resistenza di 10 kΩ (ossia 10'000Ω), chiamata pull-down (letteralmente tirare-giù)
bas). Questa resistenza permette di tirare il potenziale verso il basso (pull-down). In francese, si chiama anche questo
un richiamo almeno.

In effetti, a differenza del caso teorico, chiudere o aprire un circuito (tramite un interruttore o un pulsante)
non genera necessariamente un segnale chiaro:

Il circuito non connesso alla sorgente può agire come un'antenna in un ambiente inquinato da onde.
elettromagnetici (vicini a un telefono cellulare, ad esempio). Questo genererà nel circuito un
corrente che può essere interpretata come un segnale. Si chiama questo fenomeno induzione. È così, per
ad esempio, che alcuni smartphone possono essere ricaricati senza fili.
•Dal punto di vista meccanico, quando si preme un pulsante, il contatto non è mai istantaneo
è perfetto. Ci sono rimbalzi. Lo stesso vale quando viene rilasciato. Questi fenomeni sono parassiti
qui possono indurre in errore l'Arduino.

Il scopo di una resistenza di pull-down è quindi quello di eliminare le correnti vagabonde e di fornire un
segnale chiaro.
Se si preme il pulsante, una corrente elettrica chiara viene quindi applicata all'ingresso. La corrente prenderà il
il percorso più semplice, sia attraverso la resistenza di 220Ω e finisce per arrivare su D4, che è connesso a terra. Se si
rilascia il pulsante, la resistenza pull-down riporta l'ingresso a terra. Poiché D4 è anche collegato allo stesso
terra, c'è quindi una differenza di potenziale (una tensione) di 0 Volt, e quindi nessun segnale indesiderato all'ingresso
di D4.

Circuit con una resistenza pull-up

Osserviamo ora questo schema a destra:

Se lo confrontiamo con lo schema di un circuito con una resistenza pull-

giù, si osserva un'inversione tra la terra e il +5V.

In effetti, quando il circuito è aperto, una tensione di +5V è

applied to the input of pin 4.
Quando si preme il pulsante, la corrente elettrica va
passare per il cammino che offre meno resistenza, cioè
direttamente tramite la massa (Gnd), senza passare dall'ingresso della
spilla 4.
Il funzionamento è quindi invertito rispetto alla resistenza
a discesa.

Resistenza pull-down o pull-up?

A nostro livello, l'unica cosa che cambierà tra una resistenza pull-down e una resistenza pull-up è la
lettura dell'informazione:

Con una resistenza pull-down, di default, l'ingresso sul pin è uguale a 0.

Con una resistenza pull-up, per impostazione predefinita, l'ingresso sul pin è uguale a 1.

Nel codicese (digitalRead(bouton) == 1), sarà rispettivamente il valore d'ingresso quando il

circuito è chiuso (pull-down) o aperto (pull-up).

55
Arduino a scuola

Circuito 6: montaggio con resistenza pull-down (richiamo almeno)

Ecco il circuito da realizzare:

Circuito 6

U1
ARDUINOR3

SW1
A5SCL
D0 A4SDA
D1 A3
R2 R3 D2 A2
10k 220 D3 A1
D4 A0
D5
D6 VIN
D7 GND1
GND2
D8 5V
D9 3V
D1 R1 D10 RESET
LED 220 D11 IOREF
D12 RISERVATO
D13
GND
AREF
SDA
SCL

Liste des composants:

1 LED rosso 1 resistenza da 1k a 10kΩ

2 resistenze da 220 a 470Ω 1 pulsante

56
Arduino a scuola

Quando si preme il pulsante, il LED deve accendersi. E naturalmente, quando si rilascia il pulsante
premere, il LED si spegne. Questa azione non è meccanica, ma logica. Non è la chiusura di un circuito
elettrico che accende il LED, ma l'informazione trasmessa all'Arduino, tramite un INPUT che gli ordina
d'allumer la LED.

Osserviamo ora il codice:

Code 10: allumer une LED en fonction de l'état du bouton poussoir

/*
Codice 10 - [Link], destinato all'Arduino
Accensione LED in base allo stato del pulsante
*/

// Dichiariamo le variabili

const int bottone = 4; // la broche 4 diventa pulsante

const int led = 12; // la broche 12 diventa led

void setup()

{
pinMode(bouton, INPUT); // Inizializza il pin 4 come ingresso
pinMode(led, OUTPUT); // Inizializza il pin 12 come uscita
[Link](9600); // Apre la porta seriale a 9600 baud
}

void loop()

// Pulsante premuto...

se (digitalRead(bouton) == 1 ) //testa se il pulsante ha un valore di 1

//...accendiamo il LED
{
digitalWrite(led, ALTO); accendi il LED
}

// Altrimenti...

altro
//verifica se il pulsante ha un valore di 0
//...si spegne il LED
{
digitalWrite(led, BASSO); // spegne il LED
}
}

57
Arduino a scuola

Analizziamo il codice:

Utilizziamo una nuova istruzione: se ... altrimenti (se ... sinon). Quindi è una condizione.

Ecco cosa accadrà:

Se il pulsante è premuto (digitalRead(bouton) == 1), accendere il LED (digitalWrite(led, HIGH)), altrimenti

(else) spegnere il LED (digitalWrite(led, LOW)).

L'istruzione verifica se due espressioni sono uguali. Se lo sono, allora il risultato sarà vero (true), altrimenti
il risultato sarà falso.

Così:

const int bouton = 4; // la broche 4 diventa pulsante

const int led = 12; // la broche 12 diventa led

Si rinominano i pin 4 e 12 rispettivamente button e led. Questo faciliterà la lettura del codice.

void setup() {
// Inizializza il pin 4 come ingresso
pinMode(bouton, INPUT);

// Inizializza il pin 12 come uscita

pinMode(led, USCITA);

// Apre la porta seriale a 9600 baud

[Link](9600);
}

Ecco, ora il nostro microcontrollore sa che c'è qualcosa di connesso al suo pin 4 e che è
configurata in ingresso (INPUT). Allo stesso modo, il pin 12 è configurato in uscita (OUTPUT).
Ora che il pulsante è impostato, cercheremo di capire qual è il suo stato (premuto o rilasciato).
Se il microcontrollore rileva una corrente elettrica al suo pin 4, allora memorizzerà un valore di 1.
In caso contrario (differenza di potenziale di 0V), memorizzerà un valore di 0.

Per leggere lo stato del pin 4, utilizzeremo l'espressione digitalRead. Quindi:

se (digitalRead(bouton) == 1 )
digitalWrite(led, ALTO); accendi il LED

deve essere compreso come:

se la spilla 4 ha un valore pari a 1

allora la broche 12 è in posizione alta = LED acceso

e le linee:
altrimenti {

digitalWrite(led, BASSO); // spegne il LED

devono essere intesi come:

sinon (cioè: il pin 4 ha un valore pari a 0)

la broche 12 è in posizione bassa = LED spento

Ecco un piccolo video che presenta l'attività: [Link]

58
Arduino a scuola

Codice 11: Un codice più elegante

Il codice precedente è semplice, ma manca un po' di finezza; un po' come un barbaro con un'ascia.
a due mani in una ricezione di Monsieur l'Ambasciatore. Ecco quindi un'altra soluzione, vestita in
smoking:

/*
Codice 11 - [Link], destinato all'Arduino
Accensione LED in base allo stato del pulsante
*/

const int bottone = 4; // la broche 4 diventa pulsante

const int led = 12; // la broche 12 diventa led
int etatbouton; // variabile qui registra lo stato del pulsante

void setup()
{
pinMode(bouton, INPUT); // Inizializza il pulsante come input
pinMode(led, OUTPUT); // Inizializza il led come uscita
etatbouton = LOW; // Inizializza lo stato del pulsante come rilasciato
[Link](9600); // Apre la porta seriale a 9600 baud
}

vuoto ciclo()
{
etatbouton = digitalRead(bouton); //On mémorise l’état du bouton

se(etatbouton == BASSO) //controlla se il pulsante ha un livello logico BASSO

{
digitalWrite(led,LOW); //il LED rimane spento
}

altro //testa se il pulsante ha un livello logico diverso da BASSO (quindi ALTO)

{
digitalWrite(led,HIGH); //il pulsante è premuto, il LED è acceso
}
}

Per cominciare, creeremo una variabile che sceglieremo di chiamare etatbouton. Essa servirà a
memorizzare lo stato del pulsante (logico, no?):

int etatbouton;

Si iscrive lo stato del pulsante nella variabile in questo modo, con la funzione digitalRead:

etatbouton = digitalRead(bouton);

Non ci resta che chiamare lo stato del pulsante, memorizzato nella variabile stato pulsante, e fargli passare un
piccolo test con if... else (se... altrimenti):

Se lo stato del pulsante è BASSO (cioè = 0), allora il LED è BASSO (spento). Altrimenti, il LED è
ALTO (in effetti, se lo stato del pulsante non è BASSO, può essere solo ALTO, ovvero acceso...)

E quindi questo dà:

if(etatbouton == LOW) //testa se il bottone ha un livello logico BASSO

{
digitalWrite(led,LOW); //il LED rimane spento
}
altrimenti //testa se il pulsante ha un livello logico diverso da BASSO (quindi ALTO)
{
digitalWrite(led,HIGH); //il pulsante è premuto, il LED è acceso
}
Ricordiamo che l'istruzione==verifica se due espressioni sono uguali.
59
Arduino a scuola

Piccoli esercizi: pulsante e LED lampeggiante

Immaginiamo ora il seguente scenario: con lo stesso circuito: quando premiamo il pulsante, la
Il LED inizia a lampeggiare.

Modifica il programma per ottenere questo risultato.

Scarica la risposta

[Link]

E ora, modifica il programma affinché, quando colleghiamo l'Arduino al computer, il LED

si accende e rimane accesa. D'altra parte, quando premiamo il pulsante, il LED lampeggia.

Scarica la risposta

[Link]

60
Arduino a scuola

Il bargraphe
Un bargraphe è un indicatore che mostra una quantità, proveniente da un'informazione qualsiasi (livello dell'acqua,
puissance sonore, etc.), sous une forme lumineuse. Le plus souvent, on utilise des LEDs alignées en guise
di visualizzazione.

L’objectif de cet exercice est de réaliser un bargraphe de 4 LEDs, avec deux boutons poussoirs. L’un d’eux
servirà a incrementare il valore sul bargraph (vale a dire aumentare il numero di LED accesi), mentre
l'altro servirà a decrementarlo.

Ecco il diagramma del circuito da montare:

Circuito 7

LED1 a LED4: a scelta

R5 e R6: resistenze di protezione LED1

R1
R7 e R8: resistenze pull-down 220

SW1 e SW2: pulsanti a pressione

LED2
R2
220
U1
ARDUINO
LED3
R3
220
AREF
GND
D13 LED4
D12
D11 R4
RESET D10 220
3V D9
5V D8
GND2
GND1 D7
VIN D6 R5 R7
D5 220 10k
A0 D4
A1 D3
A2 D2 R6 R8
A3 D1 220 10k
A4 D0
A5

SW1 SW2

61
Arduino a scuola

Elenco dei componenti

4 LED a scelta
6 resistori da 220Ω
2 resistenze da 1 a 10kΩ
2 pulsanti a pressione

Come si può osservare, le resistenze R7 e R8 sono montate in pull-down (richiamo almeno). Questo circuito
pourrait tout à fait être monté avec des résistances pull-up.

Normalmente, a questo punto, dovremmo essere in grado di eseguire il montaggio utilizzando lo schema elettrico!
In caso contrario, ecco il montaggio da realizzare:

Circuito 8

62
Arduino a scuola

Codice 12: il bargraphe

/*
Codice 12 - [Link], destinato all'Arduino
Il bargraphe
L'obiettivo è realizzare un grafico a barre, con 4 LED e due pulsanti: uno per
incrementare il numero di LED accesi, l'altro per decrementarlo.
*/

/*
Dichiarazione delle costanti per i nomi dei pin
*/

const int btn_minus = 3; //Pulsante 1 per decrementare il numero di LED accesi

const int btn_plus = 4; //Pulsante 2 per incrementare il numero di LED accesi
const int led_0 = 8; //Led 0
const int led_1 = 9; //Led 1
const int led_2 = 10; //Led 2
const int led_3 = 11; //Led 3

/*
Dichiarazione delle variabili utilizzate per il conteggio e il deconto
*/

int numero_led = 0; il numero che sarà incrementato e decrementato

int stato_bottone; //lettura dello stato dei pulsanti (solo uno alla volta, ma una
variable suffit; en effet, il n'est pas prévu d'appuyer sur les deux boutons simultanément)
int memoire_plus = BASSO; // stato rilassato predefinito per il pulsante 2
int memoire_minus = LOW; // stato rilasciato per impostazione predefinita per il pulsante 1

/*
Inizializzazione dei pin in ingresso/uscita: ingressi per i pulsanti, uscite per i LED
*/

void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
}

/*
E si parte con il programma!
*/

void loop()
{
//lettura dello stato del pulsante di incremento (si legge lo stato di btn_plus e si registra)
nella variabile stato_bottone)
etat_bouton = digitalRead(btn_plus);

Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se((etat_bouton != memoire_plus) && (etat_bouton == ALTO))
{
nombre_led++; //incrementiamo la variabile che indica quante LED devono accendersi
}

memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

//e ora lo stesso per il pulsante che decrementa

etat_bouton = digitalRead(btn_minus); //lecture de son état
63
Arduino a scuola

Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se((etat_bouton != memoire_minus) && (etat_bouton == ALTO))
{
nombre_led--; //decremente il valore di nombre_led
}
memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

//applichiamo dei limiti al numero per non superare 4 o 0 (dato che abbiamo 4 LED)
se(nombre_led > 4)
{
nombre_led = 4;
}
se(nombre_led < 0)
{
nombre_led = 0;
}

//Creiamo una funzione affiche() per la visualizzazione del risultato

//gli inviamo quindi come parametro il valore del numero di LED da illuminare

affiche(numero_led);
}

void affiche(int valore_ricevuto)

{
//spegniamo tutti i LED
digitalWrite(led_0, BASSO);
digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);

Poi le accendiamo una ad una

se(valeur_recue >= 1) se il valore ricevuto è maggiore o uguale a 1...

{
digitalWrite(led_0, ALTO); accendiamo il LED 0
}
se(valeur_recue >= 2) se il valore ricevuto è maggiore o uguale a 2...
{
digitalWrite(led_1, ALTO); accendiamo il LED 1 (sottinteso che il LED 0 è
allumata, poiché il valore è maggiore di 1)
}
se(valeur_recue >= 3) se il valore ricevuto è maggiore o uguale a 3...
{
digitalWrite(led_2, ALTO); accendiamo il LED 2
}
se(valeur_recue >= 4) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_3, ALTO); accendiamo il LED 3
}
}

Video

Video di presentazione del bargraphe: [Link] -1

64
Arduino a scuola

Analisi del codice:

Facendo riferimento allo schema di montaggio, dichiariamo le costanti per ogni pin: i pulsanti.
sono collegati ai pin 3 e 4, mentre le LED sono collegate ai pin 8 a 11.

/*
Dichiarazione delle costanti per i nomi dei pin
*/

const int btn_minus = 3; //Pulsante 1 per decrementare il numero di LED accesi

const int btn_plus = 4; //Pulsante 2 per incrementare il numero di LED accesi
const int led_0 = 8; //Led 0
const int led_1 = 9; //Led 1
const int led_2 = 10; //Led 2
const int led_3 = 11; //Led 3

Poi si creano le variabili necessarie e si inizializza il loro stato.

/*
Dichiarazione delle variabili utilizzate per il conteggio e il decounting
*/

int numero_led = 0; //il numero che sarà incrementato e decrementato

int etat_bouton; // lettura dello stato dei pulsanti (solo uno alla volta, ma una
la variabile è sufficiente; infatti, non è previsto premere i due pulsanti contemporaneamente)
int memoire_plus = BASSO; // stato rilassato per impostazione predefinita per il pulsante 2
int memoire_minus = LOW; // stato rilasciato per impostazione predefinita per il pulsante 1

Si inizializzano poi i pin, a seconda che si tratti di ingressi (i pulsanti) o uscite (le LED).

/*
Inizializzazione dei pin in ingresso/uscita: ingressi per i pulsanti, uscite per i LED
*/

void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
}

Andiamo per la parte del programma nel ciclo infinito.

Utilizza digitalRead per leggere lo stato del pulsante (btn_plus) e registrare questo stato nella variabile stato_bouton.

vuoto ciclo()
{
//lettura dello stato del pulsante di incremento (si legge lo stato di btn_plus e lo si iscrive
nella variabile stato_bottone)

etat_bouton = digitalRead(btn_plus);

Adesso, sta diventando serio. Vediamo cosa segue:

//Se il pulsante ha uno stato diverso da quello registrato E quel stato è "premuto"

se((etat_bouton != memoire_plus) && (etat_bouton == ALTO))

65
Arduino a scuola

Se lo stato del pulsante 2 è diverso da quello registrato, e qualcuno preme su

il pulsante, allora...

Le!=significa diverso da(testa la differenza tra due variabili) e l'operatore logico&&significaE

Per essere precisi, abbiamo: se ... e ... con Leif ... && ... Esempio: se fa bello e caldo, allora andiamo al
spiaggia).

Ricordiamo ora l'operazione++, che incrementa una variabile (variabile = variabile + 1, è-

dire; si aggiunge ogni volta 1 alla variabile). Nel nostro caso, si tratta del valore della variabile numero_led
che incrementiamo.

{
nombre_led++; //in aumentiamo la variabile che indica quante LED dovranno accendersi
}

Ecco! Registriamo il nuovo stato del pulsante per il prosieguo!

memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant.

Ora ricominciamo tutto, ma per il pulsante 1.

//e ora lo stesso per il pulsante che diminuisce

etat_bouton = digitalRead(btn_minus); //lecture de son état

//Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se((etat_bouton != memoire_minus) && (etat_bouton == HIGH))
{
nombre_led--; //decrementa il valore di nombre_led
}
memoire_minus = etat_bouton; //si registra lo stato del pulsante per il turno successivo

Ora limiteremo il numero di LED da collegare. Infatti, nel nostro caso, abbiamo 4 LED.
Quindi se premiamo 10 volte il pulsante 2, si accenderanno solo 4 LED.

//applichiamo dei limiti al numero per non superare 4 o 0 (dato che abbiamo 4 LED)
se(nombre_led > 4)
{
nombre_led = 4;
}

Se si preme il pulsante più di 4 volte, il risultato sarà uguale a 4

Stessa cosa adesso per il pulsante 1.

se(nombre_led < 0)
{
nombre_led = 0;
}

Ora dobbiamo gestire l'accensione dei LED. Per semplificare il codice, creeremo una funzione che
servirà a gestire la visualizzazione. Chiameremo questa funzione affiche, con un parametro int valore_recue.
il parametro rappresenta il numero da visualizzare.

//Creiamo una funzione mostra() per la visualizzazione del risultato

//gli inviamo quindi come parametro il valore del numero di LED da accendere

mostra(numero_led);
}

void affiche(int valore_ricevuto)

Iniziamo prima di tutto a spegnere tutti i LED.

66
Arduino à l'école

{
//spegniamo tutti i led
digitalWrite(led_0, BASSO);
digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
Se la funzione riceve il numero 1, accende il LED 1. Se riceve il numero 2, accende il LED 1 e 2. Se
riceve 3, accende il LED 1, 2 e 3. Infine, se riceve 4, allora accende tutti i LED:

Poi li accendiamo uno alla volta

se(valeur_recue >= 1) se il valore ricevuto è maggiore o uguale a 1...

{
digitalWrite(led_0, ALTO); accendiamo il LED 0
}
se(valeur_recue >= 2) se il valore ricevuto è maggiore o uguale a 2...
{
digitalWrite(led_1, ALTO); // "on allume la LED 1 (sous-entendu que la LED 0 est
allumata, poiché il valore è maggiore di 1)
}
se(valeur_recue >= 3) se il valore ricevuto è maggiore o uguale a 3...
{
digitalWrite(led_2, ALTO); accendiamo il LED 2
}
se(valeur_recue >= 4) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_3, HIGH; accendiamo il LED 3
}
}

Il simbolo >= significa: ... è maggiore o uguale a .... Si tratta di testare la superiorità o l'uguaglianza di una variabile.
rispetto a un valore. Pertanto, in:

se(valeur_recue >= 4)
{
digitalWrite(led_3, ALTO); accendiamo il LED 3
}

Si la variabile valore_ricevuto è maggiore o uguale a 4, allora accendiamo il LED 3.

Depurare con l'aiuto di condensatori

L'avrete senza dubbio notato: nonostante i pull-down, i pulsanti a pressione sono poco precisi. Infatti,
a volte, due LED si accendono o si spengono per una pressione sul pulsante. Questo è dovuto al fatto che il pulsante-
il pulsante non è meccanicamente perfetto. Quando si preme, il segnale non è necessariamente pulito.
Pendant quelques millisecondes, le signal va passer de 0V à 5V plusieurs fois avant de se stabiliser. L'Arduino
può interpretare uno di questi movimenti parassiti per un segnale di ingresso e quindi reagirà di conseguenza. Per
esempio, premendo una volta il pulsante, l'Arduino può registrare due impulsi in ingresso
et allumerà due LED invece di uno solo.

C'è modo di disinfettare il pulsante e di assorbire questi rimbalzi montando in parallelo al pulsante
poussoir un condensatore di bassa capacità (10nF).

Che cos'è un condensatore?

Il condensatore è un componente elettronico passivo, come le resistenze. Ha la capacità di

di immagazzinare una carica elettrica, prima di poterla restituire in caso di abbassamento della tensione. Si utilizza
così i condensatori come regolatori di tensione, Ma utilizziamo anche la sua capacità di caricarsi per
assorbire le brusche, ma brevi fluttuazioni di tensione che sono i disturbi. La capacità di carico si
misura in Farad (F).

67
Arduino a scuola

Condensatore ceramico Condensatore elettrolitico Simbolo del condensatore

Circuito 9
LED1 a LED4: a scelta

R5 e R6: resistenze di protezione LED1

R1
R7 e R8: resistenze pull-down 220

SW1 e SW2: pulsanti a pressione

LED2
R2
C1 e C2: condensatori 220
U1
ARDUINO
LED3
R3
220
AREF
GND
D13 LED4
D12
D11 R4
AZZERARE D10 220
3V D9
5V D8
GND2
GND1 D7
VIN D6 R5 R7
D5 220 10k
A0 D4
A1 D3
A2 D2 R6 R8
A3 D1 220 10k
A4 D0
A5

SW1 C2 SW2 C1
10nF 10nF

68
Arduino a scuola

Come si può vedere nel circuito sopra, sono stati aggiunti due condensatori di bassa capacità.
parallelo ai pulsanti. Se la barriera non è assoluta, ciò consente di aumentare considerevolmente
La precisione dei pulsanti.

L'installazione dei condensatori non ha alcuna influenza a livello di codice. Non è quindi necessario farlo.
modificatore.

La barra grafica a 10 LED

Esistono dei grafici a barre con 10 LED. Possiamo usarli al posto delle 4 LED precedenti.
montaggio.

Riferimenti utilizzati in questo esercizio: Kingbright DC-10EWA o DC7G3EWA.

Da un lato ci sono i catodi, dall'altro gli anodi. Nel nostro caso, gli anodi sono dal lato in cui si
trovano le iscrizioni.

Il codice, invece, deve essere adattato di conseguenza per 10 LED. Un esempio si trova qui:

Codice 13: il bargraphe a 10 LED

/*
Codice 13 - [Link], destinato all'Arduino
Il diagramma a barre
L'obiettivo è realizzare un grafico a barre, con due pulsanti.
pulsanti: uno per incrementare il numero di LED accesi,
l'altro per decrementarlo.
La barra grafica è composta da 10 LED.
*/

/*
Dichiarazione delle costanti per i nomi dei pin
*/

const int btn_minus = 2; //Pulsante 1 per diminuire il numero di LED accesi

const int btn_plus = 3; //Pulsante 2 per incrementare il numero di LED accesi
const int led_0 = 4; //Led 0
const int led_1 = 5; //Led 1
const int led_2 = 6; //Led 2
const int led_3 = 7; //Led 3
const int led_4 = 8; //Led 4
69
Arduino a scuola

const int led_5 = 9; //Led 5

const int led_6 = 10; //Led 6
const int led_7 = 11; //Led 7
const int led_8 = 12; //Led 8
const int led_9 = 13; //Led 9

/*
Dichiarazione delle variabili utilizzate per il conteggio e il decontaggio
*/

int numero_led = 0; //il numero che sarà incrementato e decrementato

int stato_bottone; //lecture de l'état des boutons (un seul à la fois, mais une
variabile sufficiente; infatti, non è previsto premere entrambi i pulsanti simultaneamente)
int memoire_plus = LOW; // stato rilasciato per impostazione predefinita per il pulsante 2
int memoire_minus = LOW; //stato rilasciato per impostazione predefinita per il pulsante 1

/*
Initialisation des broches en entrée/sortie: entrées pour les boutons, sorties pour les LEDs
*/

void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INGRESSO);
pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
pinMode(led_4, OUTPUT);
pinMode(led_5, OUTPUT);
pinMode(led_6, OUTPUT);
pinMode(led_7, OUTPUT);
pinMode(led_8, OUTPUT);
pinMode(led_9, OUTPUT);

vuoto ciclo()
{
//lettura dello stato del pulsante di incremento (si legge lo stato di btn_plus e lo si registra
//nella variabile stato_bottone)
etat_bouton = digitalRead(btn_plus);

//Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se ((etat_bouton != memoire_plus) && (etat_bouton == ALTO))
{
nombre_led++; //incremetiamo la variabile che indica quante LED devono accendersi
}

memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

//e ora lo stesso per il pulsante che decrementa

etat_bouton = digitalRead(btn_minus); //lecture de son état

//Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se ((etat_bouton != memoire_minus) && (etat_bouton == ALTO))
{
nombre_led--; //decrementa il valore di nombre_led
}
memoria_meno = stato_bottone; //si registra lo stato del pulsante per il turno successivo

//applichiamo dei limiti al numero per non superare 4 o 0 (dal momento che abbiamo 4 LED)
se (nombre_led > 10)
{
nombre_led = 10;
}
se (nombre_led < 0)
{

70
Arduino a scuola

numero_led = 0;
}

//Creiamo una funzione affiche() per visualizzare il risultato

//gli inviamo quindi come parametro il valore del numero di LED da illuminare

mostra(numero_led);
}

void affiche(int valore_ricevuto)

{
//si spengono tutti i led
digitalWrite(led_0, BASSO);
digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, BASSO);
digitalWrite(led_9, LOW);

//Poi le accendiamo una a una

se (valore_ricevuto >= 1) se il valore ricevuto è maggiore o uguale a 1...

{
digitalWrite(led_0, ALTO); accendiamo il LED 0
}
se (valore_ricevuto >= 2) se il valore ricevuto è maggiore o uguale a 2...
{
digitalWrite(led_1, ALTO); accendiamo il LED 1 (sottinteso che il LED 0 è
accesa, poiché il valore è maggiore di 1)
}
se (valore_ricevuto >= 3) se il valore ricevuto è maggiore o uguale a 3...
{
digitalWrite(led_2, ALTO); accendiamo il LED 2
}
se (valore_ricevuto >= 4) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_3, ALTO); accendiamo il LED 3
}
se (valore_ricevuto >= 5) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_4, ALTO); si accende il LED 3
}
se (valore_ricevuto >= 6) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_5, ALTO); accendiamo il LED 3
}
se (valore_ricevuto >= 7) // "si la valeur reçue est plus grande ou égale à 4..."
{
digitalWrite(led_6, ALTO); si accende il LED 3
}
se (valore_ricevuto >= 8) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_7, ALTO); si accende il LED 3
}
se (valore_ricevuto >= 9) se il valore ricevuto è maggiore o uguale a 4...
{
digitalWrite(led_8, ALTO); accendiamo il LED 3
}
se (valore_ricevuto >= 10) // "si la valeur reçue est plus grande ou égale à 4..."
{
digitalWrite(led_9, ALTO); accendiamo il LED 3
}
}

71
Arduino a scuola

l'afficheur digitale

Per questo montaggio, utilizzeremo un display digitale a LED.

La referenza utilizzata qui è un display a anodo comune Kingbright SA56-11 SRWA11.

10 kOhm

100 Ohm
D3

100 Ohm
D4

D6

D7

D8
D9

220 Ohm g f A a b
10 9 8 7 6

1 2 3 4 5
220 Ohm e d A c punto
D10

D11

D12
D13

Nel caso di un'anodo comune, quest'ultimo è collegato a +5V. I catodi sono collegati a
le spille.
A livello di codice, ciò implica che i LED sono accesi in posizione LOW e spenti in posizione HIGH.
Con un componente a catodo comune, è il contrario.
Nel nostro esempio, inizieremo accendendo tutti i diodi, poi uno dopo l'altro, per i
identificatore. Si possono poi scrivere dei numeri.

11Disponibile qui: [Link]/episode/arduino-lecole-apprendre-compter

72
Arduino a scuola

Identificazione della posizione dei LED

Il codice seguente consente di identificare la posizione delle LED accendendo l'una dopo l'altra:

/*
Codice 14 - [Link], destinato all'Arduino
L'afficheur a 7 o 8 segmenti
L'obiettivo è visualizzare numeri su un display a 7 segmenti (7 cifre).
Questo codice ha lo scopo di accendere tutte le LED e poi una dopo l'altra
per identificare la loro posizione.
*/

const int led_1 = 6; //Led 1

const int led_2 = 7; //Led 2
const int led_3 = 8; //Led 3
const int led_4 = 9;
const int led_5 = 10;
const int led_6 = 11;
const int led_7 = 12;
const int led_8 = 13;

void setup()
{
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
pinMode(led_4, OUTPUT);
pinMode(led_5, OUTPUT);
pinMode(led_6, OUTPUT);
pinMode(led_7, OUTPUT);
pinMode(led_8, USCITA);
}

vuoto ciclo()
{

accendiamo tutti i led

digitalWrite(led_1, BASSO);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, BASSO);
ritardo(1500);

//si spengono tutti i led

digitalWrite(led_1, ALTO);
digitalWrite(led_2, ALTO);
digitalWrite(led_3, ALTO);
digitalWrite(led_4, ALTO);
digitalWrite(led_5, ALTO);
digitalWrite(led_6, ALTO);
digitalWrite(led_7, ALTO);
digitalWrite(led_8, ALTO);
ritardo(500);

//accendiamo un diodo uno dopo l'altro per identificarne la posizione

digitalWrite(led_1, BASSO);
ritardo(1500);

digitalWrite(led_1, ALTO);
digitalWrite(led_2, BASSO);
ritardo(1500);

73
Arduino a scuola

digitalWrite(led_2, ALTO);
digitalWrite(led_3, BASSO);
ritardo(1500);

digitalWrite(led_3, ALTO);
digitalWrite(led_4, BASSO);
ritarda(1500);

digitalWrite(led_4, ALTO);
digitalWrite(led_5, LOW);
ritardo(1500);

digitalWrite(led_5, ALTO);
digitalWrite(led_6, BASSO);
ritarda(1500);

digitalWrite(led_6, ALTO);
digitalWrite(led_7, BASSO);
ritardo(1500);

digitalWrite(led_7, ALTO);
digitalWrite(led_8, BASSO);
ritardo(1500);
}

L'obiettivo è identificare ogni LED nel diagramma sottostante:

Ecco quindi, nel nostro caso, i LED che devono essere accesi per scrivere i seguenti numeri:

# led_1 led_2 led_3 led_4 led_5 led_6 led_7

1 X X

2 X X X X X

3 X X X X X

4 X X X X

5 X X X X X

6 X X X X X X

7 X X X

8 X X X X X X X

9 X X X X X

0 X X X X X X

Non utilizziamo la led_8, che rappresenta un punto.

Il codice per contare da 0 a 9 è qui: [Link]
74
Arduino a scuola

A tuo turno:

# led_1 led_2 led_3 led_4 led_5 led_6 led_7

1

75
Arduino a scuola

È possibile scrivere anche le lettere dell'alfabeto utilizzando un display a 7 segmenti.12:

Esempio:

Ovviamente, rimane artigianale; ma può dare risultati accettabili, come si può vedere qui:

12Fonte della polizia: [Link]

76
Arduino a scuola

Sintesi: imparare a contare

Obiettivo

Quest'ultima lezione sintetizzerà tutto ciò che abbiamo visto fino ad ora. L'obiettivo è realizzare un
montaggio, con due pulsanti e un display a 7 segmenti. Uno dei pulsanti servirà ad incrementare
i numeri sul display, e l'altro a decrementare. Così, premendo il pulsante 6 volte, i
i numeri da 1 a 6 verranno visualizzati successivamente.

Schema elettronico del montaggio

Nel diagramma che segue, il display a 7 segmenti è a anodo comune. Come al solito, ogni pulsante-
Il pulsante è dotato di una resistenza pull-down da 1kΩ o 10kΩ e di una resistenza di protezione dell'input.
100Ω. L'ordine di collegamento del display è irrilevante, poiché useremo il codice 14 per identificare l'ordine.
d'attivazione dei pin.
10 kOhm

100 Ohm
D3

100 Ohm
D4

D6

D7

D8
D9

220 Ohm g f A a b
10 9 8 7 6

1 2 3 4 5
220 Ohm e d A c punto
D10

D11

D12
D13

77
Arduino a scuola

Circuito 10

R1
220

R2
220

R3
220 a
f b

R4 g LED1
U1 220
ARDUINO
e c
d
R9 dp
220

AREF
GND R10
D13 220
D12
D11
RISETA D10 R11
3V D9 220
5V D8
GND2
GND1 D7 R12
VIN D6 220
D5
A0 D4
A1 D3
A2 D2
A3 D1
R5 R7
A4 D0 220 10k
A5

R6 R8
220 10k

SW1 C2 SW2 C1
10nF 10nF

78
Arduino a scuola

Codice 15: imparare a contare

Il codice può essere scaricato all'indirizzo seguente: [Link]

È molto simile ai codici precedenti. La principale differenza risiede nelse(valeur_recue == 1)

qui in questo caso significa "se il valore ricevuto è uguale a 1, accendiamo i segmenti per visualizzare il numero 1."
Contrariamente al se(valeur_recue >= 1), che consente di accumulare l'accensione dei LED (1 LED per 1,
due LED per 2,...), l'obiettivo qui è accendere solo le LED necessarie per visualizzare il numero corretto. Non deve
non bisognerebbe che un3 diventasse poi un9 invece di un4, perché accumuliamo i LED accesi.

/*
Codice 15 - [Link], destinato all'Arduino
Imparare a contare
L'obiettivo è visualizzare numeri su un display a 7 segmenti. Un pulsante permette
uno per incrementare il numero, l'altro per decremetarlo.
Si conta così da 0 a 9 o da 1 a 0.
*/

/*
Dichiarazione delle costanti per i nomi dei pin.
Il nostro display è a 8 segmenti, con quindi un punto. Anche se non lo utilizziamo, noi
l'abbiamo comunque cablato.
*/

const int btn_minus = 3; //Pulsante 1 per decrementare i numeri

const int btn_plus = 4; //Pulsante 2 per incrementare i numeri
const int led_1 = 6; //Led 1
const int led_2 = 7; //Led 2
const int led_3 = 8; //Led 3
const int led_4 = 9; //Led 4
const int led_5 = 10;
const int led_6 = 11;
const int led_7 = 12;
const int led_8 = 13;

/*
Dichiarazione delle variabili utilizzate per il conteggio e il deconto
*/

int numero_led = 0; //il numero che sarà incrementato e decrementato

int stato_bottone; //lettura dello stato dei pulsanti (solo uno alla volta, ma una
variabile sufficiente; in effetti, non è previsto premere i due pulsanti contemporaneamente)
int memoire_plus = BASSO; // stato rilasciato per impostazione predefinita per il pulsante 2
int memoire_minus = LOW; // stato rilassato predefinito per il pulsante 1

/*
Inutilizzo dei pin di input/output: ingressi per i pulsanti, uscite per i LED
*/

void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_1, USO);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
pinMode(led_4, USCITA);
pinMode(led_5, OUTPUT);
pinMode(led_6, OUTPUT);
pinMode(led_7, OUTPUT);
pinMode(led_8, OUTPUT);
}

79
Arduino a scuola

/*
E si parte con il programma!
*/

void ciclo()
{
//lettura dello stato del pulsante di incremento (si legge lo stato del btn_plus e lo si iscrive
//nella variabile stato_bottone)
etat_bouton = digitalRead(btn_plus);

//Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se((etat_bouton != memoire_plus) && (etat_bouton == ALTO))
{
nombre_led++; //incrementeamo la variabile che indica quante LED devono accendersi
}

memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

//e ora lo stesso per il pulsante che decremente

etat_bouton = digitalRead(btn_minus); //lecture de son état

//Se il pulsante ha uno stato diverso da quello registrato E che questo stato è "premuto"
se((etat_bouton != memoire_minus) && (etat_bouton == HIGH))
{
nombre_led--; //decrementa il valore di nombre_led
}
memoire_minus = stato_bottone; // registriamo lo stato del pulsante per il turno successivo

//applichiamo dei limiti al numero per non superare 4 o 0 (poiché abbiamo 4 LED)
se(nombre_led > 10)
{
nombre_led = 10;
}
se(nombre_led < 0)
{
nombre_led = 0;
}

//Creiamo una funzione affiche() per visualizzare il risultato

//gli inviamo quindi come parametro il valore del numero di LED da illuminare

affiche(numero_led);
}

void affiche(int valore_ricevuto)

{
Spegniamo tutte le led
digitalWrite(led_1, ALTO);
digitalWrite(led_2, ALTO);
digitalWrite(led_3, HIGH);
digitalWrite(led_4, ALTO);
digitalWrite(led_5, ALTO);
digitalWrite(led_6, ALTO);
digitalWrite(led_7, ALTO);
digitalWrite(led_8, ALTO);

//Per ogni cifra, la cosa più semplice è elencare tutti i LED

//e di assegnare loro il valore desiderato

se(valeur_recue == 1) // "se il valore ricevuto è uguale a 1, accendiamo i "

//segmenti per visualizzare il numero 1
{

digitalWrite(led_1, BASSO);
digitalWrite(led_2, ALTO);

ottanta
Arduino a scuola

digitalWrite(led_3, ALTO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, ALTO);
digitalWrite(led_6, ALTO);
digitalWrite(led_7, ALTO);
digitalWrite(led_8, ALTO);

se(valeur_recue == 2) se il valore ricevuto è uguale a 2, accendiamo i

//segmenti per visualizzare il numero 2
{

digitalWrite(led_1, LOW);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, ALTO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, ALTO);
digitalWrite(led_8, ALTO);

}
se(valeur_recue == 3) se il valore ricevuto è uguale... beh... lo sai tu
//suite...
{

digitalWrite(led_1, ALTO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, ALTO);
digitalWrite(led_5, LOW);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, HIGH);

}
se(valeur_recue == 4)
{

digitalWrite(led_1, ALTO);
digitalWrite(led_2, ALTO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, ALTO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, HIGH);

if(valeur_recue == 5)
{

digitalWrite(led_1, ALTO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, ALTO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, ALTO);

}
se(valeur_recue == 6)
{

digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);

81
Arduino a scuola

digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, ALTO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, ALTO);

se(valeur_recue == 7)
{

digitalWrite(led_1, ALTO);
digitalWrite(led_2, HIGH);
digitalWrite(led_3, ALTO);
digitalWrite(led_4, ALTO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, ALTO);

se(valeur_recue == 8)
{

digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, BASSO);

se(valeur_recue == 9)
{

digitalWrite(led_1, ALTO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, BASSO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, BASSO);

se(valeur_recue == 10)
{

digitalWrite(led_1, BASSO);
digitalWrite(led_2, BASSO);
digitalWrite(led_3, ALTO);
digitalWrite(led_4, BASSO);
digitalWrite(led_5, BASSO);
digitalWrite(led_6, BASSO);
digitalWrite(led_7, BASSO);
digitalWrite(led_8, BASSO);

}
}

Il codice termina con il numero 0, in assenza del 10.

Il codice non è ottimizzato; potremmo evitare di ripetere i digitalWrite che sono in posizione LOW più volte.
volte di seguito. Tuttavia, questo consente di comprendere e analizzare il codice in modo molto più semplice;
cominciare dagli studenti.
82
Arduino a scuola

Progetto 9: gli input analogici

Un segnale analogico13variano in modo continuo nel tempo. Il suo valore è quindi un numero reale. Si
trova segnali analogici costantemente, come la temperatura, la velocità...

Segnale digitale

Segnale analogico

L'Arduino Uno possiede 6 ingressi analogici, numerati da A0 a A5. In realtà, il microcontrollore non è
capace di comprendere un segnale analogico. È quindi necessario prima convertirlo in segnale digitale tramite un
circuito speciale chiamato convertitore analogico/digitale. Questo convertitore campionerà il segnale ricevuto
sotto forma di una variazione di tensione e trasformarla in valori compresi tra 0 e 1023. Attenzione a
non far entrare una tensione superiore a 5V, poiché ciò distruggerebbe l'Arduino.

La fotoresistenza
Una fotoresistenza è un componente elettronico
la cui resistenza (in OhmΩ) varia in funzione di
l'intensità luminosa. Più alta è la luminosità,
più la resistenza è bassa. Possiamo quindi usarla
come sensore di luce per:

• Misura della luce ambientale per una

stazione meteorologica.
• Rilevatore di luce in una stanza.
• Seguace di luce in un robot.
• Rilevatore di passaggio.
•…

13Ulteriori informazioni: [Link]

83
Arduino a scuola

I suoi simboli elettronici sono i seguenti:

Il vantaggio delle fotocellule è che sono molto economiche. D'altra parte, la loro reazione alla luce è
diverso per ogni fotoresistenza, anche quando sono state prodotte nello stesso lotto. Si può così
segnare una differenza di resistenza di oltre il 50% tra due fotoresistenze dello stesso modello per la
stessa luminosità. Non si può quindi utilizzare per una misurazione precisa della luce. D'altra parte, sono
ideali per misurare cambiamenti semplici della luminosità.

Circuito 11: divisore di tensione

Per il circuito 11, avremo bisogno di una fotoresistenza che collegheremo al pin A0.

Il montaggio resistenza fissa - fotoresistenza costituisce quello che si chiama un divisore di tensione. 5V sono
introdotti nel circuito dall'Arduino. Colleghiamo il punto tra le due resistenze a un pin analogico
dell'Arduino e misuriamo la tensione tramite la funzione analogRead (pin). Qualsiasi cambiamento della tensione
la misura è dovuta alla fotoresistenza poiché è l'unica che cambia in questo circuito, in base alla
luce.

Elenco dei componenti

1 LED
1 resistenza di 220Ω
1 resistenza da 10kΩ
1 fotoresistenza

Circuito 11

84
Arduino a scuola

U1
ARDUINO

AREF
GND
D13
D12
D11
AZZERARE D10
3V D9
5V D8
GND2
LDR1 GND1 D7
Fotorresistenza VIN D6 R1
D5 220
A0 D4
A1 D3
A2 D2
A3 D1
A4 D0 D1
R2 A5 LED
10k

Codice 16: valore di soglia

L'obiettivo di questo codice è definire una soglia di luminosità oltre la quale spegniamo un LED. Andremo per
questo utilizza una nuova istruzione: se ... altrimenti (se ... altrimenti). Quindi si tratta di una condizione.

Ecco cosa succederà:

Sila luminosité dépasse le seuil (if (analogRead (lightPin)> seuil)), éteindre la LED (digitalWrite (ledPin,
BASSO)); sinon (altro), accendere il LED (digitalWrite(ledPin, HIGH)).

L'istruzione==verifica se due espressioni sono uguali. Se lo sono, allora il risultato sarà vero (true) altrimenti
il risultato sarà falso.

In questo caso, la soglia è fissata a 900 (su 1023). Variando il valore della soglia, si modifica la sensibilità di
rilevazione della luminosità.

/*
Codice 16 - [Link], destinato all'Arduino
Obiettivo: Spegnere un LED non appena la luminosità è sufficiente
*/

//***** INTESTAZIONE DICHIARATIVA *****

int lightPin = 0; //Rinominiamo il pin A0 in "lightPin"

int ledPin = 9; //Rinominiamo il pin 9 in "ledPin"

//***** FUNZIONE SETUP = Codice di inizializzazione *****

// La funzione setup() viene eseguita per prima ed una sola volta, all'avvio del programma

void setup()
{
pinMode(ledPin, OUTPUT);
[Link](9600);
}

85
Arduino a scuola

vuoto ciclo()
{
int soglia = 900; //Si definisce una soglia di luminosità (su 1023) a
//dal quale la LED si spegne
se (analogRead (lightPin) > seuil) Se la luminosità è superiore alla soglia...
{
digitalWrite (ledPin, BASSO); //... allora spegniamo il LED.
}
altro //Sinon...
{
digitalWrite (ledPin, HIGH); //...accendiamo il LED
}
}

Codice 17: variazione della luminosità di un LED in funzione della luce ambientale

Immaginiamo ora di voler variare la luminosità di un LED in base alla luminosità della stanza
nella quale si trova: più è giorno, meno la LED è luminosa.

Teoricamente, non c'è nulla di complicato; basta combinare il segnale della fotresistenza con il valore
PWM del LED. Praticamente, ci ritroviamo con un segnale in ingresso (la fotoresistenza) suddiviso in 1024
paliers, mentre quelli del segnale PWM contano 256 paliers. Solo, 1024, è 256 x 4. Dividendo la
valore della variabile lightReading per 4, la rendiamo compatibile con i 256 livelli di variazione della luminosità
dalla LED.

/*
Codice 17 - [Link], destinato all'Arduino
Obiettivo: Variare la luminosità del LED in base alla luminosità della stanza
[Link]
*/

int lightPin = 0;

int lightReading;

int ledPin = 9;
int luminositàLed;

void setup() {

[Link](9600);
}

vuoto ciclo() {

lightReading = analogRead(lightPin);

[Link]("Lettura analogica = ");

[Link](lightReading);

lightReading = 1023 - lightReading;

ledBrightness = lightReading / 4;
analogWrite(ledPin, ledBrightness);

ritardo(100);
}

86
Arduino a scuola

Analisi del codice

Innanzitutto, definiamo le nostre costanti e le nostre variabili. Così, il pin A0, su cui la
photorésistance (couplée à la résistance pulldown) est connectée est renomméelightPin. On créé ensuite une
variabile namedelightReadingper memorizzare il valore analogico (compreso tra 0 e 1023) del valore di
la fotoresistenza con il divisore di tensione. Naturalmente, il pin 9, a cui è collegato il LED
è chiamata ledPin. Si noti che il pin 9 è compatibile con PWM. Infine, creiamo una variabile ledBrightness
per memorizzare il valore di luminosità del LED (compreso tra 0 e 255).

int lightPin = 0;
int lightReading;
int ledPin = 9;
int luminositàLed
Successivamente, memorizziamo il valore della fotoresistenza con un analogRead nella variabile lightReading.

lightReading = analogRead(lightPin);

Piccola parentesi: si può controllare il buon funzionamento della fotoresistenza inviando alla console di Arduino
IDE le valori misurati grazie a [Link], che si trova in Menu Strumenti -> Monitoraggio seriale. Questo codice
è quindi facoltativo.

[Link]("Lettura analogica = ");

[Link](lightReading);

Più scura è, più il LED deve essere luminoso.

// Questo significa che bisogna invertire il valore letto da 0-1023 a 1023-0, con una
sottrazione.
lightReading = 1023 - lightReading;

//Alla fine bisogna mappare i valori letti da 0-1023 a 0-255 che sono i valori
utilizzate da analogWrite.
//Per questo, si converte il valore della variabile "lightReading" dividendolo per 4.
ledBrightness = lightReading / 4;
analogWrite(ledPin, ledBrightness); // Accende finalmente il LED con la luminosità memorizzata
nella variabile "ledBrightness".

ritardo(100);
}
La variazione di luminosità è spesso invertita. Così, una sveglia è molto luminosa quando è giorno e poco
luminoso durante la notte. Per simulare ciò, basta rimuovere la seguente riga:

lightReading = 1023 - lightReading;

Codice 18: mappatura dei dati

Il mapping dei dati è l'associazione dei dati appartenti a uno con i dati appartenti a un altro.
un altro insieme, in modo che si possa passare armoniosamente dalle prime alle seconde14.
Nel nostro caso, abbiamo dati iscritti in un intervallo compreso tra 0 e 1023 che dobbiamo
convertire in un intervallo tra 0 e 255, che corrisponde a 8 bit.

Se riprendiamo l'esercizio precedente, una piccola modifica permette di fare il mapping dei dati.

/*
Codice 18 - [Link], destinato all'Arduino
Obiettivo: Variare la luminosità del LED in base alla luminosità della stanza con
mappatura dei dati

14[Link]

87
Arduino a scuola

Fonte: [Link]
*/

int lightPin = 0; La fotoresistenza e la resistenza pulldown da 1 a 10K sono

connessi a A0
int lightReading; // Lettura analogica del valore della fotoresistenza con il
partitore di tensione
int ledPin = 9; // LED in PWM sulla pin 9
int luminositàLed; // Variabile per memorizzare il valore di luminosità del LED
void setup() {

[Link](9600);
}

void loop() {
lightReading = analogRead(lightPin);

//Visualizzazione del valore di "lightReading" nella console

[Link]("Lettura analogica = ");
[Link](lightReading); // Visualizzazione del valore grezzo derivante da
//fotorresistenza.

Più diventa buio, più il LED deve essere luminoso.

// Questo significa che bisogna invertire il valore letto da 0-1023 a 1023-0, con una
//sottrazione.
lightReading = 1023 - lightReading;

//Infine, è necessario abbinare con la funzione "map" i valori letti da 0-1023 a 0-255
//qui sont les valeurs utilisées par analogWrite.

ledBrightness = map(lightReading, 0, 1023, 0, 255);

analogWrite(ledPin, ledBrightness); // Accende finalmente il LED con la luminosità memorizzata
//dans la variable "ledBrightness".

ritarda(100);
}

Si vede nella riga seguente il mappaggio:

ledBrightness = map(lightReading, 0, 1023, 0, 255);

la funzione map funziona nel modo seguente:

Variabile Variabile Dati Dati
di arrivo d'origine d'origine d'arrivo

variabile2 = mappa(variabile1, 0, 1023, 0, 255);

Variable1 è l'origine dei dati. Variable2 è la destinazione dei dati.

88
Arduino a scuola

Progetto 10: il potenziometro

Il potenziometro è una resistenza variabile. A differenza, è il pulsante di regolazione del volume su una
radio. La maggior parte dei potenziometri sono rotativi o lineari.

Potentiometro rotativo Potenziometro lineare

I potenziometri sono molto comuni negli apparecchi elettronici, ad esempio nelle console di missaggio.

Mixer del RadioBus15

Ecco i simboli elettronici (europeo sopra e americano sotto) del potenziometro:

Come tutte le resistenze, il potenziometro modifica la tensione di un circuito. Lo utilizzeremo quindi principalmente
come ingresso (input) in una broche analogica (A0 a A5) dell'Arduino.

15 [Link]

89
Arduino a scuola

I potenziometri hanno generalmente tre terminali16Le spine esterne si collegano all'alimentazione

+5V e a terra, mentre il pin centrale invia il segnale al pin di ingresso analogico dell'Arduino.

Scopa
Piste resistiva

+5V FUORI GND

verso l'ingresso
analogico GND
FUORI

+5V

Circuito 12: Usare il potenziometro per variare la luminosità di un LED

È tempo di bruciare il nostro primo LED (se non lo abbiamo già fatto)! È il passaggio obbligato di ogni buon
creatore! Per fare ciò, collegheremo un LED al pin OUT del potenziometro e lo metteremo a
terra. Piccolo consiglio: prima di collegare, ruotare il potenziometro al minimo, in senso antiorario
di un orologio.

Una volta collegato l'Arduino, ruotare delicatamente il potenziometro in senso orario. La

Il LED inizierà a illuminarsi, poi sempre di più, prima di... bruciare.

Circuito 12

90
Arduino a scuola

U1
ARDUINO

AREF
GND
D13
D12
D11
RESETTARE D10
3V D9
5V D8
GND2
GND1 D7
VIN D6
D5
R2 A0 D4
10k A1 D3
A2 D2
A3 D1
A4 D0
D1 A5
LED

Abbiamo appena visto: variare la tensione all'ingresso di un LED non è la soluzione migliore per far variare
la sua luminosità… anche se il LED non si brucia, oltre il suo voltaggio di funzionamento, la sua durata sarà
fortemente ridotta. Ma che importa, visto che abbiamo la funzione PWM17Quindi andremo a collegare il
potenziometro, in ingresso analogico su A0, con un LED in PWM sul pin 9.

Liste des composants

1 LED
1 resistenza di 220Ω
1 potenziometro da 10kΩ o 20kΩ

Circuito 13: Utilizzare il potenziometro per variarne la luminosità di un LED

Circuito 13

17Vedare il Progetto 7 di questo corso.

91
Arduino a scuola

U1
ARDUINO

AREF
GND
D13
D12
D11
RESET D10
3V D9
5V D8
GND2
GND1 D7
VIN D6 R1
D5 220
R2 A0 D4
10k A1 D3
A2 D2
A3 D1
A4 D0 D1
A5 LED

Il codice è molto semplice. Come per il codice 17, recuperiamo il valore compreso tra 0 e 1023 su A0, prima di
dividerla per 4, in modo da renderla compatibile con l'ampiezza del PWM, compresa tra 0 e 255. Come per
il codice 18, si potrebbe anche immaginare una mappatura invece della divisione.

Codice 19: Variare la luminosità del LED in PWM utilizzando un potenziometro

/*
Codice 19 - [Link], destinato all'Arduino
Obiettivo: Leggere il valore del potenziometro per variare la luminosità del LED in PWM
Philippe Krähenbühl
*/

int ledPin = 9; //Rinominiamo il pin 9 in "ledPin"

int analogPin = 0; Il potenziometro è collegato al pin analogico 0
int val = 0; // la variabile qui memorizza il valore letto è impostata a 0

void setup()

{
pinMode(ledPin, OUTPUT);
}

void loop()

{
val = analogRead(analogPin); //lettura del valore analogo (potenziometro)
analogWrite(ledPin, val / 4); // valore analogico letto (0 a 1023) diviso per 4 (0 a 255)
}

92
Arduino a scuola

Circuito 14: Accendere i LED di un bargraph utilizzando un potenziometro

Quando si gira la manopola per aumentare il volume, sarebbe interessante avere un grafico a barre che ci
indica il livello.

Quindi realizzeremo un grafico a barre utilizzando 8 LED.

Elenco dei componenti

8 LED
8 resistenze di 220Ω
1 potenziometro da 10kΩ o 20kΩ

Circuito 14

PR1
Potentiometro

UNO R3
U1
ARDUINOR3
ARDUINO

R1 R2 R3 R4 R5 R6 R7 R8
220 220 220 220 220 220 220 220

LED1 LED2 LED3 LED4 LED5 LED6 LED7 LED8

93
Arduino a scuola

Codice 20: Visualizza il valore di un potenziometro utilizzando un grafico a barre

Il caso di questo codice è molto interessante. Ora sappiamo che abbiamo 1024 livelli sull'ingresso.
analogico dell'Arduino. Quando l'Arduino riceve il valore di 1024, 8 LED devono essere accesi. Così,
Quando riceverà il valore di 512, 4 LED dovranno essere accesi (512 essendo naturalmente la metà di 1024).
Quindi divideremo i nostri 1024 livelli per 8, per ottenere l'intervallo che accenderà i LED uno dopo l'altro.
altri. Attenzione; si inizia a contare da 0, non da 1. È per questo che i nostri 1024 livelli si
terminano a 1023.

Si arriva al risultato seguente:

LED1: de 0 à 127 LED2: da 128 a 255 LED3: da 256 a 383 LED4: da 384 a 511
LED5: da 512 a 639 LED6: da 640 a 767 LED7: da 768 a 895 LED6: de 769 à 1023

Da lì, basta andare a cercare il valore ricevuto, che saranno memorizzato nella variabile readValue, poi di
fare passare in 8 test a partire da if... else consecutivi.

[Link] ha l'obiettivo di visualizzare nel monitor il valore ricevuto dall'Arduino18.

/*
Codice 20 - [Link], destinato all'Arduino
Obiettivo: Visualizzare il valore di un potenziometro utilizzando un grafico a barre
*/

// Informazioni sulle LED

int led1 = 5;
int led2 = 6;
int led3 = 7;
int led4 = 8;
int led5 = 9;
int led6 = 10;
int led7 = 11;
int led8 = 12;

// Informazioni sul potenziometro

int potPin = A0;
int readValue;
int writeValue;

void setup() {

[Link](9600);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(led7, OUTPUT);
pinMode(led8, OUTPUT);
}

void loop() {

Scrittura del valore del potenziometro

dans la variable "readValue"
*/

18Vedi codice 17
94
Arduino a scuola

readValue = analogRead(potPin);

Iscrizione nel monitor seriale

Colore=valore della variabile readValue
*/

[Link]("\Val=");
[Link](readValue);
ritardo(200);

// Da 0 a 127, led1
se (readValue < 128) {
led 1
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, ALTO);
digitalWrite(led5, ALTO);
digitalWrite(led6, ALTO);
digitalWrite(led7, ALTO);
digitalWrite(led8, ALTO);
}

// Da 128 a 255, led 1 a 2

altrimenti se (readValue >= 128 && readValue < 256) {
led 2
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, BASSO);
digitalWrite(led4, BASSO);
digitalWrite(led5, BASSO);
digitalWrite(led6, LOW);
digitalWrite(led7, BASSO);
digitalWrite(led8, BASSO);
}

// Da 256 a 383, led 1 a 3

else if (readValue >= 256 && readValue < 384) {
led 3
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, BASSO);
digitalWrite(led5, BASSO);
digitalWrite(led6, LOW);
digitalWrite(led7, BASSO);
digitalWrite(led8, BASSO);
}

// Da 384 a 511, led 4

else if (readValue >= 384 && readValue < 512) {
led 4
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, HIGH);
digitalWrite(led5, LOW);
digitalWrite(led6, BASSO);
digitalWrite(led7, BASSO);
digitalWrite(led8, LOW);
}

Da 512 a 639, led 5

altrimenti se (readValue >= 512 && readValue < 640) {
led 5
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, HIGH);
digitalWrite(led4, ALTO);

95
Arduino a scuola

digitalWrite(led5, ALTO);
digitalWrite(led6, BASSO);
digitalWrite(led7, BASSO);
digitalWrite(led8, BASSO);
}

// Da 640 a 767, led 6

else if (readValue >= 640 && readValue < 768) {
led 6
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, ALTO);
digitalWrite(led5, ALTO);
digitalWrite(led6, ALTO);
digitalWrite(led7, BASSO);
digitalWrite(led8, BASSO);
}

// Da 768 a 895, led 7

else if (readValue >= 768 && readValue < 896) {
led 7
digitalWrite(led1, ALTO);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, ALTO);
digitalWrite(led5, ALTO);
digitalWrite(led6, ALTO);
digitalWrite(led7, ALTO);
digitalWrite(led8, BASSO);
}

// Da 896 a 1023, led 8

altrimenti {

led 8
digitalWrite(led1, HIGH);
digitalWrite(led2, ALTO);
digitalWrite(led3, ALTO);
digitalWrite(led4, ALTO);
digitalWrite(led5, ALTO);
digitalWrite(led6, ALTO);
digitalWrite(led7, ALTO);
digitalWrite(led8, HIGH);
}
}

Variante 1: utilizzare un bargrafo con 10 LED

A questo punto, si può utilizzare un potenziometro e visualizzarne il valore tramite un grafico a barre con 10 LED. Basta
per questo non dividere più 1024 per 8, ma per 10 (arrotondando).

96
Arduino a scuola

Variante 2: utilizzare un display LED a 8 cifre

Ecco una variante un po' più sofisticata. Si tratta di visualizzare nuovamente il valore di un potenziometro. Ma
cette fois avec un afficheur LED 8 digits. On affiche la valeur de 0 (min) à 9 (max).

97
Arduino a scuola

Progetto 11: costruire una stazione meteorologica

Contributo di Jean-Pierre Dulex, Scuole secondarie delle Ormonts-Leysin

Obiettivo: utilizzare un sensore di temperatura/umidità e visualizzare i dati su un display LCD

Questo progetto è la sintesi degli input analogici, con come bonus l'utilizzo di uno schermo per l'affissione
dati.

Conoscere la temperatura e l'umidità è un'informazione utile per vivere comodamente, per immagazzinare
alimenti o materiali, per previsioni meteorologiche... Con questo progetto impareremo come misurare questi
due dati e mostrarli su un display LCD.

Con i progetti precedenti, abbiamo imparato a misurare valori (intensità luminosa e temperatura)
con sensori analogici grazie alle entrate analogiche della scheda Arduino che sono dotate di un
componente che trasforma i valori analogici misurati in valori numerici. Ma ci sono anche
numerosi sensori che trasformano da soli i valori analogici misurati in valori digitali
sfruttabili tramite mezzi informatici. È il caso di un sensore di temperatura e umidità molto
diffuso e economico, il DHT11 che utilizzeremo per questo progetto.

In basso a destra, di colore blu, il sensore DHT11, sopra il display LCD a due righe di 16 caratteri che
indica la temperatura e l'umidità attuali. Si nota anche un potenziometro (resistenza variabile) sulla parte
il lato destro della breadboard il cui ruolo è regolare la luminosità dello schermo.
98
Arduino a scuola

Il sensore DHT11 è fornito con molti kit per Arduino, altrimenti si può acquistare per pochi
franchi. Il DHT11 misura solo temperature positive, tra 0°C e 50°C con una precisione di ± 2°C
e tassi di umidità relativa dal 20 all'80% con una precisione di ± 5%. Per esigenze più specifiche o se
s’agit de mesurer aussi des températures négatives, il faut se munir de son grand frère, le DHT22, deux fois
più costoso, ma la sua gamma di misura va da -50°C a +125°C, con una precisione di 0,5°C e di 0
a 100% (precisione ± 2%) per la misura dell'umidità relativa.

Attenzione: ci sono versioni dei sensori DHTxx che non sono preassemblati su un piccolo circuito come il modello di
sinistra sopra utilizzata in questo progetto. Se è così, è necessario aggiungere una resistenza di pull-up da 5 a 10 kOhm e un
condensatore da 100 nF tra i pin 1 (alimentazione 5 V) e 4 (GND). Uno schema del cablaggio è disponibile tramite
qui :[Link]

Circuito 15

Utilizzo del sensore di temperatura e umidità

Quando si tiene il sensore con la griglia di fronte a noi, il perno centrale è l'alimentazione, deve essere
collegata al 5V dell'Arduino. La pin più a destra sarà collegata al – (GND). Quanto alla pin più a
A sinistra, c'è la scheda dati, sarà collegata all'ingresso digitale utilizzato per leggere i dati.

Una volta che questi dati sono conosciuti, il montaggio è un gioco da ragazzi e uno schema qui è inutile, noi sceglieremo
il Pin7 per i dati :

99
Arduino a scuola

Codice 21: Acquisire i dati del sensore e visualizzarli.

L'obiettivo di questo codice è acquisire tramite uno dei pin digitali dell'Arduino i dati di temperatura.
e di umidità trasmessi dal sensore DHT11, per poi mostrarli sullo schermo del computer. Per
per comunicare con il sensore, è necessario prima scaricare e installare la libreria specifica
a questo sensore (o piuttosto una delle librerie per questo sensore, poiché ce ne sono diverse versioni). Le
Le librerie sono insiemi di funzioni che si aggiungono alle funzioni di base del software [Link].
Alcune librerie sono preinstallate, ad esempio quella intitolata LiquidCrystal di cui avremo bisogno
più tardi per la visualizzazione sullo schermo LCD, altre devono essere installate dall'utente man mano che
i suoi bisogni. La libreria DHTLib che utilizzeremo per questo progetto fa parte di quest'ultima
categoria e deve quindi essere installata "a mano".
Dalla versione 1.6.0 dell'IDE Arduino, un gestore di librerie ha permesso di semplificare notevolmente
l'installazione e l'aggiornamento delle librerie. Il gestore è accessibile tramite il menu Schizzo->Includi
Gestire le biblioteche. Si apre una finestra di gestione delle biblioteche.
la quale è possibile cercare una nuova biblioteca digitando il suo nome nel campo di ricerca
in alto a sinistra o di fare aggiornamenti delle librerie esistenti.

Sopra, digitando dht nella barra di ricerca otteniamo in seconda posizione la libreria DHTLib che noi
andiamo a usare. Non resta che installarlo facendo clic sul pulsante che appare a destra quando lo selezioniamo.

Una soluzione alternativa per installare una libreria consiste nel scaricare il file .zip della libreria
desiderato, quindi installarlo tramite il menu Disegno->Includere una libreria->Aggiungi una [Link].

La biblioteca DHTLib può essere scaricata qui:

[Link]

Nota: sugli account degli studenti, le biblioteche aggiuntive sono installate nella cartella personale dell'utente
e saranno quindi accessibili solo per questo singolo utente, è necessario avere accesso da amministratore per installare una
biblioteca per tutti gli utenti di un computer.

Attenzione, affinché la biblioteca appena installata sia utilizzabile, è necessario uscire e poi riavviare Arduino

La biblioteca ad hoc essendo ora installata, possiamo passare al codice:

/*
Codice 21 - [Link], destinato all'Arduino
Obiettivo: Visualizzare la temperatura e l'umidità su uno schermo
*/

//***** TESTO INTESTAZIONE DICHIARATIVA *****

100
Arduino a scuola

#include <dht.h> //si carica la libreria

dht DHT; //creiamo l'oggetto del sensore DHT11

#define DHT11_PIN 7 //si definisce il Pin che verrà utilizzato per ricevere i dati

void configurazione() // inizio della funzione setup()

{
[Link](9600); //Per una volta, l'apertura della porta seriale e la definizione della sua
la velocità in baud è utile, anzi indispensabile poiché utilizzeremo questa porta per visualizzare
i valori del sensore.
}

//***** FUNZIONE LOOP = Codice di inizializzazione *****

// La funzione setup() viene eseguita per prima e una sola volta, all'avvio del programma

void loop() // inizio della funzione loop()

{
int chk = DHT.read11(DHT11_PIN); si legge lo stato del sensore
[Link]("Temperatura = "); //si scrive la parola Temperatura sul monitor
[Link]([Link]); //si mostra sulla stessa riga la temperatura letta
[Link]("Umidità = "); //si scrive la parola Umidità sul monitor
[Link]([Link]à);//si stampa sulla stessa riga l'umidità letta
ritardo(1000); //facciamo una pausa di 1 secondo tra 2 interrogazioni del sensore
}

Per visualizzare i dati trasmessi dal sensore, è necessario aprire una finestra del monitor seriale su
il tuo computer: Menu Strumenti -> Monitor seriale.

Finché il monitor seriale è aperto, la temperatura e l'umidità misurate vengono visualizzate una volta al secondo

101
Arduino a scuola

Circuito 16

Visualizzazione dei valori misurati su uno schermo LCD

Mostrare il risultato delle misurazioni sul monitor seriale è molto carino, ma se si vuole fare una
installazione di misurazione permanente e autonoma, questa soluzione non è adatta, poiché è necessario che il computer
sia sempre acceso e collegato alla scheda. La visualizzazione su un piccolo schermo LCD è una soluzione ben
più elegante e pratico. Uno dei display LCD più diffusi al mondo Arduino e che è spesso
fornito con i kit di base è il modello detto 16x2 LCD (è in grado di visualizzare due righe di 16 caratteri
All'acquisto, un tale schermo costa tra 7 e 15€.

Nota: lo scopo finale è visualizzare la temperatura e l'umidità trasmesse dal sensore DHT11, è
consigliato lasciare il circuito 9 in posto (su un lato o un'estremità della breadboard, altrimenti il)
dovrà essere ricablato più tardi. Le immagini qui sotto non includono volutamente il DHT11,
sempre collegato al Pin7 per migliorarne la leggibilità.

Liste des composants :

1 schermo LED 2x12

1 potenziometro (resistenza variabile)
1 resistenza di 220Ω
1 sensore DHT11 (già cablato dal circuito 9)

Esiste una grande varietà di modelli di schermi LCD, alcuni molto pratici che hanno già dei pin che
superano la faccia inferiore e si incastrano direttamente nella breadboard, altri richiedendo
l'uso di connettori maschio-maschio per poter collegarsi alla breadboard o direttamente alla scheda
Arduino tramite cavi di collegamento.
102
Arduino a scuola

Tutti i modelli di schermo LCD sono dotati di 16 pin di cui il cablaggio è il seguente:

I primi due pin a sinistra servono per l'alimentazione dello schermo. Polo negativo o GND per il
premier et pôle positivo (5V) per il 2ème.
Il 3° pin è collegato a un potenziometro e serve a regolare il contrasto dello schermo LCD.
Il 4° pin, contrassegnato come RS per Register Select, è collegato al pin 12 dell'Arduino. Serve a selezionare la zona
memoria dello schermo LCD nella quale scriveremo.
Il 5° deve essere collegato a terra (GND).
Le 6ème, noté E pour Enable, est connecté au pin 11 de l'Arduino. Il permet de lancer ou non l'écriture
nelle zone di memoria.
I quattro seguenti (7, 8, 9 e 10)ème) sono collegati a terra (GND).
Le quattro che seguono (11 a 14ème, notati 5, 4, 3, 2 nello schema sopra, poiché si collegano ai
Perni 5, 4, 3, 2 dell'Arduino. Servono per la trasmissione dei dati da visualizzare.
I due perni tutto a destra (15 e 16)ème) servono per alimentare la LED del retroilluminazione dello schermo LCD.
Attenzione, il penultimo (polo positivo 5V) deve essere assolutamente protetto da una resistenza di circa
220Ω. L'ultimo è collegato al polo negativo (GND).

Una volta effettuato il montaggio e collegato l'Arduino alla porta USB del computer, puoi ruotare il
potenziometro e vedrete il contrasto dello schermo modificarsi.

Codice 22: Visualizza i dati sullo schermo LCD

A differenza della biblioteca «DHTLib» utilizzata in precedenza, la biblioteca «LiquidCrystal» è

inclusa con il software Arduino IDE, ma è comunque necessario installarla prima di poterla utilizzare.
Menu :Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques
Nella scheda di ricerca, digita: "LiquidCrystal". Se la libreria è già installata, vedrai scritto
"INSTALLATO" accanto al suo nome, altrimenti clicca su Installa

Attenzione, affinché la libreria appena installata sia utilizzabile, è necessario chiudere e riavviare Arduino.
IDE.

/*
Codice 22 - [Link], destinato all'Arduino
Obiettivo: Visualizzare la temperatura e l'umidità su un display LCD
*/

//***** TESTA DICHIARATIVA *****

103
Arduino a scuola

#include <dht.h> //includiamo la libreria per il sensore DHT11

#include <LiquidCrystal.h> //includiamo la libreria per lo schermo LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);//creiamo l'oggetto LCD e definiamo i pin utilizzati

dht DHT; // si crea l'oggetto del sensore DHT11

#define DHT11_PIN 7 //si definisce il Pin utilizzato per i dati del DHT11

vuoto setup(){}
[Link](16, 2); //inizializziamo la comunicazione con lo schermo LCD
}

void loop()
{
int chk = DHT.read11(DHT11_PIN); //si leggono i dati dal sensore DHT
[Link](0,0); //posizioniamo il cursore dello schermo LCD all'inizio della 1eralinea
[Link]("Temp: "); //scriviamo la parola "Temp: " nella posizione del cursore
[Link]([Link],1);//scriviamo la temperatura letta dal sensore, con 1 cifra
dietro la virgola
[Link]((char)223); //si aggiunge il simbolo ° dopo il valore della temperatura
[Link]("C"); //aggiungiamo la lettera C per grado Celsius
[Link](0,1); //spostiamo il cursore dello schermo LCD all'inizio della 2ª riga
[Link]("Umidità: "); //si scrive la parola "Hum. rel: " nella posizione del cursore
[Link]([Link]à,1); //scriviamo l'umidità relativa letta dal sensore, con 1
cifra dietro la virgola
[Link]("%"); //on ajoute le symbole "%" après la valeur de l'humidité
ritarda(1000); //aspettiamo un secondo prima di procedere alla lettura successiva
}

104
Arduino a scuola

Progetto 12: Utilizzare un servomotore

I servomotori, spesso abbreviati in «servo» dai loro utenti, sono motori di un tipo
particolari, molto apprezzati per far girare qualcosa fino a una posizione ben precisa e capaci di
mantenere questa posizione fino all'arrivo di una nuova istruzione. Sono molto usati nel modellismo
(direzione delle auto telecomandate, comando delle superfici di controllo di deriva e di profondità sugli aerei,
ecc...), ma hanno anche un posto nella robotica e nell'industria, ad esempio in valvole per regolare
des flux de liquides.

Un servomotore detto «9 grammi» molto diffuso nel mondo di Arduino.

In questo capitolo, impareremo a utilizzare il servomotore più comune nel modellismo e nella
piccola elettronica, si tratta dei modelli detti 9g, per 9 grammi. Esternamente, si presenta sotto forma di
di un piccolo rettangolo, con due piccoli bordi sui lati per fissarlo saldamente e un asse decentrato su
le quale si possono fissare braccia intercambiabili per garantire il collegamento meccanico con il pezzo che deve muoversi.
Anche se ci sono servomotori a rotazione continua, la stragrande maggioranza dei modelli è in grado di
muovere il braccio solo di 180°.

Visto dall'interno, un servomotore è un po' più complesso di quanto appaia:

105
Arduino a scuola

Un piccolo motore a corrente continua è collegato a un potenziometro (resistenza variabile) tramite un

circuito elettronico che consente di controllare finemente il motore in base alla posizione del potenziometro.
Sull'asse di uscita del motore, una serie di ingranaggi consente di aumentare la sua coppia (la sua forza utile) in
riducendo la sua velocità di rotazione.
Quando il motore è in funzione, gli ingranaggi si animano, il braccio si muove e trascina nel suo movimento il
potenziometro. Se il movimento si ferma, il circuito elettronico regola continuamente la velocità del motore per
che il potenziometro e quindi per estensione il braccio del motore rimanga sempre nello stesso posto. È questo che
permette ad esempio a un braccio di un robot di non cadere sotto l'effetto del proprio peso quando il
il movimento si fermò!

Utilizzo di un servomotore con l'Arduino

Per comandare un servomotore, è necessario inviargli un treno di impulsi di cui il periodo (intervallo di tempo
tra ogni impulso) è sempre di 20 ms (millisecondi). Ciò che varierà e che alla fine determinerà la
la posizione del braccio non è il periodo, ma bensì la durata dell'impulso:

• per un impulso di 1 ms, il servomotore si posiziona a 0°

• per un impulso di 1,5 ms, il servomotore si posiziona a 90°
• per un impulso di 2 ms, il servomotore si posiziona a 180°

Questo schema ricorda il PWM che abbiamo utilizzato per variare l'intensità di un LED, ad esempio, il principio è
effettivamente molto simile, con un treno di onde rettangolari poiché i dati trasmessi sono digitali (ALTO
o LOW) senza valori intermedi.

La connessione di un servomotore non presenta difficoltà. Il filo rosso si collega all'alimentazione (5V), il filo
il nero si connette al ground (GND) e il filo giallo (attenzione a volte bianco o arancione o… a seconda del materiale)
non collegare il produttore cinese ?) a qualsiasi uscita digitale dell'Arduino (pin 0 a 13)

106
Arduino a scuola

Circuito 17

Codice 23: Far muovere il braccio di un servomotore nei due sensi

L'obiettivo dei tre codici qui sotto è quello di familiarizzarsi con l'uso dei servomotori.

Per i 3 codici, avremo bisogno della libreria Servo che fa parte di default del software Arduino, ma
qui non è installata per impostazione predefinita.

Menu :Croquis -> Inclure une bibliothèque -> Servo

Attenzione, affinché la libreria appena installata sia utilizzabile, è necessario chiudere e riavviare Arduino.

/*
Codice 23 - [Link], destinato all'Arduino
Obiettivo: Far muovere il braccio di un servomotore in una direzione e poi nell'altra, indefinitamente
*/

//*****TESTA DICHIARATIVA*****

#include <Servo.h> //includiamo la libreria per pilotare un servomotore

Servo monServo; //si crea l'oggetto monServo

void setup()
{
[Link](9); //si definisce il Pin utilizzato dal servomotore
}

void loop()
{
per (int posizione = 0; posizione <=180; posizione ++){ //creiamo una variabile posizione che
prendere valori tra 0 e 180 gradi
[Link](posizione); //il braccio del servomotore assume la posizione della variabile
posizione
107
Arduino a scuola

ritarda(15); //aspettiamo 15 millisecondi

}
per (int posizione = 180; posizione >= 0; posizione--) { //questa volta la variabile posizione
passa da 180 a 0°
[Link](posizione); //il braccio del servocomando prende la posizione della variabile
posizione
ritarda(15); //il braccio del servomotore prende la posizione della variabile posizione
}
}

Una volta che il vostro codice è funzionante, non esitate a testare diversi tempi di attesa, di chiedere dei
percorso di 90° solo o altri valori, di variare il passo degli incrementi utilizzati, ad esempio di 5° in
5°, ecc.. E osserva ogni volta il nuovo risultato.

Abbiamo detto parlando dei servomotori che una volta raggiunta una posizione, il motore, grazie ai
informazioni, mantiene il braccio nella posizione richiesta fino a quando non riceve un nuovo ordine.
la funzione di mantenimento è fondamentale sia nella modellistica che nella robotica. Se un braccio robotico afferra
qualcosa ad esempio, non deve cadere semplicemente sotto l’effetto del peso del pezzo afferrato e del suo
braccia. Pertanto, il servomotore deve quindi continuare continuamente ad adattare la posizione da mantenere. Il piccolo
La variazione del codice di seguito ci dimostrerà da un lato che la posizione richiesta è mantenuta anche quando
on demande à l’Arduino d’effectuer une autre tâche (ici, allumer la diode 13) et vous pouvez aussi essayer de
gira il servo a mano (senza forzare!) per sentire la resistenza alla rotazione che esercita il servo che cerca di
mantenere la propria posizione.

Codice 24: Servomotore e gestione delle attività

/*
Codice 24 - [Link], destinato all'Arduino
Obiettivo: dimostrare che la libreria Servo consente al servomotore di agire e di mantenersi
in posizione anche quando l'Arduino esegue un'altra attività.
*/

//*****TESTA DICHIARATIVA*****

#include <Servo.h> //includiamo la libreria per controllare un servomotore

Servo monServo; //creiamo l'oggetto monServo

void setup()
{
[Link](9); //si definisce il Pin utilizzato dal servomotore
pinMode(13,OUTPUT); //il Pin13 è impostato in modalità OUTPUT
}

void loop()
{
[Link](0); // si dice all'oggetto di mettere il servo a 0°
diode13(); // chiamata alla funzione diode13 che è definita più in basso
[Link](180); // si dice all'oggetto di mettere il servo a 180°
diode13(); // appel de la fonction diode13
}
void diode13() //fare lampeggiare il diodo 13 15 volte
{
per (int t=0;t<15;t++) {
digitalWrite(13,HIGH);
ritarda(100);
digitalWrite(13,BASSO);
ritarda(100);
} }

A voi di variare anche gli angoli richiesti, il numero di lampeggiamenti del LED 13, il tempo
d'attesa…

108
Arduino a scuola

E per concludere con il controllo dei servomotori, ecco un codice che non manca di provocare il suo
piccolo effetto. Aggiungerai un potenziometro al tuo circuito ed è la posizione del potenziometro che
tournerez che servirà a posizionare il braccio del servomotore.

Per aiutarti, ecco il diagramma del montaggio:

Circuito 18

Codice 25: comandare un servomotore con un potenziometro

Questo codice molto semplice consente. Con un mapping, di collegare i 1024 passi di un potenziometro ai 180° di
rotazione di un servo.

/*
Codice 25 - [Link], destinato all'Arduino
Obiettivo: controllare un servomotore con un potenziometro
*/

//*****INTESTAZIONE DICHIARATIVA*****

#include <Servo.h> //includiamo la libreria per pilotare un servomotore

Servo monServo; //creiamo l'oggetto monServo
int pinmonServo=9; //definiamo il Pin9 collegato al comando del servomotore
int pinPotar=A0; //si definisce il Pin analogico A0 per la lettura del potenziometro

void setup()
{
[Link](pinmonServo); //associamo l'oggetto monServo al pin di comando
}

void loop()
{
int valeurPotar=analogRead(pinPotar); // on lit la valeur du potentiomètre
int angolo=map(valeurPotar, 0,1023,0,180); //si trasforma il valore analogico letto in valore
//l'angolo tra 0 e 180°
[Link](angle); //si posiziona il braccio del servomotore all'angolo
}

109
Arduino a scuola

Codice 26: Comandare due servomotori utilizzando un joystick

Ogni giocatore di videogiochi conosce il joystick, quest'interfaccia di comando. Si basa su un sistema di

coordinate su una scala X e Y. La posizione su ogni scala è
determinata da un potenziometro. Nel caso di Arduino, si decomporrà
ogni asse in 1024 passi. Quindi, lo zero, cioè la posizione centrale,
corrisponde a 512 sull'asse X e Y.

Applicando quanto abbiamo appreso con il codice 25, diventa possibile controllare due servomotori con
un joystick.

Per il cablaggio, un joystick ha un pin +5V (a volte annotato VCC) per l'alimentazione elettrica, un
brocheGND(terra), due brocheVRx e VRy, rispettivamente per la posizione dell'asse X e Y e infine un
brocheSW (a volte chiamata SEL). Quest'ultima corrisponde al pulsante, quando si preme su
joystick.

Circuito 19

110
Arduino a scuola

Il codice 26 non è altro che un adattamento del codice 25: si tratta di aggiungere un secondo servo.

/*
Codice 26 - [Link], destinato all'Arduino
Obiettivo: controllare due servomotori con un joystick
*/

//*****INTESTAZIONE DICHIARATIVA*****

#include <Servo.h> //includiamo la libreria per controllare un servomotore

Servo monServo1; //creiamo l'oggetto monServo1
Servo monServo2; //si crea l'oggetto monServo2
int pinmonServo1=8; //definiamo il pin 8 collegato al comando del servomotore
int pinmonServo2=9; //si definisce il pin 9 collegato al comando del servomotore
int AxeX=A0; //si definisce il pin analogico A0 per la lettura dell'asse X
int AxeY=A1; //si definisce il pin analogico A1 per la lettura dell'asse Y

void setup()
{
[Link](pinmonServo1); //colle l'oggetto monServo1 al pin pinmonServo1
[Link](pinmonServo2); //si associa l'oggetto monServo2 al pin pinmonServo2
}

void loop()
{
int valeurAxeX=analogRead(AxeX); // si legge il valore dell'asse X
int angleX=map(valeurAxeX, 0,1023,0,180); //si trasforma il valore analogico letto in valore
d'angolo tra 0 e 180°
[Link](angleX); //si porta il braccio del servomotore 1 alla posizione angolo
int valeurAxeY=analogRead(AxeY); // leggiamo il valore dell'asse Y
int angleY=map(valeurAxeY, 0,1023,0,180); //si trasforma il valore analogico letto in valore
d'angolo tra 0 e 180°
[Link](angleY); //mettiamo il braccio del servomotore 2 alla posizione angle
}

Vediamo ora un altro modo per ottenere lo stesso risultato. Qui, memorizziamo i valori inviati dal
joystick rispettivamente nelle variabili X e Y. Si utilizza quindi un calcolo per convertire il valore dei due
variabili in gradi, ossia 1024 passi in 180 gradi: 180/1024, che dà un valore di 0.1756° per passo.

/*
Codice 27 - [Link], destinato all'Arduino
Obiettivo: controllare due servomotori con un joystick
Ispirato da [Link]
*/

##includi <Servo.h> //Librerie e dichiarazione dei servomotori

Servo monservo1;
Servo monservo2;

int AxeY = 1; // Dichiarazione dei pin analogici utilizzati per collegare l'asse X e Y
int AxeX = 0;

void setup() {
[Link](9600);
pinMode(AxeX, INPUT); //Dichiarazione delle modalità dei pin in INPUT e la posizione dei servomotori
[Link](8);
pinMode(AxeY, INPUT);
[Link](9);

}
void loop() {
int X=analogRead(AxeX); //Si legge prima il valore analogico dal pin del X (0v-
5v)=>(0-1023)
X=X*0.1756; //si fa una calibrazione in base ai limiti del servo (0-1023)=>(0-180)
X=180-X;//Utilizziamo questo per cambiare il senso di orientamento del supporto
[Link](X); //Scriviamo il valore finale calibrato e orientato

111
Arduino a scuola

int Y=analogRead(AxeY);//Prima si legge il valore analogico dal pin del Y (0v-5v)=>(0-

1023)
Y=Y*0.1466; //facciamo una calibrazione secondo i limiti del servo (0-1023)=>(0-150)
[Link](Y);//Scriviamo il valore finale calibrato
} Y=Y*0.1466; //on fait une calibration suivant les limites du servo (0-1023)=>(0-150)
[Link](Y);//Si scrive il valore finale calibrato
}

Diventa quindi possibile comandare un braccio robotico di 4 servo con semplicemente due joystick. In
In questo caso, è necessario prevedere un'alimentazione esterna per i servomotori e non dimenticare di realizzare una messa a terra.
comune tra l'alimentazione, l'Arduino, i servomotori e i joystick.

Conclusione (provvisoria)

Conclusione provvisoria, poiché le possibilità di Arduino e dell'elettronica sono infinite. Man mano che
des desideri dei miei alunni, delle nostre scoperte e sperimentazioni, ma anche dei contributi dei lettori,
questo corso è costantemente aggiornato.

Questo corso è stato redatto da Frédéric Genevey, insegnante nelle Scuole Primarie e Secondarie di Ecublens.
Suisse,[Link]

112