noiembrie 21, 2026
Buton tactil conectat la o placă Arduino pe un breadboard pentru testarea unei intrări digitale cu INPUT_PULLUP.

Montaj demonstrativ cu un buton conectat între intrarea digitală și GND pentru testarea funcției INPUT_PULLUP.

Un buton pare una dintre cele mai simple componente electronice, dar citirea lui corectă implică două lucruri importante: pinul de intrare trebuie să aibă permanent o stare logică definită, iar programul trebuie să ignore oscilațiile foarte scurte produse de contactele mecanice. În acest ghid conectăm un buton momentan la o placă Arduino, folosim rezistența internă INPUT_PULLUP și construim un program care schimbă starea LED-ului la fiecare apăsare validă, fără să numere de mai multe ori aceeași apăsare.

Proiectul continuă seria de exerciții practice din categoria Electronică și Robotică. Dacă nu ai folosit încă o placă de dezvoltare, începe cu prezentarea diferențelor dintre Arduino și Raspberry Pi. Aici ne concentrăm strict pe o intrare digitală și pe citirea fiabilă a unui contact.

Ce vei construi și ce trebuie să înțelegi

La final, butonul va controla LED-ul integrat al plăcii sau un LED extern montat corect. O apăsare validă va aprinde LED-ul dacă era stins și îl va stinge dacă era aprins. Programul va recunoaște tranziția de la eliberat la apăsat, va aștepta stabilizarea contactului și abia apoi va schimba starea ieșirii.

  • vei identifica pinii unui buton tactil cu patru terminale;
  • vei conecta butonul între un pin digital și GND;
  • vei folosi pinMode() cu INPUT_PULLUP și vei citi starea prin digitalRead();
  • vei înțelege de ce logica pare inversată: apăsat înseamnă LOW;
  • vei aplica o metodă de debounce fără întârzieri lungi în bucla principală.

Componente și pregătirea montajului

Pentru exemplu folosim o placă Arduino UNO R3 sau o placă compatibilă, un buton momentan (pushbutton), un breadboard și două fire jumper. LED-ul integrat, identificat în program prin LED_BUILTIN, este suficient pentru primul test. Nu ai nevoie de un rezistor extern pentru intrarea butonului atunci când folosești rezistența internă de pull-up.

Dacă vrei să folosești un LED extern, adaugă un LED și un rezistor de limitare a curentului, de exemplu 220–330 Ω într-un montaj demonstrativ pentru o placă de 5 V. Conectează LED-ul în serie cu rezistorul, nu direct între pin și GND. Pentru alt model de placă, verifică tensiunea logică și limitele electrice din documentația producătorului.

Cum recunoști terminalele unui buton cu patru pini

Multe butoane tactile mici au patru terminale, dar cele două terminale de pe aceeași latură sunt deja conectate electric între ele. La apăsare, contactul unește cele două perechi. De aceea, butonul se montează de obicei peste șanțul central al breadboard-ului, astfel încât fiecare pereche să ajungă pe câte o parte a șanțului.

Nu te baza exclusiv pe forma capsulei sau pe poziția picioarelor. Dacă nu ești sigur, verifică perechile cu funcția de continuitate a unui multimetru, fără alimentarea circuitului. Astfel eviți să conectezi ambele fire la aceeași pereche, situație în care apăsarea nu va schimba starea intrării.

Schema de conectare cu INPUT_PULLUP

Alege un pin digital, de exemplu D2, și conectează un terminal al butonului la acesta. Celălalt terminal al butonului se conectează la GND. În acest montaj nu legăm butonul la 5 V: rezistența internă de pull-up menține intrarea la nivel logic HIGH cât timp contactul este deschis.

  • un terminal al butonului → pinul digital D2;
  • terminalul opus al butonului → GND;
  • LED-ul integrat al plăcii → este controlat prin LED_BUILTIN în program;
  • placa → conectată la calculator prin USB pentru încărcarea sketch-ului și deschiderea Serial Monitor.

Înainte de conectarea USB-ului, verifică poziția butonului pe breadboard și asigură-te că firele ajung la două contacte opuse, nu la aceeași pereche internă. Nu modifica legăturile cu circuitul alimentat. Dacă folosești o placă de 3,3 V, păstrează toate conexiunile în limitele ei și nu aplica 5 V pe intrările care nu sunt tolerate la această tensiune.

De ce folosim rezistența internă de pull-up

