Program pentru scrierea schițelor Arduino. Arduino: exemple de ceea ce se poate face

O zi bună, Habr. Lansez o serie de articole care vă vor ajuta să vă familiarizați cu Arduino. Dar asta nu înseamnă că, dacă nu ești nou în această afacere, nu vei găsi nimic interesant pentru tine.

Introducere

Ar fi o idee bună să începeți prin a vă familiariza cu Arduino. Arduino – hardware și software pentru automatizarea clădirilor și sisteme robotice. Principalul avantaj este că platforma este destinată utilizatorilor neprofesioniști. Adică, oricine își poate crea propriul robot, indiferent de cunoștințele de programare și de propriile abilități.

start

Crearea unui proiect pe Arduino constă din 3 etape principale: scrierea codului, prototiparea (breadboarding) și firmware-ul. Pentru a scrie cod și apoi a flash-a placa, avem nevoie de un mediu de dezvoltare. De fapt, există destul de multe dintre ele, dar vom programa în mediul original - Arduino IDE. Vom scrie codul în sine în C++, adaptat pentru Arduino. Îl puteți descărca de pe site-ul oficial. O schiță este un program scris pe Arduino. Să ne uităm la structura codului:

main())( void setup())( ) void loop())( ) )

Este important de reținut că procesorul Arduino creează funcția main(), care este necesară în C++. Și rezultatul a ceea ce vede programatorul este:

void setup() ( ) void loop() ( )

Să ne uităm la cele două funcții necesare. Funcția setup() este apelată o singură dată când pornește microcontrolerul. Ea este cea care stabilește toate setările de bază. Funcția loop() este ciclică. Este numit într-o buclă nesfârșită pe toată durata de funcționare a microcontrolerului.

Primul program

Pentru a înțelege mai bine principiul de funcționare al platformei, să scriem primul program. Vom executa acest program cel mai simplu (Blink) în două versiuni. Singura diferență dintre ele este asamblarea.

int Led = 13; // declară variabila Led pe pinul 13 (ieșire) void setup() ( pinMode(Led, OUTPUT); // definește variabila ) void loop() ( digitalWrite(Led, HIGH); // aplică tensiune la întârzierea pinului 13 (1000); // așteptați 1 secundă digitalWrite (Led, LOW); // nu aplicați tensiune la pinul 13 întârziere (1000); // așteptați 1 secundă)

Principiul de funcționare al acestui program este destul de simplu: LED-ul se aprinde timp de 1 secundă și se stinge timp de 1 secundă. Pentru prima opțiune, nu trebuie să asamblam un aspect. Deoarece platforma Arduino are un LED încorporat conectat la pinul 13.

Firmware-ul Arduino

Pentru a încărca o schiță în Arduino, trebuie mai întâi să o salvăm pur și simplu. Apoi, pentru a evita problemele la încărcare, trebuie să verificați setările programatorului. Pentru a face acest lucru, selectați fila „Instrumente” din panoul de sus. În secțiunea „Plată”, selectați plata. Ar putea fi Arduino Uno, Arduino Nano, Arduino Mega, Arduino Leonardo sau altele. Tot în secțiunea „Port” trebuie să selectați portul de conectare (portul la care v-ați conectat platforma). După acești pași, puteți încărca schița. Pentru a face acest lucru, faceți clic pe săgeată sau selectați „Descărcare” în fila „Schiță” (puteți folosi și comanda rapidă de la tastatură „Ctrl + U”). Firmware-ul plăcii a fost finalizat cu succes.

Prototiparea/aspectarea

Pentru a asambla placa de breadboard, avem nevoie de următoarele elemente: LED, rezistor, cablare (jumpers), placa de breadboard. Pentru a nu arde nimic și pentru ca totul să funcționeze cu succes, trebuie să te ocupi de LED-ul. Are două „picioare”. Scurt este un minus, lung este un plus. Vom conecta masa (GND) si un rezistor la cel scurt (pentru a reduce curentul furnizat LED-ului pentru a nu-l arde), iar celui lung il vom alimenta (conectare la pinul 13). După conectare, încărcați schița pe tablă dacă nu ați făcut acest lucru anterior. Codul rămâne același.

Acesta este sfârșitul primei părți. Vă mulțumim pentru atenție.

