Portul digital de intrare-ieșire

1Obiectivele lucrării

• Înțelegerea rolului regiștrilor DDRx, PORTx și PINx
• Configurarea pinilor prin acces direct la regiștri, cu operații pe biți
• Utilizarea rezistoarelor de pull-up interne pentru citirea butoanelor
• Implementarea eliminării vibrațiilor contactelor
• Compararea vitezei între digitalWrite() și scrierea directă în registru

2Materiale necesare

• 1 Arduino Uno
• 1 Breadboard
• 4 LED-uri
• 4 Rezistoare 220 Ω
• 2 Butoane
• 10 Fire jumper

3Cei trei regiștri ai unui port

ATmega328P are trei porturi: B (pinii digitali 8–13), C (pinii analogici A0–A5) și D (pinii digitali 0–7). Fiecare este controlat de trei regiștri de câte 8 biți:

Tabela de configurare completă

4Structura internă a unui pin

5Simulator de regiștri

Apăsați pe biți pentru a modifica regiștrii. Starea pinilor din partea de jos se actualizează exact după tabela de configurare - la fel ca pe microcontrolerul real.

6Laborator de măști

Nu se modifică niciodată tot registrul dacă se dorește schimbarea unui singur pin - s-ar afecta ceilalți șapte. Se folosesc măști de biți, construite cu operatorul de deplasare:

Verificați mai jos, bit cu bit, ce face fiecare operație. Alegeți operatorul & cu operandul B pe 11011111 ca să vedeți cum se șterge exact bitul 5.

7Scheme de montaj

8Vibrațiile contactului

Un buton mecanic nu comută curat. Lamelele metalice vibrează câteva milisecunde la contact, generând zeci de tranziții false. Fără filtrare, o singură apăsare fizică este văzută de program ca mai multe apăsări.

9Simulator de debounce

Urmăriți pas cu pas cum algoritmul respinge tranzițiile false și acceptă doar starea stabilă. Observați că vibrațiile de la t = 102 și t = 107 nu produc nicio incrementare.

10Cod sursă

Funcții Arduino vs. acces direct la regiștri

void setup() {
  // --- varianta Arduino: lizibila, dar lenta ---
  pinMode(13, OUTPUT);
  pinMode(2, INPUT_PULLUP);

  // --- varianta echivalenta cu registri: rapida ---
  DDRB  |= (1 << PB5);    // pinul 13 = iesire
  DDRD  &= ~(1 << PD2);   // pinul 2  = intrare
  PORTD |= (1 << PD2);    // activeaza pull-up pe pinul 2
}

void loop() {
  // citirea butonului: 0 = apasat, din cauza pull-up-ului
  if (!(PIND & (1 << PD2))) {
    PORTB |= (1 << PB5);    // aprinde
  } else {
    PORTB &= ~(1 << PB5);   // stinge
  }
}

Măsurarea diferenței de viteză

Nu avem încă monitorul serial (lucrarea 6), așa că nu tipărim durata: o facem vizibilă. Fiecare metodă comută pinul într-o buclă strânsă, iar pinul comandă un LED separat. Cu cât metoda este mai rapidă, cu atât bucla se termină mai devreme și LED-ul de „ocupat” stă aprins mai puțin. Diferența se vede cu ochiul liber, iar pe osciloscop se poate și măsura.

const uint16_t N = 20000;

void setup() {
  DDRB |= (1 << PB0);          // pinul 8: pinul care se comuta
  DDRB |= (1 << PB4);          // pinul 12: martor "ruleaza digitalWrite"
  DDRB |= (1 << PB3);          // pinul 11: martor "ruleaza varianta cu registru"
}

void loop() {
  // ---- varianta cu functie: martorul de pe pinul 12 sta aprins cat dureaza
  PORTB |= (1 << PB4);
  for (uint16_t i = 0; i < N; i++) {
    digitalWrite(8, HIGH);
    digitalWrite(8, LOW);
  }
  PORTB &= ~(1 << PB4);

  delay(400);

  // ---- varianta cu registru: martorul de pe pinul 11
  PORTB |= (1 << PB3);
  for (uint16_t i = 0; i < N; i++) {
    PORTB |=  (1 << PB0);
    PORTB &= ~(1 << PB0);
  }
  PORTB &= ~(1 << PB3);

  delay(400);
}

Debounce complet

const uint8_t PIN_BUTON = 2;
const uint8_t PIN_LED   = 13;
const uint16_t INTERVAL_DEBOUNCE = 40;   // ms

bool stareLed      = false;
bool ultimaCitire  = HIGH;
bool stareStabila  = HIGH;
unsigned long ultimulMoment = 0;

