Director de funcții Arduino. Arduino - Managing Operatori

Acest simulator funcționează cel mai bine în browserul Chrome
Să ne uităm la Arduino pe atent.

Arduino este NE. computer mare.La care pot fi conectate lanțuri externe. ATMEGA 328P folosită în Arduino Uno
Acesta este cel mai mare cip de la bord. Acest cip efectuează programe stocate în memoria sa. Puteți descărca programul prin USB cu folosind Arduino. IDE. port USB Oferă, de asemenea, putere Arduino.

Există un conector de alimentare separat. Pe tablă există două ieșiri desemnate 5V și 3.3V, care sunt necesare pentru a alimenta diferite dispozitive. De asemenea, veți găsi contacte marcate ca GND, acestea sunt concluziile Pământului (Pământul este 0b). Platforma ARDUINO, are, de asemenea, 14 concluzii digitale (pini) marcate cu numere de la 0 la 13, care sunt conectate la nodurile externe și au două stări mari sau mici (pornire sau oprire). Aceste contacte pot funcționa ca iesiri sau ca intrări, adică Acestea pot fie să transfere unele date și pot gestiona dispozitive externe sau pot primi date de la dispozitive. Următoarele concluzii la bord sunt indicate A0-A5. Acestea sunt intrări analogice care pot primi date de la diferiți senzori. Acest lucru este deosebit de convenabil atunci când trebuie să măsurați un anumit interval, cum ar fi temperatura. Intrările analogice au funcții suplimentarecare pot fi utilizate separat.

Cum se utilizează taxa de sex masculin.

Cabinetul este necesar pentru a conecta temporar elementele, verificați modul în care dispozitivul funcționează, înainte de a vă desființa toți împreună.
Toate exemplele următoare sunt asamblate pe lot, astfel încât să puteți efectua rapid modificări ale diagramei și să reutilizați părțile fără a îngheța cu lipirea.

Există rânduri de găuri în camionul de depozitare în care puteți introduce piese și fire. Unele dintre aceste găuri sunt conectate electric unul cu celălalt.

Cele două rânduri superioare și inferioare sunt conectate printr-un rând de-a lungul întregii plăci. Aceste rânduri sunt folosite pentru a alimenta puterea asupra schemei. Poate fi 5V sau 3.3V, dar în orice caz, primul lucru pe care trebuie să-l faceți este conectarea 5V și GND pe cardul de depozitare, așa cum se arată în figură. Uneori, aceste conexiuni de rând pot fi întrerupte în mijlocul plăcii, atunci dacă aveți nevoie, le puteți conecta, așa cum se arată în imagine.

Găurile rămase situate în mijlocul plăcii sunt grupate cu cinci găuri. Acestea sunt folosite pentru a conecta detaliile sistemului.

Primul lucru pe care îl conectăm la microcontrolerul nostru este un LED. Circuitul conexiunilor electrice este prezentat în imagine.

De ce aveți nevoie de un rezistor în schemă? Î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 va eșua. Pentru a afla ce valoare nominală ar trebui să fie un rezistor cu ajutorul legii Ohm. Pentru cei care nu știu sau au uitat, Legea Ohm spune că există o dependență liniară a curentului de tensiune. Aceștia, cu atât mai mult facem tensiune la rezistență, cu atât mai multe fluxuri curente prin ea.
V \u003d i * r
Unde V.- Diferența pe rezistență
I.- curent prin rezistență
R.- Rezistența la găsire.
În primul rând, trebuie să învățăm tensiunea la rezistență. Cele mai multe LED-uri 3mm sau 5mm, pe care le veți folosi, aveți o tensiune de lucru de 3B. Aceasta înseamnă că trebuie să plătim pe rezistor 5-3 \u003d 2b.

Apoi calculăm curentul care trece prin rezistență.
Cele mai multe LED-uri de 3 și 5 mm strălucesc luminozitatea completă la un curent de 20mA. Curentul mai mult decât acest lucru poate fi depășit, iar puterea inferioară actuală va reduce luminozitatea lor fără a provoca nici un rău.

Deci, vrem să pornim LED-ul în lanțul 5V, astfel încât să existe un curent de 20mA. Deoarece toate părțile sunt incluse într-un lanț pe rezistor va fi, de asemenea, un curent de 20mA.
Primim
2b \u003d 20 ma * r
2b \u003d 0,02A * r
R \u003d 100 ohm
100 ohmi Aceasta este rezistența minimă, este mai bine să utilizați un pic mai mult, deoarece LED-urile au o anumită variație a caracteristicilor.
ÎN acest exemplu Folosit rezistor 220 ohmi. Doar pentru că autorul are multe dintre ele: Wink :.

Introduceți condusul în deschiderile din mijlocul plăcii astfel încât ieșirea sa lungă să fie conectată la una dintre concluziile rezistorului. Cel de-al doilea capăt al rezisorului este conectat de la 5V, iar a doua ieșire LED este conectată cu GND. LED-ul ar trebui să se aprindă.

Rețineți că există o diferență în modul de conectare a LED-ului. Curentul curge de la o ieșire mai lungă la un număr mai scurt. În diagramă, acest lucru poate fi reprezentat că curentul curge spre cealaltă parte unde este îndreptată triunghiul. Încercați să întoarceți LED-ul și veți vedea că nu va străluci.

Dar cum veți conecta rezistorul, nu există nicio diferență deloc. Puteți să-l transformați sau să încercați să vă conectați la o altă ieșire a LED-ului, acesta nu va afecta funcționarea schemei. El va limita în continuare curentul prin LED.

Anatomia arduino schiță.

Programe pentru schița de apel Arduino. Ele constau din două funcții de bază. Funcţie înființat. și funcția. Buclă.
În interiorul acestei caracteristici veți specifica toate setările de bază. Ce concluzii vor lucra la intrare sau ieșire care biblioteci să se conecteze, să inițializeze variabilele. Funcţie Înființat () Începe doar o singură dată în timpul schiței când începe programul.
Aceasta este funcția principală care se efectuează după înființat (). De fapt, acesta este programul însuși. Această caracteristică va fi nesfârșită până când opriți alimentarea.

Arduino clipește LED.

În acest exemplu, conectăm schema LED la una dintre concluziile digitale Arduino și o vom dezactiva și o dezactiva utilizând programul, precum și veți afla mai multe funcții utile.

Această caracteristică este utilizată în înființat () parte a programului și servește la inițializarea concluziilor pe care le veți folosi ca intrare (INTRARE) sau ieșire (Ieșire). Nu veți putea citi sau scrie date de la Pina până când îl instalați în consecință pinmode.. Această caracteristică are două argumente: numarul pin- Acesta este numărul de Pina, pe care îl veți folosi.

Mod.- Deoarece PIN-ul va funcționa. Pe intrare (INTRARE) sau ieșire (Ieșire). Pentru a aprinde LED-ul trebuie să depunem un semnal DE Arduino. Pentru a face acest lucru, configuram PIN pentru a ieși.
- Această caracteristică este utilizată pentru a seta o stare. (Stat) Pina. (Numarul pin). Există două state principale (în general 3), un lucru Înalt, Pinul va fi 5V, celălalt este Scăzut. Și pe Pinea va fi 0b. Aceasta înseamnă că trebuie să lăsăm LED-ul pe Pinea, conectat la LED-ul pentru a stabili un nivel ridicat. Înalt.

Întârziere. Acesta servește la întârzierea activității programului la perioada specificată în MSEK.
Mai jos este codul care provoacă intermitent LED-ul.
// LED-ul clipește int LEDPIN \u003d 7; // PIN ARDUINO la care LED-ul VOID () LED (LEDPIN, ieșire); // Instalarea Pina ca ieșire) Loop () (DigitalWrite (Ledpin, High); // Întârzierea LED (1000); // întârziere 1000 msek (1 sec) digital (LEDPIN, scăzut); // Opriți LED-ul de întârziere (1000); // așteptați 1 sec)

Coduri mici.
Rânduri care încep cu "//" Acest comentariu Arduino le ignoră.
Toate comenzile se termină cu un punct de virgulă dacă le uiți, apoi obțineți un mesaj de eroare.

lEDPIN.- Aceasta este o variabilă. Variabilele sunt utilizate în programe pentru stocarea valorilor. În acest exemplu, variabil lEDPIN. Alocă la 7, acesta este numărul de Pina Arduino. Când Arduino în program va întâlni un șir cu o variabilă lEDPIN. El va folosi valoarea pe care am indicat-o mai devreme.
Deci, înregistrarea pinmode (LEDPIN, ieșire) Intrări similare pinmode (7, ieșire).
Dar, în primul caz, este suficient să schimbați variabila și se va schimba în fiecare rând, unde este folosit și în al doilea caz, pentru a schimba variabila, va trebui să faceți schimbări în fiecare echipă.

Prima linie indică tipul de variabilă. Când programați Arduino, este important să declarați întotdeauna tipul de variabile. În timp ce aveți suficient să știți asta Int. Anunță numere negative și pozitive.
Mai jos este simularea schiței. Faceți clic pe Start pentru a vizualiza funcționarea schemei.

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

Controlați mai multe LED-uri.

În acest exemplu, veți învăța cum să gestionați mai multe LED-uri. Pentru a face acest lucru, setați alte 3 LED-uri pe tablă și conectați-le la rezistoarele și ieșirile lui Arduino, după cum se arată mai jos.

