Buton de bibliotecă Arduino cu întârziere. Conectarea unui buton la Arduino

vei avea nevoie

• Arduino;
• butonul de tact;
• rezistență 10 kOhm;
• panou;
• fire de conectare.

1 Specie butoane

Butoanele sunt diferite, dar toate îndeplinesc aceeași funcție - conectează fizic (sau, dimpotrivă, rup) conductorii împreună pentru a asigura contactul electric. În cel mai simplu caz, aceasta este o conexiune a doi conductori, există butoane care se conectează Mai mult conductoare.

Unele butoane lasă firele conectate după apăsarea ( butoane de blocare), alții deschid circuitul imediat după eliberare ( butoane care nu se blochează).

Butoanele sunt, de asemenea, împărțite în:

• deschis în mod normal,
• în mod normal închis.

Primii, la apăsare, închid circuitul, al doilea deschid circuitul.

În zilele noastre un tip de butoane numite "butoane de tact". Ceas - nu din cuvântul „tact”, ci din cuvântul „tactil”, deoarece Presiunea este simțită bine de degete. Dar acest termen eronat s-a stabilit, iar acum aceste butoane se numesc așa peste tot în țara noastră. Acestea sunt butoane care, atunci când sunt apăsate, se închid circuit electric, iar când sunt eliberate, se deschid, i.e. Acestea sunt butoane care nu se blochează, în mod normal deschise.

2 Sună contacte

Un buton este o invenție foarte simplă și utilă, care servește la o mai bună interacțiune între om și tehnologie. Dar, ca totul în natură, nu este ideal. Acest lucru se manifestă prin faptul că atunci când apăsați butonul și când îl eliberați, așa-numitul. „bounce” în engleză. Aceasta este comutarea stării unui buton de mai multe ori într-o perioadă scurtă de timp (de ordinul a câteva milisecunde) înainte ca acesta să ia o stare de echilibru. Acest fenomen nedorit apare atunci când butonul este comutat din cauza elasticității materialelor butonului sau din cauza microscânteilor generate în timpul contactului electric.

În următorul articol vom analiza în detaliu modalitățile de a combate „saritul” la închiderea și deschiderea contactelor. Între timp, să ne uităm la opțiunile pentru conectarea butonului la Arduino.

3 Conexiune incorectă butoane

Pentru a conecta un buton de ceas normal deschis la Arduino, puteți face cel mai mult într-un mod simplu: conectați un conductor liber al butonului la alimentare sau la masă, celălalt la digital Pin Arduino. Dar, în general, acest lucru este greșit. Cert este că, în momentele în care butonul nu este închis, vor apărea interferențe electromagnetice pe ieșirea digitală Arduino și, din această cauză, sunt posibile false pozitive.

Pentru a evita interferențele, pinul digital este de obicei conectat printr-un rezistor destul de mare (10 kOhm) fie la masă, fie la alimentare. În primul caz se numește "circuit cu rezistență de tragere", în al doilea - "circuit cu rezistență de tragere în jos". Să ne uităm la fiecare dintre ele.

4 Conectarea unui buton conform circuitului cu un rezistor de tragere

Mai întâi să ne conectăm la Butonul Arduino conform circuitului cu un rezistor de tragere. Pentru a face acest lucru, conectați un contact al butonului la masă, al doilea la ieșirea digitală „2”. Ieșirea digitală „2” va fi, de asemenea, conectată printr-un rezistor de 10 kOhm la sursa de +5 V.

Să scriem o schiță ca aceasta pentru a procesa clicurile pe buton și să o încărcăm în Arduino.

// Setați numerele de pin: const int buttonPin = 2; const int ledPin = 13; void setup() ( pinMode(ledPin, OUTPUT); } pinMode(buttonPin, INPUT); void loop() ( }

int buttonState = digitalRead(buttonPin); // citește starea butonului dacă (buttonState == HIGH) ( digitalWrite(ledPin, HIGH); // aprinde LED-ul când butonul este apăsat) altfel ( digitalWrite(ledPin, LOW); // stinge LED-ul când butonul este eliberat) LED-ul încorporat de la pinul „13” este aprins constant până când butonul este apăsat. Aceste. Portul Arduino „2” este întotdeauna ridicat nivel logic

