[6] STM32F4 - Rejestry - Przerwania zewnetrzne EXTI

Ten post chciałbym poświęcić na opisanie przerwań zewnętrznych w tytułowym układzie, które zostaną zaprogramowane bezpośrednio na rejestrach mikrokontrolera.

Rejestry:

Możny wyróżnić następujące definicje przerwań EXTI definiowanych za pomocą NVIC dla opisywanego mikrokontrolera:

• EXTI0_IRQn
• EXTI1_IRQn
• EXTI2_IRQn
• EXTI3_IRQn
• EXTI4_IRQn
• EXTI9_5_IRQn 
• EXTI15_10_IRQn

Definicje dla pozostałych przerwań można znaleźć w pliku stm32f4xx.h.

Co do rejestrów to są one właściwie takie same jak dla mikrokontrolera STM32F1, które opisałem w jednym z wcześniejszych postów.

Programowanie:

W pierwszej kolejności należy włączyć odpowiednie zegary:

Uruchamiane są zegary dla GPIOA, GPIOD oraz dla SYSCFG:

1. RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
2. RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;
3. RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
4. __DSB();

Kolejnym elementem jest deklaracja pinów dla przycisku oraz wyprowadzeń:

1. //PA0 jako iwejscie dla przycisku
2. GPIOA->MODER |= 0x00;
3. GPIOA->OSPEEDR |= GPIO_Speed_50MHz;
4. GPIOA->OTYPER |= GPIO_OType_PP;
5. GPIOA->PUPDR |= GPIO_PuPd_NOPULL;
6. //PD12 - PD15 jako wyjscia
7. GPIOD->MODER |= (GPIO_MODER_MODER12_0 | GPIO_MODER_MODER13_0 | GPIO_MODER_MODER14_0 | GPIO_MODER_MODER15_0);
8. GPIOD->OSPEEDR |= GPIO_Speed_50MHz;
9. GPIOD->OTYPER |= GPIO_OType_PP;
10. GPIOD->PUPDR |= GPIO_PuPd_NOPULL;
12.  SYSCFG->EXTICR[0] = SYSCFG_EXTICR1_EXTI0_PA; //Podlaczenie pinu PA0 do zewnętrznego przerwania z EXTI_Line0

Następnym krokiem jest definicja przerwań dla danej linii:

1. //Konfiguracja EXTI oraz NVIC
2. EXTI->FTSR = EXTI_FTSR_TR0;
3. EXTI->IMR = EXTI_IMR_MR0;
4. __enable_irq();
5.    
6. NVIC_SetPriority(EXTI0_IRQn,0);
7. NVIC_ClearPendingIRQ(EXTI0_IRQn);
8. NVIC_EnableIRQ(EXTI0_IRQn);

Ustawiana jest sposób w jaki na linii będzie to przerwanie generowane, w tym przypadku zboczem opadającym. W rejestrze IMR wystawiane jest przerwanie na określoną nogę układu. Następnie przerwania zostają włączone, ta komenda nie jest właściwie konieczna, ponieważ zostają one włączone automatycznie. 

Kolejna część dotyczy konfiguracji NVIC, ustawiana jest tam odpowiednia linia wraz z wartością priorytetu dla danego przerwania. Można wprowadzać wartości od 0 do 15, przy czym 0 ma najwyższy priorytet. 

Teraz czas na obsługę przerwania czyli tzw. handler:

1. void EXTI0_IRQHandler(void)
2. {
3.     if(EXTI->PR & EXTI_PR_PR0)
4.     {
5.         delay_simple(10000);
6.         EXTI->PR = EXTI_PR_PR0;
7.         switch(zmienna)
8.         {
9.             case 0:
10.             {
11.                 GPIOD->BSRRL = GPIO_Pin_12; //((uint16_t)0x1000)
12.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
13.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
14.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
15.                 zmienna++;
16.                 break;
17.             }
18.            
19.             case 1:
20.             {
21.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
22.                 GPIOD->BSRRL = GPIO_Pin_13; //((uint16_t)0x2000)
23.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
24.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
25.                 zmienna++;
26.                 break;
27.             }
28.            
29.             case 2:
30.             {
31.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
32.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
33.                 GPIOD->BSRRL = GPIO_Pin_14; //((uint16_t)0x4000)
34.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
35.                 zmienna++;
36.                 break;
37.             }
38.            
39.             case 3:
40.             {
41.                 zmienna = 0;
42.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
43.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
44.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
45.                 GPIOD->BSRRL = GPIO_Pin_15; //((uint16_t)0x8000)
46.                 break;
47.             }
48.         }
49.     }
50. }

Po wywołaniu przerwania i wejściu do procedury obsługi, następuje sprawdzenie czy zostało ono wywołane z danej nogi mikrokontrolera, ta część właściwie ma więcej pożytku dla przerwań zawierających wspólne handlery tzn. dla pinów od 5 do 9 oraz od 10 do 15. Natomiast nie zaszkodzi sprawdzić to również w tym przypadku.

