sobota, 19 listopada 2016

[1] STM32F429l - Wyświetlacz LCD

W tym poście chiałbym przedstawić sposób obsługi wyświetlacza zamontowanego na płytce STM32F429l Discovery za pomocą CubeMx oraz bibliotek standardowych.

Opis wyświetlacza:


Na płytkach discovery z  mikrokontrolerm STM32F429l znajduje się wyświetlacz LCD wyposarzony w sterownik ILI9341. Rodzielczość to 2,41", QVGA 240x320 pikseli. Głębia kolorów to 16(65536) bądź 18 bitów (262144). Co daje całkiem pokaźną liczbę kolorów.

Kontroler może być operowany z napięciem 2.8V +/- 0.3V.

Mikrokontroler został wyposarzony w sterownik LTDC do sterowania wyświetlaczem. Można nim sterować za pomocą wspomnianego sterownika lub za pomocą interfejsu SPI.

Rys. 1. Podłączenie wyświetlacza

Podłączenie 

Poniżej schemat oraz sposób podłączenia do poszczególnych pinów na płytce Discovery:

  • MISO - PF8
  • Podświetlenie(LED) - 3.3V
  • Clock - PF7
  • MOSI - PF9
  • WRX - PD13 - Rejest Data/Command
  • CS - PC2
  • Reset - PD12
  • GND - GND
  • VCC - 3.3V
Piny od SPI podłaczone są pod SPI5.

Programowanie CubeMx:


W celu przygotowania projektu należy posłużyć się środowiskiem CubeMx, które w graficzny sposób przedstawi sposób inicjalizacji głównych elementów.

Na samym początku dobrze pobrać paczkę z przykładami oraz sterownikami do STM32F4 z tego linku.

W pierwszej kolejności należy włączyć SDRam w konfiguracji przedstawionej na rysunku 1.

Rys. 2. Ustawienie projektu

Kolejnym elementem jest sterownik wyświetlacza LTDC z głębią kolorów ustawioną na 18 bitów, zegar na zewętrzny HSE, oraz SPI5 do których jest podłączony wyświetlacz.

Rys. 3. Ustawienie projektu

Kolejny etap dotyczy konfiguracji zegara. Wybrałem maksymane taktowanie z zegara zewnętrznego. Dodatkowo należy ustawić zegar dla wyświetlacza (na samym dole obrazka).

Rys. 4. Ustawienie projektu - taktowanie

Po przygotowaniu projektu zgodnie ze wskazówkami powyżej należy dołożyć elementy biblioteki, które ułatwią proces programowania.

BSP: Do programu należy dodać następujące pliki:
stm32f429i_discovery.c - Lokalizacja: Drivers\BSP\STM32F429I-Discovery
stm32f429i_discovery_lcd.c - Lokalizacja: Drivers\BSP\STM32F429I-Discovery
stm32f429i_discovery_sdram.c - Lokalizacja: Drivers\BSP\STM32F429I-Discovery
ili9341.c - Lokalizacji: Drivers\BSP\Components\ili9341

Dalej w zależnosci od wersji oprogramowania bądź bibliotek mogą występować błędy, ja spotkałem się z błędami dotyczącymi braku zdefiniowanej funkcji. Należy podstawić do projektu plik stm32f4xx_hal_ltdc z lokalizacji Drivers\STM32F4xx_HAL_Driver\Inc. Dodatkowo należy umieścić deklaracje funkcji np. w linii 133:

  1. /* Private function prototypes -----------------------------------------------*/
  2. static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx);
  3. __weak void HAL_LTDC_ReloadEventCallback(LTDC_HandleTypeDef *hltdc);
  4. /* Private functions ---------------------------------------------------------*/

Po takich operacjach projekt powinien się poprawnie skompilować. To teraz przejdę do głównej części projektu.

Na samym początku należy oczywiście dołożyć bibliotekę zawierającą wykrozystywane funkje:

  1. /* USER CODE BEGIN Includes */
  2. #include "stm32f429i_discovery_lcd.h"
  4. /* USER CODE END Includes */

