Arduino la ș coală

[Link]
Surf pe valul Arduino ș i învaț ă bazele
de electronică ș i programare.

Frédéric Genevey. Ilustraț ii: Fanny Conus

info@[Link]
Editie februarie 2020 – V6.2
Arduino la școală

Despre acest curs

Acest curs este publicat pentru comunitatea Arduino de la [Link] prin intermediul site-ului său [Link] Este vorba despre
o resursă educațională liberă1, sursă deschisă, sub licența CC BY-NC-SA2Utilizarea gratuită a acestui curs
dans le cadre d’une formation payante est tolérée. Un avis à l'auteur est néanmoins bienvenu. Les écoles
școlile publice, liceele, gimnaziile, universitățile, asociațiile și FabLabs pot solicita gratuit
o versiune Word a acestui document, pentru a o adapta mai ușor nevoilor lor sau celor ale elevilor cu dislexie.

Acest curs poate serve ca bază pentru părinții care ar dori să descopere lumea Arduino și
electronica cu copiii lor. Dar, te rog: nu-i obliga pe copiii tăi să-l citească! Asta este treaba ta. Ai grijă
o abordare ludică și prin proiecte.

Istoricul acestui curs

J'ai commencé ce cours en même temps que j'ai commencé à utiliser l'Arduino avec mes élèves en 2012.
Anul acesta, am profitat de ocazie pentru a pirata bradul de Crăciun al directorului școlii 3. În primul rând destinat elevilor
d'une opțiune VSO de la școala vaudoisă, acest curs este acum adaptat pentru elevii unei OCOM MITICou
Tehnologie, începând cu ora 10.

Puteți trimite observațiile, ideile și corecturile dvs. la info@[Link].

Un mulț umesc special lui Sophie Caré ș i Jean-Pierre Dulex pentru revizuirea ș i testele efectuate cu aceș tia.
elevi, precum ș i la profesorul Jean-Daniel Nicoud.

Alya, mascota noastră, este o creaț ie a lui Fanny Conus.

Susț inerea creării acestui curs

Apreciați acest curs și ați dori să susțineți crearea și actualizările sale? Donațiile dumneavoastră sunt binevenite.
Vor fi folosiți pentru a finanța găzduirea site-urilor, precum și pentru achiziția de echipamente Arduino. În cele din urmă, ca acest curs
este o resursă educațională liberă, open source, veți contribui la menținerea gratuității acesteia.

Puteți face o donație prin PayPal sau printr-o carte de credit la această adresă: [Link]

1[Link]

2 [Link]
3 [Link]

2
Arduino la școală

Codurile utilizate în acest curs pot fi descărcate de la

adresa următoare:
[Link]

Instrucț iuni de siguranț ă

Electricitatea poate fi mortală! Pentru a evita orice risc, în special cu elevii, este bine să nu se lucreze
cu tensiune foarte joasă (TBT). Tensiunea de funcționare a Arduino-ului se situează în jur de 5 Volți.

Câteva reguli elementare de securitate

Nu conectați niciodată direct Arduino la rețeaua electrică (230 Volți alternativi).
Pentru alimentarea proiectelor, utilizați transformatoare care respectă normele de siguranță în vigoare.
Nu demontați aparatele electronice fără supraveghere. Anumite componente, cum ar fi
condensatori, pot elibera descărcări electrice mortale, chiar și atunci când nu sunt
conectați la sector.
Acest curs NU permite dobândirea competențelor și noțiunilor de securitate necesare pentru a lucra
cu sectorul (230 V), nici cu electricitatea auto (12V).

3
Arduino la școală

Table des matières

DESPRE ACEST CURS...................................................................................................................................................... 2
ISTORICUL ACESTUI CURS.............................................................................................................................................2
SUSTINEREA CREĂRII ACESTUI CURS..........................................................................................................................2
INSTRUCȚIUNI DE SIGURANȚĂ.................................................................................................................................................... 3

CÂTEVA REGULI ELEMENTARE DE SIGURANȚ Ă........................................................................................................3

TABELUL DE MATERII........................................................................................................................................................... 4
PREFAȚĂ
INTRODUCERE........................................................................................................................................................................ 8
REFERENCES..................................................................................................................................................................8
BIBLIOGRAFIE...............................................................................................................................................................9
CELE MAI BUNE CURSURI ONLINE.................................................................................................................................12
DESPRE SCHEMELOR ELECTRONICE.................................................................................................................13
MATERIAL NECESAR...................................................................................................................................................... 14
DESCOPERIREA PLATFORMEI ARDUINO

SCHEMA UNEI PLATINEARDUINOUNO........................................................................................................................16

LE MICROCONTROLEUR................................................................................................................................................16
ALIMENTAȚ IA
LA CONNECTIQUE
Explorarea pinilor Arduino.........................................................................................................................18
LA PLATINE D’EXPERIMENTATION (BREADBOARD).......................................................................................................19
SOFTWARE-UL ARDUINO IDE
Bază de electronică..................................................................................................................................... 21
REAMINTIRE MICĂ DESPRE ELECTRICITATE......................................................................................................................21
Câteva resurse pentru a înț elege electricitatea:.........................................................................................21
PROIECTUL 1: CIRCUITUL ELECTRIC
Lista componentelor............................................................................................................................................22
Observaț ii..................................................................................................................................................22
CIRCUITUL ELECTRIC
LES DIODES..................................................................................................................................................................24
REZISTENȚ ELE........................................................................................................................................................25
PROIECTUL 2: A FACE SĂ FLICKERE O LED
Lista componentelor............................................................................................................................................27
LE LOGICIELARDUINOIDE
Meniul
CODE1: A FACE LED-UL SĂ CLIPOCEASCĂ PE BROCHA 13..........................................................................................29
Observaț ii...........................................................................................................................................................29
Depanare
Introducere în cod..............................................................................................................................................30
Analiza codului 1.................................................................................................................................................32
Modificăm codul...................................................................................................................................................33
Sugestie:.....................................................................................................................................................................34
EXERICITIU: LANSAȚ I UNSOS........................................................................................................................................34
CODUL EXERCIȚ IILOR..........................................................................................................................................35
PROIECTUL 3: A FACE SĂ CLIPOCEASCĂ PATRU LED-URI................................................................................................................ 36
4
Arduino la școală

Lista componentelor............................................................................................................................................36
CODE2: A FACE SĂ CLIPOCLE 4 LED-uri.............................................................................................................................37
CODE3:REALIZAREA UNUI CHENILAR A4 LEDS............................................................................................................38
PROIECTUL 4: INTRODUCERE ÎN VARIABILE
O VARIABLE, CE ESTE?
Numele unei variabile...........................................................................................................................................39
Definirea unei variabile................................................................................................................................................39
DEFINIREA PIPELOR MICROCONTROLLER-ULUI..........................................................................................................41
PROIECTUL 5: SEMAFORII........................................................................................................................... 42
Lista componentelor............................................................................................................................................43
CODE4: SEMAFORUL
VARIANTE...................................................................................................................................................................45
Variante 1
Variantă 2
Variantă 3
PROIECTUL 6: INCREMENTAREA
LISTA COMPONENTELOR:.............................................................................................................................................46
Analiza codului.....................................................................................................................................................47
CODE6: REALIZEAZĂ UN CHENILLARD PE BROȘELE 10A13 CU UNFOR.........................................................48
Analiza codului.....................................................................................................................................................49
PROIECT 7: PWM, VARIAȚIA ÎN DULCEA A UNEI LED
CODE7: AGENȚIA VARIAȚIEI LUMINOSITĂȚII UNEI LED MODIFICÂND VALOAREA PWM................................................51
Analiza codului.....................................................................................................................................................51
CODE8: VARIAȚ I LUMINOSITATEA UNEI LED DE DULCEȚ E ..................................................................................... 51
Analiza codului.....................................................................................................................................................52
CODE9: ALTERNATIVĂ PENTRU A VARIA LUMINIOZITATEA UNEI LED....................................................................53
PROIECTUL 8: INFORMAȚIILE NUMERICALE

PROTEJAȚ I ARDUINO
REZISTENȚ A LA ÎNCLINARE/ ÎNCĂRCĂTOARE
Circuit cu o rezistenț ă pull-down.........................................................................................................54
Circuit cu o rezistenț ă pull-up.....................................................................................................................55
Rezistenț ă pull-down sau pull-up?
CIRCUIT6:MONTARE CU REZISTENȚ Ă PULL-DOWN(AMINTIRE CEL PUȚ IN)................................................................56
Lista componentelor:..........................................................................................................................................56
CODE10: APRINDEREA UNEI LED ÎN FUNCȚIE DE STAREA BUTONULUI DE APĂSARE.........................................................57
Analizăm codul:.................................................................................................................................................58
CODUL11: UN COD MAI ELEGANT.............................................................................................................................59
EXERCITII MICI: BUTON PUS SI LED CARE CLIPOCESCP...............................................60
LE BARGRAPHE.............................................................................................................................................................61
Lista componentelor............................................................................................................................................62
CODE12:BARAGRAPH
Video
Analiza codului:....................................................................................................................................................65
DEPARASITER CU AJUTORUL CONDENSATORILOR..............................................................................................................67
Ce este un condensator?
VARIANTA: LE BARGRAPHE A10 LEDS......................................................................................................................69
CODE13: BARGRAPHE A10 LEDS.........................................................................................................................69
VARIAȚ IE: Afiș aj digital.........................................................................................................................72
Identificarea poziț iei LED-urilor.................................................................................................................73
SYNTHESE:APPRENDRE A COMPTER...........................................................................................................................77
Obiectiv....................................................................................................................................................................77
Schema electronică a montajului.......................................................................................................................77
5
Arduino la școală

CODE15: ÎNVĂȚ ARE SĂ NUMERI.............................................................................................................................79

PROIECTUL 9: INPUȚII ANALOGICI.................................................................................................................................. 83

LA FOTORESISTENȚ Ă
CIRCUIT11: DIVIZOR DE TENSIUNE..............................................................................................................................84
Lista componentelor
CODE16:VALOARE DE PRAG.........................................................................................................................................85
CODE17:VARIATIE A LUMINOSITATII UNEI LED IN FUNCTIE DE LUMINA AMBIENTA.................................86
Analiza codului.....................................................................................................................................................87
CODE18: MAPARE DE DATE...............................................................................................................................87
PROIECTUL 10: POTENCIOMETRUL...................................................................................................................................... 89
CIRCUIT12: UTILIZAȚI POTENȚIOMETRUL PENTRU A VARIA LUMINOSITATEA UNEI LED....................................90
Lista componentelor............................................................................................................................................91
CIRCUIT13: UTILIZAȚI POTENȚIOMETRUL PENTRU A VARIA LUMINOSITATEA UNEI LED....................................91
CODE19: VARIAȚI LUMINOSITATEA LED-ului CU AJUTORUL UNUI POTENȚIOMETRU...........................................92
CIRCUIT14: ALIMENTAREA LED-URILOR UNUI BARGRAPHE CU AJUTORUL UNUI POTENTIOMETRU................................................93
Listă de componente............................................................................................................................................93
CODE20: Afișați valoarea unui potentiometru cu ajutorul unui graf de bare..................................................94
VARIANTE1: UTILIZARE UN BARGRAPHE CU 10 LED-uri
VARIANTE2: A UTILIZA UN AFFICHEUR LED 8 DIGITE.
PROIECTUL 11: CONSTRUIREA OREI METEOROLOGICE

CODE21: ACHIZIȚ IONAREA DATELOR DE LA SENZOR Ș I AFISAREA ACESTORA........................................................................100

Lista componentelor :.......................................................................................................................................102
CODE22: AFISAREA DATELOR PE ECRANUL LCD............................................................................................103
PROIECTUL 12 : UTILIZAREA UNUI SERVOMOTOR.....................................................................................................................105
CODE23: FĂRĂ A FACE BRATUL UNUI SERVOMOTOR SĂ SE MIȘTE ÎN AMBELE SENSURI......................................................107
CODE24: SERVOMOTOR Ș I GESTIONAREA SARCINILOR................................................................................................108
CODE25: COMANDAREA UNUI SERVOMOTOR CU UN POTENȚ IOMETRU...................................................................109
CODE26: COMANDAREA A DOUĂ SERVOMOTOARE CU AJUTORUL UNUI JOYSTICK.................................................................110
CONCLUSION (PROVISOIRE)..............................................................................................................................................112

6
Arduino la școală

Prefaț ă

Când Massimo Banzi și colegii săi de la Institutul de Design al Interacțiunii din Ivrea, Italia, au dezvoltat
Arduino, scopul era de a permite studenților să aibă la dispoziție o platformă care valorează prețul unei
pizza pentru a realiza proiecte interactive4.
Astfel, Arduino a fost conceput încă de la început cu un scop educațional, pentru a fi ieftin, având o mare
cantitate de intrări și ieșiri, compatibil Mac, Windows și Linux, programabil cu un limbaj foarte
simplu și open source. Aici doar avantaje pentru lumea școlară, în special pentru că Arduino
se situe la intersecția între informatică, electronică și munca manuală5.

Abordarea pedagogică a Arduino este specială. Nu este vorba de a aborda materia într-un mod
liniare, dar lucrând și „făcând din nimic”: conectăm, montăm și vedem ce iese. Este
o abordare prin practică și experimentare care se potrivește foarte bine elevilor, chiar și (și mai ales) celor puțini
scolari. Există bineînțeles un risc de a „arde” un Arduino; dar nu este decât echipament de 30 de franci, și nu
un computer la 1200 franci! Arduino este un instrument excelent pentru învățarea prin practică și pentru proiecte bazate pe proiect.
învăț are. O abordare prin teorie, chiar dacă rămâne posibilă, ar fi contraproductivă.

Cea mai bună dovadă că Arduino este perfect adaptat pentru elevi este că, în câteva lecții, ei sunt deja
pregătiți să realizați proiecte concrete.

Acest curs a fost gândit pentru elevi (și profesori) care nu au nicio noțiune în programare și în
electronică. În raport cu potențialul gigantic al Arduino, este deliberat limitat, dar se străduiește
de a fi progresiv și mai ales axat pe practică. Acest curs nu este conceput pentru a fi urmat într-un mod liniar.
De fapt, acesta serveș te drept cadru teoretic. După dobândirea bazelor, profesorul are toate motivele să lucreze în
proiect bazat pe acest curs.

Note: faites attention avec les copies chinoises d'Arduino. Les moins chères peuvent poser des problèmes
utilizarea destul de importantă (drivere necesare, cablare cu contacte false…).

Ilustraț ia 1 Diduino, compatibil Arduino, dezvoltat la Lausanne

Istoria Arduino:[Link]
4

5Referințe:[Link] și
[Link]
7
Arduino la școală

Introducere

Referinț e
Acest document este o compunere și o adaptare a textelor și exercițiilor, provenind din următoarele surse:

Surse principale:

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

Surse anexate:

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

Acest curs oferă doar o introducere în electronică. Un curs mult mai complet și foarte bine realizat este
disponibil aici:

[Link]

În plus, trebuie menționat excelentul wiki următor, care propune foarte multe experimente pe Arduino.
Ideal pentru lucrări practice sau pentru a organiza provocări pentru elevi:

[Link]

8
Arduino la școală

Bibliografie
Există numeroase cărți despre Arduino și despre electronică. Iată o selecție de cărți pe care le avem.
evaluați și selectați.

Notă: vă încurajăm să comandați aceste cărți de la librăria dumneavoastră. Dar dacă doriți să le
comandând de la Amazon, v-am fi recunoscători să folosiți linkurile sponsorizate de mai jos. Ele
îmi permit să câștig suficient pentru a comanda unul sau două cărți Arduino pe an.

Electronică:

L’électronique en pratique, de Charles Platt

ISBN: 978-2212135077

Abordarea pedagogică a acestei cărț i este învăț area prin practică.

Începem prin a experimenta ș i a descoperi, ș i abia apoi
vine teoria pentru a întări ș i a explica descoperirile. Asta face
deci o lucrare de referinț ă pentru învăț area electronicii la
ș coala; în special ca supliment la Arduino ș i Raspberry Pi. El
Este, aș adar, o carte excelentă pentru profesor.

Răsfoiește această carte pe [Link]

Comandă pe [Link]

Electronica pentru copii, de Øyvind Nydal Dahl

ISBN:978-2212118629

Este uneori dificil să abordăm ș i să în ț elegem no ț iunile

de electricitate ș i electronică elevilor. Acolo este că
Electronica pentru copii aduce o abordare
interesant: nu ne complicăm cu Arduino ș i programare.
Întregul primului terc din carte, adică partea 1, este dedicat
electricitatea. Într-un mod simplu ș i pedagogic, copilul înț elege acest lucru
ce este electricitatea. Partea a doua permite descoperirea
diverse componente electronice prin intermediul unor circuite mici, dintre care
anumiț i sunt sudati. În cele din urmă, a treia parte este o abordare a
lumea digitală, dar prin electronică. Ș i aceasta parte, ea este
genial! Abordăm circuitele logice, binairele...

Răsfoiește această carte pe [Link]

Comandă pe [Link]

9
Arduino la școală

Arduino:

Marele manual Arduino, de Erik Bartmann

ISBN: 978-2212137019

Această carte este cu siguranț ă una dintre cele mai bune pentru a începe cu Arduino. Ea
oferă o introducere rapidă în electronică ș i mai ales codul este foarte
bine explicat, îmbogă ț it cu scheme. Nu se limitează în sfâr ș it la
câteva noț iuni de bază, dar merge destul de departe.

Răsfoiește pe [Link]
Comandă pe [Link]

Démarrez cu Arduino – a 2-a ediț ie: Principii de bază ș i primii

montaje, de Massimo Banzi

ISBN: 978-2100701520

Massimo Banzi este unul dintre principalii creatori ai Arduino. Aș adar,

că îș i cunoaș te subiectul! Accentul acestei lucrări este pus pe o iniț iere
la programarea Arduino, mai mult decât pe electronică. A
consilier pentru toț i începătorii.

Comandă cartea de pe [Link]

La aventură cu Arduino – De la 10 ani, de Becky Stewart

ISBN: 978-2212143140

Subtitrarea; „de la 10 ani” implică faptul că această carte lipsește

complet țintă: blocuri mari de text, prezentare densă,
îngrijorătoare și puțin tristă, precum și de a fi nevoit să aștept pagina 41 înainte de
realizeaza-ti primul montaj (o rezistenta, un LED…
Acum, această carte are totuși anumite avantaje, pentru un
un profesor sau un părinte care va însoți copiii: exercițiile
sunt bine organizate, explicațiile sunt clare și simple de
a înțelege. Obiectivele sunt ambițioase, deoarece vom merge până la
abordarea registrelor cu decalaj și a servomotoarelor.

Comandă cartea pe [Link]

10
Arduino la școală

Programare cu Arduino învăț ându-ne distrându-ne pentru începători, de Olivier

Engler

ISBN: 978-2412023877

Toată lumea cunoaște seria de cărți Pentru începători. Numele

colectarea este înșelătoare; fiecare carte va studia un subiect în profunzime; dar se
îl va lua de mână pe cititor, pas cu pas.
Este indicat pe copertă: 20 de proiecte de realizat încă de la 10 ani.
Așadar? Ei bine, nu ne distrăm; iar la 10 ani, vom avea lucruri mai bune de făcut
Ce este să te scufunzi în această carte. Și totuși, rămâne una dintre
cele mai bune cărți pentru a descoperi lumea Arduino, dar cu destinația
tineri pasionați sau adulți care nu au nici o noțiune de
programare sau Arduino și care sunt interesați să descopere acest
lume... sau pentru a însoți un tânăr. De fapt, este o carte excelentă pentru
orice cadru didactic care nu are ani de programare în spate
lui/ea și care dorește să îi implice pe elevii săi în aventura Arduino. A
condiția de a accepta tutoiul în stil Ikea... și obsesiile
lingvistice ale autorului, care se străduiește à appelermikonun
microcontroler.
Primul montaj electronic intervine doar cu puțin înainte de pagină
100. Înainte de asta, există doar puțină practică. Vom fi pierdut toate cele
tineri cu mult înainte de asta. Dar atunci, ce se întâmplă în decursul celor 100
primele pagini? Ei bine, o prezentare, clară, didactică, de
l'Arduino, așa cum nu am mai văzut în alte cărți. Abordăm
chiar și limbajul de asamblare (pe scurt, dar discutăm despre)
de asemenea, un exemplu). Este și prima carte care prezintă
simplu și clar ceea ce este un microcontroler și la ce servește.
Fiecare element al plăcii Arduino Uno este astfel prezentat. Este
complet, simplu, ușor de înțeles.
Fiecare concept este astfel prezentat. Normal, într-un curs
Arduino, începem prin a face montaje pe pini
numeroase. Aici nu; începem cu pini analogici.
Uimitor. Răcoritor. Și nu atât de prost. Înțelegem cu toții o
variatia unei valori analogice.

Comandă cartea pe [Link]

