Arduino în limbajul c. Arduino și limbaje de programare compatibile

În acest articol, am decis să alcătuiesc un ghid complet pas cu pas pentru începătorii Arduino. Ne vom uita la ce este Arduino, ce aveți nevoie pentru a începe să învățați, de unde să descărcați și cum să instalați și să configurați mediul de programare, cum funcționează și cum să utilizați limbajul de programare și multe altele care sunt necesare pentru a crea cu drepturi depline. dispozitive complexe bazate pe familia acestor microcontrolere.

Aici voi încerca să dau un minim condensat, astfel încât să înțelegeți principiile lucrului cu Arduino. Pentru o imersiune mai completă în lumea microcontrolerelor programabile, acordați atenție altor secțiuni și articole ale acestui site. Voi lăsa link-uri către alte materiale pe acest site pentru un studiu mai detaliat al unor aspecte.

Ce este Arduino și pentru ce este?

Arduino este un kit de construcție electronică care permite oricui să creeze o varietate de dispozitive electro-mecanice. Arduino este format din software și hardware. Partea software include un mediu de dezvoltare (un program pentru scrierea și depanarea firmware-ului), multe biblioteci gata făcute și convenabile și un limbaj de programare simplificat. Hardware-ul include o linie mare de microcontrolere și module gata făcute pentru acestea. Datorită acestui lucru, lucrul cu Arduino este foarte ușor!

Cu ajutorul Arduino puteți învăța programare, inginerie electrică și mecanică. Dar acesta nu este doar un constructor educațional. Pe baza acestuia, puteți realiza dispozitive cu adevărat utile.
Pornind de la simple lumini intermitente, stații meteo, sisteme de automatizare și terminând cu sisteme de casă inteligentă, mașini CNC și vehicule aeriene fără pilot. Posibilitățile nu sunt nici măcar limitate de imaginația ta, deoarece există un număr mare de instrucțiuni și idei de implementare.

Kit de pornire Arduino

Pentru a începe să învățați Arduino, trebuie să achiziționați placa microcontrolerului în sine și părți suplimentare. Cel mai bine este să achiziționați un kit de pornire Arduino, dar puteți alege singur tot ce aveți nevoie. Recomand să alegeți un set pentru că este mai ușor și adesea mai ieftin. Iată link-uri către cele mai bune seturi și piese individuale pe care cu siguranță va trebui să le studiați:

Kit de bază Arduino pentru începători:	Cumpără
Set mare pentru antrenament și primele proiecte:	Cumpără
Set de senzori și module suplimentari:	Cumpără
Arduino Uno este cel mai simplu și convenabil model din linie:	Cumpără
Placă fără sudură pentru învățare și prototipare ușoară:	Cumpără
Set de fire cu conectori comozi:	Cumpără
Set LED:	Cumpără
Set rezistoare:	Cumpără
Butoane:	Cumpără
Potențiometre:	Cumpără

Mediul de dezvoltare Arduino IDE

Pentru a scrie, depana și descărca firmware, trebuie să descărcați și să instalați IDE-ul Arduino. Acesta este un program foarte simplu și convenabil. Pe site-ul meu am descris deja procesul de descărcare, instalare și configurare a mediului de dezvoltare. Prin urmare, aici voi lăsa pur și simplu link-uri către cea mai recentă versiune a programului și către

Versiune	Windows	Mac OS X	Linux
1.8.2

Limbajul de programare Arduino

Când aveți o placă de microcontroler în mâini și un mediu de dezvoltare instalat pe computer, puteți începe să scrieți primele schițe (firmware). Pentru a face acest lucru, trebuie să vă familiarizați cu limbajul de programare.

Programarea Arduino folosește o versiune simplificată a limbajului C++ cu funcții predefinite. Ca și în alte limbaje de programare asemănătoare C, există o serie de reguli pentru scrierea codului. Iată cele mai de bază:

• Fiecare instrucțiune trebuie să fie urmată de un punct și virgulă (;)
• Înainte de a declara o funcție, trebuie să specificați tipul de date returnat de funcție sau nul dacă funcția nu returnează o valoare.
• De asemenea, este necesar să se indice tipul de date înainte de a declara o variabilă.
• Comentariile sunt desemnate: // Inline și /* bloc */

Puteți afla mai multe despre tipurile de date, funcții, variabile, operatori și constructe de limbaj pe pagina de la Nu este necesar să memorați și să vă amintiți toate aceste informații. Puteți oricând să mergeți la cartea de referință și să vă uitați la sintaxa unei anumite funcții.

Toate firmware-ul Arduino trebuie să conțină cel puțin 2 funcții. Acestea sunt setup() și loop().

funcția de configurare

Pentru ca totul să funcționeze, trebuie să scriem o schiță. Să facem LED-ul să se aprindă după apăsarea butonului și să ne stingem după următoarea apăsare. Iată prima noastră schiță:

// variabile cu pinii dispozitivelor conectate int switchPin = 8; int ledPin = 11; // variabile pentru a stoca starea butonului și LED-ul boolean lastButton = LOW; curent booleanButton = LOW; boolean ledOn = fals; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // funcție pentru debouncing boolean debounse(boolean last) ( boolean current = digitalRead(switchPin); if (last != current) ( întârziere ( 5); curent = digitalRead (switchPin ) return current ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; (ledPin, ledOn);

// variabile cu pinii dispozitivelor conectate int switchPin = 8 ; int ledPin = 11 ; // variabile pentru a stoca starea butonului și a LED-ului boolean lastButton = LOW ; curent booleanButton = LOW ; boolean ledOn = fals ; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); // funcție pentru debouncing boolean debounse (boolean last ) ( curent boolean = digitalRead(switchPin); dacă (ultimul != curent ) ( întârziere(5); curent = digitalRead(switchPin); curent de retur; void loop() ( currentButton = debounse(lastButton); dacă (lastButton == LOW && currentButton == HIGH ) ( ledOn = ! A condus la ; lastButton = curentButton ; digitalWrite(ledPin, ledOn);

