Revizuire/Design/Editare: Myakishev E.A.

Mediu de dezvoltare (IDE) Arduino

Mediu de dezvoltare integrat Arduino(alias IDE Arduino) conține un editor de text pentru scrierea codului, o zonă de mesaje, o consolă de text, o bară de instrumente pentru butoane (pentru cele mai comune funcții) și mai multe meniuri. In afara de asta, IDE Arduino se poate conecta la placi ArduinoȘi Genuino, iar acest lucru este necesar, de exemplu, pentru încărcarea schițelor și comunicarea dintre utilizator și componenta hardware Arduino.

Scrierea schițelor

Programe scrise în mediul de dezvoltare Arduino, se numesc schite. Sunt scrise într-un editor de text IDEși sunt salvate în fișiere cu extensia *.eu nu. Editorul are funcții pentru tăierea/lipirea și căutarea/înlocuirea textului. Zona de mesaje oferă feedback la salvarea și exportul schițelor și, de asemenea, afișează erori. Consola afișează date text care provin de la IDE, inclusiv mesaje de eroare complete și alte informații. Colțul din dreapta jos al ferestrei afișează placa și portul serial configurat în prezent. Butonul din bara de instrumente vă permite să inspectați, să încărcați, să creați, să deschideți și să salvați schițe, precum și să deschideți monitorul serial.

Notă. Versiuni IDE Arduino inainte de 1.0 salvați schițele cu extensie *.pde. Cu toate acestea, în versiune 1.0 Puteți deschide în continuare aceste schițe, dar când salvați vi se va cere să acordați o extensie acestor schițe *.eu nu.

Butoanele din bara de instrumente:

Comenzi suplimentare IDE Arduino pot fi găsite în meniu Fişier, Editați | ×, Schiță, InstrumenteȘi Ajutor. Aceste meniuri sunt sensibile la context, de ex. ele vor fi disponibile numai dacă sunt relevante pentru munca efectuată.

Meniul Fișier:

• Nou– Creează o nouă instanță a unui editor de text, care va avea deja codul minim pentru a crea o nouă schiță.
• Deschis– Vă permite să descărcați o schiță căutând-o în unități și foldere de pe computer.
• Deschideți recent– Oferă o listă scurtă de schițe deschise recent care sunt gata de plecare.
• Dosar cu schițe (Sketchbook)– Afișează schițele în prezent în folderul schițe (de ex. "caiet de schițe"). Dacă faceți clic pe numele oricăreia dintre schițele afișate, aceasta se va deschide imediat într-o copie nouă IDE Arduino.
• Exemple– Toate exemplele și bibliotecile incluse în software vor fi afișate aici. IDE Arduino. Toate exemplele sunt structurate într-o formă de arbore, ceea ce vă permite să găsiți rapid subiectul sau biblioteca dorită.
• Închide– Închide instanța curentă IDE Arduino.
• Salvați– Salvează schița sub numele curent. Dacă fișierul nu a fost încă denumit, un nume va fi sugerat în fereastră "Salvează ca...".
• Salvați ca... (Salvați ca...)– Vă permite să salvați schița curentă sub un alt nume.
• Configurare pagina– Afișează o fereastră „Setări pagini” pentru a imprima o schiță pe o imprimantă.
• Imprimare– Trimite schița curentă către imprimantă în conformitate cu setările specificate în meniu „Setări pagini”.
• Preferințe– Deschide o fereastră „Setări”, unde puteți ajusta unele setări în consecință IDE Arduino. De exemplu, limba interfeței.
• Părăsi– Închide toate ferestrele IDE Arduino. Totuși, când fugi IDE Arduino data viitoare, toate schițele care au fost deschise făcând clic pe "Ieșire", se va redeschide automat.

Meniu Editare:

• Anulați/Refaceți- Echipa "Anulare" returnează lucrarea în editorul de text cu unul sau mai mulți pași înapoi și "Întoarcere" vă permite să mergeți înapoi înainte.
• A tăia– Îndepărtează fragmentul de cod selectat și îl plasează în buffer.
• Copie– Duplică fragmentul de cod selectat și îl plasează în buffer.
• Copie pentru forum– Copiază fragmentul de cod selectat în buffer, aducându-l simultan în forma adecvată pentru publicare pe forum (împreună cu evidențierea sintaxei color).
• Copiați ca HTML– Copiază fragmentul de cod selectat în buffer în HTML-form pentru a putea fi încorporat în pagini web.
• Pastă– Inserează conținutul bufferului în locația editorului în care se află cursorul.
• Selectează tot– Selectează și afișează tot conținutul editorului de text.
• Adăugați/Ștergeți comentariu (Comentați/Anulați comentariul)– Adaugă sau elimină un caracter de comentariu (de ex. «//»
• Mărire/Reducere indent– Adaugă sau elimină spațiul gol (ca atunci când apăsați un buton "Spaţiu") la începutul fiecărei linii din fragmentul de cod selectat.
• Găsi– Deschide meniul "Găsi", unde tu, prin setarea anumitor parametri, poți specifica textul pe care vrei să-l găsești în schița curentă.
• Găsește următorul– Evidențiază în text următorul fragment căutat (în raport cu poziția cursorului) specificat în meniu "Găsi".
• Găsiți Anterior– Evidențiază în text fragmentul căutat anterior (în raport cu poziția cursorului) specificat în meniu "Găsi".

Meniu schiță:

• Verificați/Compilați– Verifică schița pentru erori prin compilarea acesteia. Datele de scanare, inclusiv utilizarea memoriei și variabilele globale, vor fi afișate în consolă.
– Compilează și descarcă un fișier binar pe placa configurată prin portul configurat.
• Încărcați folosind programator– Suprascrie bootloader-ul de pe placă. Vă permite să utilizați întregul volum pentru schițe Flash-memorie. Pentru a recupera bootloader-ul suprascris și pentru a putea încărca din nou schițele prin serial USB-port, va trebui să utilizați articolul Instrumente > Burn Bootloader. Rețineți că aceasta este o comandă NU ÎNREGISTREAZĂ biți de siguranță - pentru aceasta, din nou, utilizați articolul Instrumente > Burn Bootloader.
• Exportați binarul compilat– Salvează schița în format *.hex, care poate fi stocat ca arhivă sau trimis la bord folosind alte instrumente.
• Afișați dosarul schiță– Deschide folderul de schiță curent.
• Includeți biblioteca– Adaugă o bibliotecă la o schiță folosind o directivă #include, introdus la începutul codului. Citiți mai detaliat mai jos în secțiunea „Biblioteci”. În plus, aici puteți deschide „Manager de bibliotecă”și folosește-l pentru a adăuga din ZIP-noi fișiere de bibliotecă.
• Adăugați fișier... (Adăugați fișier...)– Adaugă un fișier nou la schiță (va fi copiat din locația în care se află în prezent). Noul fișier va apărea într-o filă nouă a ferestrei curente IDE Arduino. Fișierul poate fi șters folosind meniul de marcaje, care se deschide făcând clic pe triunghiul mic situat sub pictograma monitorului portului din partea dreaptă a barei de instrumente.

Meniul Instrumente:

• Formatare automată– Formatează frumos schița, adică îi adaugă indentare, astfel încât bretelele de deschidere și de închidere să fie aliniate, iar operatorii din interiorul bretelelor sunt mai la dreapta.
• Schiță de arhivă– Arhivează o copie a schiței curente către ZIP-fişier. Arhiva este plasată în același director în care se află schița.
• Remediați codificarea și reîncărcarea– Corectează eventualele discrepanțe între harta de caractere a editorului IDE Arduinoși carduri cu simbol ale altora OS.
• Port Monitor (Monitor serial)– Deschide o fereastră de monitorizare a portului și inițiază comunicarea cu orice card conectat prin portul selectat curent. De obicei, aceasta va permite resetarea plăcii, dar numai dacă acceptă resetarea prin deschiderea portului serial.
• Bord– Selectează placa pe care o vei folosi. Descrierile diferitelor plăci pot fi citite mai jos în secțiune „Plăți”.
• Port– Acest meniu afișează toate dispozitivele seriale (reale și virtuale) conectate la placă. Această listă este actualizată automat de fiecare dată când deschideți meniul "Unelte", situat la un nivel superior.
• Programator– Folosit pentru a selecta un programator hardware dacă programarea plăcii sau a cipului nu se efectuează folosind sistemul încorporat USB- conexiune seriala. De regulă, această comandă este rar folosită, dar poate fi utilă, de exemplu, atunci când scrieți un bootloader pe un nou microcontroler.
• Burn Bootloader– Vă permite să scrieți un bootloader pe microcontrolerul plăcii Arduino. În condiții normale de utilizare Arduino sau Genuino această comandă nu este necesară, dar poate fi utilă dacă ați achiziționat un microcontroler nou ATmega(care de obicei vine fără un bootloader). Înainte de a arde bootloader-ul, asigurați-vă că ați selectat placa corectă - acest lucru se face în meniu Instrumente > Placă. Această comandă setează, de asemenea, biții de siguranță necesari.

Meniul de ajutor:

Aici puteți accesa rapid numeroasele documente care vin cu IDE Arduino, adică pot fi citite chiar și fără acces la internet. Sunt articole aici "Pentru incepatori", "Director" după limbă Arduino, ghid IDE etc. Toate aceste documente sunt copii locale ale celor aflate pe site Arduinoși au link-uri pentru a accesa versiunile lor online.

• Găsiți în Referință– Aceasta este singura funcție interactivă din meniu "Ajutor". Vă permite să deschideți direct un articol local despre un element de limbă Arduino, unde cursorul se află în prezent în editorul de text IDE.

Dosar cu schițe (Sketchbook)

Mediu de dezvoltare Arduino folosește ideea unui caiet de schițe, adică un loc specific în care sunt stocate toate programele (sau schițele). Schițele aflate în acest folder pot fi deschise din meniu Fișier > Dosar cu schițe (Fișier > Caiet de schițe) sau prin buton "Deschis" pe bara de instrumente. Un folder cu schițe va fi creat automat la prima pornire IDE Arduino. Puteți vizualiza sau modifica locația caietului de schițe în meniu „Setări”.

Notă: Din versiune 1.0 schițele sunt salvate cu extensia *.eu nu. Anterior au fost salvate în format *.pde. Cu toate acestea, chiar și lucrând cu versiunea 1.0 și mai sus, încă poți deschide PDE-fisare, dar IDE le va redenumi automat în extensie *.eu nu.

Filele

Vă permite să gestionați schițele care conțin mai mult de un fișier (fiecare dintre acestea va fi în propria filă). Acestea pot fi fișiere obișnuite sub formă de cod pentru Arduino(extensia nu este vizibilă), fișiere C (extensia *.c), C++ fișiere (extensie *.cpp) Și "anteturi" fișiere (extensie

Înainte de a încărca schița, trebuie să selectați elementele corecte din meniu Instrumente > PlacăȘi Instrumente > Port. Lista de panouri poate fi găsită mai jos în secțiune „Plăți”. Pe Mac portul serial va fi probabil /dev/tty.usbmodem241(Pentru O.N.U, Mega2560 sau Leonardo), /dev/tty.usbserial-1B1(Pentru Duemilanove si altele devreme USB-modele) sau /dev/tty.USA19QW1b1P1.1(pentru placa serială conectată folosind USB- adaptor serial Keyspan). Pe Windows asta va fi posibil, COM1 sau COM2(pentru placa de serie), COM4, COM5, COM7 sau mai mare (pentru plăci cu USB-conexiune) – a afla, uite USB-dispozitiv serial in Manager de dispozitiv in sectiunea cu porturi. Pe Linux asta trebuie sa fie /dev/ttyACMx, /de/ttyUSBx sau asa ceva. După ce ați selectat portul și placa corecte, faceți clic pe butonul situat pe bara de instrumente sau selectați un element din meniu "Fişier". Placă conectată la IDE, se va reseta automat, după care va începe descărcarea. Pentru modelele mai vechi (adică predecesorii Diecimilia) nu există resetare automată, așa că va trebui să apăsați singur butonul de resetare înainte de a încărca schița. Pe majoritatea plăcilor, după încărcarea schiței, acestea încep să clipească RX- Și TX-LED-uri. În plus, dacă descărcarea are succes, IDE Arduino, iar dacă nu, va afișa o eroare.

Când încărcați o schiță, utilizați instrumentul de încărcare. Arduino– un mic program încărcat în microcontrolerul plăcii dumneavoastră. Vă permite să descărcați cod fără a utiliza hardware suplimentar. Bootloader-ul este activ pentru câteva secunde în timp ce placa este în modul de resetare, apoi rulează schița care a fost încărcată cel mai recent în microcontroler. Când pornește bootloader-ul (adică când placa este în modul de resetare), LED-ul încorporat (al 13-lea) de pe placă va începe să clipească.

Biblioteci

Datorită bibliotecilor, schițele pot fi echipate cu funcționalități suplimentare - de exemplu, pentru lucrul cu echipamente noi sau manipularea datelor. Pentru a utiliza o bibliotecă într-o schiță, selectați-o din meniu Schiță> Includeți biblioteca (Schiță > Includeți biblioteca) . Aceasta va adăuga una sau mai multe directive la începutul schiței.#include și va compila, de asemenea, biblioteca împreună cu schița. Deoarece bibliotecile sunt încărcate pe tablă împreună cu schița, acest lucru crește cantitatea de spațiu pe care o ocupă schița. Dacă biblioteca nu mai este necesară, pur și simplu eliminați directivele #include din partea de sus a codului .

O listă de biblioteci poate fi găsită. Unele biblioteci sunt deja incluse cu IDE Arduino, iar altele pot fi descărcate din diverse surse folosind „Manager de bibliotecă”.

Din versiune 1.0.5 biblioteca poate fi adăugată din ZIP-file și folosește-l într-o schiță deschisă. Instrucțiunile pentru instalarea unei biblioteci terță parte pot fi citite aici. Dacă vrei să-ți scrii propria bibliotecă, citește.

Echipamente de la terți

Suportul pentru echipamente terță parte poate fi adăugat prin crearea unui subfolder hardware în folderele cu schițe. Astfel in IDE puteți adăuga fișiere care conțin informații despre placă (afișate în meniu "A plati"), biblioteci root, bootloadere și informații despre programatori. Pentru a instala platforma, creați un folder hardware, apoi extrageți platforma terță parte în propriul său subdosar. Nu da un nume subdosarului "arduino", deoarece aceasta va suprascrie platforma încorporată Arduino. Pentru a elimina o platformă, pur și simplu ștergeți subdosarul acesteia.

Citiți mai multe despre crearea de pachete pentru echipamente terțe.

Monitor porturi

Aceasta afișează datele care provin de la Arduino/Genuino(atât obișnuite, cât și USB-modele) către un computer printr-o interfață serială. Pentru a trimite date la tablă, introduceți textul și apoi faceți clic pe butonul de trimitere sau pur și simplu apăsați ↵ Enter. În lista derulantă, selectați rata de transfer de date care se potrivește cu viteza specificată în Serial.begin al schiței. Ține minte că pe Windows, MacȘi Linux când este conectat prin intermediul plăcii de monitorizare porturi Arduino/Genuino va efectua o resetare (adică readucerea execuției schiței în poziția inițială). "Vorbi" cu placa puteți, de asemenea, prin Prelucrare, Flash, MaxMSP etc. Citeşte mai mult.

Setări

Unele setări pot fi setate în meniu „Setări”(pe Mac este în meniu Arduino, și pe WindowsȘi Linux- V "Fişier"). Orice altceva se află în fișierul de setări, a cărui locație este indicată în același meniu „Setări”.

Suport lingvistic

Din versiune 1.0.1 , interfață IDE Arduino suporturi peste 30 de limbi. Implicit în IDE Arduino Va fi selectată limba selectată în sistemul dvs. de operare. Dar vă rugăm să rețineți că Windows, și, de asemenea, eventual pe Linux, aceasta este determinată de setările locale de dată și monedă, nu de limba în care "voce" sistem de operare.

Dacă doriți să schimbați manual setările de limbă, rulați IDE Arduinoși deschide fereastra Preferințe. Lângă inscripție va exista un meniu derulant cu o listă de limbi acceptate în prezent. Selectați limba dorită și apoi reporniți IDE Arduino. Dacă limba dvs OS nu este suportat, atunci interfața IDE Arduino va fi tradus automat în engleză.

Pentru a readuce setările de limbă la setările implicite, în meniul drop-down Limbajul editorului trebuie să alegi Defectiune de sistem. Această modificare va intra în vigoare numai după ce reporniți Arduino IDE. De asemenea, dacă ați schimbat setările de limbă OS, apoi pentru a IDE Arduino a apărut o nouă limbă, trebuie și repornită.

Scânduri

Selectarea unei plăci are două efecte: setează parametrii (cum ar fi viteza procesorului și rata de transmisie) utilizați la compilarea și încărcarea schițelor și setează setările de fișiere și biți de siguranță utilizate de comanda de scriere a încărcătorului. Caracteristicile unor plăci diferă doar în ultimii parametri, așa că, chiar dacă totul s-a încărcat cu succes, mai are sens să le verifici înainte de a scrie bootloader-ul. Un tabel care compară caracteristicile diferitelor modele poate fi găsit.

Mai jos sunt enumerate plăcile pentru care IDE Arduino există suport încorporat și toate sunt bazate pe nucleu AVR. In afara de asta, „Managerul consiliului”, disponibil în versiune standard IDE Arduino, vă permite să adăugați suport pentru plăci noi cu nuclee diferite - cum ar fi Arduino Due, Arduino Zero, Edison, Galileo etc.

• Arduino Yun. Procesor ATmega32u4 de 16 MHz (resetare automată), 12 pini de intrare analogică, 20 pini de intrare/ieșire digitală (I/O), șapte canale de modulație pe lățime a impulsurilor (PWM).
• Arduino/Genuino Uno. ATmega328 la 16 MHz (resetare automată), 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Arduino Diecimilia sau Duemilanove cu ATmega168. ATmega168 la 16 MHz (cu resetare automată).
• Arduino Nano cu ATmega328. ATmega328 la 16 MHz (cu resetare automată), 8 pini de intrare analogică.
• Arduino/Genuino Mega 2560. ATmega2560 la 16 MHz (cu resetare automată), 16 pini de intrare analogică, 54 pini de intrare/ieșire digitală și 15 canale PWM.
• Arduino Mega. ATmega1280 la 16 MHz (resetare automată), 16 pini de intrare analogică, 54 pini de intrare/ieșire digitală și 15 canale PWM.
• Arduino Mega ADK. ATmega2560 la 16 MHz (resetare automată), 16 pini de intrare analogică, 54 pini I/O digitale și 15 canale PWM.
• Arduino Leonardo. ATmega32u4 la 16 MHz (resetare automată), 12 pini de intrare analogică, 20 pini de intrare/ieșire digitală și 7 canale PWM.
• Arduino Micro. ATmega32u4 la 16 MHz (resetare automată), 12 pini de intrare analogică, 20 pini de intrare/ieșire digitală și 7 canale PWM.
• Arduino Esplora. ATmega32u4 la 16 MHz (cu resetare automată).
• Arduino Mini cu ATmega328. ATmega328 la 16 MHz (resetare automată), 8 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Arduino Ethernet. Echivalent cu Arduino Uno cu modul Ethernet Shield. ATmega328 la 16 MHz (resetare automată), 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Arduino Fio. ATmega328 la 8 MHz (cu resetare automată). Echivalent cu Arduino Pro sau Pro Mini (3.3B, 8 MHz) cu ATmega328, 6 pini de intrare analogică, 14 pini de intrare/ieșire digitale și 6 canale PWM.
• Arduino BT cu ATmega328. ATmega328 la 16 MHz. Bootloader-ul înregistrat (4 KB) include cod pentru a inițializa modulul Bluetooth încorporat. Există, de asemenea, 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• LilyPad Arduino USB. ATmega32u4 la 8 MHz (resetare automată), 4 pini de intrare analogică, 9 pini de intrare/ieșire analogică și 4 canale PWM.
• LilyPad Arduino. ATmega168 sau ATmega132 la 8 MHz (resetare automată), 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Arduino Pro sau Pro Mini (5V, 16 MHz) cu ATmega328. ATmega328 la 16 MHz (cu resetare automată). Echivalent cu Arduino Duemilanove sau Nano cu ATmega328, 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Arduino NG (sau mai devreme) cu ATmega168. ATmega168 la 16 MHz (fără resetare automată). Compilarea și încărcarea este echivalentă cu un Arduino Diecimila sau Duemilanove cu un ATmega168, dar bootloader-ul înregistrat are o întârziere mai mare (și la resetare, LED-ul încorporat de pe pinul 13 clipește de trei ori). Există, de asemenea, 6 pini de intrare analogică, 14 pini de intrare/ieșire digitală și 6 canale PWM.
• Controlul robotului Arduino. ATmega328 la 16 MHz (cu resetare automată).
• Motor robot Arduino. ATmega328 la 16 MHz (cu resetare automată).
• Arduino Gemma. ATtiny85 la 8 MHz (resetare automată), 1 pin de intrare analogică, 3 pini I/O digitale și 2 canale PWM.

Pentru instrucțiuni despre adăugarea suportului pentru plăci noi, consultați „Echipamente terțe” superior.

Ai devenit mândru proprietar al unei plăci Arduino. Ce e de facut in continuare? Și apoi trebuie să conectați Arduino la computer. Ne vom uita la începutul cu Arduino Uno pe sistemul de operare Windows.

1. Instalarea Arduino IDE

Mai întâi trebuie să instalați mediul de dezvoltare integrat Arduino - Arduino IDE - pe computer.

Instalarea IDE-ului Arduino folosind programul de instalare vă va scuti de majoritatea problemelor potențiale cu driverele și mediul software.

2. Lansați Arduino IDE

Odată ce ați descărcat și instalat IDE-ul Arduino, să-l lansăm!

În fața noastră este fereastra IDE Arduino. Vă rugăm să rețineți că încă nu am conectat placa noastră Arduino Uno la computer, dar în colțul din dreapta jos există deja inscripția „Arduino Uno pe COM1”. Acesta este modul în care Arduino IDE ne spune că este configurat în prezent să funcționeze cu placa țintă Arduino Uno. Și când va veni momentul, Arduino IDE va ​​căuta Arduino Uno pe portul COM1.

Vom schimba aceste setări mai târziu.

Ceva n-a mers bine?

Arduino IDE nu pornește? JRE (Java Runtime Environment) este probabil instalat incorect pe computer. Consultați punctul (1) pentru a reinstala IDE-ul Arduino: instalatorul va face toată munca de implementare a JRE.

3. Conectarea Arduino la computer

După instalarea IDE-ului Arduino, este timpul să conectați Arduino Uno la computer.

Conectați Arduino Uno la computer printr-un cablu USB. Veți vedea că LED-ul „ON” de pe placă se aprinde și LED-ul „L” va începe să clipească. Aceasta înseamnă că placa este furnizată cu energie, iar microcontrolerul Arduino Uno a început să execute programul „Blink” programat din fabrică (luminând LED-ul).

Pentru a configura Arduino IDE să funcționeze cu Arduino Uno, trebuie să aflăm ce număr de port COM i-a atribuit computerul Arduino Uno. Pentru a face acest lucru, accesați Windows Device Manager și deschideți fila „Porturi (COM și LPT)”. Ar trebui să vedem următoarea imagine:

Aceasta înseamnă că sistemul de operare a recunoscut placa noastră Arduino Uno ca port COM, a selectat driverul corect pentru acesta și a atribuit acestui port COM numărul 7. Dacă conectăm o altă placă Arduino la computer, sistemul de operare îi va atribui un număr diferit. Prin urmare, dacă aveți mai multe plăci Arduino, este foarte important să nu vă încurcati cu privire la numerele portului COM.

Ceva n-a mers bine?

4. Configurarea IDE-ului Arduino pentru a funcționa cu Arduino Uno

Acum trebuie să spunem IDE-ului Arduino că placa cu care va comunica se află pe portul COM „COM7”.

Pentru a face acest lucru, accesați meniul „Service” → „Serial Port” și selectați portul „COM7”. Acum, Arduino IDE știe că este ceva pe portul „COM7”. Și în curând va trebui să comunice cu acest „ceva”.

Pentru ca Arduino IDE să nu aibă îndoieli, este necesar să indicați direct: „Vom folosi Arduino Uno!” Pentru a face acest lucru, accesați meniul „Service” → „Board” și selectați „Arduino Uno”.

Ceva n-a mers bine?

Lista de porturi seriale este goală? Aceasta înseamnă că Arduino Uno nu este conectat corect. Reveniți la pasul (3) pentru a depana conexiunea.

Arduino IDE incredibil de lent atunci când navighezi în meniuri? Dezactivați toate dispozitivele serial Bluetooth externe în Manager dispozitive. De exemplu, un dispozitiv virtual pentru a se conecta la un telefon mobil prin Bluetooth poate provoca acest comportament.

Mediul este configurat, placa este conectată. Acum puteți continua la încărcarea schiței.

Arduino IDE conține o mulțime de exemple gata făcute în care puteți vedea rapid soluția la orice problemă. Conține, de asemenea, un exemplu simplu de „Blink”. Să-l selectăm.

Să modificăm puțin codul pentru a vedea diferența cu LED-ul din fabrică care clipește.

În loc de linie:

Întârziere (1000);

Întârziere (100);

Versiunea completă a codului:

LED-ul „L” ar trebui să se aprindă acum și să se stingă pentru o zecime de secundă. Este de 10 ori mai rapid decât versiunea din fabrică.

Să încărcăm schița noastră pe Arduino Uno și să verificăm dacă este adevărat? După pornire, LED-ul va începe să clipească mai repede. Asta înseamnă că totul a funcționat. Acum puteți trece în siguranță la „Experimente”

Ceva n-a mers bine?

Ca urmare a descărcării, apare o eroare precum avrdude: stk500_get sync(): not in sync: resp = 0x00 ? Aceasta înseamnă că Arduino nu este configurat corect. Reveniți la pașii anteriori pentru a vă asigura că dispozitivul a fost recunoscut de sistemul de operare și setările corecte pentru portul COM și modelul plăcii sunt setate în Arduino IDE.

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ă, de asemenea, energie arduino.

Există un conector de alimentare separat. Placa are doi pini etichetați 5v și 3.3v, care sunt necesari pentru alimentarea diferitelor dispozitive. Veți găsi, de asemenea, pini marcați GND, aceștia sunt pinii de masă (pământul este 0V). Platforma Arduino are și 14 pini digitali, etichetați de la 0 la 13, care se conectează la noduri externe și au două stări, ridicată sau scăzută (pornit sau oprit). Aceste contacte pot funcționa ca ieșiri sau ca intrări, de ex. pot fie să transmită unele date și să controleze 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 folosește 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.

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

Vom calcula apoi curentul care trece prin rezistor.
Majoritatea LED-urilor de 3 mm și 5 mm strălucesc 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, vrem 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, rezistența 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ță. Îl puteți întoarce sau î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 (IESIREA). 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 (IESIREA). 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 modifica 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: 1240)

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ă aprinde ș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 schimbați comanda digitalWrite() pe analogWrite(). analogWrite() are două argumente: primul este numărul de pin, iar al doilea este valoarea PWM (0-255), în raport cu LED-urile aceasta va fi luminozitatea acestora, iar pentru motoarele electrice viteza de rotație. Mai jos este un exemplu de cod pentru diferite luminozități LED.
//Schimbați luminozitatea LED-ului int ledPin = 9;//un LED este conectat la acest pin void setup() ( pinMode(ledPin, OUTPUT);// inițializarea pinului la ieșire ) void loop() ( analogWrite( ledPin, 255);// luminozitate maximă (255/255 = 1) întârziere (1000);//pauză 1 sec digitalWrite (ledPin, LOW);//stinge LED întârziere (1000);//pauză 1 sec analog Write ( ledPin, 191);//luminozitate cu 3/4 (191/255 ~= 0,75) întârziere (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//oprire întârziere LED (1000);// pauză 1 sec analogWrite(ledPin, 127); //întârziere de jumătate de luminozitate (127/255 ~= 0,5) (1000);//pauză 1 secundă digitalWrite (ledPin, LOW);//întârziere LED-ul de oprire (1000);/ /pauză 1 sec analogWrite(ledPin, 63); //sferturi de luminozitate (63/255 ~= 0,25) delay(1000);//pauză 1 sec digitalWrite(ledPin, LOW);//stinge LED-ul delay(1000) ;//pauză 1 secundă)

Încercați să modificați valoarea PWM din comandă analogWrite() pentru a vedea cum afectează acest lucru luminozitatea.
În continuare, veți învăța cum să reglați ușor luminozitatea de la maxim la zero. Desigur, puteți copia o bucată de cod de 255 de ori
analogWrite(ledPin, luminozitate); delay(5);//scurt 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.
Următorul exemplu utilizează două bucle, una pentru a reduce luminozitatea de la 255 la 0
pentru (luminozitate int=0;luminozitate=0;luminozitate--)( analogWrite(ledPin,luminozitate); delay(5); )
întârziere (5) folosit pentru a încetini viteza de atenuare a luminozității 5*256=1280ms=1.28s)
Prima linie folosește „ luminozitate-" pentru a face ca valoarea luminozității să scadă cu 1 de fiecare dată când bucla este repetată. Rețineți că bucla va 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 diferite luminozități, le puteți combina pentru a crea 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.

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

