28 09.2016

Te-ai gândit vreodată să-ți faci viața mai ușoară acasă? Pentru a avea lucruri care ar rezolva sarcinile de zi cu zi, de rutină pentru tine. Dispozitiv inteligent, care ar duce la îndeplinire functie utila, de exemplu, uda grădina, curăța camera, ducea încărcătura. Aceste probleme pot fi rezolvate. Dar doar cumpărarea lui nu va fi suficient. Orice controler logic industrial sau cip are nevoie de un „creier” pentru a efectua o anumită secvență de acțiuni. Pentru a efectua operații în cazul nostru, limbajul de programare Arduino este potrivit.

Din acest articol veți învăța:

Salutări, prieteni! Pentru cei care nu mă cunosc, numele meu este Gridin Semyon. Puteți citi despre mine. Articolul de astăzi va fi dedicat două programe principale, fără de care nu vom mai avea mișcare și înțelegere reciprocă.

Descrierea generală a limbajelor de programare

După cum am scris mai sus, vom lua în considerare două medii de dezvoltare populare. Prin analogie cu, poate fi împărțit în editor graficși „notepad inteligent”. Acestea sunt programele Arduino IDE și FLprog.

Baza mediului de dezvoltare este Procesarea/Wiring - acesta este C++ obișnuit, completat cu funcții și diferite biblioteci. Există mai multe versiuni pentru sisteme de operare Windows, Mac OS și Linux.

Care este diferenta lor fundamentala?? Arduino IDE este un mediu de dezvoltare care descrie codul programului. Și FLprog este similar cu CFC CoDeSyS, care vă permite să desenați diagrame. Care mediu este mai bun? Ambele sunt bune și convenabile în felul lor, dar dacă doriți să vă ocupați serios de controlere, cel mai bine este să învățați limbi similare SI. Principalul lor avantaj este flexibilitatea și natura nelimitată a algoritmului. Îmi place foarte mult IDE-ul Arduino.

Descrierea Arduino IDE

Distribuția poate fi descărcată de pe site-ul oficial. Descărcați arhiva, ocupă puțin mai mult de 100 MB. Instalarea este standard, ca toate aplicațiile pentru Windows. Driverele pentru toate tipurile de plăci trebuie instalate în pachet. Și așa arată fereastra de lucru programe.

Mediul de dezvoltare Arduino constă din:

• editor codul programului;
• zone de mesaje;
• ferestre de ieșire a textului;
• bare de instrumente cu butoane pentru comenzile utilizate frecvent;
• mai multe meniuri

Setări Arduino IDE

Se numește un program scris în mediul de dezvoltare Arduinoschiţa. Schița este scrisă într-un editor de text, care are evidențierea colorată a codului de program creat. Un exemplu de program simplu în imaginea de mai jos.

Funcționalități suplimentare pot fi adăugate folosindbiblioteci,reprezentând cod conceput într-un mod special. Practic, nu este accesibil dezvoltatorului. Mediul vine de obicei cu set standard, care poate fi completat treptat. Sunt în subdirectorbiblioteci Directorul Arduino.

Multe biblioteci vin cu exemple situate în folderexemplu.Selectarea unei biblioteci din meniu o va adăuga cod sursă linii:

Arduino

#include

#include

Aceasta este o directivă - un fel de instrucțiune, un fișier antet care descrie obiecte, funcții și constante de bibliotecă. Multe funcții au fost deja dezvoltate pentru cele mai comune sarcini. Crede-mă, asta ușurează viața programatorului.

După ce am conectat placa electronică la computer. Facem urmatoarele setari - selectam placa Arduino si portul Com prin care ne vom conecta.

Arduino