5 RIDICAT. Când apăsăm butonul, tensiunea de pe portul „2” devine LOW și LED-ul se stinge. Conectarea unui buton

conform schemei cu un rezistor de tragere

Acum să asamblam un circuit cu un rezistor de tragere în jos. Conectam un contact al butonului la sursa de alimentare +5 V, al doilea la ieșirea digitală „2”. Conectam ieșirea digitală „2” printr-un rezistor de 10 kOhm la masă. Nu vom schimba schița. Când porniți circuitul pe portul digital „2” al Arduino nivel scăzut LOW și LED-ul nu este aprins. Când apăsați butonul, portul „2” primește nivel înalt

HIGH și LED-ul se aprinde. În acest exemplu, ne vom uita la conectarea unui buton la un controler Arduino. Când apăsați butonul, vom aprinde LED-ul încorporat. Majoritate Placi Arduino

au un LED SMT încorporat conectat la ieșirea 13 (pin 13).

• Componente necesare
• Controler Arduino
• butonul tact
• Rezistor de 10 kOhm
• placă de prototipare

fire de conectare

Conectăm puterea de ieșire (5V) și masă (Gnd), cu fire roșii și, respectiv, negre, la placa. În mod obișnuit, plăcile folosesc rândurile exterioare de pini pentru alimentare și împământare, așa cum se arată în figură. Cu al treilea fir albastru conectăm pinul digital 2 al controlerului Arduino la pinul butonului ceasului. La același contact sau la un contact conectat permanent la acesta într-un design cu 4 pini, conectăm un rezistor pull-up de 10 kOhm, care la rândul său este conectat la masă. Conectăm cealaltă ieșire a butonului la o sursă de alimentare de 5 V.

Când butonul de ceas nu este apăsat, ieșirea 2 este conectată numai la masă printr-un rezistor de tragere și această intrare va citi LOW. Iar la apăsarea butonului, apare un contact între intrarea 2 și sursa de alimentare de 5V și se va citi.

Notă: Cel mai adesea, butoanele de tact au două contacte pe fiecare parte, așa cum se arată în figura de conectare. În același timp, butonul are o formă aproape pătrată. Este IMPORTANT atunci când conectați care contacte sunt conectate și care sunt închise când sunt apăsate. Cel mai bine este să suni la buton dacă nu ești sigur.

ŞI Arduino aici nu este o excepție, după ce LED-ul clipește, încearcă să conecteze butonul și să-l folosească pentru a controla clipirea chiar a acestui LED. Nu este nimic deosebit de complicat aici, dar există o nuanță numită „sarire de contact”. Cum să conectați corect un buton la Arduino Ce este „saritul de contact”, cum se manifestă acest efect și metodele de combatere a acestuia vor fi discutate astăzi.

Cea mai simplă diagramă pentru conectarea unui buton la un microcontroler arată astfel:

Dacă cheia S 1 este deschis (butonul este eliberat), apoi la intrarea digitală D în microcontroler vom avea o tensiune de 5V, corespunzatoare uneia logice. Când butonul este apăsat, introduceți D în se conectează la masă, ceea ce corespunde nivelului logic zero și toată tensiunea va scădea pe rezistor R 1, a cărui valoare se alege pe baza faptului că la apăsarea butonului nu trece prea mult curent prin el (de obicei aproximativ 10÷100 kOhm).

Dacă conectați doar un buton între intrarea digitală și masă (fără rezistor R 1, conectat la +5V) sau între intrare și +5V, apoi în poziția când butonul nu este apăsat, o tensiune nedefinită va fi prezentă pe intrarea digitală a microcontrolerului (poate corespunde nivelului 0, sau poate 1) și am citi stări aleatorii. Prin urmare, se folosește o rezistență R 1, despre care se spune că „trage în sus” intrarea la +5V atunci când butonul este eliberat.

