Vaja 3: GPIO z STM32 HAL knjižnico

Namen tokratne vaje je, da se seznanite s knjižnico STM32 HAL na primeru naprave GPIO, ki smo jo uporabljali zadnja dva tedna. Knjižnica je organizirana na podoben način kot na zadnji vaji, ko smo si sami izdelali funkcije za uporabo GPIO. Pri vsakem delu knjižnice si bomo pogledali, katere registre nastavlja, in ga primerjali s svojo knjižnico. Videli boste, da knjižnica ne počne nič drugega, kot to, kar smo do sedaj počeli sami.

Začetni projekt

Za to vajo uporabite začetni projekt iz vaje 1.

Knjižnica STM32 HAL

Knjižnica STM32 HAL (Hardware Abstraction Layer) je sestavljena iz dveh delov:

  • datoteke stm32h750xx.h (del t. i. CMSIS), ki opisuje strojno opremo mikrokrmilnika: strukture z registri naprav, začetne naslove naprav in imena posameznih bitov v registrih,
  • datotek stm32h7xx_hal_*.h in stm32h7xx_hal_*.c, ki vsebujejo makroje in funkcije za delo z napravami. Za GPIO sta to stm32h7xx_hal_gpio.h in stm32h7xx_hal_gpio.c.

Vse datoteke so del projekta, ki ga ustvari STM32CubeMX (mapa Drivers), zato si lahko izvorno kodo vsake funkcije kadarkoli pogledate. V razvojnem okolju to najlaže storite tako, da kliknete na ime funkcije ali makroja ob pritisnjeni tipki Ctrl (na macOS Cmd).

Vklop ure

Za vklop ure posamezne GPIO naprave so na voljo enostavni makroji, ki so zapisani v obliki __HAL_RCC_GPIOx_CLK_ENABLE():

__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOI_CLK_ENABLE();
__HAL_RCC_GPIOJ_CLK_ENABLE();
__HAL_RCC_GPIOK_CLK_ENABLE();

Na voljo so tudi makroji za izklop ure GPIO naprav, ki so zapisani v obliki __HAL_RCC_GPIOx_CLK_DISABLE().

Poglejmo, kako je zapisan makro za vklop ure naprave GPIOD (datoteka stm32h7xx_hal_rcc.h):

#define __HAL_RCC_GPIOD_CLK_ENABLE()   do { \
                                        __IO uint32_t tmpreg; \
                                        SET_BIT(RCC->AHB4ENR, RCC_AHB4ENR_GPIODEN);\
                                        /* Delay after an RCC peripheral clock enabling */ \
                                        tmpreg = READ_BIT(RCC->AHB4ENR, RCC_AHB4ENR_GPIODEN);\
                                        UNUSED(tmpreg); \
                                       } while(0)

RCC->AHB4ENR je register RCC_AHB4ENR, RCC_AHB4ENR_GPIODEN pa je maska bita 3 (1 << 3). SET_BIT(REG, BIT) je makro za REG |= BIT. Prva vrstica je torej enaka makroju, ki smo ga napisali na zadnji vaji:

#define GPIOD_CLK_ENABLE() (*RCC_AHB4ENR = *RCC_AHB4ENR | (1 << 3))

Makro register takoj zatem še prebere. S tem počaka, da se vpis zares izvede, preden začnemo nastavljati registre naprave GPIOD.

Struktura GPIO registrov in naslovi naprav

Knjižnica ima definirano strukturo naprave, ki jo vidite spodaj. Ta vsebuje vse registre, podobno kot smo to naredili na zadnji vaji. Strukturo najdemo v stm32h750xx.h.

