Probleme speciale de proiectare asistata a

circuitelor cu microcontrolere - PACM

Sketch-ul

Masterand Profesor coordonator

Ing. Preoteasa Victor Conf. Dr. Ing. Neaca Iustinian

Craiova
2019
Instructiuni utilizate:

- If, If...else
- For
- While, do.. while
- Pin mode
- Digital read
- Analog read
- Digital write
- Analog write
- Comenzi relative de timp (delay, milis)
- Comenzi pentru transmisia seriala

Instructiunile conditionale determina programele sa testeze diferite conditii si

in functie de acestea sa decida executia anumitor comenzi.
Aceste instructiuni conditionale sunt:

 if() - executa comenzile dorite cand o conditie scrisa in paranteze este

adevarata.
 if() ... else - executa anumite comenzi cand o conditie este adevarata si
alte comenzi cand aceasta este falsa.

Instructiunea ”If”

if()" (daca) este cea mai simpla instructiune conditionala. Forma generala a
acestei instructiuni este urmatoarea :

 if (conditie) {
    // Codul care va fi executat daca este Adevarata conditia
}

- Unde 'conditie' poate fi orice expresie alcatuita cu operatori rationali, de

egalitate si logici.

Instructiunea "if ... else"

In exemplu anterior am vazut ca daca este adevarata conditia din parantezele
instructiunii "if()", se executa codul dintre acoladele ei, iar in caz contrar nu se
intampla nimic.
Folosind combinatia "if() ... else" (daca ... altfel) putem stabili comenzi care sa
fie executate si cand conditia instructiunii "if()" este FALSE.
Forma generala a instructiuni "if() ... else" este urmatoarea :
  if (conditie) {
    // codul care va fi executat daca este Adevarata conditia
}
else {
    // codul ce va fi executat daca conditia este falsa
}

- Unde 'conditie' poate fi orice expresie logica.

Daca rezultatul conditiei este TRUE se executa codul dintre primele

acolade, care apartin de "if()", in caz contrar, cand conditia returneaza FALSE,
sunt executate comenzile din acoladele de la "else".

Exista trei instructiuni repetitive folosite in toate limbajele:

- instructiunea repetitiva cu test initial CAT TIMP ( WHILE ): se foloseste cand

numarul de repetitii este nedefinit;

- instructiunea repetitiva cu test final REPETA-PANA CAND ( DO WHILE

sau REPEAT): se foloseste cand numarul de repetitii este nedefinit;

- instructiunea repetitiva cu un numar cunoscut de pasi PENTRU ( FOR ): se

foloseste cand numarul de repetitii este cunoscut – un numar fix de ori.

Instructiunea ”For”

Instructiunea FOR este o instructiune repetitiva care permite executia

repetata a unei instructiuni in functie de valoarea unui contor.

Instrucţiunea for are doua forme:                         

             FOR identificator:=expresie1 TO expresie2 DO instructiune;
(CAZUL                    CRESCATOR)
            FOR identificator:=expresie1 DOWNTO expresie2
DO instructiune;(CAZUL DESCRESCATOR),
unde identificator este o variabila de orice tip ordinal, iar expresie1 şi expresie2
sunt expresii de acelasi  tip cu variabila data.
Instructiunile repetitive se folosesc atunci cand se doreste efectuarea unei
comenzi de mai multe ori.
Instructiunea for() (denumita si bucla for()) poate fi conasiderata cea mai des
folosita instructiune repetitiva. In ActionScript 3 putem folosi bucla "for()" cu
mai multe variante:

 for - la fel ca si in alte limbaje de programare, executa codul de un numar

specificat de ori
Aceasta are urmatoarea forma generala:

 var i:int
for (i=nr_start; i<nr_end; i++) {
    cod care va fi executat
}

- "i" este o variabila de initializare a buclei "for()", folosita ca un contoar pentru

