czwartek, 16 listopada 2017

[14] STM32F4 - CubeMx - Wyświetlacz TFT 240x320 ze sterownikiem ILI9341

Ten post chciałbym poświęcić na przedstawienie obsługi działania wyświetlacza ze sterownikiem ILI9341. Cały program zostanie przygotowany za pomocą CubeMx oraz Keil uVision. W bardzo łątwy sposób można cały program przenieść do Eclipsa np. AC6.

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

CubeMx:


Tutaj do uruchomienia jest kilka elementów. Najważniejszy jest interfejs wyświetlacza FSMC (ang. Flexible Static Memory Controler).  Głównie pozwala on na obsługę pamięci Flash oraz SRAM. Natomiast dodatkowo można wybrać obsługę wyświetlacza w programie konfiguracyjnym:


Kolejnym obowiązkowym elementem jest zegar RCC:


Wraz z odpowiednią konfiguracją:


Dodatkowo można uruchomić kartę SD czy Pendriva. Pozwoli to na dostęp do czcionek oraz obrazów do wyświetlania. Na końcu można uruchomić USART1. Co pozwoli na debugowanie w czasie normalnej pracy urządzenia. Jego ustawienia mogą zostać domyślne.

Inicjalizacja:


Podczas tworzenia biblioteki opierałem się na dokumentacji od Adafruit napisanej dla tego wyświetlacza pod SPI dla Arduino.

