Referință la limbajul Arduino. Ce este Arduino? Cum se scriu programe pentru Arduino

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 ambele dispozitive cu circuite simple, precum și proiecte complexe, care necesită forță de muncă intensă, cum ar fi 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 el consiliu de dezvoltare, când piesele necesare (rezistoare, diode, tranzistoare etc.) sunt conectate la controler fără a fi nevoie de lipire.

Majoritatea plăcilor Arduino au o conexiune prin 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 individuale seturi sau seturi de construcție, așa-numitele kit-uri, 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ă matriceală;
plăci de expansiune;
condensatoare.

Trebuie sa stii programare?

Primii pași pentru a lucra Placa Arduinoîncepe 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. Așadar, 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,
control motor pas cu pas,
redarea textului
etc.

Cum se configurează Arduino?

Unul dintre principalele avantaje ale designerului este securitatea 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 „Next”, 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âinile

Pentru a implementa cu încredere idei complexe, utilizați mediu 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 apoi următoarea apăsare va ieși. 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 ) return current ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; (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 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.

" este curs de pregatire„Arduino pentru începători”. Seria este reprezentată de 10 lecții, precum și material suplimentar. Lecțiile includ instrucțiuni text, fotografii și videoclipuri cu instrucțiuni. În fiecare lecție veți găsi o listă de componente necesare, o listă de programe și o diagramă de conectare. După ce ai studiat aceste 10 lecții de bază, poți începe să faci mai multe modele interesanteși asamblarea roboților bazați pe Arduino. Cursul este destinat începătorilor; nu aveți nevoie de cunoștințe pentru a începe. Informații suplimentare din inginerie electrică sau robotică.

Scurte informații despre Arduino

Ce este Arduino?

Arduino (Arduino) este o platformă hardware de calcul, ale cărei componente principale sunt o placă de intrare-ieșire și un mediu de dezvoltare. Arduino poate fi folosit pentru a crea obiecte interactive de sine stătătoare sau pentru a se conecta la software care rulează pe un computer. Arduino este un computer cu o singură placă.

Cum sunt conectați Arduino și roboții?

Răspunsul este foarte simplu - Arduino este adesea folosit ca creierul robotului.

Avantajul plăcilor Arduino față de platforme similare este relativ preț scăzutși distribuție aproape în masă printre amatorii și profesioniștii roboticii și ingineriei electrice. Odată ce ați început să utilizați Arduino, veți găsi asistență în orice limbă și oameni care vă vor răspunde la întrebări și vor discuta despre evoluțiile dvs.

Lecția 1. LED intermitent pe Arduino

În prima lecție veți învăța cum să conectați un LED la un Arduino și să îl controlați să clipească. Acesta este cel mai simplu și de bază model.

Dioda electro luminiscenta- un dispozitiv semiconductor care creează radiații optice atunci când un curent electric este trecut prin el în direcția înainte.

Lecția 2. Conectarea unui buton pe Arduino

În acest tutorial veți învăța cum să conectați un buton și un LED la un Arduino.

Când butonul este apăsat, LED-ul se va aprinde, în timp ce când butonul este apăsat, nu se va aprinde. Acesta este și modelul de bază.

Lecția 3. Conectarea unui potențiometru la Arduino

În acest tutorial veți învăța cum să conectați un potențiometru la Arduino.

Potențiometru- Acest rezistență cu rezistență reglabilă.Potențiometrele sunt folosite ca regulatoare diverși parametri– volumul sunetului, puterea, tensiunea etc.Aceasta este, de asemenea, una dintre schemele de bază. În modelul nostru de la rotirea butonului potențiometruluiLuminozitatea LED-ului va depinde.

Lecția 4. Controlul servo pe Arduino

În acest tutorial veți învăța cum să conectați un servo la un Arduino.

Servoeste un motor a cărui poziție a arborelui poate fi controlată prin setarea unghiului de rotație.

Servo-urile sunt folosite pentru a simula diverse mișcări mecanice ale roboților.

Lecția 5. LED-uri în trei culori pe Arduino

În acest tutorial veți învăța cum să conectați un LED tricolor la un Arduino.

LED tricolor(led rgb) - acestea sunt trei LED-uri de culori diferite într-o singură carcasă. Ele vin fie cu o mică placă de circuit imprimat pe care sunt amplasate rezistențele, fie fără rezistențe încorporate. Lecția acoperă ambele opțiuni.

Lecția 6. Element piezo pe Arduino

În această lecție veți învăța cum să conectați un element piezo la un Arduino.

Element piezo- un convertor electromecanic care se traduce tensiune electrică în vibrația membranei. Aceste vibrații creează sunet.

În modelul nostru, frecvența sunetului poate fi reglată prin setarea parametrilor corespunzători în program.

Lecția 7. Fotorezistor pe Arduino

În această lecție a cursului nostru veți învăța cum să conectați un fotorezistor la Arduino.

Fotorezistor- un rezistor a cărui rezistență depinde de luminozitatea luminii care cade pe el.

În modelul nostru, LED-ul se aprinde numai dacă luminozitatea luminii de deasupra fotorezistorului este mai mică decât o anumită luminozitate poate fi reglată în program;

Lecția 8. Senzor de mișcare (PIR) pe Arduino. Trimiterea automată de e-mail

În această lecție a cursului nostru veți învăța cum să conectați un senzor de mișcare (PIR) la Arduino, precum și să organizați trimiterea automată de e-mail.

Senzor de mișcare (PIR)- senzor infrarosu pentru a detecta miscarea sau prezenta oamenilor sau animalelor.

În modelul nostru, atunci când primește un semnal despre mișcarea umană de la un senzor PIR, Arduino trimite o comandă către computer pentru a trimite un e-mail și scrisoarea este trimisă automat.

Lecția 9. Conectarea unui senzor de temperatură și umiditate DHT11 sau DHT22

În această lecție a noastră, veți învăța cum să conectați un senzor de temperatură și umiditate DHT11 sau DHT22 la un Arduino și, de asemenea, vă veți familiariza cu diferențele dintre caracteristicile acestora.

Senzor de temperatura si umiditate este un senzor digital compozit format dintr-un senzor capacitiv de umiditate și un termistor pentru măsurarea temperaturii.

În modelul nostru, Arduino citește citirile senzorului și afișează citirile pe ecranul computerului.

Lecția 10. Conectarea unei tastaturi matrice

În această lecție a cursului nostru, veți învăța cum să conectați o tastatură matriceală la o placă Arduino și, de asemenea, să vă familiarizați cu diverse circuite interesante.

Tastatura Matrix conceput pentru a simplifica conexiunea un numar mare butoane Astfel de dispozitive se găsesc peste tot - în tastaturile computerelor, calculatoare și așa mai departe.

Lecția 11. Conectarea modulului de ceas în timp real DS3231

În ultima lecție a cursului nostru, veți învăța cum să conectați un modul de ceas în timp real din familie
DS la placa Arduino și, de asemenea, familiarizați-vă cu diverse circuite interesante.

Modul ceas în timp real este un circuit electronic conceput pentru a înregistra date cronometrice ( ora curentă, data, ziua saptamanii etc.), este un sistem format dintr-o sursa de alimentare autonoma si un dispozitiv de contorizare.

Aplicație. Cadre și roboți Arduino gata făcute

Puteți începe să învățați Arduino nu numai de pe placa în sine, ci și prin achiziționarea unui robot gata făcut, cu drepturi depline, bazat pe această placă - un robot păianjen, o mașină robot, un robot țestoasă etc. Astfel de cale potrivit pentru cei care circuite electrice nu deosebit de atractiv.

Prin achiziționarea unui model de robot funcțional, de ex. de fapt, o jucărie high-tech gata făcută poate trezi interesul pentru design independent și robotică. Deschiderea platformei Arduino permite de la aceeași componente fă-ți jucării noi.

O altă opțiune este să achiziționați un cadru sau un corp de robot: o platformă pe roți sau o pistă, un umanoid, un păianjen etc. În acest caz, va trebui să faceți singur umplerea robotului.

Aplicație. Directorul mobil

– un asistent pentru dezvoltatorii de algoritmi pentru platforma Arduino, al cărui scop este să ofere Utilizator final oportunitatea de a avea apelare mobilă comenzi (carte de referință).

Aplicația constă din 3 secțiuni principale:

Operatori;
Date;
Funcții.

De unde să cumpărați Arduino

truse Arduino

Cursul va fi actualizat cu lecții suplimentare. Urmați-ne

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(). Ea execută comenzile scrise în corpul ei într-o buclă nesfârșită (între acolade). 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 linie 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. Datele pot fi folosite pentru calcule diferite formate, cu adâncime de biți diferită, astfel încât variabilele din 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ția va dura mai multa memorie datele și programele vor necesita 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 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 varste; // 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ă
}