În viața unui dezvoltator Arduino, mai devreme sau mai târziu vine un moment în care mediul de dezvoltare standard devine aglomerat. Dacă schițele nu mai au suficientă memorie, aveți nevoie de timp real și lucrați cu întreruperi, sau doriți doar să fiți mai aproape de hardware, atunci este timpul să treceți la C. Inginerii electronici cu experiență se vor încruntă disprețuitor la mențiunea Arduino și vor trimite începătorul la un magazin de radio pentru un fier de lipit. Poate că acesta nu este cel mai rău sfat, dar nu îl vom urma încă. Dacă aruncăm Arduino IDE și limbajul de cablare/procesare, rămânem cu o placă de depanare excelentă, dotată deja cu tot ce este necesar pentru funcționarea microcontrolerului. Și, important, un bootloader este deja conectat în memoria controlerului, permițându-vă să încărcați firmware-ul fără a utiliza un programator.

Pentru a programa în C, avem nevoie de AVR GCC Toolchain.

Vom avea nevoie și de Arduino IDE instalat, deoarece... conține utilitarul avrdude, care este necesar pentru a descărca firmware-ul pe controler. CrossPack conține și avrdude, dar versiunea care vine cu el nu funcționează cu Arduino.

După ce totul este instalat, să creăm primul nostru proiect. Pentru început, să scriem Makefile. Ne va permite să evităm introducerea manuală a comenzilor lungi de fiecare dată când compilam și încărcăm firmware-ul.

#Controller instalat pe placă. Poate fi diferit, de exemplu atmega328 DEVICE = atmega168 #Clock frequency 16 MHz CLOCK = 16000000 #Avrdude launch command. Trebuie copiat din IDE-ul Arduino. AVRDUDE = /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBIECTE = main.o COMPILARE = ​​avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DEVICE) all: main .hex .c.o: $(COMPILARE) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf

În acest fișier trebuie să introducem comanda noastră pentru a lansa avrdude. Va arăta diferit pe sisteme diferite. Pentru a afla opțiunea dvs., lansați IDE-ul Arduino și bifați caseta „Afișați ieșirea detaliate în timpul încărcării” din setări.

Acum încărcăm orice schiță în Arduino și ne uităm la mesajele afișate în partea de jos a ferestrei. Găsim apelul avrdude acolo, copiem totul, cu excepția parametrului -Uflash și îl lipim în Makefile după „AVRDUDE =”.

O notă rapidă: toată indentarea din Makefile se face cu caractere tabulatoare (tasta Tab). Dacă editorul dvs. de text înlocuiește aceste caractere cu spații, comanda make va refuza construirea proiectului.

Acum să creăm un fișier principal.c- textul propriu-zis al programului nostru, în care în mod tradițional clipim LED-ul.

#include #include #define LED_PIN 5 int main() ( DDRB |= 1<< LED_PIN; while(1) { PORTB |= 1 << LED_PIN; _delay_ms(1000); PORTB &= ~(1 << LED_PIN); _delay_ms(1000); } return 0; }

Proiectul nostru este gata. Să deschidem consola în directorul nostru de proiect și să introducem comanda „make”:

După cum puteți vedea, dimensiunea firmware-ului rezultat este de numai 180 de octeți. O schiță similară Arduino ocupă 1116 octeți în memoria controlerului.

Acum să ne întoarcem la consolă și să introducem „make flash” pentru a încărca fișierul compilat în controler:

Dacă descărcarea a fost finalizată fără erori, LED-ul conectat la pinul 13 al plăcii va clipi fericit. Uneori, avrdude nu poate găsi placa sau cade din cauza unui timeout - în acest caz, răsucirea cablului USB poate ajuta. De asemenea, pentru a evita conflictele de acces la placă, nu uitați să închideți IDE-ul Arduino înainte de comanda „make flash”.

Poate că multe dintre lucrurile descrise în acest articol vor părea evidente pentru dezvoltatorii experimentați. Am încercat să descriu procesul într-un limbaj cât mai ușor de înțeles pentru un utilizator Arduino începător și să adun într-un singur loc informațiile pe care le-am putut obține din diverse surse și le-am verificat empiric. Poate că acest articol va economisi cuiva câteva ore de timp.

Succes în stăpânirea microcontrolerelor!

Arduino este o placă mică care este folosită pentru a crea diverse dispozitive, gadget-uri interesante și chiar platforme de calcul. Această placă se numește microcontroler, care este open source și poate fi folosit cu multe aplicații.