typedef struct
{
  __IO uint32_t MODER;    /*!< GPIO port mode register,               Address offset: 0x00      */
  __IO uint32_t OTYPER;   /*!< GPIO port output type register,        Address offset: 0x04      */
  __IO uint32_t OSPEEDR;  /*!< GPIO port output speed register,       Address offset: 0x08      */
  __IO uint32_t PUPDR;    /*!< GPIO port pull-up/pull-down register,  Address offset: 0x0C      */
  __IO uint32_t IDR;      /*!< GPIO port input data register,         Address offset: 0x10      */
  __IO uint32_t ODR;      /*!< GPIO port output data register,        Address offset: 0x14      */
  __IO uint32_t BSRR;     /*!< GPIO port bit set/reset,               Address offset: 0x18      */
  __IO uint32_t LCKR;     /*!< GPIO port configuration lock register, Address offset: 0x1C      */
  __IO uint32_t AFR[2];   /*!< GPIO alternate function registers,     Address offset: 0x20-0x24 */
} GPIO_TypeDef;
Tip__IO

__IO je zgolj redefinicija rezervirane besede volatile. V eni izmed .h datotek knjižnice bomo našli vrstico #define __IO volatile.

Prvih sedem članov se natanko ujema z našo strukturo GPIO_device. Knjižnica na koncu doda še registre, ki jih mi nismo potrebovali: LCKR ter AFRL in AFRH. Slednja sta zapisana kot tabela dveh elementov: AFR[0] je AFRL, AFR[1] pa AFRH. Ker so dodani na konec strukture, se odmiki ostalih registrov ne spremenijo.

V isti datoteki so definirani tudi vsi kazalci na naprave:

#define GPIOA               ((GPIO_TypeDef *) GPIOA_BASE)
#define GPIOB               ((GPIO_TypeDef *) GPIOB_BASE)
#define GPIOC               ((GPIO_TypeDef *) GPIOC_BASE)
#define GPIOD               ((GPIO_TypeDef *) GPIOD_BASE)
#define GPIOE               ((GPIO_TypeDef *) GPIOE_BASE)
#define GPIOF               ((GPIO_TypeDef *) GPIOF_BASE)
#define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)
#define GPIOH               ((GPIO_TypeDef *) GPIOH_BASE)
#define GPIOI               ((GPIO_TypeDef *) GPIOI_BASE)
#define GPIOJ               ((GPIO_TypeDef *) GPIOJ_BASE)
#define GPIOK               ((GPIO_TypeDef *) GPIOK_BASE)

Kazalce na naprave smo na zadnji vaji napisali na enak način, le da smo naslove zapisali neposredno. Knjižnica jih sestavi iz več delov, na primer:

#define PERIPH_BASE           (0x40000000UL)
#define D3_AHB1PERIPH_BASE    (PERIPH_BASE + 0x18020000UL)
#define GPIOD_BASE            (D3_AHB1PERIPH_BASE + 0x0C00UL) // = 0x58020C00

Primerjava z našo knjižnico:

// nasa knjiznica
#define GPIOD ((GPIO_device *)0x58020C00)

// HAL
#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)

Strukturo in kazalce lahko uporabljamo tudi sami, kadar želimo neposredno brati ali pisati v register, npr. GPIOD->ODR.

Inicializacija GPIO

Za inicializacijo pinov uporabimo funkcijo HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init). Prvi argument je tako kot pri zadnji vaji kazalec na napravo (strukturo z registri). Uporabili bomo torej eno izmed konstant, ki so zapisane zgoraj. Drugi argument je kazalec na inicializacijsko strukturo. Tako bomo namesto s petimi dodatnimi argumenti (pin, mode, output_type, pull, speed) funkcijo za inicializacijo klicali z dodatno strukturo, ki vsebuje vrednosti za inicializacijo.

Ta struktura je definirana v stm32h7xx_hal_gpio.h:

typedef struct
{
  uint32_t Pin;
  uint32_t Mode;
  uint32_t Pull;
  uint32_t Speed;
  uint32_t Alternate;
} GPIO_InitTypeDef;

Elementi strukture ustrezajo argumentom naše funkcije GPIO_Init in se neposredno preslikajo v registre:

Preslikava elementov strukture GPIO_InitTypeDef v argumente naše funkcije in registre
Element Argument naše funkcije Registri
Pin pin /
Mode mode in output_type MODER, OTYPER
Pull pull PUPDR
Speed speed OSPEEDR
Alternate / AFRL, AFRH

Pin

Za element Pin uporabimo eno izmed pripravljenih konstant za oznako pinov (ali njihovo kombinacijo):

