[3] STM32F429I - Discovery - LCD TFT oraz panel dotykowy, biblioteki STD

Ten post chciałbym poświęcić na opisanie obsługi wyświetlacza za pomocą interfejsu SPI, oraz programowanie panelu dotykowego za pomocą interfejsu I2C.

Wszystkie funkcje nie opisane w tym poście są wyjaśnione i można je pobrać na samym dole tego postu.

[http://www.st.com/en/evaluation-tools/32f429idiscovery.html]

Wyświetlacz:

W tym przypadku zamiast LTDC wykorzystałem SPI. Głównym powodem jest ograniczenie ilości linii transmisyjnych oraz tym, że występuje całkiem spora grupa wyświetlaczy TFT wykorzystujących komunikację po tym interfejsie. Dodatkowym atutem przy tym jest ich dosyć przyzwoita cena.

Inicjalizacja wyświetlacza odbywa się przez następującą funkcje:

1. static void ili9341_InitDisplay(void)
2. {
3.   /* Configurate LCD */
4.   ili9341_WriteCmdData(0xCA);
5.   ili9341_WriteData(0xC3);
6.   ili9341_WriteData(0x08);
7.   ili9341_WriteData(0x50);
8.   ili9341_WriteCmdData(LCD_POWERB);
9.   ili9341_WriteData(0x00);
10.   ili9341_WriteData(0xC1);
11.   ili9341_WriteData(0x30);
12.   ili9341_WriteCmdData(LCD_POWER_SEQ);
13.   ili9341_WriteData(0x64);
14.   ili9341_WriteData(0x03);
15.   ili9341_WriteData(0x12);
16.   ili9341_WriteData(0x81);
17.   ili9341_WriteCmdData(LCD_DTCA);
18.   ili9341_WriteData(0x85);
19.   ili9341_WriteData(0x00);
20.   ili9341_WriteData(0x78);
21.   ili9341_WriteCmdData(LCD_POWERA);
22.   ili9341_WriteData(0x39);
23.   ili9341_WriteData(0x2C);
24.   ili9341_WriteData(0x00);
25.   ili9341_WriteData(0x34);
26.   ili9341_WriteData(0x02);
27.   ili9341_WriteCmdData(LCD_PRC);
28.   ili9341_WriteData(0x20);
29.   ili9341_WriteCmdData(LCD_DTCB);
30.   ili9341_WriteData(0x00);
31.   ili9341_WriteData(0x00);
32.   ili9341_WriteCmdData(LCD_FRC);
33.   ili9341_WriteData(0x00);
34.   ili9341_WriteData(0x1B);
35.   ili9341_WriteCmdData(LCD_DFC);
36.   ili9341_WriteData(0x0A);
37.   ili9341_WriteData(0xA2);
38.   ili9341_WriteCmdData(LCD_POWER1);
39.   ili9341_WriteData(0x10);
40.   ili9341_WriteCmdData(LCD_POWER2);
41.   ili9341_WriteData(0x10);
42.   ili9341_WriteCmdData(LCD_VCOM1);
43.   ili9341_WriteData(0x45);
44.   ili9341_WriteData(0x15);
45.   ili9341_WriteCmdData(LCD_VCOM2);
46.   ili9341_WriteData(0x90);
47.   ili9341_WriteCmdData(LCD_MAC);
48.   ili9341_WriteData(0xC8);
49.   ili9341_WriteCmdData(LCD_3GAMMA_EN);
50.   ili9341_WriteData(0x00);
51.   ili9341_WriteCmdData(LCD_RGB_INTERFACE);
52.   ili9341_WriteData(0xC2);
53.   ili9341_WriteCmdData(LCD_DFC);
54.   ili9341_WriteData(0x0A);
55.   ili9341_WriteData(0xA7);
56.   ili9341_WriteData(0x27);
57.   ili9341_WriteData(0x04);
59.     /* Colomn address set */
60.   ili9341_WriteCmdData(LCD_COLUMN_ADDR);
61.   ili9341_WriteData(0x00);
62.   ili9341_WriteData(0x00);
63.   ili9341_WriteData(0x00);
64.   ili9341_WriteData(0xEF);
66.     /* Page adress set */
67.   ili9341_WriteCmdData(LCD_PAGE_ADDR);
68.   ili9341_WriteData(0x00);
69.   ili9341_WriteData(0x00);
70.   ili9341_WriteData(0x01);
71.   ili9341_WriteData(0x3F);
72.   ili9341_WriteCmdData(LCD_INTERFACE);
73.   ili9341_WriteData(0x01);
74.   ili9341_WriteData(0x00);
75.   ili9341_WriteData(0x06);
77.   ili9341_WriteCmdData(LCD_GRAM);
78.   ili9341_Delay(LCD_INIT_PAUSE);
80.   ili9341_WriteCmdData(LCD_GAMMA);
81.   ili9341_WriteData(0x01);
83.   ili9341_WriteCmdData(LCD_PGAMMA);
84.   ili9341_WriteData(0x0F);
85.   ili9341_WriteData(0x29);
86.   ili9341_WriteData(0x24);
87.   ili9341_WriteData(0x0C);
88.   ili9341_WriteData(0x0E);
89.   ili9341_WriteData(0x09);
90.   ili9341_WriteData(0x4E);
91.   ili9341_WriteData(0x78);
92.   ili9341_WriteData(0x3C);
93.   ili9341_WriteData(0x09);
94.   ili9341_WriteData(0x13);
95.   ili9341_WriteData(0x05);
96.   ili9341_WriteData(0x17);
97.   ili9341_WriteData(0x11);
98.   ili9341_WriteData(0x00);
99.   ili9341_WriteCmdData(LCD_NGAMMA);
100.   ili9341_WriteData(0x00);
101.   ili9341_WriteData(0x16);
102.   ili9341_WriteData(0x1B);
103.   ili9341_WriteData(0x04);
104.   ili9341_WriteData(0x11);
105.   ili9341_WriteData(0x07);
106.   ili9341_WriteData(0x31);
107.   ili9341_WriteData(0x33);
108.   ili9341_WriteData(0x42);
109.   ili9341_WriteData(0x05);
110.   ili9341_WriteData(0x0C);
111.   ili9341_WriteData(0x0A);
112.   ili9341_WriteData(0x28);
113.   ili9341_WriteData(0x2F);
114.   ili9341_WriteData(0x0F);
116.   ili9341_WriteCmdData(LCD_SLEEP_OUT);
117.   ili9341_Delay(LCD_INIT_PAUSE);
118.   ili9341_WriteCmdData(LCD_DISPLAY_ON);
120.   /* Gram Start writing */
121.   ili9341_WriteCmdData(LCD_GRAM);
122. }

Uruchomienie interfejsu SPI:

1. void SPI5_Initialization(void)
2. {
3.   GPIO_InitTypeDef  GPIO_InitStructure;
4.   SPI_InitTypeDef  SPI_InitStructure;
6.   /* Enable clock for SPI5 */
7.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI5, ENABLE);
9.   /* Enables clocks */
10.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
11.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
14.   /* Set pin as alternative */
15.   GPIO_PinAFConfig(GPIOF, GPIO_PinSource7, GPIO_AF_SPI5);
16.   GPIO_PinAFConfig(GPIOF, GPIO_PinSource9, GPIO_AF_SPI5);
17.   GPIO_PinAFConfig(GPIOF, GPIO_PinSource8, GPIO_AF_SPI5);
19.     /* Set GPIO as alternative for SPI5 with pulldown */
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
21.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
22.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
23.   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
25.   /* SCK pin */
26.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
27.   GPIO_Init(GPIOF, &GPIO_InitStructure);
28.    
29.   /* MOSI pin */
30.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
31.   GPIO_Init(GPIOF, &GPIO_InitStructure);
32.    
33.   /* MISO pin */
34.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
35.   GPIO_Init(GPIOF, &GPIO_InitStructure);
37.   SPI_I2S_DeInit(SPI5);
39.     /* Configurate SPI */
40.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
41.   SPI_InitStructure.SPI_Mode            = SPI_Mode_Master;
42.   SPI_InitStructure.SPI_DataSize    = SPI_DataSize_8b;
43.    
44.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
45.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
46.    
47.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
48.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
50.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
52.   SPI_InitStructure.SPI_CRCPolynomial = 7;
53.   SPI_Init(SPI5, &SPI_InitStructure);
55.   /* Enable SPI5 */
56.   SPI_Cmd(SPI5, ENABLE);
57. }