Aleatoriu(256)- returnează un număr aleatoriu în intervalul de la 0 la 255.
În fișierul atașat este o schiță care va demonstra tranzițiile netede ale culorilor de la roșu la verde, apoi la albastru, roșu, verde etc. (descărcări: 343)
Exemplul de schiță funcționează, dar există o mulțime de coduri duplicate. Puteți simplifica codul scriind propria funcție de ajutor care se va schimba ușor de la o culoare la alta.
Iată cum va arăta: (descărcări: 382)
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: 286)

Buton

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

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 va fi imprimat 2,5 / 5 * 1023 = 512
analogRead are un singur argument - Acesta este numărul de intrare analogică (A0-A5). Următoarea schiță arată codul pentru citirea tensiunii de la potențiometru. Pentru a face acest lucru, conectați un rezistor variabil, bornele exterioare la pinii de 5V și GND și terminalul din mijloc 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);//aprinde ledul cu intensitatea setată de pot Serial.println("pressed"); ( digitalWrite(ledPin, LOW);//oprire dacă butonul nu este apăsat Serial.println("ne apăsat"); ) )

Oricine începe să învețe Arduino este familiarizat cu Arduino IDE. Vă permite să scrieți schițe, să verificați corectitudinea și să le încărcați în Arduino. Dar este acesta singurul mediu pentru dezvoltarea de programe pentru Arduino? Deloc! Să vedem ce alte opțiuni mai sunt.

