Învățarea programării de bază Arduino - Tutorial pentru noii veniți

În acest tutorial învățăm cum să facem programarea de bază Arduino prin exemple de coduri și exemple de programe. Acest tutorial poate fi un curs extrem de valoros pentru toți noii veniți care doresc să înțeleagă elementele de bază printr-un limbaj ușor de înțeles.

Introducere

Conform wikipedia un microcontroler este echivalent cu un mini computer construit într-un singur cip IC, având propriul procesor central, intrări programabile, periferice de memorie și ieșire.

Un microcontroler devine atât de util pentru un utilizator, deoarece oferă un procesor încorporat, memorie și porturi de intrare / ieșire (numite și GPIO sau pini de intrare / ieșire de uz general) pe care le putem controla de către utilizator conform oricărei specificații dorite.

În acest tutorial vom lucra cu o placă Arduino Uno pentru învățarea și testarea programelor. Pentru testarea și integrarea ansamblului hardware vom folosi o panou de testare.

Acum să ne mișcăm rapid și să învățăm cum să începem cu o programare Arduino.

1.2 Instalarea software-ului (Windows)

Pentru aceasta, veți avea nevoie de acces la internet, pe care, evident, îl veți avea în computer. Accesați următorul link și descărcați software-ul IDE:

Fișier ZIP Windows pentru instalare non admin

După descărcare, veți găsi pictograma de configurare Arduino în folderul de descărcare, care ar arăta astfel:

Odată ce obțineți acest lucru, puteți pur și simplu să faceți dublu clic pe el și să instalați Arduino the Integrated Development Environment (IDE) în computer. Procesul complet poate fi vizualizat în următorul videoclip:

1.4 Începând cu primul nostru circuit

Înainte de a începe să învățăm tehnicile de programare propriu-zise, ​​pentru orice începător ar fi util să începem cu o componentă de bază, cum ar fi un LED, și să înțelegem cum să-l conectăm cu un Arduino.

După cum știm, un LED este o diodă emițătoare de lumină care are o polaritate și nu se va aprinde dacă nu este conectat cu polii de alimentare corespunzători.

Un alt aspect al LED-urilor este că aceste dispozitive funcționează cu curent redus și se pot deteriora instantaneu dacă un rezistor calculat corespunzător nu este inclus în serie cu unul dintre pinii săi.

De regulă, un 330 ohm 1/4 watt este destul de ideal pentru fiecare creștere de 5V a intrării de alimentare pentru a limita curentul la un nivel de siguranță necesar. Prin urmare, pentru 5V poate fi de 330 ohmi, pentru 10V poate fi de 680 ohmi și așa mai departe.

Folosind Breadboard pentru asamblare

Vă rugăm să vă asigurați că știți cum să utilizați un panou de masă înainte de a încerca tutorialul explicat în acest capitol, deoarece vom folosi o panou pentru toate experimentele de aici.

Configurarea de bază a conexiunii LED poate fi observată mai jos:

Puteți vedea 3 componente de bază de mai sus:

1. Un LED de 5 mm, 20 mA
2. un rezistor de 330 ohmi 1/4 wați
3. Un Placa Arduino

Doar asamblați sistemul conform schemei.

Apoi, conectați 5V de la computerul USB la Arduino. De îndată ce faceți acest lucru, veți vedea LED-ul aprins.

Știu că este destul de simplu, dar este întotdeauna bine să începi de la zero. Fiți siguri că lucrurile vor începe să devină din ce în ce mai interesante pe măsură ce avansăm.

1.5 Controlul LED-ului cu Arduino

Acum vom învăța cum să controlăm un LED cu un program Arduino.

Pentru a scrie un program trebuie să avem cel puțin 2 funcții în fiecare program.

O funcție poate fi înțeleasă ca o serie de instrucțiuni de programare care pot fi atribuite cu un nume, așa cum este dat mai jos:

1. înființat() aceasta este apelată sau executată în timpul începerii programului.
2. buclă() aceasta este apelată sau executată în mod repetat pe întreaga perioadă operațională a Arduino.

Prin urmare, deși este posibil să nu aibă funcționalități practice, din punct de vedere tehnic, cel mai scurt program legitim Arduino poate fi scris ca:

Cel mai simplu program

void setup()
{
}
void loop()
{
}

Este posibil să fi observat că în multe dintre limbajele de programare, sistemul începe prin afișarea unei tipăriri simple, „Bună ziua, lume” pe ecranul de afișare

Echivalentul electronic pentru această expresie în interpretarea microcontrolerului este să clipească un LED pornit și oprit.

Acesta este cel mai de bază program pe care îl puteți scrie și implementa pentru a indica o funcționare corectă a sistemului.

Vom încerca să implementăm și să înțelegem procedura prin următoarea bucată de cod:

Listarea 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

OK, acum să înțelegem ce înseamnă fiecare linie a codului și cum funcționează pentru a executa funcția:

const int kPinLed = 13

Aceasta funcționează ca o constantă care ne permite să o folosim în timpul cursului complet de programare, fără a fi nevoie să folosim valoarea reală care este setată împotriva ei.

Conform regulilor standard, astfel de constante sunt recunoscute cu litera de pornire la . Deși acest lucru nu este obligatoriu, face lucrurile mai clare și ușor de înțeles ori de câte ori ai chef să treci prin detaliile codului.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Acest cod configurează pinul specific la care este conectat LED-ul nostru. Cu alte cuvinte, codul îi spune lui Arduino să controleze aspectul „scriere” pe acest pin, în loc să-l „citească”.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Rândurile de mai sus indică execuția efectivă a aplicației. Codul începe prin scrierea și redarea unei ieșiri HIGH pe conexiunea LED relevantă, pornind LED-ul.

Aici, termenul HIGH înseamnă pur și simplu să obțineți + 5V pe pinul în cauză al Arduino. Termenul complementar LOW indică pur și simplu un zero sau 0V pe pinul desemnat.

Apoi, apelăm delay() a cărei funcție este de a crea o întârziere prin milisecunde (1/1000 de secundă). Deoarece este introdusă cifra 500, întârzierea implementată va fi de 1/2 secundă.

De îndată ce această 1/2 secundă se scurge, se execută următoarea linie care stinge LED-ul cu termenul LOW pe același pin.

Linia ulterioară generează din nou întârzierea de 1/2 secundă, pentru a permite LED-ului să rămână OFF timp de 1/2 secunde.

Și procesul continuă infinit prin executarea liniilor de cod, atâta timp cât Arduino este menținut alimentat.

Înainte de a trece la nivelul următor, vă recomand să vă rog să programați codul de mai sus și să verificați dacă sunteți capabil să implementați corect sau nu secvența LED ON / OF.