Aceasta este cea mai simplă și mai ieftină opțiune pentru începători, amatori și profesioniști. Procesul de programare se desfășoară în limbajul Processing/Wiring, care se învață rapid și ușor și se bazează pe limbajul C++, iar datorită acestuia este foarte ușor de realizat. Să ne uităm la ce este Arduino, cum este util pentru începători, capacitățile și caracteristicile sale.

Arduino este o platformă sau o placă de calcul care va servi drept creier pentru noile dvs. dispozitive sau gadgeturi. Pe baza acestuia, puteți crea atât dispozitive cu circuite simple, cât și proiecte complexe, care necesită multă muncă, de exemplu, roboți sau drone.

Baza proiectantului este placa de intrare-ieșire (hardware), precum și partea de software. Software-ul de proiectare bazat pe Arduino este reprezentat de un mediu de dezvoltare integrat.

În exterior, mediul în sine arată astfel:

Software-ul Arduino este proiectat în așa fel încât chiar și un utilizator începător, fără cunoștințe de programare, se poate descurca. Un factor suplimentar de succes în utilizarea unui microcontroler a fost capacitatea de a lucra cu o placă de breadboard, atunci când piesele necesare (rezistoare, diode, tranzistoare etc.) sunt conectate la controler fără a fi nevoie de lipire.

Majoritatea plăcilor Arduino sunt conectate printr-un cablu USB. O astfel de conexiune vă permite să furnizați energie plăcii și să încărcați schițe, de exemplu. mini-programe. Procesul de programare este, de asemenea, extrem de simplu. În primul rând, utilizatorul folosește editorul de cod IDE pentru a crea programul necesar, apoi este încărcat cu un singur clic în Arduino.

Cum să cumpăr Arduino?

Placa și multe părți Arduino sunt fabricate Italia, prin urmare, componentele originale sunt destul de scumpe. Dar există componente separate ale designerului sau seturi, așa-numitele truse, care sunt produse după analogia italiană, dar la prețuri mai accesibile.

Puteți cumpăra un analog de pe piața internă sau, de exemplu, îl puteți comanda din China. Mulți oameni știu despre site-ul AliExpress, de exemplu. Dar pentru cei care încep să se cunoască cu Arduino, este mai bine să-și comande prima placă de la un magazin online rus. În timp, puteți trece la cumpărarea de plăci de circuite și piese din China. Termenul de livrare din această țară va fi de la două săptămâni la o lună și, de exemplu, costul unui kit mare nu va mai fi 60-70 de dolari.

Seturile standard includ de obicei următoarele piese:

• tabla de paine;
• LED-uri;
• rezistențe;
• baterii 9V;
• regulatoare de tensiune;
• butoane;
• săritori;
• tastatură matricială;
• plăci de expansiune;
• condensatoare.

Trebuie sa stii programare?

Primii pași în lucrul cu placa Arduino încep cu programarea plăcii. Un program care este deja gata să lucreze cu o placă se numește schiță. Nu este nevoie să vă faceți griji că nu cunoașteți programarea. Procesul de creare a programelor este destul de simplu și există o mulțime de exemple de schițe pe Internet, deoarece comunitatea Arduino este foarte mare.

După ce programul este compilat, acesta este încărcat (flash) pe placă. În acest caz, Arduino are un avantaj incontestabil - în majoritatea cazurilor se folosește un cablu USB pentru programare. Imediat după încărcare, programul este gata să execute diverse comenzi.

Începătorii cu Arduino trebuie să cunoască două funcții cheie:

• înființat()– folosit o dată când placa este pornită, folosit pentru a inițializa setările;
• buclă()– folosit în mod constant, este etapa finală de configurare.

Exemplu de notație a funcției înființat():