Citind starea intrării digitale a microcontrolerului, putem determina dacă butonul este apăsat (starea 0 logică) sau nu (vom primi unul logic la intrare).

Conectarea unui buton la Arduino

Microcontrolere Atmel AVR ATmega(pe baza căruia este construit Arduino) au rezistențe de sarcină conectate prin software încorporate R n 20 kOhm și le putem folosi simplificând schema de conectare.

Rezistorul de sarcină intern este conectat prin scrierea unuia logic la bitul necesar al portului.

Exemplu de schiță Arduino, care aprinde și stinge LED-ul încorporat de pe pinul 13, în funcție de dacă butonul conectat la al doilea pin este apăsat sau eliberat, folosind o rezistență de sarcină internă:

void setup() ( pinMode(13, OUTPUT); //LED pe pinul 13 pinMode(2, INPUT); //2 pini sunt în modul de intrare. Butonul este conectat la masă. digitalWrite(2, HIGH); // conectați rezistența de tragere ) void loop() ( digitalWrite(13, !digitalRead(2)); // citiți starea butonului și comutați LED-ul )

Aici inversăm valoarea citită de la portul de intrare folosind un boolean NU, notat printr-un semn de exclamare înaintea funcției digitalRead, deoarece atunci când butonul este apăsat citim 0, iar pentru a aprinde LED-ul către port trebuie să trimitem 1.

Sarirea contactului

Totul ar fi bine dacă am locui acolo lume ideală cu nasturi perfecti. Contactele mecanice reale care sunt prezente în butoane nu se închid sau se deschid instantaneu. Într-o perioadă scurtă de timp, contactele cheii (butonului) sunt închise și deschise în mod repetat, drept urmare nu se primește o singură cădere de tensiune, ci un întreg pachet de impulsuri la intrarea microcontrolerului. Acest fenomen se numește „sarire de contact”.

În exemplul de mai sus, când pur și simplu am pornit și stins LED-ul folosind un buton, nu am observat acest lucru, deoarece pornirea/oprirea LED-ului în momentul „săririi” sa întâmplat foarte repede și pur și simplu nu l-am văzut cu ajutorul nostru. ochi.

Această bibliotecă include următoarele metode:

• sări()— inițializarea obiectului Bounce
• interval nul (interval lung nesemnat)— setează timpul anti-sarire în milisecunde
• atașare goală (pin int)— setează pinul la care este conectat butonul și conectează rezistența de pull-up încorporată la acest pin
• int update()- pentru că Sări nu folosește , „actualizați” obiectul înainte de a-i citi starea și acest lucru trebuie făcut în mod constant (de exemplu, în interiorul buclă). Metodă actualizare actualizează obiectul și revine ADEVĂRAT(1), dacă starea pinului s-a schimbat (butonul a fost apăsat sau, dimpotrivă, eliberat) și FALS(0) în caz contrar. Apelarea unei metode actualizare interior buclă trebuie făcută o singură dată.
• int read()— returnează starea actualizată a pinului

În mod implicit, biblioteca Bounce utilizează un interval de stabilizare ( interval stabil) pentru a implementa anti-rebond. Acest lucru este mai ușor de înțeles și elimină necesitatea de a cunoaște durata conversației.

Parametru interval stabil Biblioteci de respingere

După ce a hotărât

#define BOUNCE_LOCK-OUT

#define BOUNCE_LOCK-OUT

în dosar Bounce.h poate fi pornit metoda alternativa lupta împotriva vorbăriei. Această metodă vă permite să reacționați mai rapid la modificările stării butonului, cu toate acestea, necesită setarea duratei săriturii, iar această valoare, așa cum am menționat mai sus, crește în timp, ceea ce înseamnă că va trebui să faceți modificări la cod sau setați o valoare în mod deliberat mai mare.

Iată un exemplu de utilizare a acestei biblioteci:

#include Bounce bouncer = Bounce(); //creați o instanță a clasei Bounce void setup() ( pinMode(2 ,INPUT); // butonul de pe pinul 2 digitalWrite(2 ,HIGH); // conectați rezistorul de pull-up încorporat .attach(2) ); // instalează butonul bouncer (5) // setează parametrul interval stabil = 5 ms Serial.begin(9600) // setarea portului serial la 9600 bps (if (bouncer). update()) ( // dacă apare un eveniment dacă (bouncer.read()==0) ( //dacă butonul este apăsat Serial.println("apăsat"); //afișează un mesaj despre apăsarea ) altfel Serial. println("eliberat" //afișează un mesaj despre renunțare) )

#include Bounce bouncer = Bounce () ; //creați o instanță a clasei Bounce void setup() pinMode(2, INPUT); // butonul de pe pinul 2 digitalWrite(2, HIGH); // conectați rezistența de pull-up încorporată bouncer. atașează(2); // setați butonul bouncer. interval(5); // setați intervalul stabil al parametrului = 5 ms Serial. începe(9600); //setează portul serial la 9600 bps buclă goală () if (bouncer . update () ) { //dacă a avut loc un eveniment dacă (bouncer . citește () == 0 )

Un buton este un dispozitiv mecanic binecunoscut care poate închide și deschide un circuit electric după bunul plac. Există multe tipuri de butoane care funcționează în funcție de reguli diferite. De exemplu, butonul de apăsare folosit în acest tutorial completează circuitul doar atâta timp cât apăsați degetul pe el. Un buton deschis, pe de altă parte, întrerupe circuitul atunci când este apăsat.

Există butoane cu un grup de contacte, dintre care unele întrerup circuitul atunci când sunt apăsate, în timp ce altele se închid în acest moment. Versiunile mici ale acestor butoane sunt adesea numite microîntrerupătoare.

Butoanele de tact pot fi găsite în aproape orice dispozitiv electronic: pe tastatura unui computer, pe un telefon, pe o telecomandă a televizorului etc.

Există butoane de blocare care funcționează ca un buton pix: apăsat o dată - circuitul este închis, a doua oară - se rupe. Fotografia arată doar una dintre acestea. Butoanele de blocare sunt convenabile de utilizat pentru a comuta modul de operare al dispozitivului. De exemplu, puteți comuta sursa de alimentare: baterie sau sursă de alimentare.

Sau o altă opțiune - butoane mari pentru oprirea de urgență a echipamentului. Sunt pictate în interior culori strălucitoare pentru a atrage atenția unei persoane. În esență, sunt butoane tactile obișnuite pentru deschidere sau butoane cu blocare.

Acestea sunt doar câteva dintre opțiuni. Pe lângă butoane, în lumea electricității există și alte mecanisme, precum întrerupătoarele și întrerupătoarele. Toate sunt proiectate pentru a controla mecanic fluxul de curent în circuit.

1. Conexiune

Deci, vom lucra cu cel mai simplu buton tact, la care vom încerca să ne conectăm Arduino Uno. În mod obișnuit, atunci când lucrați cu panouri fără lipire, se folosește un buton cu știfturi de lipit. În fotografia de la începutul lecției puteți vedea că un astfel de buton are patru ace ușor îndoite. Există butoane cu două ieșiri directe, sunt potrivite și pentru activitățile noastre.

Pe scheme electrice butonul arata asa:

Și așa arată diagrama de contact din butonul nostru:

De regulă, știfturile butonului de tact sunt plasate laturi opuse carcase în perechi. Adică putem folosi fie o pereche de contacte pe o parte, fie o pereche pe cealaltă.

Acesta este modul în care butonul este conectat la placa:

Acum să încercăm să asamblam cel mai simplu circuit pe o placă care va demonstra funcționarea butonului. Vom aprinde LED-ul.

Circuitul rezultat îndeplinește o funcție simplă: apăsați butonul - LED-ul se aprinde, eliberați-l - se stinge. Putem asambla exact același circuit fără buton. Este suficient să închideți și să deschideți manual oricare dintre cele șase conexiuni din diagramă.

2.Conectează-te la Arduino Uno

Acum că funcția butonului este extrem de clară, să încercăm să conectăm butonul la microcontroler și să scriem programul corespunzător. Să ne stabilim o sarcină simplă: lăsați LED-ul Arduino Uno să clipească de trei ori când apăsați butonul Arduino Uno o dată. Pentru a rezolva această problemă folosim următoarea schemă:

În această diagramă vedem circuitul deja familiar pentru. Vedem și un buton conectat la pinul Arduino nr. 3. Aici poate apărea destul de rezonabil o întrebare: de ce am conectat și butonul la masă, printr-un rezistor de 10 kOhm? Pentru a rezolva această problemă, să ne imaginăm că am conectat butonul conform unei scheme „naive” fără bretele :)