Pentru a activa și a dezactiva LED-urile în rândul său. Trebuie să scrieți un program similar cu acesta:
// multi LED-ul clipi int LED1PIN \u003d 4; INT LED2PIN \u003d 5; INT LED3PIN \u003d 6; INT LED4PIN \u003d 7; VOID SETUP () (// Instalarea de pini ca ieșire de pinmode (LED1pin, ieșire); Pinmode (LED2PIN, ieșire); Pinmode (LED3PIN, ieșire); Pinmode (LED4PIN, ieșire); () (DigitalWrite (LED1PIN) ); // întârzierea LED-ului de bun venit (1000); // întârziere 1 sec digital (LED1pin, scăzut); // Excelentă LED-ul de întârziere (1000); // întârziere 1 sec // Faceți același lucru pentru celelalte 3 LED-uri digitalWrite ( LED2PIN, ridicat); // întârzierea LED (1000); // întârziere 1 sec digital (LED2pin, scăzut); // Excelența LED-ul de întârziere (1000); // întârziere 1 sec digital (LED3PIN, HIGH); // Slash Întârzierea LED (1000); // întârziere 1 sec digital (LED3PIN, scăzut); // extinderea LED-urilor de întârziere (1000); // întârziere 1 sec digital (LED4PIN, HIGH); // LED LED de întârziere (1000); // Întârziere 1 sec digital (LED4PIN, scăzut); // extinderea întârzierii LED (1000); // întârziere 1 sec)

Acest program va funcționa perfect, dar aceasta nu este decizia cea mai rațională. Codul trebuie schimbat. Pentru ca programul să lucreze de la momentul în care aplicăm un design numit.
Ciclurile sunt convenabile atunci când trebuie să repetați aceeași acțiune de mai multe ori. În codul de mai sus, repetăm \u200b\u200bliniile

Digital (LED4pin, ridicat); Întârzierea (1000); Digital (LED4pin, scăzut); Întârzierea (1000);
Codul complet de schiță în atașament (Descărcări: 1384)

Ajustarea luminozității LED

Uneori trebuie să schimbați luminozitatea LED-urilor din program. Acest lucru se poate face folosind comanda. analogWrite () . Această comandă include rapid și dezactivează LED-ul că ochiul nu văd acest pâlpâire. Dacă jumătatea de timp este pornită, iar jumătate se oprește, va părea vizual că strălucește jumătate din luminozitatea ei. Aceasta se numește modulare a impulsului (PWM sau PWM în limba engleză). PWM se aplică destul de des, deoarece poate fi controlată printr-o componentă "analogică" utilizând un cod digital. Nu toate concluziile lui Arduino sunt potrivite pentru aceste scopuri. Numai acele concluzii, despre care se constată o astfel de desemnare " ~ ", O veți vedea lângă ieșirile de 3,5,6,9,10,11.
Conectați unul dintre LED-urile dvs. cu una dintre concluziile PWM (autorul este o concluzie 9). Acum rulați intermitența LED-ului, dar mai întâi schimbați comanda digitalWrite () pe analogWrite (). analogWrite () Are două argumente: primul este numărul de ieșire și a doua valoare a PWM (0-255), cu referire la LED-urile pe care le va fi luminozitatea luminescenței și pentru motoarele electrice viteza de rotație. Mai jos este un exemplu exemplu pentru luminozitatea diferită a LED-ului.
// modificarea luminozității INT LEDPIN \u003d 9; // la această ieșire, setarea VOID (pinmode (LEDPIN, ieșire); // inițializarea pinului la bucla de ieșire) () (analogwrite (LEDPIN, 255); / / Luminozitate completă (255/255 \u003d 1) întârziere (1000); // pauză 1 sec digital (LEDPIN, LOW); // Opriți LED-ul de întârziere (1000); // pauză 1 sec analog (LEDPIN, 191); // luminozitate pe 3/4 (191/255 ~ \u003d 0,75) întârziere (1000); // pauză 1 sec digital (LEDPIN, LOW); // Opriți LED-ul de întârziere (1000); // pauză 1 sec analog ( LEDPIN, 127); // Half Lightness (127/255 ~ \u003d 0,5) Întârzie (1000); // pauză 1 sec digital (LEDPIN, LOW); // Opriți LED-ul de întârziere (1000); // pauză 1 sec Analog (LEDPIN, 63); // sfert de luminozitate (63/255 ~ \u003d 0,25) întârziere (1000); // pauză 1 sec digital (LEDPIN, LOW); // Opriți LED-ul de întârziere (1000); // pauza 1 s)

Încercați să modificați valoarea PWM în echipă analogWrite ()Pentru a vedea cum afectează luminozitatea.
Apoi, veți învăța cum să ajustați luminozitatea fără probleme la zero. Puteți, desigur, să copiați o bucată de cod de 255 de ori
Analog (LEDPIN, luminozitate); Întârzierea (5); // luminozitate scurtă \u003d luminozitate + 1;
Dar tu înțelegi - nu va fi practic. Cel mai bine este să folosiți ciclul utilizat mai devreme.
Următorul exemplu utilizează două cicluri, una pentru a reduce luminozitatea de la 255 la 0
pentru (int luminozitate \u003d 0; luminozitate \u003d 0; luminozitate -) (analog (LEDPIN, luminozitate); întârziere (5);)
Întârzierea (5) Folosit pentru a încetini viteza de creștere și reducerea luminozității 5 * 256 \u003d 1280 ms \u003d 1,28 sec.)
În prima linie utilizată " luminozitate-"Pentru ca valoarea luminozității să scadă cu 1, de fiecare dată când se repetă ciclul. Rețineți că ciclul va funcționa atâta timp cât luminozitate\u003e \u003d 0. Prin schimbarea semnului > Pe semnul >= Am pornit 0 în gama de luminozitate. Această schiță este modelată mai jos. Schimbarea fără probleme a luminozității INT LEDPIN \u003d 9; // O setare vid (Pinmode (Ledpin, Ieșire); // PIN inițializare) buclă void () (// crește fără probleme luminozitatea (0 până la 255) pentru (INT Lightness \u003d 0; luminozitate \u003d 0; luminozitate -) (analogire (LEDPIN, luminozitate); întârziere (5); // așteptăm 1 sec // reduce fără probleme luminozitatea (255 la 0) pentru (int Luminozitate \u003d 255; Luminozitate\u003e \u003d 0; Luminozitate -) (analogică (LEDPIN, Luminozitate); Întârzie (5);) Întârzie (1000); // așteptăm 1 sec))
Acest lucru nu este foarte bun, dar ideea este de înțeles.

RGB LED și Arduino

LED-ul RGB este de fapt trei LED-uri de culoare diferită într-un caz.

Inclusiv diferite LED-uri cu luminozitate diferită, puteți combina și obțineți culori diferite. Pentru Arduino, unde gradarea luminozității este de 256, veți primi 256 ^ 3 \u003d 16581375 Culori posibile. De fapt, ei vor fi cu siguranță mai puțin.
LED, pe care vom fi folosit de un catod comun. Acestea. Toate cele trei LED-uri sunt conectate constructiv de catozi la o singură concluzie. Vom conecta această concluzie la ieșirea GND. Concluziile rămase, prin rezistențe restrictive, trebuie să fie conectate la concluziile PWM. Autorul a utilizat concluziile 9-11. În ordine, poate fi controlată de fiecare condus separat. În prima schiță, se arată cum să activați fiecare condus separat.

// RGB LED - Testare // Conexiuni PIN INT RED \u003d 9; int verde \u003d 10; Int albastru \u003d 11; VOID SETUP () (Pinmode (roșu, ieșire); Pinmode (albastru, ieșire); Pinmode (verde, ieșire);) buclă void () (// pornirea / oprirea / dezactivarea LED-ului roșu (roșu, ridicat); întârziere ( 500); DigitalWrite (roșu, scăzut); întârziere (500); // Porniți / opriți LED-ul LED-ului verde (verde, ridicat); întârziere (500); digital (verde, scăzut); întârziere (500); // Activare / dezactivați LED-ul albastru digital (albastru, ridicat); întârziere (500); digital (albastru, scăzut); întârziere (500);)

Următorul exemplu utilizează comenzi analogWrite () Și pentru a obține diferite valori ale luminozității aleatoare pentru LED-uri. Veți vedea culori diferite care se schimbă aleatoriu.
// RGB LED - Culori aleatoare // Conexiuni PIN INT RED \u003d 9; int verde \u003d 10; Int albastru \u003d 11; VOID SETUP () (Pinmode (roșu, ieșire); Pinmode (albastru, ieșire); Pinmode (verde, ieșire);) buclă void () (// alegerea unei analogi de culoare aleatorie (roșu, aleator (256)); analogWrite ( Albastru, aleatoriu (256)); analog (verde, aleatoriu (256)); întârziere (1000); // așteptați o secundă)

Randrom (256)- Se intoarce număr aleatoriu variind de la 0 la 255.
În fișierul de schițe atașat, care va demonstra tranziții netede de culori de la roșu la verde, apoi la albastru, roșu, verde etc. (Descărcări: 381)
Exemplul de schiță funcționează, dar există o mulțime de cod recurent. Puteți simplifica codul scriind propria dvs. funcția auxiliarăcare vor schimba fără probleme o culoare la alta.
Așa va arăta: (Descărcări: 414)
Să luăm în considerare definirea unei funcții în părți. Funcția este numită fADER. Și are două argumente. Fiecare argument este separat printr-o virgulă și are un tip declarat în primul rând al funcției de determinare a funcției: vid catre (int color1, int color2). Vedeți că ambele argumente sunt declarate ca int.și sunt numite nume color1. și color2. Ca variabile condiționate pentru a determina funcția. Nulă. înseamnă că funcția nu returnează nici o valoare, pur și simplu execută comenzi. Dacă ar fi fost necesar să scrieți o funcție care a returnat rezultatul multiplicării, ar arăta astfel:
Int multiplicator (int numar1, int numar2) (int produs \u003d număr1 * Număr2; produs de retur;)
Vă rugăm să rețineți cum am declarat tipul int. Ca un tip de valoare de returnare în schimb
nulă..
În interiorul funcției, echipele pe care le-ați folosit deja în schița anterioară, numai numerele concluziilor au fost înlocuite cu color1. și color2.. Funcția este numită fADER., argumentele sale sunt calculate ca color1 \u003d roșu și color2 \u003d verde.. În arhivă schiță completă folosind funcții (Descărcări: 313)

