[7] STM32F4 - Rejestry - Watchdog

Tym razem chciałbym opisać sposób konfiguracji Watchdoga IWDG oraz WWDG za pomocą rejestrów na mikrokontrolerze STM32F4.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Wcześniej umieściłem na blogu podobny post dotyczący układu Watchdog, jednak dotyczył on tylko układu IWDG i nie polegał w pełni na rejestrach.

IWDG:

Jest to licznik 12 bitowy zliczający w dół od zadanej wartości. Taktowany jest z oscylatora LSI. W przypadku dojścia do zera mikrokontroler zostaje zresetowany.

IWDG_KR - rejestr odpowiedzialny za sterowanie pracą IWDG. Zdefiniowane są trzy wartości stałe jakie można do niego wprowadzić.

- 0xCCCC - uruchomienie watchdoga
- 0xAAAA - wartość czyszcząca licznik.
- 0x5555 - uruchamia dostęp do IWDG_PR oraz IWDG_RLR. Po wprowadzeniu kolejnej wartości do IWDG_KR blokada zostaje ponownie aktywowana.

IWDG_PR - ustawienie dzielnika dla watchdoga.

 

IWDG_RLR - wartość od jakiej licznik rozpocznie zliczanie.

IWDG_SR - przechowuje on dwie wartości. Pierwsza RVU odpowiada za informacje o trwającej aktualizacji dla wartości licznika. Druga PVU o aktualizacji dzielnika.

Najpierw należy uruchomić zegar oraz diody sygnalizacyjne:

1. RCC->AHB1ENR |= RCC_AHB1Periph_GPIOD; /* Clock for Diodes */
2. __DSB();
4. /* Set diode pins as output */
5. for(uint8_t loop = 12; loop<16; loop++)
6. {
7.     setPinAsOutput(GPIOD, loop);
8. }

Dalej uruchamiany jest SysTick. W przerwaniu od niego będzie następowało czyszczenie danych w rejestrze:

1. SysTick_Config(10000);

Teraz sprawdzam czy IWDG wywołało ostatni reset:

1. if(RCC->CSR & RCC_CSR_WDGRSTF)
2. {
3.     RCC->CSR = RCC_CSR_RMVF;
4.     blinkDiode(DIODE_GREEN);
5.     blinkDiode(DIODE_GREEN);
6. }

W kolejnym kroku zanim zostanie uruchomiony LSI. Jest on niezbędny do działania IWDG. Ponieważ z tego źródła jest on taktowany:

1. RCC->CSR |= RCC_CSR_LSION;
2.    
3. while((RCC->CSR & RCC_CSR_LSIRDY) == 0)  { ; }

Ustawienie parametrów dla watchdoga:

1. IWDG->KR = 0x5555;      /* Enable access to IWDG_PR */
2. IWDG->PR = 2;           /* Set prescaler Value*/
3. IWDG->RLR = 1000;       /* Set counter value */
4. IWDG->KR = 0xaaaa;      /* Clear data, set counter to max (In out case 1000) value */
5. IWDG->KR = 0xcccc;      /* Enable IWDG */
6. __DSB();                /* Wait */
7.    
8. startFlag = 1;          /* Start count process */  
9.    
10. EXTI->IMR = EXTI_IMR_MR0;   /* Unmask interrupt, need for systick interrupts */

Obsługa przerwania od licznika:

1. void SysTick_Handler(void)
2. {
3.     if(startFlag)
4.     {
5.         reload++;
6.     }
7.     if(reload == 1600)
8.     {
9.         IWDG->KR = 0xaaaa;
10.         reload = 0;
11.         togglePin(GPIOD, DIODE_ORANGE);
12.     }
13.    
14.     if(delay)
15.     {
16.         delay--;
17.     }
18. }

Cały kod:

1. #include "stm32f4xx.h"
2. #include "stm32f4xx_rcc.h"
3. #include "stm32f4xx_gpio.h"
5. #define DIODE_GREEN             GPIO_Pin_12
6. #define DIODE_ORANGE            GPIO_Pin_13
7. #define DIODE_RED               GPIO_Pin_14
8. #define DIODE_BLUE              GPIO_Pin_15
10. #define BTN_PIN                 GPIO_Pin_0
12. #define setPinHigh(GPIOx, PIN)  ((GPIOx)->BSRRL = (PIN))
13. #define setPinLow(GPIOx, PIN)   ((GPIOx)->BSRRH = (PIN))
14. #define togglePin(GPIOx, PIN)   ((GPIOx)->ODR ^= (PIN))
16. static void setPinAsOutput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
17. static void setPinAsInput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
18. static void configExtiInterrupt();
19. void blinkDiode(uint16_t GPIO_PIN);
20. static void delayTime(uint32_t cnt);
22. volatile uint32_t reload;
23. volatile uint32_t delay;
24. volatile uint32_t startFlag;
26. int main()
27. {
28.     RCC->AHB1ENR |= RCC_AHB1Periph_GPIOD;   /* Clock for Diodes */
29.     __DSB();
30.    
31.     /* Set diode pins as output */
32.     for(uint8_t loop = 12; loop<16; loop++)
33.     {
34.         setPinAsOutput(GPIOD, loop);
35.     }
36.    
37.     SysTick_Config(10000);
38.    
39.     if(RCC->CSR & RCC_CSR_WDGRSTF)
40.     {
41.         RCC->CSR = RCC_CSR_RMVF;
42.         blinkDiode(DIODE_GREEN);
43.         blinkDiode(DIODE_GREEN);
44.     }
45.    
46.     RCC->CSR |= RCC_CSR_LSION;
47.     while((RCC->CSR & RCC_CSR_LSIRDY) == 0) { ; }
48.    
49.     setPinHigh(GPIOD, DIODE_BLUE);
50.    
51.     IWDG->KR = 0x5555;      /* Enable access to IWDG_PR */
52.     IWDG->PR = 2;           /* Set prescaler Value*/
53.     IWDG->RLR = 1000;       /* Set counter value */
54.     IWDG->KR = 0xaaaa;      /* Clear data, set counter to max (In out case 1000) value */
55.     IWDG->KR = 0xcccc;      /* Enable IWDG */
56.     __DSB();                /* Wait */
57.    
58.     startFlag = 1;          /* Start count process */  
59.    
60.     EXTI->IMR = EXTI_IMR_MR0;   /* Unmask interrupt, need for systick interrupts */
61.    
62.     while (1) { }
63. }
65. void SysTick_Handler(void)
66. {
67.     if(startFlag)
68.     {
69.         reload++;
70.     }
71.     if(reload == 1600)
72.     {
73.         IWDG->KR = 0xaaaa;
74.         reload = 0;
75.         togglePin(GPIOD, DIODE_ORANGE);
76.     }
77.    
78.     if(delay)
79.     {
80.         delay--;
81.     }
82. }
84. static void setPinAsOutput(GPIO_TypeDef* GPIOx, uint8_t pinNumber)
85. {
86.     GPIOx->MODER |= GPIO_Mode_OUT << (pinNumber * 2);
87.     GPIOx->OSPEEDR |= GPIO_Speed_25MHz << (pinNumber * 2);
88.     GPIOx->OTYPER |= GPIO_OType_PP << pinNumber;
89.     GPIOx->PUPDR |= GPIO_PuPd_NOPULL << (pinNumber * 2);
90. }
92. void blinkDiode(uint16_t GPIO_PIN)
93. {
94.     togglePin(GPIOD, GPIO_PIN);
95.     delayTime(20);
96.     togglePin(GPIOD, GPIO_PIN);
97.     delayTime(20);
98. }
100. static void delayTime(uint32_t cnt)
101. {
102.     delay = cnt;
103.     while(delay){ ; }
104. }

WWDG:

Działą podobnie zlicza w dół i generuje reset. Licznik IWDG może zostać załadowany nowymi wartościami w każdej chwili (byle przed doliczeniem do zera), natomiast WWDG potrzebuje aby odbyło się to w określonym oknie czasowym (ang. Window). W praktyce oznacza to że jeśli skasuje się licznik za wcześnie bądź za późno to nastąpi reset.

Minusem tego układu jest duża zależność od programu i od samego sprzętu. Nie działa on osobno ja IWDG, nie jest też taktowany z osobnej linii (WWDG taktowany z APB1). Wobec sposobu taktowania, układ nie będzie działał w trybach uśpienia. Natomiast dzięki temu dokładność odmierzanego przez układ czasu jest dosyć wysoka.

WWDG_CR - rejestr kontrolny, zawiera on bit włączający WDGA oraz zawartość licznika T.

Należy pamiętać, że wygenerowanie sygnału reset nastąpi po odliczeniu z 0x40 na 0x3F. Czyli gdy bit T[6] zostanie wyzerowany.

WWDG_CFR - rejestr konfiguracyjny zawiera bit wybudzający (EWI), dzielnik (WDGTB) oraz wartość okna (W) która będzie porównywana do zawartości licznika.

WWDG_SR - rejestr statusowy, przechowuje informację z flagą która zostaje aktywowana gdy rejestr dobije do 0x40. Program może wprowadzać tam tylko 0 w celu wyczyszczenia. Wprowadzenie 1 nie będzie miało żadnego efektu.

Należy pamiętać, że układ WWDG w przeciwieństwie do IWDG musi zostać włączony.

Program poniżej prezentuje przykładowe użycie. WWDG jest odświeżane w przerwaniu od Systicka. Teraz przejdę po fragmentach programu. Na samym końcu umieszczę cały kod zgrupowany razem.

Na początek dołączenie bibliotek oraz definicji z numerami pinów oraz makrami dla świecenia diodami. Posłuży to do informowania użytkownika o statusie operacji:

1. #include "stm32f4xx.h"
2. #include "stm32f4xx_rcc.h"
3. #include "stm32f4xx_gpio.h"
5. #define DIODE_GREEN             GPIO_Pin_12
6. #define DIODE_ORANGE            GPIO_Pin_13
7. #define DIODE_RED               GPIO_Pin_14
8. #define DIODE_BLUE              GPIO_Pin_15
10. #define BTN_PIN                 GPIO_Pin_0
12. #define setPinHigh(GPIOx, PIN)  ((GPIOx)->BSRRL = (PIN))
13. #define setPinLow(GPIOx, PIN)   ((GPIOx)->BSRRH = (PIN))
14. #define togglePin(GPIOx, PIN)   ((GPIOx)->ODR ^= (PIN))

Następnie definicja funkcji statycznych:

1. static void setPinAsOutput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
2. static void setPinAsInput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
3. static void configExtiInterrupt();
4. static void delayTime10_ms(uint32_t count);
5. static void blinkDiode(void);

Teraz przejdę do opisu pętli głównej programu:

1. RCC->CFGR = (uint32_t)RCC_CFGR_PPRE1_DIV2;              /* Config PCLK1 = HCLK */
2. RCC->AHB1ENR |= RCC_AHB1Periph_GPIOD;                   /* Clock for Diodes */
3. RCC->AHB1ENR |= RCC_AHB1Periph_GPIOA;                   /* Clock for Btn */
4. RCC->APB2ENR = RCC_APB2ENR_SYSCFGEN;                    /* Config SYSCFG Clock */
5. RCC->APB1ENR = RCC_APB1ENR_WWDGEN;                      /* Clock for WWDG */
6. __DSB();

Kolejnym elementem jest uruchomienie Systicka. W jego przerwaniu będzie umieszczona instrukcja ładująca dane do WWDG.

1. SysTick_Config(10000);

Dalej w kolejce jest uruchomienie diod świecących:

1. for(uint8_t loop = 12; loop<16; loop++)
2. {
3.     setPinAsOutput(GPIOD, loop);
4. }

Tutaj funkcja wywołuje się cztery razy przechodząc przez piny od 12 do 15.