Aici, între pinul nr. 3 și masă, există un mic condensator care poate acumula încărcare. Multe microcontrolere au această caracteristică.

Acum imaginați-vă că închidem butonul. Curentul începe să curgă de la +5V, direct la contactul nr. 3, încărcând simultan capacitatea. Arduino înregistrează cu succes apăsarea butonului. Dar după ce ne scoatem degetul de pe butonul ceasului, contrar așteptărilor noastre, microcontrolerul continuă să considere că butonul este apăsat! Desigur, pentru că un condensator încărcat eliberează treptat sarcina acumulată la piciorul nr. 3. Acest lucru va continua până când capacitatea este descărcată sub nivelul logic.

3. Program

În cele din urmă, ne-am dat seama de nuanțele schemei noastre și suntem gata să scriem un program. În tutorialul software, am învățat despre funcțiile pentru configurarea pinurilor pinModeși funcție de ieșire digitală digitalWrite. De data aceasta avem nevoie de o altă funcție importantă care oferă informații de intrare către microcontroler:

DigitalRead(număr_de_contact);

Această funcție returnează valoarea booleană pe care Arduino a citit-o de la un pin dat. Aceasta înseamnă că dacă se aplică +5V la contact, funcția va reveni adevăr*. Dacă contactul este conectat la masă, obținem valoarea minciună. În C++, adevărat și fals sunt echivalente cu numerele 1 și, respectiv, 0.