#define GPIO_PIN_0                 ((uint16_t)0x0001)  /* Pin 0 selected    */
#define GPIO_PIN_1                 ((uint16_t)0x0002)  /* Pin 1 selected    */
#define GPIO_PIN_2                 ((uint16_t)0x0004)  /* Pin 2 selected    */
#define GPIO_PIN_3                 ((uint16_t)0x0008)  /* Pin 3 selected    */
#define GPIO_PIN_4                 ((uint16_t)0x0010)  /* Pin 4 selected    */
#define GPIO_PIN_5                 ((uint16_t)0x0020)  /* Pin 5 selected    */
#define GPIO_PIN_6                 ((uint16_t)0x0040)  /* Pin 6 selected    */
#define GPIO_PIN_7                 ((uint16_t)0x0080)  /* Pin 7 selected    */
#define GPIO_PIN_8                 ((uint16_t)0x0100)  /* Pin 8 selected    */
#define GPIO_PIN_9                 ((uint16_t)0x0200)  /* Pin 9 selected    */
#define GPIO_PIN_10                ((uint16_t)0x0400)  /* Pin 10 selected   */
#define GPIO_PIN_11                ((uint16_t)0x0800)  /* Pin 11 selected   */
#define GPIO_PIN_12                ((uint16_t)0x1000)  /* Pin 12 selected   */
#define GPIO_PIN_13                ((uint16_t)0x2000)  /* Pin 13 selected   */
#define GPIO_PIN_14                ((uint16_t)0x4000)  /* Pin 14 selected   */
#define GPIO_PIN_15                ((uint16_t)0x8000)  /* Pin 15 selected   */
#define GPIO_PIN_All               ((uint16_t)0xFFFF)  /* All pins selected */

Tu je pomembna razlika z našo knjižnico. Mi smo pin podali kot številko (npr. 3), konstante v knjižnici HAL pa so maske: GPIO_PIN_n ima vrednost 1 << n. Ker ima vsak pin svoj bit, lahko z operatorjem | izberemo več pinov hkrati, npr. GPIO_PIN_2 | GPIO_PIN_3, in jih inicializiramo z enim klicem funkcije.

WarningŠtevilka pina ni maska

Klic HAL_GPIO_WritePin(GPIOD, 3, GPIO_PIN_SET) se prevede brez napak, a ne nastavi pina 3. Vrednost 3 je binarno 0b11, zato nastavi pina 0 in 1. Vedno uporabljajte konstante GPIO_PIN_n.

Mode

Za element Mode so na voljo spodnje nastavitve. Kot vidimo, s tem elementom nastavimo, ali bo pin deloval kot vhod, izhod, alternativna funkcija ali v analognem načinu. Hkrati pa v primeru, da pin uporabljamo kot izhod, nastavimo tudi tip izhoda: push-pull (PP) ali open-drain (OD). Obstaja še nekaj dodatnih možnosti, ki niso navedene spodaj. Te bomo spoznali v nadaljevanju semestra.

GPIO_MODE_INPUT     // vhod
GPIO_MODE_OUTPUT_PP // izhod push-pull
GPIO_MODE_OUTPUT_OD // izhod open-drain
GPIO_MODE_AF_PP     // alternativna funkcija push-pull
GPIO_MODE_AF_OD     // alternativna funkcija open-drain
GPIO_MODE_ANALOG    // analogni način

Ena vrednost torej nosi nastavitev za dva registra, ki smo ju v naši funkciji podali z dvema argumentoma (mode in output_type). Spodnja dva bita vrednosti se zapišeta v MODER, bit 4 pa v OTYPER:

Vrednosti za Mode in njihova preslikava v registra MODER in OTYPER
Konstanta Vrednost MODER OTYPER
GPIO_MODE_INPUT 0x00 00 /
GPIO_MODE_OUTPUT_PP 0x01 01 0
GPIO_MODE_OUTPUT_OD 0x11 01 1
GPIO_MODE_AF_PP 0x02 10 0
GPIO_MODE_AF_OD 0x12 10 1
GPIO_MODE_ANALOG 0x03 11 /