// anunț funcție personalizată cu numele 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 litere mici, cu prima literă minuscule (minuscule).

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

Acest simulator funcționează cel mai bine pe browserul Chrome
Să aruncăm o privire mai atentă la Arduino.

Arduino nu este calculator mare, la care se pot conecta circuite externe. ÎN Arduino Uno Se folosește Atmega 328P
Acesta este cel mai mare cip de pe placă. Acest cip execută programe care sunt stocate în memoria sa. Puteți descărca programul prin usb folosind Arduino IDE. Portul USB oferă, de asemenea, alimentare arduino.

Există un conector de alimentare separat. Placa are doi pini etichetați 5v și 3.3v, care sunt necesari pentru alimentarea diferitelor dispozitive. Veți găsi, de asemenea, pini marcați GND, aceștia sunt pinii de masă (pământul este 0V). Platforma Arduino are și 14 pini digitali, etichetați de la 0 la 13, care se conectează la noduri externe și au două stări, ridicată sau scăzută (pornit sau oprit). Aceste contacte pot funcționa ca ieșiri sau ca intrări, de ex. pot fie să transmită unele date și să controleze dispozitive externe sau primiți date de la dispozitive. Următorii pini de pe placă sunt etichetați A0-A5. Acestea sunt intrări analogice care pot accepta date de la diverși senzori. Acest lucru este convenabil mai ales atunci când trebuie să măsurați un anumit interval, cum ar fi temperatura. Intrările analogice au funcții suplimentare, care poate fi folosit separat.