Pentru ca contactul care ne interesează să funcționeze în modul de introducere a informațiilor, va trebui să îl setăm într-un anumit mod:

PinMode(număr_pin, INTRARE);

În cele din urmă, să punem totul împreună și să scriem un program.

Const int led = 2; buton const int = 3; int val = 0; void setup())( pinMode(led, OUTPUT); pinMode(button, INPUT); ) void loop())( val = digitalRead(button); if(val)( for(int i=0; i<3; i++){ digitalWrite(led, HIGH); delay(500); digitalWrite(led, LOW); delay(500); } } }

Încărcăm programul pe Arduino Uno și verificăm funcționarea programului. Dacă totul este făcut corect, ar trebui să arate ca în imagine:

Ei bine, asta-i tot. Acum ne putem controla dispozitivele folosind butoane. Dacă ați terminat deja lecția pe, atunci vom putea face un ceas cu ceas cu alarmă!

Note:

* În standardele logice TTL, adevăratul corespunde tensiunii de la 2V la 5V și fals de la 0V la 0,8V

Primul program ar trebui să controleze LED-ul folosind un buton:

• la apăsarea butonului, LED-ul se aprinde;
• Când butonul este apăsat, LED-ul nu se aprinde.

Conectarea unui buton și LED la placa Arduino.

Pentru a comunica cu elemente externe, controlerul Arduino UNO are 14 pini digitali. Fiecare pin poate fi definit de program ca intrare sau ieșire.

Ieșirea digitală are doar două stări, înaltă și scăzută. Starea înaltă corespunde unei tensiuni de ieșire de aproximativ 5 V, starea joasă – 0 V. Ieșirea permite conectarea unei sarcini cu un curent de până la 40 mA.