Pull

Za element Pull so na voljo spodnje nastavitve, ki sovpadajo neposredno z vrednostmi v registru PUPDR. Vrednosti so enake kot pri naših konstantah GPIO_NO_PULL, GPIO_PULL_UP in GPIO_PULL_DOWN:

GPIO_NOPULL    // 0 - brez pull-up ali pull-down upora
GPIO_PULLUP    // 1 - vklopi pull-up upor
GPIO_PULLDOWN  // 2 - vklopi pull-down upor

Speed

Nastavitve, ki jih lahko uporabimo za Speed, podobno sovpadajo neposredno z vrednostmi v registru OSPEEDR in z našimi konstantami GPIO_SPEED_*:

GPIO_SPEED_FREQ_LOW       // 0 - nizka hitrost osveževanja
GPIO_SPEED_FREQ_MEDIUM    // 1 - srednja hitrost osveževanja
GPIO_SPEED_FREQ_HIGH      // 2 - visoka hitrost osveževanja
GPIO_SPEED_FREQ_VERY_HIGH // 3 - zelo visoka hitrost osveževanja

Alternate

O elementu Alternate bomo več povedali v nadaljevanju semestra, zaenkrat ga ne potrebujemo. Njegova vrednost se zapiše v register AFRL ali AFRH, a le, kadar je Mode nastavljen na eno izmed alternativnih funkcij.

Primer inicializacije

Inicializacijo pina PB12 kot izhod tipa push-pull brez pull-up/pull-down uporov in z najnižjo hitrostjo osveževanja bi zapisali kot:

__HAL_RCC_GPIOB_CLK_ENABLE();     // vklop ure naprave GPIOB

GPIO_InitTypeDef init = {0};
init.Pin = GPIO_PIN_12;           // pin 12
init.Mode = GPIO_MODE_OUTPUT_PP;  // izhod push-pull
init.Pull = GPIO_NOPULL;          // brez pull-up/down uporov
init.Speed = GPIO_SPEED_FREQ_LOW; // nizka hitrost osveževanja
HAL_GPIO_Init(GPIOB, &init);      // naprava GPIOB

Z = {0} vse elemente strukture nastavimo na 0. Tako imajo elementi, ki jih ne nastavimo izrecno (v tem primeru Alternate), znano vrednost.

Z našo knjižnico bi isto zapisali kot:

GPIOB_CLK_ENABLE();
GPIO_Init(GPIOB, 12, GPIO_MODE_OUTPUT, GPIO_OUTPUT_TYPE_PUSH_PULL,
          GPIO_NO_PULL, GPIO_SPEED_LOW);

Kaj naredi HAL_GPIO_Init?

Funkcija gre čez vse pine, ki so izbrani v Pin, in za vsakega nastavi registre na enak način kot naša funkcija GPIO_Init: najprej pobriše bite, ki pripadajo pinu, nato vanje zapiše želeno vrednost. Poenostavljeno (brez preverjanja argumentov, alternativnih funkcij in prekinitev) je funkcija zapisana tako:

for (uint32_t n = 0; n < 16; n++) {
  if ((GPIO_Init->Pin & (1 << n)) == 0) {
    continue; // pin n ni izbran
  }

  uint32_t mode = GPIO_Init->Mode & 3;         // spodnja dva bita
  uint32_t otype = (GPIO_Init->Mode >> 4) & 1; // bit 4

  if (mode == 1 || mode == 2) { // izhod ali alternativna funkcija
    GPIOx->OSPEEDR = (GPIOx->OSPEEDR & ~(3 << (2 * n))) | (GPIO_Init->Speed << (2 * n));
    GPIOx->OTYPER = (GPIOx->OTYPER & ~(1 << n)) | (otype << n);
  }

  GPIOx->PUPDR = (GPIOx->PUPDR & ~(3 << (2 * n))) | (GPIO_Init->Pull << (2 * n));
  GPIOx->MODER = (GPIOx->MODER & ~(3 << (2 * n))) | (mode << (2 * n));
}