Cum se utilizează panou.

Placa este necesară pentru a conecta temporar piesele, pentru a verifica cum funcționează dispozitivul, înainte de a lipi totul împreună.
Toate exemplele următoare sunt asamblate pe o placă, astfel încât să puteți face rapid modificări la circuit și să reutilizați piesele fără să vă deranjați cu lipirea.

Placa are șiruri de găuri în care puteți introduce piese și fire. Unele dintre aceste găuri sunt conectate electric între ele.

Cele două rânduri de sus și de jos sunt conectate în rânduri de-a lungul întregii plăci. Aceste rânduri sunt folosite pentru a furniza energie circuitului. Ar putea fi de 5V sau 3,3V, dar în orice caz, primul lucru pe care trebuie să-l faceți este să conectați 5V și GND la placa, așa cum se arată în imagine. Uneori, aceste conexiuni de rând pot fi rupte în mijlocul plăcii, apoi, dacă este necesar, le puteți conecta așa cum se arată în imagine.

Găurile rămase, situate în mijlocul plăcii, sunt grupate în grupuri de cinci găuri. Sunt folosite pentru a conecta părțile circuitului.

Primul lucru pe care îl vom conecta la microcontrolerul nostru este un LED. Sistem legăturile electrice prezentată în imagine.

De ce este nevoie de o rezistență într-un circuit? În acest caz, limitează curentul care trece prin LED. Fiecare LED este proiectat pentru un anumit curent, iar dacă acest curent este mai mare, LED-ul se va defecta. Puteți afla ce valoare ar trebui să aibă rezistorul folosind legea lui Ohm. Pentru cei care nu știu sau au uitat, legea lui Ohm spune că există o relație liniară între curent și tensiune. Adică, cu cât aplicăm mai multă tensiune rezistorului, cu atât mai mult curent va curge prin el.
V=I*R
Unde V- tensiunea pe rezistor
eu- curent prin rezistor
R- rezistenta care trebuie gasita.
În primul rând, trebuie să aflăm tensiunea pe rezistor. Majoritatea LED-urilor de 3 mm sau 5 mm pe care le veți folosi au o tensiune de funcționare de 3V. Aceasta înseamnă că trebuie să stingem 5-3 = 2V la rezistor.