Następnie w funkcji main należy:

  1.   /* USER CODE BEGIN 2 */
  2.     BSP_LCD_Init();                                                     //Wlaczenie biblioteki
  3.     BSP_LCD_LayerDefaultInit(LCD_BACKGROUND_LAYER, LCD_FRAME_BUFFER);   //Wlaczenie pierwszej warstw
  4.     BSP_LCD_LayerDefaultInit(LCD_FOREGROUND_LAYER, LCD_FRAME_BUFFER);   //Wlaczenie drugiej warstwy
  5.     BSP_LCD_SelectLayer(LCD_FOREGROUND_LAYER);                          //Wybranie warstwy aktywnej
  6.     BSP_LCD_DisplayOn();                                                //Wlaczenie podswietlania
  7.     BSP_LCD_Clear(LCD_COLOR_BLACK);                                     //Kolor Tla
  8.   /* USER CODE END 2 */

Po powyższych operacjach kolor tła jest ustawiony na czarny. Aby wpisać na ekran czy narysować coś należy wykonać:

  1.     BSP_LCD_SetTextColor(LCD_COLOR_RED);
  2.     BSP_LCD_DisplayStringAtLine(0,(uint8_t*)"Naglowek 1");
  3.     BSP_LCD_DisplayStringAt(10, 40, (uint8_t*)"Linia", LEFT_MODE);
  4.     BSP_LCD_FillRect(10, 100, 100, 50);

Dodatkowo przygotowałem funkcję, jak poniżej która pozwala na ustawianie parametrów dla każdej linii tekstu. Nie jest ona zbytnio skomplikowana. Podaje się do niej większą ilość parametrów po czym ona wchodzi do funkcji zdefiniowanych w bibliotece.

  1. void DisplayText(uint16_t X, uint16_t Y, uint8_t *pText, uint32_t Color,Text_AlignModeTypdef mode)
  2. {
  3.     BSP_LCD_SetTextColor(Color);
  4.     BSP_LCD_DisplayStringAt(X, Y, (uint8_t*)pText, mode);
  5. }

Dane liczbowe można przedstawić na ekranie poprzez wprowadzenie ich do bufora, oraz zamianę przy użyciu finkcji strcpy().

Programowanie biblioteki standardowe:


W tym poście przejdę przez procedurę odpalenia wyświetlacza za pomocą standardowych bibliotek.