În acest articol ne vom uita la cele mai populare 4 medii de dezvoltare:

• Arduino IDE;
• Programino;
• CodeBlocks pentru Arduino.

1 Mediu de dezvoltare Arduino IDE

Desigur, acest mediu de dezvoltare este familiar pentru oricine a programat vreodată pentru Arduino.

Conține tot minimul necesar pentru dezvoltarea programelor: scrierea codului, verificarea codului, compilarea, încărcarea unei schițe pe Arduino, monitorul portului serial. Oricine a lucrat în medii de dezvoltare „adulte” serioase, cum ar fi JetBrains IDEA, Microsoft Visual Studio sau Quartus, va observa probabil că IDE-ul Arduino este destul de ascetic: nu oferă nimic de prisos și nu oferă nicio comoditate specială.

2 Mediu de dezvoltare Programino

Să ne uităm la mediul de dezvoltare PROGRAMINO. Acesta este un mediu de dezvoltare plătit, dar îl puteți încerca gratuit timp de 14 zile. Programino, ca și alte medii de dezvoltare, necesită totuși să aveți instalat IDE-ul Arduino. Când porniți pentru prima dată programul, ar trebui să specificați calea către fișierul executabil arduino.exe în setări. Pentru a face acest lucru, accesați meniul de setări: Opțiuni Editor Setări. Va apărea o fereastră în care va trebui să specificați calea către directorul cu Arduino IDE și bibliotecile aferente. Acum suntem gata să scriem programe în Programino.