În această schiță, am creat o funcție suplimentară de debounse pentru a suprima respingerea contactului. Există informații despre respingerea contactelor pe site-ul meu. Asigurați-vă că verificați acest material.

PWM Arduino

Modularea lățimii impulsului (PWM) este procesul de control al tensiunii folosind ciclul de lucru al unui semnal. Adică, folosind PWM putem controla fără probleme sarcina. De exemplu, puteți modifica fără probleme luminozitatea unui LED, dar această modificare a luminozității se obține nu prin scăderea tensiunii, ci prin creșterea intervalelor semnalului scăzut. Principiul de funcționare al PWM este prezentat în această diagramă:

Când aplicăm PWM unui LED, acesta începe să se aprindă rapid și să se stingă. Ochiul uman nu este capabil să vadă acest lucru deoarece frecvența este prea mare. Dar atunci când filmați, cel mai probabil veți vedea momente în care LED-ul nu este aprins. Acest lucru se va întâmpla cu condiția ca rata de cadre a camerei să nu fie un multiplu al frecvenței PWM.

Arduino are un modulator de lățime a impulsului încorporat. Puteți utiliza PWM numai pe acei pini care sunt acceptați de microcontroler. De exemplu, Arduino Uno și Nano au 6 pini PWM: aceștia sunt pinii D3, D5, D6, D9, D10 și D11. Știfturile pot diferi pe alte plăci. Puteți găsi o descriere a tablei care vă interesează

Pentru a utiliza PWM în Arduino există o funcție. Acesta ia ca argumente numărul de pin și valoarea PWM de la 0 la 255. 0 este 0% umple cu un semnal ridicat, iar 255 este 100%. Să scriem o schiță simplă ca exemplu. Să facem ca LED-ul să se aprindă lin, să așteptăm o secundă și să se stingă la fel de ușor și așa mai departe la infinit. Iată un exemplu de utilizare a acestei funcții:

// LED-ul este conectat la pinul 11 ​​int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analogWrite(ledPin, i); delay(5); ) )

// LED-ul conectat la pinul 11 int ledPin = 11 ; void setup() ( pinMode(ledPin, OUTPUT); void loop() ( pentru (int i = 0; i< 255 ; i ++ ) { analogWrite(ledPin, i); întârziere(5); întârziere (1000); pentru (int i = 255; i > 0; i -- ) (

Publicul țintă al lui Arduino este reprezentat de utilizatorii neprofesioniști din domeniul roboticii și sistemelor simple de automatizare. Produsul principal este un set de plăci, prin combinarea cărora se pot crea diverse dispozitive capabile să îndeplinească o gamă largă de sarcini.

De exemplu, dintr-un set de scânduri produse de această companie, puteți asambla un alimentator automat pentru animalele dvs. de companie. Și acesta este doar unul dintre cele mai simple exemple. Sfera de aplicare posibilă a acestora este limitată doar de imaginația utilizatorilor.

Pe lângă plăcile de circuite imprimate produse sub marca Arduino, acestea au propriul limbaj de programare Arduino, care se bazează pe un limbaj cunoscut pe scară largă printre programatori. C/C++. Să aruncăm o privire mai atentă la ce este.

Limbajul de programare Arduino este destul de ușor de învățat, deoarece publicul țintă principal pentru utilizarea sa este amatorii. Cu toate acestea, este considerat unul dintre cele mai bune limbaje pentru programarea microcontrolerelor.

Arduino IDE este un program gratuit pe care oricine îl poate descărca. Pe site-ul nostru puteți utiliza orice versiune a mediului care vi se potrivește. De asemenea, accesul pentru descărcarea IDE-ului este oferit pe site-ul oficial al companiei, iar dacă se dorește, dezvoltatorii pot fi mulțumiți făcând un transfer de bani.

Un program scris în limbajul de programare Arduino se numește schiță. Schițele terminate sunt înregistrate pe tablă pentru execuție.

IDE-ul este suportat de sisteme de operare precum Windows, MacOs și Linux. Site-ul oficial al companiei precizează că acest limbaj de programare este scris în Wiring, dar de fapt nu există și este scris folosind C++ cu mici modificări.

De ce aveți nevoie pentru a începe cu Arduino IDE?

Pentru a începe, vom avea nevoie de următoarele lucruri:

• Placi Arduino;
• Cablu USB;
• un computer cu Arduino IDE instalat pe el.

Având acest set, poți începe să experimentezi cu plăcile pe care le ai, înregistrând primele tale schițe pe ele.

Cum se configurează Arduino pe un computer?

Acest lucru se face simplu. Trebuie să faceți următoarele:

• trebuie să conectați produsul pe care l-ați asamblat la computer folosind un cablu USB;
• În Manager dispozitive, trebuie să verificați la ce port este conectat microcontrolerul. Daca nu este afisat sau scrie ca dispozitivul nu este recunoscut, inseamna ca nu ai instalat corect driverul sau placa ta are nevoie de diagnosticare;
• Următorul pas este lansarea limbajului nostru de programare Arduino IDE. În meniu trebuie să selectați fila Instrumente. Când faceți clic pe el, se va deschide o listă în care trebuie să selectați elementul de port. Acolo trebuie să selectați portul specificat în managerul de dispozitive;
• Pasul final este să selectăm tabla pe care o vom folosi pentru a încărca schițele.

Important! Când vă conectați placa la un alt port USB, toate setările vor trebui făcute din nou.

Introducere în interfața Arduino

Unul dintre elementele principale ale Arduino este meniul principal al programului, care vă permite să accesați toate funcțiile disponibile ale programului nostru.

Mai jos este un panou cu pictograme care afișează cele mai utilizate funcții ale IDE-ului Arduino:

verificarea erorilor;

crearea unei noi schițe;

deschiderea ferestrei portului microcontrolerului;

Următorul element cel mai important este fila fișiere de proiect. Dacă aceasta este o schiță simplă, atunci va exista un singur fișier. Cu toate acestea, schițele complexe pot consta din mai multe fișiere. În acest caz, puteți comuta rapid vizualizarea de la un fișier la altul în bara de file. Este foarte confortabil.