V primerjavi z našo funkcijo opazimo tri razlike:

  • Ker je Pin maska, funkcija v zanki preveri vseh 16 bitov in nastavi vse izbrane pine.
  • Hitrost in tip izhoda se nastavita le, kadar pin deluje kot izhod ali alternativna funkcija, saj pri vhodu nimata pomena.
  • Register MODER se nastavi zadnji, tako da pin začne delovati kot izhod šele, ko so vse ostale nastavitve že pripravljene.

Nastavljanje vrednosti na izhodu

Za nastavljanje vrednosti na izhodu imamo na voljo dve funkciji:

void HAL_GPIO_WritePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState);
void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);

Funkcija HAL_GPIO_WritePin omogoča nastavljanje logične vrednosti pina na poljubno vrednost, funkcija HAL_GPIO_TogglePin pa negira trenutno logično vrednost pina. Za stanje pina uporabimo eno izmed možnosti, definiranih v naštevnem tipu GPIO_PinState:

typedef enum
{
  GPIO_PIN_RESET = 0U,
  GPIO_PIN_SET
} GPIO_PinState;

Namesto zgornjih vrednosti lahko uporabite tudi številski vrednosti 0 in 1. Nekaj primerov uporabe obeh funkcij:

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET); // nastavimo pin PA0 na 1
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1 | GPIO_PIN_10, GPIO_PIN_RESET); // nastavimo pina PB1 in PB10 na 0
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, 0); // nastavimo pin PC1 na 0
HAL_GPIO_TogglePin(GPIOK, GPIO_PIN_7); // obrnemo logično vrednost pina PK7

Funkcija HAL_GPIO_WritePin je skoraj enaka naši funkciji GPIO_WritePin. Obe uporabljata register BSRR, razlika je le v tem, da je GPIO_Pin že maska, zato zamika 1 << pin ni treba:

// nasa knjiznica
void GPIO_WritePin(GPIO_device *gpio, uint32_t pin, uint32_t value) {
  if (value) {
    gpio->BSRR = 1 << pin;
  } else {
    gpio->BSRR = 1 << (pin + 16);
  }
}

// HAL
void HAL_GPIO_WritePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)
{
  if (PinState != GPIO_PIN_RESET)
  {
    GPIOx->BSRR = GPIO_Pin;
  }
  else
  {
    GPIOx->BSRR = (uint32_t)GPIO_Pin << GPIO_NUMBER; // GPIO_NUMBER je 16
  }
}

HAL_GPIO_TogglePin mora poznati trenutno vrednost izhoda, zato najprej prebere ODR. Pine, ki so na enici, nato pobriše prek zgornjih 16 bitov BSRR, pine, ki so na ničli, pa postavi prek spodnjih 16 bitov:

void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
  uint32_t odr = GPIOx->ODR;
  GPIOx->BSRR = ((odr & GPIO_Pin) << GPIO_NUMBER) | (~odr & GPIO_Pin);
}

Branje vhoda

Za branje stanja na vhodu imamo na voljo funkcijo:

GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);

Funkcija vrne GPIO_PIN_SET (številska vrednost 1) v primeru, da je vrednost na vhodu podanega pina enica. V nasprotnem primeru vrne GPIO_PIN_RESET (številska vrednost 0). Tudi ta funkcija je enaka naši funkciji GPIO_ReadPin: prebere register IDR in preveri bit, ki pripada pinu.

GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
  if ((GPIOx->IDR & GPIO_Pin) != 0x00U)
  {
    return GPIO_PIN_SET;
  }
  else
  {
    return GPIO_PIN_RESET;
  }
}

Povzetek

Primerjava naše knjižnice s knjižnico HAL
Naša knjižnica HAL Registri
GPIO_device GPIO_TypeDef vsi registri GPIO naprave
GPIOx_CLK_ENABLE() __HAL_RCC_GPIOx_CLK_ENABLE() RCC_AHB4ENR
GPIO_Init HAL_GPIO_Init MODER, OTYPER, OSPEEDR, PUPDR (in AFRL/AFRH)
GPIO_WritePin HAL_GPIO_WritePin BSRR
/ HAL_GPIO_TogglePin ODR (branje), BSRR (pisanje)
GPIO_ReadPin HAL_GPIO_ReadPin IDR