void setup() ( // inițializați pinul digital 13 ca ieșire. pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(1000) );

void setup() ( // inițializați pinul digital 13 ca ieșire. pinMode(13, IEȘIRE); void loop() ( digitalWrite(13, HIGH); întârziere (1000); digitalWrite(13, LOW); întârziere (1000);

Deci, apropo, este convenabil să verificați funcționalitatea plăcii care a venit din magazin. Rapid și ușor.

Mai este un lucru convenabil. Se numeșteMonitorul portului serial (Monitor serial). Afișează datele trimise către platformăArduino.De obicei mă uit la ce semnale îmi dau diferiții senzori conectați la placă.

Conectarea bibliotecilor

Sunt moduri diferite pentru a adăuga caracteristici personalizate. Puteți conecta biblioteci în trei moduri:

1. Folosind Library Manager
2. Utilizarea importului ca fișier .zip
3. Instalare manuală.

1. Folosind Library Manager.În fereastra de lucru a programului, selectați fila Schiță. După aceea, faceți clic pe butonul Conectare bibliotecă. Directorul bibliotecii se va deschide în fața noastră. Fereastra se va afișa deja fișierele instalate cu semnăturăinstalatsi cele care pot fi instalate.

2. Utilizarea importului ca fișier .zip.Adesea, pe Internet puteți găsi fișiere de bibliotecă ambalate în arhive cu extensie zip. Conține un antet fișier.h și un cod fișier.cpp. Nu este nevoie să despachetați arhiva în timpul instalării. Doar accesați meniul Schiță - Conectați biblioteca - Adăugați o bibliotecă .ZIP

3. Instalare manuală.Mai întâi, închideți programul Arduino IDE. Mai întâi ne despachetăm arhiva. Și transferăm fișierele cu extensia .h și .cpp într-un folder cu același nume ca și arhiva. Plasați folderul în directorul rădăcină.

Documentele mele\Arduino\biblioteci

Descrierea FLPprog

FLprog este proiect gratuit dezvoltatori independenți, permițându-vă să lucrați cu blocuri funcționale sau cu diagrame relee. Acest mediu este convenabil pentru oameni - nu pentru programatori. Vă permite să vedeți vizual și clar algoritmul folosind diagrame și blocuri funcționale. Puteți descărca distribuția de la site-ul oficial.

Urmaresc proiectul de destul de mult timp. Băieții se dezvoltă, adăugând constant noi funcționalități și schimbându-le pe cele vechi. Văd promisiuni în acest mediu. Deoarece îndeplinește două funcții importante:simplitate și ușurință în utilizare.

Să încercăm să creăm un proiect simplu. Vom comuta ieșirea 13 la LED.

Să creăm un nou proiect. În fereastra de sus, adăugați numărul necesar de intrări și ieșiri, setați un nume și atribuiți o intrare sau o ieșire fizică plăcii.

Scoatem elementele de care avem nevoie din arborele de obiecte și elementele de care avem nevoie pe pânza de editare. În cazul nostru, putem folosi un simplu declanșator RS pentru a-l porni și opri.

După crearea algoritmului, faceți clic pe butonul de compilare, programul oferă o schiță gata făcută în IDE.

Am analizat capacitățile și comoditatea programelor pentru dezvoltarea algoritmilor pe controlerul din seria Arduino. Există și programe care vă permit să creați diagrame structurale și imagini vizuale. Dar recomand folosirea editor de text, pentru că atunci îți va fi mai ușor. Spune-mi, ce mediu este cel mai convenabil pentru tine și de ce??

Pe 22 septembrie, am participat la un seminar la Krasnodar „Controle cu panou tactil OVEN SPK.” Conferința a avut loc în elegantul și frumosul hotel Bristol. A fost foarte interesant și mișto.

În prima parte a seminarului, ni sa spus despre capabilitățile și avantajele produselor OWEN. Apoi a fost o pauză de cafea cu gogoși. Am luat o grămadă de lucruri, gogoși, prăjituri și bomboane, pentru că îmi era foarte foame =)

În partea a doua a seminarului, după prânz, am fost prezentați. Ne-au spus multe despre vizualizarea Web. Această tendință începe să capete amploare. Ei bine, desigur, controlați echipamentul prin orice browser de internet. Acest lucru este foarte cool. Apropo, echipamentul în sine este în valiză.

Voi publica o serie de articole despre CoDeSyS 3.5 în viitorul apropiat. Așadar, dacă cineva este interesat, abonează-te sau vine pur și simplu în vizită. voi fi mereu bucuros!!!

Apropo, aproape că am uitat, următorul articol va fi despre placa electronică Arduino. Va fi interesant, nu-l ratați.

Ne vedem în articolele următoare.

Salutări, Gridin Semyon.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Succes în stăpânirea microcontrolerelor!

Deci ai un procesor. Probabil înțelegeți că procesorul poate fi programat cumva să facă ceea ce doriți. Pentru a face o muncă utilă, este necesar să (a) scrieți un program util și (b) să îl dați procesorului pentru execuție.

În general, nu contează ce tip de procesor aveți: cel mai recent Intel Pentium în laptop sau un microcontroler pe o placă Arduino. Principiile scrierii unui program, de ex. programare, în ambele cazuri la fel. Singura diferență este viteza și domeniul de aplicare a capabilităților de lucru cu alte dispozitive.

Ce este un program și unde să-l scrie

Procesorul, în ciuda întregii complexități a producției, este în esență un lucru destul de simplu și direct. Nu știe să gândească. El poate doar orbește, octet cu octet, să execute instrucțiunile care i-au fost înmânate. Un exemplu aproximativ al secvenței de instrucțiuni poate fi dat:

Octet de instrucțiune	Ce înseamnă pentru procesor
00001001	înseamnă: luați următorul octet și stocați-l în celula nr. 1
00000110	... acesta este exact următorul octet pe care îl amintim în celula nr. 1: numărul 5
00011001	înseamnă: scădeți unul din valoarea din celula nr. 1 și lăsați rezultatul actualizat acolo
00101001	înseamnă: comparați valoarea din celula nr. 1 cu zero și, dacă este zero, treceți prin cât mai mulți octeți indicați în octetul următor
00000100	...dacă rezultatul a fost zero, vrem să sărim 4 octeți la penultima instrucțiune
10000011
01000001	...litera „A” corespunde exact acestui cod
00101000	înseamnă că vrem să sărim înapoi la cât mai mulți octeți indicați în octetul următor
00000110	... vom sări cu 6 octeți înapoi la instrucțiunea nr. 3
10000011	înseamnă că dorim să afișăm caracterul al cărui cod este scris în octetul următor
00100001	... semnul "!" Acest cod se potrivește exact

Ca urmare a executării unei astfel de secvențe de instrucțiuni, pe ecran va fi afișată expresia de panică „AAAH!”.

Destul de mult cod pentru un scop atât de simplu! Este clar că dacă toate programele ar fi scrise așa, direct, dezvoltarea unor produse complexe ar dura secole.

De ce sunt necesare limbaje de programare?

Pentru a simplifica sarcina de un milion de ori, au fost inventate limbaje de programare. Există o mulțime de ele și chiar și dintre cele care sunt auzite în mod constant, vă puteți aminti rapid o duzină sau două: Assembler, C, C++, C#, Java, Python, Ruby, PHP, Scala, JavaScript.

Programele în aceste limbi sunt mult mai apropiate de limbajul uman natural. Și, prin urmare, sunt mai ușor, mai rapid și mai plăcut de scris și, cel mai important, sunt mult mai simple citire: ție imediat după ce ai scris, ție un an mai târziu, sau colegului tău.

Problema este că astfel de limbi nu sunt de înțeles de procesor și înainte de a-i oferi acest program, trebuie să o faci compila: traduceți din limbajul natural în aceleași instrucțiuni sub formă de zerouri și unu. Acest lucru se face prin programe numite compilatoare. Fiecare limbaj, cu excepția cazului în care rămâne la nivel de fantezie, are propriul compilator. Pentru limbile populare, există de obicei mai multe dintre care să alegeți, de la diferiți producători și pentru diferite platforme. Cele mai multe dintre ele sunt disponibile gratuit pe Internet.

Deci, există programe într-un limbaj care este pe deplin înțeles de oameni: ele mai sunt numite și „cod sursă”, pur și simplu „cod” sau „coduri sursă”. Sunt scrise în fișiere text simple folosind orice editor de text, chiar și folosind notepad. Apoi, ele sunt transformate în seturi de zerouri și de înțeles de procesor folosind compilatorul: compilatorul primește codul sursă ca intrare și creează executabil binar, cel de înțeles de procesor.

Fișierele binare nu pot fi citite și, în general, sunt destinate doar execuției de către procesor. Pot fi de diferite tipuri în funcție de ce au fost primite: .exe sunt programe pentru Windows, .hex sunt programe pentru execuție de către un microcontroler de tip Arduino etc.

De ce există atât de multe limbaje de programare și care este diferența?

De ce? Pentru că există mulți oameni și companii pe Pământ și mulți credeau că pot face ce e mai bun: mai convenabil, mai clar, mai rapid, mai subțire.

Care este diferența: diferitele limbi au un echilibru diferit între viteza de scriere, lizibilitate și viteza de execuție.

Să ne uităm la același program care afișează un cântec despre 99 de sticle de bere pe ecran în diferite limbaje de programare.

De exemplu, limbajul Perl. Se scrie repede; este imposibil de înțeles ce a vrut să spună programatorul; executat incet:

sub b( $n = 99 - @_ - $_ || Nu; "$n sticla" . "s" x!!-- $n . "de bere" ) ​​; $w = "pe perete" ; harta morții ( b. „$w,\n" . b. ",\n Luați unul jos, treceți-l,\n " . b(0) . „$w.} 0 .. 98

\n\n"

limbajul Java. Este nevoie de un timp relativ lung pentru a scrie; ușor de citit; se execută destul de repede, dar ocupă multă memorie: sticle de clasă ( public static void main(Şir sticle de clasă ( public static void main( argumente) ( s = "s"; pentru (int beers= 99 ; beers>- 1 ; ) ( s = "s"; Sistem s = "s";.out .print (beri + "sticlă" + s + "de bere pe perete, " ) ; .out .println (beri + "sticlă" + s + "de bere, " ) ;) ; s = "s"; dacă (beri== 0 ) ( .out .print () ; s = "s";„Du-te la magazin, cumpără-ți mai multe.” s = "s";.out .print (beri + "sticlă" + s + "de bere pe perete, " ) ; .out .println ("99 de sticle de bere pe perete.\n " s = "s";.exit(0); ) altfel) ; } } }

„Luați unul jos, dați-l în jur.”

); s = (-- bere == 1) ?"" : "s" ; .out .println (beri + „sticlă” + s +" de bere pe perete.\n " ; imprimați restul celei de-a patra rânduri mov ah, 9 int 21h cmp cx, 0; De bere? jne loopstart; dacă nu, continuați int 20h; părăsiți la MS-DOS; subrutină pentru a imprima registrul CX în zecimală printcx: mov di , offset numbufferend; umpleți tamponul de la sfârșit mov ax, cx; puneți numărul în AX ca să-l putem împărți printcxloop: mov dx, 0; cuvânt de ordin înalt al numărătorului - întotdeauna 0 mov bx, 10 div bx; împărțiți DX:AX la 10. AX=cot, DX=restul adauga dl , "0"; converti restul într-un caracter ASCII mov[ds:di],dl; pune-l în tamponul de imprimare cmp ax, 0; Mai sunt cifre de calculat? je printcxend; daca nu, sfarsitul dec di ; pune următoarea cifră înaintea celei curente jmp printcxloop ; loop printcxend: mov dx , di ; tipăriți, începând cu ultima cifră calculată mov ah, 9 int 21h ret; Linia de date 1 db „sticle de bere pe perete”,, 13 , 10 , "$" line2_3 db "sticle de bere", 13 , 10 , „Luați unul jos, dați-l în jur.”, 13 , 10 , „$” linia4 db

„sticle de bere pe perete”.

, 13 , 10 , 13 , 10 , "$" numbuffer db 0 , 0 , 0 , 0 , 0 numbufferend db 0 , "$" codul se termină sfârşitul începutului Cum este programat Arduino? Dacă vorbim despre Arduino sau microcontrolere de la Atmel, în ce limbă poți scrie programe pentru ele? Răspunsul teoretic: oricare. Dar, în practică, alegerea este limitată la limbajele Assembler, C și C++. Acest lucru se datorează faptului că, în comparație cu

computer desktop

au resurse foarte limitate. Kilobytes de memorie, nu gigabytes. Megaherți pe procesor, nu gigaherți. Acesta este un preț de plătit pentru ieftinitate și eficiență energetică.

Prin urmare, avem nevoie de un limbaj care să poată compila și executa eficient. Adică se traduce chiar în acele zerouri și unuri din instrucțiuni cât mai optim posibil, fără a irosi instrucțiuni prețioase și memorie. Limbile menționate mai sus au acest tip de eficiență. Folosindu-le chiar și în limitele înguste ale resurselor microcontrolerului, puteți scrie programe bogate în funcții care rulează rapid. Assembler, după cum ați văzut, nu poate fi numit cel mai simplu și mai elegant și, prin urmare, limbajul emblematic pentru Arduino este C/C++. Multe surse spun că Arduino este programat

De ce sunt menționate C și C++ în aceeași propoziție? C++ este o suprastructură a lui C. Fiecare program C este un program C++ valid, dar nu invers. Puteți folosi ambele. De cele mai multe ori, nici nu te vei gândi la ce folosești atunci când rezolvi problema actuală.

Mai aproape de subiect: primul program

Să scriem primul program pentru Arduino și să facem ca placa să-l execute. Trebuie să creați un fișier text cu codul sursă, să îl compilați și să lipiți rezultatul fișier binar microcontroler pe placă.

Să mergem în ordine. Să scriem codul sursă. Îl poți scrie în notepad sau în orice alt editor. Cu toate acestea, pentru a face munca convenabilă, există așa-numitele medii de dezvoltare (IDE: Integrated Development Environment). Sub forma unui singur instrument, acestea oferă un editor de text cu evidențiere și sugestii, un compilator lansat de un buton și multe alte bucurii. Pentru Arduino, acest mediu se numește Arduino IDE. Este disponibil gratuit pentru descărcare de pe site-ul oficial.

Instalați mediul și rulați-l. În fereastra care apare, veți vedea: cea mai mare parte a spațiului este acordat editorului de text. Codul este scris în el. Codul din lumea Arduino este de asemenea numit schiţa.

Deci haideți să scriem o schiță care nu face nimic. Adică minimul posibil programul potrivitîn C++, care doar pierde timpul.

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

Să nu ne concentrăm deocamdată pe sensul codului scris. Să-l compilam. Pentru a face acest lucru, în Arduino IDE, există un buton „Verificare” pe bara de instrumente. Faceți clic pe el și în câteva secunde fișierul binar va fi gata. Acest lucru va fi anunțat prin inscripția „Compilare finalizată” sub editorul de text.

Ca urmare, avem un fișier binar cu extensia .hex, care poate fi executat de microcontroler.

Acum trebuie să-l introduceți în Arduino. Acest proces se numește pornire, intermitent sau inundare. Pentru a încărca în Arduino IDE, există un buton „Încărcare” pe bara de instrumente. Conectați Arduino la computer printr-un cablu USB, faceți clic pe „Încărcați” și în câteva momente programul va fi încărcat pe Arduino. În acest caz, programul care a fost acolo anterior va fi șters.

Mesajul „Încărcare terminată” va indica instalarea cu succes a firmware-ului.

Dacă întâmpinați o eroare când încercați să descărcați, asigurați-vă că:

ÎN Meniul Instrumente→ Se selectează portul la care este conectat de fapt Arduino. Puteți conecta și scoate cablul USB pentru a vedea ce port apare și dispare: acesta este Arduino.

Ai instalat driverele necesare pentru Arduino. Acest lucru este necesar pe Windows, nu este necesar pe Linux și este necesar doar pe plăci mai vechi înainte de Arduino Duemilanove pe MacOS.

Felicitări! Ai venit până la capăt ardezie curată la un program care rulează în Arduino. Poate că nu face nimic, dar acesta este deja un succes.

Ardublock este limbaj grafic programare pentru Arduino, concepută pentru începători. Acest mediu este destul de ușor de utilizat, ușor de instalat și aproape complet tradus în rusă. Un program proiectat vizual care seamănă cu blocurile...

Întreruperile sunt un mecanism foarte important în Arduino care permite dispozitivelor externe să interacționeze cu controlerul atunci când apar diverse evenimente. Prin instalarea unui handler de întrerupere hardware în schiță, putem răspunde la pornirea sau dezactivarea unui buton, la apăsarea tastaturii,...

Serial.print() și Serial.println() sunt principalele funcții ale Arduino pentru a transfera informații de pe placa Arduino la computer prin portul serial. Cele mai populare plăci Arduino Uno, Mega, Nano nu au afișaj încorporat, așa că...

Este posibil să faci proiecte Arduino fără placa Arduino în sine? Se pare, destul. Mulțumită numeroșilor servicii onlineși programe care au propriul nume: emulator sau Arduino simulator. Cei mai populari reprezentanți ai unor astfel de programe sunt...

Început în serie - extrem de instrucțiuni importante Arduino, permite controlerului să stabilească o conexiune cu dispozitive externe. Cel mai adesea, acest „dispozitiv extern” este computerul la care conectăm Arduino. De aceea, începutul serialului este mai intens...

O variabilă globală în Arduino este o variabilă a cărei sferă se extinde la întregul program, este vizibilă în toate modulele și funcțiile. În acest articol ne vom uita la câteva exemple de utilizare a variabilelor globale...

Matricele Arduino sunt un element de limbaj utilizat în mod activ de programatori pentru a lucra cu seturi de date de același tip. Array-urile se găsesc în aproape toate limbajele de programare, Arduino nu face excepție, a cărui sintaxă este foarte asemănătoare...

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 de pe folosind Arduino IDE. Port 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, de asemenea, 14 pini digitali, etichetați de la 0 la 13, care se conectează la noduri externe și au două stări, ridicată sau scăzută (pornit sau oprit). Aceste contacte pot funcționa ca ieșiri sau ca intrări, de ex. pot fie să transmită unele date și să controleze dispozitivele externe, fie să primească date de la dispozitive. Următorii pini de pe placă sunt etichetați A0-A5. Acestea sunt intrări analogice care pot primi date de la diverși senzori. Acest lucru este convenabil mai ales atunci când trebuie să măsurați un anumit interval, cum ar fi temperatura. Intrările analogice au caracteristici suplimentare, care poate fi folosit separat.

Cum se utilizează panou.

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

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

Cele două rânduri de sus și de jos sunt conectate în rânduri de-a lungul întregii plăci. Aceste rânduri sunt folosite pentru a furniza energie circuitului. Ar putea fi de 5V sau 3,3V, dar în orice caz, primul lucru pe care trebuie să-l faceți este să conectați 5V și GND la placa, așa cum se arată în imagine. Uneori, aceste conexiuni de rând pot fi rupte în mijlocul plăcii, apoi, dacă 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 în grupuri de cinci găuri. Sunt folosite pentru a conecta părțile circuitului.

Primul lucru pe care îl vom conecta la microcontrolerul nostru este un LED. Schema de conectare electrică este prezentată în imagine.

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

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

Vă rugăm să rețineți că există o diferență în modul în care conectați LED-ul. Curentul curge 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 (IEȘIRE). Nu veți putea să citiți sau să scrieți date din pin până când nu îl setați respectiv pinMode. Această funcție are două argumente: pinNumber este numărul PIN pe care îl veți folosi.

Modul-setează cum va funcționa pinul. La intrare (INTRARE) sau ieșire (IEȘIRE). Pentru a aprinde LED-ul trebuie să dăm un semnal DIN Arduino. Pentru a face acest lucru, configurăm pinul de ieșire.
- această funcție este folosită pentru a seta starea (stat) pina (pinNumber). Există două stări principale (de fapt 3 dintre ele), una este RIDICAT, 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 RIDICAT.

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

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

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

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

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

Controlul mai multor LED-uri.

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

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

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

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

Reglarea luminozității LED-urilor

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

Încercați să modificați valoarea PWM din comandă analogWrite() pentru a vedea cum afectează acest lucru luminozitatea.
În continuare, veți învăța cum să reglați ușor luminozitatea de la maxim la zero. Desigur, puteți copia o bucată de cod de 255 de ori
analogWrite(ledPin, luminozitate); delay(5);//short delay luminozitate = luminozitate + 1;
Dar, înțelegi, acest lucru nu va fi practic. Cel mai bun mod de a face acest lucru este 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. Aceste. toate cele trei LED-uri sunt conectate structural prin catozi la un terminal. Vom conecta acest pin la pinul GND. Pinii rămași, prin rezistențe de limitare, trebuie conectați la pinii PWM. Autorul a folosit pinii 9-11. În acest fel, va fi posibil să controlați fiecare LED separat. Prima schiță arată cum să porniți fiecare LED individual.

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

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

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

Buton

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

Aceasta înseamnă că, în timp ce butonul nu este apăsat, nu trece curent prin el, iar după ce a fost eliberat, butonul revine la pozitia de pornire.
Pe lângă buton, circuitul folosește un rezistor. În acest caz, nu limitează curentul, ci „trage” butonul la 0V (GND). Aceste. până când butonul este apăsat pe pinul Arduino la care este conectat, se va întâmpla nivel scăzut. Rezistorul folosit în circuit este de 10 kOhm.

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

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

Intrare analogică.

analogRead vă permite să citiți date de la unul dintre pinii analogici ai 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 intrare analogică(A0-A5). Următoarea schiță arată codul pentru citirea tensiunii de la potențiometru. Pentru a face acest lucru, conectați-vă rezistor variabil, pinii cei mai exteriori merg la pinii 5V și GND, iar pinul din mijloc merge la intrarea A0.

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