Ministerul Educaţie si Cercetarii al Republicii Moldova

IP Centrul de Excelență în Energetică și Electronică

Catedra ,, Automatizari ''

Lucrarea de laborator NR.3,5

Disciplina : Automatizare cu microprocesoare
Tema : Elaborarea și testarea programului Lumini dinamice

A elaborat elevul din grup AT -0119 Cortac Marin

A verificare profesorul Litvin Nicolae

Chișinau 2023
 Lucrare de laborator 3 și 5
Tema: 1.Elaborarea și testarea programului Lumini dinamice
2.Elaborarea și testarea programului de aprindere dinamică a 8 leduri
cu microcontrolere
Suflecă-ți mânecile și hai să explorăm! În această activitate practică, vom efectua unele
experimente de bază cu ajutorul breadboard-lui pentru a vă prezenta conceptele de bază ai
platformei Arduino  și aspectele fluxului de activități în explorare.

În primul rând montați-vă pentru succes (pozitiv), la operarea cu bord-l Arduino Uno și

placa de executare a conexiunilor breadboard la montare. Această posibilitate oferă un
beneficiu imens de a realiza prototipuri împreună în timpi foarte mici și asigurarea de situații
neplăcute ca exemplu un proiect nereușit de la idea de concepere! Breadboard montat pe
platforma de plastic are un autocolant car permite după necesitate să-l dezlipiți de pe acesta
și Arduino Uno se atașează cu șuruburi de la partea inferioară. Nu contează în ce fel se
confruntă Arduino în raport cu placa de extindere. O șurubelniță mică este la îndemână aici,
astfel încât puteți cu ușurință prinde piulița din partea de sus a bordului  cu bulonul din
partea de jos. Pentru o potrivire sigură sunt necesare doar în două locuri de prindere cu seturi
din piulițe/buloane  în diagonală.
Pasul 1: Consumabile sau echipamentul de operare
Pentru a urma împreună cu această activitate vom avea nevoie de:
 Computer care rulează software-ul Arduino IDE
 Unele dintre elementele de la Adafruit Arduino Uno Buget Pack:
 Arduino Uno bord-ul
 Cablu USB A-B
 Placă de prototipare (Breadboard) de dimensiuni medii/mare
 Fire de conexiune
 5 LED-uri cu iluminare roșu de 5 mm
 LED-uri luminoase de culoare roșu, verde și albastru (câte unul sau un LED
RGB)
 5 rezistențe 220-1Kohm (important toate aceeași valoare, orice valoare din acest
interval)
 Placă de fixare din plastic pentru breadboard și Arduino
 Șurubelniță mică cu cap plat
Pasul 2: Breadboards solderless
Plăcile de dezvoltare fără lipire din partea inferioară sunt pentru circuitele de prototipuri
rapid și ușor. O puteți asemăna cu o placă care poate fi (ștearsă) dezasamblată, o mare pentru
utilizată la brainstorming rapid și experimentare. Plăcile de dezvoltare vă permit să conectați
componente utilizând conectori de fixare metalici conectați în noduri multi-port. Părțile
conductoare ale plăcii de dezvoltare permit electronilor să parcurgă curentul între
componentele, firele conectate pe ea, prin intermediul nodurilor de conexiune aflate în parte
de desupt.

În dreapta puteți vedea în interiorul unei plăci de dezvoltare modul în care aceste noduri sunt
conectate. Două Magistrale lungi trec pe fiecare parte laterală, marcate cu linii roșii și
albastre în față. Aceste conectori lungi sunt de obicei folosite pentru conexiuni de alimentare
cu tensiune DC(+,-) sau AC(~), care sunt utilizate destul de des. Liniile pe orizontale sunt
mai mici care cuprind mijlocul plăcii sunt pentru conectarea firelor și componentelor.
Observați separatorul în mijlocul plăcii, asta există pentru a oferi cipurilor un loc unde să se
monteze, oferind acces independent la fiecare dintre pinii săi.
Este nevoie de unele practici pentru a obține o experiență în minimă în înțelegerea circuitului
asamblat în baza plăcii de dezvoltare. S-ar putea să fie necesar să reveniți de mai multe ori la
imaginea unde este descris interiorul breadboard-lui; E ceva normal!