Limbajul folosit în acest mediu de dezvoltare este același ca și în IDE-ul original Arduino - C. Adică, de fapt, dacă scrieți deja schițe în IDE-ul Arduino, atunci nu va trebui să învățați un nou limbaj de programare, ceea ce este un mare avantaj al acestui mediu de dezvoltare.

Cu toate acestea, pe lângă aceasta, acest IDE oferă o modalitate atât de convenabilă de dezvoltare rapidă precum completarea codului. Adică, nu trebuie să te uiți în mod constant în cartea de referință despre comenzile și metodele Arduino. Începeți să tastați cod, iar mediul de dezvoltare vă va solicita să alegeți dintre opțiunile disponibile pe cea de care aveți nevoie. De exemplu, tastați „digi” și IDE-ul vă oferă opțiuni: „digitalRead”, „digitalWrite” și alte opțiuni posibile.

Să scriem o schiță simplă în care vom interoga constant unul dintre pinii analogici ai Arduino și vom scoate citirile către portul serial.

Încercați să tastați schița manual în loc să copiați și să lipiți pentru a experimenta confortul completării codului Programino.

Const int pinA = A5; void setup() ( pinMode(pinA, INPUT); Serial.begin(19200); ) void loop() ( int r = analogRead(pinA); Serial.println(r); delay(100); )

