[25] STM32F4 - DWT

Ten post chciałbym poświęcić na opisanie sprzętowego licznika zegarowego DWT CYCCNT. Jest to bardzo precyzyjny układ sprzętowy za którego pomocą można dokonać bardzo dokładnych obliczeń. Rejestr CYCCNT zlicza ilość cykli wykonanych przez CPU. W związku z czym można go użyć do obliczenia dokładnej ilości cykli w danym czasie. 

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

Jego minusem zwłaszcza dla funkcji opóźniających jest konieczność wykonania szeregu instrukcji sprawdzających ilość cykli, co zwłaszcza dla krótkich czasów wpłynie negatywnie na dokładność opóźnień. Natomiast przy odmierzaniu np. 50us błąd będzie właściwie znikomy.

Opis rejestru DWT:

DWT (Data Watchpoint Trigger) składa się z czterech komparatorów. Dla układu dostępne są jego cztery różne konfiguracje, dodatkowo można go skonfigurować by podawał ilość cykli zegara, prędkość ładowania LSU, ilość cykli uśpienia dla układu, ilość cykli zegara w czasie trwania instrukcji.

DWT składa się z następujących rejestrów:

1. typedef struct
2. {
3.   __IO uint32_t CTRL;                    /*!< Offset: 0x000 (R/W)  Control Register                          */
4.   __IO uint32_t CYCCNT;                  /*!< Offset: 0x004 (R/W)  Cycle Count Register                      */
5.   __IO uint32_t CPICNT;                  /*!< Offset: 0x008 (R/W)  CPI Count Register                        */
6.   __IO uint32_t EXCCNT;                  /*!< Offset: 0x00C (R/W)  Exception Overhead Count Register         */
7.   __IO uint32_t SLEEPCNT;                /*!< Offset: 0x010 (R/W)  Sleep Count Register                      */
8.   __IO uint32_t LSUCNT;                  /*!< Offset: 0x014 (R/W)  LSU Count Register                        */
9.   __IO uint32_t FOLDCNT;                 /*!< Offset: 0x018 (R/W)  Folded-instruction Count Register         */
10.   __I  uint32_t PCSR;                    /*!< Offset: 0x01C (R/ )  Program Counter Sample Register           */
11.   __IO uint32_t COMP0;                   /*!< Offset: 0x020 (R/W)  Comparator Register 0                     */
12.   __IO uint32_t MASK0;                   /*!< Offset: 0x024 (R/W)  Mask Register 0                           */
13.   __IO uint32_t FUNCTION0;               /*!< Offset: 0x028 (R/W)  Function Register 0                       */
14.        uint32_t RESERVED0[1];
15.   __IO uint32_t COMP1;                   /*!< Offset: 0x030 (R/W)  Comparator Register 1                     */
16.   __IO uint32_t MASK1;                   /*!< Offset: 0x034 (R/W)  Mask Register 1                           */
17.   __IO uint32_t FUNCTION1;               /*!< Offset: 0x038 (R/W)  Function Register 1                       */
18.        uint32_t RESERVED1[1];
19.   __IO uint32_t COMP2;                   /*!< Offset: 0x040 (R/W)  Comparator Register 2                     */
20.   __IO uint32_t MASK2;                   /*!< Offset: 0x044 (R/W)  Mask Register 2                           */
21.   __IO uint32_t FUNCTION2;               /*!< Offset: 0x048 (R/W)  Function Register 2                       */
22.        uint32_t RESERVED2[1];
23.   __IO uint32_t COMP3;                   /*!< Offset: 0x050 (R/W)  Comparator Register 3                     */
24.   __IO uint32_t MASK3;                   /*!< Offset: 0x054 (R/W)  Mask Register 3                           */
25.   __IO uint32_t FUNCTION3;               /*!< Offset: 0x058 (R/W)  Function Register 3                       */
26. } DWT_Type;

Jak można zaobserwować w zestawieniu powyżej (pobrane z core_cm4.h), wszystkie rejestry są typu Read/Write. Cały blok składa się z czterech komparatorów oraz rejestrów przechowujących czasy przejść poszczególnych cykli wraz ustawieniami licznika.

Dokładny opis rejestru można znaleźć pod tym adresem.

Poniżej przedstawię opis rejestrów jakie wykorzystuje w części programu opisanej poniżej:

DEMCR - (Debug Exception and Monitor Control Register) (link) rejestr ten pozwala na włączenie układu DW poprzez wprowadzenie 1 do bitu 24.

DTW - CTRL - rejestr kontrolny, w nim ustawiam bit 0, odpowiedzialny za wlaczenie licznika CYCCNT. Jeśli nie zostanie on włączony nic się w nim nie dzieje. Po uruchomieniu należy go zainicjalizować wartością 0 w rejestrze DWT_CYCCNT.