void setup() {
  pinMode(PIN_BUTON, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  bool citire = digitalRead(PIN_BUTON);

  if (citire != ultimaCitire) {          // orice schimbare reporneste cronometrul
    ultimulMoment = millis();
    ultimaCitire  = citire;
  }

  if (millis() - ultimulMoment > INTERVAL_DEBOUNCE) {
    if (citire != stareStabila) {        // starea s-a stabilizat
      stareStabila = citire;

      if (stareStabila == LOW) {         // front descendent = apasare reala
        stareLed = !stareLed;
        digitalWrite(PIN_LED, stareLed);   // o singura comutare pe apasare
      }
    }
  }
}

Efect de lumini pe patru LED-uri

void setup() {
  DDRB |= 0b00001111;    // pinii 8, 9, 10, 11 ca iesiri, dintr-o singura operatie
}

void loop() {
  // deplasare la stanga
  for (uint8_t i = 0; i < 4; i++) {
    PORTB = (PORTB & 0xF0) | (1 << i);   // pastreaza bitii 4-7, seteaza doar unul din 0-3
    delay(120);
  }
  // deplasare la dreapta, fara a repeta capetele
  for (int8_t i = 2; i > 0; i--) {
    PORTB = (PORTB & 0xF0) | (1 << i);
    delay(120);
  }
}

11Montaj interactiv

Un pin de intrare se citește din PINx, nu din PORTx - iar când folosiți rezistența internă de ridicare, logica se inversează: butonul apăsat înseamnă 0. Montajele de mai jos vă lasă să apăsați butonul cu mouse-ul și să vedeți bitul din PIND schimbându-se în timp real.

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRD  &= ~(1 << PD2);      // pinul 2 este INTRARE
    PORTD |=  (1 << PD2);      // rezistenta interna de ridicare, activa
    DDRB  |=  (1 << PB5);      // pinul 13 este IESIRE
    DDRD  |=  (1 << PD7);      // pinul 7 este IESIRE

    while (1) {
        if (!(PIND & (1 << PD2))) {     // bitul este 0 -> buton APASAT
            PORTB |=  (1 << PB5);       // LED-ul "apasat" se aprinde
        } else {
            PORTB &= ~(1 << PB5);
        }

        /* Al doilea LED copiaza bitul brut, fara negare.
           Priviti-le pe amandoua: sunt mereu in opozitie. */
        if (PIND & (1 << PD2)) PORTD |=  (1 << PD7);
        else                   PORTD &= ~(1 << PD7);

        _delay_ms(150);
    }
}

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRD  &= ~(1 << PD2);      // pinul 2 = INTRARE (butonul)
    PORTD |=  (1 << PD2);      // rezistenta interna de ridicare
    DDRB  |=  (1 << PB5);      // pinul 13 = IESIRE (LED-ul)

    /* Butonul in repaus da 1. Apasat, da 0.
       Daca am scrie doar "daca este 0, comuta LED-ul", LED-ul ar comuta
       de sute de ori cat tinem butonul apasat. Noi vrem O SINGURA data,
       chiar in clipa apasarii - adica exact cand citirea TRECE din 1 in 0.
       Ca sa prindem trecerea, tinem minte ce am citit rotirea trecuta. */

    unsigned char stareAnterioara = 1;   // in repaus butonul da 1

    while (1) {
        unsigned char stareCurenta = (PIND & (1 << PD2)) ? 1 : 0;

        /* --- PASUL 1 -----------------------------------------------
           Inlocuiti 0 de mai jos cu conditia de trecere din 1 in 0:
           "inainte era 1 SI acum este 0", scris cu == si &&.
           Cat timp lasati 0, conditia e mereu falsa si LED-ul NU se
           aprinde - exact ce vedeti daca porniti acum programul.     */

        if (0) {

            /* --- PASUL 2 -------------------------------------------
               Comutati bitul PB5 din PORTB. Idiomul de COMUTARE este
               cel cu ^= , de la lucrarea trecuta. Scrieti linia aici: */



            /* --- PASUL 3 -------------------------------------------
               Lamelele butonului vibreaza cateva milisecunde. Puneti
               aici o pauza de 20 ms ca sa le lasati sa se linisteasca: */


        }

        /* --- PASUL 4 -----------------------------------------------
           Citirea de acum devine "cea anterioara" pentru rotirea
           urmatoare. Fara linia asta, comparatia nu are cu ce sa se
           faca si LED-ul nu se aprinde niciodata. Scrieti-o aici:    */


        _delay_ms(5);
    }
}

12Sarcini de lucru

• Montați 4 LED-uri pe pinii 8–11 și aprindeți-le secvențial, folosind doar operații pe regiștri.
• Conectați un buton pe pinul 2 cu pull-up intern; afișați pe serial valoarea în repaus și la apăsare.
• Verificați ce se citește pe un pin de intrare lăsat flotant, fără pull-up.
• Implementați debounce software și numărați apăsările; verificați că fiecare apăsare fizică produce exact o incrementare.
• Modificați programul astfel încât fiecare apăsare să schimbe direcția efectului de lumini.
• Rulați benchmark-ul și notați raportul dintre digitalWrite() și accesul direct.
• Realizați un numărător binar pe 4 LED-uri, incrementat la fiecare apăsare de buton.
• Încercați PORTB = 0b00000001; fără mască și observați ce se întâmplă cu LED-ul de pe D13.

13Aplicație de aprofundare

14Întrebări de verificare

15Resurse

• Îndrumarul acestei lucrări (PDF)
• Îndrumarul complet de laborator
• Pagina cursului - toate materialele