Ce mai interesant oferă Programino IDE? Acest mediu de dezvoltare are câteva instrumente utile suplimentare disponibile prin meniu Instrumente. De exemplu: blocnotes, designer de simboluri LCD, convertor DEC-BIN-HEX, terminal de port serial, plotter analogic și altele.

Să aruncăm o privire mai atentă asupra instrumentului Plotter analogic. Acest instrument vă permite să vizualizați ce vine în portul COM de la Arduino.

Pentru ca plotterul să funcționeze în schiță, trebuie să activați portul serial la o viteză de 19200 kb/sec. Datele analogice sunt transmise plotterului folosind comanda Serial.println().

Să începem plotterul analogic. Hai să apăsăm butonul Conectați pentru a vă conecta la portul la care avem conectat Arduino.

Acest instrument poate fi util, de exemplu, pentru afișarea citirilor în timp ale unor senzori analogici: temperatură, umiditate, presiune, iluminare și altele.

Înainte de a scrie o schiță în memoria Arduino, ar trebui să specificați tipul de placă folosită și portul la care este conectată prin meniu Hardware.

Pentru a încărca schița în memoria Arduino, faceți clic pe pictograma de descărcare din meniul de sus. Programino va descărca schița și în fereastra de jurnal de jos va afișa date despre dimensiunea schiței și resursele gratuite rămase ale plăcii Arduino.