Pasul 3: Asamblarea circuitului de iluminare intermitent (clipire) 

 -
Primul circuit îl vom realiza pe placa de dezvoltare conectând un LED roșu la placa Arduino
Uno. Să începem încet, cu o conexiune prin fire cum este descris în continuare. Luați
aceleași fire colorate pentru a urma mai ușor realizarea întocmai a circuitului de asamblare.
Verificați de două ori dacă cablul USB este deconectat înainte de a face orice cablare la bord.
Luați un fir roșu și conectați-l cu un capăt în pin marcat 5V de pe bord-ul Arduino UNO.
Conectați celălalt capăt al firului roșu la Magistrala de pe placa de dezvoltare marcată cu o
linie roșie- acesta va fi magistrala electrică +5V.

În mod similar, luăm un fir albastru și conectați-l într-unul dintre pinii marcat cu textul
GND, chiar lângă firul roșu. Există trei pini de legare la pământ pe o placă Arduino Uno, și
toate sunt conectate în același circuit de alimentare cu restul plăcii, așa că nu contează pe
care îl alegeți. Conectați celălalt capăt al firului albastru la magistrala albastră de pe placa de
dezvoltare. Aceasta este o
configurație de bază pe
care o veți utiliza din nou
și din nou, și ar trebui să
fie conectate după
necesitate la celelalte două
magistrale ale breadboard-
lui din partea opusă. .
Circuitul din acest conținut
se va conecta la magistrala
 la sol, și în celălalt se va folosi
conectarea direct a unor
componente la magistrala de
alimentare 5V.
Apoi, conectați un fir galben
în Arduino UNO pin 13.
Conectați celălalt capăt la
orice nod al liniilor
orizontal de pe placa de
dezvoltare (rândul 10
prezentat mai sus). Pentru
acest prim circuit, toate
conexiunile
dumneavoastră ar trebui
să fie construite în
jumătatea breaboard-lui
cât mai apropiat de placa
Arduino.
Conectați un alt fir
albastru de la orice
conector de pe șina GND
(-) la un alt rând orizontal
de pe placa de dezvoltare
(rândul 18 prezentat mai sus).

Acum ia un rezistor 1K (sau dacă e marcat color: benzile maro-negru-roșu-auriu), și

conectați unul dintre pinii săi (nu contează care) în același rând ca firul de conexiune
albastru. Rezistențele toate arată similar, cu excepția benzilor folosite pentru a indica
valoarea lor.
Conectați celălalt capăt într-un rând chiar lângă firul galben.

Acum luăm un LED roșu (diodă emițătoare de lumină). Vezi atent cu unul din pinii săi este
mai lungă decât cealaltă? Acesta mai lung (numit anod) este pinul unde se aplică tensiunea
pozitivă, iar pinul mai scurt este (numit catod) și se aplică o tensiune negativă. În circuitul pe
care îl construim, tensiunea pozitivă vine de la pinul D13 Arduino și trece prin LED și
rezistor la GND pământul, așa că ar trebui să conectați pozitiv (mai lung) către firul galben și
negativ (mai scurt) către rezistor. Un rezistor ne ajută la limitarea curentului care trece printr-
un LED, și ne asigură curentul nominal de funcționare a LED-lui.
La conectarea cablul USB către PC și placheta Arduino, LED-ul trebuie să înceapă imediat
să clipească! E programat să clipească orice e conectat la pinul D13. Aceasta include LED-ul
de pe bord pe care l-ați văzut în configurarea software-ului, precum și cel pe care tocmai la-ți
conecta prin fire prin intermediului plăcii de dezvoltare.

