[V] STM32F429I - Projekt - Zegar RTC, Wyświetlacz, Touchpad

Ten post poświęcę na przygotowanie programu obsługującego zegar czasu rzeczywistego w mikrokontrolerze STM32F429I. Do projektu dodatkowo zostanie dołożona obsługa wyświetlacza oraz touchpada w oparciu o biblioteki HAL'a.

Kwarc:

Jeśli chodzi o źródło taktowania układu to możliwe są dwa rozwiązania, kwarc wewnętrzny oraz zewnętrzny. Oba o wartościach 32.768 kHz. W obu płytkach discovery (STM32F407VG oraz STM32F429I) kwarc zewnętrzny nie został zamontowany, zostało na niego tylko przygotowane miejsce.

Zegar wewnętrzny posiada dosyć duży błąd oraz ulega sporym wahaniom wraz ze zmianami temperatury. Może to być dosyć mocno uciążliwie, jeżeli utrzymywanie poprawnego czasu jest bardzo ważne dla aplikacji. Ten problem można rozwiązać na dwa sposoby.

Pierwszy z nich polega na zamontowaniu stabilnego kwarcu zewnętrznego. Pozwoli on na znacznie dokładniejsze odmierzanie czasu. Drugi sposób natomiast dotyczy zostania przy kwarcu wewnętrznym natomiast przeprowadzanie aktualizacji czasu poprzez internet. Dla prostszych aplikacji sposób 1 jest zdecydowanie bardziej odpowiedni. Dla bardzo rozbudowanych układów, które już wykorzystują połączenie z internetem równie dobrze można wprowadzić aktualizację czasu.

Na obrazku powyżej przedstawiłem podłączenie kwarcu zaczerpnięte z dokumentacji do układu.

Drugim ważnym elementem jest podtrzymywanie czasu przez układ po zaniku zasilania. Na płytce nie wprowadzono możliwości dołączenia baterii. Odpowiednią podstawkę na baterie CR2032 należy zamontować na płytce w następujący sposób:

W pierwszej kolejności trzeba odlutować rezystor R52 (STM32F429I) bądź R26(STM32F407). Należy to zrobić ponieważ gdy odłączone będzie zasilanie to bateria będzie wykorzystywana do zasilania całego układu, drugim minusem jest to, że po ponownym załączeniu zasilania VDD będzie powodował ładowanie baterii. Co w przypadku standardowej CR2032 nie byłoby wskazane. 

Po tej drobnej operacji koszyk z baterią należy przylutować np. do kondensatora podłączonego do pinu VBAT tzn. C28 (STM32F407 oraz STM32F429I) bądź bezpośrednio do pinu 6 mikrokontrolera.

Tworzenie projektu CubeMx:

W tej części pominę inicjalizację RTC, ponieważ ona będzie włączona bezpośrednio w przygotowanym programie z pominięcie włączenia poprzez Cuba'a.

Program oraz jego główne funkcje:

Poniżej przedstawię poszczególne funkcje dla RTC, następnie przejdę do opisu touchpada oraz wyświetlacza.

RTC programowanie:

Na samym początku układ RTC.

Poniżej funkcja włączająca cały układ:

1. uint32_t RTC_Init(RTC_ClockSource_t source)   //Inicjalizacja RTC
2. {
3.     uint32_t status;
4.     RTC_time_t datatime;
5.    
6.     //--------------------------------------------------------------
7.     RTC_Handle.Instance = RTC;                                 
8.     RTC_Handle.Init.AsynchPrediv = RTC_ASYNC_PREDIV;           
9.     RTC_Handle.Init.SynchPrediv = RTC_SYNC_PREDIV;                 
10.     RTC_Handle.Init.HourFormat = RTC_HOURFORMAT_24;                
11.     RTC_Handle.Init.OutPut = RTC_OUTPUT_DISABLE;                   
12.     RTC_Handle.Init.OutPutType = RTC_OUTPUT_TYPE_PUSHPULL;         
13.     RTC_Handle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;     
14.     //--------------------------------------------------------------
16.     __HAL_RCC_PWR_CLK_ENABLE();                                 //PWR ON
17.     HAL_PWR_EnableBkUpAccess();                                 //BKP Domain
18.     status = HAL_RTCEx_BKUPRead(&RTC_Handle, RTC_STATUS_REG);   //Status RTC
19.    
20.     //Sprawdzenie czy RTC zostalo juz zainicjalizowane
21.     if (status == RTC_STATUS_TIME_OK)
22.     {
23.         //Wlaczenie zegara wewnetrznego, jeśli taki został wybrany
24.         if (source == RTC_ClockSource_Internal)
25.         {
26.             RTC_Config(RTC_ClockSource_Internal);
27.         }
29.         HAL_RTC_WaitForSynchro(&RTC_Handle);                    //Oczekiwanie na synchronizacje RTC
30.         RTC_GetDateTime(&datatime, RTC_Format_BIN);             //Pobranie daty oraz czasu
31.         __HAL_RCC_CLEAR_RESET_FLAGS();                          //Wyczyszczenie flag resetu
32.         return 1;                                               //Zwroc OK
33.     }
34.     else
35.     {
36.         RTC_Config(source);                                     //Wlacz RTC zegar
37.        
38.         //Ustaw wartosci domyslne w strukturze daty
39.         RTC_DateStruct.Year = 0;
40.         RTC_DateStruct.Month = 1;
41.         RTC_DateStruct.Date = 1;
42.         RTC_DateStruct.WeekDay = RTC_WEEKDAY_TUESDAY;
43.        
44.         HAL_RTC_SetDate(&RTC_Handle, &RTC_DateStruct, RTC_FORMAT_BIN);
46.         //Ustaw czas wartosci domyslne
47.         RTC_TimeStruct.Hours = 0x00;
48.         RTC_TimeStruct.Minutes = 0x00;
49.         RTC_TimeStruct.Seconds = 0x00;
50.         RTC_TimeStruct.TimeFormat = RTC_HOURFORMAT_24;
51.         RTC_TimeStruct.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
52.         RTC_TimeStruct.StoreOperation = RTC_STOREOPERATION_RESET;
54.         //Ustaw czas
55.         HAL_RTC_SetTime(&RTC_Handle, &RTC_TimeStruct, RTC_FORMAT_BCD);
56.        
57.         //Wlacz RTC
58.         HAL_RTC_Init(&RTC_Handle);
60.         //Zapisz dane do back up register
61.         HAL_RTCEx_BKUPWrite(&RTC_Handle, RTC_STATUS_REG, RTC_STATUS_TIME_OK);
62.        
63.         //RTC byl juz zainicjalizowany
64.         return 0;
65.     }
66. }

Ustawienie zegarów:

1. void RTC_Config(RTC_ClockSource_t source)
2. {
3.     RCC_OscInitTypeDef RCC_OscInitStruct;
4.     RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
6.     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
8.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;          //Wylaczenie PLL
10.     if (source == RTC_ClockSource_Internal)                 //LSI
11.     {
12.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
13.         RCC_OscInitStruct.LSIState = RCC_LSI_ON;
15.         PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
16.     }
17.     else                                                    //LSE
18.     {
19.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
20.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
22.         PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
23.     }
24.    
25.     HAL_RCC_OscConfig(&RCC_OscInitStruct);                  //Configuracja oscylatora
27.     HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);        //Select peripheral clock
29.     __HAL_RCC_RTC_ENABLE();                                 //Enable RTC clock
30. }

Włączenie przerwań od RTC:

1. typedef enum
2. {
3.     RTC_Interupt_Dis = 0x00,
4.     RTC_Interupt_60s,
5.     RTC_Interupt_30s,
6.     RTC_Interupt_15s,
7.     RTC_Interupt_10s,
8.     RTC_Interupt_5s,
9.     RTC_Interupt_2s,
10.     RTC_Interupt_1s,
11.     RTC_Interupt_500ms,
12.     RTC_Interupt_250ms,
13.     RTC_Interupt_125ms
14. } RTC_Interupt_t;
16. RTC_Resoult_t RTC_Interrupts(RTC_Interupt_t int_value)
17. {
18.     uint32_t val_to_set;
19.    
20.     __HAL_RTC_WAKEUPTIMER_DISABLE(&RTC_Handle); //Disable interrupt
21.    
22.     __HAL_RTC_WAKEUPTIMER_DISABLE_IT(&RTC_Handle, RTC_IT_WUT);
23.    
24.     (EXTI->PR = RTC_EXTI_LINE_WAKEUPTIMER_EVENT); //Clear pending bit
25.    
26.     __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&RTC_Handle, RTC_FLAG_WUTF); //Clear flag
27.    
28.     if (int_value != RTC_Interupt_Dis) {
29.         if (int_value == RTC_Interupt_60s)      {   val_to_set = 0x3BFFF;   }
30.         else if (int_value == RTC_Interupt_30s) {   val_to_set = 0x1DFFF;   }
31.         else if (int_value == RTC_Interupt_15s) {   val_to_set = 0xEFFF;    }
32.         else if (int_value == RTC_Interupt_10s) {   val_to_set = 0x9FFF;    }
33.         else if (int_value == RTC_Interupt_5s)  {   val_to_set = 0x4FFF;    }
34.         else if (int_value == RTC_Interupt_2s)  {   val_to_set = 0x1FFF;    }
35.         else if (int_value == RTC_Interupt_1s)  {   val_to_set = 0x0FFF;    }
36.         else if (int_value == RTC_Interupt_500ms) { val_to_set = 0x7FF; }
37.         else if (int_value == RTC_Interupt_250ms) { val_to_set = 0x3FF; }
38.         else if (int_value == RTC_Interupt_125ms) { val_to_set = 0x1FF; }      
40.         HAL_RTCEx_SetWakeUpTimer_IT(&RTC_Handle, val_to_set, RTC_WAKEUPCLOCK_RTCCLK_DIV8);
41.        
42.         HAL_NVIC_SetPriority(RTC_WKUP_IRQn, RTC_NVIC_PRIORITY, RTC_NVIC_WAKEUP_SUBPRIORITY);
43.         HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);
44.     }
46.     return RTC_Result_Ok;
47. }

Obsługa Touchpada:

Na samym początku należy rozpocząć od inicjalizacji touchpada:

1. uint32_t BSP_LCD_GetXSize(void)
2. {
3.   return LcdDrv->GetLcdPixelWidth();
4. }
6. uint32_t BSP_LCD_GetYSize(void)
7. {
8.   return LcdDrv->GetLcdPixelHeight();
9. }
11. uint8_t BSP_TS_Init(uint16_t XSize, uint16_t YSize)
12. {
13.   uint8_t ret = TS_ERROR;
15.   //Inicjalizacja wielkości ekranu x oraz y
16.   TsXBoundary = XSize;
17.   TsYBoundary = YSize;
19.   /* Read ID and verify if the IO expander is ready */
20.   if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
21.   {
22.     TsDrv = &stmpe811_ts_drv;   //Inicjalizacja struktury dla TS
23.     ret = TS_OK;
24.   }
26.   if(ret == TS_OK)      //Inicjalizacja sterowników TS
27.   {
28.     TsDrv->Init(TS_I2C_ADDRESS);
29.     TsDrv->Start(TS_I2C_ADDRESS);
30.   }
32.   return ret;
33. }

Funkcje ustawiające długość boków X oraz boku Y wyświetlacza. Następna pozwala na inicjalizację touchpada:

1. uint32_t BSP_LCD_GetXSize(void)
2. {
3.   return LcdDrv->GetLcdPixelWidth();
4. }
6. uint32_t BSP_LCD_GetYSize(void)
7. {
8.   return LcdDrv->GetLcdPixelHeight();
9. }
11. uint8_t BSP_TS_Init(uint16_t XSize, uint16_t YSize)
12. {
13.   uint8_t ret = TS_ERROR;
15.   //Inicjalizacja wielkości ekranu x oraz y
16.   TsXBoundary = XSize;
17.   TsYBoundary = YSize;
19.   /* Read ID and verify if the IO expander is ready */
20.   if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
21.   {
22.     TsDrv = &stmpe811_ts_drv;   //Inicjalizacja struktury dla TS
23.     ret = TS_OK;
24.   }
26.   if(ret == TS_OK)      //Inicjalizacja sterowników TS
27.   {
28.     TsDrv->Init(TS_I2C_ADDRESS);
29.     TsDrv->Start(TS_I2C_ADDRESS);
30.   }
32.   return ret;
33. }

Obsługa Wyświetlacza:

Obsługa wyświetlacza za pomocą funkcji BSP wygląda następująco:

Najpierw inicjalizacja wyświetlacza:

1. uint8_t BSP_LCD_Init(void)
2. {
3.   /* On STM32F429I-DISCO, it is not possible to read ILI9341 ID because */
4.   /* PIN EXTC is not connected to VDD and then LCD_READ_ID4 is not accessible. */
5.   /* In this case, ReadID function is bypassed.*/  
6.   /*if(ili9341_drv.ReadID() == ILI9341_ID)*/
8.     /* LTDC Configuration ----------------------------------------------------*/
9.     LtdcHandler.Instance = LTDC;
10.    
11.     /*
12.      * Timing configuration  (Typical configuration from ILI9341 datasheet)
13.      * HSYNC=10 (9+1) | HBP=20 (29-10+1) | ActiveW=240 (269-20-10+1) | HFP=10 (279-240-20-10+1)
14.      * VSYNC=2 (1+1) | VBP=2 (3-2+1) | ActiveH=320 (323-2-2+1) | VFP=4 (327-320-2-2+1)
15.     */
16.    
17.     LtdcHandler.Init.HorizontalSync = ILI9341_HSYNC;    //Configure horizontal synchronization width
18.     LtdcHandler.Init.VerticalSync = ILI9341_VSYNC;      //Configure vertical synchronization height
19.     LtdcHandler.Init.AccumulatedHBP = ILI9341_HBP;      //Configure accumulated horizontal back porch
20.     LtdcHandler.Init.AccumulatedVBP = ILI9341_VBP;      //Configure accumulated vertical back porch
21.     LtdcHandler.Init.AccumulatedActiveW = 269;          //Configure accumulated active width
22.     LtdcHandler.Init.AccumulatedActiveH = 323;          //Configure accumulated active height
23.     LtdcHandler.Init.TotalWidth = 279;                  //Configure total width
24.     LtdcHandler.Init.TotalHeigh = 327;                  //Configure total height
25.    
26.     /* Configure R,G,B component values for LCD background color */
27.     LtdcHandler.Init.Backcolor.Red= 0;              //R Value
28.     LtdcHandler.Init.Backcolor.Blue= 0;             //B Value
29.     LtdcHandler.Init.Backcolor.Green= 0;            //G Value
30.    
31.     /* LCD clock configuration */
32.     /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
33.     /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */
34.     /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */
35.     /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */
36.     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
37.     PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;
38.     PeriphClkInitStruct.PLLSAI.PLLSAIR = 4;
39.     PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8;
40.     HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
41.    
42.     //Polarity
43.     LtdcHandler.Init.HSPolarity = LTDC_HSPOLARITY_AL;
44.     LtdcHandler.Init.VSPolarity = LTDC_VSPOLARITY_AL;
45.     LtdcHandler.Init.DEPolarity = LTDC_DEPOLARITY_AL;
46.     LtdcHandler.Init.PCPolarity = LTDC_PCPOLARITY_IPC;
47.    
48.     MspInit();
49.     HAL_LTDC_Init(&LtdcHandler);
50.    
51.     /* Select the device */
52.     LcdDrv = &ili9341_drv;
54.     /* LCD Init */   
55.     LcdDrv->Init();
57.     /* Initialize the SDRAM */
58.     BSP_SDRAM_Init();
60.     /* Initialize the font */
61.     BSP_LCD_SetFont(&LCD_DEFAULT_FONT);
63.   return LCD_OK;
64. }

Kolejna funkcja z biblioteki BSP służy do wybrania warstwy oraz bufora:

1. void BSP_LCD_LayerDefaultInit(uint16_t LayerIndex, uint32_t FB_Address)
2. {    
3.   LCD_LayerCfgTypeDef   Layercfg;
5.   //Layer Init
6.   Layercfg.WindowX0 = 0;
7.   Layercfg.WindowX1 = BSP_LCD_GetXSize();
8.   Layercfg.WindowY0 = 0;
9.   Layercfg.WindowY1 = BSP_LCD_GetYSize();
10.   Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_ARGB8888;
11.   Layercfg.FBStartAdress = FB_Address;
12.   Layercfg.Alpha = 255;
13.   Layercfg.Alpha0 = 0;
14.   Layercfg.Backcolor.Blue = 0;
15.   Layercfg.Backcolor.Green = 0;
16.   Layercfg.Backcolor.Red = 0;
17.   Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
18.   Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
19.   Layercfg.ImageWidth = BSP_LCD_GetXSize();
20.   Layercfg.ImageHeight = BSP_LCD_GetYSize();
22.   HAL_LTDC_ConfigLayer(&LtdcHandler, &Layercfg, LayerIndex);
24.   DrawProp[LayerIndex].BackColor = LCD_COLOR_WHITE;
25.   DrawProp[LayerIndex].pFont     = &Font24;
26.   DrawProp[LayerIndex].TextColor = LCD_COLOR_BLACK;
28.   //Dithering activation
29.   HAL_LTDC_EnableDither(&LtdcHandler);
30. }

Następnie wykorzystywane są funkcje odpowiedzialne za wybranie aktywnej warstwy, włączenie wyświetlacza oraz zapełnienie ekranu wybranym kolorem

1. void BSP_LCD_SelectLayer(uint32_t LayerIndex)
2. {
3.   ActiveLayer = LayerIndex;
4. }
6. void BSP_LCD_DisplayOn(void)
7. {
8.   if(LcdDrv->DisplayOn != NULL)
9.   {
10.     LcdDrv->DisplayOn();
11.   }
12. }
14. void BSP_LCD_Clear(uint32_t Color)
15. {
16.   /* Clear the LCD */
17.   FillBuffer(ActiveLayer, (uint32_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress), BSP_LCD_GetXSize(), BSP_LCD_GetYSize(), 0, Color);
18. }

Do wyświetlania tekstu na ekranie wykorzystuje takie funkcje jak:

1. void BSP_LCD_DisplayChar(uint16_t Xpos, uint16_t Ypos, uint8_t Ascii)
2. {
3.   DrawChar(Xpos, Ypos, &DrawProp[ActiveLayer].pFont->table[(Ascii-' ') *\
4.               DrawProp[ActiveLayer].pFont->Height * ((DrawProp[ActiveLayer].pFont->Width + 7) / 8)]);
5. }
7. void BSP_LCD_DisplayStringAtLine(uint16_t Line, uint8_t *ptr)
8. {
9.   BSP_LCD_DisplayStringAt(0, LINE(Line), ptr, LEFT_MODE);
10. }
12. void BSP_LCD_DisplayStringAt(uint16_t X, uint16_t Y, uint8_t *pText, Text_AlignModeTypdef mode)
13. {
14.   uint16_t refcolumn = 1, i = 0;
15.   uint32_t size = 0, xsize = 0;
16.   uint8_t  *ptr = pText;
18.   while (*ptr++) { size++; }    //Get text size
20.   xsize = (BSP_LCD_GetXSize()/DrawProp[ActiveLayer].pFont->Width);  //Characters number per line
22.   switch (mode) //Select data align metod
23.   {
24.   case CENTER_MODE:
25.     {
26.       refcolumn = X+ ((xsize - size)* DrawProp[ActiveLayer].pFont->Width) / 2;
27.       break;
28.     }
29.   case LEFT_MODE:
30.     {
31.       refcolumn = X;
32.       break;
33.     }
34.   case RIGHT_MODE:
35.     {
36.       refcolumn = X + ((xsize - size)*DrawProp[ActiveLayer].pFont->Width);
37.       break;
38.     }
39.   default:
40.     {
41.       refcolumn = X;
42.       break;
43.     }
44.   }
46.   //send data as string character by character on LCD
47.   while ((*pText != 0) & (((BSP_LCD_GetXSize() - (i*DrawProp[ActiveLayer].pFont->Width)) & 0xFFFF) >= DrawProp[ActiveLayer].pFont->Width))
48.   {
49.     //Display one character on LCD
50.     BSP_LCD_DisplayChar(refcolumn, Y, *pText);
51.     // Decrement the column position by 16
52.     refcolumn += DrawProp[ActiveLayer].pFont->Width;
53.     // Point on the next character */
54.     pText++;
55.     i++;
56.   }  
57. }

Tekst wyświetlany może też zostać zdefiniowany bezpośrednio w definicjach. Wtedy przyjmuje on następującą postać:

1. #define printf_date(...)         BSP_LCD_SetFont(&Font16);\
2.                                  BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()/17, __VA_ARGS__, CENTER_MODE);
4. #define printf_time(...)         BSP_LCD_SetFont(&Font16);\
5.                                  BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()/10, __VA_ARGS__, CENTER_MODE);

Do definicji podaje się bufor z danymi, które mają być wyświetlone na wyświetlaczu.

Teraz przejdę do obsługi dotyku. Klawisze zostały zdefiniowane w przygotowanej strukturze, która zawiera wszystkie potrzebne elementy.

1. typedef void (*ButtonClickHandler) (uint8_t buttonId);
3. typedef struct{
4.     const uint8_t ButtonId;
5.     ButtonClickHandler Handler;
6.     const uint16_t Xpos;
7.     const uint16_t Ypos;
8.     const uint16_t Width;
9.     const uint16_t Height;
10. }Button_t;
12. Button_t HourIncrement = {
13.         .ButtonId = 0x01,
14.         .Handler = HourIncrementHandler,
15.         .Xpos = 0,
16.         .Ypos = 80,
17.         .Width = 50,
18.         .Height = 60,
19. };
20. Button_t HourDecrement = {
21.         .ButtonId = 0x02,
22.         .Handler = HourDecrementHandler,
23.         .Xpos = 60,
24.         .Ypos = 80,
25.         .Width = 50,
26.         .Height = 60,
27.     };
28. Button_t MinutesIncrement = {
29.         .ButtonId = 0x03,
30.         .Handler = MinutesIncrementHandler,
31.         .Xpos = 120,
32.         .Ypos = 80,
33.         .Width = 50,
34.         .Height = 60,
35.     };
36. Button_t MinutesDecrement = {
37.         .ButtonId = 0x04,
38.         .Handler = MinutesDecrementHandler,
39.         .Xpos = 180,
40.         .Ypos = 80,
41.         .Width = 50,
42.         .Height = 60,
43.     };
45. Button_t *allButtons[4] = {
46.         &HourIncrement,
47.         &HourDecrement,
48.         &MinutesIncrement,
49.         &MinutesDecrement
50. };

W strukturze przechowywany jest numer przycisku, wskaźnik na funkcję obsługującą kliknięcie w obszarze przycisku, pozycję startową na osi X oraz osi Y, ostatnie dwa parametry zawierają szerokość oraz wysokość prosokąta. Wszystkie zdefiniowane przyciski są zebrane razem jako wskaźniki w allButtons[4].

Inicjalizacja przycisków przebiega w sposób następujący:

1.   for(i=0; i<4; i++)    //Stworzenie przycisków
2.   {
3.       BSP_LCD_FillRect(allButtons[i]->Xpos, allButtons[i]->Ypos, allButtons[i]->Width, allButtons[i]->Height);
4.   }
6.   BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
8.   BSP_LCD_DisplayStringAt(25, 100, (uint8_t*)"M+", CENTER_MODE);
9.   BSP_LCD_DisplayStringAt(85, 100, (uint8_t*)"M-", CENTER_MODE);
10.   BSP_LCD_DisplayStringAt(145, 100, (uint8_t*)"H+", CENTER_MODE);
11.   BSP_LCD_DisplayStringAt(205, 100, (uint8_t*)"H-", CENTER_MODE);

W pętli for następuje przejście pomiędzy wszystkimi przyciskami, po ich umieszczeniu na ekranie

Obsługa dotyku zrealizowana została na liczniku 6, jego inicjalizacja wygląda następująco:

1. static void MX_TIM6_Init(void)
2. {
3.   TIM_MasterConfigTypeDef sMasterConfig;
5.   htim6.Instance = TIM6;
6.   htim6.Init.Prescaler = 1000;
7.   htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
8.   htim6.Init.Period = 400;
9.   if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
10.   {
11.     Error_Handler();
12.   }
14.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_ENABLE;
15.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
16.   if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
17.   {
18.     Error_Handler();
19.   }
20.   HAL_TIM_Base_Start_IT(&htim6);
21. }

W procedurze obsługi przerwania zrealizowałem aktualizowanie RTC oraz sprawdzanie każdego z przycisków z wywołanie obsługi kliknięcia:

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
2. {
3.     uint8_t i=0;
4.     char data[40];
6.     if (status == 1)
7.     {
8.         BSP_TS_GetState(&TS_State);
10.         if (TS_State.TouchDetected)
11.         {
12.             coordinate.positionX = Calibration_GetX(TS_State.X);
13.             coordinate.positionY = Calibration_GetY(TS_State.Y);
15.             sprintf(data, "Touch: X:%u Y:%u", coordinate.positionX, coordinate.positionY);
16.             printf_touch_pos((uint8_t*)data);
18.             for(i=0;i<4;i++)
19.             {
20.                 if((coordinate.positionY > allButtons[i]->Ypos) && (coordinate.positionY < (allButtons[i]->Ypos + allButtons[i]->Height)))
21.                 {
22.                     if((coordinate.positionX > allButtons[i]->Xpos) && (coordinate.positionX < (allButtons[i]->Xpos + allButtons[i]->Width)))
23.                     {
24.                         allButtons[i]->Handler(allButtons[i]->ButtonId);
25.                         status = 0;
26.                     }
27.                 }
28.             }
29.         }
30.         else
31.         {
32.             coordinate.positionX = 0;
33.             coordinate.positionY = 0;
34.         }
35.     }
37.     RTC_GetDateTime(&RTCD, RTC_Format_BIN);
39.     if (RTCD.Seconds != sec)
40.     {
41.         sec = RTCD.Seconds;
42.         sprintf(data, "D: %02d.%02d.%04d", RTCD.Day, RTCD.Month, RTCD.Year + 2000);
43.         printf_date((uint8_t*)data);
45.         sprintf(data, "T: %02d.%02d.%02d", RTCD.Hours, RTCD.Minutes, RTCD.Seconds);
46.         printf_time((uint8_t*)data);
47.         BSP_LCD_SetBackColor(LCD_COLOR_YELLOW);
48.     }
49. }

Obsługa przycisku na kliknięcie. Jest on wywoływany w przerwaniu od przycisku, po sprawdzeniu miejsca jego kliknięcia.

1. ButtonClickHandler HourIncrementHandler(uint8_t buttonId)
2. {
3.     BSP_LCD_DisplayStringAtLine(9, (uint8_t*)"H+");
4.     SetDate(1, 0);
5. }
7. ButtonClickHandler HourDecrementHandler(uint8_t buttonId)
8. {
9.     BSP_LCD_DisplayStringAtLine(9, (uint8_t*)"H-");
10.     SetDate(2, 0);
11. }
13. ButtonClickHandler MinutesIncrementHandler(uint8_t buttonId)
14. {
15.     BSP_LCD_DisplayStringAtLine(9, (uint8_t*)"M+");
16.     SetDate(0, 1);
17. }
19. ButtonClickHandler MinutesDecrementHandler(uint8_t buttonId)
20. {
21.     BSP_LCD_DisplayStringAtLine(9, (uint8_t*)"M-");
22.     SetDate(0, 2);
23. }

Pliki z projektem można znaleźć na dysku Google pod tym linkiem.