50 de montaj pedagogic cu Arduino, de Alexis Dumont ș i

Benoit Yernaux

ISBN: 979-1027501441

Iată în sfârșit o carte destinat în mod explicit cadrelor didactice. Aici, nu este vorba de
teorie, dar imediat din practică. Așa cum sugerează titlul său,
cartea este un catalog de proiecte Arduino, întotdeauna mai complexe și
destinate clasei. Nu este vorba aici doar de a lucra la
programare, dar și utilizarea Arduino în matematică,
fizică, biologie... O bază bună pentru lucrări practice sau
proiecte ale elevilor. Această carte nu este destinată începătorilor în
lumea Arduino, ci mai degrabă profesorului, care având deja cunoștințe solide
baze, caută proiecte pentru elevii săi. Legătura cu diferitele
disciplinesle școlare este adevăratul plus al acestei cărți.

Comandă cartea pe [Link]

11
Arduino la școală

Sylvia prezintă: super proiecte Arduino, de Sylvia Todd

ISBN: 978-2412023891

Nu este comun ca o carte despre Arduino să fie scrisă de o tânără

domnișoară. Dar nu este orice domnișoară; ea este deja
o figură recunoscută în mișcarea maker. Această mică carte, foarte
colorat, superb ilustrat, se adresează clar copiilor; dar
adultii începători pe Arduino își vor găsi la fel de mult interes.
După cum indică titlul, nu este vorba despre a învăța să programezi pe
Arduino, dar mai aproape de a aborda această lume cu proiecte mici care, mină
de nimic, uneori merg destul de departe. O reușită.

Comandă cartea pe [Link]

Caiet de activităț i Arduino pentru copii: De la 8 ani, de Frédéric

Durere

ISBN: 978-2212675696

Este posibil să programezi Arduino cu ajutorul Scratch și al

software mBlock. Această carte este foarte clară și bine ilustrată. Ne ghidează la
travers de șapte munți pentru a ajunge la crearea unei mini-stații
vreme. Programarea se face prin Scratch, deci fără cod și totul
în franceză. Ideal deci pentru a permite tinerilor curioși să descopere
lumea Arduino.
Rămân totuși dubitativ în ceea ce privește montajul "pluviometru". Cu mine
experiență, voi încerca să evit să fac să coexiste apă cu
electronica și un calculator...

Comandă cartea pe [Link]

Celor mai bune cursuri online

[Link]
[Link]

12
Arduino la școală

Despre schemele electronice

Pentru a realiza schemele electrice, folosim următoarele instrumente, disponibile gratuit pe Mac
et PC:

Fritzing: [Link]
Rezolvă Elec: [Link]
Fido Cadj: [Link]
QElectroTech[Link]
iCircuit[Link]

Există, de asemenea, o soluție foarte elegantă online6Ce site permite crearea de

scheme-uri electronice precum și realizarea circuitelor electronice.

Un simulator Arduino este, de asemenea, disponibil la această adresă: [Link] Acesta permite
realizarea schemelor de amplasare a componentelor pe plăcile de experimentare, la fel ca
Fritzing, dar și realizarea de scheme și circuite electronice.

Ilustrarea 2 Simulător Arduino de Tinkercad

6Aceasta va fi soluț ia utilizată în principal în acest curs. Pentru mai multe informaț ii: [Link]
13
Arduino la școală

Material necesar

Iată lista minimă a echipamentului necesar pentru a urma acest curs:

O placă Arduino sau compatibilă cu Arduino

O placă de experimentare (breadboard)
Cabluri de legătură (jumperi)
6 LED-uri roșii
2 LED-uri verzi
2 LED-uri galbene sau portocalii
1 LED RGB anodă sau catod comun
10 rezistențe de 220 la 470Ω
2 rezistențe de 1 la 10kΩ
2 condensatori 10nF
2 butoane de apăsare
1 fotorezistență
1 bargraphe 10 LED-uri*
1 multimètre
1 potentiometru (rezistență variabilă) de 10 sau 20kΩ
1 servo
1 joystick*

Pentru a putea merge mai departe, iată componentele necesare:

Senzor de temperatură și umiditate DHT11

1 ecran LED 2x12

(opțional)

Notă: această listă va evolua odată cu cursul

14
Arduino la școală

Descoperirea platformei Arduino

Arduino face parte din familia plăcilor de dezvoltare. Spre deosebire de Raspberry Pi7, el nu deține
nu există un OS bazat pe Linux. Prin urmare, este necesar un computer. Totuși, rămâne unul dintre cele mai accesibile și
des dintre cele mai răspândite. O placă de dezvoltare este, în general, unCircuit imprimat echipat cu un
microprocesor sau microcontroler. Deoarece Arduino este open source, există un număr mare de
clone și plăci compatibile, la fel cum există numeroase modele oficiale de Arduino, cu
funcții particulare:

Ilustraț ia 3 Diferite modele Arduino

Pentru acest curs, ne vom baza pe cel mai cunoscut: Arduino Uno. Dar un alt model sau un clon va fi suficient.
de asemenea afacerea.

7[Link]

15
Arduino la școală

Schema unei plăci Arduino Uno

Microcontrolerul
Este creierul hărții noastre. Conține:

• Un procesor pentru a prelucra datele și

a face calcule
• Un spațiu de stocare a datelor
• Porturi pentru a comunica (pinii)

El va primi programul pe care îl vom crea și

îi va stoca în memoria sa înainte de a-l executa.
Grație acestui program, el va ști să facă lucruri,
care pot fi: a face o LED să clipească, a afișa
caractere pe un ecran, trimite date către un
calculator, a porni sau a opri un motor...

Există două modele de Arduino Uno: unul cu un

microcontroler de mari dimensiuni, și unul cu un
microcontroler zis SMD (SMD: Montat pe suprafață
Dispozitiv, adică componente montate pe suprafaț ă, în
opozitie la componentele care traversează harta
electronică și care sunt sudate pe partea opusă). Dintr-
din punct de vedere al utilizării, nu există nicio diferență între
cele două tipuri de microcontrolere.
Ilustraț ie 4: un procesor ATmega328 la microscop

16
Arduino la şcoală

Arduino Uno Arduino Uno SMD

Când observi o placă Arduino Uno la raze X, poți constata că marea cip conține de fapt
o mică cip, ca cea din versiunea SMD. Observați și pistele care leagă pinii la
microcontrôleur:

Mathew Schwartz

17
Arduino la școală

Alimentaț ia
Pentru a funcționa, o placă Arduino are nevoie de o alimentare. Microcontrolerul funcționează la 5V,
cartea poate fi alimentată direct cu 5V prin portul USB sau printr-o alimentare externă care este
cuprinde între 7V și 12V. Un regulator se ocupă apoi de reducerea tensiunii la 5V pentru buna
funcționarea hărții.

Atenț ie: hărț ile Arduino Due ainsi que d'autres cartes récentes funcț ionează cu un
tensiune de 3.3V la nivelul ieș irilor! Tensiunea de alimentare este similară cu cea a Arduino
Uno. În acest curs, plecăm de la principiul că tensiunea montajelor este de 5 Volț i.

La conectivitate
În afară de un LED conectat la pinul 13, placa Arduino nu
nu deține componente (rezistențe, diode,
motoare...) care pot fi folosite pentru un program. El
este necesar să le adăugăm. Dar pentru asta, trebuie să le ...
conectează-te la card. Acolo intervin
conectori, de asemenea numiți pini.

Pe plăcile Arduino și pe multe plăci compatibile

Arduino, pini se află în același loc. Aceasta
permet fixarea unor plăci de extensie, numite shield-uri
împilându-le.

Explorarea piniilor Arduino

0 la 13 Intrări/ieșiri digitale
A0 la A5 Intrări/ieșiri analogice
GND Pământ sau masă (0V)
5V Alimentare +5V
3.3V Alimentare +3.3V
Vin Alimentare nesolidă (= aceeași tensiune ca cea de la intrarea plăcii)

Conexiunile între componente sunt realizate prin jumperi, o tipologie de cabluri mici.

18
Arduino la școală

Placa de experimentare (breadboard)

O placă de experimentare (numită breadboard) permite realizarea de prototipuri de montaje
electronice fără sudură și, prin urmare, de a putea reutiliza componentele.

Toți conectorii dintr-un rând de 5 sunt conectați între ei. Deci, dacă conectăm două elemente într-un
grup de cinci conectori, aceștia vor fi conectați între ei. La fel este și în cazul alinierilor de conectori
roșii (pentru alimentație) și albaștri (pentru pământ). Astfel, legăturile pot fi schițate astfel:

Rândurile lungi sunt folosite pentru a conecta masa (GND), în albastru ș i +5V, în roș u

Conectorii sunt conectaț i electric între ei prin 5

Nu există legătură electrică prin linia de separare

Toț i conectorii unei linii exterioare sunt conectaț i electric între ei

Les composants doivent ainsi être placés à cheval sur des connecteurs qui n'ont pas de liens électriques entre
ei, ca în schema alăturată.

19
Arduino în școală

Software-ul Arduino IDE

Software-ul Arduino IDE funcționează pe Mac, Windows și Linux. Datorită acestui software, vom crea,
testează și trimite programele pe Arduino.

IDE-ul este descărcabil la următoarea adresă: [Link]

O versiune online a editorului de cod este disponibilă la această adresă: [Link]

20
Arduino la școală

Bazele electronicii
Memento despre electricitate
Electricitatea (sau, mai precis, curentul electric) este o deplasare a electronilor într-un mediu.
conductor. Ne putem imagina acest lucru ca o deplasare a apei într-un conduct sau la un baraj
hidroelectrică.

Electronii ar fi apa
Generatorul ar fi rezervorul de apă
Conductorii sunt în mod natural conductele forțate
Consumatorul (o ampulă sau un LED, de exemplu) este turbinele, care exploatează energia din
deplasarea electronilor

Pe un baraj, cu cât diferența dintre altitudinea nivelului rezervorului și cea a turbinelor este mai mare,
cu atât mai mare va fi presiunea apei. Pentru un baraj, această diferență de altitudine se numește înălțime
cădere. Acesta este echivalentul pe un circuit electric al diferenței de potențial, care se măsoară în Volți (V) și se notează
U.
Debitul de apă (=cantitatea de apă care se scurge pe unitate de timp) corespunde intensităț ii, de asemenea numită
curent, care este deci debitul de electroni. Se măsoară în Amperi (A) ș i se notează I.
Puterea electrică se notează Pet și se măsoară în Watts (W). Aceasta exprimă cantitatea de curent (I),
transformată în căldură sau în mișcare. Pe un baraj, aceasta corespunde energiei produse de turbină.

Puterea P este produsul tensiunii V în volți și al intensității I în amperi.

!=#∙%
Pentru ca acești electroni să se miște toți în aceeași direcție, trebuie să existe o diferență în număr
electroane între cele două extremități ale circuitului electric.
Pentru a menține această diferență a numărului de electroni, se folosește un generator (baterie, acumulator,
alternator...)
Diferența de cantitate de electroni între două părți ale unui circuit se numește diferență de potențial.
se măsoară în Volți (V).

Câteva resurse pentru a înț elege electricitatea:

Nu e deloc complicat cu electricitatea: [Link]

Nu e magie despre transportul electricității: [Link]
Nu e magie despre baterii și acumulatori: [Link]
Site pedagogic despre electricitate Hydro-Québec:[Link]
Bătălia electricității
21
Arduino la școală

Proiectul 1: circuitul electric

Realizează circuitul următor:

Notă: culoarea firelor electrice contează puțin, la fel ca și poziția lor pe plăcile de experimentare.

Circuit 1

Lista componentelor

1 LED
1 rezistență de 220 la 470Ω
2 cabluri

Observaț ii

+5V Iată cum arată la nivelul schemei electrice.

REZISTENȚ Ă
220 Când conectezi Arduino la computer prin cablul USB, el
Există 50% ș anse ca LED-ul să se aprindă. Într-adevăr, dacă nu
nu se aprinde, trebuie să roti ț i LED-ul în cealaltă direc ț ie. Asta
particularitatea este că electricitatea poate trece prin ea doar în
D1 un sens.
LED

22
Arduino la școală

Circuitul electric
Pentru a avea un curent electric, avem nevoie de o sursă, de un receptor și de un drum.

Sursa furnizează forța care deplasează electronii: o baterie, un acumulator, un generator...

Recepția va utiliza forța de deplasare a electronilor: o bombă, un motor...
Lecheminconducteur permet aux électrons de se déplacer de la source au récepteur: souvent il s'agit de
fiu de cupru.

Împreună, ei formează un circuit electric. Asta a fost realizat în timpul exercițiului: ai conectat o sursă
electrons la pământ. Aceasta a creat o tensiune și, prin urmare, un curent electric: electronii s-au deplasat.
Deplasarea lor a permis astfel LED-ului să se aprindă. Arduino-ul servește doar ca sursă de alimentare electrică, cum ar fi
o pilă.

O baterie este alcătuită dintr-un mediu care conține numeroși electroni în exces și dintr-un al doilea mediu în lipsă.
d'electroane. Când conectăm cele două poli ale acumulatorului (plusul și minusul) cu un fir electric (conductorul), electronii
electronii se vor deplasa astfel din mediul bogat în electroni către mediul sărăcit. Dacă plasăm o lampă
electric între cele două, trecerea electronilor va genera lumină.

Circuit electric

Iată schema electrică a circuitului de mai sus:

Comutator
S1

Ampulă L1 V1 Grămadă
5

Când întrerupătorul este activat, se spune că circuitul este închis. Electronii se vor mișca apoi și
energia acestei deplasări poate fi exploatată pentru a aprinde o lampă sau a pune în funcțiune un motor, prin
exemple.

Când întrerupătorul este declanșat, se spune că circuitul este deschis. Polul pozitiv nefiind astfel conectat la
polul negativ, electronii nu se mai pot deplasa.

23
Arduino la școală

Diodele
L-am văzut: curentul electric se deplasează într-o direcție; are o direcție de deplasare. Este posibil să
înlocuiți becul cu un diodă electroluminescentă, numită și [Link] are particularitatea de a nu
lasă curentul electric să treacă doar într-o singură direcț ie.

Curentul electric poate trece prin diodă doar în sensul anodului către catod.

Se recunoaște anodul, deoarece este pinul cel mai lung. Când cele două pini sunt
De aceeași lungime, putem distinge anodul de catod printr-un plat din partea de
aceasta din urmă. Simbolul LED-ului este următorul:

Atenție: curentul produs de Arduino este prea mare pentru a conecta direct o LED la acesta.
Utilizarea unei rezistenț e este obligatorie, pentru a nu arde LED-ul.

Folosind diverse materiale semiconductoare, se schimbă culoarea luminii emise de LED.

există în sfârșit o mare varietate de forme de LED-uri.

8[Link]

24
Arduino la școală

Rezistenț ele

Unerésistance este un component electronic sau electric de care principalul

caracteristica este de a opune o rezistență mai mare sau mai mică (măsurată în ohmi:
Ω) la circulația curentului electric.

Atunci putem compara, debitul de apă cu curentul electric I (care este de altfel debitul
d'electrons), diferenta de presiune la diferenta de potential electric (care este
tensiuneU) și, în final, îngustarea la rezistențaR.

Astfel, pentru o tensiune fixă, cu cât rezistența este mai mică, cu atât curentul care o traversează este mai mare. Această proporție
este verificată de legea lui Ohm:

& &
& = ' ∙ % )* +,-. ' = )* % =
% '
O rezistență este un mediu puțin conductor; electronii se chinuie să se deplaseze prin ea. Energia lor
se disipă astfel în general sub formă de căldură. Acest principiu este folosit pentru ceainice.
electronice sau becurile cu filament.

Valoarea unei rezistențe se măsoară în Ohmi (Ω). Valoarea unei rezistențe este determinată de
benzi de culori.

Este de asemenea posibil să folosești o rezistență ca reducător de tensiune. Este suficient de fapt să recuperezi o
sursă de curent electric înainte și după rezistență.

25
Arduino la școală

Pe lângă tabelul de mai sus, ne putem ajuta de micile instrucțiuni care se află aici:
[Link]

Rezistența este schițată în aceste două moduri (europene în stânga și americane în dreapta):

Un calculator de valori ale rezistențelor este disponibil la această adresă: [Link]

26
Arduino la școală

Proiectul 2: a face un LED să pâlpâie

Ca prim program, vom face să clipocescă un LED D1, conectat la pinul 13. Iată
schemă de cablare:

Circuit 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

Lista componentelor

1 Led
1 rezistență de 220 la 470Ω
2 cabluri

27
Arduino la școală

Software-ul Arduino IDE

Programarea se face în software-ul Arduino IDE:

Menu

Fereastră de programare

Fereastra de control

Meniul

Butonul 1: Acest buton permite verificarea programului, el activează un modul care caută erorile.
în program
Buton 2: Trimiterea programului pe Arduino
Buton 3 : Crează un fișier nou
Buton 4 : Deschide un fișier existent
Buton 5: Salvează un fișier

Să începem imediat cu un mic cod. Apoi îl vom analiza.

Odată ce codul este scris (sau lipit) în fereastra de programare, trebuie să fie trimis pe Arduino. Pentru aceasta,
după ce ați conectat Arduino la computer, trebuie să selectați portul (tty_usbmodemXXXXX) și tipul de
carte (Arduino Uno, în cazul nostru). Aceste două setări se află în meniul Instrumente.

Faceți clic în cele din urmă pe butonul de încărcare (upload).

28
Arduino la școală

Cod 1: a face să clipească un LED pe pinul 13

/*
Cod 1 - [Link], destinat Arduino-ului
Obiectiv: a face LED-ul să clipească pe pinul 13
*/

//***** FUNC Ț IA SETUP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i o singură dată, la pornirea programului

void setup() // începutul func ț iei setup()

{
pinMode(13, OUTPUT); // Ini ț ializează broasca 13 ca ie ș ire
[Link](9600); Deschide portul serial la 9600 bps
} // sfâr ș itul func ț iei setup()

//***** FUNC Ț IE LOOP = Buclă fără sfâr ș it = inima programului *****

// func ț ia loop() se execută fără sfâr ș it în buclă atât timp cât Arduino este sub
tensiune

void loop() // începutul func ț iei loop()

{
digitalWrite(13, HIGH); // Pune ț i pe broche 13 la nivel înalt = porni ț i LED-ul
întârziere(500); // Pauză de 500ms
digitalWrite(13, LOW); // Pune ț i pe pinul 13 în pozi ț ia de jos = stinge ț i LED-ul
întârziere(500); // Pauză 500ms
} // sfâr ș itul func ț iei loop()

Observations

Acest cod permite să clipească LED-ul D1 situat pe pinul 13. Un LED, sudat pe Arduino și conectat
la broche 13 clipește de asemenea. Rezistenta R1 de 220Ω servește pentru a reduce tensiunea și a evita ca LED-ul să
grătar.

Depistare erori

Există numeroase erori posibile într-un program Arduino. Citirea și înțelegerea acestor
erorile în Arduino IDE nu sunt evidente. Vei găsi sfaturi prețioase aici:

[Link]

29
Arduino la școală

Introducere în cod

Derularea programului

Programul se desfășoară în următorul mod :

1. Luarea în considerare a instrucțiunilor din partea declarativă

2. Executarea părții de configurare (funcția setup())
3. Execuția buclei infinite (funcția loop ( )): codul inclus în bucla infinită este executat
în mod indefinit.

Vom vedea treptat diversele elemente prezente în schemă. Importantul pentru moment este să
a ști că un program este împărțit în trei părți: antet declarativ, funcția setup și funcția loop.

Următoarea suită ne va permite să intrăm în codul minim: funcțiile setup și loop.

Codul minim

Cu Arduino, trebuie să folosim un cod minimal atunci când creăm un program. Acest cod permite să împărțim
programul în două părți.

void setup()
{
}

void loop()
{
}

Așadar, avem în fața noastră codul minim pe care trebuie să-l inserăm în programul nostru. Dar ce ar putea fi acesta?
ce înseamnă pentru cineva care nu a programat niciodată?

30
Arduino la școală

Funcț ia

În codul 1, se află două funcții. Funcțiile sunt de fapt porțiuni de cod.

Prima funcț ie:

void setup()
{
}

Cette fonctionsetup()est appeléeune seule foislorsque le programme commence. C'est pourquoi c'est dans
această funcție pe care o vom scrie codul care nu trebuie să fie executat decât o singură dată. O numim această
fonction : "fonction d'initialisation". On y retrouvera la mise en place des différentes sorties et quelques autres
setări.

Odată ce am inițializat programul, trebuie apoi să creăm „inima” sa, în alte cuvinte, programul în sine
la fel.

A doua funcț ie:

void loop()
{
}

Așadar, în această funcție loop() vom scrie conținutul programului. Este important de știut că această
funcția este apelată în permanență, adică este executată o dată, apoi când execuția ei este
terminată, o reexecutăm, din nou și din nou. Vorbim despre bucla infinită.

