Ce limbaj de programare este folosit în Arduino. Limbajul de programare Arduino
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ți 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, IEȘIRE); //Al 13-lea pin va fi ieșirea
pinMode(12, INPUT); //iar al 12-lea este intrarea
Notă:
Intrările analogice pot fi folosite 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 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 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.
Valoarea 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ă
delayMicrosecunde
delayMicrosecunde(time_μ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 î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.
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. Buffer-ul 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 numărului 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 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 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.
Baza limbajului de programare al modulului Arduino este limbajul C (cel mai probabil C++). Mai exact, acest dialect al limbii se numește Processing/Wiring. Veți găsi o prezentare generală bună a limbii în anexă. Dar vreau să vorbesc mai mult nu despre limbaj, ci despre programare.
Un program este un anumit set de comenzi care este înțeles de procesor, procesorul computerului dvs. sau procesorul microcontrolerului modulului Arduino, nu contează. Procesorul citește instrucțiunile și le execută. Orice comenzi pe care procesorul le înțelege sunt numere binare. Acestea sunt doar numere binare și nimic altceva. Efectuând operațiile aritmetice pentru care procesorul a fost conceput cândva, procesorul operează pe numere. Numerele binare. Și se dovedește că atât comenzile, cât și la ce se referă sunt doar numere binare. Ca aceasta. Dar cum sortează procesorul prin această „grămadă” de numere binare?
În primul rând, toate aceste numere binare sunt scrise în celule RAM succesive care au adrese. Când încărcați un program și acesta începe să ruleze, procesorul primește prima adresă a programului, unde trebuie scrisă comanda. Acele instrucțiuni care necesită ca procesorul să funcționeze cu numere au „semne de identificare”, de exemplu, că în următoarele două celule de memorie sunt două numere care trebuie adăugate. Și contorul, să-l numim contor de program, unde este scrisă adresa următoarei comenzi, în acest caz mărește adresa astfel încât programul să conțină următoarea comandă la această adresă. Dacă programul nu funcționează corect sau există erori, procesorul poate face o greșeală și apoi, după ce a citit un număr în loc de o comandă, procesorul face ceva complet diferit de ceea ce ar trebui să facă, iar programul „se îngheață”.
Astfel, orice program este o succesiune de numere binare. Și programarea este capacitatea de a scrie corect secvențele corecte de numere binare. Cu destul de mult timp în urmă, instrumentele speciale numite limbaje de programare au început să fie folosite pentru a scrie programe.
Cu toate acestea, orice program necesită mai întâi să înțelegeți clar ce ar trebui să facă programul și de ce este necesar. Cu cât înțelegeți mai clar acest lucru, cu atât este mai ușor să creați un program. Programele mici, deși este greu de spus care programe sunt mici și care nu, pot fi considerate ca un întreg. Programele mai complexe sunt cel mai bine împărțite în părți care pot fi tratate ca programe independente. Acest lucru face mai bună crearea acestora, mai ușor de depanat și testat.
Nu sunt pregătit să argumentez, dar cred că este mai convenabil să porniți un program cu o descriere în limbaj obișnuit. Și în acest sens, cred că programarea nu trebuie confundată cu scrierea codului programului. Când un program este descris în cuvinte obișnuite, vă este mai ușor să determinați, de exemplu, ce limbaj de programare să alegeți pentru a crea codul programului.
Cel mai apropiat lucru de a scrie un program folosind numere binare este limbajul de asamblare. Se caracterizează prin corespondența comenzilor limbajului cu comenzile binare înțelese de procesor. Dar codarea programelor în limbaj de asamblare necesită mult efort și este mai aproape de o artă decât de operațiuni formale. Limbile de nivel înalt precum BASIC sau C sunt mai universale și mai ușor de utilizat. Și de mult timp, un limbaj grafic a fost folosit pentru a scrie programe într-o formă generală, iar recent au apărut „traducători” din acest limbaj în limbajul procesoarelor.
Pe lângă limbajele de programare generale, a existat întotdeauna o anumită specializare a limbajelor de programare și au existat limbaje specializate. Aș include și limbajul de programare al modulului Arduino printre acestea din urmă.
Tot ceea ce avem nevoie pentru a spune modulului să facă ceva de care avem nevoie este organizat într-un set convenabil de comenzi. Dar mai întâi, de ce avem nevoie de la Arduino?
Modulul poate fi utilizat în diferite capacități - este inima (sau capul) robotului, este baza dispozitivului, este și un constructor convenabil pentru stăpânirea lucrului cu microcontrolere etc.
Mai sus, am folosit deja programe simple pentru a verifica conexiunea modulului la computer. Pentru unii le pot părea prea simple și, prin urmare, nu sunt interesante, dar orice programe complexe constau din fragmente mai simple, similare cu cele cu care ne-am familiarizat deja.
Să vedem ce ne poate spune cel mai simplu program „Blink an LED”.
int ledPin = 13;
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
În primul rând, să ne amintim ce este un LED. În esență, aceasta este o diodă obișnuită, în care, datorită designului său, atunci când curentul curge în direcția înainte, joncțiunea începe să strălucească. Adică, pentru ca un LED să strălucească, curentul trebuie să circule prin el, ceea ce înseamnă că trebuie aplicată tensiune pe LED. Și pentru ca curentul să nu depășească valoarea admisă, un rezistor trebuie conectat în serie cu LED-ul, care se numește rezistor de limitare a curentului (a se vedea Anexa A, ieșire digitală). Tensiunea este aplicată LED-ului de către microcontrolerul care formează baza modulului Arduino. Microcontrolerul, pe lângă procesorul care execută comenzile noastre, are unul sau mai multe porturi I/O. Fără a lua în considerare dispozitivul specific al portului, să spunem asta - atunci când pinul portului funcționează ca ieșire, acesta poate fi reprezentat ca ieșirea unui microcircuit digital cu două stări, pornit și oprit (există tensiune la ieșire , nu există tensiune la ieșire).
Dar același pin de port poate funcționa și ca intrare. În acest caz, poate fi reprezentat, de exemplu, ca intrarea unui microcircuit digital - un nivel logic, ridicat sau scăzut, este aplicat intrării (a se vedea Anexa A, intrare digitală).
Cum intermitem LED-ul:
Activați pinul de ieșire a portului. Opriți ieșirea portului.
Dar procesorul este foarte rapid. Nu vom avea timp să observăm clipirea. Pentru a observa această clipire, trebuie să adăugăm pauze. Acesta este:
Activați pinul de ieșire a portului. Pauză de 1 secundă.
Opriți ieșirea portului.
Pauză de 1 secundă.
Acesta este programul nostru. Procesorul va citi prima comandă și va porni ieșirea, LED-ul se va aprinde. Apoi procesorul se va opri și va opri ieșirea, LED-ul se va stinge. Dar a clipit o singură dată.
Repetarea unui proces sau a unui set de comenzi se numește buclă în programare. Sunt utilizate diferite tipuri de cicluri. Există o buclă care rulează de un anumit număr de ori. Aceasta este o buclă pentru. Există bucle care rulează până când este îndeplinită o anumită condiție, care face parte din construcția buclei din limbaj. Și dacă condiția nu este îndeplinită niciodată, atunci bucla este executată de un număr infinit de ori. Este un ciclu nesfârșit.
Nu cred că microcontrolerele sunt folosite cu programe de tipul prezentat mai sus. Adică mai multe comenzi sunt executate o dată și controlerul nu mai funcționează. De regulă, funcționează continuu de îndată ce i se aplică tensiunea de alimentare. Aceasta înseamnă că microcontrolerul trebuie să funcționeze într-o buclă nesfârșită.
Acesta este exact ceea ce spune funcția void loop(), o buclă este o buclă, o buclă închisă. Nu există nicio condiție pentru oprirea ciclului și, prin urmare, nu există nicio condiție pentru finalizarea acestuia.
În plus, trebuie să spunem modulului Arduino ce pin de port vrem să folosim și cum vrem să fie folosit, pentru ieșire (OUTPUT) sau pentru intrare (INPUT). Acest scop este servit de funcția void setup(), care este obligatorie pentru limbajul Arduino, chiar dacă nu este folosită, și de comanda pinMode() pentru a seta modul de funcționare de ieșire.
pinMode(ledPin, OUTPUT);
Și totuși, constructul limbajului folosește variabile pentru a determina numărul de ieșire:
int ledPin = 13;
Utilizarea variabilelor este convenabilă. Dacă decideți că veți utiliza ieșirea 12 în loc de 13, veți face doar o modificare pe o singură linie. Acest lucru este valabil mai ales în programele mari. Numele variabilei poate fi ales după cum doriți, dar în general trebuie să fie doar caractere, iar numărul de caractere este adesea limitat. Dacă setați incorect numele variabilei, cred că compilatorul vă va corecta.
Funcția digitalWrite(ledPin, HIGH) setează pinul specificat la o stare ridicată, adică pornește pinul.
Și întârzierea (1000), așa cum ați înțeles deja, înseamnă o pauză de 1000 de milisecunde sau 1 secundă.
Rămâne să înțelegem ce înseamnă prefixe precum int și void. Orice valoare, orice variabilă se află în memorie, la fel ca și comenzile programului. Numerele formate adesea din 8 biți sunt scrise în celulele de memorie. Acesta este un octet. Dar un octet este un număr de la 0 la 255. Pentru a înregistra numere mari, aveți nevoie de doi octeți sau mai mulți, adică două sau mai multe celule de memorie. Pentru a clarifica procesorului cum să găsească un număr, diferitele tipuri de numere au nume diferite. Deci un număr numit octet va ocupa o celulă, int (întreg, întreg) va lua mai mult. În plus, funcțiile utilizate în limbajele de programare returnează și numere. Pentru a determina ce tip de număr ar trebui să returneze o funcție, prefixați funcția cu acel tip de număr returnat. Dar unele funcții pot să nu returneze numere; astfel de funcții sunt precedate de notația void (vezi Anexa A, variabile).
Atât de interesant poate spune chiar și cel mai simplu program.
Sper că puteți citi despre toate acestea în anexă. Acum să facem experimente simple, folosind doar ceea ce știm deja din capacitățile limbajului. Mai întâi, să înlocuim o variabilă de tip int, care ocupă mult spațiu de memorie, cu un octet - un loc, o celulă de memorie. Să vedem ce putem face.
byte ledPin = 13;
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
După compilarea și încărcarea programului în modul, nu vom observa nicio modificare în funcționarea programului. Amenda. Apoi vom schimba programul pentru a observa modificări în funcționarea acestuia.
Pentru a face acest lucru, vom înlocui numărul din funcția de întârziere (1000) cu o variabilă, numind-o my_del. Această variabilă trebuie să fie un număr întreg, adică int.
int my_del = 5000;
Nu uitați să terminați fiecare comandă cu punct și virgulă. Faceți modificări în program, compilați-l și încărcați-l în modul. Apoi modificați variabila și recompilați și încărcați din nou:
byte my_del = 5000;
Sunt sigur că diferența va fi vizibilă.
Să facem un alt experiment cu schimbarea duratei pauzelor. Să reducem durata pauzelor, să zicem, de cinci ori. Să facem o pauză de 2 secunde, apoi să o mărim și de cinci ori. Și din nou facem o pauză de 2 secunde. O buclă care rulează un anumit număr de ori se numește buclă for și este scrisă astfel:
pentru (int i = 0; i<5; i++)
ceva care este executat într-o buclă for
Pentru a executa bucla, are nevoie de o variabilă, pentru noi este i, variabilei trebuie să i se dea o valoare inițială, pe care i-am atribuit-o. Apoi urmează condiția pentru terminarea buclei, avem i mai mic decât 5. Și intrarea i++ este o intrare tipică în limbaj C pentru creșterea unei variabile cu una. Acolade limitează setul de comenzi care pot fi executate într-o buclă for. Alte limbaje de programare pot avea diferiți delimitatori pentru evidențierea unui bloc de cod de funcție.
În interiorul buclei facem același lucru ca înainte, cu câteva modificări minore:
pentru (int i = 0; i<5; i++)
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
my_del = my_del - 100;
Am vorbit mai sus despre modificarea înregistrării pauzei, iar schimbarea pauzei în sine se realizează prin scăderea variabilei cu 100.
Pentru a doua buclă, vom scrie același bloc de cod, dar vom crește variabila durata pauzei cu 100.
pentru (int i = 0; i<5; i++)
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
Ați observat că înregistrarea unei scăderi a pauzei și o creștere a acesteia arată diferit. Aceasta este, de asemenea, o caracteristică a limbajului C. Deși, pentru claritate, această intrare ar fi trebuit repetată, schimbând doar semnul minus în plus. Deci obținem acest program:
int ledPin = 13;
int my_del = 1000;
pinMode(ledPin, OUTPUT);
pentru (int i = 0; i<5; i++)
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
pentru (int i = 0; i<5; i++)
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
Să copiem codul programului nostru în programul Arduin, să îl compilam și să îl încărcăm în modul. Modificarea duratei pauzelor este vizibilă. Și va fi și mai vizibil, încercați dacă bucla for este executată, să zicem, de 8 ori.
Ceea ce tocmai am făcut este ceea ce fac programatorii profesioniști - având un program gata făcut, acesta poate fi ușor modificat pentru a se potrivi nevoilor sau dorințelor dumneavoastră. De aceea își stochează toate programele. Ceea ce te sfatuiesc sa faci si eu.
Ce ne-a lipsit în experimentul nostru? Nu am comentat munca noastră. Pentru a adăuga un comentariu, utilizați fie o dublă bară oblică, fie o singură bară oblică, dar cu asteriscuri (vezi Anexa A). Vă sfătuiesc să faceți acest lucru singur, pentru că atunci când vă întoarceți la program după un timp, o veți înțelege mai ușor dacă există explicații despre ceea ce faceți în cutare sau cutare loc al programului. Și vă mai sfătuiesc să stocați descrierea acesteia în limbaj simplu, realizată în orice editor de text, în folderul cu fiecare program.
Cel mai simplu program „clipirea unui LED” poate servi pentru încă o duzină de experimente (chiar și cu un LED). Mi se pare că această parte a lucrării, care vine cu ce altceva se poate face într-un mod interesant, este cea mai interesantă. Dacă vă referiți la anexa în care este descris limbajul de programare, la secțiunea „controlul programului”, puteți înlocui bucla for cu un alt tip de buclă. Și încercați cum funcționează alte tipuri de cicluri.
Deși un procesor cu microcontroler, ca oricare altul, poate efectua calcule (de aceea a fost inventat), iar acesta este folosit, de exemplu, în dispozitive, cea mai tipică operație pentru un microcontroler va fi setarea portului de ieșire la un nivel ridicat sau scăzut. stare, adică „luminați LED-ul” ca reacție la evenimente externe.
Microcontrolerul învață despre evenimentele externe în principal prin starea intrărilor. Setând pinii portului la o intrare digitală, îl putem monitoriza. Dacă starea inițială a intrării este ridicată și un eveniment face ca intrarea să scadă, atunci putem face ceva ca răspuns la acel eveniment.
Cel mai simplu exemplu este un buton la intrare. Când butonul nu este apăsat, intrarea este într-o stare ridicată. Dacă apăsăm butonul, intrarea scade și putem „aprinde” LED-ul la ieșire. Data viitoare când apăsați butonul, LED-ul poate fi stins.
Acesta este din nou un exemplu de program simplu. Chiar și un începător poate considera că este neinteresant. Cu toate acestea, acest program simplu poate găsi și aplicații destul de utile. Voi da doar un exemplu: după apăsarea butonului, nu vom aprinde LED-ul, ci vom clipi (într-un anumit fel). Și să luăm un LED cu radiație infraroșie. Ca rezultat, vom obține un panou de control. Acesta este un program atât de simplu.
Există diferențe în lista de exemple în diferite versiuni ale programului. Dar puteți consulta manualul de limbă din anexă, care are un exemplu și diagramă de program (în secțiunea de exemple numită „anexă”) pentru lucrul cu intrare. Voi copia programul:
int ledPin = 13;
pinMode(ledPin, OUTPUT);
pinMode(inPin, INPUT);
dacă (digitalRead(inPin) == HIGH)
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);
Și, după cum puteți vedea, obținem un program complet nou prin modificarea celui vechi. Acum LED-ul va clipi numai atunci când este apăsat butonul care este conectat la pinul 2. Pinul 2 este conectat la firul comun (masă, GND) printr-un rezistor de 10 kOhm. Butonul este conectat la un capăt la tensiunea de alimentare +5V, iar la celălalt capăt la pinul 2.
În program întâlnim un nou construct de limbaj dacă din secțiunea de control al programului. Se citește astfel: dacă condiția (închisă între paranteze) este îndeplinită, atunci blocul de program cuprins între acolade este executat. Rețineți că în condiția (digitalRead(inPin) == HIGH) egalitatea intrării cu starea ridicată se face folosind două semne egale! Foarte des, în grabă, acest lucru este uitat, iar starea se dovedește a fi incorectă.
Programul poate fi copiat și încărcat în modulul Arduino. Cu toate acestea, pentru a verifica funcționarea programului, va trebui să faceți unele modificări în designul modulului. Totuși, acest lucru depinde de tipul de modul. Modulul original are prize pentru conectarea la carduri de expansiune. În acest caz, puteți introduce fire solide adecvate în locurile necesare din conector. Modulul meu are contacte blade pentru conectarea la plăcile de expansiune. Pot fie să caut un conector potrivit, fie, care este mai ieftin, să folosesc o priză potrivită pentru cip într-un pachet DIP.
A doua întrebare este cum să găsiți pinii modulului care sunt utilizați în program?
Poza pe care am făcut-o de pe site-ul: http://robocraft.ru/ vă va ajuta să vă dați seama.
Orez. 4.1. Locația și scopul controlerului și pinii modulului Arduino
Toate pinurile de pe modulul meu CraftDuino sunt etichetate, așa că găsirea pinului potrivit este ușoară. Puteți conecta un buton și o rezistență și puteți verifica funcționarea programului. Apropo, pe site-ul RoboCraft menționat mai sus, întregul proces este afișat în imagini (dar programul nu folosește exact aceleași concluzii!). te sfatuiesc sa te uiti.
Multe microcontrolere includ dispozitive hardware suplimentare. Deci Atmega168, pe baza căruia este asamblat modulul Arduino, are un UART, o unitate încorporată pentru comunicarea cu alte dispozitive folosind schimbul de date în serie. De exemplu, cu un computer printr-un port COM. Sau cu un alt microcontroler folosind blocul său UART încorporat. Există și un convertor analog-digital. Și un model de modulare a lățimii pulsului.
Utilizarea acestuia din urmă este ilustrată de un program pe care îl voi copia și de pe site-ul RoboCraft. Dar programul poate fi preluat și din aplicație. Și poate că este în exemplele programului Arduino.
// Fading LED by BARRAGAN
valoare int = 0; // variabilă pentru a stoca valoarea dorită
int ledpin = 9; // LED-ul conectat la pinul digital 9
// Nu este nevoie să apelați funcția pinMode
pentru(valoare = 0; valoare<= 255; value+=5) // постепенно зажигаем светодиод
analogWrite(ledpin, valoare); // valoare de ieșire (de la 0 la 255)
întârziere (30); // aștept 🙂
pentru(valoare = 255; valoare >=0; valoare-=5) // stinge treptat LED-ul
analogWrite(ledpin, valoare);
Dacă în programul anterior funcția digitalRead(inPin), citirea intrării digitale, era nouă pentru noi, atunci în acest program funcția analogWrite(ledpin, value) este nouă pentru noi, deși parametrii acestei funcții sunt variabile deja familiare nouă. . Vom vorbi despre utilizarea intrării analogice, folosind un ADC (convertor analog-digital), mai târziu. Acum să revenim la problemele generale de programare.
Programarea este ceva ce poate face toată lumea, dar va fi nevoie de timp pentru a stăpâni atât programarea, cât și orice limbaj de programare. Astăzi există o serie de programe care vă ajută să stăpâniți programarea. Și unul dintre ele este direct legat de modulul Arduino. Se numește Scratch pentru Arduino sau S4A pe scurt. Puteți găsi și descărca acest program de la: http://seaside.citilab.eu/scratch/arduino. Nu știu exact cum este tradus numele programului, dar „a începe de la zero” este tradus ca „începe de la zero”.
Site-ul web al proiectului S4A are versiuni pentru Windows și Linux, dar pentru sistemul de operare din urmă programul este gata de instalat în versiunea de distribuție Debian. Nu vreau să spun că nu poate fi folosit cu alte distribuții Linux, dar mai întâi vom vedea cum să lucrăm cu modulul Arduino în Windows.
După instalarea programului în mod obișnuit, puteți configura interfața în limba rusă folosind comutatorul de limbă.
Orez. 4.2. Comutator de limbă a interfeței programului
Prima pictogramă din bara de instrumente, când este făcută clic, afișează toate limbile posibile ale interfeței programului. Limba rusa poate fi gasita in sectiunea...
Orez. 4.3. Lista limbilor de utilizat în interfața programului
... marcat ca „mai mult...”.
Dacă nu faceți nimic, rămâne inscripția din fereastra din dreapta „Tabla de căutare...”, dar modulul nu este găsit. Pentru a conecta modulul Arduino la programul S4A, trebuie să descărcați altceva de pe site-ul proiectului.
Orez. 4.4. Fișier de încărcat în modulul Arduino pentru S4A
Acest fișier nu este altceva decât un program pentru Arduino (Sketch). Adică, un fișier text care poate fi copiat în editorul Arduino, compilat și încărcat în modul. După ce părăsiți programul Arduino, puteți rula programul S4A și modulul este acum localizat.
Orez. 4.5. Conectarea modulului la program
Intrările analogice ale modulului nu sunt conectate, nici intrările digitale, astfel încât valorile afișate pentru modul se schimbă constant în mod aleatoriu.
După ce te-ai familiarizat cu elementele de bază ale Arduino, precum și după ce ai scris un program „Hello World!”. Este timpul să vă familiarizați cu un limbaj de programare.
Structura limbajului se bazează în primul rând pe C/C++, astfel încât cei care au programat anterior în acest limbaj nu vor avea dificultăți să stăpânească programarea Arduino. Alții ar trebui să învețe informații de bază despre comenzile de control, tipurile de date și funcții.
O mare parte din informațiile conținute aici vor fi compatibile cu orice curs C/C++, ținând cont de diferențele dintre tipurile de date, precum și de câteva instrucțiuni specifice privind programarea portului I/O.
Bazele
Câteva lucruri formale, adică cele despre care toată lumea le știe, dar uneori uită...
În Arduino IDE, ca și în C/C++, trebuie să fii conștient de cazurile de caractere. Cuvintele cheie precum if, for sunt întotdeauna scrise cu litere mici. Fiecare instrucțiune se termină cu „;”. Punctul și virgulă îi spune compilatorului care parte să interpreteze ca instrucțiune.
Parantezele (..) sunt folosite pentru a desemna blocuri de program. Le folosim pentru a constrânge corpuri de funcții (vezi mai jos), bucle și instrucțiuni condiționale.
Este o bună practică să adăugați comentarii la conținutul programului, acest lucru face codul ușor de înțeles. Comentariile pe o singură linie încep cu // (bară oblică dublă). Comentariile pe mai multe linii încep cu /* si se termina cu */
Dacă vrem să includem orice bibliotecă în programul nostru, folosim comanda include. Iată exemple de conectare a bibliotecilor:
#include
Funcții în Arduino
O funcție (subrutină) este o parte separată a unui program care efectuează anumite operații. Funcțiile sunt folosite pentru a simplifica programul principal și pentru a îmbunătăți lizibilitatea codului. Este util să folosim funcții, deoarece le putem folosi cu ușurință în multe dintre proiectele noastre.
Un curs standard de programare conține informații despre funcții care vor fi prezentate în articolele următoare. In cazul Arduino, functiile vor fi discutate la inceput deoarece chiar si cel mai simplu program trebuie sa aiba doua functii speciale. Acest lucru a fost deja menționat în articolele anterioare, dar aici sistematizăm aceste informații.
Declarație de funcție
Diagrama de declarare a funcției arată astfel:
Tastați nume_funcție(parametru) ( // instrucțiuni pentru execuție (corpul funcției) return (/* return value*/); )
tip este numele oricărui tip de date disponibil într-un anumit limbaj de programare. Vom furniza o listă de tipuri disponibile la programarea Arduino într-un articol separat.
După execuție, funcția va returna valoarea tipului declarat. Dacă funcția nu acceptă nicio valoare returnată, atunci tipul de date va fi „void”.
nume_funcție permite identificarea acestuia în mod unic. Pentru a apela (a rula) o funcție, îi dăm un nume.
parametru— parametru de apel de funcție. Parametrii nu sunt necesari, dar sunt adesea utili. Dacă scriem o funcție care nu are argumente, lăsăm parantezele goale.
În paranteze „(…)” se află corpul real al funcției sau instrucțiunii pe care dorim să o executăm. Vom oferi o descriere a instrucțiunilor specifice într-un articol separat.
Toate funcțiile care returnează o valoare se termină cu o instrucțiune return urmată de valoarea returnată. Numai funcțiile declarate cu un pointer nul ("void") nu conțin o instrucțiune return. Trebuie să știți că instrucțiunea return termină funcția, indiferent de locație.
Mai jos sunt câteva exemple de declarații de funcție.
Void f1() ( //corpul funcției) —————————————— int minus() ( //corpul funcției returnare (0); ) ———————————— ——— int plus(int a, int b) ( return (a+b); )
După cum puteți vedea din exemple, o declarație de funcție poate lua mai multe forme, în funcție de nevoile dvs.
Vă încurajăm cu tărie să învățați și să utilizați funcțiile atunci când scrieți propriile programe. De-a lungul timpului, fiecare programator acumulează propria bibliotecă de funcții „pentru toate ocaziile”, ceea ce face mai ușor și mai rapid să scrieți programe noi.
Acum că știm cum să scriem propria noastră funcție, trebuie să învățăm cum să o folosim.
Apelarea unei funcții
Scriem toate funcțiile într-un singur fișier/program. Există, desigur, o soluție mai elegantă, dar vom încerca să o descriem data viitoare.
Odată ce declarăm o funcție, o putem folosi în alte funcții cu numele corespunzător și orice parametri necesari. Mai jos sunt exemple de apelare a funcțiilor pe care le-am dat mai sus:
F1(); plus(2,2); y=plus(1,5);
După cum puteți vedea în exemple, un apel de funcție se face prin specificarea numelui și a numărului necesar de parametri. Este important să apelați întotdeauna o funcție așa cum este declarată.
Dacă funcția f1() este declarată fără parametri, atunci nu se poate specifica niciun parametri la apelarea acesteia, adică. apelarea f1(0) va fi incorectă.
Funcția plus(int a, int b) necesită exact doi parametri, deci nu este posibilă apelarea cu unul sau trei parametri.
Apelarea y=plus(1,5) va executa funcția „plus” cu parametrii „1” și „5” și va stoca valoarea returnată în variabila „y”.
funcțiile setup() și loop().
Cu cunoștințe despre declararea și apelarea funcției, putem trece la funcțiile sistemului Arduino: înființat()Și buclă(). Arduino IDE este necesar pentru a declara aceste două funcții.
setup() este o funcție care este apelată automat atunci când alimentarea este pornită sau este apăsat butonul RESET.
După cum sugerează și numele, este folosit pentru a seta valorile inițiale ale variabilelor, declarațiile de intrări și ieșiri ale sistemului, care sunt de obicei specificate în parametrii inițiali. Datorită specificității sale, această funcție nu returnează o valoare și nu este apelată cu parametri. Declarația corectă a funcției setup() este mai jos:
Void setup () ( // corpul funcției - inițializarea sistemului)
loop() este o funcție care este apelată într-o buclă infinită. De asemenea, această funcție nu returnează o valoare și nu este apelată cu parametri. Declarația corectă a funcției loop() este prezentată mai jos:
Buclă goală () ( // corpul funcției - codul programului )
După cum puteți vedea, declarația funcției loop() este identică cu declarația funcției setup(). Diferența constă în performanța acestor funcții de către microcontroler.
Vom analiza acum următorul pseudocod:
Void setup () ( on_led1 (); //porniți led1 off_led1 (); //opriți led1) void loop () ( on_led2 (); //porniți led2 off_led2 (); //opriți led2)
Există două instrucțiuni în funcția setup(): prima aprinde led1 conectat la placă (de exemplu pin 13) și a doua stinge led1.
Funcția loop() are instrucțiuni identice pentru a porni și opri LED-ul2 conectat la placă (de exemplu, pinul 12).
Ca urmare a rulării programului, led1 va clipi o dată, în timp ce led2 se va aprinde și se va stinge atâta timp cât Arduino este pornit.
Apăsarea butonului RESET va face ca ledul 1 să clipească din nou și ledul 2 să clipească din nou continuu.
Rezuma:
- Funcțiile setup() și loop() sunt funcții de sistem care trebuie definite în fiecare proiect. Chiar și în situația în care nu scriem niciun cod într-una dintre ele, trebuie totuși să declarăm aceste două funcții;
- Funcția setup() este executată o dată, loop() este executată continuu;
- Ne creăm propriile funcții într-un singur fișier;
- Putem apela funcțiile noastre atât din setup() și loop(), cât și din alte funcții;
- Funcțiile noastre proprii pot fi apelate cu parametri și returnează o valoare;
- Un apel de funcție trebuie efectuat în conformitate cu declarația sa.
Vei avea nevoie
- - Placa Arduino UNO,
- - Cablu USB (USB A - USB B),
- - Calculator personal,
- - Dioda electro luminiscenta,
- - rezistenta 220 Ohm,
- - o pereche de fire de 5-10 cm,
- - dacă este disponibil - panou.
Instrucțiuni
Descărcați mediul de dezvoltare Arduino pentru sistemul dvs. de operare (sunt acceptate Windows, Mac OS X, Linux) de pe pagina http://arduino.cc/en/Main/Software, îl puteți instala, puteți. Fișierul descărcat conține și drivere pentru plăcile Arduino.
Instalați driverul. Luați în considerare opțiunea pentru sistemul de operare Windows. Pentru a face acest lucru, așteptați până când sistemul de operare vă solicită să instalați driverul. Declin. Apăsați Win + Pauză, lansați Device Manager. Găsiți secțiunea „Porturi (COM și LPT)”. Veți vedea acolo un port numit „Arduino UNO (COMxx)”. Faceți clic dreapta pe el și selectați „Actualizați driverul”. Apoi, selectați locația driverului pe care tocmai l-ați descărcat.
Mediul de dezvoltare conține deja multe exemple pentru studierea funcționării plăcii. Deschideți exemplul „Blink”: File > Examples > 01.Basics > Blink.
Îndreptați mediul de dezvoltare către placa dvs. Pentru a face acest lucru, în meniul Instrumente > Placă, selectați „Arduino UNO”.
Selectați portul căruia este alocată placa Arduino. Pentru a afla la ce port este conectată placa, lansați Device Manager și căutați secțiunea Porturi (COM și LPT). Portul va fi indicat în paranteze după numele tablei. Dacă placa nu este în listă, încercați-o de pe computer și așteptați câteva secunde, încercați din nou.
Deconectați placa de la computer. Asamblați circuitul așa cum se arată în figură. Vă rugăm să rețineți că piciorul scurt al LED-ului trebuie să fie conectat la pinul GND, piciorul lung printr-un rezistor la pinul digital 13 al plăcii Arduino. Este mai convenabil să utilizați o placă, dar dacă nu este disponibilă, puteți conecta firele prin răsucire.
Notă importantă! Pinul digital 13 are deja propriul rezistor pe placă. Prin urmare, atunci când conectați un LED la placă, nu este necesar să utilizați un rezistor extern. Când conectați un LED la orice alți pini Arduino, utilizarea este obligatorie!
Acum puteți încărca programul în memoria plăcii. Conectați placa la computer, așteptați câteva secunde până când placa se inițializează. Faceți clic pe butonul „Încărcare” și al dumneavoastră va fi scris în memoria plăcii Arduino. Programarea cu Arduino este foarte intuitivă și deloc dificilă. Uită-te la imagine - există mici explicații în comentariile programului. Acest lucru este suficient pentru a vă face să începeți primul experiment.
Video pe tema
Notă
Aveți grijă când lucrați cu placa Arduino - acesta este un produs electronic care necesită o manipulare atentă. Există conductori expuși pe partea de jos a plăcii, iar dacă așezați placa pe o suprafață conductoare, există șansa de a arde placa. De asemenea, nu atingeți placa cu mâinile umede sau ude și evitați zonele umede atunci când lucrați.
Sfaturi utile
Există multe site-uri pe Internet dedicate Arduino. Citește, stăpâne, nu-ți fie frică să experimentezi și să înveți lucruri noi!
Surse:
- LED intermitent
Programarea atrage și interesează mulți oameni moderni, în special profesioniști tineri și începători, care abia încep să aleagă o viitoare profesie. Ei se confruntă adesea cu întrebarea - de unde să înceapă în învățarea programarii? Dacă decideți să învățați cum să programați, nu ar trebui să faceți o greșeală comună - nu vă ocupați imediat de sisteme și limbaje complexe (de exemplu, C). A începe cu un limbaj prea complex vă poate oferi o impresie greșită despre programare în general. Începătorilor li se recomandă să lucreze cu cele mai simple sisteme - de exemplu, să învețe să scrie programe în BASIC. Învățarea acestei limbi vă va permite să obțineți rezultate bune într-un timp scurt. PureBasic este ușor de învățat - acest limbaj versatil, puternic compilat, vă va ajuta să înțelegeți elementele de bază ale programării și să vă îmbunătățiți abilitățile în viitor.
Instrucțiuni
Vă poate dura aproximativ un an pentru a învăța elementele de bază ale programării. Veți învăța caracteristicile programării procedurale și orientate pe obiecte, principiile de lucru cu arbori binari, matrice, liste etc. Abia după ce a învățat elementele de bază, treceți la sarcini mai complexe.
Vizitați site-urile web ale dezvoltatorilor de limbaje de programare și studiați documentația. Asigurați-vă că comunicați pe forumurile pentru programatori; de obicei, aceștia răspund la majoritatea întrebărilor de la începători.
Matematică
Dacă vrei să înveți să programezi, trebuie doar să știi matematică. În procesul de lucru, veți întâlni un număr mare de probleme care nu pot fi rezolvate fără cunoașterea elementelor de bază ale acestei științe. Există un număr mare de sisteme și teorii matematice (seria Fourier, numere Fibonacci etc.) care simplifică foarte mult procesul de programare.Învățarea nu se termină niciodată
Evoluția limbajelor de programare nu stă pe loc; dezvoltarea lor este în desfășurare. Încercați să citiți cât mai multă literatură legată de domeniul de programare în care intenționați să lucrați. Căutați întotdeauna modalități alternative de a rezolva problemele care apar, acest lucru vă va ajuta să îmbunătățiți constant eficiența codului pe care îl creați. Discutați cu programatori profesioniști; aceștia vor putea întotdeauna să vă sfătuiască cum să rezolvați o anumită problemă. Citirea codurilor lor vă va ajuta foarte mult.Este imposibil să păstrezi totul în minte tot timpul. Simțiți-vă liber să utilizați cărțile de referință în limbajul de programare.
Problemele de programare, oricât de simple ar fi, nu sunt niciodată rezolvate deodată. Ele necesită întotdeauna dezvoltarea algoritmului corect de acțiuni care este eficient într-o anumită situație specifică. Găsirea algoritmilor optimi necesită practică și antrenament constant. Încercați să rezolvați mai des micile probleme de programare (le puteți găsi pe site-uri specializate), acest lucru vă va ajuta să vă perfecționați treptat abilitățile în acest domeniu.
Buna ziua! Sunt Alikin Alexander Sergeevich, profesor de educație suplimentară, conduc cluburile „Robotică” și „Inginerie radio” la Centrul pentru Tehnologia Tineretului și Tineretului din Labinsk. Aș dori să vorbesc puțin despre o metodă simplificată de programare a Arduino folosind programul ArduBlock.
Am introdus acest program în procesul educațional și sunt încântat de rezultat, este foarte solicitat în rândul copiilor, mai ales la scrierea unor programe simple sau pentru realizarea unei etape inițiale a unor programe complexe. ArduBlock este un mediu de programare grafic, adică toate acțiunile sunt efectuate cu imagini desenate cu acțiuni semnate în limba rusă, ceea ce simplifică foarte mult învățarea platformei Arduino. Copiii din clasa a II-a pot stăpâni cu ușurință lucrul cu Arduino datorită acestui program.
Da, cineva ar putea spune că Scratch încă există și este, de asemenea, un mediu grafic foarte simplu pentru programarea Arduino. Dar Scratch nu flashează Arduino, ci îl controlează doar printr-un cablu USB. Arduino este dependent de computer și nu poate funcționa autonom. Atunci când creați propriile proiecte, autonomia este principalul lucru pentru Arduino, mai ales atunci când creați dispozitive robotizate.
Chiar și roboții LEGO cunoscuți, precum NXT sau EV3, nu mai sunt atât de interesanți pentru studenții noștri odată cu apariția programului ArduBlock în programarea Arduino. Arduino este, de asemenea, mult mai ieftin decât orice trusă de construcție LEGO și multe componente pot fi pur și simplu luate din electronicele de uz casnic vechi. Programul ArduBlock va ajuta nu numai începătorii, ci și utilizatorii activi ai platformei Arduino.
Deci, ce este ArduBlock? După cum am spus deja, acesta este un mediu de programare grafică. Aproape complet tradus în rusă. Dar punctul culminant al ArduBlock nu este doar acesta, ci și faptul că programul ArduBlock pe care l-am scris se convertește în codul IDE Arduino. Acest program este integrat în mediul de programare Arduino IDE, adică este un plugin.
Mai jos este un exemplu de LED care clipește și un program convertit în Arduino IDE. Toate lucrările cu programul sunt foarte simple și orice student o poate înțelege.
Ca urmare a lucrului cu programul, puteți nu numai să programați Arduino, ci și să studiați comenzi pe care nu le înțelegem în formatul text al IDE-ului Arduino, dar dacă vă este prea lene să scrieți comenzi standard, puteți utiliza rapid mouse-ul pentru a schița un program simplu în ArduBlok și a-l depana în Arduino IDE.
Pentru a instala ArduBlok, trebuie mai întâi să descărcați și să instalați Arduino IDE de pe site-ul oficial Arduino și să înțelegeți setările atunci când lucrați cu placa Arduino UNO. Cum să faceți acest lucru este descris pe același site web sau pe Amperka, sau vizionați-l pe YouTube. Ei bine, când toate acestea sunt descoperite, trebuie să descărcați ArduBlok de pe site-ul oficial, aici. Nu recomand să descărcați cele mai recente versiuni, sunt foarte complicate pentru începători, dar versiunea din 2013-07-12 este cea mai bună, acest fișier este cel mai popular acolo.
Apoi, redenumiți fișierul descărcat în ardublock-all și în folderul „documente”. Creăm următoarele foldere: Arduino > instrumente > ArduBlockTool > instrument și în acesta din urmă aruncăm fișierul descărcat și redenumit. ArduBlok funcționează pe toate sistemele de operare, chiar și pe Linux, eu personal l-am testat pe XP, Win7, Win8, toate exemplele sunt pentru Win7. Instalarea programului este aceeași pentru toate sistemele.
Ei bine, ca să spun simplu, am pregătit o arhivă pe discul 7z Mail, despachetând care vei găsi 2 foldere. Într-unul există deja un program Arduino IDE funcțional, iar în celălalt folder conținutul trebuie trimis în folderul documente.
Pentru a funcționa în ArduBlok, trebuie să rulați IDE-ul Arduino. Apoi mergem la fila Instrumente și acolo găsim articolul ArduBlok, facem clic pe el - și iată-l, scopul nostru.
Acum să ne uităm la interfața programului. După cum înțelegeți deja, nu există setări în el, dar există o mulțime de pictograme pentru programare și fiecare dintre ele poartă o comandă în format text Arduino IDE. Noile versiuni au și mai multe pictograme, așa că înțelegerea celei mai recente versiuni de ArduBlok este dificilă și unele dintre pictograme nu sunt traduse în rusă.
În secțiunea „Management” vom găsi o varietate de cicluri.
În secțiunea „Porturi”, putem gestiona valorile porturilor, precum și emițătorul de sunet, servo sau senzorul de proximitate ultrasonic conectat la acestea.
În secțiunea „Numere/Constante”, putem selecta valori digitale sau crea o variabilă, dar este puțin probabil să utilizați ceea ce este mai jos.
În secțiunea „Operatori” vom găsi toți operatorii de comparare și calcul necesari.
Secțiunea Utilități folosește în principal pictograme cronometrate.
„TinkerKit Bloks” este secțiunea pentru senzorii TinkerKit achiziționați. Noi, desigur, nu avem un astfel de set, dar asta nu înseamnă că pictogramele nu sunt potrivite pentru alte seturi, dimpotrivă, este foarte convenabil ca băieții să folosească pictograme precum aprinderea unui LED sau a unui buton. Aceste semne sunt folosite în aproape toate programele. Dar au o particularitate - atunci când le selectați, există pictograme incorecte care indică porturi, așa că trebuie să le eliminați și să înlocuiți pictograma din secțiunea „numere/constante” din partea de sus a listei.
„Robot DF” - această secțiune este utilizată dacă senzorii specificați în ea sunt prezenți, uneori sunt găsiți. Iar exemplul nostru de astăzi nu face excepție, avem un „Comutator IR reglabil” și un „Senzor de linie”. „Senzorul de linie” este diferit de cel din imagine, deoarece este de la compania Amperka. Acțiunile lor sunt identice, dar senzorul Ampere este mult mai bun, deoarece are un regulator de sensibilitate.
„Seedstudio Grove” - Nu am folosit niciodată senzorii din această secțiune, deși există doar joystick-uri. În versiunile noi, această secțiune a fost extinsă.
Și ultima secțiune este „Kitul de linkuri”. Nu am dat peste senzorii prezentați în ea.
Aș dori să arăt un exemplu de program pe un robot care se mișcă de-a lungul unei benzi. Robotul este foarte simplu, atât de asamblat, cât și de achiziționat, dar pe primul loc. Să începem cu achiziția și asamblarea acestuia.
Iată setul de piese în sine, totul a fost achiziționat pe site-ul Amperka.
- AMP-B001 Scut motor (2 canale, 2 A) 1.890 RUB
- AMP-B017 Troyka Shield 1.690 RUB
- AMP-X053 Compartiment baterie 3×2 AA 1 60 RUR
- AMP-B018 Senzor digital de linie 2.580 RUB
- ROB0049 Platformă MiniQ cu două roți 1.1890 RUB
- SEN0019 Senzor de obstacol cu infraroșu 1.390 RUB
- FIT0032 Suport pentru senzor infraroșu obstacol RUB 1,90
- A000066 Arduino Uno 1 1150 RUR
Mai întâi, să asamblam platforma cu roți și să lipim firele la motoare.
Apoi vom instala rack-uri pentru a monta placa Arduino UNO, care au fost luate de pe o placa de baza veche sau alte suporturi similare.
Apoi atașăm placa Arduino UNO la aceste rafturi, dar nu putem fixa un șurub - conectorii sunt în cale. Puteți, desigur, să le dezlipiți, dar acest lucru este la discreția dvs.
Apoi atașăm senzorul de obstacol în infraroșu la suportul său special. Vă rugăm să rețineți că regulatorul de sensibilitate este situat în partea de sus, acesta este pentru ușurință de reglare.
Acum instalăm senzori digitali de linie, aici va trebui să căutați câteva șuruburi și 4 piulițe pentru ei. Instalăm două piulițe între platformă în sine și senzorul de linie și fixăm senzorii cu restul.
Apoi instalăm Motor Shield, sau altfel îl puteți numi driverul motorului. În cazul nostru, acordați atenție jumperului. Nu vom folosi o sursă de alimentare separată pentru motoare, așa că este instalată în această poziție. Partea inferioară este sigilată cu bandă electrică pentru a preveni scurtcircuite accidentale de la conectorul USB Arduino UNO, pentru orice eventualitate.
Instalăm Troyka Shield deasupra motorului Shield. Este necesar pentru confortul conectării senzorilor. Toți senzorii pe care îi folosim sunt digitali, astfel încât senzorii de linie sunt conectați la porturile 8 și 9, deoarece sunt numiți și pini, iar senzorul de obstacol în infraroșu este conectat la portul 12. Asigurați-vă că rețineți că nu puteți utiliza porturile 4, 5, 6, 7 deoarece sunt folosite de Motor Shield pentru a controla motoarele. Chiar am pictat special peste aceste porturi cu un marker roșu, astfel încât elevii să-și poată da seama.
Dacă ați observat deja, am adăugat o bucșă neagră, pentru orice eventualitate, pentru ca compartimentul bateriei pe care l-am instalat să nu zboare. Și, în sfârșit, asigurăm întreaga structură cu o bandă elastică obișnuită.
Există 2 tipuri de conexiuni la compartimentul bateriei. Prima conexiune a firelor la Troyka Shield. De asemenea, este posibil să lipiți ștecherul de alimentare și să îl conectați la placa Arduino UNO în sine.
Robotul nostru este gata. Înainte de a începe programarea, va trebui să învățați cum funcționează totul, și anume:
- Motoare:
Porturile 4 și 5 sunt folosite pentru a controla un motor, iar 6 și 7 pe celălalt;
Reglăm viteza de rotație a motoarelor folosind PWM pe porturile 5 și 6;
Înainte sau înapoi, trimițând semnale către porturile 4 și 7.
- Senzori:
Toți suntem digitali, așa că dau semnale logice sub formă de 1 sau 0;
Iar pentru a le regla, au regulatoare speciale, iar cu ajutorul unei surubelnite potrivite pot fi calibrate.
Detalii pot fi găsite la Amperke. De ce aici? Pentru că există o mulțime de informații despre lucrul cu Arduino.
Ei bine, probabil că am privit totul superficial, l-am studiat și, bineînțeles, am asamblat robotul. Acum trebuie programat, iată-l - programul mult așteptat!
Și programul a fost convertit în Arduino IDE:
Void setup() (pinMode(8, INPUT); pinMode(12, INPUT); pinMode(9, INPUT); pinMode(4, OUTPUT); pinMode(7, OUTPUT); pinMode(5, OUTPUT); pinMode(6) , OUTPUT); ) void loop() ( if (digitalRead(12)) ( if (digitalRead(8)) ( if (digitalRead(9)) ( digitalWrite(4 , HIGH); analogWrite(5, 255); analogWrite( 6, 255); digitalWrite(7, HIGH); ) else ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite(6, 50); digitalWrite(7, LOW); ) ) else ( if (digitalRead) (9)) ( digitalWrite(4, LOW); analogWrite(5, 50); analogWrite(6, 255); digitalWrite(7, HIGH); ) else ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7 , HIGH); ) ) ) else ( digitalWrite(4 , HIGH); analogWrite(5, 0); analogWrite(6, 0); digitalWrite(7 , HIGH); ) )
În concluzie, vreau să spun că acest program este pur și simplu o mană cerească pentru educație; chiar și pentru auto-studiu, vă va ajuta să învățați comenzile Arduino IDE. Principalul punct culminant este faptul că există mai mult de 50 de pictograme de instalare, începe să „se defecteze”. Da, într-adevăr, acesta este punctul culminant, deoarece programarea numai pe ArduBlok tot timpul nu vă va învăța să programați în Arduino IDE. Așa-numitul „glitch” vă oferă posibilitatea de a gândi și de a încerca să vă amintiți comenzile pentru depanarea precisă a programelor.
Vă doresc succes.