3 Mediu de dezvoltare B4R (de bază pentru Arduino)

O altă alternativă interesantă la Arduino IDE este B4R, sau „Basic for Arduino”. Acest mediu de dezvoltare este unic prin faptul că folosește Basic mai degrabă decât C. De asemenea, acceptă funcționalitatea de completare a codului. În plus, este complet gratuit.

Când porniți pentru prima dată, mediul B4R necesită, de asemenea, să specificați calea către directorul cu Arduino IDE și, dacă este necesar, biblioteci suplimentare non-standard și module comune. Aceste setări pot fi configurate ulterior prin intermediul meniului Instrumente Configurați căi.

Și alegeți și o tablă: Tools Board Selector:

Să scriem o astfel de schiță și, în același timp, să cunoaștem puțin mai bine mediul de dezvoltare.

În partea centrală există un câmp pentru editarea codului. În dreapta este zona file și filele în sine: biblioteci disponibile, module de schiță, jurnal și căutare. În fotografia de mai sus, fila cu revista este deschisă. Se poate observa că aici sunt afișate mesaje care sunt specificate în program prin comandă Buturuga(). În acest mediu de dezvoltare, puteți seta puncte de întrerupere, ceea ce este foarte util în timpul depanării și, de asemenea, puteți utiliza marcaje pentru o navigare mai rapidă a codului.

Nu veți putea începe imediat programarea în acest mediu de dezvoltare, deoarece... folosește un limbaj diferit, mai orientat pe obiecte decât clasicul IDE Arduino, cu o sintaxă diferită. Cu toate acestea, comoditatea acestui mediu și prezența unei îndrumări bune din partea dezvoltatorilor compensează complet aceste neajunsuri.

4 Mediu de dezvoltare Blocuri de cod pentru Arduino

Există și alte medii de dezvoltare pentru Arduino în afară de cele enumerate. De exemplu, CodeBlocks. Principala sa diferență față de IDE-urile descrise este capacitatea de a scrie cod pentru microcontrolere și alte platforme, nu numai pentru Arduino. Nu o voi descrie mai detaliat, este mai ușor să citiți informațiile de pe site-ul oficial și fișierele de ajutor.

Acum știm că există medii de dezvoltare alternative, mult mai convenabile decât clasicul IDE Arduino. Folosirea lor poate face scrierea propriilor schițe mult mai ușoară și mai rapidă.

Pentru a scrie (edita) și a încărca (firmware) programe (schițe) pe Arduino, trebuie să instalați un program de programare precum Arduino IDE sau să utilizați un editor web on-line. Puteți descărca (descărca) cea mai recentă versiune a programului Arduino IDE sau puteți utiliza editorul web din secțiunea Software a site-ului web arduino.cc.

Descărcarea (încărcarea) Arduino IDE de pe site-ul oficial:

Accesați site-ul web oficial Arduino și selectați, din lista furnizată, sistemul de operare pe care rulează computerul dvs. În acest articol ne vom uita la instalarea IDE-ului Arduino pe sistemul de operare Windows. Selectarea primei linii " Windows Instalator„Veți instala IDE-ul Arduino (așa cum instalați orice alte programe) și selectând a doua linie” Windows Fișier ZIP pentru instalare non-admin» Veți descărca o arhivă ZIP cu un folder de program pe care îl puteți rula fără instalare (chiar dacă nu aveți drepturi de administrator pe computer).

Indiferent de sistemul de operare pe care îl alegeți, vi se va cere să le mulțumiți dezvoltatorilor, este exact asta, depinde de dvs.