numarul de repetari. Poate fi utilizata si alta litera sau cuvant, ca la orice
variabila.
Se poate folosi si direct "var i = nr_start;", dar din motivele precizate in lectia
despre variabile, este indicat sa se specifice si tipul.
- "nr_start" este un numar initial de la care incep repetarile executiei codului
dintre acolade.
- Conditia "i<nr_end" verifica si asigura ca numarul de repetari sa se incadreaza
intr-o anumita valoare, stabilita la "nr_end". Cat timp rezultatul acestei conditii
este TRUE se executa inca o data codul dintre acolade.
- "i++" incrementeaza cu o unitate valoarea la care a ajuns "i", apoi aceasta
valoare este verificata din nou de "i<nr_end", pana cand rezultatul este FALSE.
Atunci se opreste executia buclei.
- In loc de "i<nr_end" se poate folosi si alta conditie relationala, de exemplu
"i<=nr_end"
Iata un exemplu simplu de utilizare a instructiunii "for":

Instructiunea ”While” , ”Do... while”

Sintaxa: while (expL) instructiune

Efect:

1. Se evalueaza expresia logica

2. Daca valoare expresiei logice este 1 (adevarat) se executa instructiunea si
revine la pasul 1
3. Daca valoarea expresiei logice este zero (falsa) se continua cu
instructiunea de dupa punct-virgula

Observatii:
 In esenta, cat timp valoarea expresiei logice este adevarata, se executa
instructiunea;

- daca valoarea expresiei logice este falsa de la inceput atunci instructiunea nu

se mai executa;

- daca WHILE trebuie sa repete mai mult de o instructiune, acestea se vor

incadra intre acolade;

- instructiunea WHILE se mai numeste ”repetitiva cu test initial” sau

”conditionata anterior” , pentru ca intai verifica valoarea conditiei si apoi
executa secventa ce trebuie repetata.

Sintaxa: do {instructiuni} while {conditie}

Efect:

1. Se executa secventa de instructiuni

2. Se evalueaza conditia
3. Daca valoarea conditiei este adevarata se revine la pasul 1
4. Daca valoarea conditiei este falsa se continua cu instructiunea de dupa
punct si virgula

Observatii:

- Do- while se mai numeste instructiune cu test final sau conditionata

posterior
- Observati ca intai se executa secventa de instructiuni si apoi se testeaza
- Succestiunea de operatii este intructiune, test, instructiune, test, ... test,
instructiune, test.

Exemplu:

O problema la care putem folosi DO-WHILE este prelucrarea cifrelor

unui numar natural/intreg. Cifrele vor fi prelucrate pe rand, de la sfarsitul
numarului catre inceput, de fiecare data taind ultima cifra (deja prelucrata).
Algoritmul se reia pana cand nu mai sunt cifre in numar, adica valoarea N
ajunge la valoarea zero.

Sesizati ca orice numar are o ultima cifra, movtiv pentru care intai
prelucrez si tai,si apoi verifica daca mai sunt cifre de prelucrat.
Scheletul algoritmului ar fi :

cin>>n;

do { //prelucrarea ultimei cifre

      ..............;

      // tai ultima cifra

     n=n/10;

    } while (n!=0);

Instructiunea ”Pin mode”

Descriere:

Configurează pinul specificat pentru a se comporta fie ca intrare, fie ca

ieșire. Consultați descrierea pinilor digitali pentru detalii despre funcționalitatea
pinilor
Începând cu Arduino 1.0.1, este posibilă activarea rezistențelor interne de
tragere cu modul INPUT_PULLUP. În plus, modul INPUT dezactivează
explicit extragerile interne

Sintaxa
pinMode(pin, mode)

Parametrii
pin: numarul de pini al caror mod doresti sa il setezi

moduri: INPUT, OUTPUT, sau INPUT_PULLUP.
Examplu

int ledPin = 13;                 // LED connected to digital pin 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delay(1000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(1000);                  // waits for a second
}
[Get Code]

Nota

Pinii de intrare analogici pot fi folosiți ca pini digitali, numiți A0, A1 etc.

Instructiunea ”Digital read”

Descriere
Citește valoarea dintr-un pin digital specificat, HIGH sau LOW.

Sintaxa

digitalRead(pin)
Parametrii
pin: numărul pinului Arduino pe care doriți să îl citiți

Examplu

Setează pinul 13 la aceeași valoare ca pinul 7, declarat drept intrare.

int ledPin = 13; // LED connectat la pinul digital 13
int inPin = 7; // buton conectat la pinul digital 7