Primer: LED na PD3 in PJ2

Koda za prižig LED na pinu PD3:

__HAL_RCC_GPIOD_CLK_ENABLE();

GPIO_InitTypeDef init = {0};
init.Pin = GPIO_PIN_3;
init.Mode = GPIO_MODE_OUTPUT_PP;
init.Pull = GPIO_NOPULL;
init.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &init);

HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);

LED na pinu PD3 sveti ob enici, zato zanjo potrebujemo izhod tipa push-pull. LED na pinu PJ2 sveti ob ničli, zato lahko uporabimo tudi open-drain tip izhoda. Ker pin LED prižge tako, da jo poveže z 0 V, pull-up upor za prižiganje ni nujen, z njim pa ima pin, ko je LED ugasnjena, določen visok logični nivo:

__HAL_RCC_GPIOJ_CLK_ENABLE();

GPIO_InitTypeDef init = {0};
init.Pin = GPIO_PIN_2;
init.Mode = GPIO_MODE_OUTPUT_OD;
init.Pull = GPIO_PULLUP;
init.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOJ, &init);

HAL_GPIO_WritePin(GPIOJ, GPIO_PIN_2, GPIO_PIN_RESET); // LED sveti ob nicli

HAL_Delay

Knjižnica STM32 HAL ponuja funkcijo, ki omogoča izvedbo zakasnitve z milisekundno natančnostjo - HAL_Delay(uint32_t ms). Klic funkcije HAL_Delay(1000) se bo tako izvajal (vsaj) 1000 ms oz. 1 s. Funkcijo lahko kličemo kadarkoli po klicu funkcij HAL_Init() in SystemClock_Config(), ki se nahajata v programu, ko ustvarite projekt.

Spodnji program bo stanje pina PD3 obrnil vsako sekundo.

while(1) {
  HAL_Delay(1000);
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
  HAL_Delay(1000);
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
}

Primer: gumb na PC13 z LED na PD3

Gumb na pinu PC13 inicializiramo kot vhod, LED na pinu PD3 pa kot izhod. Pull-up/down upor ni potreben, saj ima gumb na plošči zunanji upor:

__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();

GPIO_InitTypeDef init_led = {0};
init_led.Pin = GPIO_PIN_3;
init_led.Mode = GPIO_MODE_OUTPUT_PP;
init_led.Pull = GPIO_NOPULL;
init_led.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &init_led);

GPIO_InitTypeDef init_gumb = {0};
init_gumb.Pin = GPIO_PIN_13;
init_gumb.Mode = GPIO_MODE_INPUT;
init_gumb.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC, &init_gumb);

Spodnji program prižge LED na pinu PD3, dokler je gumb pritisnjen.

while(1) {
  if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET) {
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
  } else {
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
  }
}

Naloga 3

Napišite program, ki bo:

  • inicializiral pin PC13 (gumb) kot vhod,
  • inicializiral pina PD3 in PJ2 kot izhod tipa push-pull brez pull-up/down uporov,
  • inicializiral pin PI13 kot izhod tipa open-drain s pull-up uporom.

Po inicializaciji naj se izvaja naslednje:

  • rdeča LED na pinu PI13 naj se prižge ob prvem pritisku gumba, ob drugem pritisku ugasne, ob tretjem zopet prižge, in tako dalje. Zaznavati morate prehode stanja gumba iz 0 v 1, ne zgolj pritisk gumba.
  • zelena LED na pinu PD3 naj utripa s frekvenco 2 Hz (0,25 s naj bo prižgana, 0,25 s ugasnjena).
  • zelena LED na pinu PJ2 naj utripa s frekvenco 1 Hz (0,5 s naj bo prižgana, 0,5 s ugasnjena).

Slika 7.1 prikazuje primer pravilnega delovanja. Diagram prikazuje napetosti na pinih, navpične črtkane črte pa označujejo pritiske gumba. Upoštevajte, da LED na pinih PI13 in PJ2 svetita ob 0 V, LED na pinu PD3 pa ob 3,3 V.