Deoarece LED-ul implicit din Arduino este conectat cu pinul # 13, ar trebui să răspundă imediat la programul de mai sus și să înceapă să clipească. Cu toate acestea, dacă observați că LED-ul extern nu clipește, ar putea exista o eroare de conexiune cu LED-ul dvs., puteți încerca să inversați polaritatea LED-ului dvs. și, sperăm, să-l vedeți și să clipească.

Puteți juca cu timpul de întârziere modificând cifra „500” la o altă valoare și găsiți LED-ul „ascultând” comenzile și făcându-l să clipească conform valorilor de întârziere specificate.

Dar amintiți-vă, dacă vedeți LED-ul nu clipește cu o rată constantă de 1 secundă, indiferent de modificarea timpului de întârziere, acest lucru poate indica faptul că codul nu funcționează din cauza unei greșeli. Deoarece în mod implicit Arduino va fi programat cu o rată de intermitent de 1 secundă. Prin urmare, această rată trebuie să varieze în funcție de codul dvs. pentru confirmarea funcționării sale corecte.

1.7 Comentarii

Liniile de coduri pe care le-am înțeles mai sus au fost scrise special pentru software-ul computerului.

Cu toate acestea, pentru a se asigura că utilizatorul este capabil să trimită semnificația liniilor și să le înțeleagă, poate fi adesea util și sensibil să scrieți explicația lângă liniile de coduri dorite.

Acestea sunt numite comentarii care sunt scrise doar pentru referință umană sau de utilizator și sunt codificate pentru a permite computerelor să o ignore în siguranță.

Limba acestor comentarii este scrisă cu câteva formate:

1. Stilul bloc al comentariului, în care descrierea comentariului este inclusă sub simbolul de început / * și simbolul de sfârșit * /
2. Acest lucru nu trebuie să se restricționeze într-o singură linie, ci poate fi extins la următoarele rânduri ulterioare, în funcție de lungimea comentariului sau a descrierii, așa cum se arată în următorul exemplu:

/ * Acesta este un comentariu * /

/ * La fel și asta * /

/* Și
* acest
* la fel de
* bine */

Pentru a scrie o descriere rapidă pentru o singură linie pentru un comentariu, două simboluri // la început devin suficiente. Acest lucru îi spune computerului că această linie nu are nimic de-a face cu codul real și trebuie ignorată. De exemplu:

// Acesta este un comentariu pe care computerele îl vor ignora.

Iată un exemplu de referință:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Depanarea

Dacă programul dvs. prezintă o „eroare” în timpul compilării sau o altă problemă, următoarele sfaturi vă vor ajuta probabil să verificați din nou codul pentru a scăpa de obstacol.

