Vaja 1: Uvod v GPIO

Namen tokratne vaje je, da spoznate delo z osnovami splošnonamenskega vhoda/izhoda (GPIO) v STM32. Končni cilj je, da prižgemo LED in beremo stanje gumba.

Delo z naslovi v C-ju in rezervirana beseda volatile

Za delo z GPIO bomo morali znati brati iz specifičnih naslovov ter vanje tudi pisati nove vrednosti. Recimo, da želimo postaviti bit 19 v 32-bitni vrednosti, ki se nahaja na naslovu 0x10012008. V zbirniku za RISC-V bi to naredili z naslednjim zaporedjem ukazov:

li t0, 0x10012008   # naložimo naslov v register

li t2, 0x01         # naložimo enico v register
slli t2, t2, 19     # (1 << 19)

lw t3, 0(t0)        # preberemo trenutno stanje na naslovu

or t3, t3, t2       # postavimo bit 19 in ohranimo stanje ostalih
sw t3, 0(t0)        # shranimo rezultat na isti naslov

Enako bi v C-ju storili z naslednjimi vrsticami:

uint32_t *p = ((uint32_t *)0x10012008); // eksplicitno nastavimo naslov
*p = *p | (1 << 19); // postavimo bit 19

oziroma z uporabo makrojev/konstant

#define GPIO_OUTPUT_EN ((uint32_t *)0x10012008) // naslov prestavimo v konstanto
uint32_t *p = GPIO_OUTPUT_EN;
*p = *p | (1 << 19);

ali še krajše:

*GPIO_OUTPUT_EN = *GPIO_OUTPUT_EN | (1 << 19);

Rezervirana beseda volatile

Spodaj je prikazan primer kode, ki v zanki bere stanje bita 7 registra REG_A, ki je register pomnilniško preslikane vhodno/izhodne naprave (angl. memory mapped I/O). To pomeni, da njegovo vrednost lahko spreminja tako vhod kot CPE. V primeru, da je vrednost iskanega bita enica, postavimo bit 19 v REG_B, ki je ravno tako register pomnilniško preslikane V/I naprave:

#define REG_A ((uint32_t *)0x10012000)
#define REG_B ((uint32_t *)0x1001200C)

int main() {
    uint32_t *p = (uint32_t *) REG_A;
    while(1) {
        if (*p & (1 << 7)) {
            *REG_B = *REG_B | (1 << 19);
        }
    }
}

V primeru, da ima prevajalnik za C vklopljene optimizacije, se to prevede v naslednjo kodo zbirnika:

main:
            li      a5,REG_A     # nalozimo naslov REG_A
            lw      a4,0(a5)     # branje vrednosti REG_A
            li      a5,0x80      # nalozimo 1 << 7
            lui     a3,0x80      # nalozimo 1 << 19 (lui namesto li)
            and     a5,a5,a4     # *p & (1 << 7)
            li      a4,REG_B     # nalozimo naslov REG_B
oznaka_1:   bnez    a5,oznaka_2  # ce je b7 postavljen, preskocimo naslednjo vrstico
loop:       j       loop         # neskoncna zanka
oznaka_2:   lw      a2,0(a4)     # ce je b7 postavljen, preberemo REG_B
            or      a2,a2,a3     # *REG_B | (1 << 19)
            sw      a2,0(a4)     # shranimo nazaj v REG_B
            j       oznaka_1

Če pozorno pregledamo kodo v zbirniku, opazimo, da se vsebina iz naslova REG_A prebere samo enkrat. Prevajalnik namreč nima informacije, da gre za register pomnilniško preslikane V/I naprave. Vrednost registra se lahko na naslovu, na katerega kaže kazalec, spreminja tudi izven normalnega toka programa. Vsebino na naslovu namreč v tem primeru spreminja zunanji dogodek, na primer pritisk/spust gumba. Prevajalniku to informacijo damo tako, da ob deklaraciji spremenljivke dodamo rezervirano besedo volatile:

volatile uint32_t *p_A = (volatile uint32_t *) REG_A;
volatile uint32_t *p_B = (volatile uint32_t *) REG_B;

Rezervirana beseda volatile se v C-ju uporablja predvsem, kadar delamo z:

  • pomnilniško preslikanimi registri vhodno/izhodnih naprav,
  • globalnimi spremenljivkami, ki jih spreminjajo prekinitveno servisni programi - več o tem čez nekaj tednov,
  • globalnimi spremenljivkami, do katerih dostopa več niti. Pri tem volatile zagotovi le, da se vrednost vsakič prebere iz pomnilnika, ne zagotavlja pa, da niti ne pišejo v spremenljivko hkrati.

GPIO v STM32H7

Na mikrokrmilnikih STM32H750, ki jih uporabljamo, je na voljo 168 splošnonamenskih pinov (angl. general-purpose input/output). Označujemo jih s kratico GPIO. Pini so razdeljeni v skupine po največ 16 pinov. Vsaka skupina pinov pripada ločeni GPIO napravi; naprave so označene s črko: GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, GPIOH, GPIOI, GPIOJ, GPIOK. Pini znotraj naprave so označeni s številkami od 0 do 15, razen GPIOK, ki ima zgolj osem pinov.

Kadar bomo govorili o pinih, bomo uporabljali oznake, kot so PA0, PC13 in PI2. Vse oznake se začnejo s črko P, ki nam pove, da govorimo o pinu. Temu sledita črkovna oznaka GPIO naprave ter številska oznaka pina znotraj naprave. Oznaka PC13 torej pomeni, da gre za pin 13 na napravi GPIOC, PA0 pa da gre za pin 0 na napravi GPIOA.

Gradivo

Povezavi do dokumentacije mikrokrmilnika in razvojne plošče, ki vsebujeta informacije, opisane v nadaljevanju:

Upravljanje perifernih ur GPIO naprav

Nastavitve za posamezne pine znotraj GPIO naprave so shranjene v registrih. Kot veste, registri za svoje delovanje potrebujejo uro. Ure GPIO naprav so po resetu izključene, zato bo običajno prva stvar, ki jo bomo naredili, vklop ur naprav, ki jih bomo potrebovali.

Upravljanje perifernih ur je del ločene naprave Reset and Clock Control oziroma krajše RCC. Za GPIO naprave skrbi 32-bitni register RCC_AHB4ENR (RCC AHB4 clock register - register za upravljanje perifernih ur naprav na vodilu AHB4). Spodnjih enajst bitov tega registra je namenjenih enajstim GPIO napravam. Bit 0 skrbi za uro naprave GPIOA, bit 1 za uro naprave GPIOB in tako dalje do bita 10, ki skrbi za uro naprave GPIOK. Enica na posameznem bitu pomeni, da je periferna ura vklopljena.

Register se nahaja na naslovu 0x580244E0.

RCC AHB4 clock register - RCC_AHB4ENR

Naslovni prostor GPIO naprav

Vsaka GPIO naprava ima svoj ločen, 1 KB velik del naslovnega prostora, v katerem se nahajajo registri za upravljanje njenih pinov. Razdelitev naslovnega prostora je vidna na Slika 5.1. Registri naprave GPIOE se tako nahajajo med naslovi 0x58021000 in 0x580213FF, registri naprave GPIOC pa med naslovoma 0x58020800 in 0x58020BFF.

Slika 5.1: Razdelitev naslovnega prostora za GPIO naprave

V naslovnem prostoru vsake GPIO naprave se nahaja deset 32-bitnih registrov, s pomočjo katerih lahko konfiguriramo vse, kar se tiče splošnonamenskih pinov. Danes bomo spoznali tri registre, preostale pa naslednjič.

Registri GPIO naprav
Odmik Kratko ime Polno ime
0x00 MODER Mode register
0x10 IDR Input data register
0x14 ODR Output data register

Odmik predstavlja število bajtov od začetnega naslova naprave. Register MODER naprave GPIOE se torej nahaja na naslovu 0x58021000, register IDR na naslovu 0x58021010, ODR pa na 0x58021014. Register MODER naprave GPIOC se nahaja na naslovu 0x58020800, register IDR na naslovu 0x58020810, ODR pa na 0x58020814.