Uruchomienie pamięci SDRAM

1. uint8_t SDRAM_Initialization(void)
2. {
3.     uint16_t read_value = 0;
4.   uint16_t write_value = 0;
5.   uint8_t operation_status = 0;
7.   /* Init GPIO for SDRAM */
8.   SDRAM_InitGpio();
9.    
10.   /* Init FMC */
11.   SDRAM_InitFMC();
13.     /* Initialization sequence */
14.     SDRAM_Initialization_Sequence();
15.    
16.     /* Check if initialization went ok */
17.   read_value=SDRAM_ReadData16b(0x00);
18.   SDRAM_WriteData16b(0x00, 0xA5B6);
19.   write_value=SDRAM_ReadData16b(0x00);
20.   SDRAM_WriteData16b(0x00, read_value);
21.    
22.   if(write_value==0xA5B6){
23.         operation_status=1; // RAM vorhanden
24.     }
25.     else{
26.         operation_status = 0;
27.     }
29.   return operation_status;
30. }

Init LTDC:

1. static void ili9341_InitLTDC(void)
2. {
3.   LTDC_InitTypeDef       LTDC_InitStruct;
5.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_LTDC, ENABLE);
6.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2D, ENABLE);
7.      
8.   ili9341_AFConfigPins();    
10.   LTDC_InitStruct.LTDC_HSPolarity = LTDC_HSPolarity_AL;
11.   LTDC_InitStruct.LTDC_VSPolarity = LTDC_VSPolarity_AL;
12.   LTDC_InitStruct.LTDC_DEPolarity = LTDC_DEPolarity_AL;
13.   LTDC_InitStruct.LTDC_PCPolarity = LTDC_PCPolarity_IPC;
15.   LTDC_InitStruct.LTDC_BackgroundRedValue = 0;
16.   LTDC_InitStruct.LTDC_BackgroundGreenValue = 0;
17.   LTDC_InitStruct.LTDC_BackgroundBlueValue = 0;
19.   RCC_PLLSAIConfig(192, 7, 4);
20.   RCC_LTDCCLKDivConfig(RCC_PLLSAIDivR_Div8);
22.   RCC_PLLSAICmd(ENABLE);
23.   while(RCC_GetFlagStatus(RCC_FLAG_PLLSAIRDY) == RESET);
25.   LTDC_InitStruct.LTDC_HorizontalSync = 9;       // HSync-1
26.   LTDC_InitStruct.LTDC_VerticalSync = 1;         // VSync-1
27.   LTDC_InitStruct.LTDC_AccumulatedHBP = 29;      // HSync+HBP-1
28.   LTDC_InitStruct.LTDC_AccumulatedVBP = 3;       // VSync+VBP-1
29.   LTDC_InitStruct.LTDC_AccumulatedActiveW = 269; // HSync+HBP+W-1
30.   LTDC_InitStruct.LTDC_AccumulatedActiveH = 323; // VSync+VBP+H-1
31.   LTDC_InitStruct.LTDC_TotalWidth = 279;         // HSync+HBP+W+HFP-1
32.   LTDC_InitStruct.LTDC_TotalHeigh = 327;         // VSync+VBP+H+VFP-1
34.   LTDC_Init(&LTDC_InitStruct);
35. }