Gdy już nastąpi sprawdzenie następuje wejście do funkcji i wyzerowanie flagi ustawionej w rejestrze EXTI_PR, który informuje o wystąpieniu przerwania na konkretnym pinie. Jest jeszcze coś takiego jak flaga ustawiona przez układ NVIC (w tym przypadku kasowanie odbywa się wartością 0). Występuje ona gdy przerwanie zostało zgłoszone ale czeka na swoją kolej ponieważ aktualnie układ zajmuje się ważniejszym przerwaniem. Tej flagi nie trzeba kasować, jest ona zerowana automatycznie. 

Jak już wspomniałem w poprzednich postach flaga w rejestrze PR jest kasowana zaraz po wejściu do przerwania tak aby wystąpienie innego nie zostało pominięte.

Jeszcze informacja co użytej wcześniej instrukcji __enable_irq(). Występuje także instrukcja __disable_irq();. Jak można się łatwo domyśleć jedna włącza druga natomiast wyłącza przerwania. Z ich użyciem spotkałem się w procedurze obsługi przerwania co wyglądało następująco:

1. void EXTI0_IRQHandler(void)
2. {
3.     if(EXTI->PR & EXTI_PR_PR0)
4.     {
5.         __disable_irq();
6.         EXTI->PR = EXTI_PR_PR0;
8.         //Program.....
9.         __enable_irq();
10.     }
11. }

Po wejściu do obsługi przerwania są wyłączane, program się wykonuje, po czym zostają one ponownie włączone. Z takiego rozwiązania można skorzystać wtedy gdy zależy nam na tym aby to przerwanie nie było przerwane przez inne przerwanie, oczywiście tylko takie które można wyłączyć. Natomiast jeśli chcemy nie przeoczyć żadnego wystąpienia, to należy nie wykorzystywać tego typu instrukcji.

Poniżej wklejam jeszcze całą funkcje:

1. volatile uint8_t zmienna = 0;
3. int main()
4. {
5.     RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
6.     RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;
7.     RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
8.     __DSB();
9.    
10.     //PA0 jako input dla przycisku
11.     GPIOA->MODER |= 0x00;
12.     GPIOA->OSPEEDR |= GPIO_Speed_50MHz;
13.     GPIOA->OTYPER |= GPIO_OType_PP;
14.     GPIOA->PUPDR |= GPIO_PuPd_NOPULL;
15.    
16.     //PD12 - PD15 jako wyjscia
17.     GPIOD->MODER |= (GPIO_MODER_MODER12_0 | GPIO_MODER_MODER13_0 | GPIO_MODER_MODER14_0 | GPIO_MODER_MODER15_0);
18.     GPIOD->OSPEEDR |= GPIO_Speed_50MHz;
19.     GPIOD->OTYPER |= GPIO_OType_PP;
20.     GPIOD->PUPDR |= GPIO_PuPd_NOPULL;
21.    
22.     SYSCFG->EXTICR[0] = SYSCFG_EXTICR1_EXTI0_PA;
23.    
24.     //Konfiguracja EXTI oraz NVIC
25.     EXTI->FTSR = EXTI_FTSR_TR0;
26.     EXTI->IMR = EXTI_IMR_MR0;
27.     //__enable_irq();
28.    
29.     NVIC_SetPriority(EXTI0_IRQn,0);
30.     NVIC_ClearPendingIRQ(EXTI0_IRQn);
31.     NVIC_EnableIRQ(EXTI0_IRQn);
32.    
33.     while(1)
34.   {}
35.    
36. }
37.    
38. void EXTI0_IRQHandler(void)
39. {
40.     if(EXTI->PR & EXTI_PR_PR0)
41.     {
42.         EXTI->PR = EXTI_PR_PR0;
43.         switch(zmienna)
44.         {
45.             case 0:
46.             {
47.                 GPIOD->BSRRL = GPIO_Pin_12; //((uint16_t)0x1000)
48.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
49.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
50.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
51.                 zmienna++;
52.                 break;
53.             }
54.            
55.             case 1:
56.             {
57.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
58.                 GPIOD->BSRRL = GPIO_Pin_13; //((uint16_t)0x2000)
59.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
60.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
61.                 zmienna++;
62.                 break;
63.             }
64.            
65.             case 2:
66.             {
67.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
68.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
69.                 GPIOD->BSRRL = GPIO_Pin_14; //((uint16_t)0x4000)
70.                 GPIOD->BSRRH = GPIO_Pin_15; //((uint16_t)0x8000)
71.                 zmienna++;
72.                 break;
73.             }
74.            
75.             case 3:
76.             {
77.                 zmienna = 0;
78.                 GPIOD->BSRRH = GPIO_Pin_12; //((uint16_t)0x1000)
79.                 GPIOD->BSRRH = GPIO_Pin_13; //((uint16_t)0x2000)
80.                 GPIOD->BSRRH = GPIO_Pin_14; //((uint16_t)0x4000)
81.                 GPIOD->BSRRL = GPIO_Pin_15; //((uint16_t)0x8000)
82.                 break;
83.             }
84.         }
85.     }
86. }