Vom calcula apoi curentul care trece prin rezistor.
Majoritatea LED-urilor de 3 mm și 5 mm luminează la luminozitate maximă la 20 mA. Un curent mai mare decât acesta le poate dezactiva, în timp ce un curent de intensitate mai mică le va reduce luminozitatea fără a provoca niciun rău.

Deci, dorim să conectăm LED-ul la circuitul de 5V, astfel încât să poată transporta un curent de 20mA. Deoarece toate piesele sunt incluse într-un singur circuit, rezistorul va avea și un curent de 20mA.
Primim
2V = 20 mA * R
2V = 0,02A * R
R = 100 Ohm
100 Ohmi este rezistența minimă, este mai bine să folosiți puțin mai mult, deoarece LED-urile au anumite variații în caracteristici.
ÎN în acest exemplu se folosește o rezistență de 220 ohmi. Doar pentru că autorul are o mulțime de ele: cu ochiul: .

Introduceți LED-ul în găurile din mijlocul plăcii, astfel încât cablul său lung să fie conectat la unul dintre cablurile rezistenței. Conectați al doilea capăt al rezistenței la 5V și conectați cel de-al doilea cablu al LED-ului la GND. LED-ul ar trebui să se aprindă.

Vă rugăm să rețineți că există o diferență în modul în care conectați LED-ul. Curentul trece de la terminalul mai lung spre cel mai scurt. În diagramă vă puteți imagina că curentul curge în direcția în care este îndreptat triunghiul. Încercați să întoarceți LED-ul cu susul în jos și veți vedea că nu se va aprinde.

Dar modul în care conectați rezistorul nu face nicio diferență. Puteți să-l întoarceți sau să încercați să-l conectați la un alt pin al LED-ului, acest lucru nu va afecta funcționarea circuitului. Acesta va limita în continuare curentul prin LED.

Anatomia schiței Arduino.

Programele pentru Arduino se numesc sketch. Ele constau din două funcții principale. Funcţie înființatși funcția buclă
În această funcție veți seta toate setările de bază. Ce pini vor funcționa ca intrare sau ieșire, ce biblioteci să se conecteze, inițializează variabilele. Funcţie Înființat() rulează o singură dată în timpul schiței, când începe execuția programului.
aceasta este funcția principală care se execută după înființat(). De fapt, este programul în sine. Această funcție va funcționa pe termen nelimitat până când opriți alimentarea.

LED intermitent Arduino

În acest exemplu vom conecta circuitul LED la unul dintre cele digitale Pini Arduinoși îl vom porni și opri folosind programul și veți învăța și câteva funcții utile.

Această funcție este utilizată în înființat() parte a programului și servește la inițializarea pinii pe care îi veți folosi ca intrare (INTRARE) sau ieșire (IEȘIRE). Nu veți putea să citiți sau să scrieți date din pin până când nu îl setați respectiv pinMode. Această funcție are două argumente: Numarul pin este numărul PIN pe care îl veți folosi.

Modul-setează cum va funcționa pinul. La intrare (INTRARE) sau ieșire (IEȘIRE). Pentru a aprinde LED-ul trebuie să dăm un semnal DIN Arduino. Pentru a face acest lucru, configurăm pinul de ieșire.
- această funcție este folosită pentru a seta starea (stat) pina (Numarul pin). Există două stări principale (de fapt 3 dintre ele), una este ÎNALT, vor fi 5V pe pin, asta e altceva Scăzut iar pinul va fi 0v. Aceasta înseamnă că pentru a aprinde LED-ul trebuie să setăm pinul conectat la LED la un nivel ridicat ÎNALT.

Întârziere. Servește pentru a întârzia funcționarea programului pentru o perioadă specificată în msec.
Mai jos este codul care face ca LED-ul să clipească.
//LED Blink int ledPin = 7;//Pinul Arduino la care este conectat LED-ul void setup() ( pinMode(ledPin, OUTPUT);// setarea pinului ca OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// porniți întârzierea LED-ului (1000);// întârziere 1000 ms (1 sec) digitalWrite (ledPin, LOW);//Opriți întârzierea LED-ului (1000);// așteptați 1 secundă)