Un pin configurat simplu ca INPUT are impedanță mare. Dacă butonul este deschis și pinul nu este legat nici la HIGH, nici la LOW printr-un circuit adecvat, intrarea poate rămâne „în aer” (floating). În această situație, zgomotul electric poate produce citiri care alternează aparent aleatoriu între cele două niveluri logice.

Prin pinMode(pinButon, INPUT_PULLUP), microcontrolerul activează rezistența internă de pull-up. Când butonul este liber, intrarea este menținută la HIGH. Când apeși butonul, contactul o leagă la GND, iar citirea devine LOW. Această inversare este normală și trebuie reflectată în condițiile programului.

Starea butonuluiLegătura electricăValoarea citită
EliberatPull-up menține pinul la nivel HIGHHIGH
ApăsatButonul conectează pinul la GNDLOW

Aceeași idee este prezentată în exemplul oficial Arduino Digital Input Pull-Up Resistor. Reține că logica HIGH/LOW descrie nivelul electric citit de pin, nu sensul obișnuit al cuvintelor „pornit” și „oprit”.

Primul test: citește butonul în Serial Monitor

Înainte să adaugi logica de debounce, verifică dacă placa detectează corect apăsarea. În Arduino IDE selectează placa și portul potrivit, încarcă programul de mai jos și deschide Serial Monitor la 9600 baud.

const byte pinButon = 2;