Buton

În următoarea schiță, un buton va fi utilizat cu contacte normale deschise, fără fixare.

Aceasta înseamnă că, în timp ce butonul nu este apăsat, curentul nu trece prin acesta și după eliberare, butonul revine la poziția inițială.
În diagrama, în plus față de buton, se utilizează un rezistor. În acest caz, nu limitează curentul și "trage în sus" butonul la 0b (GND). Acestea. În timp ce butonul nu este apăsat pe ieșirea Arduino, la care este conectat, va exista un nivel scăzut. Rezistorul utilizat în 10 com.

// determinați apăsarea butonului Int ButtonPin \u003d 7; VOID SETUP () (Pinmode (butonpin, intrare); // Inițializați știfturile de introducere Serial.Bel (9600); // Inițializați portul serial) Loop () (dacă (ButtonPin) \u003d\u003d High) (// Dacă butonul este apăsat de serial.println ("presat"); // afișează inscripția "apăsată") altceva (serial.println ("nepresă"); // altfel "nepresător"))
În această schiță, mai multe echipe noi.
- Această comandă acceptă o valoare ridicată (nivel înalt) și scăzută (scăzută), acea ieșire pe care o verificăm. Pre-In Setup () Această ieșire trebuie să fie configurată la intrare.
; // unde butonul este numărul de ieșire unde este conectat butonul.
Portul serial vă permite să trimiteți mesaje Arduino pe un computer, în timp ce controlerul în sine execută programul. Acest lucru este util pentru depanarea programului, trimiterea de mesaje către alte dispozitive sau aplicații. Pentru a permite transferul de date printr-un port serial (alt nume UART sau USART), trebuie să îl inițializați în Configurare ()

Serial.begin () Are un singur argument este rata de transfer de date între Arduino și un computer.
Sketch folosește o comandă pentru a afișa un mesaj pe ecran în ARDUINO IDE (Instrumente \u003e\u003e Monitor Serial).
- Designul vă permite să controlați progresul programului, fumat mai multe verificări într-un singur loc.
Dacă (dacă) returnează digital, atunci cuvântul "apăsat" este afișat pe monitor. Altfel (altfel) cuvântul "presat" este afișat pe monitor. Acum puteți încerca să activați și să dezactivați LED-ul apăsând butonul.
// buton de detectare a apăsării cu ieșire LED int buttonpin \u003d 7; INT LEDPIN \u003d 8; VOID SETUP () (Pinmode (butonpin, intrare); // De data aceasta vom seta pinul de buton ca pinmode de intrare (LEDPIN, ieșire); Serial.BEGING (9600);) buclă void () (dacă (DigitalReadin) \u003d \u003d Mare) (digital (LEDPIN, HIGHT); Serial.println ("presat");) altceva (digital (LEDPIN, LOW); Serial.println ("nepresător");))

Intrare analogică.

analogi. Vă permite să citiți datele de la unul dintre ieșirile Anduino analogice și afișează o valoare în intervalul de la 0 (0b) până la 1023 (5V). Dacă tensiunea la intrarea analogică este de 2,5V, atunci va fi imprimată 2,5 / 5 * 1023 \u003d 512
analogi. Are un singur argument este un număr de intrare analogic (A0-A5). Următoarea schiță oferă un cod de citire a tensiunii cu un potențiometru. Pentru a face acest lucru, conectați un rezistor alternativ, ieșiri extreme la PIN 5V și GND și ieșirea medie la intrarea A0.

Rulați următorul cod și uitați-vă la monitorul serial, modul în care valorile se schimbă în funcție de rotația mânerului de rezistență.
// Intrare analogică int Potpin \u003d A0; // În acest PINA, puterea centrală a setării VOID () potențiometru este conectată la acest (// pinul analogic în mod implicit este conectat la intrare, deci inițializarea nu este necesară pentru serial. începe (9600);) buclă void () (int Potval \u003d analog (Potpin); // Potval este un număr între 0 și 1023 serial.println (Potval);)
Următoarea schiță combină testul butonului și controlul de natură al luminozității LED-ului. LED-ul va porni de la buton și va controla luminozitatea strălucirii va fi un potențiometru.
// butonul de detectare a apăsării cu ieșire LED și intensitate variabilă int butonpin \u003d 7; int ledpin \u003d 9; Int Potpin \u003d A0; VOID SETUP () (Pinmode (butonpin, intrare); Pinmode (LEDPIN, ieșire); Serial.Bel (9600);) Loop () (dacă (ButtonPin) \u003d\u003d High) (// dacă butonul apăsat int analogval \u003d Analog (POPIN); int scalateval \u003d harta (analogval, 0, 1023, 0, 255); analogWrite (LEDPIN, SCALIDVAL); // Porniți LED-ul cu intensitate setată de Pot Serial.println ("presat");) (DigitalWrite (LEDPIN, LOW); // opriți dacă butonul nu este laudă Serial.println ("nepresător");))

Fiecare limbă de programare are un set de comenzi de control care oferă multiple execuții a aceluiași cod (ciclu), selectarea unui fragment de cod adecvat (condiții) și instrucțiuni pentru ieșirea fragmentului curent al codului.

Arduino IDE împrumutat de la C / C ++ majoritatea controalelor necesare. Sintaxa lor este identică cu C. Mai jos, în cele două cuvinte descriem sintaxa lor.

Dacă operatorul

Operatorul IF vă permite să efectuați un fragment specific al programului, în funcție de rezultatul testului unei condiții specifice. Dacă starea este executată, codul programului va fi executat dacă starea nu este executată, codul programului va fi ratat. Sintaxa comenzii IF este după cum urmează:

Dacă (condiție) (instrucțiune1, instrucțiuni2;)

Condiția poate fi orice comparație a variabilei sau a valorii returnate de funcție. Principalul criteriu pentru condiții dacă este că răspunsul ar trebui să fie întotdeauna sau adevărat (adevărat) sau fals (fals). Exemple de condiții pentru operatorul IF:

Dacă (A! \u003d 2) () dacă (x<10) { } if(znak==’B’) { }

În interiorul parantezelor care sunt speriate în condiții, puteți efectua codul.

Persoanele care încep să studieze programarea fac o greșeală, echivalând valoarea variabilei specificate folosind un semn "\u003d". O astfel de intrare indică în mod clar cesiunea valorii variabilei și, prin urmare, condiția va fi întotdeauna "adevărată", adică, alerga. Verificați dacă variabila este egală cu o valoare specifică, denotă întotdeauna semnul dublu egal cu (\u003d\u003d).

Ca o condiție, puteți utiliza funcția funcției, de exemplu:

Dacă (init ()) (serial.print ("OK");)

Exemplul de mai sus va fi efectuat după cum urmează: În primul pas, funcția Init () este numită. Această caracteristică returnează o valoare care va fi interpretată ca fiind "adevărată" sau "falsă". În funcție de rezultatul comparației, textul "OK" va fi trimis sau nu va fi trimis nimic.

Dacă ... altfel operator

O operator extinsă dacă este un operator dacă ... altcineva. Acesta asigură execuția unui fragment de cod atunci când starea este efectuată (TRUE) și executarea celui de-al doilea fragment de cod dacă starea nu este executată (falsă). Operatorul de sintaxă dacă ... altcineva arată astfel:

Dacă (condiție) (// echipa A) altceva (// echipa b)

Comenzile "A" vor fi executate numai dacă starea este executată, comanda "B" va fi executată atunci când starea nu este executată. Execuția simultană a comenzii "A" și "B" este imposibilă. Următorul exemplu arată cum să utilizați sintaxa dacă ... altfel:

Dacă (init ()) (serial.print ("ok");) altceva (serial.print ("eroare");)

În mod similar, puteți verifica corectitudinea funcției și puteți informa utilizatorul.

Practica obișnuită este negarea condițiilor. Acest lucru se datorează faptului că funcția care este executată corect returnează valoarea 0, iar funcția care a funcționat incorectă din anumite motive returnează o valoare non-zero.

O explicație a unei astfel de "complicații a vieții" este simplă. Dacă funcția este efectuată corect, atunci aceasta este singura informație de care avem nevoie. În cazul unei erori, uneori este necesar să înțelegem ce a mers prost de ce funcția nu este îndeplinită corect. Și aici, numerele diferă de zero vin la salvare, adică folosind coduri digitale, putem determina tipul de eroare. De exemplu, 1 este o problemă cu citirea unei valori, 2 - fără loc în memorie sau pe un disc etc.

În ultimul exemplu modificat, se arată cum să apelați o funcție care returnează zero cu execuția corespunzătoare:

Dacă (! Init ()) (serial.print ("ok");) altceva (serial.print ("eroare");)

Cazul comutatorului operatorului.

Declarația IF vă permite să verificați o singură condiție. Uneori este necesar să se efectueze una dintre acțiunile în funcție de valoarea returnată sau de citire. Pentru aceasta, operatorul de selecție multiplă este un comutator multiplu. Sintaxa comenzii comutatorului este prezentată mai jos:

Comutator (var) (Cazul 1: // Instrucțiune pentru var \u003d 1 pauză; Cazul 2: // Instrucțiune pentru var \u003d 2 pauză; Implicit: // Instrucțiune implicită (dacă var diferă de la 1 și 2))

În funcție de valoarea variabilei variabile, instrucțiunile sunt efectuate în anumite blocuri. Labelul de caz înseamnă începerea blocului pentru valoarea specificată. De exemplu, cazul 1: înseamnă că această unitate va fi făcută pentru valoarea valorilor variabile variabile ale unuia.

Fiecare bloc trebuie completat utilizând comanda de întrerupere. Acesta întrerupe execuția suplimentară a operatorului de comutare. Dacă comanda de întrerupere lipsește, atunci instrucțiunile vor fi efectuate în blocuri ulterioare la comanda de întrerupere. Eticheta implicită nu este obligatorie, ca și altfel în comanda IF. Instrucțiunile situate în blocul implicit sunt efectuate numai atunci când valoarea variabilă variabilă de var nu este potrivită pentru niciun șablon.

Se întâmplă adesea că aceleași instrucțiuni ar trebui efectuate pentru una din mai multe valori. Acest lucru poate fi realizat după cum urmează:

Comutator (x) (Cazul 1: // Instrucțiuni pentru x \u003d 1 pauză; Cazul 2: Cazul 3: Cazul 5: // Instrucțiuni pentru x \u003d 2 sau 3 sau 4 pauză; Cazul 4: // Instrucțiuni pentru X \u003d 4 Break ; Cazul 6: // Instrucțiuni pentru x \u003d 6 pauză; Implicit: // Instrucțiuni implicite (dacă X diferă de la 1,2,3,4,5,6))

În funcție de valoarea variabilei x, va fi efectuată unitatea de instrucțiune corespunzătoare. Repetarea cazului 2: Cazul 3: Cazul 5: Informează compilatorul că dacă variabila X are o valoare de 2 sau 3 sau 5, atunci același fragment de cod va fi efectuat.

Operator pentru

Operatorul este utilizat pentru mai multe coduri. Este adesea necesară completarea acelorași instrucțiuni prin schimbarea numai a valorii unei variabile. Pentru aceasta, ciclul este perfect. Sintaxa comenzii este după cum urmează:

Int i; pentru (i \u003d 0; i<10;i++) { // инструкции для выполнения в цикле }

Primul parametru citat în instrucțiunea este valoarea inițială a variabilei. Un alt element este de a verifica condițiile pentru continuarea executării ciclului. Ciclul se efectuează până când se efectuează condiția. Ultimul element este o modificare a valorii variabilei. Cel mai adesea, creștem sau reducem valoarea (dacă este necesar). În acest exemplu, instrucțiunile conținute în ciclu vor fi efectuate la i \u003d 0 ... 9.

Adesea, variabila utilizată în ciclu este declarată ibid.

Pentru (int i \u003d 0; i<10;i++) { // инструкции для выполнения в цикле }

O variabilă care este utilizată pentru a calcula pașii de ciclu ulterior poate fi utilizată în interiorul acesteia pentru a apela o funcție cu parametrii corespunzători.

Pentru (int i \u003d 10; i\u003e 0; i-) (serial.print (i); // numere 11,9,8,6,5,5,4,3,2,1 vor veni)

Operatorul de roți

Ciclul este ideal în care vrem să calculăm. Într-o situație în care aveți nevoie pentru a efectua anumite acțiuni ca urmare a unui singur eveniment care nu este neapărat previzibil (de exemplu, așteptăm butonul pentru a apăsa butonul), apoi putem folosi instrucțiunea în timp ce efectuează blocul de operare până când starea este efectuată. Întreaga sintaxă a operatorului arată astfel:

În timp ce (condiție) (// bloc de instrucțiuni de execuție)

Este important ca validarea statului să aibă loc la începutul ciclului. Se poate întâmpla astfel încât instrucțiunile din interior ciclul roților Nu executați niciodată. În plus, este posibil să se creeze un ciclu infinit. Să vedem două exemple:

Int x \u003d 2; În timp ce (x\u003e 5) (serial.print (x);) ------------- int y \u003d 5; În timp ce (y\u003e 0) (serial.print (y);)

Primul bloc de operatori, situat în interiorul timpului, nu va fi niciodată finalizat. Variabila X contează două și nu va deveni mai mult 5. În al doilea exemplu, avem de-a face cu un ciclu infinit. Variabila "Y" are o durată de 5, adică mai mult zero. În interiorul ciclului, nu se produce nici o schimbare în variabila "y", astfel încât ciclul nu va fi niciodată finalizat.

Aceasta este o eroare comună când uităm să schimbăm parametrul care determină terminarea ciclului. Mai jos sunt două exemple corecte de aplicare a ciclului de timp:

Int x \u003d 0; În timp ce (X.<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

În primul exemplu, am avut grijă să schimbăm valoarea variabilei care este verificată în această condiție. Ca rezultat, ciclul va fi vreodată finalizat. În al doilea exemplu, un ciclu infinit a fost creat în mod deliberat. Acest ciclu este echivalent cu funcția de buclă () din Arduino IDE. În plus, în interiorul ciclului, a fost introdus un test, după executarea pe care ciclul este completat de comanda de pauză.

Operatorul face ... în timp ce

Dacă ciclul este un ciclu de timp ... în timp ce ciclul. În plus față de sintaxă, se caracterizează printr-un loc de verificare a stării. În cazul lui ... în timp ce verificarea condițiilor se efectuează după executarea blocului de instrucțiuni. Aceasta înseamnă că blocul de instrucțiuni din organismul ciclului va fi efectuat cel puțin o dată. Mai jos este sintaxa de ... în timp ce comanda:

DO (// bloc de instrucțiuni) în timp ce (condiție)

Tot ce este scris despre timpul operatorului se aplică și pentru a face ... în timp ce. Mai jos este un exemplu de utilizare a ciclului de lucru ... în timp ce:

Int x \u003d 10; DO (// Blocul de instrucțiuni x-;) în timp ce (x\u003e 0); ------------------ Blocul de instrucțiuni (condiție);) în timp ce (adevărat);

Pauza operatorului

Operatorul de pauză vă permite să ieșiți din ciclu (faceți ... în timp ce, pentru, în timp ce) și ieșiți din opțiunea Comutator. În exemplul următor, luați în considerare executarea comenzii de întrerupere:

Pentru (i \u003d 0; i<10;i++) { if(i==5) break; Serial.print(i); }

Ciclul trebuie executat pentru numere de la 0 la 9, dar pentru numerele 5, se execută o condiție care rulează operatorul de spargere. Acest lucru va duce la ieșirea din ciclu. Ca rezultat, numai numerele 0,1,2,3,4 vor fi trimise la portul serial (serial.print).

Continuați operatorul

Operatorul Continue cauzează terminarea executării instrucțiunilor ciclului (faceți ... în timp ce, pentru, în timp ce) pentru valoarea curentă și trecerea la etapa următoare a ciclului. Următorul exemplu arată modul în care funcționează operatorul continuu:

Pentru (i \u003d 0; i<10;i++) { if(i==5) continue; Serial.print(i); }

Nu este dificil să se observe, ciclul va fi finalizat pentru o valoare de la 0 la 9. Pentru valoarea 5, comanda Continuare va fi executată, ca rezultat al instrucțiunilor care sunt finalizate după această comandă sunt îndeplinite. Ca rezultat, numărul de 0,1,2,3,4,6,7,8,9 este trimis la portul serial (serial.print).

Returnarea operatorului

Declarația de retur completă execuția funcției numite și returnează valoarea unui anumit tip. Ca parametru de comandă, puteți specifica un număr, un caracter sau o variabilă a unui anumit tip. Este important ca valoarea de returnare să corespundă tipului de funcție declarată. Următorul exemplu arată modul de utilizare a declarației de returnare:

INT Checkessor () (dacă (0)\u003e 400) (// Reading Analog Input Return 1; // Pentru valori mai mult de 400 returnează 1 altceva (retur 0; // pentru alții returnează 0))

După cum puteți vedea, într-o singură funcție puteți utiliza mai mulți operatori de returnare, dar numai unul dintre ei va funcționa întotdeauna. Este permisă utilizarea operatorului de returnare fără parametri. Acest lucru permite încetarea timpurie a funcției care nu returnează nicio valoare.

Vid_name_name () (instrucțiuni1; dacă (x \u003d\u003d 0) retur; instrucțiuni2; instrucțiuni3;)

În exemplul de mai sus, instrucțiunea1 va efectua întotdeauna când funcția este numită. Execuția instrucțiunii2 și instrucțiunea3 depind de rezultatul comenzii IF. Dacă starea este executată (TRUE), comanda de retur va fi executată și funcția va finaliza lucrarea.

În cazul în care starea nu este executată, comanda de retur nu este, de asemenea, executată, dar instrucțiunile sunt executate. Instrucțiuni2 și instrucțiuni3, iar funcția își completează funcționarea.

Goto Operator

Din considerații ideologice trebuie să săriți această descriere ... Goto Operator este o comandă care nu trebuie utilizată în programarea convențională. Acesta ridică codul de complicații și este un obicei prost în programare. Recomandăm cu tărie să nu folosim această comandă în programele dvs. Datorită faptului că Goto are în documentația oficială pe site-ul Arduino.cc, îi oferim o scurtă descriere. Goto sintaxă de comandă:

.... Goto Metka; // Du-te la șir cu inscripția "Metka" ... .. .... .... METKA: // Etichetă cu care programul va continua să lucreze ...

Comanda permite tranziția la etichetă indicată, adică la locul în program.

Această lecție oferă cunoștințe minime necesare pentru programarea sistemelor ARDUINO în C. Puteți să o vizualizați și să utilizați mai departe ca informații de referință. Cei care au programat pe C în alte sisteme puteți sări peste articolul.

Repet că aceasta este informațiile minime. Descrierea indicatorilor, claselor, variabilelor de șir etc. vor fi date în lecțiile ulterioare. Dacă ceva este incomprehensibil, nu vă faceți griji. În alte lecții vor exista multe exemple și explicații.

Structura programului Arduino.

Structura programului Arduino este destul de simplă și în realizarea minimă constă din două părți ale configurației () și buclă ().

setup () () () ()

buclă void () ()

Funcția Setup () se efectuează o dată, când porniți puterea sau descărcarea controlerului. De obicei apare în setările inițiale ale variabilelor, registrele. Funcția trebuie să fie prezentă în program, chiar dacă nu există nimic.

După finalizarea configurației (), controlul merge la funcția buclă (). Ea efectuează comenzi înregistrate în corpul ei într-un ciclu infinit (între paranteze curbate). De fapt aceste echipe și fac toate acțiunile algoritmice ale controlorului.

Reguli inițiale de sintaxă C.

; punct şi virgulă Expresiile pot conține multe spații, porții de șir. Un semn de finalizare a expresiei este "punctul cu un semn de virgulă".

z \u003d x + y;
z \u003d x.
+ y;

() Brațe de figură Definiți un bloc de funcție sau expresii. De exemplu, în funcțiile Setup () și Loop ().

/ * ... * / Bloc de comentariiAsigurați-vă că închideți.

/ * Acesta este un bloc de comentarii * /

// comentariu cu o singură linie, nu este necesar să se închidă, valabil până la sfârșitul liniei.

// acesta este un comentariu de rând

Variabile și tipuri de date.

Variabila este o celulă memorie cu acces aleatorîn care sunt stocate informații. Programul utilizează variabile pentru stocarea datelor intermediare de calcul. Pentru calcule, date din diferite formate, biți diferite, astfel încât variabilele din limba C au următoarele tipuri.

Tipul de date.	Pic	Gama de numere
boolean.	8	adevarat fals
char.	8	-128 … 127
caracter nesemnat.	8	0 … 255
byte.	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 pe baza acurateței dorite a calculelor, a formatelor de date etc. Nu, de exemplu, pentru un contor care ia în considerare până la 100, selectați tipul lung. Va funcționa, dar operațiunea va lua mai mult memorie și programe de date, va necesita mai mult timp.

Anunțarea variabilelor.

Tipul de date este indicat și apoi numele variabilei.

int x; // anunțarea unei variabile numite x Int Int
lățime plutitoare; // Anunțarea unei variabile numite Widthbox tip float

Toate variabilele trebuie declarate înainte de a fi utilizate.

Variabila poate fi declarată în orice parte a programului, dar depinde de blocurile de software care pot fi utilizate. Acestea. Variabilele au domenii de aplicare.

• Variabilele declarate la începutul programului înainte de funcția VOID Setup () sunt considerate globale și disponibile oriunde în program.
• Variabilele locale sunt declarate în interiorul funcțiilor sau blocurilor, cum ar fi ciclul și pot fi utilizate numai în blocurile declarate. Există mai multe variabile cu un nume, dar diferite domenii de vizibilitate.

int mod; // variabila este disponibilă pentru toate funcțiile

setup () () () ()
// bloc gol, instalațiile inițiale nu sunt necesare
}

buclă void () ()

număr lung; // Variabila de numărare este disponibilă numai în funcții de buclă ().

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

Când declarați variabila, puteți specifica valoarea inițială (inițializați).

int x \u003d 0; // o variabilă x este declarată cu o valoare inițială de 0
char d \u003d 'a'; // o variabilă D este declarată cu valoarea inițială egală cu codul de simbol "A"

În operațiile aritmetice cu diferite tipuri de date, tipurile de date sunt convertite automat. Dar este mai bine să folosiți întotdeauna o transformare explicită.

int x; // variabil int.
char y; // caractere variabile.
int z; // variabil int.

z \u003d x + (int) y; // variabila Y este convertită în mod clar în Int

Operatii aritmetice.

Operațiuni de relație.

Operațiunile logice.

Operațiuni pe pointeri.

Operațiuni de biți.

&	ȘI
|	SAU
^	Excluzând sau
~	Inversiune.
<<	Schimbare la stânga
>>	Trecerea la dreapta

Operațiuni de atribuire mixtă.

Selectați Opțiuni, Management de program.

Dacă operatorul Verifică starea în paranteze și efectuează o expresie sau un bloc ulterior în paranteze curbate, dacă starea este adevărată.

dacă (x \u003d\u003d 5) // dacă x \u003d 5, atunci z \u003d 0
z \u003d 0;

dacă (x\u003e 5) // dacă x\u003e
(z \u003d 0; y \u003d 8;)

Dacă ... altfel. Vă permite să alegeți între două opțiuni.

dacă (x\u003e 5) // dacă x\u003e 5, atunci se efectuează blocul z \u003d 0, y \u003d 8;
{
z \u003d 0;
y \u003d 8;
}

{
z \u003d 0;
y \u003d 0;
}

Altfel. - vă permite să faceți o alegere multiplă

dacă (x\u003e 5) // dacă x\u003e 5, atunci se efectuează blocul z \u003d 0, y \u003d 8;
{
z \u003d 0;
y \u003d 8;
}

altfel dacă (x\u003e 20) // Dacă x\u003e 20, această unitate este executată
{
}

altfel // În caz contrar, această unitate este efectuată.
{
z \u003d 0;
y \u003d 0;
}

Schimbați carcasa. - Alegere multiplă. Vă permite să comparați variabila (în exemplul I) cu mai multe constante (în exemplul 5 și 10) și efectuați un bloc în care variabila este egală cu constanta.

comutator (x) (

cazul 5:
// codul se efectuează dacă x \u003d 5
Pauză;

cazul 10:
// codul se efectuează dacă x \u003d 10
Pauză;

mod implicit:
// Codul se efectuează dacă nu a coincis o valoare anterioară
Pauză;
}

Ciclu pentru. Designul vă permite să organizați cicluri cu un anumit număr de iterații. Sintaxa arată astfel:

pentru (acțiune înainte de începerea ciclului;
Continuarea continuă a ciclului;
Acțiunea la sfârșitul fiecărei iterație) (

// Ciclul codului de cod

Un exemplu de ciclu de 100 iterații.

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

{
Sum \u003d sum + i;
}

În timp ce ciclul. Operatorul vă permite să organizați cicluri cu un design:

În timp ce (expresie)
{
// Ciclul codului de cod
}

Ciclul este efectuat atâta timp cât expresia în paranteze este adevărată. Un exemplu de ciclu pentru 10 iterații.

x \u003d 0;
În timp ce (X.< 10)
{
// Ciclul codului de cod
X ++;
}

Face în timp ce - ciclu cu condiție la ieșire.

do.
{
// Ciclul codului de cod
) În timp ce (expresie);

Ciclul este efectuat până când expresia este adevărată.
Pauză - Operatorul de ieșire din ciclu. Folosit pentru a întrerupe execuția pentru, în timp ce face cicluri.

x \u003d 0;
În timp ce (X.< 10)
{
dacă (z\u003e 20); // Dacă z\u003e 20, ieșiți din ciclu
// Ciclul codului de cod
X ++;
}

Mergi la. - Operator de tranziție necondiționată.

goto Metka1; // Tranziția la Metka1
………………
metka1:

Continua. - Sari peste operatorii la capătul corpului ciclului.

x \u003d 0;
În timp ce (X.< 10)
{
// Ciclul codului de cod
dacă (z\u003e 20) continuă; // Dacă z\u003e 20, reveniți la începutul corpului ciclului
// Ciclul codului de cod
X ++;
}

Matrice.

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

Se declară o matrice.

int veacuri; // matrice de 10 variabile tip Int

greutate plutitoare; // matrice de 100 de variabile tip float

Când declarați matricile pot fi inițializate:

iNT AGE \u003d (23, 54, 34, 24, 45, 56, 23, 23, 27, 28);

Aplicați la variabilele de arme ca aceasta:

x \u003d vârste; // x i se atribuie o valoare de 5 elemente de matrice.
Vârste \u003d 32; // 9 Un element de matrice este setat la 32

Numerotarea elementelor de matrice 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 pentru care este cauzat;
• argumente - date pe care funcția le utilizează pentru a calcula;
• tipul de date returnat prin funcție.

Funcția utilizatorului este descrisă în afara funcțiilor de configurare () și buclă ().

setup () () () ()
// cod executat o singură dată când începe programul
}

buclă void () ()
// cod principal, efectuat în ciclu
}

// anunțarea unei funcții de utilizator numită funcție de funcție
Tipul de funcție (tip argument1, tip argument1, ..., tip argument)
{
// Funcția corpului
Întoarcere ();
}

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

int sumqwadr (int x, int y)
{
Retur (x * x + y * y);
}

Apelul funcției se întâmplă:

d \u003d 2; b \u003d 3;
z \u003d sumqwadr (d, b); // în Z va fi suma pătratelor variabilelor D și B

Funcțiile sunt încorporate, personalizate, conectate.

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

Ultimul lucru pe care vreau să-l spun în această lecție, așa cum este obișnuit să execute programe pe C. Cred că dacă citiți această lecție pentru prima dată, merită să săriți această secțiune și să reveniți mai târziu când va face posibilă.

Scopul principal al designului programului extern este îmbunătățirea lizibilității programelor, reducerea numărului de erori formale. Prin urmare, pentru a atinge acest obiectiv, puteți încălca în siguranță toate recomandările.

Numele din C.

Numele reprezentând tipurile de date trebuie să fie scrise într-un registru mixt. Prima literă a numelui trebuie să fie titlul (registrul de sus).

Semnal, timecount.

Variabilele trebuie înregistrate prin nume în registrul mixt, prima literă a liniei (litere mici).

Rubrica :. Puteți adăuga la marcaje.

După familiarizarea cu elementele principale ale Arduino, precum și scrierea programului "Bună ziua!" Este timpul să familiarizați limba de programare.

Structura limbii se bazează în principal pe C / C ++, astfel încât cei care au programat anterior în această limbă nu vor avea dificultăți în a părăsi Programarea Arduino. Restul ar trebui să învețe informațiile de bază despre comenzile de management, tipurile de date și funcțiile.

Majoritatea informațiilor conținute aici vor fi compatibile cu orice curs C / C ++, luând în considerare diferențele de tipuri de date, precum și mai multe instrucțiuni specifice pentru programarea porturilor I / O.

Bazele de bază ale elementelor de bază

Mai multe lucruri formale, adică cele pe care toată lumea le știe, dar uneori uită ...

În ARDUINO IDE, ca în C / C ++, trebuie să vă amintiți registrele de caractere. Cuvinte cheie, cum ar fi, pentru că sunt întotdeauna scrise în litere mici. Fiecare instrucțiune se încheie la ";". Un punct și virgulă raportează un compilator, care parte să interpreteze ca instrucțiuni.

Parantezele (...) sunt utilizate pentru a desemna blocuri software. Le folosim pentru a limita funcția corpului (vezi mai jos), cicluri și operatori condiționali.

Bună practica este de a adăuga comentarii la conținutul programului, ajută la înțelegerea cu ușurință a codului. Comentariile cu o singură linie încep cu // (Linia dublă de scufundare). Comentariile multi-line încep cu /* și se termină */

Dacă vrem să conectăm orice bibliotecă în programul nostru, folosim comanda include. Iată exemple de legare a bibliotecilor:

#Include. // Biblioteca Standard #include "Svoya_Biblioteka.h" // Biblioteca din catalogul de proiect

Funcții în Arduino.

Funcția (subrutina) este o parte separată a programului care efectuează unele operații. Funcțiile sunt utilizate pentru a simplifica programul principal și pentru a îmbunătăți lizibilitatea codului. Utile pentru a utiliza funcțiile, deoarece le putem folosi cu ușurință în multe dintre proiectele noastre.

Cursul de programare standard conține informații despre funcțiile care dau următoarele articole. În cazul lui Arduino, funcțiile vor fi discutate la început, deoarece chiar și cel mai simplu program ar trebui să aibă două funcții speciale. Acesta a fost deja menționat în articolele anterioare, dar aici sistematizăm aceste informații.

ADEMINAREA DE ATENȚIE

Caracteristicile sistemului de declarație după cum urmează:

Tipul funcției_name (parametru) (// Instrucțiuni pentru execuție (funcție corporală) Return (/ * valoare returnare * /);)

un fel - acesta este numele oricărui tip de date disponibile această limbă Programare. Lista tipurilor disponibile la programarea Arduino Să vedem într-un articol separat.

După execuție, funcția va returna valoarea tipului anunțat. În cazul în care funcția nu acceptă nicio valoare de returnare, tipul de date va fi "gol".

numele funcției. Permite identificarea fără echivoc. Pentru a apela (rula) funcția, îi dăm un nume.

parametru - Parametrul apelului funcției. Parametrii nu sunt necesari, dar adesea sunt utile. Dacă scriem o funcție care nu are argumente, lăsăm paranteze rotunde goale.

În interiorul parantezelor "(...)" conține corpul real al funcției sau instrucțiunile pe care vrem să le îndeplinim. Descrierea instrucțiunilor specifice indică într-un articol separat.

Toate funcțiile care revin la valoarea sunt completate de operatorul de returnare, urmată de valoarea returnată. Numai funcțiile declarate de indicatorul zero ("VOID") nu conțin operatorul de returnare. Este necesar să știți că declarația de retur completă performanța funcției, indiferent de locație.

Mai jos sunt câteva exemple de declarații de funcții.

Void F1 () (// funcție de corp) -------------- int minus () (// returnarea funcției corpului (0);) --------- --- int plus (int a, int b) (return (A + B);)

După cum puteți vedea în exemple, declarația de funcții poate lua diverse forme în funcție de nevoile dvs.

Vă recomandăm cu tărie să explorați și să aplicați funcții atunci când vă scrieți propriile programe. De-a lungul timpului, fiecare programator își câștigă propria bibliotecă de funcții "pentru toate ocaziile", ceea ce face mai ușor și accelerează procesul de scriere a programelor noi.

Acum că știm cum vă puteți scrie propria dvs. funcție, trebuie să învățați să o utilizați.

Funcția apelului

Toate funcțiile înregistrăm într-un singur fișier / program. Există, desigur, o soluție mai elegantă, dar vom încerca să o descriem data viitoare.

Anunță funcția, o putem folosi în alte funcții cu numele corespunzător și cu oricare dintre parametrii necesari. Mai jos sunt exemple de a apela funcțiile pe care le-am condus mai sus:

F1 (); Plus (2.2); y \u003d plus (1.5);

După cum puteți vedea în exemple, apelul funcției este efectuat prin specificarea numelui său și a numărului necesar de parametri. Este important să apelați întotdeauna o funcție în conformitate cu anunțul său.

Dacă funcția F1 () este declarată fără parametri, atunci niciun parametrii nu pot fi specificați atunci când se numește, adică. Apelarea funcției F1 (0) va fi incorectă.

Funcția plus (int a, int b) necesită doar doi parametri, astfel încât apelul cu unul sau trei parametri este imposibil.

Apelul y \u003d plus (1.5) va fi executat cu funcția "Plus" cu parametrii "1" și "5" și salvează valoarea de returnare la variabila "Y".

Funcțiile de configurare () și buclă ().

Având cunoștințe despre declararea și apelarea funcțiilor, putem merge la funcțiile sistemului Arduino: înființat () și buclă (). Arduino IDE B. obligatoriu Este necesar să se declare aceste două funcții.

configurarea () este o funcție care se numește automat când alimentarea este pornită sau apăsând butonul de resetare.

În conformitate cu numele său, este utilizat pentru a seta valorile inițiale ale variabilelor, intrările și ieșirile de sistem, care sunt de obicei setate în parametrii inițiali. Datorită specificității sale, această caracteristică nu returnează valori și nu este numită de parametri. Declarația corectă de configurare () este prezentată mai jos:

VOID SETUP () (// funcția corpului - inițializarea sistemului)

loop () este o funcție care este numită într-un ciclu infinit. Această caracteristică nu returnează valori și nu este numită parametrii. Declarația corectă a funcției LOOP () este prezentată mai jos.

Void bucla () (// funcția corpului - codul programului)

După cum puteți vedea, declararea funcției LOOP () este identică cu Declarația funcției Setup (). Diferența este de a efectua aceste funcții cu un microcontroler.

Acum analizăm următorul pseudocod:

VOID SETUP () (ON_LED1 (); // Porniți LED-ul LED1 OFF_LED1 (); // Opriți bucla LED1 LED1) (ON_LED2 (); // Porniți LED2 OFF_LED2 () LED; // Opriți LED-ul LED2)

În funcția Setup () există două instrucțiuni: Primul pornește LED-ul LED1 conectat la placă (de exemplu, contactul 13), iar al doilea se oprește LED-ul LED1.

Funcția LOOP () are instrucțiuni identice pentru pornirea și oprirea LED-ului LED2 conectat la placă (de exemplu, contactați 12).

Ca urmare a lansării programului LED1 LED, LED-ul va clipi o singură dată, în timp ce LED2 se va aprinde și va ieși până când Arduino este pornit.

Apăsarea butonului de resetare va duce la faptul că LED1 va bloca din nou o dată, iar LED2 va începe din nou să clipească.

Rezuma:

• Funcțiile de configurare () și buclă () sunt funcții de sistem care trebuie definite în fiecare proiect. Chiar și într-o situație în care într-unul dintre ele nu scriem niciun cod, trebuie să declarăm că aceste două funcții;
• Funcția de configurare () este executată o singură dată, buclă () este efectuată continuu;
• Noi creăm funcții proprii într-un singur fișier;
• Putem apela funcțiile noastre atât din configurație (), cât și din buclă () și din alte funcții;
• Funcțiile noastre pot fi numite cu parametri și valoare de returnare;
• Apelul funcției trebuie efectuat în conformitate cu declarația sa.

Baza limbajului de programare a modulului Arduino este limba SI (mai degrabă S ++). Mai precis, acest dialect de limbă se numește procesare / cablare. Bună revizuire a limbii pe care o veți găsi în aplicație. Și vreau să spun mai mult despre limba, ci despre programare.

Programul este un tip de comenzi pe care procesorul înțelege procesorul calculatorului dvs. sau procesorul Microcontrolerului Module Arduino nu este important. Procesorul citește comenzile și le îndeplinește. Orice echipe pe care procesorul înțelege că sunt numerele binare. Acestea sunt doar numere binare și nimic altceva. Prin efectuarea operațiunilor aritmetice pentru care procesorul este o dată și intenționat, procesorul funcționează cu numere. Numere binare. Și se pare că ambele echipe și ceea ce aparțin sunt doar numere binare. Ca aceasta. Dar cum înțelege procesorul acest "grămadă" numere binare?

În primul rând, toate aceste numere binare sunt scrise în celulele de memorie seriale care au adrese. Când descărcați programul și începe să funcționeze, procesorul primește prima adresă a programului, unde trebuie înregistrată comanda. Aceste comenzi care necesită operațiuni de procesoare cu numere au "identificarea semnelor", de exemplu, că în următoarele două numere de memorie două numere care trebuie să fie pliate. Și contorul, numind contorul de comenzi, unde se înregistrează adresa următoarei comenzi, în acest caz mărește adresa astfel încât programul să aibă următoarea comandă în această adresă. În cazul în care programul sau eșecurile programului sau eșecurilor, procesorul poate fi confundat, iar apoi, după citirea numărului în locul echipei, procesorul nu face ceva care ar trebui să facă și programul "îngheață".

Astfel, orice program este o secvență de numere binare. Și programarea este abilitatea de a înregistra corect secvențele corecte de numere binare. De mult timp, a început să utilizeze unelte speciale care sunt numite limbi de programare.

Cu toate acestea, orice program trebuie mai întâi nevoie de o înțelegere clară a ceea ce ar trebui să facă programul și pentru ceea ce este necesar. Cei mai clară înțelegeți acest lucru, cu atât este mai ușor să creați un program. Programe mici, deși este dificil de spus care programe sunt mici și care nu sunt, pot fi considerate în întregime. Programele mai complexe sunt împărțite mai bine în părți care pot fi văzute ca programe independente. Deci, este mai bine să creați, mai ușor de depanat și să verificați.

Nu sunt gata să mă cert, dar cred că programul este mai convenabil pentru a începe cu descrierile în limba obișnuită. Și în acest sens, cred că programele nu ar trebui să fie confundată cu scrierea codului programului. Când programul este descris prin cuvinte convenționale, este mai ușor să determinați, de exemplu, ce limbă de programare pentru a selecta un cod de program.

Cel mai apropiat de înregistrarea programului utilizând numerele binare, limba de asamblare. Se caracterizează prin respectarea comenzilor lingvistice pentru echipele binare, procesor de înțeles. Dar codificarea programelor pe asamblare necesită un efort mare și mai aproape de artă decât operațiunile formale. Mai versatil și mai ușor de aplicat limbi de nivel înalt ca Baisik sau C. Și pentru o lungă perioadă de timp, o limbă grafică este utilizată pentru a înregistra programe în general, iar recent "traducători" au apărut din această limbă la limbajul procesorului.

În plus față de limbile de programare a limbajului, a existat întotdeauna o anumită specializare a limbilor de programare și a existat limbi specializate. Ultimul l-aș lua și limba de programare a modulului Arduino.

Tot ce trebuie să spuneți modulul astfel încât să ne facă ceva necesar, organizat într-un set convenabil de comenzi. Dar la început despre ceea ce avem nevoie de Arduino?

Modulul poate fi folosit în diferite calități - aceasta este inima (sau capul) robotului, este baza dispozitivului, acesta este un designer convenabil pentru a stăpâni cu microcontrolere etc.

Mai sus, am folosit deja programe simple pentru a verifica conexiunea modulului la computer. Cineva poate părea prea simplu și, prin urmare, nu este interesant, dar orice programe complexe constau în fragmente mai simple similare cu cele cu care ne-am familiarizat deja.

Să vedem ce ne putem spune cel mai mult program simplu "LED complet".

int ledpin \u003d 13;

pinmode (LEDPIN, ieșire);

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

În primul rând, să ne amintim ce este condus. În esență, aceasta este o diodă obișnuită care, datorită designului său, atunci când fluxul curent în direcția înainte, începe tranziția. Asta este că LED-ul este aprins, trebuie să curgi prin el și, înseamnă că LED-ul trebuie aplicat la LED. Și astfel încât curentul nu depășește valoarea admisă, în seria cu LED-ul, trebuie inclus un rezistor, care se numește limitare curentă (a se vedea apendicele A, ieșirea digitală). Tensiunea la LED aplică un microcontroler, care este baza modulului Arduino. Microcontrolerul, cu excepția procesorului care efectuează comenzile noastre, are unul sau mai multe porturi I / O. Fără a intra în considerare dispozitiv specific Portul, să spunem - când ieșirea portuară funcționează la ieșire, acesta poate fi reprezentat ca o ieșire digitală cu două stări, pornită și oprită (există o tensiune la ieșire, fără tensiune la ieșire).

Dar aceeași ieșire a portului poate lucra și ca intrare. În acest caz, acesta poate fi trimis, de exemplu, ca o intrare digitală a cipurilor - un nivel logic, ridicat sau scăzut (a se vedea apendicele A, Input digital).

Pe măsură ce clipește LED-ul:

Activați ieșirea portului. Opriți ieșirea portului.

Dar procesorul funcționează foarte repede. Nu vom avea timp să vedem clarificarea. Pentru a vedea acest lucru clipește, trebuie să adăugăm pauze. I.E:

Activați ieșirea portului. Pauză 1 secundă.

Opriți ieșirea portului.

Pauză 1 secundă.

Acesta este programul nostru. Procesorul citește prima comandă și pornește ieșirea, LED-ul se aprinde. Procesorul va întrerupe în funcțiune și va opri ieșirea, LED-ul va ieși. Dar el clipea o singură dată.

Repetarea oricărui proces sau a comenzilor setate se numește programare a ciclului. Au folosit diferite tipuri de cicluri. Există un ciclu care este efectuat setați numărul timp. Acesta este un ciclu pentru. Există cicluri care sunt executate până când se efectuează o condiție, care face parte din proiectarea limbii a ciclului. Și dacă starea nu este niciodată finalizată, ciclul se efectuează un număr infinit de ori. Acesta este un ciclu infinit.

Nu cred că microcontrolerele sunt utilizate cu programele de tip, care este de mai sus. Adică, mai multe comenzi sunt executate o dată pe controlerul nu funcționează. De regulă, funcționează constant imediat ce tensiunea de alimentare este furnizată. Și înseamnă că microcontrolerul ar trebui să funcționeze într-un ciclu infinit.

Aceasta este ceea ce bucla de buclă void (), bucla este o buclă, un ciclu închis. Condițiile de încetare a ciclului nu sunt, și, prin urmare, nu există condiții pentru finalizarea acestuia.

În plus, trebuie să raportăm modulul Arduino, care portul de ieșire și modul în care vrem să folosim, să ieșim (ieșire) sau de intrare (intrare). Acest obiectiv este funcția VOID Setup (), care este obligatorie pentru limba Arduino, chiar dacă nu este utilizată și comanda Pinmode (), pentru a specifica modul de ieșire.

pinmode (LEDPIN, ieșire);

Și totuși, designul lingvistic utilizează variabile pentru a determina numărul de ieșire:

int ledpin \u003d 13;

Utilizarea variabilelor este convenabilă. Decid că nu veți folosi nici o ieșire 13 și 12, veți face o schimbare numai într-o singură linie. Este deosebit de puternic afectat în programe mari. Numele variabili poate fi ales la discreția sa, dar, de regulă, ar trebui să fie doar simbol, și adesea numărul de caractere este limitat. Dacă interpretați greșit numele variabilei, cred că compilatorul vă va corecta.

Caracteristica digital (LEDPIN, HIGH) stabilește ieșirea specificată într-o stare de nivel înalt, adică, se aprinde de ieșire.

Și întârziere (1000), după cum ați înțeles deja, înseamnă pauză în 1000 milisecunde sau 1 secundă.

Rămâne să înțelegeți ce console, cum ar fi INT, nul. Orice valori, orice variabile sunt plasate în memorie ca comenzile programului. În celulele de memorie, numerele sunt adesea scrise din 8 biți. Aceasta este octetul. Dar Byte este numere de la 0 la 255. Pentru a scrie numere mari, aveți nevoie de doi octeți sau mai mult, adică două sau mai multe celule de memorie. Pentru ca procesorul să fie clar cum să găsiți un număr, tipuri diferite Numerele au nume diferite. Deci, numărul numit Byte, va lua mai mult o celulă, int (întreg, întreg). În plus, funcțiile utilizate în limbile de programare sunt, de asemenea, returnate de numere. Pentru a determina ce tip de număr trebuie să returneze o funcție, acest tip de număr returnat este înregistrat înainte de funcție. Dar unele funcții nu pot returna numere, astfel de funcții sunt precedate de intrarea în vid (a se vedea apendicele A, variabilele).

Acesta este cât de mult poate spune un program interesant.

Toate acestea sperăm că ați citit în aplicație. Și acum vom face experimente simple folosind doar ceea ce deja știm din capacitatea limbii. În primul rând, înlocuiți-vă tipul variabil Int, care ia o mulțime de spațiu în memorie, pe octeți - un loc, o celulă de memorie. Să vedem ce reușim.

byte LEDPIN \u003d 13;

pinmode (LEDPIN, ieșire);

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

După compilarea și descărcarea programului la modul, nu vom observa modificările din program. Bine. Apoi voi schimba programul pentru a observa schimbări în activitatea sa.

Pentru a face acest lucru, vom înlocui numărul în funcție de variabila de întârziere (1000), apelându-l pe My_del. Această variabilă trebuie să fie un număr întreg, adică Int.

int my_del \u003d 5000;

Nu uitați să terminați fiecare echipă cu o virgulă. Faceți modificări la program, compilați-l și porniți în modul. Apoi schimbați variabila și repetați compilarea și încărcarea:

byte my_del \u003d 5000;

Diferența, sunt sigur că veți obține tangibil.

Vom face un alt experiment cu schimbarea duratei pauzei. Reducerea duratei pauzelor va fi efectuată, de cinci ori. Vom întrerupe timp de 2 secunde, iar apoi vom crește aceleași de cinci ori. Și din nou vom întrerupe timp de 2 secunde. Ciclul efectuat de câte ori este apelat ciclu pentru Și este scris:

pentru (int i \u003d 0; i<5; i++)

ceva care este efectuat în ciclu pentru

Pentru a executa ciclul, are nevoie de o variabilă, avem acest lucru, variabila de care aveți nevoie pentru a seta valoarea inițială pe care am acordat-o. Apoi urmează condiția de finalizare a ciclului, avem mai puțin de 5. și înregistrarea i ++ este caracteristică înregistrării C a unei creșteri a variabilei pe unitate. Figura Suporturile limitează setul de comenzi care urmează să fie executate în ciclu. În alte limbi de programare, pot exista și alte limitări pentru a evidenția blocul de cod funcțional.

În interiorul ciclului, efectuăm la fel ca înainte, cu schimbări minore:

pentru (int i \u003d 0; i<5; i++)

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

my_del \u003d my_del - 100;

Am vorbit despre schimbarea înregistrării pauzei, iar schimbarea pauzei în sine este realizată printr-o scădere a variabilei cu 100.

Pentru cel de-al doilea ciclu, vom scrie același bloc de cod, dar variabila duratei de pauză va crește cu 100.

pentru (int i \u003d 0; i<5; i++)

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

Ați observat că înregistrarea unei scăderi a pauzei și creșterea acestuia arată diferită. Aceasta este, de asemenea, o caracteristică a limbii Si. Deși pentru claritate, a fost necesară repetarea acestei intrări prin schimbarea numai a semnului minus pe plus. Deci, obținem un astfel de program:

int ledpin \u003d 13;

int my_del \u003d 1000;

pinmode (LEDPIN, ieșire);

pentru (int i \u003d 0; i<5; i++)

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

pentru (int i \u003d 0; i<5; i++)

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

Copiați codul programului nostru în programul Arduin, compilați-l și conduceți-l în modul. Schimbarea duratei pauzei este vizibilă. Și va fi și mai vizibil, încercați, dacă terminați ciclul, spuneți doar 8.

Ceea ce am făcut acum face și programatorii profesioniști - având un program gata, poate fi ușor modificat sub nevoile sau dorințele dvs. Prin urmare, ei stochează toate programele lor. Ce vă sfătuiesc să faceți și pe voi.

Ce am pierdut în experimentul tău? Nu am comentat munca noastră. Pentru a adăuga un comentariu, fie o linie oblică dublă "dreaptă, fie unică, dar cu stele (a se vedea apendicele A). Vă sfătuiesc să o faceți singur, pentru că revenind la program după un timp, sunteți mai ușor să vă dați seama dacă vi se explică faptul că faceți într-un anumit loc al programului. Și îl sfătuiesc, de asemenea, într-un dosar cu fiecare program pentru a stoca descrierea în limba obișnuită, realizată în orice editor de text.

Cel mai simplu program de a "îngheța LED-ul" poate servi chiar și pentru o duzină de experimente (chiar și cu un LED). Mi se pare că această parte a muncii, inventați că puteți face totuși un interesant, cel mai interesant. Dacă vă referiți la aplicația în care este descrisă limba de programare, în secțiunea "Management de program", puteți înlocui ciclul pentru un alt tip de ciclu. Și încercați cum funcționează alte tipuri de cicluri.

Deși procesorul microcontrolerului, ca oricare altul, poate produce calcule (pentru aceasta și a inventat-o), iar acest lucru este utilizat, de exemplu, în dispozitivele, încă cea mai caracteristică a microcontrolerului va seta ieșirea portului la un nivel ridicat sau scăzut Statul, adică "face un LED", ca o reacție la evenimentele externe.

Despre evenimente externe Microcontrolerul va cunoaște în principal la starea intrărilor. Configurarea concluziilor portului la intrarea digitală, o putem urmări. Dacă starea inițială de intrare este un nivel ridicat, iar evenimentul determină intrarea într-o stare scăzută, atunci putem face ceva, răspunzând la acest eveniment.

Cel mai simplu exemplu este introducerea butonului. Când butonul nu este apăsat, introduceți în stare ridicată. Dacă apăsați butonul, intrarea intră într-o stare scăzută și putem "aprinde" LED-ul de ieșire. Data viitoare când apăsați butonul LED pe care îl puteți plăti.

Acesta este un exemplu simplu de un program simplu. Chiar și începător, poate părea neinteresantă. Cu toate acestea, acest program simplu poate găsi destul de util. Voi da un singur exemplu: nu vom aprinde LED-ul după ce am făcut clic pe buton, dar fuzionând (într-un anumit mod). Și LED-ul va lua cu radiații infraroșii. Ca rezultat, vom obține panoul de control. Iată un program atât de simplu.

În diferite versiuni ale programului există diferențe în lista exemplelor. Dar vă puteți referi la manualul de limbă din aplicația în care există un exemplu și o schemă a programului (în secțiunea Exemple denumită "Anexă") pentru a lucra cu introducerea. Voi copia programul:

int ledpin \u003d 13;

pinmode (LEDPIN, ieșire);

pinmode (Inpin, intrare);

dacă (DigitalCead (Inpin) \u003d\u003d High)

digitalwrite (LEDPIN, HIGH);

digital (LEDPIN, scăzut);

Și, după cum vedeți, obținem un program complet nou, modificând cel vechi. Acum, LED-ul va clipi numai când este apăsat butonul, care este atașat la ieșire 2. Concluzia 2 printr-un rezistor de 10 kΩ este atașat la firul general (Land, GND). Butonul este un capăt atașat la tensiunea de alimentare + 5V și un alt capăt la ieșirea 2.

În program, întâlnim o nouă structură de limbă dacă din secțiunea de gestionare a programului. Se citește astfel: dacă o condiție este satisfăcută (închisă în paranteze), atunci programul este executat în parantezele curbate. Vă rugăm să rețineți că în această condiție (Inpin) \u003d\u003d mare) Egalitatea de intrare este foarte executată utilizând două semne de egalitate! Foarte adesea în grabă despre el este uitat, iar starea este incorectă.

Programul poate fi copiat și descărcat în modulul Arduino. Cu toate acestea, pentru a verifica funcționarea programului, trebuie să faceți unele modificări ale designului modulului. Cu toate acestea, depinde de varietatea modulului. Modulul original are o priză pentru conectarea la plăcile de extensie. În acest caz, puteți introduce fire potrivite potrivite pentru conectorii doritori. Modulul meu are contacte cuțite pentru a vă conecta cu plăcile de extensie. Pot să caut un conector adecvat, fie, care este mai ieftin, utilizați panoul de microcircitate corespunzător în cazul DIP.

A doua întrebare - Cum să găsiți concluziile din modulul care sunt utilizate în program?

Cu această întrebare vă va ajuta să găsiți imaginea pe care am luat-o de pe site: http://roobocraft.ru/.

Smochin. 4.1. Locația și scopul concluziilor controlerului și modulului Arduino

Toate concluziile modulului meu Craftduino sunt marcate, astfel încât găsirea concluziei corecte nu va fi dificilă. Puteți conecta butonul și rezistența și puteți verifica funcționarea programului. Apropo, pe site-ul Robocraft anterior, întregul proces este afișat în imagini (dar programul nu utilizează destul de astfel de concluzii!). Vă sfătuiesc să vă uitați.

Mulți microcontrolere din compoziția lor au dispozitive hardware suplimentare. Deci, ATMEGA168, pe baza cărora Modulul Arduino asamblat are un UART, un bloc încorporat pentru comunicarea cu alte dispozitive care utilizează un schimb de date consistent. De exemplu, cu un computer prin portul COM. Sau cu un alt microcontroler utilizând unitatea UART încorporată. Există, de asemenea, un convertor analog-digital. Și formatorul de modulare latitudinală.

Utilizarea acestuia ilustrează programul pe care îl copiez și de la site-ul Robocraft. Dar programul poate fi luat din aplicație. Și poate că este în exemplele programului Arduino.

// Fading condus de Barragan

iNT Value \u003d 0; // variabil pentru stocarea valorii dorite

int ledpin \u003d 9; // LED conectat la pinul digital 9

// nu este nevoie să apelați funcția Pinmode

pentru (valoare \u003d 0; valoare<= 255; value+=5) // постепенно зажигаем светодиод

analog (LEDPIN, valoare); // Valoarea de ieșire (de la 0 la 255)

Întârzierea (30); // căutând 🙂

pentru (valoare \u003d 255; valoare\u003e \u003d 0; value- \u003d 5) // treptat Gasim LED

analog (LEDPIN, valoare);

Dacă în noul program anterior pentru noi a existat o funcție digitalDalread (INPIN), citirea intrării digitale, apoi în acest program o nouă funcție analogică (LEDPIN, valoare), deși parametrii acestei funcții sunt deja familiarizați cu variabilele americane. Pe utilizarea intrării analogice, utilizând ADC (convertorul analog-digital), vom vorbi mai târziu. Și acum vom reveni la problemele generale de programare.

Programarea este ceva care este disponibil tuturor, dar timpul va trebui să stăpânească și să programeze și orice limbă de programare. Astăzi există o serie de programe care ajută la învățarea acelui programare. Și unul dintre ele este direct legat de modulul Arduino. Se numește zgâriet pentru Arduino sau S4a abreviată. Puteți găsi și descărca acest program la: http://seaside.citilab.eu/scratch/arduino. Nu știu cum numele programului este tradus cu precizie, dar "a începe de la zero" este tradus ca "începe de la zero".

Pe site-ul proiectului S4A există versiuni pentru Windows și Linux, dar pentru cel mai recent sistem de operare gata de instalare a programului în versiunea de distribuție Debian. Nu vreau să spun că nu poate fi folosit cu alte distribuții Linux, dar la început vom vedea cum să lucrăm în program cu modulul Arduino din Windows.

După instalarea programului, interfața în limba rusă poate fi configurată în mod obișnuit folosind comutatorul de limbă.

Smochin. 4.2. Comutator de limbă de interfață program

Prima pictogramă a barei de instrumente Dacă faceți clic pe, afișează toate limbile posibile de interfață a programului. Limba rusă poate fi găsită în secțiunea ...

Smochin. 4.3. Lista de limbi de utilizare în interfața de program

... marcate ca "mai mult ...".

Dacă nu faceți nimic, atunci inscripția din fereastra dreaptă "Caută Board ..." rămâne, dar modulul nu este localizat. Pentru a conecta modulul Arduino la S4A, ar trebui să descărcați încă ceva de pe site-ul proiectului.

Smochin. 4.4. Descărcare fișier la modulul Arduino pentru S4A

Acest fișier nu este altceva decât un program pentru Arduino (schiță). Acesta este, un fișier text care poate fi copiat pentru editorul Arduino, compilați și încărcați la modul. După părăsirea programului Arduino, puteți rula programul S4A și acum modulul este localizat.

Smochin. 4.5. Conectarea unui modul la program

Intrările analogice ale modulului nu sunt conectate, precum și digitale, prin urmare, valorile afișate pentru modulul se schimbă în mod constant aleatoriu.