Inicializacija GPIO naprave - vhod/izhod

Za osnovno inicializacijo GPIO pinov, to je nastavljanje, ali bomo pin uporabljali kot vhod ali kot izhod, služi register MODER. Ostale registre, s katerimi lahko določamo še preostale nastavitve, bomo spoznali naslednjič. Slika 5.2 prikazuje poenostavljeno shemo vhodno/izhodne stopnje, na kateri vidimo vse zgoraj omenjene registre in kako opravljajo svojo funkcijo.

Slika 5.2: Poenostavljena shema vhodno/izhodne stopnje z registri

MODER - mode register

Register MODER je namenjen nastavljanju načina delovanja pina - posamezen pin lahko deluje kot vhod ali izhod, v načinu alternativne funkcije ali v analognem načinu. Ker imamo štiri možne nastavitve, za vsak pin potrebujemo dva bita. Kot vidite na Slika 5.3, sta bita 0 in 1 namenjena določanju načina delovanja za pin 0, bita 2 in 3 določanju načina delovanja pina 1 in tako dalje do bitov 30 in 31, ki določata način delovanja pina 15. Vrednost 00 na dveh bitih pomeni, da pin deluje kot vhod, vrednost 01 pa pomeni, da pin deluje kot izhod. Vpis vrednosti 10 na dva bita vključi način alternativne funkcije. V tem načinu vrednost na pinu določa ena izmed preostalih naprav v mikrokrmilniku (več o tem v naslednjih tednih). Vrednost 11 pin preklopi v analogni način. Za začetek nas bosta zanimala predvsem prva dva načina delovanja. Ob resetu je večina pinov, razen redkih izjem, v analognem načinu delovanja.

Slika 5.3: MODER - Mode register

Uporaba vhoda in izhoda

Inicializaciji naprav sledi uporaba. Če pin uporabljamo kot vhod, nas zanima logična vrednost na vhodu (branje stanja pina). V primeru uporabe kot izhod pa želimo nastavljati logično vrednost na izhodu.

IDR - Input data register

Register IDR je sicer 32-biten, vendar uporabljamo zgolj spodnjih 16 bitov (po enega za vsak pin). Kot vidite na Slika 5.4, so biti označeni s črko r, kar pomeni, da jih lahko samo beremo (read-only). Branje bita n vrne logično vrednost na pinu n.

Slika 5.4: IDR - Input data register

ODR - Output data register

Tudi pri registru ODR uporabljamo zgolj spodnjih 16 bitov. Ničla na bitu n pomeni, da bo na pinu n GPIO naprave nizka logična vrednost (običajno 0 V). Enica na bitu n pomeni, da bo na pinu n GPIO naprave visoka logična vrednost (običajno 3,3 V).

Slika 5.5: ODR - Output data register

LED in gumb na razvojni plošči STM32H750 Discovery

Plošča STM32H750 Discovery nam ponuja nekaj pinov, ki jih lahko uporabimo kot enostaven digitalni vhod ali izhod:

Oznaka pina Funkcija
PC13 Modri gumb
PD3 Zelena LED - prižgana ob enici na izhodu
PJ2 Zelena LED - prižgana ob ničli na izhodu
PI13 Rdeča LED - prižgana ob ničli na izhodu

Začetni projekt

Za to vajo smo pripravili začetni projekt. Prenesite različico za razvojno okolje, ki ga uporabljate:

Projekt v STM32CubeIDE uvozite po navodilih v razdelku Uvoz obstoječega projekta. Za VS Code ZIP datoteko najprej razširite, nato pa mapo projekta odprite po navodilih v razdelku Uvoz obstoječega projekta.

Primer: inicializacija in uporaba zelene LED (PD3)

Preden lahko naredimo karkoli na napravi GPIO, moramo vklopiti uro GPIO naprave. Kot rečeno, se RCC_AHB4ENR nahaja na naslovu 0x580244E0. Postaviti moramo bit 3, ker vklapljamo uro za napravo GPIOD:

#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)
volatile uint32_t *p = RCC_AHB4ENR;
*p = *p | (1 << 3);  // bit 3 = GPIODEN

oziroma skrajšano

#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)

*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3);

Po vklopu ure naprave GPIOD nastavimo način delovanja pina 3 na izhod:

#define GPIOD_MODER ((volatile uint32_t *)0x58020C00)

*GPIOD_MODER = *GPIOD_MODER & ~(3 << (2 * 3)); // pobrišemo bita 6 in 7
*GPIOD_MODER = *GPIOD_MODER | (1 << (2 * 3));  // postavimo enico na bitu 6
TipZakaj najprej pobrišemo bita?

Ob resetu je večina pinov v analognem načinu, kar pomeni, da imata oba bita v MODER vrednost 11. Če bi zgolj postavili bit 6 (|= (1 << 6)), bi vrednost ostala 11 in pin ne bi deloval kot izhod. Zato oba bita najprej pobrišemo (00) in šele nato postavimo želeno vrednost (01).

TipKako zgradimo masko ~(3 << (2 * n))?

Vsak pin ima v MODER dva bita, pin n pa se začne na bitu 2 * n. Vrednost 3 je binarno 11, torej dve enici. S pomikom 3 << (2 * n) ju premaknemo na mesto bitov pina n, negacija ~ pa obrne vse bite, tako da dobimo ničli na mestu pina n in enice povsod drugje. Operacija & s to masko pobriše le bita pina n, ostale pa ohrani. Za pin 3:

3                 = 0000 0000 0000 0000 0000 0000 0000 0011
3 << (2 * 3)      = 0000 0000 0000 0000 0000 0000 1100 0000
~(3 << (2 * 3))   = 1111 1111 1111 1111 1111 1111 0011 1111

Osnovne bitne operacije (postavi, pobriši, negiraj in testiraj bit) smo spoznali v vaji 0.

Zdaj lahko LED končno tudi upravljamo preko registra ODR:

#define GPIOD_ODR ((volatile uint32_t *)0x58020C14)

// prižgemo LED
*GPIOD_ODR = *GPIOD_ODR | (1 << 3); // postavimo bit 3

// ugasnimo LED
*GPIOD_ODR = *GPIOD_ODR & ~(1 << 3); // pobrišemo bit 3

Še enkrat zapišimo vse skupaj:

#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)
#define GPIOD_MODER ((volatile uint32_t *)0x58020C00)
#define GPIOD_ODR ((volatile uint32_t *)0x58020C14)

// vklopimo uro GPIOD
*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3); // bit 3 = GPIODEN

// pin PD3 inicializiramo kot izhod
*GPIOD_MODER = *GPIOD_MODER & ~(3 << (2 * 3));
*GPIOD_MODER = *GPIOD_MODER | (1 << (2 * 3));

// prižgemo LED
*GPIOD_ODR = *GPIOD_ODR | (1 << 3);

// ugasnimo LED
*GPIOD_ODR = *GPIOD_ODR & ~(1 << 3);

Primer: inicializacija in uporaba gumba

Zopet začnemo z vklopom ure GPIO naprave, tokrat naprave GPIOC (bit 2).

#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)

*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 2); // bit 2 = GPIOCEN

Nastavimo pin 13, da bo deloval kot vhod.

#define GPIOC_MODER ((volatile uint32_t *)0x58020800)

*GPIOC_MODER = *GPIOC_MODER & ~(3 << (2 * 13)); // pobrišemo bita 26 in 27

Stanje gumba beremo preprosto z branjem registra IDR:

#define GPIOC_IDR ((volatile uint32_t *)0x58020810)

uint32_t stanje_gumba = *GPIOC_IDR & (1 << 13);
TipKakšno vrednost ima stanje_gumba?

