GPIO: een LED laten knipperen

De "hallo wereld" van embedded is een knipperende LED. Het lijkt een klein ding, maar als dat werkt, weet je dat je toolchain klopt, je klok klopt, je pin klopt en je firmware echt draait. In deze les begrijp je elke regel ervan.

GPIO-registers

GPIO (General Purpose Input/Output) zijn pinnen die je zelf aan, uit of uitlezen kunt. Op de ATmega328P zijn ze gegroepeerd in poorten B, C en D. Elke poort heeft drie registers:

Na een reset staan alle DDR-bits op 0: alle pinnen zijn ingang. Dat is een veilige keuze: een pin die per ongeluk uitgang is, kan kortsluiting maken met wat eraan hangt.

De schakeling

Een LED heeft een voorschakelweerstand nodig, anders trekt hij te veel stroom en gaan de LED of de pin kapot. Met 5 V, een rode LED (~2 V) en 10 mA: R = (5 − 2) / 0,010 = 300 Ω; neem 330 Ω. De Uno heeft op D13 (PB5) al een LED met weerstand op het bordje.

Uitgewerkt voorbeeld

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

#define LED_PIN PORTB5

int main(void) {
    DDRB |= (1 << DDB5);                 /* 1. PB5 als uitgang */

    for (;;) {
        PORTB |= (1 << LED_PIN);         /* 2. LED aan */
        _delay_ms(200);
        PORTB &= (uint8_t)~(1 << LED_PIN); /* 3. LED uit */
        _delay_ms(800);
    }
}

Voorspel: hoe vaak per seconde knippert de LED, en hoe lang is hij aan? Eén keer per seconde (200 + 800 ms), 200 ms aan.

Een pin omdraaien kan ook door een 1 te schrijven naar het PINx-register: PINB = (1 << PINB5);. Dat is een eigenaardigheid van de AVR: schrijven naar PIN draait de pin om in één instructie. Handig, maar minder leesbaar dan PORTB ^= ....

Hoe werkt _delay_ms?

_delay_ms(200) rekent met F_CPU uit hoeveel klokslagen 200 ms is (3,2 miljoen bij 16 MHz) en genereert een lus die precies zo lang duurt. Het is een bezig-wachtlus (busy wait): de CPU doet al die tijd niets anders.

Dat is prima voor een eerste programma, maar het heeft grote nadelen:

• Tijdens het wachten kan je programma niet reageren op een knop of seriële invoer.
• De CPU verbruikt volle stroom terwijl hij niets doet.
• Interrupts (les 7) die tussendoor draaien, maken de vertraging langer.

In les 7 vervang je dit door een timer, en in les 13 schrijf je niet-blokkerende code die meerdere dingen tegelijk doet.

HAL versus registers

Je kunt hetzelfde schrijven met een HAL (Hardware Abstraction Layer): een bibliotheek die de registers verbergt. Arduino is daar het bekendste voorbeeld van:

pinMode(13, OUTPUT);
digitalWrite(13, HIGH);

In deze cursus werk je met registers, omdat je dan begrijpt wat er gebeurt. In les 20 bouw je zelf een kleine abstractielaag, zodat je de voordelen van beide krijgt.

Typische fouten

• DDR vergeten: je schrijft PORTB |= (1 << PORTB5) maar de pin is nog ingang. Je zet dan de interne pull-up aan (les 6) en de LED gloeit hooguit zwakjes.
• Verkeerde poort: Arduino-pin D5 is PD5, niet PB5. Kijk in je pinouttabel (les 2).
• LED andersom: een LED geleidt maar in één richting. Het lange pootje (anode) gaat naar de plus-kant.

Oefeningen

1. Laat de LED op PB5 twee keer kort knipperen (100 ms aan, 100 ms uit) en daarna een seconde uit blijven, als een hartslag.
2. Sluit een tweede LED aan op PD6 (Arduino D6) en laat beide om en om knipperen.
3. Waarom kan je programma uit oefening 1 niet tegelijk reageren op een knop?

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

int main(void) {
    DDRB |= (1 << DDB5);
    for (;;) {
        for (uint8_t i = 0; i < 2; i++) {
            PORTB |= (1 << PORTB5);
            _delay_ms(100);
            PORTB &= (uint8_t)~(1 << PORTB5);
            _delay_ms(100);
        }
        _delay_ms(1000);
    }
}

Lab: knipperende LED

Samenvatting

• Elke poort heeft DDRx (richting), PORTx (uitvoer/pull-up) en PINx (lezen).
• Na een reset is elke pin ingang; zet een bit in DDRx om er een uitgang van te maken.
• _delay_ms is een bezig-wachtlus: simpel, maar je programma doet ondertussen niets anders.
• Registers zijn snel en precies; een HAL is leesbaarder en overdraagbaar.

Volgende les: de andere kant op, pinnen uitlezen met knoppen.