Mici explicații despre cod.
Liniile care încep cu „//” sunt comentarii și sunt ignorate de Arduino.
Toate comenzile se termină cu punct și virgulă dacă le uitați, veți primi un mesaj de eroare.

ledPin este o variabilă. Variabilele sunt folosite în programe pentru a stoca valori. În acest exemplu, variabila ledPin valoarea este atribuită la 7, acesta este numărul de pin Arduino. Când programul Arduino întâlnește o linie cu o variabilă ledPin, va folosi valoarea specificată mai devreme.
Deci inregistreaza pinMode(ledPin, OUTPUT) similar cu înregistrarea pinMode(7, IEȘIRE).
Dar în primul caz, trebuie doar să schimbați variabila și aceasta se va schimba în fiecare linie în care este folosită, iar în al doilea caz, pentru a schimba variabila, va trebui să faceți modificări manual în fiecare comandă.

Prima linie indică tipul variabilei. Când programați Arduino, este important să declarați întotdeauna tipul de variabile. Deocamdată este suficient să știi asta INT anunta numere negative si pozitive.
Mai jos este o simulare a schiței. Faceți clic pe Start pentru a vedea circuitul în acțiune.

După cum era de așteptat, LED-ul se stinge și se aprinde din nou după o secundă. Încercați să modificați întârzierea pentru a vedea cum funcționează.

Controlul mai multor LED-uri.

În acest exemplu, veți învăța cum să controlați mai multe LED-uri. Pentru a face acest lucru, instalați încă 3 LED-uri pe placă și conectați-le la rezistențe și pinii Arduino, așa cum se arată mai jos.

Pentru a porni și stinge LED-urile unul câte unul, trebuie să scrieți un program similar cu acesta:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //setează pinii ca OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH) );//porniți întârzierea LED (1000);//întârziere 1 sec digitalWrite (led1Pin, LOW);//opriți întârzierea LED-ului (1000);//întârziere 1 sec //faceți același lucru pentru celelalte 3 LED-uri digitalWrite(led2Pin, HIGH);//aprinde LED-ul întârziere(1000);//întârziere 1 sec digitalWrite(led2Pin, LOW);//stinge LED-ul întârziere (1000);//întârziere 1 sec digitalWrite(led3Pin, HIGH); );//aprinde LED-ul întârziere (1000);// întârziere 1 sec digitalWrite (led3Pin, LOW);//stinge LED-ul întârziere (1000);//întârziere 1 sec digitalWrite (led4Pin, HIGH);//pornire întârzierea LED-ului (1000);// întârziere 1 sec digitalWrite (led4Pin, LOW);//stinge întârzierea LED-ului (1000);//întârziere 1 secundă)

Acest program va funcționa excelent, dar nu este soluția cea mai rațională. Codul trebuie schimbat. Pentru ca programul să funcționeze din nou și din nou, vom folosi o construcție numită .
Buclele sunt utile atunci când trebuie să repetați aceeași acțiune de mai multe ori. În codul de mai sus repetăm rândurile

DigitalWrite(led4Pin, HIGH); întârziere (1000); digitalWrite(led4Pin, LOW); întârziere (1000);
codul de schiță complet în atașament (descărcări: 1187)

Reglarea luminozității LED-urilor