Na samym początku należy zdefiniować potrzebne rejestry, można je pobrać bezpośrednio z biblioteki od HAL'a.

  1. #define LCD_SWRESET             0x01   /* Software Reset */
  2. #define LCD_READ_DISPLAY_ID     0x04   /* Read display identification information */
  3. #define LCD_RDDST               0x09   /* Read Display Status */
  4. #define LCD_RDDPM               0x0A   /* Read Display Power Mode */
  5. #define LCD_RDDMADCTL           0x0B   /* Read Display MADCTL */
  6. #define LCD_RDDCOLMOD           0x0C   /* Read Display Pixel Format */
  7. #define LCD_RDDIM               0x0D   /* Read Display Image Format */
  8. #define LCD_RDDSM               0x0E   /* Read Display Signal Mode */
  9. #define LCD_RDDSDR              0x0F   /* Read Display Self-Diagnostic Result */
  10. #define LCD_SPLIN               0x10   /* Enter Sleep Mode */
  11. #define LCD_SLEEP_OUT           0x11   /* Sleep out register */
  12. #define LCD_PTLON               0x12   /* Partial Mode ON */
  13. #define LCD_NORMAL_MODE_ON      0x13   /* Normal Display Mode ON */
  14. #define LCD_DINVOFF             0x20   /* Display Inversion OFF */
  15. #define LCD_DINVON              0x21   /* Display Inversion ON */
  16. #define LCD_GAMMA               0x26   /* Gamma register */
  17. #define LCD_DISPLAY_OFF         0x28   /* Display off register */
  18. #define LCD_DISPLAY_ON          0x29   /* Display on register */
  19. #define LCD_COLUMN_ADDR         0x2A   /* Colomn address register */
  20. #define LCD_PAGE_ADDR           0x2B   /* Page address register */
  21. #define LCD_GRAM                0x2C   /* GRAM register */  
  22. #define LCD_RGBSET              0x2D   /* Color SET */  
  23. #define LCD_RAMRD               0x2E   /* Memory Read */  
  24. #define LCD_PLTAR               0x30   /* Partial Area */  
  25. #define LCD_VSCRDEF             0x33   /* Vertical Scrolling Definition */  
  26. #define LCD_TEOFF               0x34   /* Tearing Effect Line OFF */  
  27. #define LCD_TEON                0x35   /* Tearing Effect Line ON */  
  28. #define LCD_MAC                 0x36   /* Memory Access Control register*/
  29. #define LCD_VSCRSADD            0x37   /* Vertical Scrolling Start Address */  
  30. #define LCD_IDMOFF              0x38   /* Idle Mode OFF */  
  31. #define LCD_IDMON               0x39   /* Idle Mode ON */  
  32. #define LCD_PIXEL_FORMAT        0x3A   /* Pixel Format register */
  33. #define LCD_WRITE_MEM_CONTINUE  0x3C   /* Write Memory Continue */  
  34. #define LCD_READ_MEM_CONTINUE   0x3E   /* Read Memory Continue */  
  35. #define LCD_SET_TEAR_SCANLINE   0x44   /* Set Tear Scanline */  
  36. #define LCD_GET_SCANLINE        0x45   /* Get Scanline */  
  37. #define LCD_WDB                 0x51   /* Write Brightness Display register */
  38. #define LCD_RDDISBV             0x52   /* Read Display Brightness */  
  39. #define LCD_WCD                 0x53   /* Write Control Display register*/
  40. #define LCD_RDCTRLD             0x54   /* Read CTRL Display */  
  41. #define LCD_WRCABC              0x55   /* Write Content Adaptive Brightness Control */  
  42. #define LCD_RDCABC              0x56   /* Read Content Adaptive Brightness Control */  
  43. #define LCD_WRITE_CABC          0x5E   /* Write CABC Minimum Brightness */  
  44. #define LCD_READ_CABC           0x5F   /* Read CABC Minimum Brightness */  
  45. #define LCD_READ_ID1            0xDA   /* Read ID1 */
  46. #define LCD_READ_ID2            0xDB   /* Read ID2 */
  47. #define LCD_READ_ID3            0xDC   /* Read ID3 */
  49. /* Level 2 Commands */
  50. #define LCD_RGB_INTERFACE       0xB0   /* RGB Interface Signal Control */
  51. #define LCD_FRMCTR1             0xB1   /* Frame Rate Control (In Normal Mode) */
  52. #define LCD_FRMCTR2             0xB2   /* Frame Rate Control (In Idle Mode) */
  53. #define LCD_FRMCTR3             0xB3   /* Frame Rate Control (In Partial Mode) */
  54. #define LCD_INVTR               0xB4   /* Display Inversion Control */
  55. #define LCD_BPC                 0xB5   /* Blanking Porch Control register */
  56. #define LCD_DFC                 0xB6   /* Display Function Control register */
  57. #define LCD_ETMOD               0xB7   /* Entry Mode Set */
  58. #define LCD_BACKLIGHT1          0xB8   /* Backlight Control 1 */
  59. #define LCD_BACKLIGHT2          0xB9   /* Backlight Control 2 */
  60. #define LCD_BACKLIGHT3          0xBA   /* Backlight Control 3 */
  61. #define LCD_BACKLIGHT4          0xBB   /* Backlight Control 4 */
  62. #define LCD_BACKLIGHT5          0xBC   /* Backlight Control 5 */
  63. #define LCD_BACKLIGHT7          0xBE   /* Backlight Control 7 */
  64. #define LCD_BACKLIGHT8          0xBF   /* Backlight Control 8 */
  65. #define LCD_POWER1              0xC0   /* Power Control 1 register */
  66. #define LCD_POWER2              0xC1   /* Power Control 2 register */
  67. #define LCD_VCOM1               0xC5   /* VCOM Control 1 register */
  68. #define LCD_VCOM2               0xC7   /* VCOM Control 2 register */
  69. #define LCD_NVMWR               0xD0   /* NV Memory Write */
  70. #define LCD_NVMPKEY             0xD1   /* NV Memory Protection Key */
  71. #define LCD_RDNVM               0xD2   /* NV Memory Status Read */
  72. #define LCD_READ_ID4            0xD3   /* Read ID4 */
  73. #define LCD_PGAMMA              0xE0   /* Positive Gamma Correction register */
  74. #define LCD_NGAMMA              0xE1   /* Negative Gamma Correction register */
  75. #define LCD_DGAMCTRL1           0xE2   /* Digital Gamma Control 1 */
  76. #define LCD_DGAMCTRL2           0xE3   /* Digital Gamma Control 2 */
  77. #define LCD_INTERFACE           0xF6   /* Interface control register */
  79. /* Extend register commands */
  80. #define LCD_POWERA               0xCB   /* Power control A register */
  81. #define LCD_POWERB               0xCF   /* Power control B register */
  82. #define LCD_DTCA                 0xE8   /* Driver timing control A */
  83. #define LCD_DTCB                 0xEA   /* Driver timing control B */
  84. #define LCD_POWER_SEQ            0xED   /* Power on sequence register */
  85. #define LCD_3GAMMA_EN            0xF2   /* 3 Gamma enable register */
  86. #define LCD_PRC                  0xF7   /* Pump ratio control register */