Cel mai mare dintre blocuri este câmpul editor pentru schițele noastre. Aici putem vizualiza și, dacă este necesar, edita codul programului de care avem nevoie. A fost implementat un câmp separat pentru afișarea mesajelor de sistem. Cu acesta, puteți verifica dacă salvarea sau încărcarea schiței a avut succes și puteți trece la pașii următori. Există, de asemenea, o fereastră în program care afișează prezența schiței dvs. în timpul compilării.

Compilare– conversia codului sursă al limbajului de nivel înalt în cod mașină sau limbaj de asamblare.

Funcțiile de bază ale limbajului de programare

Să trecem în sfârșit la cele mai de bază funcții ale limbajului de programare Arduino.

Să spunem imediat că puteți găsi toate funcțiile pe site-ul nostru convenabil.

Punct şi virgulă;

Un punct și virgulă trebuie să urmeze fiecare expresie scrisă în limbajul de programare Arduino. De exemplu:

Int LEDpin = 9;

În această expresie atribuim o valoare unei variabile și observăm punctul și virgulă la sfârșit. Aceasta îi spune compilatorului că ați terminat o bucată de cod și treceți la următoarea bucată. Un punct și virgulă în codul Arduino separă o expresie completă de alta.

Bară oblică inversă dublă pentru comentarii pe un singur rând //

// Tot ceea ce vine după bara oblică dublă va fi gri și nu va fi citit de program

Comentariile sunt ceea ce utilizați pentru a comenta codul. Codul bun este bine comentat. Comentariile sunt menite să spună ție, și oricui altcineva care ar putea da peste codul tău, la ce te gândeai când l-ai scris. Un comentariu bun ar fi cam asa:

// Conectați un LED la acest pin Arduino int LEDpin = 9;

Acum, chiar și după 3 luni când mă uit la acest program, știu unde a fost conectat LED-ul.

Compilatorul va ignora comentariile, astfel încât să puteți scrie orice doriți. Dacă aveți nevoie de mult text pentru un comentariu, puteți utiliza un comentariu pe mai multe rânduri prezentat mai jos:

/* Un comentariu pe mai multe linii este deschis cu o singură bară oblică inversă urmată de un asterisc. Tot ce urmează va fi inactiv și ignorat de compilator până când închideți comentariul folosind mai întâi un asterisc și apoi o bară oblică inversă */

Comentariile sunt similare cu notele de subsol de cod, dar sunt mai frecvente decât cele care sunt plasate în partea de jos a paginilor în cărți.

Acolade ( )

Acoladele sunt folosite pentru a adăuga instrucțiuni care urmează să fie efectuate de o funcție (vom discuta despre funcții mai târziu). Există întotdeauna o acoladă deschisă și una care se închide. Dacă uitați să închideți o acoladă, compilatorul va imprima un cod de eroare.