Następnym krokiem jest sprawdzanie co wywołało przerwanie.

1. if(RCC->CSR & RCC_CSR_WWDGRSTF) /* Check if reset made by watchdog */
2. {
3.     blinkDiode(DIODE_GREEN);
4.     blinkDiode(DIODE_GREEN);
5. }
6. else
7. {
8.     blinkDiode(DIODE_BLUE);
9.     blinkDiode(DIODE_BLUE);
10. }

W celu sprawdzenia czy watchdog wywołał reset korzysta się z rejestru CSR w RCC.

Dalej należy wyczyścić flagę resetu, tak aby dane były czyste.

1. RCC->CSR = RCC_CSR_RMVF;                /* Set RMVF bit to clear the reset flags */

Teraz pora na uruchomienie WWDG. Najpierw potrzebne wzory:

Aby wyliczyć opóźnienie pomiędzy przeładowaniem a wyjście z okna czasowego:

Drugi przydatny wzór dotyczy obliczenia opóźnienia jakie jest potrzebne aby skasować licznik w odpowiednim momencie:

Teraz proces uruchamiania watchdog. Najpierw należy go włączyć po czym ustawić czas do resetu oraz wprowadzić wartość do bitu na pozycji szóstej w polu T. Te operacja są wykonywane na rejestrze CR.

Kolejna instrukcja wykonuje operacje na rejestrze CFR. Tam ustawiany jest dzielnik WWDG oraz konfigurowane jest okno czasowe. Tutaj podobnie jak w przypadku zawartości licznika (T) okno czasowe musi mieć ustawiony bit szósty.

Ostatnia operacja na rejestrze SR tam należy skasować flagę wywołania przerwania od WWDG.

1. WWDG->CR = WWDG_CR_WDGA | WWDG_CR_T6 | 0x7F;
2. WWDG->CFR = WWDG_CFR_EWI | 2<<7 | WWDG_CFR_W6 | 0x3F;  
3. WWDG->SR &= ~WWDG_SR_EWIF;

Uruchomienie przerwania od WWDG:

1. EXTI->IMR = EXTI_IMR_MR0;
2.    
3. NVIC_ClearPendingIRQ(WWDG_IRQn);
4. NVIC_EnableIRQ(WWDG_IRQn);

Funkcja obsługi przerwania od licznika. Co określoną ilość cyklów dane od WWDG są przeładowywane.

1. void SysTick_Handler(void)
2. {
3.     if(startFlag)
4.     {
5.         reload++;
6.     }
7.     if(reload == 200)
8.     {
9.         WWDG->CR = WWDG_CR_WDGA | WWDG_CR_T6 | 0x7F;
10.         reload = 0;
11.         startFlag = 1;
12.         togglePin(GPIOD, DIODE_ORANGE);
13.     }
14.    
15.     if(delay)
16.     {
17.         delay--;
18.     }
19. }

Cały program wygląda następująco:

1. #include "stm32f4xx.h"
2. #include "stm32f4xx_rcc.h"
3. #include "stm32f4xx_gpio.h"
5. #define DIODE_GREEN             GPIO_Pin_12
6. #define DIODE_ORANGE            GPIO_Pin_13
7. #define DIODE_RED               GPIO_Pin_14
8. #define DIODE_BLUE              GPIO_Pin_15
10. #define BTN_PIN                 GPIO_Pin_0
12. #define setPinHigh(GPIOx, PIN)      ((GPIOx)->BSRRL = (PIN))
13. #define setPinLow(GPIOx, PIN)       ((GPIOx)->BSRRH = (PIN))
14. #define togglePin(GPIOx, PIN)       ((GPIOx)->ODR ^= (PIN))
16. static void setPinAsOutput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
17. static void setPinAsInput(GPIO_TypeDef* GPIOx, uint8_t pinNumber);
18. static void configExtiInterrupt();
19. void blinkDiode(uint16_t GPIO_PIN);
20. static void delayTime(uint32_t cnt);
22. volatile uint32_t reload;
23. volatile uint32_t delay;
24. volatile uint32_t startFlag;
26. int main()
27. {
28.     RCC->CFGR = (uint32_t)RCC_CFGR_PPRE1_DIV2;                  /* Config PCLK1 = HCLK */
29.     RCC->AHB1ENR |= RCC_AHB1Periph_GPIOD;                       /* Clock for Diodes */
30.     RCC->AHB1ENR |= RCC_AHB1Periph_GPIOA;                       /* Clock for Btn */
31.     RCC->APB2ENR = RCC_APB2ENR_SYSCFGEN;                        /* Config SYSCFG Clock */
32.     RCC->APB1ENR = RCC_APB1ENR_WWDGEN;                          /* Clock for WWDG */
33.     __DSB();
34.    
35.     SysTick_Config(10000);
36.    
37.     /* Set diode pins as output */
38.     for(uint8_t loop = 12; loop<16; loop++)
39.     {
40.         setPinAsOutput(GPIOD, loop);
41.     }
42.    
43.     if(RCC->CSR & RCC_CSR_WWDGRSTF) /* Check if reset made by watchdog */
44.     {
45.         blinkDiode(DIODE_GREEN);
46.         blinkDiode(DIODE_GREEN);
47.     }
48.     else
49.     {
50.         blinkDiode(DIODE_BLUE);
51.         blinkDiode(DIODE_BLUE);
52.     }
53.    
54.     RCC->CSR = RCC_CSR_RMVF;                /* Set RMVF bit to clear the reset flags */
55.    
56.     startFlag = 1;
57.     setPinHigh(GPIOD, DIODE_BLUE);
58.    
59.     WWDG->CR = WWDG_CR_WDGA | WWDG_CR_T6 | 0x7F;        /* Enable WWDG, set bit T6 to 1, write coutner value */
60.     WWDG->CFR = WWDG_CFR_EWI | 2<<7 | WWDG_CFR_W6 | 0x3F;       /* Set Early wakeup interrupt, set Timer base, set W6 bit to 1, write window value */
61.     WWDG->SR &= ~WWDG_SR_EWIF;                          /* Clear flag */
62.    
63.     EXTI->IMR = EXTI_IMR_MR0;
64.    
65.     NVIC_ClearPendingIRQ(WWDG_IRQn);
66.     NVIC_EnableIRQ(WWDG_IRQn);
68.     while (1) { }
69. }
71. void SysTick_Handler(void)
72. {
73.     if(startFlag)
74.     {
75.         reload++;
76.     }
77.     if(reload == 200)
78.     {
79.         WWDG->CR = WWDG_CR_WDGA | WWDG_CR_T6 | 0x7F;
80.         reload = 0;
81.         startFlag = 1;
82.         togglePin(GPIOD, DIODE_ORANGE);
83.     }
84.    
85.     if(delay)
86.     {
87.         delay--;
88.     }
89. }
91. static void setPinAsOutput(GPIO_TypeDef* GPIOx, uint8_t pinNumber)
92. {
93.     GPIOx->MODER |= GPIO_Mode_OUT << (pinNumber * 2);
94.     GPIOx->OSPEEDR |= GPIO_Speed_25MHz << (pinNumber * 2);
95.     GPIOx->OTYPER |= GPIO_OType_PP << pinNumber;
96.     GPIOx->PUPDR |= GPIO_PuPd_NOPULL << (pinNumber * 2);
97. }
99. void blinkDiode(uint16_t GPIO_PIN)
100. {
101.     togglePin(GPIOD, GPIO_PIN);
102.     delayTime(20);
103.     togglePin(GPIOD, GPIO_PIN);
104.     delayTime(20);
105. }
107. static void delayTime(uint32_t cnt)
108. {
109.     delay = cnt;
110.     while(delay){ ; }
111. }
113. void WWDG_IRQHandler(void)
114. {
115.     WWDG->SR &= ~WWDG_SR_EWIF;  /* Clear interrupt flag */
116.     while(1) {}                 /* kill device, restart it */
117. }