După ce te-ai familiarizat cu elementele de bază ale Arduino, precum și după ce ai scris un program „ Salut Lume! Este timpul să vă familiarizați cu un limbaj de programare.
Structura limbajului se bazează în primul rând pe C/C++, astfel încât cei care au programat anterior în acest limbaj nu vor avea dificultăți de învățare. Programare Arduino. Alții ar trebui să învețe informații de bază despre comenzile de control, tipurile de date și funcții.
O mare parte din informațiile conținute aici vor fi compatibile cu orice curs C/C++, ținând cont de diferențele dintre tipurile de date, precum și de câteva instrucțiuni specifice privind programarea portului I/O.
Bazele
Câteva lucruri formale, adică cele despre care toată lumea le știe, dar uneori uită...
ÎN Arduino IDE, ca și în C/C++, trebuie să fiți conștient de cazurile de caractere. Cuvinte cheie, cum ar fi dacă, pentru sunt întotdeauna scrise în litere mici. Fiecare instrucțiune se termină cu „;”. Punctul și virgulă îi spune compilatorului care parte să interpreteze ca instrucțiune.
Parantezele (..) sunt folosite pentru a desemna blocuri de program. Le folosim pentru a constrânge corpuri de funcții (vezi mai jos), bucle și instrucțiuni condiționale.
Este o bună practică să adăugați comentarii la conținutul programului, acest lucru face codul ușor de înțeles. Comentariile pe o singură linie încep cu // (bară oblică dublă). Comentariile pe mai multe linii încep cu /* si se termina cu */
Dacă vrem să includem orice bibliotecă în programul nostru, folosim comanda include. Iată exemple de conectare a bibliotecilor:
#include
Funcții în Arduino
O funcție (subrutină) este parte separată programe care efectuează anumite operații. Funcțiile sunt folosite pentru a simplifica programul principal și pentru a îmbunătăți lizibilitatea codului. Este util să folosim funcții, deoarece le putem folosi cu ușurință în multe dintre proiectele noastre.
Un curs standard de programare conține informații despre funcții care vor fi prezentate în articolele următoare. În cazul lui Arduino, funcțiile vor fi discutate la început pentru că chiar cel mai simplu program trebuie să aibă două funcții speciale. Acest lucru a fost deja menționat în articolele anterioare, dar aici sistematizăm aceste informații.
Declarație de funcție
Diagrama de declarare a funcției arată astfel:
Tastați nume_funcție(parametru) ( // instrucțiuni pentru execuție (corpul funcției) return (/* return value*/); )
tip este numele oricui tip disponibil date despre limba dată programare. Vom furniza o listă de tipuri disponibile la programarea Arduino într-un articol separat.
După execuție, funcția va returna valoarea tipului declarat. Dacă funcția nu acceptă nicio valoare returnată, atunci tipul de date va fi „void”.
nume_funcție permite identificarea acestuia în mod unic. Pentru a apela (a rula) o funcție, îi dăm un nume.
parametru— parametru de apel de funcție. Parametrii nu sunt necesari, dar sunt adesea utili. Dacă scriem o funcție care nu are argumente, plecăm paranteze rotunde gol.
În paranteze „(…)” se află corpul real al funcției sau instrucțiunii pe care dorim să o executăm. Vom oferi o descriere a instrucțiunilor specifice într-un articol separat.
Toate funcțiile care returnează o valoare se termină cu o instrucțiune return urmată de valoarea returnată. Numai funcțiile declarate cu un pointer nul ("void") nu conțin o instrucțiune return. Trebuie să știți că instrucțiunea return termină funcția, indiferent de locație.
Mai jos sunt câteva exemple de declarații de funcție.
Void f1() ( //corpul funcției) —————————————— int minus() ( //corpul funcției returnare (0); ) ———————————— ——— int plus(int a, int b) ( return (a+b); )
După cum puteți vedea din exemple, o declarație de funcție poate lua mai multe forme, în funcție de nevoile dvs.
Vă recomandăm insistent să învățați și să utilizați funcțiile când scrieți programe proprii. De-a lungul timpului, fiecare programator acumulează propria bibliotecă de funcții „pentru toate ocaziile”, ceea ce face mai ușor și mai rapid să scrieți programe noi.
Acum că știm cum să scriem propria noastră funcție, trebuie să învățăm cum să o folosim.
Apelarea unei funcții
Scriem toate funcțiile într-un singur fișier/program. Există, desigur, o soluție mai elegantă, dar vom încerca să o descriem data viitoare.
Odată ce declarăm o funcție, o putem folosi în alte funcții cu numele corespunzător și orice parametri necesari. Mai jos sunt exemple de apelare a funcțiilor pe care le-am dat mai sus:
F1(); plus(2,2); y=plus(1,5);
După cum puteți vedea în exemple, un apel de funcție se face prin specificarea numelui și a numărului necesar de parametri. Este important să apelați întotdeauna o funcție așa cum este declarată.
Dacă funcția f1() este declarată fără parametri, atunci nu se poate specifica niciun parametri la apelarea acesteia, adică. apelarea f1(0) va fi incorectă.
Funcția plus(int a, int b) necesită exact doi parametri, deci nu este posibilă apelarea cu unul sau trei parametri.
Apelarea y=plus(1,5) va executa funcția „plus” cu parametrii „1” și „5” și va stoca valoarea returnată în variabila „y”.
funcțiile setup() și loop().
Cu cunoștințe despre declararea și apelarea funcțiilor, putem trece la sistem Funcții Arduino: înființat()Și buclă(). Arduino IDE este necesar pentru a declara aceste două funcții.
setup() este o funcție care este apelată automat atunci când alimentarea este pornită sau este apăsat butonul RESET.
După cum sugerează și numele, este folosit pentru a seta valorile inițiale ale variabilelor, declarațiile de intrări și ieșiri ale sistemului, care sunt de obicei specificate în parametrii initiali. Datorită specificității sale, această funcție nu returnează o valoare și nu este apelată cu parametri. Declarația corectă a funcției setup() este mai jos:
Void setup () ( // corpul funcției - inițializarea sistemului)
loop() este o funcție care este apelată buclă nesfârșită. Această funcție de asemenea, nu returnează o valoare și nu este apelat cu parametri. Declarația corectă a funcției loop() este prezentată mai jos:
Buclă goală () ( // corpul funcției - codul programului )
După cum puteți vedea, declarația funcției loop() este identică cu declarația funcției setup(). Diferența constă în performanța acestor funcții de către microcontroler.
Vom analiza acum următorul pseudocod:
Void setup () ( on_led1 (); //porniți led1 off_led1 (); //opriți led1) void loop () ( on_led2 (); //porniți led2 off_led2 (); //opriți led2)
Există două instrucțiuni în funcția setup(): prima aprinde led1 conectat la placă (de exemplu pin 13) și a doua stinge led1.
Funcția loop() are instrucțiuni identice pentru a porni și opri LED-ul2 conectat la placă (de exemplu, pinul 12).
Ca urmare a rulării programului, led1 va clipi o dată, în timp ce led2 se va aprinde și se va stinge atâta timp cât Arduino este pornit.
Apăsarea butonului RESET va face ca ledul 1 să clipească din nou și ledul 2 să clipească din nou continuu.
Rezuma:
- Funcțiile setup() și loop() sunt funcțiile sistemului, care trebuie definite în fiecare proiect. Chiar și în situația în care nu scriem niciun cod într-una dintre ele, trebuie totuși să declarăm aceste două funcții;
- Funcția setup() este executată o dată, loop() este executată continuu;
- Ne creăm propriile funcții într-un singur fișier;
- Putem apela funcțiile noastre atât din setup() și loop(), cât și din alte funcții;
- Funcțiile noastre proprii pot fi apelate cu parametri și returnează o valoare;
- Un apel de funcție trebuie efectuat în conformitate cu declarația sa.
Această lecție oferă cunoștințele minime necesare pentru a programa sistemele Arduino în C. Puteți doar să o vizualizați și apoi să o utilizați ca informații generale. 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 se întâmplă setările inițiale variabile, registre. 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.
Variabila este o celulă memorie cu acces aleator, î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, pentru un contor care numără până la 100, nu ar trebui să selectați tip lung. 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 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ă, o puteți seta valoarea initiala(inițializați).
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”
La operatii aritmetice Cu tipuri diferite apar date conversie automată tipuri 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 verifică condiția din paranteze și execută expresia ulterioară sau blocarea î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ă niciunul nu se potrivește valoarea anterioară
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 pentru bucle, 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 de tip 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.
obiectivul principal design exterior Programs 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).
Arduino este o placă de dezvoltare gata de utilizat și un limbaj de programare foarte simplu, care face ușor să începeți cu microcontrolere cu prețul dimensiunii și vitezei programului. Recent, Atmel a adăugat suport pentru bootloader-ul Arduino în AVR Studio, adică puteți scrie și încărca programe scrise în C, C++ sau Assembler fără un programator. Mai mult, puteți scrie cod în limbajul de procesare/cablare în AVR Studio.
Recomand să începeți citirea articolului cu actualizarea la sfârșit!
În acest articol vă propunem instrucțiuni pas cu pas la instalarea software-ului de programare Arduino folosind AVR Studio. Am luat ca bază o recenzie a extensiilor AVR Studio de pe site-ul easyelectronics.ru. Vom rula toate exemplele pe placa noastră.
Instalarea Arduino IDE
Folosim Arduino versiunea 1.5.2. Îl puteți descărca de pe site-ul oficial. Ultima versiune(1.6.2-r2 la momentul scrierii) din anumite motive nu funcționează cu microcontrolerul Atmega8.
Veți descărca o arhivă zip cu mediul deja implementat. Tot ce rămâne este să-l despachetezi în directorul programului.
Instalarea Atmel Studio
UPD
Văd că subiectul este popular și vreau să clarific câteva puncte.
Există trei moduri în care am încercat să programez o placă compatibilă cu Arduino în C:
- Scrieți direct în Arduino IDE în C. Trebuie să înțelegeți că Procesarea/Wiring nu este un limbaj, ci pur și simplu un set de macrocomenzi și biblioteci. Când scrieți în el, se uită în anteturile sale, vă convertește codul care poate fi citit de om în C și apoi se compilează cu compilatorul standard AVR GCC. Dacă scrieți cod în C, atunci acesta nu va accesa bibliotecile sale și va compila imediat totul așa cum ar trebui, DAR!... în același timp, linkerul va adăuga la proiectul dvs. orice dorește. Avantajul este că nu aveți nevoie de altceva decât de IDE-ul Arduino. Dezavantajul este magia, care este ascunsă de dezvoltator. Această metodă este adesea folosită în cazurile în care este necesară implementarea unei funcții pe care prietenii noștri italieni nu au prevăzut-o în limba lor.
- Metoda propusă în acest articol (de fapt, cea mai ciudată, deoarece îmbină toate neajunsurile). Din punct de vedere ideologic, această extensie este necesară pentru a programa în Procesare/Wiring și pentru a utiliza Atmel Studio ca interfață. Există, de asemenea, o funcționalitate plătită care vă permite să depanați codul, dar nu am încercat-o. Deci, în esență, la programare, totul se întâmplă la fel ca în prima opțiune, dar lucrezi într-un IDE diferit. În același timp, din punct de vedere al rezultatului, obțineți același lucru. Dacă ați programat Arduino și ați decis să o faceți în C, nu ezitați să scrieți direct în IDE-ul Arduino. Dacă nu vă place interfața, puteți folosi un editor normal (recomand Sublime Text). Dacă lucrați în Atnel Studio și doriți să vă flashați placa direct din interfața sa sau să scrieți Procesare/Cablare în ea (brusc!), atunci acest supliment este pentru dvs. Apropo, studioul funcționează doar sub Windows, adică metoda nu este pentru toată lumea. Am scris acest articol doar pentru că am găsit o metodă nouă pentru mine, dar nu-mi place.
- A treia metodă, mi se pare, este cea mai bună pentru un utilizator avansat. La început, totul se întâmplă ca de obicei - scrieți codul, îl compilați și obțineți un fișier hex. Apoi, amintindu-ți că aveți o placă obișnuită de depanare cu un bootloader în mâini, descărcați un utilitar care poate accesa acest bootloader și vă poate transfera codul în memorie. Am postat deja instrucțiuni pas cu pas. În acest caz, dezvoltatorul primește control maxim asupra tuturor funcțiilor, dar pot apărea probleme din cauza utilizării unui bootloader terță parte.
Aș dori să dezvălui încă un lucru care se întâmplă în Arduino. Orice ai face, Arduino IDE va porni cu siguranță perifericele în sine. De exemplu, va porni temporizatoarele. Și dacă doriți să lucrați cu ei în C, s-ar putea să descoperiți că nu funcționează așa cum vă așteptați. Și asta ar putea deveni problema reala. Și există multe astfel de exemple, adică există multe potențiale greble, cârje și bug-uri.
Dacă pur și simplu încărcați un fișier hex, atunci problemele pot apărea numai din cauza bootloader-ului. Până acum am găsit doar unul - după ce bootloader-ul este finalizat, UART rămâne activat. Dacă scrieți prin Arduino IDE, atunci acesta se va insera în codul dvs. pentru a-l dezactiva și cine știe ce altceva. Dacă vrei doar să-ți alergi hex, atunci nu vei obține controlul asupra picioarelor UART. Va trebui să adăugați manual o dezactivare UART la proiectul dvs. Acest artefact și exemplele de cod sunt descrise în detaliu în .
Ei bine, în concluzie. Majoritatea plăcilor compatibile cu Arduino au un conector pentru un programator ISP. Dacă cumpărați acest programator de la chinezi cu 3-4 dolari, veți uita rapid de toate aceste probleme.
Vom fi foarte bucuroși dacă ne susțineți resursa și ne vizitați magazinul de produse.
Î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 mult sfat prost, dar nu o vom urmări î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. Pe sisteme diferite va arata diferit. 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 ne încărcăm în Arduino orice schițați și priviți 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ă ale tale editor 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
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!
Acest simulator funcționează cel mai bine pe browserul Chrome
Să aruncăm o privire mai atentă la Arduino.
Arduino nu este un computer mare care poate fi conectat la circuite externe. Arduino Uno 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ă și 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, de asemenea, 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 dispozitivele externe, fie să primească date de la dispozitive. Următorii pini de pe placă sunt etichetați A0-A5. Acestea sunt intrări analogice care pot primi 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 pot fi activate separat.
Cum se utilizează o placă de dezvoltare.
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. Schema de conectare electrică este 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 ce 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 acest exemplu, este utilizat un rezistor 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 schiță. 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 un circuit LED la unul dintre pinii digitali ai Arduino și îl vom porni și opri folosind un program și, de asemenea, veți învăța 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 apă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 modificaț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); //jumătate de luminozitate (127/255 ~= 0,5) întârziere (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//oprire întârziere LED (1000);/ /pauză 1 sec analogWrite(ledPin, 63); //sferturi de luminozitate (63/255 ~= 0,25) întârziere (1000);//pauză 1 sec digitalWrite(ledPin, LOW);//stinge LED-ul întârziere (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 să folosiți bucla FOR pe care am folosit-o mai devreme.
ÎN exemplul următor sunt folosite două cicluri, unul 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 rula 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.
Prin includerea diferitelor LED-uri cu 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); digitalWrite(rosu, LOW); delay(500); //pornire/oprire LED-ul verde digitalWrite(verde, HIGH); delay(500); digitalWrite(verde, LOW); delay(500); // pornește/oprește LED-ul albastru digitalWrite(albastru, HIGH); delay(500); digitalWrite(albastru, LOW); delay(500); )
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 la întâmplare.
//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, aleatoriu (256)); analogWrite (verde, aleatoriu (256)); întârziere (1000);// așteptați o secundă)
Aleatoriu(256)-se intoarce Număr aleatoriuîn intervalul de la 0 la 255.
Se atașează o schiță care va demonstra tranziții netede culori 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 scriindu-l pe al tău functie auxiliara, 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 definiția funcției bucată cu bucată. Funcția este numită fader si are doua 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
gol.
Î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 în acest caz, nu limitează curentul, ci „trage” butonul la 0V (GND). Acestea. până când butonul este apăsat pe pinul Arduino la care este conectat, se va întâmpla nivel scăzut. 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 port serial) void loop())( if (digitalRead(buttonPin)==HIGH)(//dacă butonul este apăsat Serial.println(„apăsat”); // imprimă „apăsat” ) else ( Serial.println(„neapăsat” ); // altfel "nepresat" ) )
Există mai multe comenzi noi în această schiță.
-aceasta comanda ia valoarea High ( nivel inalt) și scăzut (nivel scăzut), ieșirea pe care o verifică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 cei mai 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"); ) altfel ( digitalWrite(ledPin, LOW);//oprire dacă butonul nu este apăsat Serial.println("ne apăsat"); ) )