Odată ce un pin este definit ca intrare, citind starea acestuia, nivelul tensiunii la intrare poate fi determinat. La o tensiune apropiată de 5 V (de fapt mai mare de 3 V), se va citi o stare ridicată, corespunzătoare constantei HIGH. Când tensiunea este aproape de 0 (mai puțin de 1,5 V), va fi citită o stare scăzută sau constantă LOW.

Trebuie să conectăm LED-ul la pin, definindu-l ca ieșire, iar butonul este conectat la pin cu modul de intrare.

LED-ul este conectat printr-un rezistor limitator de curent. Iată o diagramă tipică.

Rezistorul se calculează folosind formula I = Uieșire – Udrop pe LED / R.

Uieșire = 5 V, Udrop pe LED poate fi luată egală cu 1,5 V (indicat mai precis în cartea de referință). Se pare că în circuitul nostru curentul prin LED este setat la 10 mA.

Puteți alege orice pin, dar vă sugerez să folosiți LED-ul montat pe placă pentru ușurința conexiunilor. Același care a clipit în primul exemplu de test. Este conectat la pinul digital 13. În acest caz, nu este nevoie să conectați un LED suplimentar la placă.

Conectăm butonul la orice alt pin, de exemplu, 12. Hardware-ul circuitului de conectare a butonului trebuie să ofere niveluri de tensiune de 0 V când butonul este apăsat și 5 V când butonul este liber. Acest lucru se poate face cu o diagramă simplă.

Când butonul este apăsat, rezistorul generează 5 V la ieșire, iar atunci când este apăsat, intrarea este scurtcircuitată la masă. Voi scrie recomandări pentru alegerea unui rezistor în lecția finală despre butoane. Acum voi oferi o altă variantă. Toți pinii plăcii au rezistențe în interiorul controlerului conectate la 5 V. Aceștia pot fi activați sau dezactivați software de la pini. Rezistența acestor rezistențe este de aproximativ 20-50 kOhm. Prea mult pentru circuitele reale, dar pentru programul nostru și un buton instalat lângă controler, este destul de acceptabil.

Ca rezultat, schema de conectare va arăta astfel.

Butonul poate fi lipit pe firele la conector. L-am instalat pe o placă fără lipire. L-am cumpărat special pentru a demonstra lecții.

Funcții de control I/O.

Pentru a lucra cu ieșiri digitale, sistemul Arduino are 3 funcții încorporate. Acestea vă permit să setați modul de ieșire, să citiți sau să setați ieșirea la o anumită stare. Pentru a determina starea pinilor, aceste funcții folosesc constantele HIGH și LOW, care corespund nivelurilor de semnal ridicat și scăzut.

pinMode(pin, mod)

Setează modul de ieșire (intrare sau ieșire).

Argumente: pin și mod.

• pin – număr pin;
• mod – mod de ieșire.

Funcția nu returnează nimic.

digitalWrite(pin, valoare)

Setează starea ieșirii (înaltă sau scăzută).

Pin și valoare argumente:

• pin – număr pin;
• valoare – starea ieșirii.

Funcția nu returnează nimic.

digitalRead(pin)

Citește starea intrării.

Argumente: pin - număr pin.

Returnează starea de conectare:

digitalRead(pin) = LOW	nivel scăzut de intrare
digitalRead(pin) = HIGH	nivel ridicat de intrare

Program de control LED.

Ținând cont de lecția anterioară, acum avem toate informațiile de care avem nevoie pentru a scrie un program. Programul Arduino constă din două funcții setup() și loop. În setup() setăm modurile pin, iar în loop() citim starea butonului în variabila buttonState și o transmitem LED-ului. Ne inversăm pe parcurs, pentru că când butonul este apăsat, starea semnalului este scăzută, iar LED-ul se aprinde când este ridicat.

/* Program scetch_5_1 lecția 5
*/

buton boolean State; // creați o variabilă globală buttonState

void setup() (
pinMode(13, IEȘIRE); //

}

// buclă nesfârșită
pinMode(buttonPin, INPUT);



}

Pentru a stoca valoarea intermediară a stării butonului, creați o variabilă buttonState de tip boolean. Acesta este un tip de date boolean. Variabila poate lua una din două valori: adevărat sau fals. În cazul nostru, LED-ul se aprinde și nu se aprinde.