Wypełnienie danej warstwy wybranym kolorem:

1. void Tft_FillLayer(uint16_t color)
2. {
3.   uint32_t index = 0;
5.   for (index = 0x00; index < ILI9341_FRAME_OFFSET; index+=2) {
6.     *(__IO uint16_t*)(ILI9341_CurrentFrameBuffer + index) = color;
7.   }
8. }

Rysuj pojedynczy piksel na ekranie na podstawie globalnych ustawień kursora:

1. void Tft_DrawPixel(uint16_t color)
2. {
3.   *(volatile uint16_t*)SetGlobalCursor=color;
4.    
5.   if(Tft_Display_Mode==Orientation_Portrait)
6.     {
7.     SetGlobalXCursor++;
8.     if(SetGlobalXCursor>=ILI9341_X) {
9.       SetGlobalXCursor=0;
10.       SetGlobalXCursor++;
11.       if(SetGlobalXCursor>=ILI9341_Y) SetGlobalXCursor=0;
12.     }
13.   }
14.   else if(Tft_Display_Mode==Orientation_Landscape)
15.     {
16.     SetGlobalXCursor++;
17.     if(SetGlobalXCursor>=ILI9341_Y) {
18.       SetGlobalXCursor=0;
19.       SetGlobalXCursor++;
20.       if(SetGlobalXCursor>=ILI9341_X) SetGlobalXCursor=0;
21.     }
22.   }
23.   SetGlobalCursor=ILI9341_CurrentFrameBuffer+(2*((SetGlobalXCursor*ILI9341_X)+SetGlobalXCursor));
24. }