Void setup() ( Serial.begin(9600); // Deschide o conexiune serială pinMode(9, INPUT); // Atribui pin 9 ca intrare pinMode (13, OUTPUT); // Atribui pin 13 ca ieșire )

Funcţie înființat() se efectuează chiar de la început și numai 1 dată imediat după pornirea sau repornirea dispozitivului.

Funcţie buclă() executat după funcția setup(). Bucla este tradusă ca buclă sau ciclu. Funcția va fi executată din nou și din nou. Astfel, microcontrolerul ATmega328 (majoritatea plăcilor Arduino conțin acest lucru) va îndeplini funcția de buclă de aproximativ 10.000 de ori pe secundă.

Veți întâlni și caracteristici suplimentare:

• pinMode– modul de intrare și ieșire a informațiilor;
• analogRead– vă permite să citiți tensiunea analogică emergentă la pin;
• analogWrite– înregistrarea tensiunii analogice la pinul de ieșire;
• digitalRead– vă permite să citiți valoarea unei ieșiri digitale;
• digitalWrite– vă permite să setați valoarea ieșirii digitale la un nivel scăzut sau ridicat;
• Serial.print– traduce datele proiectului în text ușor de citit.

În plus, începătorilor Arduino le va plăcea faptul că există multe biblioteci pentru plăci, care sunt colecții de funcții care vă permit să controlați placa sau modulele suplimentare. Cele mai populare includ:

• citirea și scrierea în depozit,
• Conexiune internet,
• citind carduri SD,
• controlul motorului pas cu pas,
• redarea textului
• etc.

Cum se configurează Arduino?

Unul dintre principalele avantaje ale designerului este siguranța acestuia în ceea ce privește setările utilizatorului. Setările cheie care sunt potențial dăunătoare pentru Arduino sunt protejate și nu vor fi accesibile.

Prin urmare, chiar și un programator fără experiență poate experimenta și schimba în siguranță diverse opțiuni pentru a obține rezultatul dorit. Dar pentru orice eventualitate, vă recomandăm să citiți trei materiale importante despre cum să nu deteriorați placa:

Algoritmul clasic de configurare a programului Arduino arată astfel:

• Instalare IDE, care poate fi descărcată mai jos sau de pe site-ul producătorului;
• instalarea software-ului pe computerul pe care îl utilizați;
• lansați fișierul Arduino;
• introducerea programului dezvoltat în fereastra de cod și transferarea acestuia pe placă (folosind un cablu USB);
• în secțiunea IDE trebuie să selectați tipul de constructor care va fi utilizat. Acest lucru se poate face în fereastra „instrumente” - „plăci”;
• verificați codul și faceți clic pe „Următorul”, după care va începe descărcarea în Arduino.

Versiune	Windows	MacOS	Linux
1.6.5	Zip Instalator	Instalator	32 de biți 64 de biți
1.8.2	Zip Instalator	Instalator	32 de biți 64 de biți BRAŢ
1.8.5	Zip Instalator App	Instalator	32 de biți 64 de biți BRAŢ

Să ne antrenăm mâna

Pentru a implementa cu încredere idei complexe, utilizați mediul software și Arduino, începătorii trebuie să pună mâna pe el. Pentru a face acest lucru, se recomandă să stăpâniți mai întâi sarcinile și proiectele mai ușoare.

Cel mai simplu proiect pe care îl puteți face este să faceți ca LED-ul, care este situat pe placa Arduino vizavi de port, să clipească în fiecare secundă.

Pentru a face acest lucru aveți nevoie de:

• conectați designerul la computer,
• deschideți programul, în secțiunea „serviciu” căutăm blocul „port serial”.
• selectați intervalul dorit
• după care trebuie să adăugați codul care se află în Arduino IDE în secțiunea „Exemple”.

Primele proiecte în Arduino pentru începători pot fi:

• LED intermitent;
• conectarea și controlul unui senzor de temperatură;
• conectarea și controlul unui senzor de mișcare;
• conectarea unui fotorezistor;
• control servo drive.

Primul proiect

Acum am ajuns la primul nostru proiect. Să conectăm Arduino, LED-ul și butonul. Acest proiect este perfect pentru începători.

Schema noastră va fi astfel:

LED-ul se va aprinde după apăsarea butonului și se va stinge după următoarea apăsare. Schița sau programul pentru Arduino în sine va fi astfel:

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

Poate ați observat funcția de debounse, despre care nu am scris încă. Este necesar pt.

După ce ați stăpânit abilitățile inițiale de lucru cu o placă, puteți începe să implementați sarcini mai complexe și cu mai multe fațete. Designerul vă permite să creați o mașină RC, un elicopter controlabil, să vă creați propriul telefon, să creați un sistem etc.

Pentru a vă accelera stăpânirea lucrului cu placa Arduino, vă recomandăm să începeți să faceți dispozitive din secțiunea noastră, unde procesele de creare a celor mai interesante dispozitive și gadget-uri sunt descrise pas cu pas.

Această lecție oferă cunoștințele minime necesare pentru a programa sistemele Arduino în C. Puteți să o vizualizați și să le utilizați doar ca informații de referință în viitor. Pentru cei care au programat în C pe alte sisteme, puteți sări peste articol.

Repet că aceasta este o informație minimă. Descrierea indicatorilor, claselor, variabilelor șir etc. va fi dat în lecțiile ulterioare. Dacă ceva nu este clar, nu vă faceți griji. Vor fi multe exemple și explicații în lecțiile viitoare.

Structura programului Arduino.

Structura programului Arduino este destul de simplă și, în forma sa minimă, constă din două părți setup() și loop().

void setup() (

void loop() (

Funcția setup() este executată o dată, când controlerul este pornit sau resetat. De obicei, setările inițiale ale variabilelor și registrelor au loc în acesta. Funcția trebuie să fie prezentă în program, chiar dacă nu există nimic în el.

După finalizarea setup() controlul trece la funcția loop(). Execută comenzile scrise în corpul său (între bretele) într-o buclă nesfârșită. De fapt, aceste comenzi efectuează toate acțiunile algoritmice ale controlerului.

Regulile originale ale sintaxei limbajului C.

; punct şi virgulă Expresiile pot conține cât mai multe spații și întreruperi de rând se dorește. Sfârșitul unei expresii este indicat de simbolul punct și virgulă.

z = x + y;
z=x
+ y;

( ) acolade definiți un bloc de funcții sau expresii. De exemplu, în funcțiile setup() și loop().

/* … */ bloc de comentarii, asigurați-vă că închideți.

/* acesta este un bloc de comentarii */

// comentariu pe un rând, nu este nevoie să închideți, valabil până la sfârșitul rândului.

// acesta este un rând de comentariu

Variabile și tipuri de date.

O variabilă este o celulă RAM în care sunt stocate informații. Programul folosește variabile pentru a stoca date intermediare de calcul. Pentru calcule pot fi folosite date de diferite formate și adâncimi de biți diferite, astfel încât variabilele în limbajul C au următoarele tipuri.

Tip de date	Adâncime, biți	Interval de numere
boolean	8	adevarat fals
char	8	-128 … 127
nesemnat char	8	0 … 255
octet	8	0 … 255
int	16	-32768 … 32767
nesemnat int	16	0 … 65535
cuvânt	16	0 … 65535
lung	32	-2147483648 … 2147483647
nesemnat lung	32	0 … 4294967295
mic de statura	16	-32768 … 32767
pluti	32	-3.4028235+38 … 3.4028235+38
dubla	32	-3.4028235+38 … 3.4028235+38

Tipurile de date sunt selectate în funcție de acuratețea de calcul necesară, formatele de date etc. De exemplu, nu ar trebui să alegeți tipul lung pentru un contor care numără până la 100. Va funcționa, dar operațiunea va ocupa mai multe date și memorie de program și va dura mai mult timp.

Declararea variabilelor.

Este specificat tipul de date, urmat de numele variabilei.

int x; // declararea unei variabile numite x de tip int
float widthBox; // declararea unei variabile numite widthBox de tip float

Toate variabilele trebuie declarate înainte de a fi utilizate.

O variabilă poate fi declarată oriunde într-un program, dar aceasta determină ce blocuri de program o pot folosi. Acestea. Variabilele au domenii.

• Variabilele declarate la începutul programului, înainte de funcția void setup(), sunt considerate globale și sunt disponibile oriunde în program.
• Variabilele locale sunt declarate în interiorul funcțiilor sau blocurilor, cum ar fi o buclă for, și pot fi utilizate numai în cadrul blocurilor declarate. Este posibil să aveți mai multe variabile cu același nume, dar domenii diferite.

modul int; // variabilă disponibilă pentru toate funcțiile

void setup() (
// bloc gol, nu sunt necesare setări inițiale
}

void loop() (

număr lung; // variabila count este disponibilă numai în funcția loop().

pentru (int i=0; i< 10;) // переменная i доступна только внутри цикла
{
i++;
}
}

Când declarați o variabilă, puteți seta valoarea inițială a acesteia (inițializare).

int x = 0; // variabila x este declarată cu valoarea inițială 0
char d = 'a'; // variabila d este declarată cu valoarea inițială egală cu codul caracterului „a”

Când se efectuează operații aritmetice cu diferite tipuri de date, are loc conversia automată a tipurilor de date. Dar este întotdeauna mai bine să folosiți o conversie explicită.

int x; // variabilă int
char y; // variabilă char
int z; // variabilă int

z = x + (int)y; // variabila y este convertită explicit în int

Operatii aritmetice.

Operațiuni de relație.

Operații logice.

Operații pe pointere.

Operații cu biți.

&	ȘI
|	SAU
^	EXCLUSIV SAU
~	INVERSIUNE
<<	SHIFT LA STÂNGA
>>	SHIFT DREAPTA

Operații mixte de atribuire.

Selectarea opțiunilor, managementul programului.

operator IF testează condiția din paranteze și execută expresia ulterioară sau blocul în acolade dacă condiția este adevărată.

dacă (x == 5) // dacă x=5, atunci se execută z=0
z=0;

dacă (x > 5) // dacă x >
(z=0; y=8; )

DACA...ALTUT vă permite să alegeți între două opțiuni.

dacă (x > 5) // dacă x > 5, atunci blocul se execută z=0, y=8;
{
z=0;
y=8;
}

{
z=0;
y=0;
}

ALTE DACA– vă permite să faceți selecții multiple

dacă (x > 5) // dacă x > 5, atunci blocul se execută z=0, y=8;
{
z=0;
y=8;
}

else if (x > 20) // dacă x > 20, acest bloc este executat
{
}

else // altfel acest bloc este executat
{
z=0;
y=0;
}

CAZĂ COMMUTATOR- alegere multiplă. Vă permite să comparați o variabilă (în exemplu acesta este x) cu mai multe constante (în exemplul 5 și 10) și să executați un bloc în care variabila este egală cu constanta.

comutator (x) (

cazul 5:
// codul este executat dacă x = 5
pauză;

cazul 10:
// codul este executat dacă x = 10
pauză;

Mod implicit:
// codul este executat dacă niciuna dintre valorile anterioare nu se potrivește
pauză;
}

FOR Loop. Designul vă permite să organizați bucle cu un anumit număr de iterații. Sintaxa arată astfel:

for (acțiune înainte de începerea buclei;
condiția de continuare a buclei;
acțiune la sfârșitul fiecărei iterații) (

// bucla codul corpului

Un exemplu de buclă de 100 de iterații.

pentru (i=0; i< 100; i++) // начальное значение 0, конечное 99, шаг 1

{
suma = suma + I;
}

bucla WHILE. Operatorul vă permite să organizați bucle cu construcția:

în timp ce (expresie)
{
// bucla codul corpului
}

Bucla rulează atâta timp cât expresia dintre paranteze este adevărată. Un exemplu de buclă pentru 10 iterații.

x = 0;
în timp ce (x< 10)
{
// bucla codul corpului
x++;
}

FACE ÎN TIMP CE– o buclă cu o condiție la ieșire.

do
{
// bucla codul corpului
) în timp ce (expresie);

Bucla rulează atâta timp cât expresia este adevărată.
PAUZĂ– operator de ieșire în buclă. Folosit pentru a întrerupe execuția buclelor for, while, do while.

x = 0;
în timp ce (x< 10)
{
dacă (z > 20) se rupe; // dacă z > 20, atunci ieșiți din buclă
// bucla codul corpului
x++;
}

MERGI LA– operator de tranziție necondiționat.

gotometka1; // mergeți la metka1
………………
metka1:

CONTINUA- sărirea declarațiilor până la sfârșitul corpului buclei.

x = 0;
în timp ce (x< 10)
{
// bucla codul corpului
dacă (z > 20) continuă; // dacă z > 20, atunci reveniți la începutul corpului buclei
// bucla codul corpului
x++;
}

Matrice.

O matrice este o zonă de memorie în care mai multe variabile sunt stocate secvenţial.

O matrice este declarată astfel:

int vârste; // matrice de 10 variabile int

greutate plutitoare // matrice de 100 de variabile float

Când sunt declarate, matricele pot fi inițializate:

vârste int = ( 23, 54, 34, 24, 45, 56, 23, 23, 27, 28);

Variabilele de matrice sunt accesate astfel:

x = vârste; // x i se atribuie valoarea din al 5-lea element al tabloului.
varsta = 32; // Al 9-lea element al matricei este setat la 32

Numerotarea elementelor matricei este întotdeauna de la zero.

Funcții.

Funcțiile vă permit să efectuați aceleași acțiuni cu date diferite. Funcția are:

• numele cu care este numită;
• argumente – date pe care funcția le folosește pentru calcul;
• tipul de date returnat de funcție.

Descrie o funcție definită de utilizator în afara funcțiilor setup() și loop().

void setup() (
// codul este executat o dată când programul pornește
}

void loop() (
// codul principal, executat în buclă
}

// declararea unei funcții personalizate numite functionName
tip functionName(tip argument1, tip argument1, … , tip argument)
{
// corp de funcție
întoarcere();
}

Un exemplu de funcție care calculează suma pătratelor a două argumente.

int sumQwadr(int x, int y)
{
return(x* x + y*y);
}

Apelul funcției decurge astfel:

d= 2; b= 3;
z= sumQwadr(d, b); // z va fi suma pătratelor variabilelor d și b

Funcțiile pot fi încorporate, personalizate sau plug-in.

Foarte scurt, dar aceste date ar trebui să fie suficiente pentru a începe să scrieți programe C pentru sistemele Arduino.

Ultimul lucru pe care vreau să-l spun în această lecție este modul în care se obișnuiește să formatați programele în C. Cred că dacă citiți această lecție pentru prima dată, ar trebui să săriți peste această secțiune și să reveniți la ea mai târziu, când aveți ceva de format.

Scopul principal al designului extern al programelor este de a îmbunătăți lizibilitatea programelor și de a reduce numărul de erori formale. Prin urmare, pentru a atinge acest obiectiv, puteți încălca în siguranță toate recomandările.

Nume în limbaj C.

Numele care reprezintă tipuri de date trebuie scrise cu majuscule mixte. Prima literă a numelui trebuie să fie scrisă cu majuscule (majuscule).

Semnal, TimeCount

Variabilele trebuie scrise în nume mixte cu majuscule, cu prima literă minuscule (minuscule).

Categorie: . Puteți să-l marcați.

Primul lucru pe care ar trebui să-l faceți pentru a stăpâni Arduino este să achiziționați o placă de depanare (ar fi o idee bună să achiziționați imediat o placă de circuit etc.). Am descris deja ce tipuri de plăci Arduino există pe piață. Dacă nu ați citit încă articolul, vă recomand să-l citiți. Pentru a învăța elementele de bază, alegem o placă standard Arduino Uno (originalul sau o copie chineză bună - depinde de tine). Când conectați placa originală pentru prima dată, nu ar trebui să existe probleme, dar cu cea „chineză” va trebui să săpați puțin mai adânc (nu vă faceți griji - vă voi arăta și vă spun totul).

Conectăm Arduino la computer cu un cablu USB. LED-ul de pe placă ar trebui să se aprindă PE". Un dispozitiv nou va apărea în Manager dispozitive " Dispozitiv necunoscut". Trebuie să instalați driverul. Aici voi adăuga un mic ambiguitate(pisica a fost distrasă - nu-mi amintesc care șofer a decis " problemă necunoscută cu dispozitivul».

Mai întâi a descărcat și dezambalat mediul software Arduino ( arduino-1.6.6-windows). Apoi l-am descărcat pe acesta. Se autoextractă. Am lansat fișierul CH341SER.EXE. Selectat instalare (INSTALARE). După instalare, a apărut un mesaj, a făcut clic pe „ Bine„(Nu am avut timp să o citesc).

Apoi am mers la proprietățile „dispozitivului necunoscut” și am selectat butonul „Actualizați driverul”. Am selectat opțiunea „Instalare dintr-o locație specificată” - a indicat folderul cu mediul software Arduino dezarhivat. Și iată, totul a funcționat cu succes...

Lansăm programul Arduino (în cazul meu 1.6.6) și permitem accesul.

Toate proiectele (programele) pentru Arduino constau din două părți: anulează configurareaȘi buclă goală. anulează configurarea se efectuează o singură dată și buclă goală se face iar si iar.

Înainte de a continua, există două operațiuni obligatorii care trebuie finalizate:

— indicați în mediul software Arduino ce placă utilizați. Instrument->placă->Arduino Uno. Dacă marca este deja pe tabla de care aveți nevoie, este bine; dacă nu, puneți un semn.

— specificați în mediul software ce port serial utilizați pentru a comunica cu placa. Instrument->port->COM3. Dacă marcajul este deja pe port, este bine, dacă nu, puneți un marcaj. Dacă aveți mai multe porturi listate în secțiunea porturi, cum puteți afla care dintre ele este folosit pentru a vă conecta la placă? Luăm placa și deconectăm firul de la ea. Mergem din nou în porturi și vedem care a dispărut. În cazul meu, fila „porturi” a devenit deloc inactivă.

Reconectați cablul USB.

Primul program nu necesită module suplimentare. Vom aprinde LED-ul, care este deja montat pe placă (la pinul 13 al microcontrolerului).

Mai întâi, să configuram pinul 13 (intrare sau ieșire).

Pentru a face acest lucru, intrați în blocul „ anulează configurarea» echipa pinMode , indicăm parametrii între paranteze (13, IEȘIRE) (Ce pin este implicat, modul de operare). Mediul software evidențiază cuvintele/comenzile cu culoarea adecvată a fontului.

Du-te la bloc" buclă goală„și introduceți comanda digitalWrite cu parametrii (13, MARE) .

Primul program este gata, acum nu mai rămâne decât să-l încărcați în microcontroler. Faceți clic pe butonul ÎNCĂRCARE.

LED-ul s-a aprins. Dar nu fi atât de sceptic cu privire la simplitatea primului program. Tocmai ai stăpânit prima comandă de control. În loc de un LED, puteți conecta orice sarcină (fie că este iluminatul într-o cameră sau un servomotor care oprește alimentarea cu apă), dar despre toate acestea vom vorbi mai târziu...

Am aprins LED-ul, a strălucit puțin, este timpul să-l stingem. Pentru a face acest lucru, să modificăm programul pe care l-am scris. În loc de " ÎNALT "Hai să scriem" SCĂZUT ».

Faceți clic pe butonul ÎNCĂRCARE. LED-ul s-a stins.

Ne-am familiarizat deja cu conceptul de „”, este timpul să-l folosim. Alte programe vor deveni din ce în ce mai voluminoase și mai complexe, iar munca pentru schimbarea lor va dura din ce în ce mai mult timp dacă vom continua să scriem cod astfel.

Ne uităm la program (aprindem din nou LED-ul). Să setăm numărul pinului microcontrolerului, nu ca număr 13 , ci o variabilă căreia i se va atribui valoarea ieșirii corespunzătoare (în cazul nostru, 13). În viitor, va fi foarte convenabil să schimbați valorile variabilelor la începutul programului, în loc să scotoci prin cod în căutarea acelor locuri în care este necesară modificarea valorilor.

Creați o variabilă globală int LED_pin = 13; (tipul variabilei, numele variabilei, valoarea atribuită acesteia).

Faceți clic pe butonul ÎNCĂRCARE. LED-ul se aprinde. Totul funcționează perfect.

În această lecție, pe lângă aprinderea/oprirea LED-ului, vom învăța și cum să-l clipim.

Pentru a face acest lucru, introduceți a doua comandă „ digitalWrite» cu parametrii (LED_pin, LOW).

Faceți clic pe butonul ÎNCĂRCARE. Și ce vedem? LED-ul luminează „în cea mai mare măsură”. Motivul constă în faptul că timpul de comutare a două stări ( ÎNALT Și SCĂZUT ) este neglijabilă și ochiul uman nu poate detecta aceste comutatoare. Este necesar să măriți timpul în care LED-ul rămâne într-una dintre stări. Pentru a face acest lucru scriem comanda întârziere cu parametru (1000 ) . Întârziere în milisecunde: 1000 milisecunde – 1 secundă. Algoritmul programului este următorul: porniți LED-ul - așteptați 1 secundă, stingeți LED-ul - așteptați 1 secundă etc.

Faceți clic pe butonul ÎNCĂRCARE. LED-ul a început să pâlpâie. Totul merge.

Să finalizăm programul prin crearea unei variabile căreia i se va atribui o valoare responsabilă pentru durata întârzierii.

Faceți clic pe butonul ÎNCĂRCARE. LED-ul pâlpâie ca înainte.

Să finalizăm programul pe care l-am scris. Sarcinile sunt următoarele:

• LED-ul este aprins timp de 0,2 secunde și stins timp de 0,8 secunde;
• LED-ul este aprins timp de 0,7 secunde și stins timp de 0,3 secunde.

Programul a creat 2 variabile care sunt responsabile pentru întârzierile de timp. Unul determină timpul de funcționare al LED-ului aprins, iar al doilea – timpul de funcționare al LED-ului stins.

Vă mulțumim pentru atenție. Pe curând!