Poniżej znajdują się funkcje uruchamiające oraz ustawiające

  1. void tftDisp9341_set(void)
  2. {
  3.     /* Reset screen */
  4.     tftDisp9341_reset();
  5.     HAL_Delay(1000);
  6.    
  7.     dtt = tftDisp9341_regi_red(0xD3);
  8.    
  9.     /* Software reset */
  10.     tftDisp9341_command(ILI_DISP_SWRES);
  11.     delayus(1);
  12.    
  13.     /* Power Control A */
  14.     tftDisp9341_command(ILI_DISP_POWCONA);
  15.     tftDisp9341_data(0x39);    
  16.     tftDisp9341_data(0x2C);    
  17.     tftDisp9341_data(0x00);        
  18.     tftDisp9341_data(0x34);    
  19.     tftDisp9341_data(0x02);    
  20.     delayus(1);
  21.    
  22.     /* Power Control B */
  23.     tftDisp9341_command(ILI_DISP_POWCONB);
  24.     tftDisp9341_data(0x00);
  25.     tftDisp9341_data(0xC1);
  26.     tftDisp9341_data(0x30);
  27.     delayus(1);
  28.    
  29.     /* Driver timing control A */
  30.     tftDisp9341_command(ILI_DISP_DTIMCOA);
  31.     tftDisp9341_data(0x85);
  32.     tftDisp9341_data(0x00);
  33.     tftDisp9341_data(0x78);
  34.     delayus(1);
  35.    
  36.     /* Driver timing control B */
  37.     tftDisp9341_command(ILI_DISP_DTIMCOB);
  38.     tftDisp9341_data(0x00);
  39.     tftDisp9341_data(0x00);
  40.     delayus(1);
  41.    
  42.     /* Power on Sequence control */
  43.     tftDisp9341_command(ILI_DISP_PSEQCON);
  44.     tftDisp9341_data(0x64);
  45.     tftDisp9341_data(0x03);
  46.     tftDisp9341_data(0x12);
  47.     tftDisp9341_data(0x81);
  48.     delayus(1);
  49.    
  50.     /* Pump ratio control */
  51.     tftDisp9341_command(ILI_DISP_PUMRAT);
  52.     tftDisp9341_data(0x20);
  53.     delayus(1);
  54.    
  55.     /* Power Control 1 */
  56.     tftDisp9341_command(ILI_DISP_PWCTR1);
  57.     tftDisp9341_data(0x10);
  58.     delayus(1);
  59.    
  60.     /* Power Control 2 */
  61.     tftDisp9341_command(ILI_DISP_PWCTR2);
  62.     tftDisp9341_data(0x10);
  63.     delayus(1);
  64.    
  65.     /* VCOM Control 1 */
  66.     tftDisp9341_command(ILI_DISP_VMCTR1);
  67.     tftDisp9341_data(0x3E);
  68.     tftDisp9341_data(0x28);
  69.     delayus(1);
  70.    
  71.     /* VCOM Control 2 */
  72.     tftDisp9341_command(ILI_DISP_VMCTR2);
  73.     tftDisp9341_data(0x86);
  74.     delayus(1);
  75.    
  76.     /* Set screen rotation */
  77.     tftDisp9341_rotation(0);
  78.     delayus(1);
  79.    
  80.     /* Pixel format set for 16 bit */
  81.     tftDisp9341_command(ILI_DISP_PIXFMT);
  82.     tftDisp9341_data(0x55);
  83.     delayus(1);
  84.    
  85.     /* Frame rate control */
  86.     tftDisp9341_command(ILI_DISP_FRMCTR1);
  87.     tftDisp9341_data(0x00);
  88.     tftDisp9341_data(0x18);
  89.     delayus(1);
  90.    
  91.     /* Display function control for 320 pages */
  92.     tftDisp9341_command(ILI_DISP_DFUNCTR);
  93.     tftDisp9341_data(0x08);
  94.     tftDisp9341_data(0x82);
  95.     tftDisp9341_data(0x27);
  96.     delayus(1);
  97.    
  98.     /* Disable 3 Gamma Function */
  99.     tftDisp9341_command(ILI_DISP_3GAMMA);
  100.     tftDisp9341_data(0x00);
  101.     delayus(1);
  102.    
  103.     /* Gamma set, gamma curve G2.2 */
  104.     tftDisp9341_command(ILI_DISP_GAMMASET);
  105.     tftDisp9341_data(0x01);
  106.     delayus(1);
  107.    
  108.     /* Positive Gamma Correction */
  109.     tftDisp9341_command(ILI_DISP_GMCTRP1);
  110.     tftDisp9341_data(0x0F);
  111.     tftDisp9341_data(0x31);
  112.     tftDisp9341_data(0x2B);
  113.     tftDisp9341_data(0x0C);
  114.     tftDisp9341_data(0x0E);
  115.     tftDisp9341_data(0x08);
  116.     tftDisp9341_data(0x4E);
  117.     tftDisp9341_data(0xF1);
  118.     tftDisp9341_data(0x37);
  119.     tftDisp9341_data(0x07);
  120.     tftDisp9341_data(0x10);
  121.     tftDisp9341_data(0x03);
  122.     tftDisp9341_data(0x0E);
  123.     tftDisp9341_data(0x09);
  124.     tftDisp9341_data(0x00);
  125.     delayus(1);
  126.    
  127.     /* Negative Gamma Correction */
  128.     tftDisp9341_command(ILI_DISP_GMCTRN1);
  129.     tftDisp9341_data(0x00);
  130.     tftDisp9341_data(0x0E);
  131.     tftDisp9341_data(0x14);
  132.     tftDisp9341_data(0x03);
  133.     tftDisp9341_data(0x11);
  134.     tftDisp9341_data(0x07);
  135.     tftDisp9341_data(0x31);
  136.     tftDisp9341_data(0xC1);
  137.     tftDisp9341_data(0x48);
  138.     tftDisp9341_data(0x08);
  139.     tftDisp9341_data(0x0F);
  140.     tftDisp9341_data(0x0C);
  141.     tftDisp9341_data(0x31);
  142.     tftDisp9341_data(0x36);
  143.     tftDisp9341_data(0x0F);
  144.     delayus(1);
  145.    
  146.     /* Exit sleep */
  147.     tftDisp9341_command(ILI_DISP_SLPOUT);
  148.     HAL_Delay(150);
  149.    
  150.     /* Enable display */
  151.     tftDisp9341_command(ILI_DISP_DISPON);
  152.     tftDisp9341_data(0x2C);
  153.     HAL_Delay(150);
  154.    
  155.     /* Set fonts */
  156.     tftDisp9341_setfonts();
  157. }

