Programare Arduino. Programarea Arduino folosind ArduBlock folosind exemplul unui robot care se mișcă de-a lungul unei benzi
În ce constă programul?
Pentru început, merită să înțelegem că un program nu poate fi citit și scris ca o carte: de la copertă la copertă, de sus în jos, rând cu rând. Orice program este format din blocuri separate. Începutul unui bloc de cod în C/C++ este indicat printr-o acoladă stângă (, sfârșitul acestuia printr-o acoladă dreaptă).
Sunt blocuri diferite tipuriși care va fi executat când depinde de condițiile externe. În exemplul de program minim puteți vedea 2 blocuri. În acest exemplu, blocurile sunt numite definirea unei funcții. O funcție este doar un bloc de cod cu prenume, pe care cineva îl poate folosi apoi din exterior.
ÎN în acest caz, avem 2 funcții numite setup și loop. Prezența lor este obligatorie în orice program C++ pentru Arduino. S-ar putea să nu facă nimic, ca în cazul nostru, dar trebuie scrise. În caz contrar, veți primi o eroare în etapa de compilare.
Clasic al genului: LED intermitent
Să ne suplimentăm acum programul pentru ca măcar să se întâmple ceva. Pe Arduino, un LED este conectat la pinul 13. Poate fi controlat, ceea ce vom face.
void setup() ( pinMode(13 , OUTPUT) ; ) void loop() ( digitalWrite(13 , HIGH) ; delay(100 ); digitalWrite(13 , LOW) ; delay(900 ) ; )Compilați și descărcați programul. Veți vedea că LED-ul de pe placă clipește în fiecare secundă. Să ne dăm seama de ce acest cod duce la clipirea în fiecare secundă.
Fiecare expresie este un ordin pentru procesor de a face ceva. 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.
Acum să înțelegem în ce ordine sunt executate blocurile în sine, adică. funcții de configurare și buclă. Nu vă faceți griji cu privire la ceea ce înseamnă expresii specifice, doar respectați ordinea.
De îndată ce Arduino este pornit, clipește sau este apăsat butonul RESET, „ceva” apelează o funcțieînființat. Adică forțează ca expresiile din el să fie executate.
Imediat ce se termină configurarea, „ceva” apelează imediat funcția buclă.
De îndată ce bucla se termină, „ceva” apelează imediat funcția buclă din nou și așa mai departe la infinit.
Dacă numerotăm expresiile în ordinea modului în care sunt executate, obținem:
void setup() ( pinMode(13 , OUTPUT) ; ❶ ) void loop() ( digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100 ) ; ❸ ❼ … digitalWrite(13 , LOW) ; ❹(❻ ❿ delay(100 ) ; ❸ ❼ … digitalWrite(13 , LOW) ; ❹(❻ ❿) ❺ ❾ )Permiteți-ne să vă reamintim încă o dată că nu ar trebui să încercați să percepeți întregul program citind de sus în jos. Numai conținutul blocurilor este citit de sus în jos. În general, putem schimba ordinea declarațiilor de configurare și buclă.
void loop() ( digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100 ) ; ❸ ❼ … digitalWrite(13 , LOW) ; ❹ ❽ delay(900 ) ; ❺ ❻ ❿ delay(100 ) ; ❸ ❼… ) ❶ )Rezultatul nu va schimba nicio iotă: după compilare veți obține un fișier binar absolut echivalent.
Ce fac expresiile
Acum să încercăm să înțelegem de ce programul scris în cele din urmă face ca LED-ul să clipească.
După cum știți, pinii Arduino pot funcționa atât ca ieșiri, cât și ca intrări. Când vrem să controlăm ceva, adică să emitem un semnal, trebuie să comutăm pinul de control în starea de ieșire. În exemplul nostru, controlăm LED-ul pe al 13-lea pin, astfel încât al 13-lea pin trebuie să fie făcut o ieșire înainte de utilizare.
Acest lucru se face printr-o expresie din funcția de configurare:
PinMode(13, IEȘIRE) ;
Expresiile pot fi diferite: aritmetice, declarații, definiții, condiționale etc. În acest caz, implementăm în expresie apel de funcție. Îți amintești? Avem lor funcțiile de configurare și buclă, care sunt numite de ceva ce am numit „ceva”. Deci acum Noi numim functii care sunt deja scrise undeva.
Mai exact, în configurația noastră, numim o funcție numită pinMode. Setează pinul specificat prin număr la modul specificat: intrare sau ieșire. Indicăm ce pin și despre ce mod vorbim în paranteze, separate prin virgule, imediat după numele funcției. În cazul nostru, dorim ca al 13-lea pin să acționeze ca ieșire. OUTPUT înseamnă ieșire, INPUT înseamnă intrare.
Sunt numite valori de calificare, cum ar fi 13 și OUTPUT argumente ale funcției. Nu este deloc necesar ca toate funcțiile să aibă 2 argumente. Câte argumente are o funcție depinde de esența funcției și de modul în care autorul a scris-o. Pot exista funcții cu un argument, trei, douăzeci; funcțiile nu pot avea deloc argumente. Apoi, pentru a le apela, paranteza este deschisă și imediat închisă:
NoInterrupts() ;
De fapt, poate ați observat că nici funcțiile noastre de configurare și buclă nu acceptă niciun argument. Și misteriosul „ceva” îi cheamă în același mod cu paranteze goale la momentul potrivit.
Să revenim la codul nostru. Deci, deoarece intenționăm să clipim LED-ul pentru totdeauna, pinul de control trebuie făcut o dată la ieșire și apoi nu vrem să ne amintim despre asta. Pentru asta este destinată ideologic funcția de configurare: configurarea plăcii după cum este necesar și apoi lucrul cu ea.
Să trecem la funcția buclă:
void loop() (digitalWrite(13, HIGH); delay(100); digitalWrite(13, LOW); delay(900); )După cum sa menționat, este apelat imediat după configurare. Și este numit din nou și din nou de îndată ce se termină. Funcția de buclă este numită bucla principală a programului și este concepută ideologic pentru a efectua lucrări utile. În cazul nostru muncă utilă- LED intermitent.
Să parcurgem expresiile în ordine. Deci prima expresie este un apel la 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 valoare booleană. Drept urmare, primul lucru pe care îl facem este să aprindem LED-ul pe al 13-lea pin, aplicând 5 volți.
Odată ce acest lucru este făcut, procesorul trece imediat la următoarea expresie. Pentru noi, acesta este un apel la funcția de întârziere. Funcția de întârziere este, din nou, o funcție încorporată care face ca procesorul să intre în somn anumit timp. Este nevoie de un singur argument: timpul în milisecunde pentru a dormi. În cazul nostru este de 100 ms.
În timp ce dormim, totul rămâne așa cum este, adică. LED-ul rămâne aprins. Imediat ce 100 ms expiră, procesorul se trezește și trece imediat la următoarea expresie. În exemplul nostru, acesta este din nou un apel la funcția încorporată digitalWrite familiară. Adevărat, de data aceasta trecem valoarea LOW ca al doilea argument. Adică, setăm un zero logic pe al 13-lea pin, adică furnizăm 0 volți, adică oprim LED-ul.
După ce LED-ul este stins, trecem la următoarea expresie. Încă o dată, acesta este un apel la funcția de întârziere. De data asta adormim 900 ms.
Odată ce somnul s-a terminat, funcția buclă iese. La finalizare, „ceva” îl sună imediat din nou și totul se întâmplă din nou: LED-ul se aprinde, se aprinde, se stinge, așteaptă etc.
Dacă traduceți ceea ce este scris în rusă, obțineți următorul algoritm:
Aprinderea LED-ului
Dormiți 100 de milisecunde
Oprirea LED-ului
Dormim 900 de milisecunde
Să trecem la punctul 1
Astfel, avem un Arduino cu un far care clipește la fiecare 100 + 900 ms = 1000 ms = 1 secundă.
Ce poate fi schimbat
Să folosim doar cunoștințele pe care le-am dobândit pentru a face mai multe variații ale programului pentru a înțelege mai bine principiul.
Puteți conecta un LED extern sau alt dispozitiv care trebuie să „clipească” la un alt pin. De exemplu, pe 5. Cum ar trebui să se schimbe programul în acest caz? Trebuie să înlocuim numărul cu al 5-lea oriunde am accesat al 13-lea pin:
Compilați, descărcați, testați.
Ce trebuie făcut pentru ca LED-ul să clipească de 2 ori pe secundă? Reduceți timpul de somn, astfel încât totalul să fie de 500 ms:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(50 ); digitalWrite(5 , LOW) ; delay(450 ) ; )Cum pot face ca LED-ul să pâlpâie de două ori de fiecare dată când clipește? Trebuie să-l aprindeți de două ori cu o scurtă pauză între porniri:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(50 ); digitalWrite(5 , LOW) ; delay(50 ) ; digitalWrite(5 , HIGH) ; delay (50) ; digitalWrite(5 , LOW) ;Cum pot face ca dispozitivul să aibă 2 LED-uri care clipesc alternativ în fiecare secundă? Trebuie să comunicați cu doi pini și să lucrați în buclă cu unul sau altul:
void setup() ( pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(100 ) ; digitalWrite(5 , LOW) ; delay(900 ) ; digitalWrite (6 , HIGH) ; delay(100 ) digitalWrite(6 , LOW) ;Cum să vă asigurați că dispozitivul are 2 LED-uri care comută ca un semafor feroviar: mai întâi se aprinde unul apoi celălalt? Trebuie doar să nu opriți LED-ul aprins imediat, ci să așteptați până la momentul comutării:
void setup() ( pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; digitalWrite(6 , LOW) ; delay(1000 ) ; digitalWrite(5 , LOW) ; digitalWrite(6 , HIGH) ;Simțiți-vă liber să verificați și alte idei. După cum puteți vedea, este simplu!
Despre spațiu gol și cod frumos
În C++, spațiile, rupturile de linie și caracterele tabulatoare nu contează prea mult 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.
Spațiul gol este instrumentul unui programator, cu ajutorul căruia fie puteți face un program ușor de înțeles și vizual, fie îl puteți desfigura dincolo de recunoaștere. De exemplu, amintiți-vă programul pentru a clipi un LED:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(100 ); digitalWrite(5 , LOW) ; delay(900 ) ; )O putem schimba astfel:
void setup( ) ( pinMode(5 , OUTPUT) ; ) void loop () ( digitalWrite(5 ,HIGH) ; delay(100 ); digitalWrite(5 ,LOW) ; delay(900 ) ; )Tot ce am făcut a fost să lucrăm puțin cu spațiul gol. Acum puteți vedea clar diferența dintre codul armonios și codul ilizibil.
Pentru a respecta legea nerostită a proiectării programelor, care este respectată pe forumuri, atunci când este citită de alți oameni și este ușor de perceput de dvs., urmați câteva reguli simple:
1. Măriți întotdeauna indentația dintre ( și ) când începeți un bloc nou. De obicei sunt folosite 2 sau 4 spații. Alegeți una dintre valori și respectați-o pe tot parcursul.
Prost:
void loop() (digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900) ;)Amenda:
void loop() (digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900) ;)2. La fel ca în limbajul natural: pune un spațiu după virgule și nu pune înainte.
Prost:
DigitalWrite(5 ,HIGH) ;
Amenda:
digitalWrite(5 , HIGH) ;
3. digitalWrite(5 ,HIGH) ; DigitalWrite(5 , HIGH) ; Plasați începutul caracterului bloc (pornit linie nouă la nivelul de indentare curent sau la sfârşitul celui precedent. Și simbolul de sfârșit de bloc ) este activat
Prost:
linie separatăAmenda:
la nivelul de indentare curent:4. void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); )
Amenda:
void setup() ( pinMode(5 , OUTPUT) ; ) void setup() ( pinMode(5 , OUTPUT) ; )
Folosiți linii goale pentru a separa blocurile de semnificații:Chiar mai bine:
void loop() (digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900); digitalWrite(6, HIGH); delay(100) ; digitalWrite(6, LOW) ; delay( 900); Despre punct și virgulă S-ar putea să vă întrebați: de ce există un punct și virgulă la sfârșitul fiecărei expresii? Acestea sunt regulile C++. Se numesc astfel de reguli
sintaxa limbajului
void loop() (digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW); delay(900) ;)Programul este corect și echivalent cu ceea ce am văzut deja. Cu toate acestea, a scrie așa este o formă proastă. Codul este mult mai greu de citit. Deci, dacă nu aveți un motiv 100% bun pentru a scrie mai multe expresii pe aceeași linie, nu o faceți.
Despre comentarii
Una dintre reguli programare de calitate: „scrieți codul astfel încât să fie atât de clar încât să nu aibă nevoie de explicații.” Acest lucru este posibil, dar nu întotdeauna. Pentru a explica cititorilor săi câteva puncte neevidente din cod: colegii tăi sau tu însuți într-o lună, există așa-zise comentarii.
Acestea sunt modelele din codul programului, care sunt complet ignorate de compilator și contează doar pentru cititor. Comentariile pot fi pe mai multe rânduri sau pe o singură linie:
/* Funcția de configurare este apelată foarte întâi când se aplică energie la Arduino și acesta este un comentariu cu mai multe linii */. void setup() ( // setați pinul 13 în modul de ieșire pinMode(13, IEȘIRE) ;) void loop() ( digitalWrite(13, HIGH); delay(100) ; // sleep timp de 100 ms digitalWrite(13, LOW) ; delay(900) ; )
După cum puteți vedea, puteți scrie câte rânduri de comentarii doriți între simbolurile /* și */. Și după secvența // tot ce urmează până la sfârșitul rândului este considerat comentariu.
Așadar, sperăm că cele mai de bază principii de scriere a programelor au devenit clare. Cunoștințele dobândite vă permit să controlați în mod programatic sursa de alimentare către pinii Arduino în conformitate cu anumite scheme de sincronizare. Acest lucru nu este atât de mult, dar totuși suficient pentru primele experimente. Ardublock este limbaj grafic
programare pentru Arduino, concepută pentru începători. Acest mediu este destul de ușor de utilizat, ușor de instalat și aproape complet tradus în rusă. Un program proiectat vizual care seamănă cu blocuri...
Întreruperile sunt un mecanism foarte important în Arduino care permite dispozitivelor externe să interacționeze cu controlerul atunci când apar diverse evenimente. Prin instalarea unui handler de întrerupere hardware în schiță, putem răspunde la pornirea sau dezactivarea unui buton, la apăsarea tastaturii,...
Serial.print() și Serial.println() sunt principalele funcții ale Arduino pentru a transfera informații de pe placa Arduino la computer prin portul serial. Cele mai populare plăci Arduino Uno, Mega, Nano nu au afișaj încorporat, așa că... Este posibil să faci proiecte Arduino fără Placi Arduino servicii onlineși programe care au propriul nume: emulator sau Arduino simulator. Cei mai populari reprezentanți ai unor astfel de programe sunt...
Început în serie - extrem de instructiuni importante Arduino, permite controlerului să stabilească o conexiune cu dispozitive externe. Cel mai adesea așa dispozitiv extern„Se dovedește a fi computerul la care conectăm Arduino. De aceea, începutul serialului este mai intens...
O variabilă globală în Arduino este o variabilă a cărei sferă se extinde la întregul program, este vizibilă în toate modulele și funcțiile. În acest articol ne vom uita la câteva exemple de utilizare a variabilelor globale...
Matricele Arduino sunt un element de limbaj utilizat în mod activ de programatori pentru a lucra cu seturi de același tip de date. Array-urile se găsesc în aproape toate limbajele de programare, Arduino nu face excepție, a cărui sintaxă este foarte asemănătoare...
Din punct de vedere istoric, s-a întâmplat ca parte software Arduino constă dintr-un mediu software integrat (IDE) care vă permite să scrieți, să compilați și, de asemenea, să descărcați codul scris în hardware. Mediul ArduinoIDE și limbajul Wiring în sine se bazează în primul rând 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 desemnat bretele crete(). 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() există setările inițiale variabile, registre. După finalizarea setup() , controlul trece la funcția loop(), care este buclă nesfârșită, 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ă adăugați program 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 la blocurile 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ă comută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 o 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.
Odată terminat ultima functie, blocul buclei se termină și totul se întâmplă din nou și 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, întreruperile de rând, caracterele tabulatoare nu înseamnă mare lucru 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, un separat Limbajul Arduino nu există, așa 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, este folosit specializat pentru Microcontrolere AVR Opțiunea C/C++.
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 de înțelegere textele sursăși scrisul programe proprii chiar fără a citi literatură suplimentară.
Documentație mai completă (la engleză) este prezentat pe site-ul oficial al proiectului - http://www.arduino.cc. Există și un forum acolo, link-uri către biblioteci suplimentare si descrierea acestora.
Similar cu descrierea de pe site-ul oficial Proiect Arduino, „port” înseamnă un contact de microcontroler conectat la 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. Aceste. 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
// vizualizare mesaj text la 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ți portul specificat pentru a intra sau a ieși un semnal.
Parametri:
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, IEȘIRE); //Al 13-lea pin va fi ieșirea
pinMode(12, INPUT); //iar al 12-lea este intrarea
Nota:
Intrările analogice pot fi folosite ca intrări/ieșiri digitale prin accesarea lor prin numere care încep cu 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.
Parametri:
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
Parametri:
port: numărul portului interogat
Valoare returnată: returnează valoarea curentă pe port (HIGH sau LOW) tastați int
int val;
val = digitalRead(12); // sondaj al 12-lea pin
Nota:
Dacă nu există nimic conectat la portul 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ă tensiune de intrare 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 valoarea de intrare analogică, deci viteza maxima citiri - de aproximativ 10.000 de ori pe secundă.
Parametri:
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ă
Nota:
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).
Parametri:
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 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
Nota:
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 la executarea Freeduino 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ăr dat milisecunde
Parametri:
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.
Parametri:
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, începe numărătoarea inversă până când portul primește nivel scăzut semnal. Funcția returnează lungimea pulsului ( nivel înalt) î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.
Parametri:
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
Transmiterea datelor î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ă viteza de transmisie Port COM 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.
Parametri:
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.
Valoarea 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.
Valoarea 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.
Parametri:
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 - reprezentare binară numere 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 byte 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 are întreg tip, afișează reprezentarea zecimală a numărului b către 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” către port
Serial.println(b, HEX); //va scoate șirul „4F\r\n” în port
În monitorul portului serial obținem.
Poate fi foarte dificil să-ți începi călătoria în IT, chiar dacă doar pentru că, privind tehnologiile din jur, este imposibil să separăm interesul „hardware” de cel software. Pe de o parte, există dorința de a crea un dispozitiv cu impecabil aspect, o multitudine de senzori și posibilități nelimitate, pe de altă parte, misterul prelucrării datelor, dorința de a maximiza performanța fără a neglija funcționalitatea. Arduino - primul pas pentru mari invenții, care nu necesită cunoștințe profunde în proiectarea circuitelor sau experiență în programare.
Ce este Arduino
Dacă numiți pică o pică, atunci Arduino este un kit de construcție pentru cei care s-au săturat să creeze imagini inutile și vor să le dea măcar puțină viață. În cel mai simplu caz de Arduino - PCB, pe care se află controlerul, oscilatorul cu cristal, ADC/DAC, mai mulți conectori, diode și butoane. Restul este munca proprietarului: dacă doriți, creați un robot, dacă doriți, o platformă software și hardware pentru o casă „inteligentă”, sau uitați de beneficiile practice și distrați-vă.
Desigur, depinde. Cât de departe vrei să mergi cu experimentele tale, fie că vrei să te distrezi filtrat sau să transformi Arduino într-o platformă pentru propriul tău venit, va trebui să te îmbunătățești atât în designul hardware, cât și în învățarea limbajelor de programare. Să vorbim puțin mai mult despre acesta din urmă astăzi.
Arduino este o platformă destul de limitată în ceea ce privește capacitățile de programare, mai ales în comparație cu Raspberry Pi. Datorită faptului că pragul de intrare este indecent scăzut (tutorialul de bază ocupă 3 coli A4), nu puteți conta pe o mulțime de limbi fără a conecta module suplimentare. Se bazează pe C/C++, dar folosind o varietate de IDE-uri și biblioteci, veți avea acces la Python, C#, Go și favoritele copiilor, cum ar fi Snap! și ArduBlock. Vom vorbi în continuare despre cum, când și cine să le folosească.
C/C++
Limbajul de bază al platformei Arduino, care, cu unele modificări și simplificări, este utilizat în shell-ul software standard. Puteți găsi toate comenzile disponibile „pentru un începător”, dar nimeni nu vă împiedică să utilizați capacitățile originale ale limbajului C++; Dacă doriți să vă jucați cu C „pur”, atunci este la dispoziție un program conceput, după cum sugerează și numele, pentru interacțiunea între sistemul de operare Windows și seria AVR MK, care sunt utilizate pe Arduino. Mai mult ghid detaliat puteti citi aici.
Ardublock
Să ne îndepărtăm temporar de limbile adulților la limba preferată a copiilor Scratch, sau mai degrabă la adaptarea sa - Ardublock. Totul este la fel aici, dar cu adaptare la platforma ta: blocuri colorate, constructor, nume rusești, logică simplă. Această opțiune este grozavă chiar și pentru cei care nu sunt deloc familiarizați cu programarea. Așa cum în limbajul Logo poți muta o broască țestoasă virtuală pe un avion virtual, aici cu ajutorul unor operații simple poți interesa un copil într-o interpretare reală a acțiunilor sale de program.
Da, apropo, pentru a-l folosi trebuie să îl instalați pe IDE-ul dvs. standard Arduino. Ultimele versiuni Este mai bine să nu le prindeți, sunt destul de complexe, o dată cu sfârșitul anului 2013 va fi pentru început. Pentru a instala, redenumiți fișierul descărcat în „ardublock-all” și puneți-l în folderul „My Documents/Arduino/tools/ArduBlockTool/tool”. Dacă nu există, îl creăm noi. Dacă nu înțelegi ceva, iată mai multe detalii.
Snap!
În comparație cu Ardublock, Snap! are capabilități avansate sub formă de blocuri suplimentare, capacitatea de a utiliza liste și funcții. Adică Snap! în general, arată deja ca un limbaj de programare pentru adulți, fără a lua în considerare că mai trebuie să joci designerul de cod.
Pentru a utiliza acest limbaj, va trebui să accesați snap4arduino.org și să descărcați componentele necesare pentru sistemul de operare. Găsiți instrucțiuni pentru instalare, utilizare și exemple video aici.
Piton
În mod oficial, puteți programa pe Arduino folosind cel puțin limbajul Piet, pur și simplu pentru că, cu cantitatea potrivită de persistență, puteți compila orice în codul mașinii. Dar datorită faptului că Python este unul dintre cele mai populare limbi cu o combinație aproape optimă de complexitate/capacități, ar fi ridicol să ignorăm aplicabilitatea lui în Arduino. Puteți începe să învățați Python cu ajutorul nostru gratuit