1. Limbajul programului dvs. va depinde de majuscule și minuscule De exemplu expresia myVar nu poate fi scris ca MyVar.
2. Toate tipurile de spații albe care pot fi executate prin tastarea tastaturii sunt redate în cele din urmă ca un singur spațiu și sunt vizibile sau înțelese numai de dvs., computerul nu va lua în considerare acest lucru. Pur și simplu, spațiile libere de orice fel nu vor avea niciun efect asupra rezultatelor codului.
3. Fiecare bloc de cod trebuie să fie închis cu paranteze bucle stânga și dreapta, „{” și '}'
4. Cifrele numerice nu trebuie separate prin virgule. De exemplu, 1000 nu poate fi scris ca 1.000.
5. Fiecare linie de cod cuprinsă între paranteze cretate trebuie să se termine cu punct și virgulă

Crearea unei secvențe de lumini LED interesante cu Arduino

În capitolul nostru anterior am învățat cum să clipim continuu un LED ON / OFF cu o rată de întârziere constantă.

Acum vom afla cum pot fi executate diferite modele de întârziere pe același LED prin actualizarea codului programului.

Nu vom folosi un LED extern, ci mai degrabă vom folosi LED-ul implicit încorporat în placa Arduino la pinul # 13. Puteți găsi acest mic LED SMD chiar în spatele conectorului USB.

2.2 Înțelegerea declarațiilor IF

În această secțiune vom afla cum structurile de control ne permit să rulăm coduri individuale și, uneori, chiar repetitiv, după cum este necesar.

Declaratia dacă devine prima structură de control. Următoarea implementare arată cum este utilizată:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Vom încerca să înțelegem codul de mai sus pas cu pas și vom afla cum se poate folosi acest lucru pentru alte execuții similare.

Codurile dintre prima și a 7-a linie sunt exact similare cu programul nostru inițial.

Prima modificare se întâmplă de fapt pe linia a 8-a.

int delayTime = 1000

Puteți găsi că acesta este similar cu codul de pe prima linie, cu excepția faptului că lipsește termenul const.

Acest lucru se întâmplă pur și simplu pentru că acest cod nu este o constantă. În schimb, acest lucru este definit ca un variabil , care are proprietatea unei valori variabile în cursul programării.

În exemplul de mai sus puteți vedea că această variabilă este atribuită cu o valoare de 1000. Amintiți-vă, astfel de variabile care sunt încadrate între paranteze cretate trebuie să fie scrise strict numai în perechi de paranteze cretate și sunt denumite variabile „locale”.

Alternativ, variabilele despre care se presupune că se află în afara parantezelor crețate, precum cea pe care o discutăm acum, sunt recunoscute ca „globale” și ar putea fi executate aproape oriunde în cadrul unui cod de program.

Mergând mai departe, puteți vedea că și codurile dintre linia 9 și 11 sunt similare cu primul program, totuși lucrurile încep să devină interesante după linia 11. Să vedem cum!

delayTime = delayTime - 100

În acest cod vedem că valoarea implicită a timp de intarziere este modificat scăzând 100 din acesta.

Înțelesul 100 este dedus din valoarea inițială de 1000, oferindu-i o nouă valoare de 900.

Prin următoarea imagine vom încerca să înțelegem câțiva dintre operatorii matematici utilizați în limbajul Arduino.

Acum să evaluăm codurile dintre linia 13 și 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

Obiectivul principal al codului de mai sus este să se asigure că LED-ul continuă să clipească fără nicio întrerupere.

Datorită faptului că 100 sunt deduse din original timp de intarziere , împiedică intermitentul LED să ajungă la zero și permite intermitentul să se aprindă continuu.

Următoarea imagine prezintă câțiva operatori de comparație pe care i-am folosi în codurile noastre:

În codul nostru de mai sus, am fi putut testa codul să fie if(delayTime == 0).

Cu toate acestea, pentru că a fi o cifră negativă poate fi la fel de rău, nu ne-am străduit, iar aceasta este o practică recomandată.

Gândește-te care ar fi putut fi rezultatul dacă am fi încercat să deducem 300 în loc de 100 din delayTime?

Așa că acum v-ați fi dat seama că dacă delayTime este scris ca mai mic sau egal cu zero, atunci timpul de întârziere ar fi setat înapoi la cifra originală 1000.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

Ultimele 4 linii ale codului, așa cum se arată mai sus, devin responsabile pentru pornirea / oprirea LED-ului, pornirea / oprirea continuă a LED-ului.

Aici puteți observa în mod clar că, în loc să folosim o serie de cifre, am folosit o variabilă pentru atribuirea timpului de întârziere, astfel încât să îl putem ajusta după cum dorim în timpul perioadei operaționale a codului. E grozav, nu?

2.3 Declarații ELSE

Aici vom afla de ce și cum dacă termenul poate avea o clauză altceva astfel încât să decidă situația în caz dacă afirmația este falsă.

Îmi pare rău dacă sună prea confuz, nu vă faceți griji, vom încerca să îl înțelegem cu următorul exemplu:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

În cele de mai sus puteți vedea că în a 10-a linie codul este executat numai atunci când delayTime este mai mic sau egal cu 100, dacă nu, atunci codul din a 13-a linie este executat, dar ambele împreună nu se pot întâmpla niciodată, fie a 10-a linie, fie a 13-a linie de cod vor fi implementate, niciodată ambele.

Este posibil să fi observat că, spre deosebire de ceea ce am făcut în secțiunea noastră anterioară 2.2, aici nu am comparat cu 0, mai degrabă comparativ cu 100. Acest lucru se datorează faptului că, în acest exemplu, comparat ÎNAINTE am scăzut 100, contrar în secțiunea 2.2, am comparat DUPĂ scăzut. Puteți spune ce s-ar fi putut întâmpla dacă am compara 0 în loc de 100?

2.4 În timp ce declarațiile

LA in timp ce afirmație este destul de similară cu dacă , cu excepția adevărului că provoacă executarea repetată a unui bloc de cod (care poate fi între paranteze buclate) atât timp cât sunt aplicabile condițiile, iar acest lucru funcționează fără o altceva afirmație.

Următorul exemplu vă va ajuta să înțelegeți mai bine acest lucru

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Puteți ghici ce este programat să facă codul de mai sus? Ei bine, este conceput pentru a clipi LED-ul mai repede și apoi mai lent.

2.5 Ce este adevărat și fals?

În limbajul de programare, fals se referă la zero (0). De fapt, „adevărat” nu este folosit, în schimb se presupune că atunci când nimic nu este fals, atunci tot ceea ce este inclus este adevărat.

Pare puțin ciudat, însă face treaba destul de frumos.

Vom încerca să înțelegem situația prin următorul exemplu.

Uneori puteți întâlni un cod după cum este prezentat mai jos:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Acest lucru este codat, se pare că execuția cu LED-uri va continua să circule pentru totdeauna, deoarece este disponibilă o perioadă lungă de timp.

Cu toate acestea, un dezavantaj al acestui tip de cod ar putea apărea atunci când accidental utilizatorul aplică a = în loc de ==.

Sunt sigur că știți deja că = înseamnă o atribuire, ceea ce înseamnă că este folosit pentru a desemna o valoare selectată la o variabilă, în timp ce un == este utilizat pentru aplicarea unui test dacă valoarea a fost aceeași.

De exemplu, să presupunem că aveți nevoie de un LED pentru a clipi cu un model de viteză secvențială și repetitiv, dar ați folosit incorect un = în loc de ==.

Codul va apărea astfel:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

Eroarea va atribui 0 la delayTime și va duce la dacă declarație pentru a verifica dacă 0 este adevărat sau nu. Deoarece 0 se referă la fals, va crede că nu este adevărat și va opri aplicarea delayTime = 1000, dar în schimb funcția delayTime este ținut la 0 în cursul buclei ().

Arată foarte nedorit !!

Deci, verificați întotdeauna programul pentru a vă asigura că nu ați făcut astfel de greșeli stupide.

2.6 Combinații

Uneori este posibil să simțiți nevoia de a testa mai multe lucruri împreună. De exemplu, poate doriți să examinați dacă o variabilă era între două numere. Deși acest lucru poate fi implementat folosind instrucțiunea if de mai multe ori, poate fi mai convenabil să folosiți combinații logice pentru o citire mai bună și mai ușoară.

Implementarea combinațiilor în termeni logici se poate face cu 3 metode, așa cum se arată în tabelul următor:

Ar fi interesant de știut că operatorul NOT poate funcționa ca un comutator pentru o variabilă care poate fi desemnată fie Adevărat sau fals (sau LOW sau HIGH).

Următorul exemplu ilustrează starea:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Aici ledState va fi scăzut și, ulterior, imediat ce ledState = !ledState, va deveni HIGH. Următoarea buclă va provoca ledState a fi MARI când ledState = !ledState este scăzut.

2.7 Afirmații FOR

Acum vom încerca să înțelegem despre o altă structură de control care este a pentru buclă. Acest lucru poate fi foarte util atunci când doriți să implementați ceva de mai multe ori.

Să înțelegem acest lucru cu următorul exemplu:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Puteți găsi ceva unic în linie cu pentru.

Este codul i ++? . Acest lucru este util pentru programatorii care sunt destul de leneși și doresc să implementeze codificarea prin comenzi rapide convenabile

Termenul de mai sus este cunoscut sub numele de operatori compuși, deoarece aceștia fac treaba de a combina un operator de atribuire cu un alt operator de atribuire. Cele mai populare dintre acestea pot fi vizualizate în următorul tabel:

Veți găsi că există 3 sub-afirmații într-o afirmație for. Este structurat după cum se arată mai jos:

for (statement1conditionstatement2){
// statements
}

Afirmația nr. 1 apare chiar la început și o singură dată. Starea este testată de fiecare dată pe parcursul ciclului. Ori de câte ori este Adevărat în parantezele buclate, declarația ulterioară nr. 2 se aplică. În cazul unui fals, sistemul sare la următorul bloc de cod.

Conectarea mai multor LED-uri

OK, acum vom vedea cum putem conecta un număr mai mare de LED-uri pentru a obține efecte mai interesante.

Vă rugăm să conectați LED-urile și Arduino așa cum se arată mai jos. Sârmă roșie nu este de fapt necesară, dar, deoarece este întotdeauna o idee bună să aveți ambele șine de alimentare incluse în panoul de configurare, configurarea are sens.

Acum să reparăm un program care ne va permite să verificăm dacă hardware-ul nostru este configurat corect sau nu.

Este întotdeauna recomandat să codați și să executați biți mici de programe pentru a verifica dacă hardwar-urile respective sunt conectate corect sau nu.

Acest lucru ajută la depanarea rapidă a unei posibile erori.

Exemplul de cod de mai jos oferă LED-urilor 2 până la 5 un model specific rotindu-le unul după altul într-o manieră ciclică.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

După cum ați observat, nu este nimic în neregulă cu codul, cu excepția faptului că pare lung și, prin urmare, predispus la greșeli.

Desigur, există modalități mai bune de a scrie codul de mai sus, următoarea secțiune îl va dezvălui.

2.9 Introducerea matricilor

Tablourile pot fi un grup de variabile care pot fi indexate cu numere de index. Următorul exemplu ne va ajuta să îl înțelegem mai bine.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

OK, acum să parcurgem fiecare secțiune și să înțelegem cum funcționează de fapt.

const int k_numLEDs = 4

Codul de mai sus definește câte elemente maxime ar trebui să avem în matrice. Acest cod ne ajută în secțiunile următoare să ne asigurăm că totul este scris într-o matrice și nimic după ce matricea se termină.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

În următoarea linie am configurat structura matricei. Numerele din paranteză indică numărul de elemente din matrice. Deși cantitatea reală ar fi putut fi scrisă, scrierea ca constante funcționează mai bine. Valorile pot fi văzute în mod normal în paranteză cu virgule și desemnează valorile în matrice.

Când găsiți o matrice indexată cu numărul 0, aceasta indică primul element din matrice, așa cum se arată în code: k_LEDPins is k_LEDPins[0].

În mod similar, ultimul element va fi afișat ca k_LEDPins[3], deoarece numărul de la 0 la 3 este 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Codul de mai sus arată utilizarea buclei pentru a trece prin fiecare element de matrice și pentru a le seta ca OUTPUTS. Implementăm paranteze pătrate împreună cu indexul pentru a ajunge la fiecare dintre elementele din matrice.

dacă vă întrebați dacă este posibil să utilizați pinul # 2 la pinul # 5 fără matrice, răspunsul este da, este posibil. Dar în acest exemplu nu se face pentru că nu am făcut-o în acest fel. În secțiunile următoare puteți elimina abordarea matricei dacă pinii de ieșire selectați nu sunt în linie.

Mergând mai departe, să vedem ce face următorul bloc de cod:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Aici codul trece prin fiecare LED pentru a le porni ON secvențial cu un decalaj sau întârziere de 100 milisecunde.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

Utilizarea codului de mai sus prezintă modul în care aplicația pentru bucla ar putea fi folosit pentru a vă deplasa prin buclă chiar și în ordinea inversă.

Începe de la k_numLEDs - 1 deoarece matricele sunt zero indexate. Nu pornim de la k_LEDPins[4] deoarece acest lucru ar duce la traversarea finisajului matricei.

Codul folosește> = 0 pentru a verifica astfel încât primul element din indexul 0 să nu fie omis sau ignorat.

capitolul 3

Ce este o intrare

La fel am învățat cum să operăm lucrurile folosind Arduino. În acest capitol vom discuta despre cum să simțiți lumea reală prin interfața intrărilor din parametrii externi.

3.1 Utilizarea butoanelor

Știm cu toții ce este un buton și cum funcționează. Este un fel de comutator sau buton care conectează momentan un semnal de la o etapă de circuit la altul în timp ce se află în starea deprimat și rupe semnalul când este eliberat.

3.1.1 Un buton și un LED

Vom conecta Arduino cu un buton cu Arduino conform detaliilor prezentate mai sus și vom învăța funcționarea de bază și implementarea setului.

Butonul indicat, care se mai numește și un buton cu microcomutator, are 4 pini în total (2 perechi pe fiecare parte). Când sunt împinse, fiecare pereche de pini este unită intern și permite o conexiune sau o conducere prin ele.

În acest exemplu, folosim doar o pereche din acești pini sau contacte, cealaltă pereche este irelevantă și, prin urmare, este ignorată.

Să continuăm, aplicăm următorul cod și verificăm că funcționează!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Aici puteți găsi câteva lucruri care par neobișnuite. Să-i dăm seama cu pași înțelepți

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

Primul lucru pe care îl facem este să remediem buttonPin dupa cum INTRARE. Știu că e destul de simplu.

Apoi, atribuim ÎNALT la INTRARE pin. Vă întrebați cum poate fi posibil să scrieți ceva la intrare? Sigur, acest lucru poate fi interesant.

De fapt, atribuirea unui HIGH la o intrare Arduino comută un rezistor de tragere intern de 20k Ohm PORNIT (un LOW pe acest pin îl dezactivează).

O altă întrebare pe care o puteți face este ce este un rezistență pull-up. Am acoperit o postare cuprinzătoare privind rezistențele de tracțiune pe care le aveți invata-l aici .

OK, mergând mai departe, acum să ne uităm la codul principal al buclei:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Când apăsați butonul, pinul cu fir se conectează la masă, ceea ce redă un SCĂZUT la acel ac. Și în timp ce este în starea neprimată, același pin este ținut la ÎNALT sau + 5V prin intermediul rezistorului de tragere intern de 20K.

Aici vrem ca Arduino să aprindă LED-ul atunci când butonul este apăsat (LOW), prin urmare scriem HIGH pentru ieșire pentru fiecare răspuns al unui LOW de la buton, în timp ce este apăsat.

3.1.2 Două butoane și un LED

Ei bine, vă puteți întreba că acțiunea de mai sus ar fi putut fi făcută și fără un Arduino. Înțeleg, totuși, aceasta este o piatră abruptă pentru a afla cum butonul poate fi folosit cu Arduno.

Până în acest moment, am studiat scrierea codurilor pentru comutarea ON (HIGH) sau pentru oprirea (LOW) a unui LED.

Acum să vedem cum luminozitatea LED-ului ar putea fi controlată cu un Arduino.

Se poate face folosind două metode:

1. Prin restricționarea cantității de curent la LED
2. Prin utilizarea PWM sau modularea lățimii impulsurilor, în care alimentarea LED-ului este pornită / oprită la o rată dorită foarte rapid, producând o iluminare medie a cărei intensitate ar depinde de PWM.

Pe o placă Arduino, suportul PWM este disponibil pe pinii marcați cu o tildă (~), care sunt pinii 3, 4,5,9,10 și 11) la 500Hz (de 500 de ori pe secundă). Utilizatorul poate furniza orice valoare cuprinsă între 0 și 255, unde 0 se referă la nici un HIGH sau nu + 5V, iar 255 îi spune lui Arduino să obțină un HIGH sau + 5V tot timpul. Pentru inițierea acestor comenzi va trebui să accesați analogWrite () cu valoarea dorită.