W celu wysłania komendy wywołuje się funkcje:

  1. static void tftDisp9341_command(uint8_t command)
  2. {
  3.     ADDR_CMD = command;
  4. }

Działa ona za pomocą FSMC, który opisałem podczas przygotowywania projektu w CubeMx.

Przesłanie danych wygląda następująco:

  1. static void tftDisp9341_data(uint8_t data)
  2. {
  3.         ADDR_DATA = data;
  4.         tftDisp9341_delay(1);
  5. }

Funkcja odpowiedzialna za określenie pozycji ekranu:

  1. void tftDisp9341_rotation(uint8_t rotat)
  2. {
  3.     tftDisp9341_command(0x36);
  4.    
  5.     if(rotat == 0)
  6.     {
  7.         tftDisp9341_data(0x48);
  8.         X_SIZE = ILI9341_TFT_WIDTH;
  9.         Y_SIZE = ILI9341_TFT_HEIGHT;
  10.     }
  11.     else if(rotat == 1)
  12.     {
  13.         tftDisp9341_data(0x28);
  14.         X_SIZE = ILI9341_TFT_HEIGHT;
  15.         Y_SIZE = ILI9341_TFT_WIDTH;
  16.     }
  17.     else if(rotat == 2)
  18.     {
  19.         tftDisp9341_data(0x88);
  20.         X_SIZE = ILI9341_TFT_WIDTH;
  21.         Y_SIZE = ILI9341_TFT_HEIGHT;
  22.     }
  23.     else if(rotat == 3)
  24.     {
  25.         tftDisp9341_data(0xE8);
  26.         X_SIZE = ILI9341_TFT_HEIGHT;
  27.         Y_SIZE = ILI9341_TFT_WIDTH;
  28.     }
  29. }

Funkcje obsługujące:


W tej części znajdują się funkcje odpowiedzialne za wykonywanie operacji na wyświetlaczu, czyli rysowanie kwadratów, trójkątów, kół czy linii oraz pozostałe operacje.

Uzupełnienie ekranu podanym kolorem:

  1. void tftDisp9341_fillScr(uint16_t color)
  2. {
  3.     tftDisp9341_addrWindow(0,0,X_SIZE-1,Y_SIZE-1);
  4.     tftDisp9341_fill(color,(long)X_SIZE*(long)Y_SIZE);
  5. }


Wyrysowanie prostokąta o podanym kolorze:

  1. void tftDisp9341_fillRectangle(uint16_t color, uint16_t startX, uint16_t startY,
  2.                                                 uint16_t endX,  uint16_t endY)
  3. {
  4.     tftDisp9341_addrWindow(startX,startY,endX,endY);
  5.     tftDisp9341_fill(color,(uint16_t)(endX-startX+1)*(uint16_t)(endY-startY+1));
  6. }

Rysowanie pojedynczego piksela na ekranie:

  1. void tftDisp9341_pixel(uint16_t axisX, uint16_t axisY, uint16_t color)
  2. {
  3.     /* Check passed data */
  4.     if(axisX>=X_SIZE) || (axisY>=Y_SIZE))
  5.     {
  6.         return;
  7.     }
  8.    
  9.     tftDisp9341_addrWindow(axisX,axisY,axisX,axisY);
  10.     tftDisp9341_command(ILI_DISP_RAMWR);
  11.     tftDisp9341_data(color >> 8);
  12.     tftDisp9341_data(color & 0xFF);
  13. }

Najpierw sprawdzane są podawane parametry do funkcji. Potem ustawiany jest adres. na wybrany piksel. Kolejnym elementem jest wysłanie komendy zapisu danych po czym przesyłany jest wyświetlany kolor po 1 bajcie.

Teraz funkcja odpowiedzialna za rysowanie prostej linii na ekranie:

  1. void tftDisp9341_drawLine(uint16_t startX, uint16_t startY,
  2.                           uint16_t endX, uint16_t endY, uint16_t color)
  3. {
  4.     int16_t steep = abs(endY-startY)>abs(endX-startX);
  5.     int16_t deltaX = 0;
  6.     int16_t deltaY = 0;
  7.     int16_t errCalculate = 0;
  8.     int16_t stepY = 0;
  9.    
  10.     if(steep != 0)
  11.     {
  12.         SWAP_VALUES(startX,startY);
  13.         SWAP_VALUES(endX,endY);
  14.     }
  15.    
  16.     if(x1>x2)
  17.     {
  18.         SWAP_VALUES(startX,endX);
  19.         SWAP_VALUES(startY,endY);
  20.     }
  21.    
  22.     deltaX=endX-startX;
  23.     deltaY=abs(endY-startY);
  24.    
  25.     errCalculate=deltaX/2;
  26.    
  27.     if(startY<endY)
  28.     {
  29.         stepY=1;
  30.     }
  31.     else
  32.     {
  33.         stepY=-1;
  34.     }
  35.    
  36.     while(startX<=endX)
  37.     {
  38.         if(steep)
  39.         {
  40.             tftDisp9341_pixel(startY,startX,color);
  41.         }
  42.         else
  43.         {
  44.             tftDisp9341_pixel(startX,startY,color);
  45.         }
  46.        
  47.         errCalculate-=deltaY;
  48.        
  49.         if(errCalculate<0)
  50.         {
  51.             startY += stepY;
  52.             errCalculate=deltaX;
  53.         }
  54.         startX++;
  55.     }
  56. }

Do tej funkcji podaje się punkty startowe oraz końcowe linii. Ostatnim parametrem jest kolor linii.

Rysowanie pustego prostokąta na ekranie:

  1. void tftDisp9341_drawRectangle(uint16_t startX, uint16_t startY,
  2.                                uint16_t endX, uint16_t endY, uint16_t color)
  3. {
  4.     tftDisp9341_drawLine(startX, startY, endX, startY, color);
  5.     tftDisp9341_drawLine(endX, startY, endX, endY, color);
  6.     tftDisp9341_drawLine(startX, startY, startX, endY, color);
  7.     tftDisp9341_drawLine(startX, endY, endX, endY, color);
  8. }

Tutaj podobnie jak poprzednio podawane są parametry początkowe oraz końcowe, czyli kąta przeciwległego. Ostatnim elementem jest kolor linii. Funkcja odwołuje się do wcześniej przedstawionej funkcji rysującej linie na wyświetlaczu.

Teraz funkcja odpowiedzialna za rysowanie okręgu na ekranie:

  1. void tftDisp9341_drawCircle(uint16_t startX, uint16_t endY, uint16_t radius, uint16_t color)
  2. {
  3.     int f = 1-radius;
  4.     int ddF_x = 1;
  5.     int ddF_y = -2*radius;
  6.     int x = 0;
  7.     int y = radius;
  8.    
  9.     tftDisp9341_pixel(startX,endY+radius,color);
  10.     tftDisp9341_pixel(startX,endY-radius,color);
  11.     tftDisp9341_pixel(startX+radius,endY,color);
  12.     tftDisp9341_pixel(startX-radius,endY,color);
  13.    
  14.     while(x<y)
  15.     {
  16.         if(f>=0)
  17.         {
  18.             y--;
  19.             ddF_y+=2;
  20.             f+=ddF_y;
  21.         }
  22.        
  23.         x++;
  24.         ddF_x+=2;
  25.         f+=ddF_x;
  26.        
  27.         tftDisp9341_pixel(startX+x, endY+y, color);
  28.         tftDisp9341_pixel(startX-x, endY+y, color);
  29.         tftDisp9341_pixel(startX+x, endY-y, color);
  30.         tftDisp9341_pixel(startX-x, endY-y, color);
  31.         tftDisp9341_pixel(startX+y, endY+x, color);
  32.         tftDisp9341_pixel(startX-y, endY+x, color);
  33.         tftDisp9341_pixel(startX+y, endY-x, color);
  34.         tftDisp9341_pixel(startX-y, endY-x, color);
  35.     }
  36. }

Czcionka:


Ta część zawiera funkcje potrzebne do wyświetlenia tekstu na ekranie.

Biblioteki z czcionkami wybierzemy z plików jakie zostały udostępnione przez firmę ST. Dla przykładów dla mikrokontrolera F4 (STM32Cube_FW_F4_V1.16.0).

Czcionki można albo czytać z karty SD czy Pendriva którego podłączymy pod płytkę ST bądź przez dołączenie plików do projektu. Pliki z końcówką *.c należy dołączyć do projektu jak się będzie z nich korzystać. W przypadku pamięci zewnętrznej wgrywa się pliki z końcówką *.bin.

W tym przypadku czcionki będą zapisane na karcie SD:

  1. void tftDisp9341_setFont(selectFont_en fontSel)
  2. {
  3.     f_close(&MyFile);
  4.    
  5.     if(fontSel == se_Font8)
  6.     {
  7.         if(f_open(&MyFile,"font8.bin",FA_READ)!=FR_OK)
  8.         {
  9.             Error_Handler();
  10.         }
  11.         else
  12.         {
  13.             tftStruct.pFont=&Font8;
  14.         }
  15.     }
  16.     else if(fontSel == se_Font12)
  17.     {
  18.         if(f_open(&MyFile,"font12.bin",FA_READ)!=FR_OK)
  19.         {
  20.             Error_Handler();
  21.         }
  22.         else
  23.         {
  24.             tftStruct.pFont=&Font12;
  25.         }  
  26.     }
  27.     else if(fontSel == se_Font16)
  28.     {
  29.         if(f_open(&MyFile,"font16.bin",FA_READ)!=FR_OK)
  30.         {
  31.             Error_Handler();
  32.         }
  33.         else
  34.         {
  35.             tftStruct.pFont=&Font16;
  36.         }
  37.     }
  38.     else if(fontSel == se_Font20)
  39.     {
  40.         if(f_open(&MyFile,"font20.bin",FA_READ)!=FR_OK)
  41.         {
  42.             Error_Handler();
  43.         }
  44.         else
  45.         {
  46.             tftStruct.pFont=&Font20;
  47.         }
  48.     }
  49.     else if(fontSel == se_Font24)
  50.     {
  51.         if(f_open(&MyFile,"font24.bin",FA_READ)!=FR_OK)
  52.         {
  53.             Error_Handler();
  54.         }
  55.         else
  56.         {
  57.             tftStruct.pFont=&Font24;
  58.         }
  59.     }
  60. }

Ładowanie czcionek jest dosyć proste. Otwiera się plik. Po czym przypisuje się odpowiedni składnik do struktury.

Wypisywanie pojedynczego znaku na ekranie wygląda następująco:

  1. void tftDisp9341_drawChar(uint16_t posX, uint16_t posY, uint8_t charac)
  2. {
  3.     FRESULT res;
  4.     uint32_t readBytes = 0;
  5.     uint8_t charbuf[100] = {0};
  6.     uint32_t i = 0;
  7.     uint32_t j = 0;
  8.     uint32_t height = 0;
  9.     uint32_t width = 0;
  10.     uint16_t fontsize = 0;      /* Number of bytes for selected char */
  11.     uint32_t line = 0;
  12.     uint8_t offset = 0;
  13.     uint16_t offsetfile = 0;    /* Place in file where character definition starts */
  14.    
  15.     width = tftStruct.pFont->Width;
  16.     height = tftStruct.pFont->Height;
  17.    
  18.     if((posX+width)>=X_SIZE)
  19.     {
  20.         return;
  21.     }
  22.    
  23.     if((posY+height)>=Y_SIZE)
  24.     {
  25.         return;
  26.     }
  27.    
  28.     if(height == 8)
  29.     {
  30.         offset = 3;
  31.         fontsize = 8;
  32.         offsetfile = (charac - ' ') * fontsize;
  33.         f_lseek(&MyFile, offsetfile);
  34.         res = f_read(&MyFile,   charbuf, 8,(void*)&readBytes);
  35.        
  36.         if((readBytes==0)||(res!=FR_OK))
  37.         {
  38.             Error_Handler();
  39.         }
  40.     }
  41.     else if(height == 12)
  42.     {
  43.         offset = 1;
  44.         fontsize = 12;
  45.         offsetfile = (charac - ' ') * fontsize;
  46.         f_lseek(&MyFile,offsetfile);
  47.         res = f_read(&MyFile,   charbuf, 12,(void*)&readBytes);
  48.        
  49.         if((readBytes==0)||(res!=FR_OK))
  50.         {
  51.             Error_Handler();
  52.         }
  53.     }
  54.     else if(height == 16)
  55.     {
  56.         offset = 5;
  57.         fontsize = 32;
  58.         offsetfile = (charac - ' ') * fontsize;
  59.         f_lseek(&MyFile, offsetfile);
  60.         res = f_read(&MyFile,   charbuf, 32,(void*)&readBytes);
  61.        
  62.         if((readBytes==0)||(res!=FR_OK))
  63.         {
  64.             Error_Handler();
  65.         }
  66.     }
  67.     else if(height == 20)
  68.     {
  69.         offset = 2;
  70.         fontsize = 40;
  71.         offsetfile = (charac - ' ') * fontsize;
  72.         f_lseek(&MyFile,offsetfile);
  73.         res = f_read(&MyFile,   charbuf, 40,(void*)&readBytes);
  74.        
  75.         if((readBytes==0)||(res!=FR_OK))
  76.         {
  77.             Error_Handler();
  78.         }  
  79.     }
  80.     else if(height == 24)
  81.     {
  82.         offset = 7;
  83.         fontsize = 72;
  84.         offsetfile = (charac - ' ') * fontsize;
  85.         f_lseek(&MyFile,offsetfile);
  86.         res = f_read(&MyFile,   charbuf, 72,(void*)&readBytes);
  87.         if((readBytes==0)||(res!=FR_OK))
  88.         {
  89.             Error_Handler();
  90.         }
  91.     }
  92.    
  93.     for(i = 0; i < height; i++)
  94.     {
  95.         if((height == 8)||(height == 12))
  96.         {
  97.             line=charbuf[i];
  98.         }
  99.         else if((height == 16)||(height == 20))
  100.         {
  101.             line=(charbuf[i*2]<<8)|(charbuf[i*2+1]);
  102.         }
  103.         else
  104.         {
  105.             line=(charbuf[i*3]<<16)|(charbuf[i*3+1]<<8)|(charbuf[i*3+2]);
  106.         }
  107.        
  108.         for(j=0; j<width; j++)
  109.         {
  110.             if(line & (1<<(width-j + offset - 1)))
  111.             {
  112.                 tftDisp9341_pixel(posX + j, posY, tftStruct.TextColor);
  113.             }
  114.             else
  115.             {
  116.                 tftDisp9341_pixel(posX + j, posY, tftStruct.BackColor);
  117.             }
  118.         }
  119.         y++;
  120.     }
  121. }

Na samym początku ustalane są parametry czcionki. Na końcu w pętli for następuje wyrysowanie znaku wykorzystując komendę odpowiedzialną za wypisanie pojedynczego piksela na ekranie.

Wypisanie ciągu znaków wykonuje następująca komenda:

  1. void tftDisp9341_string(uint16_t startX, uint16_t startY, char *str)
  2. {
  3.     while(*str)
  4.     {
  5.         tftDisp9341_drawChar(startX,startY,str[0]);
  6.         startX += tftStruct.pFont->Width;
  7.         (void)*str++;
  8.     }
  9. }

Bibliotekę do wyświetlacza można pobrać z dysku Google pod tym linkiem. W folderze STM32 a następnie STM32F4_Discovery.
Autor: o
Etykiety: , ,