Slika 7.1: Časovni diagram delovanja LED pri nalogi 3
TipNamig

Ker HAL_Delay čaka, program med zakasnitvijo ne more brati gumba. Glavno zanko zato razdelite na manjše korake, nekje med 25 in 100ms (250 naj bo deljivo s korakom, ker je zakasnitev potrebna za utripanje LED na PD3). V zanki štejte korake in s tem dolžino zakasnitve. Ko presežete zakasnitev 250ms ugasnite/prižigite LED na PD3 in pri 500ms LED na PJ2.

Rdeče LED ne preklopite vsakič, ko je gumb pritisnjen, saj bi jo pritisk, daljši od dolžine posameznega koraka, preklopil večkrat. Preklopite jo le ob spremembi iz nepritisnjenega v pritisnjeno stanje: v spremenljivki si zapomnite stanje gumba iz prejšnjega koraka in ga primerjajte s trenutnim.

Izziv: zaklepanje konfiguracije

Na vaji 2 smo omenili register LCKR (configuration lock register), ki omogoča zaklepanje konfiguracije pinov. Ko pin zaklenemo, do naslednjega reseta ni več mogoče spreminjati njegovih nastavitev v registrih MODER, OTYPER, OSPEEDR, PUPDR, AFRL in AFRH. Vrednost na izhodu lahko še vedno spreminjamo prek registrov ODR in BSRR. Zaklepanje uporabimo, kadar želimo preprečiti, da bi napaka v programu (npr. pisanje na napačen naslov) spremenila nastavitve pinov, ki krmilijo kaj pomembnega.

V registru LCKR spodnjih 16 bitov (LCK0 do LCK15) izbere pine, ki jih želimo zakleniti, bit 16 (LCKK, lock key) pa pove, ali je zaklepanje aktivno. Zaklepanja ne aktiviramo z enim samim vpisom, temveč z zaporedjem vpisov, v katerem se LCKK spreminja, biti LCK0 do LCK15 pa ostajajo enaki:

  1. vpis LCKK = 1 skupaj z izbranimi biti LCKx,
  2. vpis LCKK = 0 skupaj z istimi biti LCKx,
  3. vpis LCKK = 1 skupaj z istimi biti LCKx,
  4. branje registra LCKR.

Če zaporedje ni izvedeno natanko tako, se zaklepanje ne aktivira. Ko je enkrat aktivno, ostane do reseta mikrokrmilnika.

Knjižnica HAL ima za to funkcijo HAL_GPIO_LockPin, ki zaporedje izvede namesto nas. Vrne HAL_OK, če je bilo zaklepanje uspešno, in HAL_ERROR sicer:

HAL_StatusTypeDef HAL_GPIO_LockPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
{
  __IO uint32_t tmp = GPIO_LCKR_LCKK; // GPIO_LCKR_LCKK je 1 << 16

  tmp |= GPIO_Pin;
  GPIOx->LCKR = tmp;      // LCKK = 1 + LCKx
  GPIOx->LCKR = GPIO_Pin; // LCKK = 0 + LCKx
  GPIOx->LCKR = tmp;      // LCKK = 1 + LCKx
  tmp = GPIOx->LCKR;      // obvezno branje

  if ((GPIOx->LCKR & GPIO_LCKR_LCKK) != 0x00U)
  {
    return HAL_OK;
  }
  else
  {
    return HAL_ERROR;
  }
}

Program iz naloge 3 dopolnite tako, da ob prvem pritisku gumba (poleg prižiga rdeče LED):

  • zaklene pin PD3 s funkcijo HAL_GPIO_LockPin. Če funkcija vrne HAL_ERROR, naj program prižge rdečo LED in se ustavi v neskončni zanki,
  • takoj za zaklepanjem pin PD3 ponovno inicializira, tokrat kot vhod (GPIO_MODE_INPUT).

Program poženite in preverite kaj se zgodi z zeleno LED na pinu PD3 po prvem pritisku gumba? Kaj se zgodi če pred ponovno inicializacijo ne zaklenete nastavitev?