Instrucț iunile

Acum că am văzut structura funcțiilor, să vedem ce pot conține acestea.

Instrucțiunile sunt linii de cod care spun programului: "fă asta, fă aceea..." Așadar, acestea sunt
ordine care vor fi executate de Arduino. Este foarte important să respectați exact sintaxa; altfel de
Ce, codul nu va putea fi executat.

Punctele ș i punctele;

Punctele virgule termină instrucț iunile. Dacă, de exemplu, spunem în programul nostru: "apelează la
funcția mâncaPisica", trebuie să punem un punct și virgulă după apelul acestei funcții.

Când codul nu funcționează, de obicei este pentru că lipsește un punct și virgulă. Așadar, trebuie să fii foarte
atent să nu-i uiți!

Acolele { }

Accesoriile sunt 'recipientele' codului programului. Ele sunt specifice funcțiilor, condițiilor
și buclele. Instrucțiunile programului sunt scrise în interiorul acestor acolade.
Pentru a deschide o acoladă pe Mac, apasă alt-8 ș i alt-9 pentru a o închide.

Comentariile

Comentariile sunt linii de cod care vor fi ignorate de program. Ele nu servesc la nimic.
în timpul execuției programului. Ele permit adnotarea și comentarea programului.

Linie unică de comentariu :

31
Arduino la școală

//această linie este un comentariu pe O SINGURĂ linie

Linie sau paragraf pe mai multe linii :

/*această linie este un comentariu, pe MAI MULTE linii */

care va fi ignorat de program, dar nu de cel care cite ș te codul ;) */

Accentele

Este interzis în mod formal să se folosească diacritice în programare! Cu excepția comentariilor...

Analiza codului 1

Revenim acum la codul nostru.

Linia pinMode(13, OUTPUT); initializează pinul 13 al microcontrolerului ca ieșire, adică că

datele vor fi trimise de la microcontroler către această broșă (vom trimite electricitate).

La ligne [Link](9600); inițiază portul serial care permite Arduino-ului să trimită și să primească date.
informații către computer. Este recomandat, dar funcționează și fără.

Cu instrucțiunea digitalWrite(13, HIGH);, microcontrolerul conectează pinul D13 la +5V.

efectul de aprindere a LED-ului (electricitatea iese din pinul D13).

Instrucțiunea delay(500); indică microcontrolerului să nu facă nimic timp de 500 de milisecunde, adică ½
secunde.

Cu instrucțiunea digitalWrite(13, LOW);, microcontrolerul conectează pinul D13 la masă (Gnd) acest
care are efectul de a stinge LED-ul (oprim alimentarea cu electricitate).

L'instructiondelay(500);indique au microcontrôleur à nouveau de ne rien faire pendant 500ms soit½

secunde.

Rezultatul este deci că LED-ul se aprinde timp de ½ secundă, apoi se stinge timp de o ½ secundă, după care
se aprinde timp de o jumătate de secundă... ea clipește deci.

32
Arduino la școală

Profităm acum pentru a vedea ce înseamnă termenul Output. Este vorba de a preciza dacă pinul este o intrare
sau o ieșire. De fapt, microcontrolerul are capacitatea de a folosi anumite pinii ca intrare (INPUT)
sau în ieșire (OUTPUT). Este suficient să schimbi o linie de cod pentru a spune că trebuie să folosești o
broșă la intrare (recuperarea datelor) sau la ieșire (trimiterea datelor).

Această linie de cod trebuie să se afle în funcția setup(). Funcția este pinMode(), ca în exemplu
mai jos:

void setup()
{
pinMode(13, OUTPUT);
Serial începe(9600);
}

Modifions le code

Să variem valorile instrucțiunii de întârziere și să modificăm codul conform exemplelor de mai jos.

Eseu 1:

digitalWrite(13, ÎNALT);
întârzie(50);
digitalWrite(13, LOW);
întârziere(50);

Eseu 2:

scrieDigital(13, ÎNALT);
întârziere(500);
digitalWrite(13, LOW);
intârziere(2000);

Eseu 3:

digitalWrite(13, ÎNALT);
întârziere(50);
digitalWrite(13, LOW);
întârziere(50);
digitalWrite(13, ÎNALT);
întârziere(1000);
digitalWrite(13, LOW);
întârziere(1000);

33
Arduino la școală

Sfat:

Cum există deja o rezistență și un LED lipit la Arduino și conectat la pinul 13, este
posibil să instalați direct un LED între pin și masă (GND).

Exerciț iu: a lansa un SOS

În codul Morse, literele sunt codificate cu ajutorul unei
succesiune de impulsuri scurte și lungi. Se utilizează
cod morse pentru a transmite un SOS, de exemplu sub
forme de semnale luminoase cu o lanternă.

Exercițiul constă în a programa Arduino și LED-ul său pentru a

transmite un semnal SOS luminos.
rezemune un SOS în morse:

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

Atenție: nu există spațiu între literele unui

SOS.

Un videoclip cu rezultatul este vizibil aici:

[Link]

34
Arduino la școală

Codul exerciț iului SOS

/*
Exerci ț iu Cod SOS - [Link], destinat Arduino
Obiectiv: a face LED-ul montat pe pinul 13 să clipească pentru a lansa un SOS
*/

//***** FUNC Ț IA SETUP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i o singură dată, la pornirea programului

void setup() // începutul func ț iei setup()

{
pinMode(13, OUTPUT); // Initializează bro ș a 13 ca ie ș ire
[Link](9600); Deschide portul serial la 9600 bauds
} // sfâr ș itul func ț iei setup()

//***** FUNC Ț IA LOOP = Buclă infinită = inima programului *****

// func ț ia loop() se execută fără sfâr ș it în buclă atâta timp cât Arduino este sub
tensiune

void loop() // începutul func ț iei loop()

{
digitalWrite(13, ÎNALT); // Pune bro ș a 13 la nivel înalt = aprinde LED-ul
întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i bro ș a 13 la nivelul de jos = opri ț i LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, ÎNALT); // Pune bro ș a 13 la nivel înalt = aprinde LED-ul

întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i bro ș a 13 la nivelul inferior = stinge ț i LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, HIGH); // Met la broche 13 au niveau haut = allume la LED

întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i pinul 13 la nivelul scăzut = stinge LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, ÎNALT); // Pune ț i bro ș a 13 la nivelul superior = aprinde LED-ul

aș teaptă(600); // Pauză de 600ms
digitalWrite(13, LOW); // Pune bro ș ca 13 la nivelul de jos = stinge LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, HIGH); // Pune bro ș a 13 la nivel înalt = aprinde LED-ul

întârziere(600); // Pauză de 600ms
digitalWrite(13, LOW); // Pune bro ș a 13 pe nivelul jos = stinge LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, HIGH); // Pune pe broche 13 la nivel înalt = aprinde LED-ul

întârziere(600); // Pauză de 600ms
digitalWrite(13, LOW); // Pune ț i pe bro ș a 13 la nivelul de jos = stinge ț i LED-ul
întârziere(200); // Pauză 200 ms

digitalWrite(13, HIGH); // Pune bro ș a 13 la nivelul superior = aprinde LED-ul

întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i bro ș ura 13 la nivelul inferior = stinge ț i LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, ÎNALT); // Pune bro ș a 13 la nivel înalt = aprinde LED-ul

întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i pinul 13 pe nivelul scăzut = stinge ț i LED-ul
întârziere(200); // Pauză 200ms

digitalWrite(13, HIGH); // Pune ț i cu bro ș a 13 la nivel înalt = aprinde LED-ul

întârziere(200); // Pauză de 200ms
digitalWrite(13, LOW); // Pune ț i bro ș a 13 la nivelul jos = stinge ț i LED-ul
întârziere(1000); // Pauză 1000ms
} // sfâr ș itul func ț iei loop()
35
Arduino la școală

Proiectul 3: a face să clipească patru LED-uri

Iată montajul de realizat. LED-urile sunt conectate la pinii 10 până la 13.

Circuit 3

U1
ARDUINO

D1
R1 LED
AREF 220
Pământ
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

Lista componentelor
4 LED-uri
4 rezistenţe de 220 la 470Ω
6 cabluri

36
Arduino la școală

Cod 2: a face să clipească 4 LED-uri

Acest cod face ca cele 4 LED-uri să clipească simultan.

/*
Cod 2 - [Link], destinat pentru Arduino
Obiectiv: a face să clipoce cele 4 LED-uri montate pe pini 10 până la 13
*/

//***** FUNCTIA SETUP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i o singură dată, la pornirea programului

void setup() // începutul func ț iei setup()

pinMode(10, IE Ș IRE); // Initializează bro ș a 10 ca ie ș ire

pinMode(11, OUTPUT); // Initializa ț i pinul 11 ca ie ș ire
pinMode(12, OUTPUT); // Initialize broche 12 as output
pinMode(13, OUTPUT); // Ini ț ializează pinul 13 ca ie ș ire

[Link](9600); // Deschide portul serial la 9600 bauds

} // sfâr ș itul func ț iei setup()

//***** FUNCTIE LOOP = Buclă fără sfâr ș it = inima programului *****

// func ț ia loop() se execută fără sfâr ș it în buclă atât timp cât Arduino-ul este sub
//tensiune

void loop() // începutul func ț iei loop()

digitalWrite(10, ÎNALT); // Pune pe bro ș a 10 la nivel înalt = aprinde LED-ul

digitalWrite(11, ÎNALT); // Pune ț i bro ș a 11 la nivelul superior = aprinde LED-ul
digitalWrite(12, HIGH); // Pune ț i pinul 12 la nivel înalt = aprinde LED-ul
digitalWrite(13, ALTA); // Pune bro ș a 13 la nivelul superior = aprinde LED-ul
delay(500); // Pauză de 500ms
digitalWrite(10, LOW); // Pune ț i broche 10 la nivelul de jos = stinge LED-ul
digitalWrite(11, LOW); // Pune ț i bro ș a 11 pe nivelul scăzut = stinge LED-ul
digitalWrite(12, LOW); // Pune brochea 12 pe nivelul scăzut = stinge LED-ul
digitalWrite(13, LOW); // Pune ț i pinul 13 la nivelul scăzut = stinge ț i LED-ul
întârziere(500); // Pauză 500ms

} // sfâr ș itul func ț iei loop()

37
Arduino la școală

Code 3: réaliser un chenillard à 4 LEDs.

Obiectivul este de a aprinde un LED după altul, conform tabelului următor:

Secven ț ă LED 1 LED 2 LED 3 LED 4

1 x
2 x
3 x
4 x

/*
Cod 3 - [Link], destinat pentru Arduino
Obiectiv: a face un chenillard cu 4 LED-uri montate pe pinii 10 până la 13
*/

void setup() // începutul func ț iei setup()

{
pinMode(10, OUTPUT); // Initializează bro ș a 10 ca ie ș ire
pinMode(11, IESIRE); // Initializeaza pinul 11 ca iesire
pinMode(12, OUTPUT); // Ini ț ializează pinul 12 ca ie ș ire
pinMode(13, OUTPUT); // Initialize pin 13 as output

[Link](9600); Deschide portul serial la 9600 bauds

} // sfâr ș itul func ț iei setup()

void buclă() // începutul func ț iei loop()

{
digitalWrite(10, ÎNALT); // Pune ț i bro ș a 10 la nivelul înalt = aprinde ț i LED-ul
digitalWrite(11, LOW); // Pune ț i la bro ș ura 11 la nivelul inferior = stinge ț i LED-ul
digitalWrite(12, LOW); // Pune bro ș a 12 pe nivel scăzut = stinge LED-ul
digitalWrite(13, LOW); // Pune ț i bro ș ura 13 la nivelul de jos = stinge ț i LED-ul

delay(100); // Pauză de 100ms

digitalWrite(10, LOW); // Pune bro ș ura 10 la nivelul scăzut = opre ș te LED-ul

digitalWrite(11, HIGH); // Pune pe broche 11 la nivel înalt = aprinde LED-ul

delay(100); // Pauză de 100ms

digitalWrite(11, jos); // Pune ț i pe pinul 11 la nivel scăzut = stinge ț i LED-ul

digitalWrite(12, ÎNALT); // Pune brochea 12 la nivel înalt = aprinde LED-ul

delay(100); // Pauză de 100ms

digitalWrite(12, LOW); // Pune ț i bro ș a 12 la nivelul de jos = stinge ț i LED-ul

digitalWrite(13, HIGH); // Pune bro ș a 13 la nivel înalt = aprinde LED-ul

delay(100); // Pauză de 100ms

digitalWrite(13, LOW); // Pune ț i bro ș a 13 la nivelul inferior = stinge ț i LED-ul

digitalWrite(12, HIGH); // Pune ț i piciorul 12 la nivel înalt = aprinde LED-ul

delay(100); // Pauză de 100ms

digitalWrite(12, LOW); // Pune ț i placa de bro ș ă 12 la nivelul de jos = stinge ț i LED-ul

digitalWrite(11, HIGH); // Pune bro ș a 11 pe nivel ridicat = aprinde LED-ul

delay(100); // Pauză de 100ms

} // sfâr ș itul func ț iei loop

38
Arduino la școală

Proiectul 4: introducerea în variabile

O variabilă, ce este aceasta?
Să presupunem un număr de care trebuie să ne amintim. Acest număr este stocat într-un spațiu de stocare
de la memorie RAM a microcontrolerului. Fiecare spațiu de stocare este identificat în mod unic.

Numărul stocat are particularitatea de a schimba valoarea. De fapt, variabila nu este decât un recipient. A ei
conținutul va putea fi modificat. Iar acest conteneur va fi stocat într-o zonă a memoriei. Dacă
materializează această explicație printr-un schemă, ar da:

nombre➞variable➞mémoire

simbolul "➞" semnifică: "este conținut în..."

Imaginăm că stocăm numărul într-un recipient (variabila). Fiecare recipient este, de asemenea, pus.
într-un spațiu bine definit, pentru a-l regăsi. Fiecare container (variabilă) este de asemenea identificat printr-un nume
unic.

Numele unei variabile

Numele variabilei acceptă doar alfabetul alfanumeric ([a-z], [A-Z], [0-9]) și _ (underscore). Este unic;
nu pot exista doua variabile cu acelasi nume.

Definirea unei variabile

Să ne imaginăm că dorim să stocăm numărul 4 într-o variabilă. Ar încăpea într-o cutie mică. Dar noi
ar putea fi stocat într-un mare container. Da... dar nu! Un microcontroler nu este un computer
3GHz multicore, 8Go de RAM! Aici, este vorba despre un sistem care funcționează cu un CPU la 16MHz (adică 0,016
GHz) și 2 Ko de SRAM pentru memoria volatila. Așadar, sunt cel puțin două motive pentru a alege variabilele sale de
mod rațional

1. RAM-ul nu este extensibil, când nu mai este, nu mai este! În același volum, se poate stoca
cu mult mai multe cutii mici decât containere mari. Așadar, trebuie să optimizăm spațiul.
39
Arduino la școală

2. Procesorul este de tip 8 biți (pe un Arduino UNO), astfel că este optimizat pentru a efectua prelucrări pe
Des variabile de dimensiune 8 biți, o procesare pe o variabilă de 32 biți va dura, prin urmare, (mult) mai mult timp.
Și dacă variabilele dimensiunii unui container sunt pe 32 de biți, la fel de bine putem lua o cutie care ocupă doar 8 biți
când variabila se potrivește înăuntru!

Tip de Tip de număr Valori maxime ale numărului stocat Număr pe X biț i Număr de octeț i
variabilă stocat

int întreg -32’768 la +32’767 16 biți 2 octeți

lung intreg -2’147’483’648 până la +2’147’483’647 32 de biți 4 octeți

caracter întreg -128 la +127 8 biți 1 octet

float zecimale -3.4 x 1038à +3.4 x 1038 32 de biți 4 octeți

dublu zecimale -3.4 x 1038 à +3,4 x 1038 32 de biți 4 octeți

Sa luam acum o variabila pe care o vom numi „x”. De exemplu, dacă variabila noastră „x” nu ia
pentru valori decimale, se vor folosi tipurile int, long sau char. Dacă acum variabila "x" nu depășește
pas la valeur 64 ou 87, alors on utilisera le typechar.

char x = 0;

Și, în schimb, dacă x = 260, atunci vom folosi tipul superior (care acceptă o cantitate mai mare de numere)
la cal, adică în mod diferit.

int x = 0;

Dacă în prezent variabila noastră "x" nu ia niciodată o valoare negativă (-20, -78, ...), atunci vom folosi un tip
nesemnat. Adică, în cazul nostru, unchar al cărui valoare nu mai este de -128 la +127, ci de 0 la 255.

Iată tabloul tipurilor nesemnate, recunoaștem aceste tipuri prin cuvântul unsigned (în engleză: nesemnat) care
le precede:

Type de variable Tip de număr Valori maxime ale numărului stocat Număr pe X biț i Număr de octeț i
stocat

unsigned char întreg non negativ 0 la 255 8 biți 1 octet

float nesemnat entier non négatif 0 la 65'535 16 biți 2 octeți

double fără semn număr întreg non negativ 0 la 4’294’967’295 32 biți 4 octeți

40
Arduino la școală

Definirea pinilor microcontrolerului

Până acum, am identificat pini microcontrolerului folosind numerele lor, cum ar fi
în exemplul următor: pinMode(13, OUTPUT);. Aceasta nu prezintă probleme când avem una sau două
LED-uri conectate. Dar de îndată ce avem montajuri mai complicate, devine dificil să știm cine face
Ce este. Este, deci, posibil să redenumești fiecare pin al microcontrolerului.

În primul rând, să definim pinul utilizat al microcontrolerului ca o variabilă.

const int led1 = 13;

Termenul const înseamnă că definim variabila ca fiind constantă. Prin urmare, schimbăm natura
de la variabilă care devine atunci constantă.
Termenul se referă la un tip de variabilă. Într-o variabilă de acest tip, se poate stoca un număr care variază.
de -2147483648 la +2147483647, ceea ce va fi suficient! Așadar, pinul 13 se va numi led1.

Nous sommes donc en présence d'une variable, nomméeled1, qui est en fait une constante, qui peut prendre
o valoare cuprinsă între -2147483648 și +2147483647. În cazul nostru, această constantă este atribuită numărului
13.
Concret, ce înseamnă ce? Să observăm diferența dintre cele două coduri.

Broș a nedefinită Broș ă definită

void setup() { const int led1= 13;
pinMode(13, IE Ș IRE); La broche 13 devine led1
// Ini ț ializează pinul 13 ca ie ș ire
[Link](9600); void setup() {
} pinMode(led1, OUTPUT);
// Ini ț ializează led1 ca pin de ie ș ire
void loop() { [Link](9600);
digitalWrite(13, HIGH); }
întârzie(500);
digitalWrite(13, LOW); void loop() {
întârziere(500); digitalWrite(led1, ÎNALT);
} întârziere(500);
digitalWrite(led1, LOW);
întârziere(500);
}

Se poate considera că definirea pinilor lungește codul. Dar când vom avea numeroase pinuri
în funcție, asta ne va permite să le identificăm mai ușor. Astfel, dacă avem mai multe LED-uri, noi
putem să le numim Led1, Led2, Led3,... și dacă folosim LED-uri de mai multe culori, vom putea
rosu, verde, albastru,...
În fine (și mai ales!), dacă dorim să schimbăm broșa utilizată, este suficient să corectăm variabila de la început, fără a fi nevoie
corectează tot codul.
La fel ca pentru variabile, putem da orice nume pinilor.

41
Arduino la școală

Proiectul 5: Semaforele
Pentru a pune în practică utilizarea variabilelor, iată un mic exercițiu. Ne putem baza pe codul 3 pentru
a începe.

Obiectivul acestui exercițiu este de a crea două semafoare și de a le face să funcționeze în mod sincron.

Iată etapele a două semafoare pe care trebuie să le recreezi:

Feu 1
etape 1 2 3 4

Feu 2
6 sec 2 sec 6 sec 2 sec

Pentru ajutor, un videoclip de prezentare este disponibil aici: [Link]

Circuit 4

42
Arduino la școală

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

Lista componentelor

2 LED-uri roșii
2 LED-uri galbene sau portocalii
2 LED-uri verzi
6 rezistențe de 220 la 470Ω

Pentru a facilita identificarea fiecărei LED, vom renumi pinii astfel:

Feu 1:

LED roșie conectată la pinul 4 și redenumită R1

LED galben conectată la pinul 5 și redenumită J1
LED verde conectată la pinul 6 și redenumită V1

Feu 2:

LED roșie conectată la pinul 8 și redenumită R2

LED galben conectată la pinul 9 și redenumită J2
LED verde conectată la pinul 10 și redenumită V2

În cele din urmă, vom folosi două variabile timer1 și timer2 pentru a defini timpii de aprindere. Înainte de a privi
codul de pe pagina următoare, încearcă să faci exercițiul singur.