Pierwsza funkcja będzie odpowiadała za włączenie i wstępną inicjalizację całego wyświetlacza. Oprócz pinów odpowiedzialnych za transmisję między po SPI należy włączyć także pin CS, WRX oraz Reset. 

  1. void Init_GPIO_For_Display(void)
  2. {
  3.     GPIO_InitTypeDef GPIO_InitDef;
  4.     SPI_InitTypeDef SPIINITSTRUCT;
  6.     Clock_Init(); //Wlaczenie potrzebnych zegarow
  8.     //WRX
  9.     GPIO_InitDef.GPIO_Pin = WRX_Pin
  10.     GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
  11.     GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT;
  12.     GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
  13.     GPIO_InitDef.GPIO_Speed = GPIO_Speed_25MHz;
  14.     GPIO_Init(WRX_Port, &GPIO_InitDef);
  16.     //CS
  17.     GPIO_InitDef.GPIO_Pin = CS_Pin
  18.     GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
  19.     GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT;
  20.     GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
  21.     GPIO_InitDef.GPIO_Speed = GPIO_Speed_25MHz;
  22.     GPIO_Init(CS_Port, &GPIO_InitDef);
  24.     CS_SET_HIGH();
  26.     //RST
  27.     GPIO_InitDef.GPIO_Pin = RST_Pin
  28.     GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
  29.     GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT;
  30.     GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
  31.     GPIO_InitDef.GPIO_Speed = GPIO_Speed_25MHz;
  32.     GPIO_Init(RST_Port, &GPIO_InitDef);
  33.    
  34.     //Wlaczenie SPI
  35.     SPI_I2S_DeInit(LCD_SPI);
  36.      
  37.     SPIINITSTRUCT.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  38.     SPIINITSTRUCT.SPI_Mode = SPI_Mode_Master;    
  39.     SPIINITSTRUCT.SPI_DataSize = SPI_DataSize_8b;
  40.     SPIINITSTRUCT.SPI_CPOL = SPI_CPOL_Low;        
  41.     SPIINITSTRUCT.SPI_CPHA = SPI_CPHA_1Edge;      
  42.     SPIINITSTRUCT.SPI_NSS = SPI_NSS_Soft;                  
  43.     SPIINITSTRUCT.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
  44.     SPIINITSTRUCT.SPI_FirstBit = SPI_FirstBit_MSB;
  45.     SPI_Init(SPI5, &SPIINITSTRUCT);
  47.     SPI_Cmd(SPI5, ENABLE);
  48.    
  49.     //SCK MISO MOSI
  50.     GPIOINITSTRUCT.GPIO_Pin = ( LCD_SCK | LCD_MISO | LCD_MOSI );
  51.     GPIOINITSTRUCT.GPIO_Mode = GPIO_Mode_AF;
  52.     GPIOINITSTRUCT.GPIO_OType = GPIO_OType_PP;
  53.     GPIOINITSTRUCT.GPIO_Speed = GPIO_Speed_50MHz;
  54.     GPIOINITSTRUCT.GPIO_PuPd = GPIO_PuPd_UP;
  55.     GPIO_Init(SPI_LCD_PORT, &GPIOINITSTRUCT);
  56.    
  57.     //Piny SPI5 jako alternatywne
  58.     GPIO_PinAFConfig(GPIOB, LCD_SCK_PIN_SOURCE, GPIO_AF_SPI5);
  59.     GPIO_PinAFConfig(GPIOB, LCD_MISO_PIN_, GPIO_AF_SPI5);
  60.     GPIO_PinAFConfig(GPIOB, LCD_MOSI_PIN, GPIO_AF_SPI5);
  61.    
  62.     Init_LCD(); //Inicjaliza wyswietlacza prawie tak jak w cubie
  63. }