Dacă LED-ul nu clipește, deconectați cablul USB, apoi inversați LED-ul și reconectați cablul
USB-ul; poate LED-ul a fost doar conectat în mod indirect (care nu se va deteriora, dar nu va
lumina). Sau poate că unul dintre celelalte fire sau rezistor nu sunt conectate corect.
Verificați de două ori conexiunile în raport cu diagrama circuitului:
În continuare vom folosi Arduino IDE pentru a crea programe ca acesta din exemplul de mai
jos și trimite către bord-ul Arduino pentru a rula. Încărcăm această schiță pe placa Arduino
în configurarea cum e în exemplul de mai jos, dar pentru a experimenta mai mult este
recomandat să culegeți în mod manual în rîndul de cod al programului, dar puteți găsi
această schiță și multe alte exemple urmând calea din meniul software-ul Arduino IDE (File
-> Examples -> 01.Basics -> Blink).

Exemple de schițe fac puncte de plecare pentru experimentare și propriile proiecte pe linie.
Aceste exemple sunt de neprețuit pentru experiența dumneavoastră de învățare Arduino;
folosiți-le! Este specific de a face o mulțime de greșeli de scriere atunci când scrie primul
cod, care poate provoca erori confuze. Exemplele vin la îndemână este atunci când doriți să
reparați propriul cod nu-lucru (numit depanare). Compararea muncii cu exemplele definitive
de cod funcțional poate fi o strategie utilă pentru a ajuta la depanarea codului.
Să aruncăm o privire mai atentă la elementele acestui sketch  Arduino. În primul rând este o
notificare mică:
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
Acesta este doar un comentariu, menit să ajute oamenii să înțeleagă programul. În
programele Arduino, comentariile sunt semnificate cu două bare oblice; nimic pe o singură
linie după bare oblice este aruncat atunci când vine vorba de timpul pentru
a compila (construi acest cod în versiunea care poate fi citită de microcontroler, care va rula
pe placa Arduino). Prin urmare, comentariile nu contribuie la dimensiunea programului dvs.,
asa ca comentariu departe! Puteți uita cu ușurință ceea ce fiecare secțiune a programului
dumneavoastră ar trebui să realizeze; Vă recomandăm să obțineți în obiceiul de a comenta
puternic codul dvs., și citirea comentariilor în fiecare dintre exemplele pe care le folosim în
aceste exemple descrise aici.
int led = 13;
Urmează o declarație de  variabilă. Vă puteți gândi la o variabilă ca la o găleată pentru unele
informații. Variabilele, ar fi gălețile, au dimensiuni și forme pentru a deține diferite tipuri de
informații. Variabilele au, de asemenea, nume, ar fi o etichetă obligatorie pe găleată. Această
linie de cod definește o variabilă de tip int, care înseamnă întreg. Amintiți-vă înapoi la
lecțiile de matematica de la școala primara, atunci când este posibil să fi învățat că numerele
întregi sunt numere întregi (pozitive sau negative). Deci avem o găleată care poate ține un
întreg. Este eticheta led , dar ar putea fi la fel de ușor "MyLEDPin" sau "almeuLEDPin"
orice cuvânt unic (litere și numere numai, sensibile la litere), deoarece această parte a
declarației variabilelor este de până la tine. Vă sfătuiesc să folosiți nume descriptive pentru
variabilele dvs., astfel încât să puteți urmări ceea ce programul dumneavoastră este capabil
de a face! 
După linia de cod de mai sus, de fiecare dată când vom vedea "led" în program vor fi
înlocuite cu valoarea numărului 13. Acest lucru este la îndemână pentru configurații mai
complexe, dar și în cazul nostru, în care vrem ca o valoare de referință (pinul de conectare a
LED-ul către microcontroler) adică în cazul nostru pinul 13 peste tot să facă referință în
cadrul programului doar la acest pin, iar în cazul în care modificările de cablare vor fi 
efectuate și vor fi trecute către alt por a microcontrolerului atunci se va modifica în
programul nostru doar doar valoarea numărului (în cazul nostru 13 în alta) astfel se va 
actualiza într-un singur loc în codul programului.
    // the setup routine runs once when you press reset:
    void setup() {
După mesajul sugerat de comentariu, orice conținut cod inclus în cadrul acoladelor { } al
funcției setup, se va executa o dată în sesiunea de program. Adică codul din interiorul
configurației acestei funcții se execută o singură dată când placa se alimentează prima dată la
sursa de alimentare sau de fiecare dată după apăsarea butonului de resetare al plăcii Arduino.
    // initialize the digital pin as an output.
    pinMode(led, OUTPUT);
}
Pinii 0-13 de pe placa Arduino sunt pini digitali i/o, ceea ce înseamnă că pot fi atât ca intrări
sau ieșiri. pinMode(); este o funcție, o modalitate prescurtată de a se face referi la subsete 
de comenzi "ascunse/mascate" dar care trebuie declarate. Arduino vă arată că recunoaște
anumite elemente de cod prin schimbarea culorii textului. Dacă vreodată un cuvânt cheie nu
își schimbă culoarea pe măsură ce îl tastați în Arduino, probabil că aveți o greșeală de
ortografie, eroare de scriere cu majuscule sau alte greșeli de scriere. Aceste informații
transmise funcțiilor sunt numite argumente. Deoarece variabila led va servi pentru
cunoașterea numărului pin-ul conectat cu LED-ul și este 13, iar starea este declarată
ca pinMode(led, OUTPUT); ieșire. Acestă șinie de cod configurează pinul 13 pentru a
controla un LED, iar acolada curbată închide configurația. }
   // the loop routine runs over and over again forever:
    void loop() {
Aceasta este partea principală a unui sketch Arduino, în cazul în care acțiunile ar fi
verificarea pinilor de intrare și controlul pinilor de ieșire, de obicei, se întâmplă. Totul
conținutul codului inclus între aceste acolade { }  ale funcție void loop() sau altfel zis buclat
la repetare va  avea loc până când bord-ul nu va fi deconectat de la alimenrae.

    digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

În prima line de cod din buclă este o funcție numită digitalWrite(); , care poate avea doar
două conținuturi a informației: un număr de pin  led, și valorile HIGH (on) sau LOW (off)
de stare. Aceste informații transmise funcțiilor sunt numite argumente. Deoarece
variabila ledva asigura numărul pin-lui în cazul nostru este 13, iar starea HIGH (on) va
impune conectarea LED-lui la tensiunea de alimentare prin portul dat al microcontrolerului,
în rezultatul digitalWrite(led, HIGH); LED-ul va lumina.
    delay(1000);               // wait for a second

delay();  este o altă funcție încorporată a lui Arduino. Se întrerupe programul pentru o durată
de timp, definită în milisecunde. Această linie de cod întrerupe programul pentru 1000ms
sau pentru o secundă.
 digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
Ca mai devreme, digitalWrite(); poate activa sau dezactiva un pin de ieșire. De data aceasta
se setează PIN-ul 13 în starea de nivelul jos LOW (off) adică LED-ul va fi oprit și nu va
lumina.
delay(1000);               // wait for a second
}
Această linie întrerupe programul pentru o secundă, iar acolada curbată } semnifică sfârșitul
buclei, care începe din nou imediat de la începutul void loop() {. Deci, pentru a rezuma,
programul conectează și după care dezactivează un LED cu intervale de o secundă. Să
încercăm să schimbăm intervalul. Modificați numărul de milisecunde într-o linie
de delay(); sau în ambele declarații. De exemplu, puteți crea o clipire mai diferită :
void loop() {
   digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
   delay(2000);                      // wait for two seconds
   digitalWrite(led, LOW);   // turn the LED off by making the voltage LOW
   delay(500);                       // wait for a half second
}
Încearcă să încarci pe placa Arduino această schița de clipire a LED-lui cu modificările
propuse. S-a comportat la fel sau diferit așteptați câteva secunde ?
Dacă este diferit înseamnă că bine sa lucrat! A fost o mulțime de informații. E în regulă dacă
nu înțelegi încă fiecare lucru în amănunte. Ca și învățare a oricărei limbi, limbajul de
programare Arduino are propria sintaxă și structură pe care trebuie să o navighezi, care va
deveni mai familiarizată cu practica obișnuită. Cel mai important lucru de reținut este că
puteți lucra cu cod fără să știți totul despre programare. Pe măsură ce treceți prin mai multe
exemple în această experiență de exersare, vă încurajez să aveți o fereastră deschisă în
brauzer cu pagina de referință a limbajului Arduino, care descrie fiecare element și
instrucțiune ale acestuia fiind grupate pe categorii 
Pasul 4: Adăugați mai multe LED-uri
Acum, că posedați capacitatea
de a controla un singur LED,
să adăugați ceva mai multe! La
restul LED-lor roșii la fel se
vor utiliza rezistențe de 1K.
Deconectați palca Arduino de
la portul USB / pentru a nu se
alimenta cu tensiune prin acest
port. Este recomandabil să
deconectați alimentarea de
fiecare dată când executați în
schema de circuit.

Conectați între ele cele două

perechi de magistrale opuse de
pe placa de dezvoltare: conectați
un fir care să conectează către
ambele magistrale electrice
(roșu, +) cât și un alt fir care
conectează către ambele
magistrale (albastru, -) sau
GND . Aceasta este o
configurație frecvent utilizată,
deoarece acum puteți accesa cu
ușurință tensiunea de alimentare
în ambele margini ale
breadboard-lui. Îndoiți pinii
rezistențelor la 90 de grade și tăiați capetele la aproximativ un sfert inch (6mm) de la îndoire.

Să adăugăm câteva noi LED-uri la jumătatea nefolosită a plăcii de dezvoltare. Începeți prin
conectarea unui rezistor aliniat de la GND (prize de-a lungul liniei albastre) la un rând de
breadboard. Conectați un LED roșu în placa de dezvoltare, conectând pinul său mai scurt
(negativ) la același rând cu rezistorul conectat mai devreme.
 Adăugați și restul rezistențe, LED-uri
rămase în mod analogic. Amintiți-vă
că rezistențele pot fi conectate în
orice direcție de orientare, dar LED-
uri au polaritate și lumina va fi
vizibilă numai atunci când curentul
electric trece prin dioda LED
polarizată direct.

Mutați conductorul galben de la

Arduino pin 13 la pin 7. Conectați un
alt fir galben de la Arduino pin 6 la
pinul pozitiv al următorului LED
vecin.

Conectați mai multe fire galbene în conformitate cu diagrama circuitului realizat în Fritzing (pinii Arduino 3-5
la led-urile rămase "borna pozitivă).
Creați codul de program în conformitate cu exemplul de mai jos:

Încărcați codul în placa Arduino Uno. Poate fi necesar să selectați portul din nou din meniul
de instrumente după replugging. Să învățăm să codăm o secvență de lumină, uitându-ne mai
atent la elementele programului:
    /*
  For Loop Iteration
 Demonstrates the use of a for() loop.
 Lights multiple LEDs in sequence, then in reverse.
 The circuit:  * LEDs from pins 3 through 7 to ground
 */
Această primă parte este doar un comentariu lung. Ați învățat deja despre comentarii cu o
singură linie, iar acum știți despre comentarii multi-line, a însemnat cu un /* pentru a începe
și  */ pentru a opri.
int timer = 200; // The higher the number, the slower the timing.
Se declară o variabilă! Este una de tip întreg numită "timer", iar valoarea i se atribuie egală
cu 200. După practica și posibilitatea de a fi observat efectul de licărire a LED-lor, cele mai
multe linii de programe Arduino se termină cu un punct și virgulă ;. Atunci când scrii și
modifici sketch-uri arduino proprii, ai grija de lipsă acestor punct și virgulă în situațiile unde
sunt necesare, deoarece acestea vor provoca erori la compilare.
void setup() {
  // use a for loop to initialize each pin as an output:
  for (int thisPin = 3; thisPin < 8; thisPin++) {
    pinMode(thisPin, OUTPUT);
 }
}
În void setup()  se configurează pinii de la 3 la 7 ca ieșiri utilizând o buclă pentru, care este
o buclă specială care repetă o mică secțiune de cod de un anumit număr de ori bazată pe o
condiție, utilizând un contor de incrementare. De fiecare dată prin bucla mini, starea este
testat și, dacă este adevărat, va continua să execute codul interior. Deci, de mai sus, o
variabilă thisPin este setat la 3, condiția este ca ar trebui să fie mai mică de 8, și contorul de
creștere crește de fiecare dată la trecerea prin bucla (thisPin++ este la fel ca a spune thisPin
= thisPin +1 ). Deci, prima dată prin această buclă, PIN-ul 3 este setat la o ieșire. A doua
oară prin, PIN-ul 4 este setat la o ieșire. Și așa mai departe până când thisPin este de 8,
moment în care starea este falsă și codul întrerupe bucla condiționată de satisfacerea
condiției , continuând cu restul programului. Acest lucru poate părea ca un mod complicat de
a face un lucru pentru începători, dar programatorii iubesc eficiența! Ai putea realiza la fel de
ușor configurații pin cu următoarea configurare void setup():
    void setup() {
  // initialize each pin as an output:
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
}
 Veți observa că nu există doar o modalitate de abordare al unui program/algoritm, de obicei
există mai mult posibilități de a realiza același lucruri cu programare Arduino. Codificarea
este similară cu a face lucruri în atelierul dumneavoastră: aveți tendința de a utiliza orice
instrumente aveți. Deci, vă permite să utilizați o buclă pentru ceva distractiv ... Animație!
   void loop() {
    // loop from the lowest pin to the highest:
  for (int thisPin = 3; thisPin <  8; thisPin++) {
    // turn the pin on:
    digitalWrite(thisPin, HIGH);
    delay(timer);
    // turn the pin off:
    digitalWrite(thisPin, LOW);
 }
Bucla începe cu aceeași pentru buclă ca mai devreme, incrementând de la cel mai mic număr
de pini la cel mai mare. În interiorul buclei se conectează LED-ul la thisPin pentru o durată
de 200ms (setat mai devreme ca cronometru), apoi se deconectează LED-ul înainte de buclă
și după care din nou cu LED-ul următor. 
    // loop from the highest pin to the lowest:
  for (int thisPin = 7; thisPin >= 3; thisPin--) {
    // turn the pin on:
    digitalWrite(thisPin, HIGH);
    delay(timer);
    // turn the pin off:
    digitalWrite(thisPin, LOW);
 }
}
Următoarea parte a codului este o altă pentru a buclei, dar aceasta începe de la cel mai mare
PIN și utilizează thisPin--, ceea ce înseamnă același lucru thisPin=thisPin-1 (doar că
operația minus unu), și iese din bucla atunci când thisPin, nu mai este >=3, (mai mare sau
egal cu trei, aică 2). Acolada de închidere finală a ciclului principal void loop () { } . Deci,
acest program conectează fiecare LED în ordine directă, apoi inversează ordinea și după care
iar începe de la început.
Concluzie:
In urma efectuarii acestor lucrari am reusit sa insusim careva programe simple de lucru
cu LED-urile si anume pur si simplu conectarea si deconectarea lui in intervale de timp
prestabilite , folosind doar un pin digital de pe placheta Arduino. Pentru a da alimentare
LED-ului folosim comanda “digitalWrite” (high sau low) si pentru a da intervalul de
timp de iluminare sau nu folosim “delay”. Pentru a complica putin proiectul si a adauga
mai multe LED_uri folosim pur si simplu ciclurile “for” si deja aceleasi comenzi. Aici
deja se va primi lumini alergatoare.
Bibliografie:
1. http://www.bobtech.ro/tutoriale/microcontrolere/65-cum-comanzi-un-lcd-
alfanumeric
2. https://pzik.ru/ro/podklyuchenie-lsd-1602-podklyuchenie-lcd-k-arduino-plate/
3. https://lastminuteengineers.com/arduino-1602-character-lcd-tutorial/