Puteți presupune că PWM este x / 255 unde x este valoarea dorită pe care doriți să o trimiteți prin analogWrite().

Configurați Arduino și alți parametri așa cum se arată mai sus.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Aici puteți găsi 3 rânduri care au nevoie de explicații.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

Linia: ledBrightness = constrain(ledBrightness, 0, 255) ilustrează o funcție unică în interiorul Arduino cunoscută sub numele de constrain ().

Această funcție internă cuprinde un cod asemănător cu următoarele:

int constrain (valoarea int, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Toate codurile discutate înainte de aceasta au început cu nul , ceea ce însemna să nu returnezi nimic (nul). Întrucât codul de mai sus începe cu int , care indică faptul că returnează un număr întreg. Vom discuta mai multe despre acestea în secțiunile ulterioare, în acest moment nu uitați că un întreg nu are părți fracționate.

Corect, deci acest lucru implică, codul: ledBrightness = constrain(ledBrightness, 0, 255) atribuie ledBrightness to be within the range of 0 and 255.

Următoarea linie folosește analogWrite pentru a comanda Arduino să aplice PWM pe pinul selectat cu valoarea dorită.

Următoarea linie creează o întârziere de 20 de milisecunde, aceasta pentru a ne asigura că nu reglăm mâncarea mai repede de 50 Hz sau de 50 de ori pe secundă. Acest lucru se datorează faptului că oamenii pot fi mult mai încet decât un Arduino. Prin urmare, dacă întârzierea nu se face, programul ne poate face să simțim că apăsarea primului buton a stins LED-ul și apăsarea celui de-al doilea buton l-a aprins (încercați-l singur pentru a confirma).

3.2 Potențiometre

Să mergem mai departe și să învățăm cum să folosim potențiometre cu Arduino.

Pentru a ști cum funcționează potențiometrul sau o oală, puteți citi acest lucru articol .

Conectați parametrii afișați cu Arduino, așa cum se arată mai sus.

Un pot va avea 3 terminale. Terminaslul mediu se va conecta cu ANALOG IN 0 pe Arduino. Celelalte două terminale exterioare pot fi conectate la șinele de alimentare + 5V și 0V.

Să programăm și să verificăm rezultatele:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Veți găsi câteva lucruri care pot părea complet noi și care nu sunt incluse în niciunul dintre codurile noastre anterioare.

1. Constanta kPinPot este atribuit ca A0, în care A este scurtătura pentru a descrie unul dintre pinii analogici. Cu toate acestea, A0 se referă și la pinul 14, A1 la pinul 15 și așa mai departe, iar acestea vă permit să fiți utilizate ca intrări / ieșiri digitale în cazul în care rămâneți fără pinii pentru un experiment. Dar amintiți-vă că nu puteți utiliza pinii digitali ca pini analogici.
2. Linia: ledBrightness = map(sensorValue, 0, 1023, 0, 255) prezintă o nouă funcție interioară în Arduino cunoscută sub numele de Hartă(). Această caracteristică se calibrează din nou dintr-un interval dat în altul, denumit hartă (valoare, de la Low, fromHigh, toLow, toHigh). Acest lucru poate deveni crucial deoarece analogueRead dă o valoare în intervalul 0-1023, dar analogWrite poate accepta o valoare cuprinsă între 0-255.

S-ar putea să credeți că, din moment ce este posibil să controlați luminozitatea unui LED printr-o rezistență în schimbare, pur și simplu o oală ar fi putut fi suficientă în acest scop, de ce utilizarea Arduino. Ei bine, din nou, este doar fundamentul, pentru a arăta cum un pot ar putea fi configurat cu un Arduino.

Fără probleme, acum vom face ceva care nu se poate face fără un Arduino.

În acest experiment vom vedea cum rezistența variabilă a unei oale ar putea fi utilizată pentru a controla viteza de clipire sau rata unui LED.

Iată programul:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Evitarea întârzierii ()

Codul de mai sus arată bine, dar LED-ul nu poate verifica valoarea potului până când trece prin fiecare ciclu complet. Pentru întârzieri mai lungi, acest proces devine mai lung, utilizatorul trebuie să aștepte pentru a vedea răspunsul potului în timp ce îl mută. Această întârziere poate fi evitată cu unele programe inteligente, astfel încât să permită utilizatorului să verifice valoarea fără întârzieri minime. Iată codul.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Deci, ce diferă atât de mult în codul de mai sus? Linia următoare este cea care face diferența.

long lastTime = 0

Până la această secțiune, am discutat despre variabila int. Cu toate acestea, pot exista mai multe tipuri de variabile pe care le puteți accesa. Lista poate fi citită mai jos:

În prezent, poate fi crucial doar să știm că pentru stocarea unui număr relativ mare pentru int variabilă, puteți utiliza termenul lung sau a lung int.

Aici puteți vedea o altă funcție interesantă numită milis ().

Aceasta produce intervalul de timp în milisecunde pe care Arduino l-a lucrat în cursul funcționării sale de la început (acest lucru se va reseta la 0 după fiecare 50 de zile). Aici se întoarce mult pentru că dacă s-a întors int , contorizarea pentru perioade lungi poate să nu fie posibilă. Ai putea răspunde exact cât timp? Răspunsul este de 32,767 secunde.

Prin urmare, în loc să folosim delay (), verificăm milis () și imediat ce expiră numărul particular de milisecunde schimbăm LED-ul. În consecință, stocăm ultima dată când am schimbat-o ultima data variabilă, astfel încât să ne permită să o verificăm din nou ori de câte ori dorim.

3.3 LED-uri RGB

Până acum ne-am jucat cu un LED cu o singură culoare. Deși culoarea LED-ului ar putea fi schimbată prin înlocuirea LED-ului cu o altă culoare, dar ce zici de utilizarea LED-urilor RGB pentru a schimba culorile LED-urilor fără a schimba LED-urile?

Un LED RGB este practic un LED cu un LED roșu, verde și albastru încorporat și îmbinat într-un singur LED. Are un cablu comun care merge spre sol sau șină de alimentare 0V în timp ce celelalte 3 conductoare sunt alimentate cu semnale pozitive PWM diversificate pentru implementarea amestecarea culorilor .

Puteți conecta setarea așa cum se arată mai jos:

Poate arăta puțin complex, dar de fapt este o replică a designului nostru anterior de control LED folosind PWM.

Iată un cod al programului de practică:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

După încărcarea acestui cod, vedeți doar cum reglajele potului creează un efect de lumină interesant pe RGB, poate fi o distracție reală.

Veți găsi că atunci când toate cele 3 ghivece sunt mutate poziții maxime, în loc de o culoare albă veți vedea roșu. Acest lucru se datorează faptului că culoarea roșie este cea mai proeminentă dintre cele 3 culori și, prin urmare, domină în această situație. Cu toate acestea, puteți experimenta cu funcția Hartă() , înainte de a-l executa pe porțiunea roșie a LED-ului, pentru a crea un echilibru mai sensibil.

Audio cu Arduino

În această secțiune vom învăța cum să adăugăm sunet și muzică de bază la o configurare Arduino.

Vom vedea cum să comutăm un semnal la un difuzor conectat cu frecvența dorită.

Pentru a fi mai precis, se va încerca o notă de mijloc A, care este o notă de frecvență de 440 Hz.

Pentru a face acest lucru, vom reda pur și simplu o notă de mijloc A și vom optimiza semnalul de undă sinusoidală cu undă pătrată.

De asemenea, vom calcula perioada de timp în care un difuzor poate rămâne aprins, dând în judecată formula:

timeDelay = 1 secundă / 2 x ton Frecvență.

timeDelay = 1 secundă / 2 x 440

timeDelay = 1136 microsecunde

4.1 Să conectăm placa Arduino

4.2 Adăugarea unei note simple

Am discutat deja despre funcție întârziere() unde unitatea este în milisecunde (secundă / 1000), totuși veți găsi încă o funcție delayMicroseconds() unde unitatea este în microsecunde, (milisecundă / 1000).

Pentru configurarea actuală programăm un cod pentru a comuta + 5V PORNIT / OPRIT pe pinul selectat legat de difuzor, la o rată de 440 impulsuri pe secundă.

Reamintim, în ultima discuție am determinat valoarea 1136 microsecunde pentru nota audio intenționată.

Iată deci programul pentru acest lucru, care vă va permite să auziți o notă audio de 440 Hz imediat ce programați arduino cu un difuzor conectat.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Cu aplicația de mai sus este posibil să creați o notă audio, ceea ce înseamnă, de asemenea, că putem crea o muzică conform alegerii noastre.

Din cod înțelegem că Arduino include câteva funcții integrate care contribuie în plus la crearea de muzică.

Primul este ton() care funcționează cu 2 elemente împreună cu un al treilea element opțional, desemnat ca ton (pin, frecvență, durată). sau ton (pin, frecvență)

Ambele sunt desemnate să execute respectiva perioadă de timp alocată de dvs.

În absența unei perioade de timp, muzica va continua redarea până la apel ton() este executat din nou sau până când executați nici un ().

Acest lucru va trebui făcut cu ajutorul unei funcții de întârziere în cazul în care redarea muzicii este singurul lucru fundamental pe care îl implementați.

Durata timpului poate fi crucială, deoarece permite furnizarea unui timp pentru cât timp este redat muzica, astfel încât să puteți face liber alte lucruri. De îndată ce durata expiră, muzica se oprește.

Următoarea funcție nici un () gestionează un singur parametru și oprește tonul selectat pe un anumit pin atribuit.

Un avertisment aparte: oricând când ton() funcția este implementată, funcția PWM de pe pinii 3 și 11 va înceta să funcționeze.

Prin urmare, ori de câte ori este folosit un atașament de difuzor în program, asigurați-vă că nu utilizați pinul menționat pentru difuzoare, în loc să încercați alți pinii pentru atașamentul difuzoarelor.

OK, deci iată programul pentru implementarea muzicii pe un difuzor, deși nu este o muzică reală, ci mai degrabă o notă C.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

În codul de mai sus este posibil să fi observat ceva nou și asta este #defini .

Acest termen funcționează ca o comandă de căutare și înlocuire pentru computer în timp ce se realizează compilarea.

Ori de câte ori găsește primul lucru înainte de un spațiu, îl înlocuiește cu porțiunea rămasă a liniei (numite macrocomenzi).

Deci, în acest exemplu, când computerul vede NOTE_E4 îl înlocuiește rapid cu cantitatea 330.

Pentru mai multe note și personalizare, vă puteți referi la un fișier din stick-ul USB numit pitch-uri.h , unde majoritatea frecvențelor pot fi găsite în funcție de preferința dvs.

4.4 Muzică cu funcții

Codul de mai sus arată bine, dar pare să aibă multe repetări, ar trebui să existe o metodă pentru a scurta aceste repetări, nu?

Până acum am lucrat cu două funcții esențiale incluse în Arduino. Acum ar putea fi timpul să ne creăm propriile funcții.

Fiecare funcție trebuie să înceapă cu tipul de variabilă cu care poate fi asociată. De exemplu funcția nul se referă la tipul care nu returnează nimic, de unde și numele nul. Rețineți, am discutat deja o listă de variabile în secțiunile noastre anterioare, vă recomandăm să le consultați.

În consecință, numele funcției particulare primește o paranteză deschisă '(' urmată de o listă de parametri separați prin virgulă.

Fiecare dintre parametri își dobândește tipul împreună cu un nume și, în cele din urmă, o închidere ')' paranteze.

Acești parametri pot fi aplicați în cadrul funcției sub formă de variabile.

Să vedem mai jos un exemplu în care dezvoltăm o funcție numită tonul nostru () conceput pentru a fuziona ton() cu întârziere() linii, într-un mod în care funcția încetează să revină până când nota a terminat de redat tonul.

Implementăm aceste funcții în codul nostru anterior și obținem programul de mai jos, consultați ultimele linii:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Funcțiile pot fi extrem de utile pentru a face un program mai ușor de înțeles.

Următorul este un exemplu în care putem specifica alegerea tonului pe care dorim să-l redăm folosind două matrice. O matrice pentru păstrarea notelor, cealaltă pentru păstrarea ritmurilor.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Puteți vedea clar pe prima linie introducerea #include afirmație. Sarcina acestei declarații este de a ridica întregul fișier între ghilimele și de a-l plasa în poziția #include afirmație. Conform regulilor standard, acestea sunt plasate strict la începutul programului.

capitolul 5

Măsurarea temperaturii

Doar pentru a ne aminti, amintiți-vă, în loc să scrieți programe mari, este întotdeauna înțelept să scrieți și să analizați părți mici de coduri, ceea ce ajută la depistarea rapidă a greșelilor.

5.1 Monitor serial

Până acum, codurile pe care le-am discutat nu par atât de ușor pentru a permite depanarea rapidă. Aici vom încerca să ușurăm lucrurile pentru monitorizarea și rezolvarea mai ușoară a unei posibile probleme.

Arduino are o caracteristică care îi permite să „vorbească înapoi” cu computerul. Puteți fi observat că pin0 și pin1 sunt marcate ca RX și TX unul lângă celălalt. Acești pini sunt de fapt urmăriți de un IC separat în Arduino, care le modernizează pentru a citi prin cablul USB în timp ce este conectat la computer.

Secțiunea de mai jos prezintă un program complet, vă rugăm să continuați, vom afla despre noile intrări din cod ulterior. Acest cod este același cu cel exprimat în secțiunea 2.2, cu excepția faptului că include câteva date suplimentare pentru a ne permite să identificăm pentru ce a fost codat.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Puteți identifica două lucruri noi aici, o nouă linie în înființat() funcţie.

Serial.begin(9600)

Această linie exprimă pur și simplu necesitatea utilizării Serial1 cod pentru a-l aplica cu 9600 baud. (aici serialul se referă la biți trimis unul după altul și baud înseamnă rata la care este trimis). Această valoare în baud și cea din interiorul monitorului serial (vom afla acest lucru mai târziu) trebuie să fie egale, altfel datele din monitorul serial vor arăta gunoi. 9600 fiind standardul devine mai convenabil de utilizat.

A doua nouă intrare este după cum urmează

Serial.print('delayTime = ')
Serial.println(delayTime)

Aici, a doua linie sugerează că lucrul ulterior care iese din portul serial va începe pe următoarea linie. Așa este că a doua linie este diferită de cea a pumnului.

Încă un lucru pe care îl puteți vedea sunt citate ('). Acest lucru este cunoscut sub numele de șir, care va fi folosit doar ca constante aici, deoarece discuțiile suplimentare despre acest subiect pot fi prea elaborate și dincolo de sfera de aplicare.

OK, acum putem încărca codul de mai sus în Arduino și să vedem ce se întâmplă.

Ce, uops, nimic nu pare să se fi întâmplat, LED-ul Arduino pin # 13 a clipit și s-a oprit, în timp ce LED-ul Tx a rămas intermitent.

Ei bine, asta pentru că fereastra Serial Monitor nu este încă reparată.

Trebuie să faceți clic pe caseta Serial Monitor din IDE, așa cum se arată mai sus. Nu uitați să verificați rata de transmisie situată în partea dreaptă jos, în mod implicit ar trebui să fie 9600 și va corespunde codului. Dacă nu este sigur, selectați 9600.

Următorul videoclip explică modul în care este realizat.

Acum, să mergem mai departe și să aflăm cum funcția Serial Monitor de mai sus vă poate ajuta la procesarea măsurarea temperaturii folosind Arduino

Vom folosi IC TMP36 ca senzor de temperatură, având o gamă cuprinsă între -40 și 150 de grade Celsius.

Configurarea poate fi văzută mai jos:

Următorul cod va iniția măsurarea temperaturii citind ieșirea de la senzorul TMP36 și trimițându-le către monitorul serial al ID-ului.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Să înțelegem codul din partea de sus.

float temperatureC = getTemperatureC()

Aici puteți vedea că am inclus tipul de variabilă pluti.

Acesta este singurul tip de variabilă care prezintă stocarea tuturor, cu excepția numerelor întregi (numere fără părți zecimale sau fracționate).

Precizia unei variabile flotante poate fi de până la 6 până la 7 cifre.

Codul alăturat getTemperatureC() este propria noastră funcție care calculează matematic și convertește diferența de tensiune detectată de la senzorul TMP36 în grade Celsius.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

În secțiunea următoare a codurilor, de la termenul analogIn() este atribuit să returneze o cifră între 1 și 1023, devine posibil pentru noi să evaluăm tensiunea de la senzor înmulțind citirea noastră cu 5 și apoi împărțind-o la 1024.

Senzorul TMP36 este specificat pentru a genera 0,5V la 0 grade Celsius și, ulterior, generează 10mV pentru fiecare creștere a gradului Celsius.

Iată aproximarea pe care o putem genera prin calcule:

Puteți considera că este prima dvs. funcție care returnează o anumită valoare (rețineți că toate funcțiile rămase până acum nu au returnat nicio valoare deoarece au fost de tipul nul ).

Puteți înțelege că, pentru a obține o valoare dintr-o funcție, trebuie pur și simplu să adăugați întoarcere urmat de numărul dorit pe care doriți să îl returnați.

Când spunem întoarcere înseamnă că funcția returnează un răspuns sau un răspuns ori de câte ori este apelat, care ar putea fi aplicat unei variabile.

Când acest lucru este trimis către monitorul serial, citirea se convertește în Fahrenheit convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Această funcție preia gama Celsius și o convertește în Fahrenheit.

Pentru conversia Fahrenheit în Celsius implementăm formula Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Interfața unui LCD

Acum să studiem cum să interfațăm sau să conectăm un Ecran LCD cu Arduino pentru a obține afișaj vizual pentru ieșirile necesare.

În aplicația noastră vom folosi un LCD grafic de 84x48, având 84 pixeli sau puncte orizontal și 48 pixeli rezoluție verticală. Deoarece un controler dedicat devine imperativ pentru toate LCD-urile, dispozitivul actual încorporează, de asemenea, unul sub formă de controler PCD8544.

În acest tutorial vom conecta modulul LCD specificat mai sus cu Arduino și vom aplica anumite rutine pentru a crea mesaje text pe afișaj.

În figura următoare puteți găsi detalii cu privire la interfața LCD-ului, împreună cu un mic Regulator de tensiune 3.3V . Acest regulator este necesar deoarece LCD-ul este specificat pentru a funcționa cu o sursă de 3.3V.

Puteți vedea, de asemenea, 8 pinouturi din modulul LCD, specificațiile pinoutului pot fi studiate din următorul tabel:

Acum să vedem cum putem conecta ecranul LCD și parametrii relevanți cu Arduino. Detaliile pot fi vizualizate în ilustrația de mai jos:

5.4 Comunicarea către LCD

Deși este posibil să scriem coduri elaborate pentru interacțiunea cu ecranul LCD de la Arduino, vom învăța mai degrabă cum să facem același lucru folosind bibliotecile.

Bibliotecile cuprind un sortiment de coduri care pot fi aplicate rapid pentru un program Arduino selectat.

Acest lucru permite utilizatorului să apeleze o funcție fără efort, fără a fi nevoie să treacă printr-o muncă complexă de codificare.

5.4.1 Cum se instalează biblioteca

Pentru aceasta va trebui să creați un director numit biblioteci în computerul dvs. Arduino IDE, după cum sa explicat Aici

5.4.2 Implementarea operațiunilor LCD

La fel ca abordarea noastră anterioară, vom verifica mai întâi întregul cod și apoi vom încerca să înțelegem detaliile liniilor individuale.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Linia include codul #include

Codul #include instruiește computerul să ridice fișierul menționat și să înlocuiască elementul #include cu conținutul fișierului în timpul compilării programului.

Elementul #include poate avea paranteze unghiulare care indică căutarea în directorul bibliotecii, sau poate avea și ghilimele care indică căutarea în același director în care se află programul.

Liniile de cod ulterioare exprimă pinout-urile LCD și apoi scriem o nouă formă de variabilă:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Aici exprimăm o variabilă cu numele lcd având tipul PCD8544 și instruim computerul să-i regradeze pinouturile asociate cu Arduino.

În acest proces, descriem variabila către PC prin instruirea modului în care pinul clk, din, dc și reset sunt interfațate cu Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

Linia lcd.init() inițializează operația LCD. Odată ce acest lucru este executat, următoarea linie impune un cursor în partea stângă sus a afișajului. Și următoarea linie ulterioară face un efort pentru a imprima mesajul „Bună ziua, lume”.

Arată destul de identic cu tehnica în care am trimis mesaje pe monitorul serial. Singura diferență este utilizarea codului lcd.print în loc de serial.print.

Următorul bloc de cod este de fapt numit repetitiv.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Folosind această linie lcd.setCursor(0,1) fixăm cursorul pe a 0-a coloană din partea stângă a primului rând, peste ecranul LCD.

Următoarea linie folosește o comandă rapidă: lcd.print(millis())

Dacă vă amintiți, am lucrat cu millis() în codurile noastre anterioare, am fi putut aplica același lucru și aici prin coduri:

long numMillis = millis()
lcd.print(numMillis)

Cu toate acestea, din cauza faptului că aici nu este implicată nicio perioadă de timp în milisecunde, de aceea o realizăm prin simpla trimitere millis() funcționează direct la lcd.print() .

5.5 Combinarea întregului lucru

OK, acum să combinăm toate codurile pe care le-am învățat mai sus pentru realizarea circuitului de temperatură LCD și să vedem cum arată:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Totul pare standard în programul de mai sus, cu excepția utilizării funcției setCursor () . Aceasta este folosită pentru a alinia textul cât mai mult posibil în jurul centrului afișajului.

Grozav! Și felicitări, tocmai ai programat propriul tău indicator LCD de temperatură folosind Arduino.

Aplicații practice Arduino

Deoarece, în acest moment, am acoperit în detaliu diferitele tehnici de programare, este timpul să le analizăm prin aplicarea lor pentru câteva implementări practice utile.

Vom începe cu senzori și vom vedea cum ar putea fi folosite dispozitivele senzor cu Arduino executând câteva exemple de coduri.

7.1 Introducere în senzori

În acest tutorial vom învăța despre marea varietate de senzori care ar putea fi utilizați cu Arduino. Acestea pot include dispozitive cum ar fi senzorul de lumină LDR, senzorul de efect magnetic al halelor, senzorii de înclinare, senzorul de vibrații, senzorul de presiune etc.

Vom începe cu interfața dintre senzor de lumină LDR cu Arduino, așa cum se arată în următoarea diagramă:

După cum știm cu toții, LDR este un dispozitiv de rezistență dependent de lumină a cărui rezistență depinde de intensitatea incidentului ambiental de pe suprafața sa.

Intensitatea luminii este invers proporțională cu citirea rezistenței LDR.

Aici vom afla cum această proprietate poate fi integrată cu Arduino pentru executarea unei aplicații utile:

Codul complet al programului poate fi vizualizat după cum este prezentat mai jos:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

Toți parametrii utilizați în cod au fost deja discutați în cursul nostru, pe care l-am învățat până acum. Puteți verifica liniile, consultând secțiunile relevante.

Valorile au fost alese aleatoriu, puteți schimba cu ușurință conform propriilor preferințe.

Senzor de înclinare

Un senzor de înclinare este un dispozitiv simplu care poate fi utilizat pentru a detecta o acțiune de înclinare asupra oricărui obiect unde este instalat. Dispozitivul are practic o bilă metalică în interior, care la înclinare se rostogolește peste o pereche de contacte provocând o conducție peste acele contacte. Aceste contacte fiind terminate ca cabluri ale comutatorului de înclinare, sunt utilizate cu un circuit extern pentru detectarea conducției datorită unei acțiuni de înclinare și activarea aplicației de ieșire dorite.

Acum să vedem cum senzor de înclinare dispozitivul ar putea fi conectat. Imaginea de mai jos ne oferă o idee despre configurația completă:

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

În acest exemplu, pinul implicit # 13 LED este utilizat ca indicator de înclinare.

Puteți vedea în mod clar includerea rezistorului pull-up aici, destul de similar cu ceea ce am făcut în secțiunea 3.1. Prin urmare, termenul LOW indică faptul că funcția de înclinare nu este declanșată.

7.4 Releu de comutare Reed (releu activat cu magnet miniatural)

Acum să vedem cum să conectați un comutator de releu sau un senzor de câmp magnetic cu Arduino. Un releu reed este un fel de comutator care se activează sau se conduce atunci când un câmp magnetic sau un magnet este apropiat de acesta. Practic are o pereche de contacte feromagnetice în interiorul unei incinte miniaturale din sticlă care se unesc sau fac contact din cauza tragerii magnetice ori de câte ori un magnet este aproape de el. Când se întâmplă acest lucru, terminalele contactelor arată conducerea datorită închiderii contactelor.

Și aici folosim LED-ul pinului # 13 pentru a indica răspunsul. Puteți conecta un LED extern de la acest pin, dacă este necesar, conform explicațiilor noastre anterioare.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Termenii codului ar trebui să fie familiari și explicativi.

7.5 Senzor de vibrații folosind traductor piezo

În următorul exemplu de program vom vedea cum a traductor piezo poate fi folosit ca senzor de vibrații pentru a ilumina un LED prin Arduino.

Un element piezo este de fapt un dispozitiv care generează vibrații sau oscilații atunci când se aplică o frecvență peste terminalele sale. Cu toate acestea, același piezo ar putea fi folosit în procesul invers pentru generând impulsuri electrice ca răspuns la vibrațiile aplicate pe corpul său. Această vibrație ar putea fi sub forma unei lovituri sau a unei lovituri pe suprafața piezo.

Configurați Arduino și un element piezo așa cum este dat în figura următoare

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

Pragul 100 este introdus doar pentru a vă asigura că Arduino răspunde doar la vibrațiile autentice prin lovituri și nu la alte vibrații mai mici, cum ar fi sunetele puternice sau coarnele.

Selectarea pinului A5 nu este obligatorie, puteți selecta orice alte intrări analogice conform preferințelor dvs. și potrivindu-l în codul programului.

Folosirea servomotorului cu Arduino

Un servo motor este un tip de motor DC care poate fi rotit la unghiuri precise, în funcție de cererea unei anumite aplicații. Se poate face prin aplicarea unei comenzi calculate la intrările relevante ale motorului pentru a produce un unghi precis de rotație sau de rotație în intervalul de 180 de grade al motorului.

De obicei, un servomotor are 3 fire sau intrări. Firele pozitive sunt în mod normal de culoare roșie, firul negativ sau de masă este negru, firul de comandă sau firul de semnalizare este în mod normal de culoare albă sau galbenă.

Arduino facilitează controlul servomotorului prin limbajul de suport încorporat, ceea ce face ca controlul să fie foarte convenabil și ideal pentru servomotoare.

Următorul exemplu ne va arăta programul de configurare de bază pentru implementarea controlului servomotorului prin Arduino:

Codul este dat mai jos:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Putem vedea câteva intrări noi aici. Unul care spune firul atașat al servo-ului la ce pin este atribuit. Celălalt este codul care oferă pinului o valoare între 0 și 180, pentru determinarea unghiului de rotație pe servo.

Concluzie

Subiectul Arduino poate fi infinit de lung și, prin urmare, dincolo de scopul acestui articol. Cu toate acestea, sper că tutorialul de mai sus ar fi trebuit să vă ajute cu siguranță să învățați elementele de bază ale Arduino și să înțelegeți parametrii importanți prin intermediul diferitelor exemple de coduri de aplicație.

Sperăm că mai multe informații pot fi actualizate din când în când aici, ori de câte ori sunt disponibile.

Între timp, bucurați-vă de cursul dvs. de programare, Happy Arduinoing pentru voi !!