Kolejnym elementem przesłanie odpowiednich komend pod odpowiednie adresy do wyświetlacza. Ta druga została wzięta z lekką modyfikacją z przykładowego projektu dla STM32F4.

  1. void LCD_INIT_FUNCTION(void)
  2. {
  3.     CS_SET_LOW();
  5.     SEND_REGISTER_DATA(LCD_POWERB);
  6.     SEND_RAW_DATA(0x00);
  7.     SEND_RAW_DATA(0xC1);
  8.     SEND_RAW_DATA(0x30);
  10.     SEND_REGISTER_DATA(LCD_DTCA);
  11.     SEND_RAW_DATA(0x85);
  12.     SEND_RAW_DATA(0x00);
  13.     SEND_RAW_DATA(0x78);
  15.     SEND_REGISTER_DATA(LCD_DTCB);
  16.     SEND_RAW_DATA(0x00);
  17.     SEND_RAW_DATA(0x00);
  19.     SEND_REGISTER_DATA(LCD_POWER_SEQ);
  20.     SEND_RAW_DATA(0x64);
  21.     SEND_RAW_DATA(0x03);
  22.     SEND_RAW_DATA(0x12);
  23.     SEND_RAW_DATA(0x81);
  25.     SEND_REGISTER_DATA(LCD_PRC);
  26.     SEND_RAW_DATA(0x20);
  28.     SEND_REGISTER_DATA(LCD_POWER1);
  29.     SEND_RAW_DATA(0x23);
  31.     SEND_REGISTER_DATA(LCD_POWER2);
  32.     SEND_RAW_DATA(0x10);
  34.     SEND_REGISTER_DATA(LCD_VCOM1);
  35.     SEND_RAW_DATA(0x3E);
  36.     SEND_RAW_DATA(0x28);
  38.     SEND_REGISTER_DATA(LCD_VCOM2);
  39.     SEND_RAW_DATA(0x86);
  41.     SEND_REGISTER_DATA(LCD_MAC);
  42.     SEND_RAW_DATA(0x48);
  44.     SEND_REGISTER_DATA(LCD_PIXEL_FORMAT);
  45.     SEND_RAW_DATA(0x55);
  47.     SEND_REGISTER_DATA(LCD_FRC);
  48.     SEND_RAW_DATA(0x00);
  49.     SEND_RAW_DATA(0x18);
  51.     SEND_REGISTER_DATA(LCD_DFC);
  52.     SEND_RAW_DATA(0x08);
  53.     SEND_RAW_DATA(0x82);
  54.     SEND_RAW_DATA(0x27);
  56.     SEND_REGISTER_DATA(LCD_3GAMMA_EN);
  57.     SEND_RAW_DATA(0x00);
  59.     SEND_REGISTER_DATA(ILI9341_COLUMN_ADDR);
  60.     SEND_RAW_DATA(0x00);
  61.     SEND_RAW_DATA(0x00);
  62.     SEND_RAW_DATA(0x00);
  63.     SEND_RAW_DATA(0xEF);
  65.     SEND_REGISTER_DATA(ILI9341_PAGE_ADDR);
  66.     SEND_RAW_DATA(0x00);
  67.     SEND_RAW_DATA(0x00);
  68.     SEND_RAW_DATA(0x01);
  69.     SEND_RAW_DATA(0x3F);
  71.     SEND_REGISTER_DATA(ILI9341_GAMMA);
  72.     SEND_RAW_DATA(0x01);
  74.     SEND_REGISTER_DATA(ILI9341_PGAMMA);
  75.     SEND_RAW_DATA(0x0F);
  76.     SEND_RAW_DATA(0x31);
  77.     SEND_RAW_DATA(0x2B);
  78.     SEND_RAW_DATA(0x0C);
  79.     SEND_RAW_DATA(0x0E);
  80.     SEND_RAW_DATA(0x08);
  81.     SEND_RAW_DATA(0x4E);
  82.     SEND_RAW_DATA(0xF1);
  83.     SEND_RAW_DATA(0x37);
  84.     SEND_RAW_DATA(0x07);
  85.     SEND_RAW_DATA(0x10);
  86.     SEND_RAW_DATA(0x03);
  87.     SEND_RAW_DATA(0x0E);
  88.     SEND_RAW_DATA(0x09);
  89.     SEND_RAW_DATA(0x00);
  91.     SEND_REGISTER_DATA(LCD_NGAMMA);
  92.     SEND_RAW_DATA(0x00);
  93.     SEND_RAW_DATA(0x0E);
  94.     SEND_RAW_DATA(0x14);
  95.     SEND_RAW_DATA(0x03);
  96.     SEND_RAW_DATA(0x11);
  97.     SEND_RAW_DATA(0x07);
  98.     SEND_RAW_DATA(0x31);
  99.     SEND_RAW_DATA(0xC1);
  100.     SEND_RAW_DATA(0x48);
  101.     SEND_RAW_DATA(0x08);
  102.     SEND_RAW_DATA(0x0F);
  103.     SEND_RAW_DATA(0x0C);
  104.     SEND_RAW_DATA(0x31);
  105.     SEND_RAW_DATA(0x36);
  106.     SEND_RAW_DATA(0x0F);
  108.     SEND_REGISTER_DATA(LCD_SLEEP_OUT);
  109.     Delay(10000);
  111.     SEND_REGISTER_DATA(LCD_DISPLAY_ON);
  112.     SEND_REGISTER_DATA(LCD_GRAM);
  113. }