Programowanie:

Rozpocznę od przedstawienia funkcji pozwalającej na włączenie bloku:

1. uint8_t DWT_COUNTER_ENABLE(void)
2. {
3.   uint32_t c;
5.   //Wlacz TRC,
6.   //Ustawienie bitu TRCENA
7.   //Wlacza takie bloki jak DWT, ITM, ETM, TPIU
8.   CoreDebug->DEMCR &= ~0x01000000;
9.   CoreDebug->DEMCR |=  0x01000000;
10.    
11.   //Wlacz DWT w rejestrze kontrolnym
12.   DWT->CTRL &= ~0x00000001; //Czyszczenie
13.   DWT->CTRL |=  0x00000001; //Ustawienie
14.    
15.   //Ustawienie licznika na wartosc 0
16.   DWT->CYCCNT = 0;
17.    
18.   //Wartosci z CYCCNT do zmiennej c
19.   c = DWT->CYCCNT;
21.   //Czekanie   
22.   __ASM volatile ("NOP"); __ASM volatile ("NOP"); __ASM volatile ("NOP");
23.    
24.   //Zwraca roznice pomiedzy DWT->CYCCNT a ta wartoscia kilka cykli wczesniej
25.   //Jesli wynosi ona 0 to licznik nie dziala
26.   if((DWT->CYCCNT - c) == 0)
27.   { return 0; }
28.   return (DWT->CYCCNT - c);
29. }

Za pomocą tego licznika można stworzyć dosyć dokładną funkcję opóźniającą:

1. static inline void delayUS_DWT(uint32_t us)
2. {
3.     volatile uint32_t base = (SystemCoreClock/1000000) //1 us
4.     volatile uint32_t c = base*us;                     //Ilosc cykli do przejscia
5.     volatile uint32_t s = DWT->CYCCNT;                 //aktualna wartosc danych w rejestrze, startowa
7.     while((DWT->CYCCNT - s) < c)
8.     {;}
9. }

Dobrze taką funkcję zdefiniować jako static inline, dzięki czemu można uzyskać szybsze jej wykonywanie.

Nie zaszkodzi także wyczyścić rejestru CYCCNT. W tym celu należy do niego wprowadzić wartość 0 (DWT->CYCCNT = 0;).

Poniżej przedstawię przykład pozwalający na pomiar czasu podczas którego mikrokontroler jest w trybie uśpienia oraz w trybie aktywnym:

1. typedef struct {
2.     uint32_t Working_Cycles;
3.     uint32_t Sleep_Cycles;
4.     float Load_Percent;      
5. } CPULOAD_t;
7. //Inicjalizacja struktury
8. uint8_t STRUCT_ENABLE_CPU(CPULOAD_t* CPU_Load)
9. {
10.     CPU_Load->Load_Percent = 0;
11.     CPU_Load->Sleep_Cycles = 0;
12.     CPU_Load->Working_Cycles = 0;
13.    
14.     /* Return DWT counter enabled status */
15.     return DWT_COUNTER_ENABLE();
16. }

Poniżej funkcja pozwalająca na obliczenie czasu:

1. uint8_t state_flag = 0;
3. uint8_t CPULOAD_SLEEP_MODE(CPULOAD_t* CPU_Load)
4. {
5.     uint32_t t;
6.     static uint32_t l = 0;
7.     static uint32_t WorkTim = 0;
8.     static uint32_t SleepTim = 0;
9.    
10.     //Zsumowanie czasu pracy
11.     WorkTim += DWT->CYCCNT - l;
12.    
13.     //Zapisanie czasu
14.     t = DWT->CYCCNT;
15.    
16.     //Wylaczenie przerwan
17.     __disable_irq();
18.    
19.     //Wejscie do trybu uspienia
20.     __WFI();
21.    
22.     //Zwiekszenie liczby cykli
23.     SleepTim += DWT->CYCCNT - t;
24.    
25.     //Zapisanie aktualnego czasu do zmiennej
26.     l = DWT->CYCCNT;
27.    
28.     //Ponowne wlaczenie przerwania
29.     __enable_irq();
30.    
31.     state_flag = 0;
32.    
33.     if ((SleepTim + WorkTim) >= SystemCoreClock)
34.     {
35.         //Wprowadzenie danych do struktury
36.         CPU_Load->Sleep_Cycles = SleepTim;
37.         CPU_Load->Working_Cycles = WorkTim;
38.         CPU_Load->Load_Percent = (((float)WorkTim / (float)(SleepTim + WorkTim)) * 100);
39.        
40.         //Resetuj czas
41.         SleepTim = 0;
42.         WorkTim = 0;
43.         state_flag = 1;
44.     }
45.    
46.     return state_flag;
47. }