Uneori va trebui să modificați luminozitatea LED-urilor din program. Acest lucru se poate face folosind comanda analogWrite() . Această comandă pornește și stinge LED-ul atât de repede încât ochiul nu poate vedea pâlpâirea. Dacă LED-ul este aprins jumătate din timp și stins jumătate din timp, va părea vizual că strălucește la jumătate din luminozitate. Aceasta se numește modularea lățimii impulsului (PWM sau PWM în engleză). Shim este folosit destul de des, deoarece poate fi folosit pentru a controla o componentă „analogică” folosind un cod digital. Nu toți pinii Arduino sunt potriviți pentru aceste scopuri. Doar acele concluzii în apropierea cărora se trage o astfel de desemnare " ~ ". Îl vei vedea lângă pinii 3,5,6,9,10,11.
Conectați unul dintre LED-urile dvs. la unul dintre pinii PWM (pentru autor acesta este pinul 9). Acum rulați schița intermitentă a LED-ului, dar mai întâi schimbați comanda digitalWrite() pe analogWrite(). analogWrite() are două argumente: primul este numărul de pin, iar al doilea este valoarea PWM (0-255), în raport cu LED-urile aceasta va fi luminozitatea acestora, iar pentru motoarele electrice viteza de rotație. Mai jos este un exemplu de cod pentru diferite luminozități LED.
//Schimbați luminozitatea LED-ului int ledPin = 9;//un LED este conectat la acest pin void setup() ( pinMode(ledPin, OUTPUT);// inițializarea pinului la ieșire ) void loop() ( analogWrite( ledPin, 255);// luminozitate maximă (255/255 = 1) întârziere (1000);//pauză 1 sec digitalWrite (ledPin, LOW);//stinge LED întârziere (1000);//pauză 1 sec analog Write ( ledPin, 191);//luminozitate cu 3/4 (191/255 ~= 0,75) întârziere (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//oprire întârziere LED (1000);// pauză 1 sec analogWrite(ledPin, 127); //întârziere de jumătate de luminozitate (127/255 ~= 0,5) (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//întârziere LED-ul de oprire (1000);/ /pauză 1 sec analogWrite(ledPin, 63); //sferturi de luminozitate (63/255 ~= 0,25) delay(1000);//pauză 1 sec digitalWrite(ledPin, LOW);//stinge LED-ul delay(1000) ;//pauză 1 secundă)

Încercați să modificați valoarea PWM din comandă analogWrite() pentru a vedea cum afectează acest lucru luminozitatea.
În continuare, veți învăța cum să reglați ușor luminozitatea de la maxim la zero. Desigur, puteți copia o bucată de cod de 255 de ori
analogWrite(ledPin, luminozitate); delay(5);//short delay luminozitate = luminozitate + 1;
Dar, înțelegi, acest lucru nu va fi practic. Cel mai bun mod de a face acest lucru este utilizarea bucla FOR care a fost folosit anterior.
Următorul exemplu utilizează două bucle, una pentru a reduce luminozitatea de la 255 la 0
pentru (luminozitate int=0;luminozitate=0;luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); )
întârziere (5) folosit pentru a încetini viteza de atenuare a luminozității 5*256=1280ms=1.28s)
Prima linie folosește „ luminozitate-" pentru a face ca valoarea luminozității să scadă cu 1 de fiecare dată când bucla este repetată. Rețineți că bucla va continua până când luminozitate >=0.Înlocuirea semnului > pe semn >= am inclus 0 în intervalul de luminozitate. Această schiță este modelată mai jos. //schimbați ușor luminozitatea int ledPin = 9;//un LED este conectat la acest pin void setup() ( pinMode(ledPin, OUTPUT);// inițializarea pinului de ieșire) void loop() ( //creșteți ușor luminozitate (de la 0 la 255) pentru (luminozitate int=0;luminozitate=0;luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); ) delay(1000);//așteptați 1 secundă //reduceți ușor luminozitatea (255 la 0) pentru (luminozitate int=255; luminozitate>=0; luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); ) delay(1000);//așteptați 1 secundă) )
Nu este foarte vizibil, dar ideea este clară.

LED RGB și Arduino

Un LED RGB este de fapt trei LED-uri de culori diferite într-un singur pachet.

Inclusiv LED-uri diferite Cu o luminozitate diferită, puteți combina și obține culori diferite. Pentru Arduino, unde numărul de niveluri de luminozitate este 256, veți obține 256^3=16581375 culori posibile. În realitate, desigur, vor fi mai puțini.
LED-ul pe care îl vom folosi este catodul comun. Acestea. toate cele trei LED-uri sunt conectate structural prin catozi la un terminal. Vom conecta acest pin la pinul GND. Pinii rămași, prin rezistențe de limitare, trebuie conectați la pinii PWM. Autorul a folosit pinii 9-11. În acest fel, va fi posibil să controlați fiecare LED separat. Prima schiță arată cum să porniți fiecare LED individual.

//LED RGB - test //pin conexiuni int red = 9; int verde = 10; int albastru = 11; void setup())( pinMode(rosu, OUTPUT); pinMode(albastru, OUTPUT); pinMode(verde, OUTPUT); ) void loop())( //porneste/opri LED-ul rosu digitalWrite(rosu, HIGH); delay(500); HIGH); digitalWrite (albastru, LOW);

Următorul exemplu utilizează comenzile analogWrite()și pentru a obține diferite valori aleatorii de luminozitate pentru LED-uri. Veți vedea diferite culori schimbându-se aleatoriu.
//LED RGB - culori aleatorii //conexiuni pin int red = 9; int verde = 10; int albastru = 11; void setup())( pinMode(red, OUTPUT); pinMode(albastru, OUTPUT); pinMode(verde, OUTPUT); ) void loop())( //alege o culoare aleatorie analogWrite(rosu, random(256)); analogWrite( albastru, random(256)); analogWrite(verde, random(256));

Aleatoriu(256)- returnează un număr aleatoriu în intervalul de la 0 la 255.
În fișierul atașat este o schiță care va demonstra tranzițiile netede ale culorilor de la roșu la verde, apoi la albastru, roșu, verde etc. (descărcări: 326)
Exemplul de schiță funcționează, dar există o mulțime de coduri duplicate. Puteți simplifica codul scriind propria funcție de ajutor care se va schimba ușor de la o culoare la alta.
Iată cum va arăta: (descărcări: 365)
Să ne uităm la definirea funcției bucată cu bucată. Funcția este numită faderși are două argumente. Fiecare argument este separat prin virgulă și are un tip declarat pe prima linie a definiției funcției: void fader (int color1, int color2). Vedeți că ambele argumente sunt declarate ca intși li se dau nume culoare1Și culoare2 ca variabile de condiție pentru a defini o funcție. Vidulînseamnă că funcția nu returnează nicio valoare, pur și simplu execută comenzi. Dacă ar trebui să scrieți o funcție care a returnat rezultatul înmulțirii, ar arăta astfel:
int multiplicator(int număr1, int număr2)( int produs = număr1*număr2; returnează produsul; )
Observați cum am declarat Type intîn schimb ca tip de returnare
vid.
În interiorul funcției există comenzi pe care le-ați folosit deja în schița anterioară, doar numerele de pin au fost înlocuite cu culoare1Și culoare2. Funcția este numită fader, argumentele sale sunt calculate ca culoare1 = roșuȘi culoare2 = verde. Arhiva conține o schiță completă folosind funcții (descărcări: 272)

Buton

Următoarea schiță va folosi un buton cu contacte normal deschise, fără blocare.

Aceasta înseamnă că, în timp ce butonul nu este apăsat, nu trece curent prin el, iar după ce a fost eliberat, butonul revine la poziția inițială.
Pe lângă buton, circuitul folosește un rezistor. În acest caz, nu limitează curentul, ci „trage” butonul la 0V (GND). Acestea. Până când butonul este apăsat, pinul Arduino la care este conectat se va reduce. Rezistorul folosit în circuit este de 10 kOhm.

//determină când butonul este apăsat int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//inițializați pinul la intrarea Serial.begin(9600);//inițializați portul serial) void loop())( if (digitalRead(buttonPin)==HIGH )(//dacă butonul este apăsat Serial.println("apăsat"); // afișează inscripția "apăsat" ) altfel ( Serial.println("neapăsat");// în caz contrar, "neapăsat" ) )
Există mai multe comenzi noi în această schiță.
-Această comandă preia valorile High și Low ale ieșirii pe care o testăm. Această ieșire trebuie mai întâi configurată ca intrare în setup().
; //unde butonulPin este numărul PIN la care este conectat butonul.
Portul serial permite Arduino să trimită mesaje către computer în timp ce controlerul însuși execută programul. Acest lucru este util pentru depanarea unui program, trimiterea de mesaje către alte dispozitive sau aplicații. Pentru a activa transferul de date printr-un port serial (numit și UART sau USART), trebuie să-l inițializați în setup()

Serial.begin() are un singur argument - aceasta este viteza de transfer de date între Arduino și computer.
Schița folosește o comandă pentru a afișa un mesaj pe ecran în Arduino IDE (Tools >> Serial Monitor).
- designul vă permite să controlați progresul execuției programului prin combinarea mai multor verificări într-un singur loc.
Dacă digitalRead revine HIGH, atunci cuvântul „apăsat” este afișat pe monitor. În caz contrar, cuvântul „eliberat” este afișat pe monitor. Acum puteți încerca să porniți și să opriți LED-ul apăsând un buton.
//detecție apăsare buton cu ieșire LED int buttonPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//De data aceasta vom seta pinul butonului ca INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin) )= =HIGH)( digitalWrite(ledPin,HIGH); Serial.println(„apăsat”); ) else ( digitalWrite(ledPin,LOW); Serial.println(„ne apăsat”); ) )

Intrare analogică.

analogRead vă permite să citiți date de la unul dintre pinii analogici Arduino și afișează o valoare în intervalul de la 0 (0V) la 1023 (5V). Dacă tensiunea la intrarea analogică este de 2,5 V, atunci se va imprima 2,5 / 5 * 1023 = 512
analogRead are un singur argument - Acesta este numărul intrare analogică(A0-A5). Următoarea schiță arată codul pentru citirea tensiunii de la potențiometru. Pentru a face acest lucru, conectați-vă rezistor variabil, pinii exteriori merg la pinii 5V și GND, iar pinul din mijloc merge la intrarea A0.

Rulați următorul cod și vedeți în monitorul serial cum se schimbă valorile în funcție de rotația butonului rezistenței.
//intrare analogică int potPin = A0;//pinul central al potențiometrului este conectat la acest pin void setup())( //pinul analogic este inclus ca intrare implicit, deci nu este necesară inițializarea Serial.begin(9600) ) void loop())( int potVal = analogRead(potPin);//potVal este un număr între 0 și 1023 Serial.println(potVal)
Următoarea schiță combină schița de clic pe buton și schița de control al luminozității LED. LED-ul se va aprinde de la buton, iar luminozitatea va fi controlată de un potențiometru.
//detecție apăsare buton cu ieșire LED și intensitate variabilă int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//dacă butonul este apăsat int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//porniți led-ul cu intensitatea setată de pot Serial.println("pressed"); ( digitalWrite(ledPin, LOW);//oprire dacă butonul nu este apăsat Serial.println("ne apăsat"); ) )

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

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

Cu exceptia plăci de circuite imprimate, produse sub marca Arduino, au propriul limbaj de programare Arduino, care se bazează pe un limbaj larg cunoscut printre programatori C/C++. Să aruncăm o privire mai atentă la ce este.

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

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

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

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

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

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

Placi Arduino;
Cablu USB;
calculator cu instalat Programul Arduino IDE.

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

Cum se configurează Arduino pe un computer?

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

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

Important! Când vă conectați placa la alta port USB Toate setările vor trebui făcute din nou.

Introducere în interfața Arduino

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

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

verificarea erorilor;

crearea unei noi schițe;

deschiderea ferestrei portului microcontrolerului;

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

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

Compilare– conversia codului sursă a limbii nivel inalt V Codul mașinii sau în limbaj de asamblare.

Funcțiile de bază ale limbajului de programare

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

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

Punct şi virgulă;

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

Int LEDpin = 9;

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

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

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

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

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

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

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

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

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

Acolade ( )

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

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

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

Funcții ()

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

Ia o găleată
Umpleți-l cu apă
Adăugați săpun
Găsiți un câine
Spumă câinele
Spală câinele
Clătiți câinele
Uscați câinele
Pune găleata deoparte

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

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

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

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

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

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

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

void setup()

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

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

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

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

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

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

buclă goală ()

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

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

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

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

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

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

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

Mai este altul varianta interesanta programul original. Se numește B4R, iar principala sa diferență este că nu folosește limbajul C ca bază, ci un alt limbaj de programare - Basic. The software este gratuit. Pentru a lucra cu el există tutoriale bune, inclusiv cele scrise de creatorii acestui produs.

Există și cele plătite Opțiuni Arduino IDE. Unul dintre acestea este programul PROGROMINO. Principalul său avantaj este capacitatea de a completa codul automat. Când compilați un program, nu va mai trebui să căutați informații în cărțile de referință. Programul în sine vă va oferi opțiuni posibile folosind una sau alta procedură. Setul ei include multe altele caracteristici interesante, care lipsesc în programul original și vă pot facilita lucrul cu plăcile.

Concurenți Arduino

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

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

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

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

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