Cod 4: semaforul
/*
Cod 4 - [Link], destinat Arduino-ului

43
Arduino la școală

Obiectiv: gestionarea semafoarelor

*/

// Definim variabilele pentru fiecare pin

//FEU 1
const int R1 = 4; La broche 4 devine lumina ro ș ie 1
const int J1 = 5; La broche 3 devine focul galben 1
const int V1 = 6; La broche 2 devine semaforul verde 1
//FEU2
const int R2 = 8; La broche 8 devine focul ro ș u 2
const int J2 = 9; La broche 9 devine focul galben 2
const int V2 = 10; La broche 10 devine semaforul verde 2
//TEMPS
int timer1 = 2000; //Le temps est fixé à 2 secondes
int timer2 = 6000; Timpul este stabilit la 6 secunde

void setup() {

Se initializează ie ș irile.
pinMode(R1, IESIRE);
pinMode(J1, IE Ș IRE);
setareMod(V1, IE Ș IRE);

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

void loop() {

//Faza 1: R1 ș i V2 sunt aprinse, R2, J1 ș i J2 sunt stinse

digitalWrite(R2, LOW); //R2 stins
digitalWrite(J1, LOW); //J1 stins
digitalWrite(J2, LOW); //J2 stins
digitalWrite(R1, HIGH); //R1 aprins
digitalWrite(V2, HIGH); //V2 allumé
întârziere(timer2); //durată: 6'000 de milisecunde, adică 6 secunde

//Faza 2: R1, J1, J2 aprinse ș i V2 stins

digitalWrite(V2, LOW); //V2 stins
digitalWrite(J1, ÎNALT); //J1 aprins
digitalWrite(J2, HIGH); //J2 alumat
întârziere(timer1); //durată: 2'000 milisecunde, adică 2 secunde

//Faza 3: R1, J1, J2 stinse ș i V1 ș i R2 aprinse

digitalWrite(R1, JOASĂ); //R1 stins
digitalWrite(J1, LOW); //J1 stins
digitalWrite(J2, LOW); //J2 stins
digitalWrite(V1, SUS); //V1 alumat
digitalWrite(R2, ÎNALT); //R2 aprins
întârzie(timer2);

//Faza 4: V1 stins ș i J1, J2 ș i R2 aprinse

digitalWrite(V1, LOW); //V1 stins
digitalWrite(J1, ÎNAL Ț A); //J1 aprins
digitalWrite(J2, HIGH); //J2 aprins
digitalWrite(R2, HIGH); //R2 aprins
întârziere(timer1);
}

44
Arduino la școală

Variante

Variantă 1

Există adesea un decalaj între trecerea unui semafor pe roșu și trecerea la verde a celuilalt semafor. Este în
în mod special cazul pentru focurile de șantier. Aceasta permite mașinilor încă angajate în zona de șantier
de la a ceda, înainte de a lăsa loc mașinilor care vin din față.

Descrieți etapele focurilor și programați-le pentru a lua în considerare întârzierea.

Variantă 2
Integrați un al treilea semafor, care trece de la roșu la verde în alternanță cu celelalte două semafoare.

Realizați schema electronică și programați luminile.

Variante 3
Realizarea semaforelor pentru o intersecție:

45
Arduino la școală

Proiectul 6: Incrementează
Este posibil să aplicăm asupra valorilor variabilelor diverse operații matematice. Să începem tot
de suite printr-un mic exemplu: incrementarea. Este vorba pur și simplu de a adăuga 1 variabilei. De fiecare dată
să repetăm codul, luăm valoarea variabilei și adăugăm 1.

Aceasta se face datorită acestui cod (variind o variabilă la alegere): var++;

var++; revine la a scrie : "var = var + 1;".

Circuitul va fi dintre cele mai clasice: ne vom relua chenillardul.

Circuit 5

U1
ARDUINO

D1
R1 LED
AREF 220
GND
D13
D12 D2
D11 R2 LED
RESETARE 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

Lista componentelor:
4 LED-uri roșii
4 rezistențe de 220 la 470Ω

46
Arduino la școală

Cod 5: a face LED-ul 13 să pâlpâie de 10 ori

/*
Cod 5 - [Link], destinat Arduino-ului
Objectif: faire clignoter 10 fois la LED montée sur le port 13
*/

//***** ANTET DECLARATIV *****

// Declaram variabilele, constantele...

byte contor; //Se define ș te variabila "compteur"

const int led1= 13; //On renomme la broche 10 en "led1"

//***** FUNC Ț IA SETUP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i o singură dată, la pornirea programului

void setup()

{
pinMode(led1, OUTPUT); // Ini ț ializează pinul 13 ca ie ș ire

[Link](9600); Deschide portul serial la 9600 bauds

Execută programul între acolade începând de la zero ș i incrementând de fiecare dată

//valoarea de +1: 0+1/2+1/3+1... până când variabila „compteur“ este egală cu 9 (plus //
// mic fiind 10).

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

{ // începutul programului executat de 10 ori

digitalWrite(led1, HIGH); // aprinde LED-ul
întârziere(500); // a ș teptaț i 500ms
digitalWrite(led1, LOW); // éteint la LED
întârziere(500); // a ș teptaț i 500ms
}
} // sfâr ș itul programului executat de 10 ori

void loop() {
} // video, programul deja executat în setup

Analiza codului9

Revenim la codul nostru și îl analizăm.

La ligne byte compteur; permite crearea unei variabile numite compteur. Byte indică tipul variabilei.
adică tipul de date pe care îl vom putea stoca în această variabilă. Așa cum am văzut deja,
tipul byte permite stocarea valorilor cuprinse între 0 și 255.

Linia const intled1= 13; permite crearea unei constante (o variabilă) numită led1 în care putem
stochează valoarea 13.

Linia for(compteur=0 ; compteur<10 ; compteur++) este folosită pentru a varia variabila compteur de la 0 la 9 (în
îl mărește de fiecare dată cu 1: asta face instrucțiunea compteur++)

Să privim această linie mai atent:

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

9Sursa: [Link]
47
Arduino la școală

Declarația forest este folosită de obicei pentru a repeta un bloc de instrucțiuni învăluite în paranteze. On
o folosesc adesea cu un contor incremental, care permite terminarea unui ciclu după un anumit număr
de fois.

La suite, adică: compteur=0; compteur<10; compteur++ trebuie înțeles astfel: „valoarea lui
variabila_compteur_este cuprinsă între 0 și 9 (<10 înseamnă „mai mic decât 10”) și adaugă unul la valoare de
compteur (este le compteur++)

În concluzie, această linie înseamnă:

«La început, variabila contor este egală cu zero. Vom executa codul în buclă. De fiecare dată,
se adaugă +1 la variabila ta numărătoare, până ajungem la 9. În acel moment, ne oprim.

Codul care este executat de fiecare dată este cel care este înțeles până la acoladă}. În cazul nostru, este e
codul următor care este executat de 10 ori:

digitalWrite(Led1, HIGH);
întârzie(500);
digitalWrite(Led1, LOW);
întârziere(500);

Iată părțile unei declarații pentru:

Declarația variabilei
(opțional)

Inițializare Testul condiției Incrementare/decrementare

pentru(int compteur=0;compteur<10;compteur++)
Inițializarea se efectuează mai întâi și o singură dată. La fiecare trecere prin buclă, condiția este
testată. Dacă este "adevărat", conținutul buclei forest este executat (de exemplu, a face o LED să lumineze), și
Incrementează variabila. Apoi, condiția este testată din nou. De îndată ce rezultatul testului
condiția este "fals", bucla se oprește

Cod 6: Realizaț i un chenillard pe pini 10 la 13 cu un unfor

Putem folosi fără probleme o incrementare și un for pentru a realiza pinMode-ul LED-urilor care se
urmează, de exemplu, pentru a realiza un chenillard:

/*
Cod 6 - [Link], destinat Arduino-ului
Obiectiv: a face un chenillard cu 4 LED-uri montate pe porturile 10 până la 13
*/

//***** ANTET DECLARATIV *****

// Defini ț ia variabilei "timp"

int timer = 100; // Durată, în milisecunde

//***** FUNC Ț IA SETUP = Cod de ini ț ializare *****

void setup() {

48
Arduino la școală

// Declara ț ia pinurilor 10 până la 13 folosind un for ș i un increment.

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

void loop() {
// bucla de la pini 10 la pini 13:

pentru (int thisPin = 10; thisPin < 14; thisPin++) { //Incrementând variabila
thisPin de 10 la 13
digitalWrite(thisPin, HIGH); Aprinde LED-ul
delay(timer); Durată
digitalWrite(thisPin, LOW); Opri ț i LED-ul
}

// bucla de la pinul 13 la pinul 10:

for (int thisPin = 13; thisPin >= 10; thisPin--) { //Décrément faisant passer la variable
această Pins de 13 la 10
digitalWrite(thisPin, HIGH); Aprinde LED-ul
intârzie(timer); Durată
digitalWrite(thisPin, LOW); //Oprirea LED-ului;
}
}

Analiza codului

Să ne uităm acum puțin la acest cod, în special:

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

Prima particularitate este modul în care se definesc pinii. În loc să acumulăm pinMode (xxx,
OUTPUT);, creăm o variabilă de tip int pe care o numim thisPin10și astfel valoarea inițială este de 10. Unfor
cu un increment (++) permite să se incrementeze valoarea variabilei de la 10 la 14. Apoi, este suficient să
înlocuiește în lepinModele numărul apropiat cu variabila thisPin. Astfel, pini 10, 11, 12, 13 și
14 sunt definite în output. Natural, acest lucru funcționează doar dacă pini utilizați sunt consecutivi (prin
exemple: 10, 11, 12, 13. Acesta nu va funcționa pentru pini 3, 5, 7, 8, 10).

Trecem acum la a doua parte:

pentru (int thisPin = 10; thisPin < 14; thisPin++) {

digitalWrite(thisPin, HIGH);
întârziere(timer);
digitalWrite(thisPin, LOW);
}

La fel ca pentru definirea pinilor în OUTPUT, se folosește funcția for pentru a incrementa variabila
Astfel, aprindem LED-urile conectate la pini de la 10 la 13 una după alta.

În sfârșit, în a treia parte a codului, vom aprinde LED-urile de la pinul 13 la pinul 10 cu o

fonctionforet o decremență. Pentru aceasta, se înlocuiește pe++cu un--.

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

digitalWrite(thisPin, HIGH);
întârziere(timer);
digitalWrite(thisPin, LOW);

10Dar am fi putut să o numim floare_mică...

49
Arduino la școală

Proiectul 7: PWM, variaț ie lină a unei LED-uri

Cel mai simplu mod de a varia luminozitatea unei LED-uri este de a varia curentul care o traversează.
Dar când este conectată la pinul unui Arduino, acest lucru nu este posibil: pinii 1 până la 13 sunt în
efecte numerice. Adică, ele au doar două stări: 0 sau 1; aprins sau stins. Așadar, pentru a varia
luminozitatea unei LED-uri, vom folosi o funcție numită PWM: Modulație în lățimea impulsului, adică modulație de
lățimea impulsurilor. Este vorba de a varia perioadele înalte (aprins) și joase (stins) ale pinilor la
frecvență mare. Astfel, în timpul unui ciclu de 25% în poziția înaltă și 75% în poziția joasă, LED-ul va fi mai puțin
briliantă care pentru un ciclu de 50%/50%.

În alte cuvinte, asta înseamnă că vom face LED-urile să clipească foarte repede; atât de repede încât ochiul nu va percepe
decât o lumină continuă. Dar cu cât se va mări durata perioadelor în care LED-ul este stins, cu atât va fi mai puț in
de lumină emisă; ș i astfel, mai puț in LED-ul va părea strălucitor.

Broșele capabile să suporte PWM sunt identificate printr-un "~". Acestea sunt broșele 3, 5, 6, 9, 10, 11.

Prin distincție, în loc să folosești instrucțiunea DigitalWrite, pentru a folosi PWM, folosești AnalogWrite.

Valoarea PWM se întinde pe 256 niveluri, de la 0 (=0%) la 255 (=100%). Astfel, se poate defini valoarea PWM.
dorit cu formula următoare:

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

50
Arduino la școală

Cod 7: a varia luminozitatea unei LED modificând valoarea PWM

/*
Cod 7 - [Link], destinat Arduino
Obiectiv: a face să varieze luminozitatea unui LED pe pinul 10 prin modificarea valorii PWM
*/

//***** ANTET DECLARATIV *****

int ledPin = 10; Renomim bro ș a 10 în "ledPin"

int timer = 100; Definim o durată de 0,1 secunde pentru variabila timer

//***** CONFIGURARE *****

void setup() {

pinMode(ledPin, OUTPUT);

//***** CICLU *****

void loop() {

// LED la 0%.
analogWrite(ledPin, 0);
întârziere(timer);

// LED la 19.6%.
analogWrite(ledPin, 50);
întârziere(timer);

// LED la 39.2%.
analogWrite(ledPin, 100);
întârziere(timer);

// LED la 58.8%.
analogWrite(ledPin, 150);
intarziere(timer);

// LED la 78.4%.
analogWrite(ledPin, 200);
întârziere(timer);

// LED la 100%.
analogWrite(ledPin, 255);
întârziere(timer);
}

Analyse du code

Nici o surpriză pentru acest cod, cu excepția utilizării analogWrite în loc de digitalWrite. Luminozitatea
de la LED progresează pe pași de 50. Dacă dorim să netezim progresia luminozității, trebuie să creștem
numărul de niveluri, ceea ce va îngreuna foarte mult codul. Aceasta este motivul pentru care este mai bine
de a utiliza o funcție for, așa cum vom vedea în codul următor.

Cod 8: a varia treptat luminozitatea unei LED-uri

/*
Code 8 - [Link], destinat Arduino-ului
Obiectiv: a face să varieze luminozitatea unei LED-uri pe pinul 10
Adaptat de David A. Mellis ș i Tom Igoe
*/

51
Arduino la școală

//***** ANTET DECLARATIV *****

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

//***** CONFIGURARE *****

void setup() {

//***** CICLU *****

void loop() {

// Variatia de la min la max prin adaugarea de 5 pana la 256

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

{
Definirea valorii de luminozitate (de la 0 la 255)
analogWrite(ledPin, fadeValue);

// A ș teptare de 30 de milisecunde între fiecare nivel pentru a vedea efectul.

întârziere(30);
}

Varierea maximului până la minim prin scăderea a 5 de la 256

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

{
// Defini ț ia valorii de luminozitate (de la 0 la 255)
analogWrite(ledPin, fadeValue);

A ș teptare de 30 de milisecunde între fiecare nivel pentru a vedea efectul.

întârziere(30);
}

Analiza codului

Funcția for, începem să o cunoaștem bine. Altfel, iată un mic rezumat:

Declarația variabilei
(opțional)

Inițializare Test de la condiție Incrementare/decrementare

pentru(intcompteur=0;compteur<10;compteur++)
În codul nostru, începem cu un for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5).

Așadar, creăm o variabilă fadeValue de tip int, care stochează cifra 0. Testul condiției mai mic sau
égal à 255(fadeValue <= 255) permet une sortie de la fonction dès qu'on atteint le nombre 256. Enfin; et c'est
la nouătate, nu facem o incrementare (++), ci adunăm 5 la fadeValue cu formula +=5.

Comanda analogWrite(ledPin, fadeValue); permite astfel trimite valoarea fadeValue la LED-ul ledPin.
Pe măsură ce fadeValue crește cu câte +5, luminozitatea LED-ului crește treptat. În cele din urmă,
delay permite configurarea vitezei de cre ș tere a luminozită ț ii. Fiecare nivel de 5 durează 30
milisecunde. Este nevoie de 51 de trepte de 5 pentru a trece de la 0 la 255. Astfel, va fi nevoie de51∙ 30= 1530milisecunde pentru
trece de la LED stinsă la LED la luminozitatea sa maximă, adică aproximativ o secundă și jumătate.

Apoi, odată ce LED-ul este la luminozitatea sa maximă, este vorba despre reducerea luminozității până la a o stinge, grație
au cod for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5). Le+=5 este înlocuit cu un-=5, pentru a
soustraire à chaque fois 5 à la variablefadeValue.

52
Arduino la școală

Code 9: alternative pour faire varier la luminosité d'une LED

Cu codul 8, am variat luminozitatea unei LED de la 0 la 255 cu pași de 5. De asemenea, putem la fel.
bine folosit un increment++ pentru a ajunge la același rezultat. Iată cum arată asta:

/*
Cod 9 - [Link], destinat Arduino-ului
Obiectiv: a face variabilă luminozitatea unei LED-uri pe pinul 10
*/

//***** ÎNDELA DECLARATIVĂ *****

int ledPin = 10; //Se redenume ș te bro ș a 10 în "ledPin"

//***** SETUP *****

void setup()
{
}

//***** CICLU *****

functie buclă()
{

Variatie de la minim la maxim prin increment

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

analogWrite(ledPin, fadeValue);
întârziere(10);
}

// Varierea de la max la min prin decrementare

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

analogWrite(ledPin, fadeValue);
întârziere(10);
}
}

53
Arduino la școală

Proiect 8: intrările numerice

Până acum, am tratat despre ieșiri, adică un semnal ieșea din microcontroler sub forma
forma unui curent electric (HIGH) sau a absenței acestuia (LOW) prin intermediul comenzii DigitalWrite. Am
utilizat până acum acest semnal (un curent electric) pentru a aprinde LED-uri.
De asemenea, este posibil să trimiteți un semnal către microcontroler, de exemplu, de la un senzor. Acest semnal
este un curent electric care intră în terminal. În funcție de semnalul primit, microcontrolerul va efectua o
tâche prevăzută (a aprinde lumina când un senzor de mișcare detectează o prezență, de exemplu). Pentru
asta, vom folosi comenzile DigitalRead și AnalogRead.

Protejaț i Arduino
Până acum, ne-am mulțumit întotdeauna să facem să circule curentul de la microcontroler la
la masă.
În loc să folosim pini microcontrolerului doar ca ieșire (OUTPUT), vom folosi de asemenea
le utiliza sub formă de intrare (INPUT); adică, în loc să fie conectat la masă, pinul va fi conectat.
au +5V. Totul va decurge bine, dacă la nivelul programului, pinul este configurat ca intrare. Dar dacă ea
ar fi trebuit să fie configurat în output din greșeală, este aproape sigur că microcontrolerul va termina imediat
în paradisul cipurilor electronice ars.

Astfel, pentru a evita să condamnăm microcontrolerul nostru la scaunul electric, va trebui să-l protejăm.
Aceasta se poate face conectând o rezistență de 100 la pinul microcontrolerului folosit ca intrare.
la 200Ω.
R1
100
D4

ATENȚIE!

Când conectați Arduino la computer, ultimul program primit este executat. Înainte de a începe
un nou montaj, este mai mult decât recomandat să trimiteți un program de inițializare, modelul celui de mai sus:

void setup() {
}

void loop() {
}

Acum că acest punct este rezolvat, să vedem cum să folosim butonul de apăsare cu microcontrolerul.

Rezistenț ă Pull-Down / Pull-Up

Circuit cu o rezistenț ă pull-down

Observăm acest schematic:

Când apăsăm butonul, trimitem un curent

electric pe pinul 4, care va fi interpretat ca un1.
Când se eliberează butonul, nu mai există curent care să ajungă pe
la broche 4, ceea ce va fi interpretat ca un0. Așadar, avem un
signal binaire: allumé/éteint (on/off).

54
Arduino la școală

Acest montaj conține o rezistență de 10 kΩ (adică 10.000Ω), pe care o numim pull-down (literalmente trage-în-jos)
bas). Cette résistance permet detirerle potentiel vers lebas (pull-down).En français, on appelle aussi ceci
un rappel măcar.

Într-adevăr, spre deosebire de cazul teoretic, a închide sau a deschide un circuit (printr-un întreruptor sau un buton de presiune)
nu generează neapărat un semnal clar:

Circuitul neconectat la sursă poate ac ț iona ca o antenă într-un mediu poluat de unde.
electromagnetice (aproape de un telefon mobil, de exemplu). Aceasta va genera în circuit un
un curent care poate fi interpretat ca un semnal. Acest fenomen se numește inducție. Așa este,
exemple, că anumite smartphone-uri pot fi încărcate fără fir.
Din punct de vedere mecanic, atunci când apăsa ț i un buton, contactul nu este niciodată instantaneu.
ni perfect. Există rebonduri. Este la fel când este lăsat să plece. Aceste fenomene sunt parazite
care pot induce Arduino în eroare.

Scopul unei rezistenț e de pull-down este, aș adar, de a evacua curenț ii vagabonzi ș i de a oferi un
semnal clar.
Dacă apăsăm butonul, un curent electric clar este apoi aplicat la intrare. Curentul va lua
Calea cea mai simplă, fie prin rezistența de 220Ω și ajunge în final la D4, care este conectat la pământ. Dacă ne
Lase butonul, rezistența pull-down readuce intrarea la pământ. Deoarece D4 este, de asemenea, conectat la același
pământ, atunci există o diferență de potențial (o tensiune) de 0 Volți, și prin urmare nu există semnal parazitar la intrare
de D4.

Circuit cu o rezistenț ă pull-up

Observăm acum acest schemă din dreapta:

Și dacă îl comparăm cu schema unui circuit cu o rezistență pull-

down, on constate une inversion entre la terre et le +5V.

Într-adevăr, atunci când circuitul este deschis, o tensiune de +5V este

aplicată la intrarea broșei 4.
Când apăsăm pe butonul de presiune, curentul electric va
a trece pe calea care oferă cea mai mică rezistență, adică
direct prin masă (Gnd), fără a trece prin intrarea de
broșă 4.
Funcționarea este, așadar, inversată în raport cu rezistența
trage în jos.

Rezistenț ă pull-down sau pull-up?

La nivelul nostru, singurul lucru care se va schimba între o rezistență pull-down și o rezistență pull-up este
lectura informației

Cu o rezistență pull-down, din default, intrarea pe pin este egală cu 0.

Cu o rezistență pull-up, prin default, intrarea pe pin este egală cu 1.

În coddacă (digitalRead(buton) == 1), va fi respectiv valoarea de intrare atunci când

circuitul este închis (pull-down) sau deschis (pull-up).

55
Arduino la școală

Circuit 6: montaj cu rezistenț ă pull-down (rapel cel puț in)

Iată circuitul de realizat:

Circuit 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 RESETARE
LED 220 D11 IOREF
D12 REZERVAT
D13
GND
AREF
SDA
SCL

Liste des composants:

1 LED roșu 1 rezistență de 1k la 10kΩ

2 rezistențe de 220 la 470Ω 1 buton de apăsare

56
Arduino la școală

Când apăsăm pe buton, LED-ul trebuie să se aprindă. Și în mod natural, când eliberezi butonul
poussoir, LED-ul se stinge. Această acțiune nu este mecanică, ci logică. Nu este închiderea unui circuit
electric care aprinde LED-ul, dar informația transmisă la Arduino, prin intermediul unei INPUT care îi ordonă
a aprinde LED-ul.

Observăm acum codul:

Cod 10: aprinde o LED în funcț ie de starea butonului de presiune

/*
Cod 10 - [Link], destinat Arduino
Lampa LED se aprinde în func ț ie de starea butonului de aprindere
*/

// Declarăm variabilele

const int buton = 4; // la broche 4 devine buton

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

void setup()

{
pinMode(buton, INPUT); // Initializează brochea 4 ca intrare
pinMode(led, OUTPUT); // Initializează pinul 12 ca ie ș ire
[Link](9600); // Deschide portul serial la 9600 baudi
}

void loop()

// Si butonul de apăsare este apăsat...

dacă (digitalRead(buton) == 1) //teste si le bouton a une valoare de 1

//...pornim LED-ul
{
digitalWrite(led, HIGH); activează LED-ul
}

// Sinon...

altfel
//teste si le bouton a une valeur de 0
//...opri LED-ul
{
digitalWrite(led, LOW); // stinge LED-ul
}
}

57
Arduino la școală

Să analizăm codul:

Folosim o nouă instrucțiune: dacă ... altfel (dacă ... sinon). Așadar, este o condiție.

Iată ce se va întâmpla:

Dacă butonul de apăsare este apăsat (digitalRead(buton) == 1), aprinde LED-ul (digitalWrite(led, HIGH)), altfel
(altfel) stinge LED-ul (digitalWrite(led, LOW)).

Instrucțiunea verifică dacă două expresii sunt egale. Dacă sunt, atunci rezultatul va fi adevărat (true), altfel
rezultatul va fi fals.

Astfel:

const int buton = 4; la broche 4 devine buton

const int led = 12; // la broche 12 devine LED

Se renumește pini 4 și 12 respectiv buton și led. Acest lucru va facilita citirea codului.

void setup() {
// Ini ț ializează bro ș ura 4 ca intrare
pinMode(buton, INPUT);

// Initialize pin 12 as output

pinMode(led, OUTPUT);

Deschide portul serial la 9600 baud

[Link](9600);
}

Iată, acum microcontrolerul nostru știe că este ceva conectat la pinul său 4 și că este
configurată în intrare (INPUT). De asemenea, broșa 12 este configurată în ieșire (OUTPUT).
Acum că butonul este configurat, vom căuta să aflăm care este starea sa (apăsat sau eliberat).
Și microcontrolerul detectează un curent electric la pinul 4, atunci va stoca o valoare de 1.
În caz contrar (diferență de potențial de 0V), va stoca o valoare de 0.

Pentru a citi starea pini 4, vom folosi expresia digitalRead. Astfel:

dacă (digitalRead(buton) == 1)
digitalWrite(led, HIGH); aprinde LED-ul

trebuie înțeles ca:

ș i la bro ș a 4 are o valoare egală cu 1

deci, bro ș a 12 este în pozi ț ie înaltă = LED aprins

și liniile:

altfel {
digitalWrite(led, LOW); // opre ș te LED-ul

trebuie să se înțeleagă ca:

sinon (adică: bro ș a 4 are o valoare egală cu 0)

la broche 12 este în pozi ț ie joasă = LED stins

Iată un mic videoclip care prezintă activitatea: [Link]

58
Arduino la școală

Cod 11: Un cod mai elegant

Codul precedent este simplu, dar îi lipsește puțin rafinament; un pic ca un barbar cu o secure
cu două mâini într-o recepție a Domnului Ambasador. Iată deci o altă soluție, îmbrăcată în
smoking:

/*
Cod 11 - [Link], destinat Arduino-ului
Allumare LED în func ț ie de starea butonului de apăsare
*/

const int buton = 4; la broche 4 devine buton

const int led = 12; // la broche 12 devine led
int etatbuton; // variabilă care înregistrează starea butonului

void setup()
{
pinMode(buton, INPUT); // Initializează butonul ca intrare
pinMode(led, OUTPUT); // Initializează LED-ul ca ie ș ire
etatbouton = LOW; // Initializează starea butonului ca fiind eliberat
[Link](9600); Deschide portul serial la 9600 baude
}

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

dacă (etatbuton == LOW) //testează dacă butonul are un nivel logic MIC
{
digitalWrite(led,LOW); //LED-ul rămâne stins
}

altfel //testează dacă butonul are un nivel logic diferit de BAS (deci SUS)
{
digitalWrite(led,HIGH); //butonul este apăsat, LED-ul este aprins
}
}

Pentru început, vom crea o variabilă pe care o vom numi etatbouton. Aceasta va fi folosită pentru
stocarea stării butonului (logic, nu?):

int etatbuton;

Se înscrie starea butonului în variabilă în acest mod, cu funcția digitalRead:

etatbouton = digitalRead(bouton);

Nu ne rămâne decât să apelăm starea butonului, stocată în variabila etatbouton, și să-i facem un
test mic cu if... else (si... sinon):

Si(if)l’état du bouton estLOW(c’est-à-dire = 0),alors la LED estLOW(éteinte).Sinon(else), la LED est

ÎNALT (de fapt, dacă starea butonului nu este JOASĂ, nu poate fi decât ÎNALT, adică aprins...)

Și asta dă deci aceasta:

dacă(etatbouton == LOW) //testează dacă butonul are un nivel logic MLOW

{
digitalWrite(led,LOW); //la LED reste éteinte
}
altfel // testează dacă butonul are un nivel logic diferit de BAS (deci HAUT)
{
digitalWrite(led,HIGH); //butonul este apăsat, LED-ul este aprins
}
Reamintim că instrucțiunea==verifică dacă două expresii sunt egale.
59
Arduino la școală

Exerciț ii simple: buton de comandă ș i LED care clipeș te

Să ne imaginăm acum următorul caz: cu același circuit: când apăsăm pe buton,
LED-ul începe să clipească.

Modifică programul pentru a ajunge la acest rezultat.

Descărcaț i răspunsul

[Link]

Și acum, modifică programul astfel încât atunci când conectăm Arduino la computer, LED-ul
se aprinde si rămâne aprinsă. Pe de altă parte, când apăsăm pe buton, LED-ul clipește.

Descărcaț i răspunsul

[Link]

60
Arduino la școală

Bargraful
Un bargraph este un afișaj care indică o cantitate, provenind dintr-o informație oarecare (nivelul apei,
putere sonoră, etc.), sub o formă luminoasă. Cel mai adesea, se folosesc LED-uri aliniate ca
d'affichage.

Obiectivul acestui exercițiu este de a realiza un diagramă bară cu 4 LED-uri, cu două butoane de tip push. Unul dintre ele
va servi pentru a crește valoarea pe graficul bar (adică pentru a crește numărul de LED-uri aprinse), în timp ce
Celălalt va servi pentru a-l decremente.

Iată schema circuitului de montat:

Circuit 7

LED1 până la LED4: la alegere

R5 ș i R6: rezistenț e de protecț ie LED1

R1
R7 ș i R8: rezistenț e pull-down 220

SW1 ș i SW2: butoane de apăsare

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 la școală

Liste des composants

4 LED-uri la alegere
6 rezistențe de 220Ω
2 rezistențe de 1 la 10kΩ
2 butoane de apăsare

După cum se poate observa, rezistențele R7 și R8 sunt montate în pull-down (repetare cel puțin). Acest circuit
ar putea fi montat cu rezistențe pull-up.

În mod normal, în acest stadiu, ar trebui să fim capabili să executăm montajul folosind schematica electrică!
În caz contrar, iată montajul de realizat:

Circuit 8

62
Arduino la școală

Cod 12: bargraful

/*
Cod 12 - [Link], destinat Arduino-ului
Bargraphe
Obiectivul este de a realiza un grafic cu bare, cu 4 LED-uri ș i două butoane pentru apăsare: unul pentru
incrementează numărul de LED-uri aprinse, cealaltă pentru a-l decrementea.
*/

/*
Declara ț ia constantelor pentru numele pinilor
*/

const int btn_minus = 3; //Buton 1 pentru a decremente numărul de LED-uri aprinse

const int btn_plus = 4; //Buton 2 pentru a incrementa numărul de LED-uri aprinse
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

/*
Declara ț ia variabilelor utilizate pentru numărare ș i numărare inversă
*/

int numar_led = 0; //numărul care va fi incrementat ș i decrementat

int etat_buton; //lectura stării butoanelor (unul singur deodată, dar un
variabila este suficientă; de fapt, nu este prevăzută apăsarea ambelor butoane simultan)
int memoire_plus = LOW; stare relaxată implicită pentru butonul 2
int memoire_minus = LOW; //stare implicită eliberată pentru butonul 1

/*
Ini ț ializarea pinilor în intrare/ie ș ire: intrări pentru butoane, ie ș iri pentru LED-uri
*/

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

/*
Ș i a început programul!
*/

void loop()
{
lectura stării butonului de incrementare (se cite ș te starea btn_plus ș i se înscrie)
în variabila etat_bouton)
etat_bouton = digitalRead(btn_plus);

Si butonul are un statut diferit fa ț ă de cel înregistrat Ș I acest statut este "apăsat"
dacă((etat_bouton != memoire_plus) && (etat_bouton == HIGH))
{
nombre_led++; //incrementăm variabila care indică câte LED-uri trebuie să se aprindă
}

memoire_plus = starea_butonului; //înregistrăm starea butonului pentru runda următoare

ș i acum la fel pentru butonul care decrementează

etat_bouton = digitalRead(btn_minus); //lecture de son état
63
Arduino la școală

// Ș i butonul are un statut diferit de cel înregistrat Ș I acel statut este "apăsat"
dacă((etat_bouton != memorie_minus) && (etat_bouton == HIGH))
{
nombre_led--; //decrementeaza valoarea lui nombre_led
}
memoire_minus = etat_bouton; //ne înregistrăm starea butonului pentru următorul tur

aplicăm limite numărului pentru a nu depă ș i 4 sau 0 (deoarece avem 4 LED-uri)

dacă(nombre_led > 4)
{
nombre_led = 4;
}
dacă (numar_led < 0)
{
nombre_led = 0;
}

//Se creează o func ț ie affiche() pentru afi ș area rezultatului

//atunci îi trimitem ca parametru valoarea numărului de LED-uri de iluminat

afiseaza(numar_led);
}

void afiseaza(int valoare_recep ț ionata)

{
//opri ț i toate LED-urile
digitalWrite(led_0, LOW);
digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);

//Apoi le aprindem una câte una

dacă(valeur_recue >= 1) si valoarea primită este mai mare sau egală cu 1...
{
digitalWrite(led_0, HIGH); pornim LED 0
}
dacă(valeur_recue >= 2) ș i dacă valoarea primită este mai mare sau egală cu 2...
{
digitalWrite(led_1, HIGH); aprindem LED 1 (subîn ț elegând că LED 0 este
aliniată, deoarece valoarea este mai mare decât 1)
}
dacă(valeur_recue >= 3) ș i dacă valoarea primită este mai mare sau egală cu 3...
{
digitalWrite(led_2, HIGH); aprindem LED 2
}
dacă(valeur_recue >= 4) // "si la valeur reçue est plus grande ou égale à 4..."
{
digitalWrite(led_3, HIGH); aprindem LED 3
}
}

Video

Video de prezentare a bargrafelor: [Link] -1

64
Arduino la școală

Analiza codului:

În raport cu schema de montaj, se declară constantele pentru fiecare pin: butoanele de tip push-button
sunt conectate la pini 3 și 4, în timp ce LED-urile sunt conectate la pini 8 la 11.

/*
Declara ț ia constantelor pentru numele pinilor
*/

const int btn_minus = 3; //Buton 1 pentru a decreimenta numărul de LED-uri aprinse

const int btn_plus = 4; //Buton 2 pentru a incrementa numărul de LED-uri aprinse
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

Apoi creăm variabilele necesare și le inițializăm starea.

/*
Declara ț ia variabilelor utilizate pentru numărare ș i decontare
*/

int numar_led = 0; numărul care va fi incrementat ș i decremented

int etat_bouton; //citirea stării butoanelor (doar unul de dată, dar o
variabila suficient; de fapt, nu se preconizează apăsarea simultană a celor două butoane)
int memorie_mai_mare = LOW; //starea implicită a butonului 2
int memoire_minus = LOW; //stare eliberată în mod implicit pentru butonul 1

Apoi, se inițiază pini, în funcție de faptul că sunt intrări (butonii) sau ieșiri (LED-urile).

/*
Ini ț ializarea pinilor ca intrări/ie ș iri: intrări pentru butoane, ie ș iri pentru LED-uri
*/

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);
}

Să mergem la partea programului din bucla infinită.

Utilizează digitalRead pentru a citi starea butonului (btn_plus) și pentru a înregistra această stare în variabila etat_bouton.

void loop()
{
//citirea stării butonului de incrementare (se cite ș te starea btn_plus ș i se înscrie
în variabila stare_buton)

etat_bouton = digitalRead(btn_plus);

Acum, devine serios. Haideți să vedem următorul lucru:

Ș i dacă butonul are o stare diferită de cea înregistrată Ș I că această stare este "apăsat"

dacă((etat_bouton != memorie_plus) && (etat_bouton == HIGH))

65
Arduino la școală

Dacă starea butonului 2 este diferită de cea înregistrată, ș i cineva apasă pe

butonul, aș adar...

Le!=semnificădiferența dintre două variabile și operatorul logic&&înseamnăȘI

Pentru a fi precis, avem: dacă ... și ... cu leif ... && ... Exemplu: dacă este frumos și cald, atunci vom merge la
plajă).

Să ne amintim acum de operația ++, care incrementează o variabilă (variabilă = variabilă + 1, adică-
dire; se adaugă de fiecare dată 1 la variabilă). În cazul nostru, este vorba de valoarea variabilei număr_led
pe care o incrementăm.

{
nombre_led++; //incrementăm variabila care indică câte LED-uri vor trebui să se aprindă
}

Et hai! Înregistrăm noua stare a butonului pentru mai departe!

memoire_plus = starea_butonului; //înregistrăm starea butonului pentru turul următor.

Acum, reluăm totul, dar pentru butonul 1.

ș i acum la fel pentru butonul care decrementează

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

//Si butonul are o stare diferită de cea înregistrată Ș I că această stare este "apăsat"
dacă((etat_bouton != memorie_minus) && (etat_bouton == HIGH))
{
nombre_led--; //decrementez valoarea lui nombre_led
}
memoire_minus = etat_bouton; //înregistrăm starea butonului pentru turul următor

Acum vom limita numărul de LED-uri de conectat. De fapt, în cazul nostru, avem 4 LED-uri.
Așadar, dacă apăsăm de 10 ori pe butonul 2, acesta va aprinde doar cele 4 LED-uri.

aplicăm limite la număr pentru a nu depă ș i 4 sau 0 (deoarece avem 4 LED-uri)

dacă(nombre_led > 4)
{
nombre_led = 4;
}

Dacă apasă mai mult de 4 ori pe buton, rezultatul va fi egal cu 4

Același lucru acum pentru butonul 1.

dacă(nombre_led < 0)
{
nombre_led = 0;
}

Acum, trebuie să gestionăm aprinderea LED-urilor. Pentru a simplifica codul, vom crea o funcție care
va servi la gestion a afișării. Vom numi această funcție afișează, cu un parametru int valoare_recu.
parametrul reprezintă numărul de afișat.

//Creăm o func ț ie affiche() pentru afi ș area rezultatului

atunci îi trimitem ca parametru valoarea numărului de LED-uri care trebuie să se aprindă

afiseaza(numar_led);
}

void affiche(int valoare_recep ț ionată)

Începem mai întâi prin a stinge toate LED-urile.

66
Arduino la școală

{
//oprim toate ledurile
digitalWrite(led_0, LOW);
digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
Și dacă funcția primește numărul 1, aprindem LED-ul 1. Dacă primește numărul 2, aprinde LED-ul 1 și 2. Dacă
elle reçoit 3, elle allume la LED 1, 2 et 3. Enfin, si elle reçoit 4, alors elle allume toutes les LEDs:

Apoi le aprindem pe rând

dacă(valeur_recue >= 1) ș i valoarea primită este mai mare sau egală cu 1...
{
digitalWrite(led_0, ÎNALT); aprindem LED 0
}
dacă(valeur_recue >= 2) ș i dacă valoarea primită este mai mare sau egală cu 2...
{
digitalWrite(led_1, SUS); aprindem LED 1 (subîn ț eles că LED 0 este
aprinsă, deoarece valoarea este mai mare decât 1)
}
dacă(valeur_recue >= 3) ș i dacă valoarea primită este mai mare sau egală cu 3...
{
digitalWrite(led_2, ÎNALT); aprinde LED 2
}
dacă(valeur_recue >= 4) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_3, ÎNALT; aprindem LED 3
}
}

Simbolul >= semnifică: ...este mai mare sau egal cu.... Este vorba de a testa superioritatea sau egalitatea unei variabile.
în raport cu o valoare. Astfel, în:

dacă(valeur_recue >= 4)
{
digitalWrite(led_3, ÎNALT); aprindem LED 3
}

Trebuie să citim: dacă variabila valoare_rece poate fi mai mare sau egală cu 4, atunci aprindem LED-ul 3.

Depurare cu ajutorul condensatorilor

Ați observat fără îndoială: în ciuda meniurilor derulante, butoanele de apăsare sunt puțin precise. Într-adevăr,
uneori, două LED-uri se aprind sau se sting la o apăsare a butonului. Aceasta se datorează faptului că butonul-
poussoirul nu este mecanic perfect. Când apăsăm pe el, semnalul nu este neapărat curat.
În decurs de câteva milisecunde, semnalul va trece de la 0V la 5V de mai multe ori înainte de a se stabiliza. Arduino
poate interpreta o astfel de mișcare parazitară pentru un semnal de intrare și va reacționa în consecință. Prin
de exemplu, apăsând o dată pe butonul de comandă, Arduino poate înregistra două impulsuri în intrare
și va ilumina două LED-uri în loc de unul singur.

Există o modalitate de a deparazita butonul și de a absorbi aceste reveniri montând în paralel cu butonul-
poussoir un condensateur de faible capacité (10nF).

Ce este un condensator?

Condensatorul este un component electronic pasiv, la fel ca rezistențele. Are capacitatea

de a stoca o sarcină electrică, înainte de a putea fi restituită în caz de scădere a tensiunii. Se folosește
astfel condensatoarele ca regulator de tensiune, dar folosim și capacitatea lor de a se încărca pentru
absoarbe fluctuațiile bruște, dar scurte de tensiune care sunt paraziții. Capacitatea de încărcare se
măsură în Farazi (F).

67
Arduino la școală

Condensator ceramic Condensator electroliț i Simbolul condensatorului

Circuit 9
LED1 până la LED4: la alegere

R5 ș i R6: rezistenț e de protecț ie LED1

R1
R7 ș i R8: rezistenț e pull-down 220

SW1 ș i SW2: butoane de apăsare

LED2
R2
C1 ș i C2: condensatoare 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 C2 SW2 C1
10nF 10nF

68
Arduino la școală

Așa cum se poate vedea pe circuitul de mai sus, au fost adăugate două condensatoare de capacitate mică.
paralel cu butoanele de presiune. Dacă parada nu este absolută, aceasta permite să crească considerabil
precizia butoanelor.

Instalarea condensatoarelor nu are nicio influență asupra codului. Prin urmare, nu este necesar să le
modificator.

Bargraphe-ul cu 10 LED-uri

Există grafice cu bare care integrează 10 LED-uri. Le putem folosi ca înlocuitor pentru cele 4 LED-uri de mai sus.
montaj.

Referințe utilizate în acest exercițiu: Kingbright DC-10EWA sau DC7G3EWA.

Într-o parte se află catodele, în cealaltă anodele. În cazul nostru, anodele sunt de partea unde se
găsesc inscripțiile.

Codul, de asemenea, trebuie să fie adaptat în consecință pentru 10 LED-uri. Un exemplu se găsește aici:

Cod 13: bara grafică cu 10 LED-uri

/*
Cod 13 - [Link], destinat pentru Arduino
Graficul cu bare
Obiectivul este de a realiza un grafic cu bare, cu două butoane
poussoirs: unul pentru a cre ș te numărul de LED-uri aprinse,
celălalt pentru a-l decre ș te.
Barograful este compus din 10 LED-uri.
*/

/*
Declara ț ia constantelor pentru numele pinilor
*/

const int btn_minus = 2; //Buton 1 pentru a decremen ț a numărul de LED-uri aprinse

const int btn_plus = 3; Butonul 2 pentru a incrementa numărul de LED-uri aprinse
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 la școală

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

/*
Declara ț ia variabilelor utilizate pentru numărare ș i numărare inversă
*/

int numar_led = 0; //numărul care va fi incrementat ș i decrementat

int etat_buton; //lectura stării butoanelor (unul singur deodată, dar un
variabila suficientă; de fapt, nu este prevăzut să apăsa ț i ambele butoane simultan)
int memoire_plus = LOW; //stare relaxată implicită pentru butonul 2
int memoire_minus = LOW; //stare eliberată implicit pentru butonul 1

/*
Ini ț ializarea pinilor în intrare/ie ș ire: intrări pentru butoane, ie ș iri pentru LED-uri
*/

void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_0, OUTPUT);
pinMode(led_1, IE Ș IRE);
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);

void loop()
{
lectura stării butonului de incrementare (se cite ș te starea btn_plus ș i se înscrie)
//în variabila etat_bouton)
etat_bouton = digitalRead(btn_plus);

// Ș i butonul are o stare diferită de cea înregistrată Ș I acea stare este "apăsat"
dacă ((etat_bouton != memoire_plus) && (etat_bouton == HIGH))
{
nombre_led++; //incrementăm variabila care indică câte LED-uri trebuie să se aprindă
}

memoire_plus = stare_buton; //salvăm starea butonului pentru turul următor

// ș i acum la fel pentru butonul care decrementează

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

// Ș i butonul are o stare diferită de cea înregistrată Ș I acea stare este "apăsat"
dacă ((etat_bouton != memoire_minus) && (etat_bouton == HIGH))
{
nombre_led--; //se decrementează valoarea lui nombre_led
}
memoire_minus = etat_bouton; //înregistrăm starea butonului pentru turul următor

Aplicăm limite la număr pentru a nu depă ș i 4 sau 0 (deoarece avem 4 LED-uri)

dacă (nombre_led > 10)
{
nombre_led = 10;
}
dacă (nombre_led < 0)
{

70
Arduino la școală

nombre_led = 0;
}

//Creăm o func ț ie affiche() pentru afi ș area rezultatului

atunci îi trimitem ca parametru valoarea numărului de LED-uri de iluminat

afisează(număr_led);
}

void affiche(int valoare_primita)

{
//oprim toate led-urile
digitalWrite(led_0, LOW);
digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, SCĂZUT);
digitalWrite(led_8, LOW);
digitalWrite(led_9, LOW);

Apoi le aprindem una câte una

dacă (valeur_recue >= 1) ș i dacă valoarea primită este mai mare sau egală cu 1...
{
digitalWrite(led_0, ÎNALT); pornim LED 0
}
dacă (valoare_primita >= 2) ș i dacă valoarea primită este mai mare sau egală cu 2...
{
digitalWrite(led_1, ÎNALT); aprindem LED 1 (subîn ț elegând că LED 0 este
aprinsă, deoarece valoarea este mai mare decât 1)
}
dacă (valoare_primită >= 3) si valoarea primită este mai mare sau egală cu 3...
{
digitalWrite(led_2, ÎNALT); aprinde LED-ul 2
}
dacă (valoare_primita >= 4) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_3, HIGH); aprindem LED 3
}
dacă (valoare_primită >= 5) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_4, HIGH); aprinde LED-ul 3
}
dacă (valoare_recep ț ionată >= 6) // "si la valeur reçue est plus grande ou égale à 4..."
{
digitalWrite(led_5, ÎNALT); aprinde LED-ul 3
}
dacă (valoare_primită >= 7) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_6, ÎNALT); aprindem LED-ul 3
}
dacă (valeur_recue >= 8) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_7, ÎNALT); aprindem LED 3
}
dacă (valoare_primita >= 9) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_8, ÎNALT); aprinde LED 3
}
dacă (valoare_recep ț ionată >= 10) ș i dacă valoarea primită este mai mare sau egală cu 4...
{
digitalWrite(led_9, HIGH); pornim LED 3
}
}

71
Arduino la școală

Variaț ie: afiș ajul digital

Pentru această montare, vom folosi un afișaj digital cu LED-uri.

Referința folosită aici este un afișaj cu anod comun Kingbright SA56-11 SRWA11.

10 kOhmi

100 Ohmi
D3

100 Ohmi
D4

D6

D7

D8
D9

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

1 2 3 4 5
220 Ohmi e d A c punct
D10

D11

D12
D13

În cazul unei anode comune, aceasta este conectată la +5V. Catodele sunt conectate la
brosele.
La nivelul codului, acest lucru implică că LED-urile sunt aprinse în poziția LOW și stinse în poziția HIGH.
Cu un component cu catod comun, este contrariul.
În exemplul nostru, vom începe prin a aprinde toate diodele, apoi pe rând, pentru a le
identificator. Apoi se pot scrie cifre.

11Disponibil aici: [Link]/episode/arduino-lecole-apprendre-compter

72
Arduino la școală

Identificarea poziț iei LED-urilor

Codul următor permite identificarea poziției LED-urilor prin aprinderea lor pe rând:

/*
Cod 14 - [Link], destinat Arduino-ului
Afi ș ajul cu 7 sau 8 segmente
Obiectivul este de a afi ș a cifre pe un afişaj cu 7 segmente (7 cifre).
Acest cod are scopul de a aprinde toate LED-urile, apoi pe rând.
pentru a- ș i identifica pozi ț ia.
*/

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, OUTPUT);
}

void loop()
{

aprindem toate LED-urile

digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, LOW);
digitalWrite(led_8, LOW);
întârziere(1500);

//oprim toate led-urile

digitalWrite(led_1, PE_PICIOR);
digitalWrite(led_2, ÎNALT);
digitalWrite(led_3, HIGH);
digitalWrite(led_4, SUS);
digitalWrite(led_5, ÎNALT);
digitalWrite(led_6, ÎNALT);
digitalWrite(led_7, HIGH);
digitalWrite(led_8, ÎNALT);
întârziere(500);

//aprindem un LED pe rând pentru a-i identifica pozi ț ia

digitalWrite(led_1, LOW);
întârziere(1500);

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, LOW);
întârziere(1500);

73
Arduino la școală

digitalWrite(led_2, HIGH);
digitalWrite(led_3, LOW);
întârziere(1500);

digitalWrite(led_3, ÎNALT);
digitalWrite(led_4, LOW);
întârziere(1500);

digitalWrite(led_4, SUS);
digitalWrite(led_5, LOW);
întârziere(1500);

digitalWrite(led_5, ÎNALTĂ);
digitalWrite(led_6, LOW);
întârziere(1500);

digitalWrite(led_6, SUS)
digitalWrite(led_7, jos);
întârziere(1500);

digitalWrite(led_7, HIGH);
digitalWrite(led_8, LOW);
întârziere(1500);
}

Obiectivul este de a identifica fiecare LED pe schema de mai jos:

Iată deci, în cazul nostru, LED-urile care trebuie să fie aprinse pentru a scrie cifrele următoare:

# 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

Nu folosim led_8, care reprezintă un punct.

Codul pentru a număra de la 0 la 9 este aici: [Link]
74
Arduino la școală

Pe rândul tău:

# led_1 led_2 led_3 led_4 led_5 led_6 led_7

1

cinci

75
Arduino la școală

Este de asemenea posibil să scrieți literele alfabetului cu ajutorul unui afișaj cu 7 segmente12:

Exemple:

Evident, rămâne artizanal; dar poate oferi rezultate acceptabile, așa cum se poate vedea aici:

12Sursa de la poliță: [Link]

76
Arduino la școală

Sinteză: a învăț a să numere

Obiectiv

Această ultimă lecție va sintetiza tot ce am văzut până acum. Obiectivul este de a realiza un
montaj, cu două butoane pulsante și un afișaj cu 7 segmente. Unul dintre butoane va fi folosit pentru a incrementa
cifrele de pe afișaj și celălalt pentru a le decremeta. Astfel, apăsând de 6 ori pe butonul de apăsare,
chiffres de 1 à 6 vont successivement s’afficher.

Schema electronică a montajului

Pe schema următoare, afișajul cu 7 segmente este cu anodă comună. Ca de obicei, fiecare buton-
poussoirul este dotat cu o rezistență pull-down de 1kΩ sau 10kΩ și cu o rezistență de protecție a intrării
100Ω. Ordinea de conectare a afișajului nu contează, deoarece vom folosi codul 14 pentru a identifica ordinea.
d'activation a piniilor.
10 kOhmi

100 Ohmi
D3

100 Ohmi
D4

D6

D7

D8
D9

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

1 2 3 4 5
220 Ohmi e d A c punct
D10

D11

D12
D13

77
Arduino la școală

Circuit 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
RESET 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 la școală

Cod 15: a învăț a să numere

Codul poate fi descărcat la următoarea adresă: [Link]

Este foarte similar cu codurile anterioare. Principala diferență constă îndacă(valeur_recue == 1)

, care în acest caz înseamnă "dacă valoarea primită este egală cu 1, aprindem segmentele pentru a afiș a cifra 1".
Spre deosebire dedacă(valeur_recue >= 1), care permite acumularea aprinderii LED-urilor (1 LED pentru 1,
două LED-uri pentru 2,...), obiectivul aici este de a aprinde doar LED-urile necesare pentru afișarea cifrei corecte. Nu este
ar trebui într-adevăr să nu devină un9 în loc de un4, pentru că se acumulează LED-urile aprinse.

/*
Cod 15 - [Link], destinat Arduino-ului
A învă ț a să numere
Obiectivul este de a afi ș a cifre pe un display cu 7 segmente. Un buton permite
unul pentru a incrementa cifra, celălalt pentru a decrementează.
Se numără astfel de la 0 la 9 sau de la 1 la 0.
*/

/*
Declara ț ia constantelor pentru numele pinilor.
Afisajul nostru este un 8 segmente, având deci un punct. Chiar dacă nu îl folosim, noi
L-am conectat totu ș i.
*/

const int btn_minus = 3; //Buton 1 pentru a decrementa cifrele

const int btn_plus = 4; Buton 2 pentru a incrementa cifrele
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;

/*
Declara ț ia variabilelor folosite pentru numărare ș i numărarea inversă
*/

int numar_led = 0; //numărul care va fi incrementat ș i decrementat

int etat_bouton; //lectura stării butoanelor (doar unul deodată, dar un
variabila suficient; de fapt, nu este prevăzut să apăsa ț i ambele butoane simultan)
int memorie_mai_mare = LOW; stare relaxată implicit pentru butonul 2
int memoire_minus = LOW; //stare eliberată implicit pentru butonul 1

/*
Inutilizarea piniilor de intrare/ie ș ire: intrări pentru butoane, ie ș iri pentru LED-uri
*/

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

79
Arduino la școală

/*
Ș i a început programul!
*/

void loop()
{
//lectura stării butonului de incrementare (se cite ș te starea btn_plus ș i se înregistrează
//în variabila etat_bouton)
etat_bouton = digitalRead(btn_plus);

// Ș i butonul are o stare diferită de cea înregistrată Ș I această stare este "apăsat"
dacă((etat_bouton != memorie_plus) && (etat_bouton == ÎNALT))
{
nombre_led++; //incrementăm variabila care indică câte LED-uri trebuie să se aprindă
}

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

// ș i acum la fel pentru butonul care decrementează

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

// Ș i butonul are un stări diferit de cel înregistrat Ș I această stare este "apăsat"
dacă((etat_bouton != memorie_minus) && (etat_bouton == HIGH))
{
nombre_led--; //decrementeaza valoarea lui nombre_led
}
memorie_minus = starea_butonului; //înregistrăm starea butonului pentru următorul tur

aplicăm limite la număr pentru a nu depă ș i 4 sau 0 (deoarece avem 4 LED-uri)

dacă(nombre_led > 10)
{
nombre_led = 10;
}
dacă(nombre_led < 0)
{
nombre_led = 0;
}

//Creăm o func ț ie affiche() pentru afi ș area rezultatului

atunci îi trimitem ca parametru valoarea numărului de LED-uri care trebuie să fie iluminate

afiș ează(număr_led);
}

void affiche(int valoare_recaptată)

{
//oprim toate ledurile
digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, HIGH);
digitalWrite(led_3, HIGH);
digitalWrite(led_4, ÎNALT);
digitalWrite(led_5, ÎNALT);
digitalWrite(led_6, ÎNALT);
digitalWrite(led_7, ÎNALT);
digitalWrite(led_8, ÎNALT);

//Pentru fiecare cifră, cel mai simplu este să listăm toate LED-urile
//et de leur attribuer la valeur voulue

dacă(valeur_recue == 1) si valoarea primită este egală cu 1, aprindem

//segmente pentru a afi ș a cifra 1
{

digitalWrite(led_1, LOW);
digitalWrite(led_2, ÎNALT);

80
Arduino la școală

digitalWrite(led_3, HIGH);
digitalWrite(led_4, LOW);
digitalWrite(led_5, ÎNALT);
digitalWrite(led_6, HIGH);
digitalWrite(led_7, ÎNALT);
digitalWrite(led_8, HIGH);

dacă(valeur_recue == 2) si valoarea primită este egală cu 2, aprindem

//segmente pentru a afi ș a cifra 2
{

digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, ÎNALT);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, ÎNALT);
digitalWrite(led_8, HIGH);

}
dacă(valeur_recue == 3) ș i dacă valoarea primită este egală... în sfâr ș it... ș tii tu
//suite...
{

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, ÎNALT);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, LOW);
digitalWrite(led_8, HIGH);

}
dacă(valeur_recue == 4)
{

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, ÎNALT);
digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW);
digitalWrite(led_5, HIGH);
digitalWrite(led_6, LOW);
digitalWrite(led_7, LOW);
digitalWrite(led_8, ÎNALT);

dacă(valeur_recue == 5)
{

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, ÎNALT);
digitalWrite(led_7, LOW);
digitalWrite(led_8, ÎNALT);

}
dacă(valeur_recue == 6)
{

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

81
Arduino la școală

digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, HIGH);
digitalWrite(led_7, LOW);
digitalWrite(led_8, ÎNALT);

dacă(valeur_recue == 7)
{

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, ÎNALT);
digitalWrite(led_3, HIGH);
digitalWrite(led_4, U HIGH);
digitalWrite(led_5, LOW);
digitalWrite(led_6, SCĂZUT);
scrieDigital(led_7, LOW);
digitalWrite(led_8, ÎNALT);

dacă(valeur_recue == 8)
{

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

dacă(valeur_recue == 9)
{

digitalWrite(led_1, ÎNALT);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, LOW);
digitalWrite(led_8, LOW);

dacă(valeur_recue == 10)
{

digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, HIGH);
digitalWrite(led_4, LOW);
digitalWrite(led_5, LOW);
digitalWrite(led_6, LOW);
digitalWrite(led_7, LOW);
digitalWrite(led_8, SCĂZUT);

}
}

Codul se termină cu cifra 0, în lipsa lui 10.

Codul nu este optimizat; am putea să ne lipsim de repetarea digitalWrite care sunt în poziția LOW de mai multe ori.
de mai multe ori. Cu toate acestea, aceasta permite să se poată înțelege și analiza codul mult mai simplu;
începe cu elevii.
82
Arduino la școală

Proiectul 9: intrările analogice

Un semnal analogic13variază în mod continuu de-a lungul timpului. Prin urmare, valoarea sa este un număr real. On
găsește semnale analogice constant, cum ar fi temperatura, viteza...

Semnal numeric

Semnal analogic

Arduino Uno are 6 intrări analogice, numerotate de la A0 la A5. De fapt, microcontrolerul nu este
capabil de a înțelege un semnal analogic. Prin urmare, trebuie mai întâi să-l convertești într-un semnal digital printr-un
circuit special numit convertor analogic/digital. Acest convertor va eșantiona semnalul primit
sub forma unei variații de tensiune și transformarea acesteia în valori cuprinse între 0 și 1023. Atenție la
nu introduceți o tensiune mai mare de 5V, ceea ce ar distruge Arduino.

La fotorezistenț ă
O fotorezistență este un component electronic
nu rezistența (în OhmΩ) variază în funcție de
intensitatea luminoasă. Cu cât luminozitatea este mai mare,
plus rezistența este scăzută. Putem deci să o folosim
ca senzor de lumină pentru:

• Măsurarea luminii ambientale pentru o

stație meteorologică.
• Detector de lumină într-o cameră.
• Urmaș de lumină într-un robot.
• Detector de trecere.
•…

13Mai multe informaț ii:[Link]

83
Arduino la școală

Simbolurile sale electronice sunt următoarele:

Avantajul fotorezistențelor este că sunt foarte ieftine. Pe de altă parte, reacția lor la lumină este
diferență pentru fiecare fotorezistență, chiar și atunci când au fost produse în același lot. Se poate astfel
a nota o diferență de rezistență de peste 50% între două fotorezistențe de același model pentru
aceeași luminozitate. Nu o putem folosi pentru o măsurare precisă a luminii. Pe de altă parte, ele sunt
ideale pentru a măsura schimbări simple ale luminozității.

Circuit 11: divizor de tensiune

Pentru circuitul 11, vom avea nevoie de o fotorezistență pe care o vom conecta la pinul A0.

Montajul cu rezistență fixă - fotorezistență constituie ceea ce se numește un divizor de tensiune. 5V sunt
introduse în circuit de la Arduino. Se leagă punctul dintre cele două rezistențe la un pin analogic
de la Arduino și măsurăm tensiunea prin funcția analogRead (pin). Orice schimbare a tensiunii
măsurată se datorează fotorezistenței, deoarece este singura care se schimbă în acest circuit, în funcție de
lumină.

Lista componentelor

1 LED
1 rezistență de 220Ω
1 rezistență de 10kΩ
1 fotorezistenţă

Circuit 11

84
Arduino la școală

U1
ARDUINO

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

Cod 16: valoare prag

Obiectivul acestui cod este de a defini un prag de luminozitate dincolo de care stingem un LED. Vom pentru
Aceasta folosește o nouă instrucțiune: dacă ... altfel (dacă ... în caz contrar). Deci, este o condiție.

Iată ce se va întâmpla:

Dacă luminozitatea depășește pragul (dacă (analogRead (lightPin) > prag)), stinge LED-ul (digitalWrite (ledPin,
LOW));sinon(altfel), aprinde LED-ul (digitalWrite(ledPin, HIGH)).

Instructiunea==verifică dacă două expresii sunt egale. Dacă sunt egale, atunci rezultatul va fi adevărat (true), altfel
rezultatul va fi fals.

În acest caz, pragul este stabilit la 900 (din 1023). Variind valoarea pragului, se modifică sensibilitatea de
detecția luminozității.

/*
Cod 16 - [Link], destinat Arduino-ului
Scop: A stinge un LED de îndată ce luminozitatea este suficientă
*/

//***** ANTET DECLARATIV *****

int lightPin = 0; Renumerăm bro ș a A0 în "lightPin"

int ledPin = 9; Schimbăm numele pinului 9 în "ledPin"

//***** FUNC Ț IA SETUP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i o singură dată, la pornirea programului

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

85
Arduino la școală

void loop()
{
int prag = 900; //Se stabile ș te un prag de luminozitate (pe 1023) la
//începând de la care LED-ul se stinge
dacă (analogRead (lightPin) > seuil) Ș i dacă luminozitatea este mai mare decât pragul...
{
digitalWrite (ledPin, LOW); //... a ș a că stingem LED-ul.
}
altceva //Sinon...
{
digitalWrite (ledPin, HIGH); //...pornim LED-ul
}
}