Funkcja rysująca piksel na ekranie w podanej lokalizacji:

1. void TFT_DrawPixel_WithCords(uint16_t Xpos, uint16_t Ypos, uint32_t color)
2. {
3.     *(__IO uint16_t*)(SetGlobalCursor)=color;
4.     SetGlobalCursor=ILI9341_CurrentFrameBuffer+(2*((Ypos*ILI9341_X)+Xpos));
5. }

Rysowanie linii:

1. void Tft_DrawLine(uint16_t x_start, uint16_t y_start, uint16_t x_end, uint16_t y_end, uint16_t color)
2. {
3.      int steep = abs(y_end-y_start)>abs(x_end-x_start);
4.      int dx=0;
5.      int dy=0;
6.      int err=0;
7.      int ystep=0;
8.        
9.      if (steep){
10.         kSwapVariable(x_start,y_start);
11.         kSwapVariable(x_end,y_end);
12.      }
13.      if(x_start>x_end){
14.         kSwapVariable(x_start,x_end);
15.         kSwapVariable(y_start,y_end);
16.      }
17.      dx=x_end-x_start;
18.      dy=abs(y_end-y_start);
19.      err=dx/2;
21.      if(y_start<y_end){
22.          ystep = 1;
23.      }
24.      else{
25.          ystep = -1;
26.      }
27.      for (;x_start<=x_end;x_start++)
28.      {
29.         if (steep){
30.             TFT_DrawPixel_WithCords(y_start,x_start,color);
31.         }
32.         else{
33.             TFT_DrawPixel_WithCords(x_start,y_start,color);
34.         }
35.         err-=dy;
36.         if (err<0){
37.          y_start += ystep;
38.          err+=dx;
39.         }
40.      }
41. }

Rysowanie czystego prostokąta:

1. void Tft_DrawClearRectangle(uint16_t start_x, uint16_t start_y,
2.                             uint16_t end_x, uint16_t end_y, uint16_t color)
3. {
4.     Tft_DrawLine(start_x,start_y,end_x,start_y,color);
5.     Tft_DrawLine(end_x, start_y, end_x, end_y, color);
6.     Tft_DrawLine(start_x, start_y, start_x, end_y, color);
7.     Tft_DrawLine(start_x, end_y, end_x, end_y, color);
8. }

Rysowanie prostokąta z wypełnieniem:

1. void Tft_FillRectangle(uint16_t start_x, uint16_t start_y,
2.                        uint16_t end_x, uint16_t end_y, uint16_t color)
3. {
4.     uint32_t xposition;
5.     uint32_t yposition;
6.    
7.     if(start_x>end_x){
8.         kSwapVariable(start_x,end_x);
9.     }
10.     if(start_y>end_y){
11.         kSwapVariable(start_y,end_y);
12.     }
13.    
14.     for(yposition=start_y;yposition<=end_y;yposition++){
15.         for(xposition=start_x;xposition<=end_x;xposition++){
16.                 *(__IO uint32_t*) (ILI9341_CurrentFrameBuffer + (2*(yposition*ILI9341_X + xposition)))
17.             = color;
18.         }
19.   }
20. }

Rysowanie czystego prostokąta:

1. void Tft_DrawCircle(uint16_t x_Position, uint16_t y_Position, int 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.     TFT_DrawPixel_WithCords(x_Position,y_Position+radius,color);
10.     TFT_DrawPixel_WithCords(x_Position,y_Position-radius,color);
11.     TFT_DrawPixel_WithCords(x_Position+radius,y_Position,color);
12.     TFT_DrawPixel_WithCords(x_Position-radius,y_Position,color);
13.     while (x<y){
14.         if (f>=0){
15.             y--;
16.       ddF_y+=2;
17.       f+=ddF_y;
18.         }
19.     x++;
20.     ddF_x+=2;
21.     f+=ddF_x;
22.     TFT_DrawPixel_WithCords(x_Position+x,y_Position+y,color);
23.     TFT_DrawPixel_WithCords(x_Position-x,y_Position+y,color);
24.     TFT_DrawPixel_WithCords(x_Position+x,y_Position-y,color);
25.     TFT_DrawPixel_WithCords(x_Position-x,y_Position-y,color);
26.     TFT_DrawPixel_WithCords(x_Position+y,y_Position+x,color);
27.     TFT_DrawPixel_WithCords(x_Position-y,y_Position+x,color);
28.     TFT_DrawPixel_WithCords(x_Position+y,y_Position-x,color);
29.     TFT_DrawPixel_WithCords(x_Position-y,y_Position-x,color);
30.   }
31. }