void setup() {
  pinMode(pinButon, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int stare = digitalRead(pinButon);

  if (stare == LOW) {
    Serial.println("Buton apasat");
  } else {
    Serial.println("Buton eliberat");
  }

  delay(100);
}

Dacă mesajele se schimbă atunci când apeși și eliberezi butonul, conexiunea de bază funcționează. Este posibil să observi mai multe mesaje „Buton apasat” cât timp ții apăsat contactul: programul citește starea în mod repetat, nu numără doar evenimentul de apăsare. În plus, contactul mecanic poate oscila pentru scurt timp în momentul comutării.

Ce este efectul de bounce și de ce trebuie eliminat

Un buton mecanic nu trece întotdeauna instantaneu și perfect de la deschis la închis. La atingerea contactelor, acestea pot vibra și pot produce mai multe tranziții electrice foarte rapide înainte să se stabilizeze. Fenomenul este cunoscut drept contact bounce sau bouncing.

Pentru un om, apăsarea a fost o singură acțiune. Pentru microcontroler, oscilațiile pot arăta ca mai multe apăsări succesive. Dacă programul schimbă LED-ul la fiecare tranziție detectată, o singură apăsare poate produce un rezultat imprevizibil. Debounce înseamnă să accepți schimbarea numai după ce noua stare a rămas stabilă o perioadă scurtă.

Documentația Arduino explică fenomenul în exemplul Debounce on a Pushbutton. Durata necesară depinde de buton și de circuit; în exemplul nostru folosim 35 ms ca valoare inițială de test, nu ca parametru universal pentru toate componentele.

Program complet: fiecare apăsare schimbă starea LED-ului

Următorul sketch urmărește ultima citire, momentul în care a fost observată o schimbare și ultima stare confirmată ca stabilă. LED-ul se schimbă numai când programul confirmă o tranziție stabilă către LOW, adică atunci când butonul a fost apăsat. Eliberarea butonului pregătește următoarea apăsare, dar nu schimbă LED-ul.

const byte pinButon = 2;
const byte pinLed = LED_BUILTIN;

const unsigned long timpDebounce = 35;

bool ultimaCitire = HIGH;
bool stareStabila = HIGH;
bool ledAprins = false;

unsigned long momentSchimbare = 0;

void setup() {
  pinMode(pinButon, INPUT_PULLUP);
  pinMode(pinLed, OUTPUT);

  digitalWrite(pinLed, LOW);
  Serial.begin(9600);
}

void loop() {
  bool citireCurenta = digitalRead(pinButon);

  // Memorăm momentul în care citirea s-a schimbat.
  if (citireCurenta != ultimaCitire) {
    momentSchimbare = millis();
    ultimaCitire = citireCurenta;
  }

  // Acceptăm noua stare numai după intervalul de stabilizare.
  if (millis() - momentSchimbare >= timpDebounce) {
    if (citireCurenta != stareStabila) {
      stareStabila = citireCurenta;

      // Cu INPUT_PULLUP, apăsarea înseamnă LOW.
      if (stareStabila == LOW) {
        ledAprins = !ledAprins;
        digitalWrite(pinLed, ledAprins ? HIGH : LOW);

        if (ledAprins) {
          Serial.println("LED aprins");
        } else {
          Serial.println("LED stins");
        }
      }
    }
  }
}

Încarcă programul și apasă butonul de câteva ori, cu pauze diferite între apăsări. LED-ul integrat ar trebui să-și schimbe starea o singură dată pentru fiecare apăsare confirmată. Dacă îl ții apăsat, LED-ul nu trebuie să alterneze continuu. În Serial Monitor ar trebui să apară un singur mesaj la fiecare apăsare validă.

Cum funcționează variabilele din program

  • ultimaCitire păstrează ultima valoare observată direct la pin;
  • momentSchimbare reține momentul ultimei tranziții, folosind millis();
  • stareStabila memorează ultima stare acceptată după debounce;
  • timpDebounce definește intervalul de stabilizare în milisecunde;
  • ledAprins reține starea logică a LED-ului, independent de citirea butonului.

Folosim millis() în locul unei întârzieri lungi cu delay(), astfel încât bucla principală să poată continua să ruleze și să observe alte evenimente. Diferența dintre timpul curent și momentul ultimei schimbări este calculată cu tipul unsigned long, o abordare potrivită pentru temporizări care se repetă.

Probleme frecvente și verificări rapide

SimptomCauză posibilăCe verifici
Butonul pare apăsat permanentFirele sunt conectate la aceeași pereche sau pinul este legat permanent la GNDVerifică poziția butonului și continuitatea terminalelor
Starea se schimbă aleatoriuIntrarea este floating sau montajul are contacte slabeConfirmă folosirea INPUT_PULLUP și legătura la GND
O apăsare schimbă LED-ul de mai multe oriDebounce lipsește sau intervalul este prea mic pentru butonVerifică logica de stabilizare și ajustează prudent timpul
LED-ul nu se aprindePlaca folosește alt pin pentru LED-ul integrat sau sketch-ul nu a fost încărcat corectVerifică mesajul de upload și documentația modelului
Butonul funcționează invers față de așteptăriLogica INPUT_PULLUP este interpretată ca logică activă HIGHTratează LOW drept apăsat și HIGH drept eliberat

Dacă vrei să numeri apăsările în loc să alternezi un LED, păstrează aceeași detectare a tranziției stabile și incrementează un contor numai când starea confirmată devine LOW. Exemplul oficial Arduino State Change Detection prezintă principiul detectării schimbării de stare pentru un buton.

Cum extinzi proiectul fără să complici circuitul

După ce ai confirmat că butonul funcționează, îl poți folosi ca selector de mod, comandă pentru un meniu simplu sau declanșator pentru o secvență de măsurare. Poți adăuga un al doilea buton pentru o a doua comandă, dar fiecare intrare trebuie configurată și testată separat. Pentru mai multe butoane, păstrează aceeași regulă: fiecare pin trebuie să aibă o stare logică definită și fiecare contact mecanic trebuie tratat cu o metodă de debounce potrivită.

Dacă ai lucrat deja cu un senzor LDR, observă diferența dintre cele două tipuri de intrări: în proiectul de iluminare automată cu Arduino și LDR citim o valoare analogică variabilă, în timp ce butonul de aici oferă două stări digitale. În ambele cazuri, programul transformă o citire într-o acțiune asupra unei ieșiri.

De la o apăsare simplă la o comandă fiabilă

Un buton conectat corect este un exercițiu bun pentru înțelegerea intrărilor digitale, a rezistențelor pull-up și a detectării evenimentelor. Cheia nu este doar să citești HIGH sau LOW, ci să te asiguri că pinul nu rămâne flotant și că o singură apăsare mecanică este interpretată ca un singur eveniment logic.

Păstrează schema de cablare lângă sketch, testează întâi montajul minimal și modifică un singur lucru odată. După ce înțelegi acest circuit, aceeași tehnică poate deveni baza comenzilor manuale pentru senzori, actuatoare și proiecte de automatizare mai complexe.


Descoperă mai multe la Scoala IT

Abonează-te ca să primești ultimele articole prin email.

Descoperă mai multe la Scoala IT

Abonează-te acum ca să citești în continuare și să ai acces la întreaga arhivă.

Continuă lectura