Cod 17: variaț ia luminozităț ii unei LED-uri în funcț ie de lumina ambientală

Să ne imaginăm acum că vrem să variem luminozitatea unei LED-uri în funcție de luminozitatea camerei
în care se află: cu cât este mai luminos, cu atât LED-ul este mai puțin strălucitor.

Teoretic, nu este nimic complicat; trebuie doar să combinăm semnalul fotorezistenței cu valoarea
PWM de la LED. Practic, ne regăsim cu un semnal la intrare (fotorezistența) tăiat în 1024
paliere, în timp ce cele ale semnalului PWM au 256 de paliere. Doar că 1024 este 256 x 4. Împărțind
valoarea variabilei lightReading par 4, o facem compatibilă cu cele 256 de niveluri de variație a luminozității
de la LED.

/*
Cod 17 - [Link], destinat Arduino
Obiectiv: Aface varia ț ia luminozită ț ii LED-ului în func ț ie de luminozitatea camerei
Sursă: [Link]
*/

int lightPin = 0;

int citireLumina;

int ledPin = 9;
int ledBrightness;

void setup() {

[Link](9600);
}

void loop() {

lightReading = analogRead(lightPin);

[Link]("Lectură analogică = ");

[Link](lightReading);

lightReading = 1023 - lightReading;

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

întârziere(100);
}

86
Arduino la școală

Analiza codului

În primul rând, vom defini constantele și variabilele noastre. Astfel, pinul A0, pe care
Fotorezistența (cuplată cu rezistența pull-down) este conectată și a fost redenumită lightPin. Apoi, se creează o
variabila numită lightReading pentru a stoca valoarea analogică (între 0 și 1023) a valorii de
la fotorezistență cu divisorul de tensiune. În mod natural, pinul 9, la care este conectată LED-ul
este numităledPin. De notat că pinul 9 este compatibilPWM. În cele din urmă, creăm o variabilăledBrightness
pentru a stoca valoarea de luminozitate a LED-ului (între 0 și 255).

int lightPin = 0;
int citireLumină;
int ledPin = 9;
int luminozitateLed
Apoi, stocăm valoarea fotorezistenței cu un analogRead în variabila lightReading.

lightReading = analogRead(lightPin);

Petit aparté: on peut contrôler le bon fonctionnement de la photorésistance en envoyant à la console d'Arduino
IDE valorile măsurate folosind [Link], care se află în Meniu Instrumente -> Monitor serial. Acest cod
este deci opțional.

[Link]("Lectură analogică = ");

[Link](lightReading);

Cu cât este mai întuneric, cu atât LED-ul trebuie să fie mai strălucitor.
Aceasta înseamnă că trebuie să inversa ț i valoarea citită de la 0-1023 la 1023-0, cu o
scădere.
lightReading = 1023 - lightReading;

//În final, trebuie să corelăm valorile citite de la 0-1023 la 0-255, care sunt valorile
utilizate de analogWrite.
//Pentru aceasta, convertim valoarea variabilei "lightReading" împăr ț ind-o la 4.
ledBrightness = lightReading / 4;
analogWrite(ledPin, ledBrightness); // În sfâr ș it aprinde LED-ul cu luminozitatea stocată
dans la variable "ledBrightness".

întârziere(100);
}
Variația de luminositate este adesea inversată. Astfel, un ceas deșteptător radio este foarte luminos când este zi și puțin
luminoși pe timp de noapte. Pentru a simula acest lucru, este suficient să ștergeți următoarea linie:

lightReading = 1023 - lightReading;

Cod 18: mappare de date

Maparea datelor este asocierea datelor care aparțin unui cu datele care aparțin unui
un alt ansamblu, astfel încât să se poată trece armonios de la primele la cele secundare14.
În cazul nostru, avem date înscrise într-un interval situat între 0 și 1023 pe care trebuie să le.
converte în intervalul între 0 și 255, care corespunde la 8 biți.

Și dacă reluăm exercițiul precedent, o mică modificare permite realizarea mapării datelor.

/*
Cod 18 - [Link], destinat Arduino-ului
Obiectiv: a varia intensitatea LED-ului în func ț ie de luminozitatea camerei cu
mapare de date

14[Link]

87
Arduino la școală

Sursa: [Link]
*/

int lightPin = 0; La photorezisten ț ă ș i rezisten ț a pulldown de la 1 la 10K sunt

conecta ț i la A0
int citireLumina; // Lecture analogique de la valeur de la photorésistance avec le
divizor de tensiune
int ledPin = 9; // LED PWM pe pinul 9
int ledBrightness; // Variabilă pentru a stoca valoarea de luminozitate a LED-ului
void setup() {

[Link](9600);
}

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

//Afi ș area valorii lui "lightReading" în consolă

[Link]("Lectură analogică = ");
[Link](lecturaLuminii); // Afi ș area valorii brute provenite din
//fotorezistenț ă.

// Cu cât se face mai întuneric, cu atât LED-ul trebuie să fie mai strălucitor.

Asta înseamnă că trebuie inversată valoarea citită de la 0-1023 la 1023-0, cu o

//scădere.
lightReading = 1023 - lightReading;

//În cele din urmă, trebuie să corelăm cu func ț ia "map" valorile citite de la 0-1023 la 0-255
//cine sunt valorile folosite de analogWrite.

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

analogWrite(ledPin, ledBrightness); // Începe în sfâr ș it să aprindă LED-ul cu luminozitatea stocată
//în variabila "luminozitateaLedului".

întârziere(100);
}

Se vede pe linia următoare maparea:

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

functia map functioneaza sub urmatoarea forma:

Variabilă Variabilă Date Date
de sosire de origine de origine de sosire

variable2 = map(variable1, 0, 1023, 0, 255);

Variable1 este originea datelor. Variable2 este destinația datelor.

88
Arduino la școală

Proiectul 10: potenciometru

Potentiometrul este o rezistență variabilă. Spre deosebire de acesta, este butonul de reglare a volumului pe o
radio. Cele mai multe dintre potențiometre sunt fie rotative, fie liniare.

Potentiometru rotativ Potentiometru liniar

Potențiometrele sunt foarte frecvente în aparatele electronice, de exemplu, mesele de mixaj.

Masă de mixaj a RadioBus15

Iată simbolurile electronice (european deasupra și american dedesubt) ale potentiometrului:

Ca orice rezistență, potentiometrul modifică tensiunea unui circuit. Așadar, îl vom folosi în principal
ca intrare (input) într-o broșă analogică (A0 la A5) a Arduino.

15[Link]

89
Arduino la școală

Potentiometrele au în general trei pini16Broșele exterioare se conectează la alimentare.

+5V și la masă, în timp ce pinul central trimite semnalul pe pinul de intrare analogică al Arduino.

Mătura
Pistă rezistivă

+5V AFARĂ GND

vers de intrare
analogic GND
AFARĂ

+5V

Circuit 12: Foloseș te potenț iometrul pentru a varia luminozitatea unei LED-uri
Este timpul să ne prăjim prima LED (dacă nu a fost deja făcut)! Este etapa obligatorie a oricărei bune
creator! Pentru a face acest lucru, vom conecta un LED la pinul OUT al potentiometrului și îl vom pune pe
teren. Mic sfat: înainte de a conecta, întoarceți potenciometrul la minim, în sens invers acelor de ceasornic
de o oră.

Odată ce Arduino este conectat, rotiți ușor potentiometrul în sensul acelor de ceasornic.
LED-ul va începe să se aprindă, apoi din ce în ce mai mult, înainte de a... arde.

Circuit 12

90
Arduino la școală

U1
ARDUINO

AREF
GND
D13
D12
D11
RESETARE 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

Am văzut deja: varierea tensiunii la intrarea unei LED-uri nu este cea mai bună soluție pentru a varia
luminozitatea... chiar dacă LED-ul nu se arde, dincolo de tensiunea sa de funcționare, durata sa de viață va fi
fortemente redusă. Dar ce contează, deoarece avem funcția PWM17. Vom asocia deci
potentiometru, pe intrare analogică pe A0, cu un LED pe PWM pe pinul 9.

Lista componentelor

1 LED
1 rezistență de 220Ω
1 potentiometru de 10kΩ sau 20kΩ

Circuit 13: Utilizaț i potentiometrul pentru a varia luminozitatea unei LED-uri

Circuit 13

17Vezi Proiectul 7 din acest curs.

91
Arduino la școală

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

Codul este foarte simplu. Ca și în cazul codului 17, se preia valoarea cuprinsă între 0 și 1023 pe A0, înainte
de la împărți la 4, pentru a o face compatibilă cu intervalul PWM, între 0 și 255. Ca pentru
Codul 18, am putea de asemenea imagina o mapare în locul divizării.

Cod 19: Vararea luminozităț ii LED-ului în PWM folosind un potentiometru

/*
Cod 19 - [Link], destinat Arduino-ului
Objectif: Lire la valeur du potentiomètre pour faire varier la luminosité de la LED en PWM
Philippe Krähenbühl
*/

int ledPin = 9; Se redenume ș te pinul 9 în "ledPin"

int analogPin = 0; Potentiometrul este conectat la pinul analogic 0
int val = 0; // variabila care stochează valoarea citită este setată la 0

void setup()

{
pinMode(ledPin, OUTPUT);
}

void loop()

{
val = analogRead(analogPin); lectura valorii analogice (poten ț iometru)
analogWrite(ledPin, val / 4); // valoarea analogică citită (0 la 1023) împăr ț ită la 4 (0 la 255)
}

92
Arduino la școală

Circuit 14: Aprinde LED-urile unui bargraph cu ajutorul unui potentiometru

Când rotim butonul pentru a crește volumul, ar fi interesant să avem un grafic care ne
indică nivelul.

Așadar, vom realiza un grafic cu ajutorul a 8 LED-uri.

Liste des composants

8 LED
8 rezistențe de 220Ω
1 potentiometru de 10kΩ sau 20kΩ

Circuit 14

PR1
Potentiometru

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 la școală

Cod 20: Afiș ează valoarea unui potenț iometru folosind un graf de bare
Cazul acestui cod este foarte interesant. Știm acum că avem 1024 de pași pe intrare.
analogic al Arduino. Când Arduino primește valoarea de 1024, 8 LED-uri vor trebui să fie aprinse. Astfel,
când va primi valoarea de 512, 4 LED-uri trebuie să fie aprinse (512 fiind în mod natural jumătate din 1024).
Vom împărți cele 1024 de trepte la 8, pentru a obține intervalul care va aprinde LED-urile una după alta.
alte. Atenție; începem să numărăm de la 0, nu de la 1. Aceasta este rațiunea pentru care cele 1024 de niveluri se
termină la 1023.

Ajungem la următorul rezultat:

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

A partir de là, il suffit d'aller chercher la valeur reçue, qu'on va stocker dans la variablereadValue, puis de la
a face să treacă prin 8 teste începând de la if... else consecutive.

[Link] are ca obiectiv să afiș eze în monitor valoarea primită de Arduino18.

/*
Cod 20 - [Link], destinat Arduino-ului
Obiectiv: Afi ș aț i valoarea unui potenciometru folosind un diagramă de bară
*/

// Informa ț ii despre LED-uri

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

// Informa ț ii despre potentiometru

int potPin = A0;
int citesteValoare;
int writeValue;

void setup() {

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

void loop() {

Scrierea valorii potentiometrului

în variabila "readValue"
*/

18Vezi codul 17
94
Arduino la școală

readValue = analogRead(potPin);

Inscrip ț ie în monitorul serial

de "Culoare=valoarea variabilei readValue"
*/

[Link]("\Val=");
[Link](readValue);
întârziere(200);

De la 0 la 127, led1
dacă (readValue < 128) {
led 1
digitalWrite(led1, ÎNALT);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, ÎNALT);
digitalWrite(led4, ÎNALT);
digitalWrite(led5, ÎNALT);
digitalWrite(led6, HIGH);
digitalWrite(led7, ÎNALT);
digitalWrite(led8, HIGH);
}

// De la 128 la 255, led 1 la 2

altfel dacă (readValue >= 128 && readValue < 256) {
[Link]("\tled 2");
digitalWrite(led1, HIGH);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
digitalWrite(led6, LOW);
digitalWrite(led7, LOW);
digitalWrite(led8, LOW);
}

// De la 256 la 383, led 1 la 3

altfel dacă (readValue >= 256 && readValue < 384) {
led 3
digitalWrite(led1, ÎNĂL Ț IME);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, HIGH);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
digitalWrite(led6, LOW);
digitalWrite(led7, LOW);
digitalWrite(led8, LOW);
}

De la 384 la 511, led 4

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

// De la 512 la 639, led 5

altfel dacă (valoareaCitită >= 512 && valoareaCitită < 640) {
led 5
digitalWrite(led1, HIGH);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, ÎNALT);
digitalWrite(led4, ÎNALT);

95
Arduino la școală

digitalWrite(led5, ÎNALT);
digitalWrite(led6, LOW);
digitalWrite(led7, LOW);
digitalWrite(led8, LOW);
}

// De 640 la 767, led 6

altfel dacă (readValue >= 640 && readValue < 768) {
led 6
digitalWrite(led1, HIGH);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, HIGH);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
digitalWrite(led6, ÎNALT);
digitalWrite(led7, LOW);
digitalWrite(led8, LOW);
}

De la 768 la 895, led 7

altfel dacă (readValue >= 768 && readValue < 896) {
led 7
digitalWrite(led1, HIGH);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, ÎNALT);
digitalWrite(led4, ÎNALT);
digitalWrite(led5, HIGH);
digitalWrite(led6, ÎNALT);
digitalWrite(led7, ÎNALT);
digitalWrite(led8, LOW);
}

// De 896 la 1023, led 8

altfel {
led 8
digitalWrite(led1, ÎNALT);
digitalWrite(led2, ÎNALT);
digitalWrite(led3, ÎNALTĂ);
digitalWrite(led4, ÎNALT);
digitalWrite(led5, ÎNALT);
digitalWrite(led6, ÎNALT);
digitalWrite(led7, HIGH);
digitalWrite(led8, ÎNALT);
}
}

Variante 1: utilizarea unui bargraf cu 10 LED-uri

La acest stadiu, putem folosi un potențiometru și afișa valoarea acestuia cu ajutorul unui grafic cu 10 LED-uri. Este suficient
pentru a nu mai împărți 1024 la 8, ci la 10 (rotunjind).

96
Arduino la școală

Variantă 2: utilizarea unui afiș aj LED de 8 cifre

Iată o variantă puțin mai sofisticată. Este din nou vorba despre afișarea valorii unui potentiometru. Dar
de data aceasta cu un afișaj LED de 8 cifre. Afișăm valoarea de 0 (min) la 9 (max).

97
Arduino la școală

Proiect 11: construirea unei staț ii meteo

Contribuția lui Jean-Pierre Dulex, Școlile secundare din Ormonts-Leysin

Obiectiv: a folosi un senzor de temperatură/umiditate și a afișa datele pe un ecran LCD

Acest proiect este sinteza intrărilor analogice, cu bonusul utilizării unui ecran pentru afișare
date.

Cunoașterea temperaturii și a umidității este o informație utilă pentru a trăi confortabil, pentru a stoca
alimente sau echipamente, pentru prognoze meteo... Cu acest proiect vom învăța cum să măsurăm aceste
două date și a le afișa pe un ecran LCD.

Cu proiectele anterioare, am învățat să măsurăm valori (intensitate luminoasă și temperatură)

cu senzori analogici grație intrărilor analogice ale plăcii Arduino care sunt dotate cu un
componente care transformă valorile analogice măsurate în valori numerice. Dar există și
numeroase senzori care transformă singuri valorile analogice măsurate în valori digitale
exploatabile prin mijloace informatice. Este cazul unui senzor de temperatură și umiditate foarte
răspândit și ieftin, DHT11 pe care îl vom folosi pentru acest proiect.

În colț ul din dreapta jos, de culoare albastră, senzorul DHT11, deasupra lui afiș ajul LCD cu două linii de 16 caractere care
indică temperatura ș i umiditatea actuală. De asemenea, observăm un potentiometru (rezistenț ă variabilă) pe partea
drea plăcii de circuit care are rolul de a regla luminozitatea ecranului.
98
Arduino la școală

Senzorul DHT11 este furnizat cu numeroase kituri pentru Arduino, altfel îl putem cumpăra pentru câțiva
francuri. DHT11 măsoară doar temperaturi pozitive, între 0°C și 50°C cu o precizie de ± 2°C
și rate de umiditate relativă de 20% până la 80% cu o precizie de ± 5%. Pentru nevoi mai precise sau dacă
se referă și la măsurarea temperaturilor negative, trebuie să te echipezi cu fratele său mai mare, DHT22, de două ori
mai costisitor, dar cu o gamă de măsurare care se extinde de la -50°C la +125°C, cu o precizie de 0.5°C și de 0
la 100% (precizie ± 2%) pentru măsurarea umidității relative.

Atenț ie: există versiuni ale senzorilor DHTxx care nu sunt pre-montate pe un circuit mic, cum ar fi modelul de
stanga de mai sus utilizat în acest proiect. Dacă este cazul, trebuie să adăugaț i o rezistenț ă de tragere de 5 până la 10 kOhmi ș i un
condensator de 100 nF între pini 1 (alimentare 5 V) ș i 4 (GND). Un schemă de cablare este disponibilă prin
ici :[Link]

Circuit 15

Utilizarea senzorului de temperatură ș i umiditate

Când ținem senzorul cu grila în fața noastră, pinul central este alimentarea, trebuie să fie
reliată la 5V de la Arduino. Picoața cea mai din dreapta va fi conectată la – (GND). Cât despre picoața cea mai...
stânga, este broș a de date, ea va fi conectată la intrarea digitală utilizată pentru a citi datele.

Odată ce aceste date sunt cunoscute, montajul este o joacă de copii și un schema este inutilă, vom alege
le Pin7 pentru date:

99
Arduino la școală

Cod 21: Achiziț ionaț i datele senzorului ș i afiș aț i-le.

Scopul acestui cod este de a achiziționa prin una dintre pinurile digitale ale Arduino-ului, datele de temperatură
și umiditatea transmise de senzorul DHT11, apoi să le afișeze pe ecranul computerului. Pentru
pentru a comunica cu senzorul, este necesar mai întâi să descărcați și să instalați biblioteca specifică
la acest senzor (sau mai bine zis una dintre bibliotecile pentru acest senzor, deoarece există mai multe versiuni).
bibliotecile sunt seturi de funcții care se adaugă funcțiilor de bază ale software-ului [Link].
Unele biblioteci sunt preinstalate, de exemplu cea intitulată LiquidCrystal de care vom avea nevoie
mai târziu pentru afișarea pe ecranul LCD, altele trebuie să fie instalate de utilizator pe măsură ce
nevoile sale. Biblioteca DHTLib pe care o vom folosi pentru acest proiect face parte din aceasta din urmă
categorie și trebuie, prin urmare, să fie instalată „manual”.
Începând cu versiunea 1.6.0 a IDE-ului Arduino, un manager de biblioteci a permis simplificarea considerabilă
instalarea și actualizarea bibliotecilor. Managerul este accesibil prin meniul Schiță->Includere
o bibliotecă->Gestionați bibliotecile. O fereastră de gestionare a bibliotecilor apare în
în care este posibil să căutați o nouă bibliotecă tastând numele acesteia în câmpul de căutare
în colțul din stânga sus sau de a face actualizări ale bibliotecilor existente.

În partea de sus, tastând dht în câmpul de căutare obț inem pe locul doi biblioteca DHTLib pe care noi
să folosim. Nu rămâne decât să o instalăm făcând clic pe butonul care apare în dreapta când o selectăm.

O soluție alternativă pentru a instala o bibliotecă constă în a descărca fișierul .zip al bibliotecii
dorință, apoi să o instalați prin meniul Schiță->Includeți o bibliotecă->Adăugați o bibliotecă.zip.

Biblioteca DHTLib poate fi descărcată de aici :

[Link]

Notă: pe calculatoarele elevilor, bibliotecile suplimentare sunt instalate în dosarul personal al utilizatorului
ș i vor fi therefore accesibile doar pentru acest singur utilizator, este necesar să aveț i acces de administrator pentru a instala o
bibliotecă pentru toț i utilizatorii unui computer.

Atenție, pentru ca biblioteca nou instalată să fie utilizabilă, trebuie să ieși și apoi să repornești Arduino.

Biblioteca ad hoc fiind acum instalată, putem trece la cod:

/*
Cod 21 - [Link], destinat Arduino-ului
Obiectiv: Afi ș aț i temperatura ș i umiditatea pe un ecran
*/

//***** ANTET DECLARATIV *****

100
Arduino la școală

#include <dht.h> //încărcăm biblioteca

dht DHT; //creăm obiectul senzorului DHT11

#define DHT11_PIN 7 //se define Pinul care va fi folosit pentru a primi datele

