[3] STM32 - STM32F0 - Riverdi FT801 - Revelation Board Project CooCox

W tym poście chciałbym opisać sposób obsługi wyświetlacza ze sterownikiem FT801 wraz z obsługą bazowego projektu udostępnionego przez firmę Riverdi.

[Źródło: https://riverdi.com/wp-content/uploads/datasheet/Revelation_Board_Datasheet_Rev.1.1.pdf]

Opis:

Producent udostępnił projekt testowy przygotowany w środowisku CooCox. Do projektu wykorzystano biblioteki STD.

Wykorzystywana prze zemnie płyta Revelation Board została wyposażona mikrokontroler STM32F031C6.

W celu zaprogramowania układu należy wykorzystać programator ST-Link. Po czym podłączyć się do złącza CN4 na płycie od Riverdi.

Do programowania płytki wykorzystałem programator ST-Link V2. Ale równie dobrze można wykorzystać programator z płytek Nucleo bądź inne urządzenie wspierające interfejs SWD.

Podłączenie do programatora ST-Link/V2:

[Źródło: https://www.st.com/content/ccc/resource/technical/document/user_manual/65/e0/44/72/9e/34/41/8d/DM00026748.pdf/files/DM00026748.pdf/jcr:content/translations/en.DM00026748.pdf]

• 1 - VCC
• 7 - SWDIO
• 9 - SWCLK
• 15 - RESET (Opcjonalnie)
• 20 - GND

Poprawność podłączenia może zostać sprawdzona za pomocą programu ST-Link Utility. Po podłączeniu programatora do komputera oraz do mikrokontrolera i wciśnięciu przycisku Connect to the target powinien wyświetlić się program odczytany z urządzenia:

CooCox:

Poniżej opiszę projekt udostępniony przez firmę Riverdi. Przygotowany w środowisku CooCox.

Projekt pozwala na obsługę wielu wyświetlaczy firmy Riverdi. W moim przypadku jest to wyświetlacz z pojemnościowym panelem dotykowym oraz przekątną ekranu 4'3 cala.

W celu korzystania z projektu w środowisku przygotowanym przez producenta należy pobrać CooCox CoIDE np. w wersji 1.7.8 oraz zainstalować potrzebne biblioteki w postaci pliku gcc-arm-none-eabi-5_4-2016q3-20160926-win32.exe. Następnie po uruchomieniu projektu należy podać ścieżkę do zainstalowanych narzędzi (Project->Select Toolchain Path):

C:\Program Files\GNU Tools ARM Embedded\5.4 2016q3\bin

Projekt zawiera szereg funkcji pozwalających na obsługę wyświetlaczy z sterownikiem FT801 bądź FT800.

Komunikacja z wyświetlaczem odbywa się przez interfejs SPI oraz biblioteki STD dla mikrokontrolera STM32F0. Dane przesyłane są za pomocą następującej funkcji:

1. unsigned char SPI_SendByte(unsigned char data)
2. {
3.     /* Wait until the transmit buffer is empty */
4.     while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) { }
6.     /* Send the byte */
7.     SPI_SendData8(SPI1, data);
9.     /* Wait to receive a byte*/
10.     while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) { }
11.    
12.     /* Return the byte read from the SPI bus */
13.     return SPI_ReceiveData8(SPI1);
14. }

W celu przesłania danych do wyświetlacza można posłużyć się następującymi komendami:

1. ft_uint8_t Ft_Gpu_Hal_Rd8(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr);
2. ft_uint16_t Ft_Gpu_Hal_Rd16(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr);
3. ft_uint32_t Ft_Gpu_Hal_Rd32(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr);
4. ft_void_t Ft_Gpu_Hal_Wr8(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr, ft_uint8_t v);
5. ft_void_t Ft_Gpu_Hal_Wr16(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr, ft_uint16_t v);
6. ft_void_t Ft_Gpu_Hal_Wr32(Ft_Gpu_Hal_Context_t *host,ft_uint32_t addr, ft_uint32_t v);
7. ft_void_t Ft_Gpu_HostCommand(ft_uint8_t cmd);

W projekcie można znaleźć dużą ilość przykładowych okien z wygenerowanymi różnymi grafikami jak i z różną funkcjonalnością np. wygenerowanie grafiki z Google Maps, wielopunktowy dotyk, rysowanie itp.

Poniżej krótka funkcja testowa prezentująca kliknięcie przycisku i wyświetlenie tekstu. Jest to modyfikacja jednego z okien testowych:

1. Ft_Gpu_CoCmd_Dlstart(phost);
3. Ft_App_WrCoCmd_Buffer(phost,CLEAR_COLOR_RGB(0,31,63));//white color
4. Ft_App_WrCoCmd_Buffer(phost,CLEAR(1,1,1));//clear screen
5. Ft_App_WrCoCmd_Buffer(phost,COLOR_RGB(0xFF,0xFF,0xFF));//red color
7. Ft_Gpu_CoCmd_Text(phost,(FT_DispWidth/2), (FT_DispHeight/10), 29, OPT_CENTERX, "Test wyswietlania");
9. Ft_App_WrCoCmd_Buffer(phost,COLOR_RGB(0xff,0x00,0x00));
10. StringArray[0] = '\0';
11. strcat(StringArray,"Counter ");
12. Ft_Gpu_Hal_Dec2Ascii(StringArray,(ThisDemoEnd/100)+1);
13. strcat(StringArray,"s");
14. Ft_Gpu_CoCmd_Text(phost,FT_DispWidth/2, (FT_DispHeight/4), 26, OPT_CENTERX, StringArray);
16. Ft_App_WrCoCmd_Buffer(phost,COLOR_RGB(0xff,0xff,0xff));
17. Ft_App_WrCoCmd_Buffer(phost,TAG(240));
18. Ft_Gpu_CoCmd_Button(phost,FT_DispWidth-65,FT_DispHeight-42,60,30,20,0, "Btn");
19. CurrTag2 = Ft_Gpu_Hal_Rd8(phost,REG_TOUCH_TAG);
21. if(touchTagValue == 1)
22. {
23.     Ft_Gpu_CoCmd_Text(phost,(FT_DispWidth/2), (FT_DispHeight/4), 29, OPT_CENTERX, "Btn Click");
24. }
26. Ft_App_WrCoCmd_Buffer(phost,DISPLAY());
27. Ft_Gpu_CoCmd_Swap(phost);
29. /* Download the commands into fifo */
30. Ft_App_Flush_Co_Buffer(phost);
32. /* Wait till coprocessor completes the operation */
33. Ft_Gpu_Hal_WaitCmdfifo_empty(phost);
35. /* Touch press check in sysTick */
36. void SysTick_Handler(void)
37. {
38.     //...
39.     //...
40.     //...
41.     if(CurrTag2 == 240)
42.     {
43.         CurrTag2 = 0;
44.         touchTagValue = 1;
45.         displayCounter=0;
46.     }
48.     if(touchTagValue == 1)
49.     {
50.         displayCounter++;
51.         if(displayCounter == 600)
52.         {
53.             displayCounter = 0;
54.             touchTagValue = 0;
55.         }
56.     }

Testowy projekt zmodyfikowany lekko zmodyfikowany przeze mnie można pobrać z dysku Google
tym linkiem.

W kolejnych postach przeniosę bibliotekę udostępnioną przez Riverdi do obsługi środowsika System Workbench  oraz przygotuję testowy projekt dla mikrokontrolera STM32F4 z biblioteką customową oraz kolejny projekt zawierający modyfikację plików udostępnionych przez producenta.