Vaja 2: GPIO
Namen tokratne vaje je, da spoznate še preostale podrobnosti naprave za splošnonamenski vhod/izhod (GPIO) na mikrokrmilnikih STM32H7. Končni cilj bo zopet branje stanja gumba in prižiganje LED, ko je gumb pritisnjen. Gradivo v določenih delih ponovi informacije, ki smo jih spoznali prejšnjič, da boste imeli vse zbrano na enem mestu.
Začetni projekt
Za to vajo uporabite začetni projekt iz vaje 1.
GPIO v STM32H7
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 smo spoznali na prejšnji vaji, 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 oz. 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_AHB4ENRGPIO - naslovni prostor
Mikrokrmilnik STM32H750 ima na voljo 168 GPIO pinov, ki so razdeljeni v skupine po 16 pinov, razen GPIOK, ki jih ima 8. Vsaka skupina pinov pripada ločeni GPIO napravi. Naprave so označene s črko: GPIOA, GPIOB, GPIOC in tako dalje do GPIOK. Pini znotraj naprave so označeni s številkami od 0 do 15 (pri GPIOK od 0 do 7).
Vsaka GPIO naprava ima svoj ločen del naslovnega prostora v velikosti 1 KB, v katerem se nahajajo registri za upravljanje pinov, ki posamezni napravi pripadajo. Razdelitev naslovnega prostora je vidna na Slika 6.1.
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.
| Odmik | Kratko ime | Polno ime |
|---|---|---|
| 0x00 | MODER | Mode register |
| 0x04 | OTYPER | Output type register |
| 0x08 | OSPEEDR | Output speed register |
| 0x0C | PUPDR | Pull-up/pull-down register |
| 0x10 | IDR | Input data register |
| 0x14 | ODR | Output data register |
| 0x18 | BSRR | Bit set/reset register |
| 0x1C | LCKR | Configuration lock register |
| 0x20 | AFRL | Alternate function low register |
| 0x24 | AFRH | Alternate function high register |
Zadnjih treh registrov za zdaj ne bomo potrebovali. LCKR omogoča zaklepanje konfiguracije GPIO naprave, da le-te ni mogoče spreminjati do naslednjega reseta. Alternate function registra pa se uporabljata, kadar pin uporablja druga naprava (npr. UART, SPI). Z vrednostmi v teh dveh registrih določimo napravo, ki prevzame nadzor nad pinom.
Inicializacija GPIO naprave - vhod/izhod
Za inicializacijo pinov GPIO naprave kot vhod ali izhod uporabimo prve štiri zgoraj navedene registre: MODER, OTYPER, OSPEEDR in PUPDR.
MODER - mode register
Register MODER je namenjen nastavljanju načina delovanja pina - posamezen pin lahko deluje kot vhod, 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 6.2, 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 na naslednjih vajah). Vrednost 11 pin preklopi v analogni način. Na tokratni vaji nas bosta zanimala predvsem prva dva načina delovanja. Ob resetu je večina pinov, razen redkih izjem, v analognem načinu delovanja.
PUPDR - pull-up/pull-down register
Za vsak pin imamo na razpolago t. i. pull-up in pull-down upora. Tovrstni upori so uporabni predvsem za zagotavljanje logičnega nivoja, ko ni drugih zunanjih virov ali le-ti niso aktivni. Največkrat jih uporabljamo v kombinaciji s stikali na vhodu in z izhodom tipa open-drain (več o tem v razdelku OTYPER - output type register). Pull-up upor povezuje pin z virom pozitivne napetosti (3,3 V), pull-down pa z ozemljitvijo (0 V).
Imamo tri možne nastavitve za vsak pin: pull-up upor, pull-down upor ali brez uporov. Posledično za vsak pin porabimo dva bita v registru. Vrednost 00 pomeni, da ne želimo uporabiti nobenega izmed obeh uporov, vrednost 01, da želimo uporabiti pull-up upor, vrednost 10 pa izbere uporabo pull-down upora. Vrednost 11 je rezervirana in ni v uporabi. Po resetu so biti registra na vrednosti 0.
OTYPER - output type register
V primeru, da pin uporabimo kot izhod, imamo na voljo dva različna tipa zagotavljanja logičnih nivojev na izhodu: push-pull in open-drain. Pri tipu push-pull pin aktivno vleče izhodni logični nivo k visoki ali nizki vrednosti. Prednost tega je, da omogoča hitrejše prehode med visokim in nizkim logičnim nivojem.
Pri tipu open-drain pin aktivno vleče le proti nizki logični vrednosti, za zagotavljanje visoke vrednosti pa uporabimo pull-up upor. To ima za posledico večjo porabo energije, kadar je pin v nizkem logičnem stanju. Open-drain način izhoda se uporablja predvsem, kadar je na pin priklopljenih več naprav (vodilo).
Ker imamo zgolj dve nastavitvi, za nastavitev posameznega pina zadošča en bit. Zato v registru OTYPER uporabljamo samo spodnjih 16 bitov. Ničla pomeni, da pin deluje v načinu push-pull, enica pa open-drain. Po resetu so biti registra na vrednosti 0.
Za LED na razvojni plošči, ki svetita ob ničli (PJ2 in PI13), lahko uporabimo oba tipa izhoda (open-drain ali push-pull). LED, ki sveti ob enici (PD3), deluje le z izhodom push-pull, saj je notranji pull-up upor (približno 40 kΩ) prevelik, da bi LED svetila dovolj močno.
OSPEEDR - output speed register
V primeru, da pin uporabimo kot izhod, lahko nastavimo tudi hitrost osveževanja vrednosti na pinu. Na voljo so štiri hitrosti: nizka (low), srednja (medium), visoka (high) in zelo visoka (very high). Nastavitev v resnici določa strmino prehodov med logičnima nivojema (slew rate), od česar je odvisna največja frekvenca, s katero se lahko vrednost na pinu spreminja. Pri nizki hitrosti je največja frekvenca približno 12 MHz, pri zelo visoki pa približno 100 MHz. Višje hitrosti uporabimo le, kadar to zahteva priklopljena naprava na izhodu, sicer uporabimo najnižjo hitrost. Pri višjih hitrostih se namreč pojavi več šuma, poveča se tudi poraba energije.
Hitrost osveževanja določamo v registru OSPEEDR, za vsak pin uporabimo dva bita. Če na bita zapišemo ničli, s tem izberemo nizko hitrost osveževanja, enica srednjo hitrost osveževanja, dvojka visoko ter trojka zelo visoko hitrost osveževanja. Po resetu so biti registra na vrednosti 0.
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 6.6, 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.
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).
BSRR - Bit set/reset register
Register BSRR omogoča atomarno postavljanje ali brisanje bitov v registru ODR. Vpis enice v spodnjih 16 bitov postavi enico na istoležnem bitu v ODR, vpis enice v zgornjih 16 bitov pa pobriše bit v registru ODR (glej Slika 6.9). Register je namenjen le pisanju, branje vedno vrne ničlo.
Kadar uporabimo register ODR neposredno, postavimo ali brišemo bit n z naslednjima ukazoma:
*GPIOD_ODR = *GPIOD_ODR | (1 << n); // postavi bit
*GPIOD_ODR = *GPIOD_ODR & ~(1 << n); // pobrisi bitTa ukaza zahtevata branje stare vrednosti ter uporabo logičnih operacij. Z registrom BSRR isto dosežemo z:
*GPIOD_BSRR = 1 << n; // postavi bit
*GPIOD_BSRR = 1 << (n + 16); // brisi bit - +16, da uporabimo zgornjih 16 bitovGlavna prednost tega pristopa je atomarnost: vpis v BSRR se izvede kot ena sama, nedeljiva operacija. Pri delu z registrom ODR so potrebni trije koraki: branje stare vrednosti, logična operacija in zapis nove vrednosti nazaj. Če bi se med branjem in zapisom izvedla kakšna druga koda, ki spremeni drug bit v ODR, bi zapis to spremembo povozil, saj vsebuje vrednost, prebrano pred tem. Pri registru BSRR do tega ne more priti, saj vpis spremeni le izbrane bite v ODR, branje pa ni potrebno. Kdaj se lahko med branjem in zapisom izvede druga koda, boste spoznali na vajah o prekinitvah.
Če v BSRR hkrati vpišemo enico v bit za postavljanje in v bit za brisanje istega pina (npr. bita 3 in 19 za pin 3), ima prednost postavljanje. Bit v ODR se v tem primeru postavi na enico.
Shema GPIO
Slika 6.10 prikazuje shemo vhodno/izhodne stopnje z vsemi zgoraj omenjenimi registri.
LED in gumb na razvojni plošči STM32H750 Discovery
Še enkrat ponovimo pine za LED in gumb na razvojni plošči:
| 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 |
Primer - uporaba vseh registrov za inicializacijo LED
Podobno kot na prejšnji vaji bomo inicializirali LED na pinu PD3, le da bomo tokrat nastavili vse registre. Pin bomo inicializirali kot izhod tipa push-pull brez dodatnih uporov. Hitrost osveževanja bo najnižja.
Začnemo kot vedno z vklopom periferne ure:
#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)
*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3); // postavimo GPIODENNato zapišemo naslove registrov naprave GPIOD:
#define GPIOD_MODER ((volatile uint32_t *)0x58020C00)
#define GPIOD_OTYPER ((volatile uint32_t *)0x58020C04)
#define GPIOD_OSPEEDR ((volatile uint32_t *)0x58020C08)
#define GPIOD_PUPDR ((volatile uint32_t *)0x58020C0C)
#define GPIOD_IDR ((volatile uint32_t *)0x58020C10)
#define GPIOD_ODR ((volatile uint32_t *)0x58020C14)
#define GPIOD_BSRR ((volatile uint32_t *)0x58020C18)Sedaj inicializirajmo PD3:
// pin 3 inicializiramo kot izhod
*GPIOD_MODER = *GPIOD_MODER & ~(3 << (2 * 3));
*GPIOD_MODER = *GPIOD_MODER | (1 << (2 * 3));
// pobrisemo bit 3 v OTYPER -> pin 3 deluje kot push-pull izhod
*GPIOD_OTYPER = *GPIOD_OTYPER & ~(1 << 3);
// pobrisemo bita 6 in 7 v OSPEEDR -> pin 3 deluje z najpocasnejso hitrostjo
*GPIOD_OSPEEDR = *GPIOD_OSPEEDR & ~(3 << (2 * 3));
// pobrisemo bita 6 in 7 v PUPDR -> pin 3 deluje brez dodatnih uporov
*GPIOD_PUPDR = *GPIOD_PUPDR & ~(3 << (2 * 3));Kot rečeno, imamo sedaj za prižiganje/ugašanje LED dve možnosti. Prva je neposredno delo z ODR, kot prejšnjič:
// prizgemo LED
*GPIOD_ODR = *GPIOD_ODR | (1 << 3);
// ugasnimo LED
*GPIOD_ODR = *GPIOD_ODR & ~(1 << 3);Druga je uporaba registra BSRR:
// prizgemo LED
*GPIOD_BSRR = 1 << 3;
// ugasnimo LED
*GPIOD_BSRR = 1 << (3 + 16);Uporaba struktur za registre naprave
Če bi želeli sedaj inicializirati še ostale pine, bi morali za vsakega od preostalih pinov zopet dodati sedem konstant z naslovi registrov, saj vsak pripada drugi napravi. Že pri štirih pinih bi to hitro postalo nepregledno, možnost za napake pa bi se bistveno povečala. Zato bomo ubrali pristop s strukturami. Najprej definiramo strukturo za GPIO napravo:
typedef struct {
volatile uint32_t MODER;
volatile uint32_t OTYPER;
volatile uint32_t OSPEEDR;
volatile uint32_t PUPDR;
volatile uint32_t IDR;
volatile uint32_t ODR;
volatile uint32_t BSRR;
} GPIO_device;Elementi strukture si v pomnilniku sledijo v vrstnem redu, v katerem so zapisani. Ker so vsi 32-bitni (4 bajti), so njihovi odmiki od začetka strukture 0x00, 0x04, 0x08 in tako dalje do 0x18, kar se natanko ujema z odmiki registrov v tabeli zgoraj. Ko kazalec na strukturo postavimo na začetni naslov naprave, GPIOD->ODR ustreza registru na naslovu 0x58020C00 + 0x14. Zato vrstnega reda elementov ne smemo spreminjati in ne smemo izpustiti registrov na sredini. Registre na koncu (LCKR, AFRL, AFRH) lahko izpustimo, ker za njimi ni ničesar, kar bi uporabljali.
Nato zapišemo zgolj začetne naslove GPIO naprav:
#define GPIOC ((GPIO_device *)0x58020800)
#define GPIOD ((GPIO_device *)0x58020C00)
#define GPIOI ((GPIO_device *)0x58022000)
#define GPIOJ ((GPIO_device *)0x58022400)Inicializacijo in uporabo pina PD3 bi sedaj zapisali kot:
/**** inicializacija ****/
// pin 3 inicializiramo kot izhod
GPIOD->MODER = GPIOD->MODER & ~(3 << (2 * 3));
GPIOD->MODER = GPIOD->MODER | (1 << (2 * 3));
// pobrisemo bit 3 v OTYPER -> pin 3 deluje kot push-pull izhod
GPIOD->OTYPER = GPIOD->OTYPER & ~(1 << 3);
// pobrisemo bita 6 in 7 v OSPEEDR -> pin 3 deluje z najpocasnejso hitrostjo
GPIOD->OSPEEDR = GPIOD->OSPEEDR & ~(3 << (2 * 3));
// pobrisemo bita 6 in 7 v PUPDR -> pin 3 deluje brez dodatnih uporov
GPIOD->PUPDR = GPIOD->PUPDR & ~(3 << (2 * 3));
/**** uporaba ****/
// prizgemo LED
GPIOD->BSRR = 1 << 3;
// ugasnimo LED
GPIOD->BSRR = 1 << (3 + 16);Izdelava knjižnice za uporabo GPIO naprav
Namesto da bi se vsakič ukvarjali neposredno z registri, si bomo sedaj pripravili makroje in funkcije, ki nam bodo omogočale lažjo uporabo GPIO naprav in pinov.
Začeli bomo z makroji za vklop ur GPIO naprav. Da nam ne bo treba vsakič v dokumentaciji iskati, kateri bit vklaplja uro posamezne GPIO naprave, bomo napisali 11 makrojev, enega za vsako napravo. Spodaj sta zapisana makroja za vklop ur naprav GPIOC in GPIOD.
#define RCC_AHB4ENR ((volatile uint32_t *)0x580244E0)
// makro za vklop ure GPIOC: postavi bit 2 (GPIOCEN)
#define GPIOC_CLK_ENABLE() (*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 2))
// makro za vklop ure GPIOD: postavi bit 3 (GPIODEN)
#define GPIOD_CLK_ENABLE() (*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3))Za inicializacijo GPIO pinov bomo najprej izdelali poenostavljeno funkcijo, ki bo kot argumente sprejela napravo, številko pina in način delovanja (vhod ali izhod). Prototip funkcije bo:
void GPIO_Init(GPIO_device *gpio, uint32_t pin, uint32_t mode);Za način delovanja si bomo izdelali konstante:
#define GPIO_MODE_INPUT 0
#define GPIO_MODE_OUTPUT 1Primera klicev funkcije za gumb (PC13) in LED (PD3):
GPIO_Init(GPIOC, 13, GPIO_MODE_INPUT);
GPIO_Init(GPIOD, 3, GPIO_MODE_OUTPUT);V funkciji zgolj posplošimo vrstice, ki smo jih do sedaj že zapisali večkrat. Za način delovanja vedno nastavljamo dva bita, ki imata pred klicem funkcije lahko poljubno vrednost. Zato bomo vedno najprej pobrisali vrednosti bitov, ki jih potem nastavimo.
void GPIO_Init(GPIO_device *gpio, uint32_t pin, uint32_t mode) {
// pobrisemo oba bita
gpio->MODER = gpio->MODER & ~(3 << (2 * pin));
// nastavimo na zahtevano vrednost
gpio->MODER = gpio->MODER | (mode << (2 * pin));
}V primeru, da ima mode vrednost GPIO_MODE_INPUT, torej 00, druga vrstica ne naredi ničesar. Alternativni pristop bi bil, da preverjamo vrednost mode, kot je prikazano spodaj. Ker je koda v zgornjem primeru enostavnejša in bolj pregledna, dodatna vrstica pa ni pretirano časovno potratna, se bomo raje izognili pisanju vejitev.
gpio->MODER = gpio->MODER & ~(3 << (2 * pin));
if (mode != GPIO_MODE_INPUT) {
gpio->MODER = gpio->MODER | (mode << (2 * pin));
}Pripravimo si še funkcijo za nastavljanje vrednosti izhoda. Uporabili bomo register BSRR. V primeru, da bo želena vrednost enica, bomo zapisali enico na spodnjih 16 bitov, sicer pa na zgornjih 16.
void GPIO_WritePin(GPIO_device *gpio, uint32_t pin, uint32_t value) {
if (value) {
gpio->BSRR = 1 << pin;
} else {
gpio->BSRR = 1 << (pin + 16);
}
}1 << n ali 1UL << n?
Številske konstante, kot sta 1 in 3, so v C tipa int, ki je predznačen. Za pin 15 izraza 1 << (15 + 16) in 3 << (2 * 15) premakneta enico v najvišji, predznačni bit, kar je po standardu C nedefinirano obnašanje (angl. undefined behavior). Prevajalnik GCC v praksi vrne pričakovano vrednost, zato bomo v primerih zaradi preglednosti pisali kar 1 << n. Knjižnice, kot je STM32 HAL, se temu izognejo z nepredznačenimi konstantami, npr. 1UL << n ali 3UL << (2 * n) (pripona UL pomeni unsigned long).
V funkciji za branje stanja pina ravno tako le posplošimo to, kar smo počeli na prejšnji vaji. Vračali bomo enico, če je na pinu logična enica, sicer pa ničlo.
uint32_t GPIO_ReadPin(GPIO_device *gpio, uint32_t pin) {
if (gpio->IDR & (1 << pin)) {
return 1;
} else {
return 0;
}
}Spodnja koda inicializira gumb in LED ter prižge LED, ko je gumb pritisnjen.
GPIOC_CLK_ENABLE();
GPIOD_CLK_ENABLE();
GPIO_Init(GPIOC, 13, GPIO_MODE_INPUT);
GPIO_Init(GPIOD, 3, GPIO_MODE_OUTPUT);
while(1) {
if (GPIO_ReadPin(GPIOC, 13)) {
GPIO_WritePin(GPIOD, 3, 1);
} else {
GPIO_WritePin(GPIOD, 3, 0);
}
}Naloga 2
Dokončajte izdelavo funkcij za delo z GPIO:
- Dodajte manjkajoče makroje za vklop ur GPIO naprav.
- Dopolnite funkcijo
GPIO_Inittako, da bo podpirala inicializacijo preostalih nastavitev GPIO pinov (tip izhoda, pull-up/pull-down upor, hitrost osveževanja). Funkciji dodajte argumente za te nastavitve, kot kaže spodnji prototip, in uporabite spodnje konstante. - Z dokončanimi funkcijami inicializirajte pine za LED in gumb. Pina PD3 in PI13 inicializirajte kot izhod tipa push-pull brez dodatnih uporov. Pin PJ2 inicializirajte kot izhod tipa open-drain s pull-up uporom. Gumb inicializirajte kot vhod.
- Napišite program, ki bo po pritisku gumba prižigal in ugašal LED kot pri nalogi iz vaje 1.
#define GPIO_OUTPUT_TYPE_PUSH_PULL 0
#define GPIO_OUTPUT_TYPE_OPEN_DRAIN 1
#define GPIO_NO_PULL 0
#define GPIO_PULL_UP 1
#define GPIO_PULL_DOWN 2
#define GPIO_SPEED_LOW 0
#define GPIO_SPEED_MEDIUM 1
#define GPIO_SPEED_HIGH 2
#define GPIO_SPEED_VERY_HIGH 3Prototip dopolnjene funkcije GPIO_Init naj bo:
void GPIO_Init(GPIO_device *gpio, uint32_t pin, uint32_t mode,
uint32_t output_type, uint32_t pull, uint32_t speed);Primer klica za LED na pinu PJ2:
GPIO_Init(GPIOJ, 2, GPIO_MODE_OUTPUT, GPIO_OUTPUT_TYPE_OPEN_DRAIN,
GPIO_PULL_UP, GPIO_SPEED_LOW);Na naslednji vaji bomo spoznali knjižnico STM32 HAL, ki jo proizvajalec ponuja za delo z napravami mikrokrmilnika. Videli boste, da je organizirana zelo podobno kot knjižnica, ki ste jo napisali tokrat: registre GPIO naprave opisuje struktura, naprave so podane kot kazalci na začetne naslove, za vklop ur pa so na voljo makroji.