Rysowanie znaków na ekranie, czcionka musi posiadać stałą szerokość oraz wysokość. Poniżej funkcja wypisująca znak na ekranie:

1. void Prep_Font_DrawChar(uint16_t x_position, uint16_t y_position, uint8_t sign, Prep_Font *font,
2.                                                 uint16_t fontColor, uint16_t backColor)
3. {
4.   uint16_t loop_x = 0;
5.   uint16_t loop_y = 0;
6.   uint16_t begin_mask= 0;
7.   uint16_t change_mask = 0;
8.   const uint16_t *char_size;
10.   sign -= ' ';
11.   char_size=&font->table[sign * font->height];
13.   if(Tft_Display_Mode==Orientation_Portrait)
14.     {
15.     if(font->width>8) { begin_mask=0x8000;  }
16.         else                            {   begin_mask=0x80;        }
17.    
18.     for(loop_y = 0; loop_y < font->height; loop_y++)
19.         {
20.       change_mask=begin_mask;
21.       Tft_SetCursor2Draw(x_position,loop_y+y_position);
22.       for(loop_x = 0; loop_x < font->width; loop_x++)
23.             {
24.         if((char_size[loop_y] & change_mask) == 0x00) {
25.           Tft_DrawPixel(backColor);
26.         }
27.         else {
28.           Tft_DrawPixel(fontColor);
29.         }
30.         change_mask=(change_mask>>1);
31.       }
32.     }
33.   }
34.   else
35.     {
36.     if(font->width>8)   { begin_mask=0x8000; }
37.         else                            { begin_mask=0x80;   }
38.     for(loop_y = 0; loop_y < font->height; loop_y++)
39.         {
40.       change_mask=begin_mask;
41.       Tft_SetCursor2Draw(x_position+font->height-loop_y,y_position);
42.       for(loop_x = 0; loop_x < font->width; loop_x++)
43.             {
44.         if((char_size[loop_y] & change_mask) == 0x00) {
45.           Tft_DrawPixel(backColor);
46.         }
47.         else {
48.           Tft_DrawPixel(fontColor);
49.         }
50.         change_mask=(change_mask>>1);
51.       }
52.     }
53.   }
54. }

Rysowanie ciągu znaków na ekranie:

1. void Prep_Font_DrawString(uint16_t x_position, uint16_t y_position,
2.                                                     uint8_t *buffer, Prep_Font *font, uint16_t fontColor, uint16_t backColor)
3. {
4.   uint16_t writePosition;
6.   if(Tft_Display_Mode==Orientation_Portrait)
7.     {
8.     writePosition=x_position;
9.     while (*buffer != 0) {
10.       Prep_Font_DrawChar(writePosition,y_position,*buffer,font,fontColor,backColor);
11.       writePosition+=font->width;
12.       buffer++;
13.     }
14.   }
15.   else if(Tft_Display_Mode==Orientation_Landscape)
16.     {
17.     writePosition=y_position;
18.     while (*buffer != 0) {
19.       Prep_Font_DrawChar(x_position,writePosition,*buffer,font,fontColor,backColor);
20.       writePosition+=font->width;
21.       buffer++;
22.     }
23.   }
24. }

Panel dotykowy:

W tym przypadku komunikacja odbywa się po interfejsie I2C (I2C3), jak właściwie dla wszystkich paneli dotykowych.

Jego podłączenie jest następujące:

• SCL - PA8;
• SDA - PC9;

Procedura inicjalizacyjna wygląda następująco:

1. uint8_t TouchPad_Initialization(void)
2. {
3.   uint16_t touch_pad_id=0;
5.     /* I2C3 initialization */
6.   I2C3_Initialization();
8.   /* Read Id */
9.   touch_pad_id=P_Touch_ReadID();
10.    
11.   if(touch_pad_id!=STMPE811_ID) {
12.         return 0;   /* Error */
13.     }
15.   /* Reset touch pad */
16.   TouchPad_Reset();
18.   /* Initialize touchpad */
19.   TouchPad_Function_Command(IOE_ADC_FCT, ENABLE);
20.   TouchPad_Configuration();
22.   return 1; /* OK */
23. }

Komunikacja poprzez interfejs I2C rozpoczyna się od wystawienia sygnału start. Jest to odpowiednia kombinacja przebiegów na linii SDA oraz SCL (do tego celu wykorzustuje się funkcje biblioteki STD). Dzięki temu informuje się układ podrzędny, że rozpocznie się transmisja danych. Kolejny etap to wysłanie adresu układu podrzędnego, z którym nastąpi komunikacja odczytu lub zapisu danych. Kierunek transmisji określa następny bit, po którym układ odpowiada bitem potwierdzenia ACK. 

W przypadku wybrania nadawania danych do układu podrzędnego, układ master wysyła kolejny bajty danych. Po każdym bajcie układ odbierający ma wysłać bit ACK. Dla komunikacji w drugą stronę to układ podrzędny wysyła kolejne bajty danych a układ nadzorujący przesyła bity ACK. Zakończenie transmisji odbywa się przez wygenerowanie sygnału STOP. 

Procedura odczytu pojedynczego bajtu przez I2C wygląda następująco:

1. int16_t I2C3_ReadByte(uint8_t slaveAddress, uint8_t registerAddress)
2. {
3.   int16_t read_data=0;
4.   uint32_t timeout=0;
6.   /* Generate the Start Condition */
7.   I2C_GenerateSTART(I2C3, ENABLE);
9.   timeout=I2C3_TIMEOUT;
10.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_SB)) {
11.         if ((timeout--) == 0){
12.             return(I2C3_Timeout_Service(-1));
13.         }
14.   }
16.   /* Disable ACK */
17.   I2C_AcknowledgeConfig(I2C3, DISABLE);
19.   /* send slave adress and i2c transmission direction */
20.   I2C_Send7bitAddress(I2C3, slaveAddress, I2C_Direction_Transmitter);
22.   timeout=I2C3_TIMEOUT;
23.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_ADDR)){
24.         if ((timeout--) == 0){
25.             return(I2C3_Timeout_Service(-1));
26.         }
27.   }  
29.   /* Clear Address - flag */
30.   I2C3->SR2;
32.   timeout=I2C3_TIMEOUT;
33.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_TXE)) {
34.         if ((timeout--) == 0) {
35.             return(I2C3_Timeout_Service(-1));
36.         }
37.   }  
39.     /* Adress send */
40.   I2C_SendData(I2C3, registerAddress);
42.   timeout=I2C3_TIMEOUT;
43.   while ((!I2C_GetFlagStatus(I2C3, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(I2C3, I2C_FLAG_BTF))) {
44.         if ((timeout--) == 0) {
45.             return(I2C3_Timeout_Service(-1));
46.         }
47.   }
49.   /* Generate the Start Condition */
50.   I2C_GenerateSTART(I2C3, ENABLE);
52.   timeout=I2C3_TIMEOUT;
53.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_SB)) {
54.         if ((timeout--) == 0) {
55.             return(I2C3_Timeout_Service(-1));
56.         }
57.   }
59.   // Slave-Adresse senden (read)
60.   I2C_Send7bitAddress(I2C3, slaveAddress, I2C_Direction_Receiver);
62.   timeout=I2C3_TIMEOUT;
63.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_ADDR)) {
64.         if ((timeout--) == 0) {
65.             return(I2C3_Timeout_Service(-1));
66.         }
67.   }
69.   /* Clear Address - flag */
70.   I2C3->SR2;
72.   timeout=I2C3_TIMEOUT;
73.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_RXNE)) {
74.         if ((timeout--) == 0) {
75.             return(I2C3_Timeout_Service(-1));
76.         }
77.   }
79.   /* Stop sequence */
80.   I2C_GenerateSTOP(I2C3, ENABLE);
82.   /* Read data write into variable */
83.   read_data=(int16_t)(I2C_ReceiveData(I2C3));
85.   /* Send ACK */
86.   I2C_AcknowledgeConfig(I2C3, ENABLE);
88.   return read_data;
89. }