Dacă doriți doar să descărcați programul, atunci faceți clic pe butonul „DOAR DESCARCARE” dacă doriți să descărcați programul și să mulțumiți dezvoltatorilor, contribuind la dezvoltarea ulterioară a software-ului, apoi faceți clic pe butonul „CONTRIBUIRE & DESCARCARE”; .

Așteptați până când fișierul este descărcat

După ce descărcarea este completă, fișierul ar trebui să fie localizat în folderul: " Acest calculator > Descărcări „(cu excepția cazului în care ați specificat o altă locație pentru a salva fișierul).

Rulați fișierul de instalare

din folderul: „Acest computer > Descărcări” (veți avea numere de versiune Arduino IDE în loc de X.X.X în numele fișierului).

• Primul mesaj: vă prezintă contractul de licență, faceți clic pe butonul „Sunt de acord”, va apărea al doilea mesaj.
• Mesajul 2: vă solicită să selectați componentele de instalare, faceți clic pe butonul „Următorul”, va apărea mesajul 3.
• Mesajul 3: vă solicită să selectați calea pentru a instala Arduino IDE, faceți clic pe butonul „Instalare”, va apărea mesajul 4.
• Mesajul 4: vă informează despre progresul instalării Arduino IDE, după care va apărea mesajul 5.
• Mesajul 5: vă informează că instalarea Arduino IDE este finalizată, faceți clic pe butonul „Închidere”.

În timpul procesului de instalare, deasupra ferestrei de mesaje 4, pot apărea ferestre Windows care vă solicită permisiunea de a instala drivere:

Permiteți instalarea driverelor făcând clic pe butonul „Instalare” aceste drivere vă vor permite să identificați și să lucrați cu plăcile Arduino conectate prin magistrala USB.

Aceasta completează instalarea Arduino IDE. .

Pictograma programului ar trebui să apară pe desktop:

Lansarea Arduino IDE:

Când lansați pentru prima dată programul, este posibil să primiți un mesaj Windows Firewall despre blocarea accesului la unele funcții de rețea Java IDE Arduino:

Permiteți accesul făcând clic pe butonul „Permiteți accesul”. După care, această fereastră nu va apărea.

Se va deschide fereastra programului Arduino IDE:

Următoarea figură arată scopul zonelor și butoanelor funcționale ale programului:

Acum puteți scrie o schiță (cod) și să o încărcați (încărcare/flash) în Arduino. Dar înainte de asta, trebuie să conectați placa Arduino la computer și să spuneți programului Arduino IDE ce placă Arduino ați conectat și la ce port...

Conectarea plăcii Arduino:

După ce conectați placa Arduino prin portul USB la computer, programul Arduino IDE trebuie să indice ce placă Arduino ați conectat. Pentru a face acest lucru, selectați panoul dorit din lista din secțiunea de meniu " Instrumente > A plati > Numele tabloului dvs

Acum trebuie să selectați portul Com la care este conectată placa Arduino. Pentru a face acest lucru, selectați portul Com dorit din lista de porturi Com disponibile în secțiunea de meniu " Instrumente > Port > Număr de port disponibil", după cum se arată în figura următoare:

Dacă controlerul USB al plăcii dvs. Arduino este implementat pe un cip FTDI sau similar, atunci în lista de porturi Com disponibile nu veți vedea numele plăcii Arduino între paranteze vizavi de portul Com. În cazul nostru, veți vedea pur și simplu „COM1” și „COM7”, apoi apare întrebarea, la care dintre aceste porturi este conectată placa Arduino?

Această problemă poate fi rezolvată foarte simplu. Deconectați placa Arduino de la computer și deschideți " Instrumente > Port » . În lista de porturi Com veți vedea doar disponibil Porturi Com, adică în cazul nostru doar „COM1”. Acum conectați placa Arduino la computer și deschideți din nou meniul " Instrumente > Port » . Acum veți vedea că lista de porturi Com a crescut cu unul (în cazul nostru, „COM7” a fost adăugat la „COM1”), iar placa dvs. Arduino este conectată la portul Com.

Dacă, atunci când conectați placa Arduino, nu vedeți apariția unui nou port Com, atunci controlerul USB al plăcii dvs. Arduino este implementat pe cipuri terțe și trebuie să instalați un driver suplimentar pentru acesta. Ca, de exemplu, driverul pentru cipul CH340G.

Încărcarea unei schițe din programul IDE Arduino pe placa Arduino:

După ce ați indicat tipul de placă Arduino, ați selectat portul Com și ați scris schița (codul programului), schița poate fi încărcată (încărcată/flash) pe controlerul plăcii Arduino . Pentru a face acest lucru, selectați elementul de meniu „» sau faceți clic pe butonul sub forma unui cerc cu o săgeată:

Dacă ați scris o schiță într-o fereastră nouă și nu ați salvat-o într-un fișier, atunci înainte de a o încărca pe placa Arduino, Arduino IDE vă va solicita să o salvați. Introduceți numele sub care doriți să salvați schița într-un fișier și faceți clic pe butonul „Salvare”.

În timpul încărcării, veți vedea o bară de stare care va afișa progresul compilării și încărcării schiței. Dacă nu există erori în schiță și este încărcată cu succes, în zona de notificare vor apărea informații despre cantitatea de memorie Arduino utilizată și disponibilă, iar deasupra zonei de notificare va apărea mesajul „Descărcare finalizată”.

Mica schiță de mai sus (în imagine) va face ca LED-ul de pe placa Arduino să clipească. Multe schițe sunt simplificate și scurtate prin utilizarea bibliotecilor. Puteți afla ce biblioteci sunt și cum să le instalați în secțiune.