Copiați sau rescrieți codul programului în fereastra Arduino IDE. Descărcați în controler și verificați.

Pentru a salva proiecte Arduino, am creat un folder d:\Arduino Projects\Lessons\Lesson5. În fiecare lecție a programului pe care o numesc scetch_5_1, scetch_5_2, ... Puteți face același lucru sau puteți introduce propriul sistem de salvare a fișierelor.

Bloc de program:

buttonState = digitalRead(12); // citiți starea intrării 12 (buton) și scrieți în buttonState
buttonState = ! ButonState; // inversarea variabilei buttonState
digitalWrite(13, buttonState); // scrieți starea de la buttonState la ieșirea 13 (LED)

poate fi scris fără a utiliza variabila intermediară buttonState.

digitalWrite(13, ! digitalRead(12));

Argumentul pentru funcția digitalWrite() este funcția digitalRead(). Stilul bun este doar o astfel de opțiune. Nu sunt necesare variabile suplimentare, mai puțin text.

Aceste. o funcție poate fi folosită ca argument pentru o altă funcție. Funcțiile pot fi apelate din funcții.

O altă versiune a aceluiași program folosind o instrucțiune condițională if.

/* Program scetch_5_2 lecția 5
Aprinde LED-ul (pin 13) când butonul (pin 12) este apăsat */

void setup() (
pinMode(13, IEȘIRE); // definiți pinul 13 (LED) ca ieșire
pinMode(12, INPUT_PULLUP); // definiți pinul 12 (buton) ca intrare
}

// buclă nesfârșită
pinMode(buttonPin, INPUT);
if (digitalRead(12) == LOW) digitalWrite(13, HIGH);
else digitalWrite(13, LOW);
}

Într-o buclă fără sfârșit, starea pinului 12 (buton) este verificată, iar dacă este scăzută (LOW), atunci se formează o stare înaltă (HIGH) la pinul 13 (LED). În caz contrar, starea LED-ului este LOW.

#define directivă.

În toate exemplele pentru funcțiile I/O, am specificat argumentul pin, care determină numărul pin, ca un număr specific - o constantă. Ne-am amintit că constanta 12 este numărul de pin al butonului, iar 13 este numărul de pin al LED-ului. Este mult mai convenabil să lucrezi cu nume simbolice. În acest scop, în limbajul C există o directivă care leagă identificatorii cu constante și expresii.

Directiva #define definește un identificator și o secvență de caractere care este înlocuită cu identificatorul de fiecare dată când acesta apare în textul programului.

In general arata asa:

#define nume caractere_secvență

Dacă în programele noastre scriem:

#define LED_PIN 13 //

apoi de fiecare dată când numele LED_PIN este întâlnit în program, simbolurile 13 vor fi înlocuite în timpul translației Funcția de aprindere a LED-ului arată astfel:

digitalWrite(LED_PIN, HIGH);

Programul final folosind #define.

/* Programul lecției 5
Aprinde LED-ul (pin 13) când butonul (pin 12) este apăsat */

#define LED_PIN 13 // Numărul pinului LED-ului este 13
#define BUTTON_PIN 12 // numărul pinului butonului este 12

void setup() (
pinMode(LED_PIN, OUTPUT); // definiți pinul 13 (LED) ca ieșire
pinMode(BUTTON_PIN, INPUT_PULLUP); // definiți pinul 12 (buton) ca intrare
}

// buclă nesfârșită
pinMode(buttonPin, INPUT);
digitalWrite(LED_PIN, ! digitalRead(BUTTON_PIN));
}

Rețineți că nu există punct și virgulă după directiva #define deoarece este un pseudo operator. Nu ia nicio măsură. Directiva specifică constante, deci este obișnuit să scrieți numele pentru ele cu majuscule cu un delimitator - liniuță.

În lecția următoare ne vom ocupa de chatterul butoanelor, vom împărți programul în blocuri și vom crea o interfață de comunicare între blocuri.