Void loop() ( //această acoladă se deschide //program rece aici ) //această acoladă se închide

Amintiți-vă - nicio bretele nu poate fi lăsată neînchisă!

Funcții ()

Acum este timpul să vorbim despre funcții. Funcțiile sunt fragmente de cod care sunt folosite atât de des încât sunt încapsulate în anumite cuvinte cheie, astfel încât să le puteți utiliza mai ușor. De exemplu, o funcție ar putea fi următorul set de instrucțiuni dacă trebuie să vă spălați câinele:

1. Ia o găleată
2. Umpleți-l cu apă
3. Adăugați săpun
4. Găsiți un câine
5. Spumă câinele
6. Spală câinele
7. Clătiți câinele
8. Uscați câinele
9. Pune găleata deoparte

Acest set de instrucțiuni simple poate fi încapsulat într-o funcție pe care o putem numi WashDog. De fiecare dată când dorim să executăm toate aceste instrucțiuni, introducem pur și simplu WashDog și voilà - toate instrucțiunile sunt executate.

Arduino are anumite funcții care sunt adesea folosite în . Când le introduceți, numele funcției va fi portocaliu. De exemplu, funcția pinMode() este o funcție comună folosită pentru a indica modul pin Arduino.

Dar parantezele după funcția pinMode? Multe funcții necesită argumente. Un argument este informația pe care o funcție o folosește atunci când rulează. Pentru funcția noastră WashDog, argumentele pot fi numele câinelui și tipul de săpun, precum și temperatura și dimensiunea găleții.

PinMode(13, IEȘIRE); //Setează modul de ieșire Arduino

Argumentul 13 se referă la pinul 13, iar OUTPUT este modul în care doriți să funcționeze pinul. Când introduceți aceste argumente, în terminologie aceasta se numește transmitere de date, transmiteți informațiile necesare funcțiilor. Nu toate funcțiile necesită argumente, dar parantezele de deschidere și de închidere rămân, deși goale.

Millis(); //Obține timpul în milisecunde pentru care pornește Arduino

Rețineți că cuvântul OUTPUT este de obicei albastru. Există anumite cuvinte cheie în limbajul de programare Arduino care sunt folosite frecvent, iar culoarea albastră ajută la identificarea lor. Arduino IDE le transformă automat în albastru.

void setup()

Funcția setup(), după cum sugerează și numele, este utilizată pentru a configura placa Arduino. Arduino execută tot codul conținut între acolade după setup() o singură dată. Lucrurile tipice care se întâmplă în setup() sunt, de exemplu, setarea modului la contacte:

Void setup() ( //codul dintre acolade este executat o singură dată)

S-ar putea să vă întrebați ce înseamnă void înainte de funcția setup(). Void înseamnă că funcția nu returnează informații.

Unele funcții returnează valori - funcția noastră DogWash poate returna numărul de găleți necesare pentru curățarea unui câine. Funcția analogRead() returnează o valoare întreagă între 0 și 1023. Dacă acest lucru pare puțin ciudat acum, nu vă faceți griji, deoarece vom acoperi fiecare funcție comună Arduino pe măsură ce cursul continuă.

Să ne uităm la câteva lucruri pe care ar trebui să le știi despre setup():

1. setup() rulează o singură dată;
2. setup() ar trebui să fie prima funcție din schița Arduino;
3. setup() trebuie să aibă acolade de deschidere și de închidere.

buclă goală ()

Trebuie să-i iubești pe dezvoltatorii Arduino pentru că s-au asigurat că numele funcțiilor vorbesc de la sine. După cum sugerează și numele, tot codul dintre acoladele din bucla() este repetat din nou și din nou, iar cuvântul buclă înseamnă literal „buclă”. Funcția loop() este locul unde va merge corpul programului tău.

Ca și în cazul setup(), loop() nu returnează nicio valoare, așa că este precedat de cuvântul void.

Void loop() ( //orice cod pe care îl specificați aici este executat din nou și din nou)

Ți se pare ciudat că codul rulează într-o buclă mare? Această aparentă lipsă de variație este o iluzie. Majoritatea codului dvs. va avea anumite condiții de așteptare care vor declanșa noi acțiuni.

Există și alte programe care funcționează cu Arduino?

Pe lângă IDE-ul oficial Arduino, există programe terțe care își oferă produsele pentru lucrul cu microcontrolere bazate pe Arduino.

Un set similar de funcții ne poate fi furnizat de un program numit Procesare. Este foarte asemănător cu Arduino IDE, deoarece ambele sunt realizate pe același motor. Procesarea are un set extins de funcții care nu sunt cu mult inferioare programului original. Cu ajutorul bibliotecii Serial descărcabile, utilizatorul poate crea o conexiune între transmisia de date pe care placa și Procesarea le transmit unul altuia. În acest caz, putem face ca placa să execute programe direct de pe PC-ul nostru.

Există o altă versiune interesantă a programului original. Se numește B4R, iar diferența sa principală este că nu folosește limbajul C ca bază, ci un alt limbaj de programare - Basic. Acest produs software este gratuit. Există tutoriale bune pentru a lucra cu el, inclusiv cele scrise de creatorii acestui produs.

Există și opțiuni plătite pentru Arduino IDE. Unul dintre acestea este programul PROGROMINO. Principalul său avantaj este posibilitatea de completare a codului. Când compilați un program, nu va mai trebui să căutați informații în cărțile de referință. Programul în sine vă va oferi opțiuni posibile pentru utilizarea unei anumite proceduri. Setul său include multe mai multe funcții interesante care lipsesc din programul original și vă pot face mai ușor să lucrați cu plăci.

Concurenți Arduino

Această piață pentru producția de microcontrolere pentru crearea diverselor circuite electronice și robotică are mulți fani pe tot globul. Această situație contribuie la apariția pe piață nu numai a concurenților care oferă produse similare. Pe lângă acestea, sunt produse un număr semnificativ de falsuri de diferite calități. Unele sunt foarte greu de distins de originale, deoarece au calitate identică, altele au caracteristici foarte slabe și este posibil să nu funcționeze deloc cu produsele originale.

Există chiar și plăci Arduino care acceptă microprocesoare care rulează interpreți JavaScript. Sunt relevante, în primul rând, pentru cei care doresc să folosească limbajul Java în loc de C. La urma urmei, este mai simplu și vă permite să obțineți rezultate cu o viteză crescută. Cu toate acestea, aceste plăci sunt mai scumpe în raport cu Arduino, ceea ce reprezintă un dezavantaj semnificativ.

Dacă sunteți în căutarea unui hobby și sunteți interesat de un domeniu precum inginerie electrică, puteți alege în siguranță Arduino pentru asta. Acest hobby are o mulțime de avantaje. Te vei dezvolta intelectual, deoarece această activitate va cere să ai cunoștințe în diferite domenii.

Pe lângă divertisment, hobby-ul tău te va ajuta să creezi o mulțime de produse utile pe care le poți folosi pentru a-ți ușura viața de zi cu zi. De fiecare dată, vei găsi din ce în ce mai multe modalități noi de a-ți folosi pasiunea.

Stăpânirea acestei activități nu va fi atât de dificilă, datorită disponibilității unui număr mare de manuale și tutoriale. În viitor, veți găsi mulți oameni cu gânduri asemănătoare din întreaga lume, care vă vor împărtăși cunoștințele și vă vor stimula să faceți noi experimente!

Din punct de vedere istoric, partea de software Arduino a constat dintr-un mediu software integrat (IDE) care vă permitea să scrieți, să compilați și să încărcați codul scris pe hardware. Mediul ArduinoIDE și limbajul Wiring în sine se bazează în principal pe Procesare și indirect pe C/C++. De fapt, Arduino IDE este un mare amestec, nu pentru distracție, ci pentru comoditate.

Chiar și extern șiArduinoIDE șiProcesarea sunt similare

În ce constă programul (schița)?
Fiecare program, oricât de complex ar părea, constă din seturi separate blocuri cod, care este notat prin acolade (). Un program minim necesită doar 2 blocuri: setare și buclă. Prezența lor este obligatorie în orice program C++ pentru Arduino, altfel s-ar putea să primești o eroare în etapa de compilare.
void setup() ( ) void loop() ( )
În funcția setup() apar setările inițiale ale variabilelor și ale registrelor. După finalizarea setup() , controlul trece la funcția loop(), care este o buclă infinită scrisă în corp (între ( ) ). Aceste comenzi sunt cele care efectuează toate acțiunile algoritmice ale controlerului.

Hardware"Buna ziua, lume! - LED intermitent.
Ceea ce începe prima cunoaștere cu Arduino la interfața software și hardware este LED-ul care clipește.

Mai întâi trebuie să completați programul minim. Pentru Arduino (de exemplu UNO), conectăm un LED la pinul 12 și GND (culoarea LED-ului în sine este aleasă din preferințele personale).

Void setup() ( pinMode(12, OUTPUT); ) void loop() ( digitalWrite(12, HIGH); delay(100); digitalWrite(12, LOW); delay(900); )
Faceți Ctrl+C -> Ctrl+V, compilați, încărcați, controlați. Vedem un spectacol de lumini care nu durează mai mult de o secundă. Să ne dăm seama de ce se întâmplă asta.

Am adăugat câteva blocuri goale anterior expresii . Au fost plasate între bretele ale funcțiilor de configurare și buclă.
Fiecare expresie este o instrucțiune pentru procesor. Expresiile dintr-un bloc sunt executate una după alta, strict în ordine, fără pauze sau comutare. Adică, dacă vorbim despre un anumit bloc de cod, acesta poate fi citit de sus în jos pentru a înțelege ce se face.

Ce se întâmplă între{ } ?
După cum știți, pinii Arduino pot funcționa atât ca ieșire, cât și ca intrare. Când vrem să controlăm ceva, trebuie să transferăm pinul de control în starea de ieșire. Acest lucru se face prin expresie în funcțieînființat:
pinMode(12, OUTPUT); În această situație, expresia se realizează apel de funcție . În pinMode, pinul specificat de număr este setat la modul specificat (INPUT sau OUTPUT). Ce pin și despre ce mod vorbim sunt indicate în paranteze, separate prin virgule. În cazul nostru, dorim ca al 12-lea pin să acționeze ca ieșire. OUTPUT înseamnă ieșire, INPUT înseamnă intrare. Sunt apelate valori de calificare, cum ar fi 12 și OUTPUT argumente ale funcției . Câte argumente are o funcție depinde de natura funcției și de voința creatorului ei. Funcțiile nu pot avea deloc argumente, așa cum este cazul setup și loop.

Apoi, treceți la blocul buclei, în ordinea:
-apelați funcția încorporată digitalWrite. Este conceput pentru a aplica un zero logic (LOW, 0 volți) sau unul logic (HIGH, 5 volți) unui pin dat. Două argumente sunt transmise funcției digitalWrite: numărul de pin și valoarea logică.
- apelați funcția de întârziere. Aceasta, din nou, este o funcție încorporată care face ca procesorul să „adormiți” pentru un anumit timp. Este nevoie de un singur argument: timpul în milisecunde pentru a dormi. În cazul nostru este de 100 ms. Imediat ce 100 ms expiră, procesorul se trezește și trece imediat la următoarea expresie.
- apelați funcția încorporată digitalWrite. Doar că de această dată al doilea argument este LOW. Adică setăm un zero logic pe al 12-lea pin -> aplicăm 0 volți -> stingem LED-ul.
- apelarea funcției de întârziere. De data aceasta „dormim” puțin mai mult – 900 ms.

De îndată ce ultima funcție este executată, blocul buclei se termină și totul se întâmplă din nou. De fapt, condițiile prezentate în exemplu sunt destul de variabile și poți să te joci cu valorile de întârziere, să conectezi mai multe LED-uri și să faci ceva de genul unui semafor sau un fulger de poliție (totul depinde de imaginația și voința creatorului).

În loc de o concluzie, puțin despre curățenie.
De fapt, toate spațiile, rupturile de rând, caracterele tabulatoare nu au prea multă semnificație pentru compilator. Acolo unde există un spațiu, poate exista o întrerupere de linie și invers. De fapt, 10 spații la rând, 2 întreruperi de rând și încă 5 spații sunt echivalentul unui spațiu.

Cu ajutorul spațiului gol, puteți face un program ușor de înțeles și vizual sau, dimpotrivă, îl puteți desfigura dincolo de recunoaștere. De exemplu, exemplul de program poate fi modificat astfel:
void setup() ( pinMode(12, OUTPUT); ) void loop () ( digitalWrite(12,HIGH); delay(100); digitalWrite(12,LOW); delay(900); )

Pentru a preveni pe cineva să sângereze din ochi în timpul citirii, puteți urma câteva reguli simple:

1. Întotdeauna, la începutul unui nou bloc între( Și ) crește indentarea. De obicei sunt folosite 2 sau 4 spații. Alegeți una dintre valori și respectați-o pe tot parcursul.

Void loop() (digitalWrite(12, HIGH); întârziere(100); digitalWrite(12, LOW); întârziere(900); )
2. La fel ca în limbajul obișnuit: puneți un spațiu după virgule.

digitalWrite(12, HIGH);
3. Plasați caracterul de început de bloc (pe o linie nouă la nivelul de indentare curent sau la sfârșitul celui precedent. Și caracterul de sfârșit de bloc) pe o linie separată la nivelul de indentare curent:

void setup() ( pinMode(12, OUTPUT); ) void setup() ( pinMode(12, OUTPUT); )
4. Folosiți linii goale pentru a separa blocurile de semnificații:

void loop() (digitalWrite(12, HIGH); delay(100); digitalWrite(12, LOW); delay(900); digitalWrite(12, HIGH); delay(100); digitalWrite(12, LOW); delay( 900);
5. Pentru ca copilul să se bucure de lectură, există așa-zise comentarii. Acestea sunt constructe din codul programului care sunt complet ignorate de compilator și contează doar pentru persoana care le citește. Comentariile pot fi pe mai multe rânduri sau pe o singură linie:

/* acesta este un comentariu pe mai multe rânduri */ // acesta este un comentariu pe o singură linie

Introducere

Freeduino/Arduino este programat într-un limbaj de programare special - se bazează pe C/C++ și vă permite să utilizați oricare dintre funcțiile sale. Strict vorbind, nu există un limbaj Arduino separat, la fel cum nu există un compilator Arduino - programele scrise sunt convertite (cu modificări minime) într-un program în C/C++ și apoi compilate de compilatorul AVR-GCC. Deci, de fapt, se folosește o variantă de C/C++ specializată pentru microcontrolere AVR.

Diferența este că obțineți un mediu de dezvoltare simplu și un set de biblioteci de bază care simplifică accesul la perifericele situate „la bord” microcontrolerului.

De acord, este foarte convenabil să începeți să lucrați cu un port serial la o viteză de 9600 de biți pe secundă, efectuând un apel într-o singură linie:

Serial.begin(9600);

Și atunci când utilizați C/C++ „nud”, ar trebui să vă ocupați de documentația pentru microcontroler și să apelați ceva de genul acesta:

UBRR0H = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU / 16 + 9600 / 2) / 9600 - 1);
sbi(UCSR0B, RXEN0);
sbi(UCSR0B, TXEN0);
sbi(UCSR0B, RXCIE0);

Iată o scurtă prezentare a principalelor funcții și caracteristici ale programării Arduino. Dacă nu sunteți familiarizat cu sintaxa limbajelor C/C++, vă recomandăm să consultați orice literatură despre această problemă sau surse de pe Internet.

Pe de altă parte, toate exemplele prezentate sunt foarte simple și, cel mai probabil, nu veți avea dificultăți în înțelegerea textelor sursă și în redactarea propriilor programe chiar și fără a citi literatură suplimentară.

O documentație mai completă (în engleză) este prezentată pe site-ul oficial al proiectului - http://www.arduino.cc. Există, de asemenea, un forum, link-uri către biblioteci suplimentare și descrierile acestora.

Prin analogie cu descrierea de pe site-ul oficial al proiectului Arduino, un „port” se referă la un contact de microcontroler conectat la un conector sub numărul corespunzător. În plus, există un port de comunicație serial (port COM).

Structura programului

În programul dumneavoastră trebuie să declarați două funcții principale: setup() și loop().

Funcția setup() este apelată o dată, după fiecare pornire sau resetare a plăcii Freeduino. Folosiți-l pentru a inițializa variabile, pentru a seta moduri de operare ale porturilor digitale etc.

Funcția loop() execută secvențial comenzile descrise în corpul său din nou și din nou. Acestea. După finalizarea funcției, aceasta va fi apelată din nou.

Să ne uităm la un exemplu simplu:

void setup() // setările inițiale
{
beginSerial(9600); // setează viteza portului serial la 9600 bps
pinMode(3, INPUT); // setarea celui de-al 3-lea port pentru introducerea datelor
}

// Programul verifică al 3-lea port pentru prezența unui semnal pe el și trimite un răspuns către
// ca mesaj text către portul serial al computerului
void loop() // corpul programului
{
if (digitalRead(3) == HIGH) // condiție pentru interogarea celui de-al 3-lea port
serialWrite("H"); // trimite un mesaj sub forma literei „H” la portul COM
altfel
serialWrite("L"); // trimite un mesaj sub forma literei "L" la portul COM
întârziere (1000); // întârziere 1 sec.
}

pinMode(port, mod);

Descriere:

Configura portul specificat pentru a intra sau a ieși un semnal.

Opțiuni:

port – numărul portului al cărui mod doriți să îl setați (o valoare întreagă de la 0 la 13).

modul - fie INPUT (intrare) fie OUTPUT (ieșire).

pinMode(13, OUTPUT); //Al 13-lea pin va fi ieșirea
pinMode(12, INPUT); //iar al 12-lea este intrarea

Notă:

Intrările analogice pot fi utilizate ca intrări/ieșiri digitale prin accesarea lor folosind numerele 14 (intrare analogică 0) la 19 (intrare analogică 5)

digitalWrite(port, valoare);

Descriere:

Setează nivelul de tensiune la ridicat (HIGH) sau scăzut (LOW) pe portul specificat.

Opțiuni:

port: numărul portului

valoare: HIGH sau LOW

digitalWrite(13, HIGH); // setați pinul 13 la starea „înaltă”.

valoare = digitalRead(port);

Descriere:

Citește valoarea pe portul specificat

Opțiuni:

port: numărul portului interogat

Valoare returnată: returnează valoarea curentă pe portul (HIGH sau LOW) de tip int

int val;
val = digitalRead(12); // sondaj al 12-lea pin

Notă:

Dacă nu există nimic conectat la portul care este citit, atunci funcția digitalRead() poate returna valorile HIGH sau LOW în mod neregulat.

Intrare/ieșire semnal analogic

valoare = analogRead(port);

Descriere:

Citește o valoare de la portul analog specificat. Freeduino conține 6 canale, convertor analog-digital de 10 biți fiecare. Aceasta înseamnă că tensiunea de intrare de la 0 la 5V este convertită într-o valoare întreagă de la 0 la 1023. Rezoluția citirii este: 5V/1024 valori = 0,004883 V/valoare (4,883 mV). Este nevoie de aproximativ 100 nS (0,0001 C) pentru a citi o valoare de intrare analogică, astfel încât rata maximă de citire este de aproximativ 10.000 de ori pe secundă.

Opțiuni:

Valoare returnată: returnează un număr int în intervalul de la 0 la 1023 citit de la portul specificat.

int val;
val = analogRead(0); // citește valoarea la a 0-a intrare analogică

Notă:

Porturile analogice sunt definite ca semnal de intrare în mod implicit și, spre deosebire de porturile digitale, nu trebuie să fie configurate prin apelarea funcției pinMode.

analogWrite(port, valoare);

Descriere:

Emite o valoare analogică către port. Această funcție funcționează pe: 3, 5, 6, 9, 10 și 11 porturi digitale Freeduino.

Poate fi folosit pentru a schimba luminozitatea unui LED, a controla un motor etc. După apelarea funcției analogWrite, portul corespunzător începe să funcționeze în modul de modulare a lățimii impulsului de tensiune până când există un alt apel la funcția analogWrite (sau funcțiile digitalRead / digitalWrite pe același port).

Opțiuni:

port: numărul intrării analogice interogate

valoare: un număr întreg între 0 și 255. O valoare de 0 generează 0 V pe portul specificat; o valoare de 255 generează +5V pe portul specificat. Pentru valori între 0 și 255, portul începe să alterneze rapid între nivelurile de tensiune de 0 și +5 V - cu cât valoarea este mai mare, cu atât portul generează mai des nivelul HIGH (5 V).

analogWrite(9, 128); // setați pinul 9 la o valoare echivalentă cu 2,5V

Notă:

Nu este nevoie să apelați pinMode pentru a seta portul să iasă semnale înainte de a apela analogWrite.

Frecvența de generare a semnalului este de aproximativ 490 Hz.

timp = milis();

Descriere:

Returnează numărul de milisecunde de când Freeduino a executat programul curent. Contorul se va depăși și se va reseta după aproximativ 9 ore.

Valoare returnată: returnează o valoare lungă nesemnată

nesemnat de mult timp; // declararea unei variabile de timp de tip unsigned long
timp = milis(); // transferă numărul de milisecunde

întârziere (timp_ms);

Descriere:

Întrerupe programul pentru numărul specificat de milisecunde.

Opțiuni:

time_ms – timpul de întârziere al programului în milisecunde

întârziere (1000); //pauză 1 secundă

întârziereMicrosecunde

delayMicrosecunde(timp_μs);

Descriere:

Întrerupe programul pentru numărul specificat de microsecunde.

Opțiuni:

time_μs – timpul de întârziere al programului în microsecunde

delayMicrosecunde(500); //pauză 500 de microsecunde

pulseIn(port, valoare);

Descriere:

Citește un impuls (înalt sau scăzut) de la un port digital și returnează durata pulsului în microsecunde.

De exemplu, dacă parametrul „valoare” este setat la HIGH la apelarea funcției, atunci pulseIn() așteaptă să ajungă un nivel ridicat de semnal pe port. Din momentul în care sosește, numărătoarea inversă începe până când un nivel scăzut al semnalului este primit la port. Funcția returnează lungimea pulsului (nivel ridicat) în microsecunde. Funcționează cu impulsuri de la 10 microsecunde până la 3 minute. Rețineți că această funcție nu va returna un rezultat până când nu este detectat un puls.

Opțiuni:

port: numărul portului din care citim pulsul

valoare: tip puls HIGH sau LOW

Valoarea returnată: returnează durata pulsului în microsecunde (tip int)

int durata; // declararea unei variabile durate de tip int
durata = pulseIn(pin, HIGH); // măsoară durata pulsului

Transfer de date în serie

Freeduino are un controler încorporat pentru transmiterea datelor în serie, care poate fi folosit atât pentru comunicarea între dispozitivele Freeduino/Arduino, cât și pentru comunicarea cu un computer. Pe un computer, conexiunea corespunzătoare este reprezentată de un port USB COM.

Comunicarea are loc prin porturile digitale 0 și 1 și, prin urmare, nu le veți putea folosi pentru I/O digitale dacă utilizați funcții seriale.

Serial.begin(baud_rate);

Descriere:

Setează rata de transfer a informațiilor portului COM în biți pe secundă pentru transmisia de date în serie. Pentru a comunica cu un computer, utilizați una dintre aceste viteze standardizate: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 sau 115200. Puteți, de asemenea, să comunicați cu alte microcontroloare. porturile 0 și 1.

Opțiuni:

baud_rate: Rata de flux de date în biți pe secundă.

Serial.begin(9600); //setează viteza la 9600 bps

Serial.disponibil

count = Serial.available();

Descriere:

Octeții primiți prin portul serial ajung în bufferul microcontrolerului, de unde programul dumneavoastră îi poate citi. Funcția returnează numărul de octeți acumulați în buffer. Bufferul serial poate stoca până la 128 de octeți.

Valoare returnată:

Returnează o valoare int - numărul de octeți disponibili pentru citire în memoria tampon serial sau 0 dacă nu este nimic disponibil.

if (Serial.available() > 0) ( // Dacă există date în buffer
// aici ar trebui să existe recepția și procesarea datelor
}

char = Serial.read();

Descriere:

Citește următorul octet din bufferul portului serial.

Valoare returnată:

Primul octet disponibil de date primite de la portul serial sau -1 dacă nu există date de intrare.

incomingByte = Serial.read(); // citire octet

Descriere:

Șterge bufferul de intrare a portului serial. Datele din buffer se pierd, iar apelurile ulterioare către Serial.read() sau Serial.available() vor avea sens pentru datele primite după apelul Serial.flush().

Serial.flush(); // Ștergeți memoria tampon - începeți să primiți date „de la zero”

Descriere:

Datele de ieșire pe portul serial.

Opțiuni:

Funcția are mai multe forme de apel în funcție de tipul și formatul datelor de ieșire.

Serial.print(b, DEC) tipărește un șir ASCII - reprezentarea zecimală a lui b.

int b = 79;

Serial.print(b, HEX) tipărește un șir ASCII - reprezentarea hexazecimală a numărului b.

int b = 79;

Serial.print(b, OCT) tipărește un șir ASCII - reprezentarea octală a numărului b.

int b = 79;
Serial.print(b, OCT); //va scoate șirul „117” către port

Serial.print(b, BIN) tipărește un șir ASCII - reprezentarea binară a numărului b.

int b = 79;
Serial.print(b, BIN); //va scoate șirul „1001111” în port

Serial.print(b, BYTE) tipărește octetul inferior al lui b.

int b = 79;
Serial.print(b, BYTE); //va afișa numărul 79 (un octet). În monitor
//din portul serial obținem simbolul „O” - its
//codul este 79

Serial.print(str) dacă str este un șir de caractere sau o matrice de caractere, transferă str la byte-ul portului COM.

octeți de caractere = (79, 80, 81); //matrice de 3 octeți cu valorile 79,80,81
Serial.print("Aici octeții noștri:"); // scoate linia „Aici octeții noștri:”
Serial.print(octeți); //imite 3 caractere cu codurile 79,80,81 –
//acestea sunt caracterele „OPQ”

Serial.print(b) dacă b este de tip octet sau char, imprimă numărul b însuși în port.

char b = 79;
Serial.print(b); //va scoate caracterul „O” în port

Serial.print(b) dacă b este de tip întreg, tipărește reprezentarea zecimală a lui b în port.

int b = 79;
Serial.print(b); //va scoate șirul „79” către port

Descriere:

Funcția Serial.println este similară cu funcția Serial.print și are aceleași opțiuni de apel. Singura diferență este că două caractere suplimentare sunt scoase după date - un caracter de întoarcere carucior (ASCII 13 sau „\r”) și un caracter de linie nouă (ASCII 10 sau „\n”).

Exemplul 1 și exemplul 2 vor scoate același lucru în port:

int b = 79;
Serial.print(b, DEC); //va scoate șirul „79” către port
Serial.print("\r\n"); //va afișa caracterele „\r\n” – line feed
Serial.print(b, HEX); //va scoate șirul „4F” către port
Serial.print("\r\n");//va imprima caracterele "\r\n" – line feed

int b = 79;
Serial.println(b, DEC); //va scoate șirul „79\r\n” în port
Serial.println(b, HEX); //va scoate șirul „4F\r\n” în port

În monitorul portului serial obținem.

Limbajul de programare Arduino pentru începători este prezentat în detaliu în tabelul de mai jos. Microcontrolerul Arduino este programat într-un limbaj de programare special bazat pe C/C++. Limbajul de programare Arduino este o variantă a C++, cu alte cuvinte, nu există un limbaj de programare separat pentru Arduino. Puteți descărca cartea PDF la sfârșitul paginii.

În Arduino IDE, toate schițele scrise sunt compilate într-un program în C/C++ cu modificări minime. Compilatorul Arduino IDE simplifică foarte mult scrierea programelor pentru această platformă, iar crearea de dispozitive pe Arduino devine mult mai accesibilă persoanelor care nu au cunoștințe extinse despre limbajul C/C++. Mai jos vom oferi o scurtă referință care descrie principalele funcții ale limbajului Arduino cu exemple.

Referință detaliată la limbajul Arduino

Limbajul poate fi împărțit în patru secțiuni: instrucțiuni, date, funcții și biblioteci.

Limbajul Arduino	Exemplu	Descriere
Operatori
înființat()	void setup() { pinMode(3, INPUT); }	Funcția este folosită pentru a inițializa variabile, a determina modurile de funcționare ale pinii de pe placă etc. Funcția rulează o singură dată, după fiecare alimentare a microcontrolerului.
buclă()	buclă goală () { digitalWrite(3, HIGH); întârziere (1000); digitalWrite(3, LOW); întârziere (1000); }	Funcția buclă se desfășoară, permițând programului să efectueze și să reacționeze la calcule. Funcțiile setup() și loop() trebuie să fie prezente în fiecare schiță, chiar dacă aceste instrucțiuni nu sunt folosite în program.
Declarații de control
dacă	… dacă(x> dacă (x< 100) digitalWrite (3, LOW ); …	Instrucțiunea if este utilizată în combinație cu operatorii de comparare (==, !=,<, >) și verifică dacă condiția este adevărată. De exemplu, dacă valoarea variabilei x este mai mare de 100, atunci LED-ul de la ieșirea 13 se aprinde dacă este mai mic, LED-ul se stinge.
daca..altfel	… if (x > 100) digitalWrite (3, HIGH ); else digitalWrite(3, LOW); …	Declarația else vă permite să efectuați o altă verificare decât cea specificată în if, pentru a efectua mai multe verificări care se exclud reciproc. Dacă niciunul dintre verificări nu primește un rezultat ADEVĂRAT, atunci blocul de instrucțiuni din else este executat.
comutator...caz	… comutator(x) { cazul 3: rupere ; } …	La fel ca o instrucțiune if, o instrucțiune switch controlează un program permițându-vă să specificați acțiuni care vor fi efectuate în diferite condiții. Break este o comandă pentru a ieși dintr-o instrucțiune implicită, dacă nu este selectată nicio alternativă.
pentru	void setup() { pinMode(3, OUTPUT); } buclă goală () { pentru (int i=0; i<= 255; i++){ analogWrite(3, i); întârziere (10); } }	Construcția for este folosită pentru a repeta instrucțiunile cuprinse între acolade. De exemplu, diminuarea lină a unui LED. Antetul buclei for este format din trei părți: for (inițializare; condiție; increment) - inițializarea se efectuează o dată, apoi condiția este verificată, dacă condiția este adevărată, atunci se realizează incrementul. Bucla se repetă până când condiția devine falsă.
in timp ce	buclă goală () { în timp ce (x< 10) { x = x + 1; Serial.println(x); întârziere (200); } }	Instrucțiunea while este folosită ca o buclă care se va executa atâta timp cât condiția din paranteze este adevărată. În exemplu, instrucțiunea while loop va repeta codul între paranteze la nesfârșit până când x este mai mic de 10.
face în timp ce	buclă goală () { do { x = x + 1; întârziere (100); Serial.println(x); } în timp ce (x< 10); întârziere (900); }	Instrucțiunea do...while loop funcționează în același mod ca bucla while. Totuși, dacă expresia dintre paranteze este adevărată, bucla continuă mai degrabă decât iese din buclă. În exemplul de mai sus, dacă x este mai mare de 10, operația de adăugare va continua, dar cu o pauză de 1000 ms.
pauză continua	comutator(x) { cazul 1: digitalWrite (3, HIGH ); cazul 2: digitalWrite (3, LOW ); cazul 3: rupere ; cazul 4: continua ; implicit: digitalWrite (4, HIGH); }	Break este folosit pentru a forța ieșirea din buclele switch, do, for și while fără a aștepta finalizarea buclei. Instrucțiunea continue omite instrucțiunile rămase în pasul curent al buclei.
Sintaxă
; (punct şi virgulă)	… digitalWrite(3, HIGH); …	Un punct și virgulă este folosit pentru a marca sfârșitul unei declarații. Uitarea punctului și virgulă la sfârșitul unei linii are ca rezultat o eroare de compilare.
{} (bretele)	void setup() { pinMode(3, INPUT); }	Paranteza de deschidere „(” trebuie urmată de paranteza de închidere „)”. Parantezele nepotrivite pot duce la erori ascunse și de neînțeles la compilarea unei schițe.
// (un comentariu)	x = 5; // un comentariu