int val = 0; // variabilă pentru a stoca valoarea citită

void setup() {
pinMode(ledPin, OUTPUT); // stabilește pinul digital 13 ca ieșire

pinMode(inPin, INPUT); // stabileste pinul digital 7 ca intrare

}

void loop() {
val = digitalRead(inPin); // citeste pinul de intrare
digitalWrite(ledPin, val); // setează LED-ul la valoarea butonului

Observatii:

Dacă pinul nu este conectat la nimic, digitalRead () poate reveni fie

HIGH, fie LOW (și acest lucru se poate schimba la întâmplare).
Pinii de intrare analogici pot fi folosiți ca pini digitali, numiți A0, A1 etc.

Instructiunea ”Analog read”

Citește valoarea din pinul analog specificat. Plăcile Arduino conțin un

convertor analogic pe 10 biți multicanal, digital. Aceasta înseamnă că va
cartografia tensiunile de intrare între 0 și tensiunea de operare (5V sau 3,3 V) în
valori între 0 și 1023. Pe un Arduino UNO, de exemplu, aceasta produce o
rezoluție între citirile de: 5 volți / 1024 unități sau , 0,0049 volți (4,9 mV) pe
unitate. Consultați tabelul de mai jos pentru pinii utilizabili, tensiunea de
funcționare și rezoluția maximă pentru unele plăci Arduino.
Intervalul de intrare poate fi modificat folosind analogReference (), în timp ce
rezoluția poate fi modificată (numai pentru plăcile Zero, Due și MKR) folosind
analogReadResolution ().
Pe placi bazate pe ATmega (UNO, Nano, Mini, Mega), este nevoie de
aproximativ 100 de microsecunde (0,0001 s) pentru a citi o intrare analogică,
astfel încât rata maximă de citire este de aproximativ 10.000 de ori pe secundă

Sintaxa

analogRead(pin)

Parametrii
pin: numele pinului de intrare analog de citit de la (A0 la A5 pe majoritatea
plăcilor, A0 la A6 pe placi MKR, A0 la A7 pe Mini și Nano, A0 în A15 pe
Mega).

Examplu de Cod

Codul citește tensiunea pe analogic și îl afișează.

int analogPin = A3; // ștergător de potențiometru (borna mijlocie) conectat la
pinul analogic 3 // afară duce la sol și + 5V
int val = 0; // variabila pentru stocarea valorii citite

void setup() {
Serial.begin(9600); // serial de configurare

void loop() {
val = analogRead(analogPin); // citeste pinul de intrare
Serial.println(val); // verifica valoarea
 Instructiunea ”Digital write”

Scrieți o valoare HIGH sau LOW pe un pin digital.

Dacă pinul a fost configurat ca OUTPUT cu pinMode (), tensiunea sa va fi
setată la valoarea corespunzătoare: 5V (sau 3.3V pe plăci 3.3V) pentru HIGH,
0V (la sol) pentru LOW.
Dacă pinul este configurat ca INPUT, digitalWrite () va activa (HIGH)
sau va dezactiva (LOW) pull-ul intern pe pinul de intrare. Se recomandă să
setați pinMode () la INPUT_PULLUP pentru a activa rezistența internă de
tragere. Consultați tutorialul Digital Pins pentru mai multe informații.
Dacă nu setați pinMode () la OUTPUT și conectați un LED la un pin,
când apelați digitalWrite (HIGH), LED-ul poate părea slab. Fără a seta în mod
explicit PinMode (), digitalWrite () va fi permis rezistența internă de extragere,
care acționează ca o rezistență mare de limitare a curentului.

Sintaxa

digitalWrite(pin, valoare)

Parameters

pin: numarul pinului Arduino.

value: HIGH or LOW.

Examplu de Cod

Codul face ca pinul digital 13 să fie un OUTPUT și să-l comute alternând între
HIGH și LOW la un singur pas.
void setup() {
pinMode(13, OUTPUT); // seteaza pinul diigtal 13 ca intrare
}
void loop() {
digitalWrite(13, HIGH); // seteaza pinul digital 13 pornit
delay(1000); // asteapta pentru o secunda
digitalWrite(13, LOW); // seteaza pinul digital 13 oprit
delay(1000); // asteapta pentru o secunda
}

Observatii

Pinii de intrare analogice pot fi folosiţi ca pini digitali, numiţi A0, A1 etc.
Excepție fac pinii Arduino Nano, Pro Mini și Mini A6 și A7, care pot fi folosiți
doar ca intrări analogice.

Instructiunea ”Analog write”

Scrie o valoare analogică (undă PWM) pe un pin. Poate fi folosit pentru a

aprinde un LED cu luminozități diferite sau pentru a conduce un motor la
diferite viteze. După un apel către analogWrite (), pinul va genera o undă
dreptunghiulară constantă a ciclului de sarcină specificat până la următorul apel
către analogWrite () (sau un apel la digitalRead () sau digitalWrite ()) pe același
pin.

Sintaxa

analogWrite(pin, valoare)

Parametrii
pin: pinul Arduino la care să scrie. Tipuri de date permise: int. valoare: ciclul de
serviciu: între 0 (mereu oprit) și 255 (mereu pornit). Tipuri de date permise: int.

Examplu de Cod

Setează ieșirea la LED proporțional cu valoarea citită de la potențiometru.

int ledPin = 9; // LED-ul conectat la pinul 9
int analogPin = 3; // potentiometru conectat la pinul analog 3
int val = 0; // variabila stocata in variabila de citire

void setup() {
pinMode(ledPin, OUTPUT); // seteaza pinul ca iesire
}

void loop() {
val = analogRead(analogPin); // citeste pinul de intrare
analogWrite(ledPin, val / 4); // valorile analogRead pornesc de la 0 la 1023,
}

Observatii

Ieșirile PWM generate pe pinii 5 și 6 vor avea cicluri de serviciu mai mari
decât se aștepta Acest lucru se datorează interacțiunilor cu funcțiile millis () și
delay (), care împărtășesc același timer intern folosit pentru a genera acele ieșiri
PWM. Acest lucru va fi observat mai ales pe setările ciclului de serviciu scăzut
(de exemplu, 0 - 10) și poate duce la o valoare de 0 care nu oprește complet
ieșirea pe pinii 5 și 6.

Instructiunea ”Milis”

Funcția millis () este una dintre cele mai puternice funcții ale bibliotecii
Arduino. Această funcție returnează numărul de milisecunde pe care schița
curentă a fost executată de la ultima resetare. La început, s-ar putea să vă
gândiți, bine că nu este deloc util! Dar luați în considerare modul în care vă
spuneți timpul în timpul zilei. Efectiv, vă uitați la câte minute au trecut de la
miezul nopții. Aceasta este ideea din spatele millis ()!
În loc să „așteptați o anumită perioadă de timp”, așa cum faceți cu
întârziere (), puteți utiliza millis () pentru a întreba „cât timp a trecut”? Începem
prin a privi câteva moduri în care puteți utiliza întârziere () pentru a aprinde
intermitent LED-uri. Probabil că sunteți deja familiarizați cu acest prim
exemplu de cod Arduino IDE include acest exemplu ca „Blink”.

void setup() {
   pinMode(13, OUTPUT);
}
 
void loop() {
   digitalWrite(13, HIGH);   // seteaza LED-ul pornit
   delay(1000);              // asteapta pentru o secunda
   digitalWrite(13, LOW);    // seteaza LED-ul oprit
   delay(1000);              // asteapta pentru o secunda
}
Citind fiecare linie de buclă () în secvență schița:
1. Aprinde LED-ul de pe pinul 13,
2. Asteapta o secunda (sau 1000 milisecunde),
3. Opreste LED-ul de pe pinul 13,
4. Asteapta o secunda,
5. Apoi se repeta intreaga secventa.
Problema potențială este că, în timp ce stai întârziat (), codul tău nu mai
poate face altceva. Haideți să aruncăm o privire la un exemplu în care nu vă
„blocați” pentru cei 1000 de milisecunde.

Instructiunea ”Delay”

Descriere
Întrerupe programul pentru perioada de timp (în milisecunde) specificată
ca parametru. (Există 1000 de milisecunde într-o secundă.)

Sintaxa

delay(ms)

Parameterii

ms: numărul de milisecunde de întrerupt. Tipuri de date permise: nesemnat timp

lung.

El codează întrerupe programul pentru o secundă înainte de a comuta pinul de

ieșire.

int ledPin = 13; // LED conectat la pinul digital 13

void setup() {
pinMode(ledPin, OUTPUT); // seteaza pinul digital ca iesire
}

void loop() {
digitalWrite(ledPin, HIGH); // porneste Led-ul
delay(1000); // asteapta timp de o secunda
digitalWrite(ledPin, LOW); // opreste LED-ul
 delay(1000); // asteapta timp de o secunda
}

Observatii

Deși este ușor să creezi un LED care clipește cu funcția de întârziere ()

și multe schițe folosesc întârzieri scurte pentru astfel de sarcini precum
deconectarea comutatorilor, utilizarea întârzierii () într-o schiță are dezavantaje
semnificative. Nicio altă citire a senzorilor, a calculelor matematice sau a
manipulării pinului nu poate continua în timpul funcției de întârziere, astfel
încât, în realitate, se oprește majoritatea altor activități. Pentru abordări
alternative pentru controlul sincronizării, consultați schița Blink Without Delay,
care se bucle, care interzice funcția millis () până la trecerea timpului suficient.
Programatorii mai cunoscuți, de obicei, evită utilizarea întârzierii () pentru
cronometrarea evenimentelor mai lungi de 10 milisecunde, cu excepția cazului
în care schița Arduino este foarte simplă.
Anumite lucruri continuă în timp ce funcția de întârziere () controlează
cipul Atmega, cu toate acestea, deoarece funcția de întârziere nu dezactivează
întreruperile. Comunicarea serială care apare la pinul RX este înregistrată,
valorile PWM (analogWrite) și stările pin sunt întreținute și întreruperile vor
funcționa așa cum ar trebui.

Comenzi pentru transmisia seriala

Cand se citeste ceva de la portul serial intotdeauna se primeste informatia
bit cu bit pana cand a fost atins un byte (adica au fost transmisi 8 biti). Daca nu
exista alte constrangeri Arduino va stoca aceasta informatie intr-o variabila de
tip char (de fapt este un byte care ia valori in domeniul codului ASCII 0-127).
Cand am vorbit de constarngeri am incercat sa zic faptul ca se pot trimite mai
multe caractere insa tinand cont de particularitatile transmisiei seriale, pentru a
putea utiliza aceste date este nevoie ca ele sa fie salvate intr-un vector (array).
Arduino dispune de o functie care face fix acest lucru " Serial.readBytes(arg1,
arg2) ". Primul argument reprezinta un array in care se stocheaza datele primite
prin portul serial iar cel de-al doilea argument reprezinta numarul de bytes care
vor fi cititi.
De exemplu:
Sa zicem ca avem definit un vector denumit " buffer[7]". Functia descrisa mai
sus va lua primul argument arg1= buffer (de fapt este un pointer catre vectorul
buffer) si daca dorim sa citim doar primle 3 caractere trimise arg2 va fi egal cu
3: Serial.readBytes(buffer, 3). 
Daca se trimite  secventa : "arduino" continutul vectorului buffer va fi:

 buffer[0]='a'
 buffer[1]='r'
 buffer[2]='d'
Bibliografie:
- http://hobbyelectro.blogspot.com/2014/01/arduino-si-comenzi-prin-interfata.html
- https://www.arduino.cc/reference/en/language/functions/time/delay/
- https://www.baldengineer.com/millis-tutorial.html
- https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/
- https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/
- https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/
- https://www.arduino.cc/en/Reference.PinMode
- https://mchelariu.wordpress.com/2010/01/12/l10-instructiunea-do-while/
- https://mchelariu.wordpress.com/2010/11/12/l11-instructiunea-while/
- https://marplo.net/flash/instructiuni-repetitive-for_as
- https://infopascalfacts.wordpress.com/2016/11/09/%D0%B7%D0%B0%D0%B3%D0%BE
%D0%BB%D0%BE%D0%B2%D0%BE%D0%BA-%D0%B7%D0%B0%D0%BF
%D0%B8%D1%81%D0%B8-%D0%B2-%D0%B1%D0%BB%D0%BE%D0%B3%D0%B5-
2/