void setup() // începutul func ț iei setup()

{
[Link](9600); //Pour une fois, l’ouverture du port série et la définition de sa
viteza în bauds este utilă, chiar indispensabilă, deoarece vom folosi acest port pentru a afi ș a
valorile senzorului.
}

//***** FUNCTIE LOOP = Cod de ini ț ializare *****

// Func ț ia setup() este executată prima dată ș i doar o singură dată, la pornirea programului

void loop() // începutul func ț iei loop()

{
int chk = DHT.read11(DHT11_PIN); pe lit citim starea senzorului
[Link]("Temperatura = "); //scriem cuvântul Temperatură pe monitor
[Link]([Link]); //afişăm pe aceeaşi linie temperatura citită
[Link]("Umiditate = "); //scriem cuvântul Umiditate pe monitor
[Link]([Link]);//afi ș ăm pe aceea ș i linie umiditatea citită
intârziere(1000); //facem o pauză de 1 secundă între 2 interogări ale senzorului
}

Pentru a vizualiza datele transmise de senzor, trebuie să deschideți în continuare o fereastră a monitorului serial pe
calculatorul dvs.: Meniu Unelte -> Monitor serial.

Atâta timp cât monitorul serial este deschis, temperatura ș i umiditatea măsurate se afiș ează o dată pe secundă.

101
Arduino la școală

Circuit 16

Afiș area valorilor măsurate pe un ecran LCD

Afișarea rezultatelor măsurătorilor pe monitorul serial este foarte plăcută, dar dacă dorim să facem o
instalarea de măsurare permanentă și autonomă, această soluție nu este potrivită, deoarece trebuie ca computerul
aşa că este mereu aprins şi conectat la placă. Afisajul pe un mic ecran LCD este o soluţie bună
mai elegantă și practică. Unul dintre cele mai răspândite ecrane LCD din lumea Arduino și care este adesea
furnizat cu kiturile de bază este modelul numit 16x2 LCD (este capabil să afișeze două rânduri de 16 caractere
la achiziție un astfel de ecran costă între 7 și 15€.

Notă: scopul final este de a afiș a temperatura ș i umiditatea transmise de senzorul DHT11, este
recomandat să lăsaț i circuitul 9 în loc (pe o parte sau o extremitate a plaselor de circuit, altfel el
va trebui să le recablăm mai târziu. Imaginile de mai jos nu includ intenț ionat DHT11,
întotdeauna conectat la Pin7 pentru a îmbunătăț i lizibilitatea lor.

Lista componentelor :

1 ecran LED 2x12

1 potenciometru (rezistență variabilă)
1 rezistență de 220Ω
1 senzor DHT11 (deja cablat din circuitul 9)

Există o mare varietate de modele de ecrane LCD, unele foarte practice având deja pini care
depășesc fața inferioară și care se încastrează direct în breadboard, altele necesitând
utilizarea conectorilor masculini-masculini pentru a se conecta la breadboard sau direct la placă
Arduino prin cabluri de legătură.
102
Arduino la școală

Toate modelele de ecrane LCD sunt dotate cu 16 pini, iar cablarea este următoarea:

Primii doi pini din stânga servesc pentru alimentarea ecranului. Pol negativ sau GND pentru
premier și pôle pozitiv (5V) pentru 2èmă.
Cel de-al treilea pin este conectat la un potentiometru și servește pentru a ajusta contrastul ecranului LCD.
Al 4-lea, notat RS pentru Register Select, este conectat la pinul 12 al Arduino-ului. El servește la selectarea zonei
memoria ecranului LCD în care vom scrie.
Al cincilea trebuie să fie conectat la masă (GND).
Al 6-lea, notat E pentru Enable, este conectat la pinul 11 al Arduino. Acesta permite inițierea sau nu a scrierii.
în zonele de memorie.
Următoarele patru (7, 8, 9 și 10)ème) sunt conectate la pământ (GND).
Cei patru care urmează (11 la 14)ème, notați 5, 4, 3, 2 pe diagrama de mai sus, deoarece se conectează la
Pinii 5, 4, 3, 2 de la Arduino. Aceștia sunt folosiți pentru transmiterea datelor de afișat.
Cei doi pini din dreapta (15 și 16ème) servesc pentru a alimenta LED-ul de retroiluminare al ecranului LCD.
Atenție, penultimul (pola pozitiv 5V) trebuie neapărat să fie protejat de o rezistență de aproximativ
220Ω. Ultimul este conectat la polul negativ (GND).

Odată ce montajul este efectuat și Arduino este conectat la portul USB al computerului, puteți rotunji
potentiometru și veți observa cum se modifică contrastul ecranului.

Cod 22: Afiș ează datele pe ecranul LCD

Spre deosebire de biblioteca „DHTLib” folosită anterior, biblioteca „LiquidCrystal” este

inclus cu software-ul Arduino IDE, dar trebuie totuși să-l instalezi înainte de a putea să-l folosești.
Menu :Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques
În fila de căutare, tastați: "LiquidCrystal". Dacă biblioteca este deja instalată, veți vedea notat
"INSTALAT" lângă numele său, altfel faceți clic pe Instalați

Atenție, pentru ca biblioteca recent instalată să fie utilizabilă, trebuie să ieșiți și să relansați Arduino.
IDE.

/*
Cod 22 - [Link], destinat Arduino-ului
Obiectiv: Afi ș area temperaturii ș i umidită ț ii pe un ecran LCD
*/

//***** ANTET DECLARATIV *****

103
Arduino la școală

#include <dht.h> //includem biblioteca pentru senzorul DHT11

#include <LiquidCrystal.h> //includem biblioteca pentru ecranul LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);//creăm obiectul LCD ș i definim pinii utiliza ț i

dht DHT; Pe dăm obiectul senzorului DHT11

#define DHT11_PIN 7 //se define ș te pinul utilizat pentru datele DHT11

void setup(){
[Link](16, 2); //ini ț ializăm comunicarea cu ecranul LCD
}

void loop()
{
int chk = DHT.read11(DHT11_PIN); Citim datele de la senzorul DHT
[Link](0,0); //plasează cursorul pe ecranul LCD la începutul liniei 1erelinie
[Link]("Temp: "); Scriem cuvântul "Temp: " la locul cursorului
[Link]([Link],1);//se scrie temperatura citită de senzor, cu 1 cifră
după virgulă
[Link]((char)223); //se adaugă simbolul ° după valoarea temperaturii
[Link]("C"); //adăugăm litera C pentru grad Celsius
[Link](0,1); //mutăm cursorul de pe ecranul LCD la începutul celei de-a 2-a linii
[Link]("Umiditate: "); Scriem cuvântul "Hum. rel: " la locul cursorului
[Link]([Link],1); se scrie umiditatea relativă citită de senzor, cu 1
cifră după virgulă
% //se adaugă simbolul "%" după valoarea umidită ț ii
întârziere(1000); //a ș teptăm un secund înainte de a continua cu lectura următoare
}

104
Arduino à l'école

Proiectul 12 : Utilizarea unui servomotor

Servomotoarele, adesea prescurtate în „servo” de către utilizatorii lor, sunt motoare de un tip
particular, foarte apreciați pentru a face să funcționeze ceva până la o poziție foarte precisă și capabili să
menținerea acestei poziții până la sosirea unei noi instrucțiuni. Ele sunt foarte utilizate în modelism
direcția mașinilor teleghidate, comanda stabilizatoarelor de direcție și de adâncime pe avioane,
etc…), dar au și locul lor în robotică și industrie, de exemplu, în vane pentru a reglementa
fluxuri de lichide.

Un servomotor denumit „9 grame” foarte răspândit în lumea Arduino.

În acest capitol, vom învăța să folosim cel mai răspândit servomotor în modelism și în
electronică mică, este vorba despre modelele numite 9g, pentru 9 grame. Exterior, se prezintă sub forma
d’un petit rectangle, avec deux petits rebords sur les côtés pour le fixer solidement et un axe décentré su
la căruia se pot fixa brațe interschimbabile pentru a asigura legătura mecanică cu piesa care trebuie să se miște.
Chiar dacă există servomotoare cu rotație continuă, imensa majoritate a modelelor sunt capabile să
mișcați-le brațul pe 180° doar.

Văzut din interior, un servomotor este puțin mai complex decât pare:

105
Arduino la școală

Un mic motor cu curent continu este conectat la un potentiometru (rezistență variabilă) prin intermediul unei
circuit electronic care permite controlul fin al motorului în funcție de poziția potentiometrului.
Pe axa de ieșire a motorului, o serie de angrenaje permite creșterea cuplului său (forța sa utilă) prin
reducând viteza sa de rotație.
Când motorul pornește, rotițele se animă, brațul se mișcă și duce cu el în mișcare
potentiometru. Dacă mișcarea se oprește, circuitul electronic ajustează continuu viteza motorului pentru
că potentiometrul și, prin extensie, brațul motorului rămâne întotdeauna în același loc. Este ceea ce
permite de exemplu unui braț al unui robot să nu cadă sub efectul propriei greutăți atunci când
mișcarea se oprește!

Utilizarea unui servomotor cu Arduino

Pentru a comanda un servomotor, trebuie să-i trimiteți un tren de impulsuri ale căror perioadă (interval de timp
între fiecare impuls) este întotdeauna de 20 ms (milisecunde). Ceea ce va varia și care în final va determina
poziția brațului nu este perioada, ci mai degrabă durata impulsului:

• pentru un impuls de 1 ms, servomotorul se pune în poziția 0°

• pentru un impuls de 1.5 ms, servomotorul se poziționează la 90°
• pentru un impuls de 2 ms, servomotorul se pune în poziția de 180°

Această schemă aminteș te de PWM-ul pe care l-am folosit pentru a varia intensitatea unei LED-uri, de exemplu, principiul este
de fapt foarte asemănătoare, cu un tren de unde pătrate deoarece datele transmise sunt digitale (HIGH
ou LOW) fără valori intermediare.

Conectarea unui servomotor nu prezintă dificultăți. Cablul roșu se conectează la sursa de alimentare (5V), cablul
negru se conectează la pământ (GND) și firul galben (atenție, uneori alb sau portocaliu sau… în funcție de material)
nu conectați fabricanții chinezi?) la orice ieșire digitală a Arduino (pin 0 la 13)

106
Arduino la școală

Circuit 17

Cod 23: A face să se miș te braț ul unui servomotor în ambele sensuri

Obiectivul celor trei coduri de mai jos este de a se familiariza cu utilizarea servomotoarelor.

Pentru cele 3 coduri, vom avea nevoie de biblioteca Servo, care face parte din software-ul Arduino.
care nu este instalat în mod implicit.

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

Atenție, pentru ca biblioteca nou-instalată să fie utilizabilă, trebuie să ieșiți și apoi să relansați Arduino

/*
Cod 23 - [Link], destinat Arduino-ului
Obiectiv: A face bra ț ul unui servomotor să se mi ș te într-o direc ț ie, apoi în cealaltă, la nesfâr ș it
*/

//*****ANTET DECLARATIV*****

#include <Servo.h> //includem biblioteca pentru a controla un servomotor

Servomotor monServo; //se creează obiectul monServo

void setup()
{
[Link](9); //se define ș te pinul utilizat de servomotor
}

void loop()
{
for (int pozitie = 0; pozitie <=180; pozitie ++){ //se creează o variabilă pozitie care
ia valori între 0 ș i 180 de grade
[Link](position); bra ț ul servomotorului preia pozi ț ia variabilei
poziț ie
107
Arduino la școală

întârziere(15); //a ș teptăm 15 milisecunde

}
pentru (int pozitie = 180; pozitie >= 0; pozitie --){ //de data aceasta variabila pozitie
trece de 180 la 0°
[Link](poziț ie); bra ț ul servomotorului ia pozi ț ia variabilei
poziț ie
întârziere(15); bra ț ul servomotorului ia pozi ț ia variabilei pozi ț ie
}
}

Odată ce codul dumneavoastră este funcțional, nu ezitați să testați diferite timpi de așteptare, să solicitați
parcurs de 90° numai sau alte valori, de a schimba pasul incrementelor utilizate, de exemplu de 5° în
5°, etc.. Și observați de fiecare dată noul rezultat.

Am spus vorbind despre servomotoare că, odată ce o poziție este atinsă, motorul, grație...
informații, menține brațul în poziția solicitată până când un nou ordin îi ajunge. Aceasta
funcția de menținere este primordială atât în modelism, cât și în robotică. Dacă un braț robotic apucă
ceva de exemplu, nu trebuie să cadă doar sub efectul greutății piesei apucate și a sa
brațe. Pentru aceasta, servomotorul trebuie să continue constant să ajusteze poziția de menținut. Mică
varianta de cod de mai jos ne va dovedi de o parte că poziția solicitată este menținută chiar și când
cerem Arduino-ului să efectueze o altă sarcină (aici, să aprindă diodele 13) și puteți încerca de asemenea să
întoarce servomotorul manual (fără a forța!) pentru a simți rezistența la rotație pe care o exercită servomotorul care încearcă să
întreține-ți poziția.

Codul 24: Servomotor ș i gestionarea sarcinilor

/*
Cod 24 - [Link], destinat Arduino
Obiectiv: a dovedi că biblioteca Servo permite servomotorului să ac ț ioneze ș i să se men ț ină
în pozi ț ie chiar ș i atunci când Arduino efectuează o altă sarcină.
*/

//*****ANTET DECLARATIV*****

#include <Servo.h> //inclus biblioteca pentru a controla un servomotor

Servo monServo; // se creează obiectul monServo

func ț ie de configurare()

{
[Link](9); //definim Pin-ul utilizat de servomotor
pinMode(13,OUTPUT); //Pinul 13 este setat pe modul OUTPUT
}

void loop()
{
[Link](0); // spunem obiectului să pună servo la 0°
diode13(); // apelarea func ț iei diode13 care este definită mai jos
[Link](180); // îi spunem obiectului să pună servo-ul la 180°
diode13(); // apelarea func ț iei diode13
}
void diode13() //vom face să clipească de 15 ori dioda 13
{
pentru (int t=0;t<15;t++) {
digitalWrite(13, ÎNALT);
întârziere(100);
digitalWrite(13,LOW);
întârziere(100);
} }

La voi să variați și unghiurile solicitate, numărul de scintilări ale LED-ului 13, timpul
de așteptare…

108
Arduino la școală

Și pentru a încheia cu pilotarea servomotoarelor, iată un cod care nu ezită să provoace.

efect mic. Veți adăuga un potentiometru la montajul dvs. și este poziția potentiometrului pe care o
tournerez care va servi la poziționarea brațului servomotorului.

Pentru a te ajuta, iată schema montajului :

Circuit 18

Cod 25: comanda un servomotor cu un potentiometru

Acest cod foarte simplu permite. Cu ajutorul unei mapări, leagă cele 1024 de pași ai unui potentiometru de 180° de
rotatia unui servo.

/*
Cod 25 - [Link], destinat Arduino-ului
Obiectiv: a comanda un servomotor cu un poten ț iometru
*/

//*****ANTET DECLARATIV*****

#include <Servo.h> //includ biblioteca pentru a controla un servomotor

Servo monServo; //creăm obiectul meuServo
int pinmonServo=9; //definim Pin9 legată de comanda servomotorului
int pinPotar=A0; //definim pinul analogic A0 pentru citirea potentiometrului

void setup()
{
[Link](pinmonServo); // legăm obiectul monServo la pinul de comandă
}

void loop()
{
int valeurPotar=analogRead(pinPotar); // citim valoarea potentiometrului
int unghi=mapare(valeurPotar, 0,1023,0,180); //transformăm valoarea analogică citită în valoare
unghi între 0 ș i 180°
[Link](angle); //punem bra ț ul servomotorului în pozi ț ia unghi
}

109
Arduino la școală

Cod 26: Comandarea a două servomotoare cu ajutorul unui joystick

Fiecare jucător de jocuri video cunoaște joystick-ul, această interfață de comandă. Acesta se bazează pe un sistem de
coordonate într-o scară X și Y. Poziția pe fiecare scară este
determinat de un potențiometru. În cazul Arduino, se va descompune
fiecare axă în 1024 de pași. Astfel, zero, adică poziția centrală,
correspond à 512 sur l'axe X et Y.

Prin aplicarea a ceea ce am învățat cu codul 25, devine posibil să comandăm două servomotoare cu
un joystick.

Pentru cablare, un joystick are un pin +5V (une dată notat VCC) pentru alimentarea electrică, un
brocheGND(împământ), două broșeVRx șiVRy, respectiv pentru poziția axei X și Y și în cele din urmă o
brocheSW (câteodată numită SEL). Aceasta corespunde butonului de tip push, când se apasă pe
joystick

Circuit 19

110
Arduino la școală

Codul 26 nu este decât o adaptare a codului 25: este vorba despre adăugarea unui al doilea servo.

/*
Cod 26 - [Link], destinat Arduino-ului
Obiectiv: a comanda două servomotoare cu un joystick
*/

//*****ANTET DECLARATIV*****

#include <Servo.h> //includem biblioteca pentru a pilota un servomotor

Servo monServo1; //creăm obiectul monServo1
Servo monServo2; //creăm obiectul monServo2
int pinmonServo1=8; //se define ș te pinul 8 legat de controlul servomotorului
int pinmonServo2=9; //definim pinul 9 legat de comanda servomotorului
int AxeX=A0; //definim pinul analogic A0 pentru citirea axului X
int AxeY=A1; //definim pinul analogic A1 pentru citirea axului Y

void setup()
{
[Link](pinmonServo1); //legăm obiectul monServo1 la pinul pinmonServo1
[Link](pinmonServo2); //legăm obiectul monServo2 la pinul pinmonServo2
}

void loop()
{
int valeurAxeX=analogRead(AxeX); // citim valoarea axei X
int angleX=map(valeurAxeX, 0,1023,0,180); //transformăm valoarea analogică citită în valoare
unghi între 0 ș i 180°
[Link](angleX); //punem bra ț ul servomotorului 1 în pozi ț ia unghi
int valeurAxeY=analogRead(AxeY); // citim valoarea de pe axa Y
int unghiY=mapare(valeurAxeY, 0,1023,0,180); //transformăm valoarea analogică citită în valoare
unghi între 0 ș i 180°
[Link](angleY); //punem bra ț ul servomotorului 2 în pozi ț ia unghi
}

Să vedem acum o altă modalitate de a obține același rezultat. Aici, stocăm valorile trimise de către
joystick respectiv în variabilele X și Y. Apoi folosim un calcul pentru a converti valorile celor două
variabile în grade, adică 1024 pași în 180 de grade: 180/1024, ceea ce dă o valoare de 0.1756° pe pas.

/*
Cod 27 - [Link], destinat Arduino
Obiectiv: a comanda două servomotoare cu ajutorul unui joystick
Inspirat de [Link]
*/

##include <Servo.h> //Bibliotecă ș i declara ț ia servomotoarelor

Servo monservo1;
Servo monservo2;

int AxeY = 1; //Declara ț ia pinilor analogici utiliza ț i pentru a conecta axa X ș i Y

int AxeX = 0;

void setup() {
[Link](9600);
pinMode(AxeX, INPUT); //Declara ț ia modurilor pinilor în INPUT ș i amplasarea servo-urilor
[Link](8);
pinMode(AxeY, INPUT);
[Link](9);

}
void loop() {
int X=analogRead(AxeX); //Mai întâi citim valoarea analogică de pe pinul X (0v-
5v)=>(0-1023)
X=X*0.1756; //facem o calibrare conform limitelor servo-ului (0-1023)=>(0-180)
X=180-X;//Folosim acest lucru pentru a schimba direc ț ia de orientare a suportului
[Link](X); //Se scrie valoarea finală calibrată ș i orientată

111
Arduino la școală

int Y=analogRead(AxeY);//Se cite ș te mai întâi valoarea analogică de pe pinul Y (0v-5v)=>(0-

1023)
Y=Y*0.1466; //facem o calibrare în func ț ie de limitele servo-ului (0-1023)=>(0-150)
[Link](Y);//Scriem valoarea finală calibrată
} Y=Y*0.1466; //facem o calibrare în func ț ie de limitele servo-ului (0-1023)=>(0-150)
[Link](Y);//Se scrie valoarea finală calibrată
}

Devine atunci posibil să comanzi un braț robotic cu 4 servomotoare doar cu două joystick-uri.
pentru servomotoare, trebuie prevăzută o sursă de alimentare externă și să nu uităm să realizăm o împământare
comună între alimentare, Arduino, servomotoare și joystick-uri.

Concluzie (provizorie)

Concluzie provizorie, deoarece posibilitățile Arduino și ale electronicii sunt nelimitate. Pe măsură ce
dorințele elevilor mei, descoperirile și experimentările noastre, dar și contribuțiile cititorilor,
acest curs este constant actualizat.

Acest curs a fost redactat de Frédéric Genevey, profesor la Școlile Primare și Secundare din Ecublens.
Suisse,[Link]

112