Ko je gumb pritisnjen, ima stanje_gumba vrednost 0x2000 (1 << 13), ne 1. Kot pogoj v if (stanje_gumba) to deluje, saj v programskem jeziku C vsaka neničelna vrednost velja kot izpolnjen pogoj (true). Primerjava stanje_gumba == 1 tako v tem primeru ne bi delovala. Če želimo vrednost 0 ali 1, bit najprej pomaknemo na mesto 0:

uint32_t stanje_gumba = (*GPIOC_IDR >> 13) & 1;

Primer: uporaba gumba in LED

Napišimo sedaj primer, kjer inicializiramo LED in gumb. LED prižgemo, kadar je gumb pritisnjen, sicer pa LED ugasnemo. Na vrhu main.c definiramo vse konstante:

#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)

#define GPIOD_MODER ((volatile uint32_t *)0x58020C00)
#define GPIOD_ODR ((volatile uint32_t *)0x58020C14)

#define GPIOC_MODER ((volatile uint32_t *)0x58020800)
#define GPIOC_IDR ((volatile uint32_t *)0x58020810)

Dodamo še kodo za inicializacijo ter zanko, v kateri preverjamo stanje gumba in prižigamo LED.

// vklopimo uro GPIOC in GPIOD
*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3) | (1 << 2);

// init LED
*GPIOD_MODER = *GPIOD_MODER & ~(3 << (2 * 3));
*GPIOD_MODER = *GPIOD_MODER | (1 << (2 * 3));

// init gumb
*GPIOC_MODER = *GPIOC_MODER & ~(3 << (2 * 13));

while(1) {
    // če želite spremljati stanje gumba v "Live Expressions"
    // deklarirajte stanje_gumba kot globalno spremenljivko
    uint32_t stanje_gumba = *GPIOC_IDR & (1 << 13);
    if (stanje_gumba) {
        // prižgemo LED
        *GPIOD_ODR = *GPIOD_ODR | (1 << 3);
    } else {
        // ugasnimo LED
        *GPIOD_ODR = *GPIOD_ODR & ~(1 << 3);
    }
}

Naloga 1

Dodajte inicializacijo preostalih dveh LED. Bodite pozorni, da sta LED prižgani, ko je na izhodu logična ničla. Nato napišite program, ki bo po pritisku gumba prižigal in ugašal LED, kot kaže spodnji GIF. Ob pritisku gumba naj se LED prižgejo ena za drugo, tako da hkrati sveti le ena: najprej desna zelena, nato srednja zelena, nato rdeča, potem pa v obratnem vrstnem redu nazaj (srednja zelena, desna zelena). Na koncu naj ugasnejo vse LED, program pa naj čaka na naslednji pritisk gumba. Za časovne zamike (angl. delay) uporabite zanke z veliko ponovitvami.

Slika 5.6: Prikaz prižiganja LED

Namig: pri deklaraciji števca zanke za zamik uporabite rezervirano besedo volatile. Brez volatile lahko prevajalnik ob vklopljenih optimizacijah zanko v celoti odstrani. Zamik zapišite kot funkcijo void zamik(uint32_t n), ki jo kličete med prižiganjem LED.

NoteIzziv: binarni števec

Napišite program, ki deluje kot binarni števec. Ob vsakem pritisku gumba naj se števec poveča za 1, po vrednosti 7 pa naj se vrne na 0. Vrednost števca prikažite na treh LED v dvojiškem zapisu: bit 0 na PD3, bit 1 na PJ2 in bit 2 na PI13. Prižgana LED pomeni enico. Pri tem bodite pozorni na LED, ki svetita ob ničli na izhodu.

En pritisk gumba mora števec povečati natanko enkrat, ne glede na to, kako dolgo gumb držimo. Zato ni dovolj preverjati le trenutnega stanja gumba, temveč morate zaznati spremembo iz nepritisnjenega v pritisnjeno stanje (primerjajte prejšnje in trenutno stanje). Ker gumb ob pritisku odskakuje (angl. button bouncing), lahko en pritisk povzroči več hitrih sprememb stanja. Kratek zamik (delay) po zaznani spremembi to težavo odpravi.