Tak więc wysłanie danych bądź rozkazów jest rozróżniane stanem na pinie WRX. Pin CS musi być w stanie niskim. Po wysłaniu przestawiany jest na wysoki.

  1. void SEND_REGISTER_DATA(uint8_t data)
  2. {
  3.     WRX_SET_LOW;
  4.     CS_SET_LOW;
  5.     SPI_SEND_DATA(LCD_SPI, data);
  6.     CS_SET_HIGH;
  7. }
  9. void SEND_RAW_DATA(uint8_t data)
  10. {
  11.     WRX_SET_HIGH;
  12.     CS_SET_LOW;
  13.     SPI_SEND_DATA(LCD_SPI, data);
  14.     CS_SET_HIGH;
  15. }

Poniżej funkcje do ustawiania potrzebnych parametrów wyświetlacza. W pierwszej kolejności orientacja. Czyli czy obraz ma być wyświetlony pionowo czy poziomo. Dodatkowo można wybrać która z dwóch warstw ma być ustawiona.

  1. void SET_ORIENTATION(uint8_t orientation)
  2. {
  3.     //orientation = 0 Pionowo1
  4.     //orientation = 1 Pionowo2
  5.     //orientation = 2 Poziomo1
  6.     //orientation = 3 Poziomo2
  8.     SEND_REGISTER_DATA(LCD_MAC);
  9.     if (0 == orientation) { SEND_RAW_DATA(0x58); }
  10.     else if (1 == orientation) { SEND_RAW_DATA(0x88); }
  11.     else if (2 == orientation) { SEND_RAW_DATA(0x28); }
  12.     else if (3 == orientation) { SEND_RAW_DATA(0xE8); }
  13. }

Jeśli chodzi o główną funckję programu to całość należy rozpocząć oczywiście od włączenia biblioteki. Kolejny krok będzie ustawienie tła wyświetlacza. Dalej można już wprowadzać znaki czy rysować po ekranie.

Włączenie bądź wyłączenie wyświetlacza można uzyskać poprzez przesłanie komendy DISPLAY_OFF czy DISPLAY_ON.