NACK na samym końcu informuje o zakończeniu odbierania danych.  Czyli, informuje urządzenie podrzędne, że więcej danych nie będzie już odbierane.

Procedura zapisu danych do układu podrzędnego:

1. uint8_t I2C3_WriteByte(uint8_t slaveAddress, uint8_t registerAddress, uint8_t dataToWrite)
2. {
3.   int16_t status=0;
4.   uint32_t timeout=0;
6.   /* Generate the Start Condition */
7.   I2C_GenerateSTART(I2C3, ENABLE);
9.   timeout=I2C3_TIMEOUT;
10.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_SB)) {
11.     if(timeout!=0){
12.             timeout--;
13.         }
14.         else{
15.             return 0;
16.         }
17.   }
19.   /* send slave adress and i2c transmission direction */
20.   I2C_Send7bitAddress(I2C3, slaveAddress, I2C_Direction_Transmitter);
22.   timeout=I2C3_TIMEOUT;
23.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_ADDR)) {
24.     if(timeout!=0){
25.             timeout--;
26.         }
27.         else{
28.             return 0;
29.         }
30.   }  
32.   /* Clear Address - flag */
33.   I2C3->SR2;
35.   timeout=I2C3_TIMEOUT;
36.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_TXE)) {
37.     if(timeout!=0){
38.             timeout--;
39.         }
40.         else{
41.             return 0;
42.         }
43.   }
45.   /* Send register value */
46.   I2C_SendData(I2C3, registerAddress);
48.   timeout=I2C3_TIMEOUT;
49.   while (!I2C_GetFlagStatus(I2C3, I2C_FLAG_TXE)) {
50.     if(timeout!=0){
51.             timeout--;
52.         }
53.         else{
54.             return 0;
55.         }
56.   }
58.   /* Send data to write */
59.   I2C_SendData(I2C3, dataToWrite);
61.   timeout=I2C3_TIMEOUT;
62.   while ((!I2C_GetFlagStatus(I2C3, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(I2C3, I2C_FLAG_BTF))) {
63.     if(timeout!=0){
64.             timeout--;
65.         }
66.         else{
67.             return 0;
68.         }
69.   }
71.   /* Stop sequence */
72.   I2C_GenerateSTOP(I2C3, ENABLE);
74.     /* Operation OK, change status*/
75.   status=1;
77.   return status;
78. }

Odczytanie danych z touchpada wykonywane jest za pomocą następującej funkcji:

1. uint8_t TouchPad_Read_Position(void)
2. {
3.   uint32_t x_Different = 0;
4.   uint32_t y_Different = 0;
5.   uint32_t tmp_x = 0;
6.   uint32_t tmp_y = 0;
7.   static uint32_t x = 0;
8.   static uint32_t y = 0;
9.   int16_t i2c_read_data = 0;
11.     /* Read axis data */
12.   i2c_read_data=I2C3_ReadByte(STMPE811_I2C_ADDR, IOE_REG_TP_CTRL);
13.    
14.     /* Check if data was read */
15.   if(i2c_read_data<0)   { return 0; }
17.     /* Check touch status */
18.   if((i2c_read_data&0x80)==0) { Touch_Data.status = TOUCH_RELEASED; }
19.   else                        { Touch_Data.status = TOUCH_PRESSED;  }
20.    
21.     /* If TouchPad was clicked */
22.   if(Touch_Data.status==TOUCH_PRESSED)
23.   {
24.     tmp_x = TouchPad_Read_X_Axis();
25.     tmp_y = TouchPad_Read_Y_Axis();
26.     x_Different = tmp_x > x? (tmp_x - x): (x - tmp_x);
27.     y_Different = tmp_y > y? (tmp_y - y): (y - tmp_y);
28.     if (x_Different + y_Different > 4)
29.     {
30.       x = tmp_x;
31.       y = tmp_y;
32.     }
33.   }
34.    
35.   Touch_Data.xp = x;
36.   Touch_Data.yp = y;
38.   I2C3_WriteByte(STMPE811_I2C_ADDR, IOE_REG_FIFO_STA, 0x01);
39.   I2C3_WriteByte(STMPE811_I2C_ADDR, IOE_REG_FIFO_STA, 0x00);
41.   return 1;
42. }

Pliki do projektu można pobrać z dysku google pod tym linkiem.