Kolejną rzeczą jest ustawienie pozycji x oraz y. Do tego należy skorzystać z następującej funkcji.

  1. void Set_Cursor(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
  2. {
  3.     SEND_REGISTER_DATA(LCD_COLUMN_ADDR);
  4.     SEND_RAW_DATA(x1 >> 8);     //Przeslanie 8 bitow z przesunieciem
  5.     SEND_RAW_DATA(x1 & 0xFF);
  6.     SEND_RAW_DATA(x2 >> 8); //Przeslanie 8 bitow
  7.     SEND_RAW_DATA(x2 & 0xFF);
  9.     SEND_REGISTER_DATA(LCD_PAGE_ADDR);
  10.     SEND_RAW_DATA(y1 >> 8);   //Przeslanie 8 bitow gornych
  11.     SEND_RAW_DATA(y1 & 0xFF);
  12.     SEND_RAW_DATA(y2 >> 8);   //Przeslanie 8 bitow
  13.     SEND_RAW_DATA(y2 & 0xFF);
  14. }

Następnie aby wyświetlić piksel na ekranie wykonuje się to poprzez:

  1. void Put_Pixel(uint16_t x, uint16_t y, uint32_t color)
  2. {
  3.     Set_Cursor(x, y, x, y);
  5.     SEND_REGISTER_DATA(LCD_GRAM);
  6.     SEND_RAW_DATA(color >> 8); // przeslanie koloru 8 bitow
  7.     SEND_RAW_DATA(color & 0xFF); //Przeslanie drugiej czesci koloru
  8. }

Teraz przykładowa funkcja zapełniająca cały ekran określonym kolorem:

  1. void Fill_Whole_LCD(uint32_t set_color)
  2. {
  3.     uint32_t n = 0;
  4.     uint32_t h_bit = 0;
  5.     uint32_t l_bit = 0;
  7.     h_bit = set_color >> 8;
  8.     l_bit = set_color & 0xFF;
  10.     Set_Cursor(0, 0, SZEROKOSC_LCD - 1, WYSOKOSC_LCD - 1);
  12.     SEND_REGISTER_DATA(LCD_GRAM);
  14.     for (n = 0; n < LCD_PIXEL; n++)
  15.     {
  16.         SEND_RAW_DATA(i);
  17.         SEND_RAW_DATA(j);
  18.     }
  19. }

Do rysowania linii wykorzystałem funkcje z biblioteki Hala z niewielką modyfikacją:

  1. #define ABS(X)  ((X) > 0 ? (X) : -(X))
  3. void LCD_DrawLine(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, uint32_t color)
  4. {
  5.   int16_t deltax = 0, deltay = 0, x = 0, y = 0, xinc1 = 0, xinc2 = 0,
  6.   yinc1 = 0, yinc2 = 0, den = 0, num = 0, numadd = 0, numpixels = 0,
  7.   curpixel = 0;
  9.   deltax = ABS(X2 - X1);        //Roznica pomiedzy X
  10.   deltay = ABS(Y2 - Y1);        //Roznice pomiedzy Y
  11.   x = X1;                       //Rozpoczecie od 1 pixela
  12.   y = Y1;                       //Rozpoczecie od 1 pixela
  14.   if (X2 >= X1)                 //X rosnie
  15.   {
  16.     xinc1 = 1;
  17.     xinc2 = 1;
  18.   }
  19.   else                          //X maleje
  20.   {
  21.     xinc1 = -1;
  22.     xinc2 = -1;
  23.   }
  25.   if (Y2 >= Y1)                 //Y rosnie
  26.   {
  27.     yinc1 = 1;
  28.     yinc2 = 1;
  29.   }
  30.   else                          //Y maleje
  31.   {
  32.     yinc1 = -1;
  33.     yinc2 = -1;
  34.   }
  36.   if (deltax >= deltay)         //Przynajmniej jedna wartosc X dla kazdego Y
  37.   {
  38.     xinc1 = 0;                  //Nie zmienia x kiedy numer jest wiekszy od wartosci zmniejszanej
  39.     yinc2 = 0;                  //Nie zmienia y dla kazdej iteracji
  40.     den = deltax;
  41.     num = deltax / 2;
  42.     numadd = deltay;
  43.     numpixels = deltax;         //Jest wiecej wartosci x niz y
  44.   }
  45.   else                          //Jest przynajmniej jeden y dla kazdego x
  46.   {
  47.     xinc2 = 0;                  //Nie zmieniaj x dla kazdej iteracji
  48.     yinc1 = 0;                  //Nie zmieniaj y gdy numer jest wiekszy od wartosci zmniejszanej
  49.     den = deltay;
  50.     num = deltay / 2;
  51.     numadd = deltax;
  52.     numpixels = deltay;         //Jest wiecej wartosci y niz x
  53.   }
  55.   for (curpixel = 0; curpixel <= numpixels; curpixel++)
  56.   {
  57.     Put_Pixel(x, y, color);                                     //Wyswietl piksel
  58.     num += numadd;                            //Zwieksz wartosc
  59.     if (num >= den)                           //Sprawdzenie czy wartosci zwiekszana jest rózwna zmniejszanej
  60.     {
  61.       num -= den;                             // Oblicz wartosc numeru
  62.       x += xinc1;                             //Zmien X
  63.       y += yinc1;                             //Zmien Y
  64.     }
  65.     x += xinc2;                               //Zmien X
  66.     y += yinc2;                               //Zmien Y
  67.   }
  68. }

 Bibliografia

[1] STM32F429
Autor: o
Etykiety: