21ic电子技术开发论坛»论坛首页 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-F407测评】+LCD+FATFT+BMP图片显示
12下一页
返回列表 发新帖

[活动专区] 【AT-START-F407测评】+LCD+FATFT+BMP图片显示

[复制链接]
 楼主| qjp1988113 发表于 2021-3-2 12:57 | 显示全部楼层 |阅读模式
start, TFT, LCD, pi, TE
手头上有个驱动为HX8347的ardunio接口的LCD屏，今天我们就要ATF407来驱动它。屏幕用SPI方式驱动，同时SD卡也跟屏幕挂在同一路SPI上。
我们通过CS选择，分时使用这2个外设。并移植FATFS，让其显示SD卡里面的BMP图片。
废话不多说，我们先来配置SPI，这里使用SPI1，其中SPI的时钟速度不能太快，要考虑到SD卡的兼容性:
复制
  1. static void SPI1_GPIO_Configuration(void)
    

  2. {
    

  3.   GPIO_InitType GPIO_InitStructure;
    


  4. 

  5.         RCC_APB2PeriphClockCmd(SPI1_GPIO_CLK|RCC_APB2PERIPH_SPI1|RCC_APB2PERIPH_AFIO, ENABLE);
    

  6.         
    

  7.          /* Configure SPI_FLASH pins*/
    

  8.   GPIO_InitStructure.GPIO_Pins =  SPI1_PIN_MOSI;
    

  9.   GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_10MHz; 
    

  10.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  11.   GPIO_Init(SPI1_GPIO, &GPIO_InitStructure);
    


  12. 

  13.   GPIO_InitStructure.GPIO_Pins = SPI1_PIN_MISO;
    

  14.   GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_10MHz;  
    

  15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  16.   GPIO_Init(SPI1_GPIO, &GPIO_InitStructure);
    


  17. 

  18.   GPIO_InitStructure.GPIO_Pins =  SPI1_PIN_SCK;
    

  19.   GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_10MHz; 
    

  20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  21.   GPIO_Init(SPI1_GPIO, &GPIO_InitStructure);
    

  22.         
    

  23.         //CS
    

  24.   GPIO_InitStructure.GPIO_Pins = LCD_CS_PIN;
    

  25.   GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_10MHz;  
    

  26.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  27.   GPIO_Init(LCD_CS_GPIO, &GPIO_InitStructure);  
    

  28.         
    

  29. }
    


  30. 

  31. //SPI1 初始化
    

  32. void SPI1_Init(void)
    

  33. {
    


  34. 

  35.         SPI_InitType   SPI_InitStructure;
    

  36.         
    

  37.         /* Enable SPIy clock and GPIO clock for SPIy and SPIz */
    

  38.   RCC_APB2PeriphClockCmd(SPI1_CLK , ENABLE);
    


  39. 

  40.   /* 1st phase: SPI1 Master */
    

  41.   /* GPIO configuration ------------------------------------------------------*/
    

  42.   SPI1_GPIO_Configuration();
    

  43.         
    

  44.         //CS 置高
    

  45.         __LCD_CS_SET();
    

  46.   
    

  47.   /* SPI1 Config -------------------------------------------------------------*/
    

  48.   SPI_DefaultInitParaConfig(&SPI_InitStructure);
    

  49.   SPI_InitStructure.SPI_TransMode = SPI_TRANSMODE_FULLDUPLEX;
    

  50.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2EDGE;
    

  51.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_HIGH;
    

  52.         SPI_InitStructure.SPI_CPOLY = 0;
    

  53.         SPI_InitStructure.SPI_FirstBit = SPI_FIRSTBIT_MSB;
    

  54.   SPI_InitStructure.SPI_FrameSize = SPI_FRAMESIZE_8BIT;
    

  55.         SPI_InitStructure.SPI_MCLKP = SPI_MCLKP_8;
    

  56.         
    

  57.         //SPI_InitStructure.SPI_MCLKP = SPI_MCLKP_32;
    

  58.         
    

  59.         
    

  60.   SPI_InitStructure.SPI_NSSSEL = SPI_NSSSEL_SOFT;
    

  61.         SPI_InitStructure.SPI_Mode = SPI_MODE_MASTER;
    

  62.   
    

  63.   SPI_Init(SPI1, &SPI_InitStructure);
    


  64. 

  65.   
    

  66.   /* Enable SPI1 */
    

  67.   SPI_Enable(SPI1, ENABLE);
    


  68. 

  69. }
配置好了后，我们单独写一个SPI读写一个字节的函数：
复制
  1. unsigned int SPI1ReadWriteByte(unsigned char tx_data)
    

  2. {
    

  3.         
    

  4.                 /* Wait for SPIy Tx buffer empty */
    

  5.     while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TE) == RESET);
    


  6. 

  7.     /* Send SPIy data */
    

  8.     SPI_I2S_TxData(SPI1,tx_data);
    


  9. 

  10.     /* Wait for SPIy data reception */
    

  11.     while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RNE) == RESET);
    

  12.     /* Read SPIy received data */
    

  13.     return SPI_I2S_RxData(SPI1);
    

  14.         
    

  15. }
我们定义LCD的读写，直接调用SPI1的读写函数：
复制
  1. #define __LCD_WRITE_BYTE(__DATA)  SPI1ReadWriteByte(__DATA)
其中LCD的其他几个控制引脚的配置，与JTAG的引脚有冲突，我们remap为SWD调试模式，释放PA15 PB3 PB4 3个引脚作为普通引脚：
复制
  1. void lcd_port_init(void)
    

  2. {
    


  3. 

  4.         GPIO_InitType GPIO_InitStructure;
    


  5. 

  6.         RCC_APB2PeriphClockCmd(RCC_APB2PERIPH_GPIOA| RCC_APB2PERIPH_GPIOC||RCC_APB2PERIPH_AFIO , ENABLE); 
    

  7.   //调试仅SWD
    

  8.         GPIO_PinsRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//释放PA15  PB3  PB4
    

  9.         
    

  10.         GPIO_StructInit(&GPIO_InitStructure);
    

  11.         //LCD-CS  PA15
    

  12.         GPIO_InitStructure.GPIO_Pins = LCD_CS_PIN;                            
    

  13.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  14.         GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_50MHz; 
    

  15.         GPIO_Init(LCD_CS_GPIO, &GPIO_InitStructure);
    

  16.         //LCD-DC  PA8
    

  17.         GPIO_InitStructure.GPIO_Pins = LCD_DC_PIN;                            
    

  18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  19.         GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_50MHz; 
    

  20.         GPIO_Init(LCD_DC_GPIO, &GPIO_InitStructure);
    

  21.         //LCD-BKL PC7
    

  22.         GPIO_InitStructure.GPIO_Pins = LCD_BKL_PIN;                           
    

  23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  24.         GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_50MHz; 
    

  25.         GPIO_Init(LCD_BKL_GPIO, &GPIO_InitStructure);
    


  26. 

  27. }
LCD其他操作函数：
复制
  1. void lcd_write_byte(uint8_t chByte, uint8_t chCmd)
    

  2. {
    

  3.     if (chCmd) {
    

  4.         __LCD_DC_SET();
    

  5.     } else {
    

  6.         __LCD_DC_CLR();
    

  7.     }
    

  8.     
    

  9.     __LCD_CS_CLR();
    

  10.     __LCD_WRITE_BYTE(chByte);
    

  11.     __LCD_CS_SET();
    

  12. }
    


  13. 

  14. void lcd_write_word(uint16_t hwData)
    

  15. {
    

  16.     __LCD_DC_SET();
    

  17.     __LCD_CS_CLR();
    

  18.     __LCD_WRITE_BYTE(hwData >> 8);
    

  19.     __LCD_WRITE_BYTE(hwData & 0xFF);
    

  20.     __LCD_CS_SET();
    

  21. }
    


  22. 

  23. void lcd_write_register(uint8_t chRegister, uint8_t chValue)
    

  24. {
    

  25.         lcd_write_byte(chRegister, LCD_CMD);
    

  26.         lcd_write_byte(chValue, LCD_DATA);
    

  27. }
    


  28. 

  29. //set the specified position of cursor on lcd.
    

  30. //hwXpos specify x position
    

  31. //hwYpos specify y position
    

  32. void lcd_set_cursor(uint16_t hwXpos, uint16_t hwYpos)
    

  33. {
    

  34.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  35.                 return;
    

  36.         }
    

  37.     
    

  38.     lcd_write_register(0x02, hwXpos >> 8);
    

  39.         lcd_write_register(0x03, hwXpos & 0xFF); //Column Start
    

  40.         lcd_write_register(0x06, hwYpos >> 8);
    

  41.         lcd_write_register(0x07, hwYpos & 0xFF); //Row Start
    

  42. }
    


  43. 

  44. //clear the lcd with the specified color.
    

  45. void lcd_clear_screen(uint16_t hwColor)  
    

  46. {
    

  47.         uint32_t i, wCount = LCD_WIDTH;
    

  48.         
    

  49.         wCount *= LCD_HEIGHT;
    

  50.         
    

  51.         lcd_set_cursor(0, 0);
    

  52.         lcd_write_byte(0x22, LCD_CMD);
    

  53.     
    

  54.     __LCD_DC_SET();
    

  55.         __LCD_CS_CLR();
    

  56.         for (i = 0; i < wCount; i ++) {
    

  57.                 __LCD_WRITE_BYTE(hwColor >> 8);
    

  58.                 __LCD_WRITE_BYTE(hwColor & 0xFF);
    

  59.         }
    

  60.         __LCD_CS_SET();
    

  61. }
    


  62. 

  63. //draw a point on the lcd with the specified color.
    

  64. //hwXpos specify x position.
    

  65. //hwYpos specify y position.
    

  66. //hwColor color of the point.
    

  67. void lcd_draw_point(uint16_t hwXpos, uint16_t hwYpos, uint16_t hwColor) 
    

  68. {
    

  69.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  70.                 return;
    

  71.         }
    

  72.         
    

  73.         lcd_set_cursor(hwXpos, hwYpos);
    

  74.         lcd_write_byte(0x22, LCD_CMD);
    

  75.     lcd_write_word(hwColor);
    

  76. }
    


  77. 

  78. //display a char at the specified position on lcd.
    

  79. void lcd_display_char(uint16_t hwXpos, //specify x position.
    

  80.                          uint16_t hwYpos, //specify y position.
    

  81.                          uint8_t chChr,   //a char is display.
    

  82.                          uint8_t chSize,  //specify the size of the char
    

  83.                          uint16_t hwColor) //specify the color of the char
    

  84. {              
    

  85.         uint8_t i, j, chTemp;
    

  86.         uint16_t hwYpos0 = hwYpos, hwColorVal = 0;
    


  87. 

  88.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  89.                 return;
    

  90.         }
    


  91. 

  92.                                            
    

  93.     for (i = 0; i < chSize; i ++) {   
    

  94.                 if (FONT_1206 == chSize) {
    

  95.                         chTemp = c_chFont1206[chChr - 0x20][i];  
    

  96.                 } else if (FONT_1608 == chSize) { 
    

  97.                         chTemp = c_chFont1608[chChr - 0x20][i];
    

  98.                 }
    

  99.                 
    

  100.         for (j = 0; j < 8; j ++) {
    

  101.                     if (chTemp & 0x80) {
    

  102.                                 hwColorVal = hwColor;
    

  103.                                 lcd_draw_point(hwXpos, hwYpos, hwColorVal);
    

  104.                     }                        
    

  105.                         chTemp <<= 1;
    

  106.                         hwYpos ++;
    

  107.                         if ((hwYpos - hwYpos0) == chSize) {
    

  108.                                 hwYpos = hwYpos0;
    

  109.                                 hwXpos ++;
    

  110.                                 break;
    

  111.                         }
    

  112.                 }           
    

  113.     } 
    

  114. }
    


  115. 


  116. 

  117. //_pow
    

  118. uint32_t _pow(uint8_t m, uint8_t n)
    

  119. {
    

  120.         uint32_t result = 1;
    

  121.         
    

  122.         while(n --) result *= m;    
    

  123.         return result;
    

  124. }
    


  125. 

  126. //display a number at the specified position on lcd.
    

  127. void lcd_display_num(uint16_t hwXpos,  //specify x position.
    

  128.                           uint16_t hwYpos, //specify y position.
    

  129.                           uint32_t chNum,  //a number is display.
    

  130.                           uint8_t chLen,   //length ot the number
    

  131.                           uint8_t chSize,  //specify the size of the number
    

  132.                           uint16_t hwColor) //specify the color of the number
    

  133. {                 
    

  134.         uint8_t i;
    

  135.         uint8_t chTemp, chShow = 0;
    


  136. 

  137.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  138.                 return;
    

  139.         }
    

  140.         
    

  141.         for(i = 0; i < chLen; i ++) {
    

  142.                 chTemp = (chNum / _pow(10, chLen - i - 1)) % 10;
    

  143.                 if(chShow == 0 && i < (chLen - 1)) {
    

  144.                         if(chTemp == 0) {
    

  145.                                 lcd_display_char(hwXpos + (chSize / 2) * i, hwYpos, ' ', chSize, hwColor);
    

  146.                                 continue;
    

  147.                         } else {
    

  148.                                 chShow = 1;
    

  149.                         }         
    

  150.                 }
    

  151.                  lcd_display_char(hwXpos + (chSize / 2) * i, hwYpos, chTemp + '0', chSize, hwColor); 
    

  152.         }
    

  153. } 
    


  154. 

  155. //display a string at the specified position on lcd.
    

  156. void lcd_display_string(uint16_t hwXpos, //specify x position.
    

  157.                          uint16_t hwYpos,   //specify y position.
    

  158.                          const uint8_t *pchString,  //a pointer to string
    

  159.                          uint8_t chSize,    // the size of the string 
    

  160.                          uint16_t hwColor)  // specify the color of the string 
    

  161. {
    


  162. 

  163.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  164.                 return;
    

  165.         }
    

  166.         
    

  167.     while (*pchString != '\0') {       
    

  168.         if (hwXpos > (LCD_WIDTH - chSize / 2)) {
    

  169.                         hwXpos = 0;
    

  170.                         hwYpos += chSize;
    

  171.                         if (hwYpos > (LCD_HEIGHT - chSize)) {
    

  172.                                 hwYpos = hwXpos = 0;
    

  173.                                 lcd_clear_screen(0x00);
    

  174.                         }
    

  175.                 }
    

  176.                 
    

  177.         lcd_display_char(hwXpos, hwYpos, (uint8_t)*pchString, chSize, hwColor);
    

  178.         hwXpos += chSize / 2;
    

  179.         pchString ++;
    

  180.     } 
    

  181. }
    


  182. 

  183. //draw a line at the specified position on lcd.
    

  184. void lcd_draw_line(uint16_t hwXpos0, //specify x0 position.
    

  185.                       uint16_t hwYpos0, //specify y0 position.
    

  186.                       uint16_t hwXpos1, //specify x1 position.
    

  187.                       uint16_t hwYpos1, //specify y1 position.
    

  188.                       uint16_t hwColor) //specify the color of the line
    

  189. {
    

  190.         int x = hwXpos1 - hwXpos0;
    

  191.     int y = hwYpos1 - hwYpos0;
    

  192.     int dx = abs(x), sx = hwXpos0 < hwXpos1 ? 1 : -1;
    

  193.     int dy = -abs(y), sy = hwYpos0 < hwYpos1 ? 1 : -1;
    

  194.     int err = dx + dy, e2;
    


  195. 

  196.         if (hwXpos0 >= LCD_WIDTH || hwYpos0 >= LCD_HEIGHT || hwXpos1 >= LCD_WIDTH || hwYpos1 >= LCD_HEIGHT) {
    

  197.                 return;
    

  198.         }
    

  199.     
    

  200.     for (;;){
    

  201.         lcd_draw_point(hwXpos0, hwYpos0 , hwColor);
    

  202.         e2 = 2 * err;
    

  203.         if (e2 >= dy) {     
    

  204.             if (hwXpos0 == hwXpos1) break;
    

  205.             err += dy; hwXpos0 += sx;
    

  206.         }
    

  207.         if (e2 <= dx) {
    

  208.             if (hwYpos0 == hwYpos1) break;
    

  209.             err += dx; hwYpos0 += sy;
    

  210.         }
    

  211.     }
    

  212. }
    


  213. 

  214. //draw a circle at the specified position on lcd.
    

  215. void lcd_draw_circle(uint16_t hwXpos,  //specify x position.
    

  216.                         uint16_t hwYpos,  //specify y position.
    

  217.                         uint16_t hwRadius, //specify the radius of the circle.
    

  218.                         uint16_t hwColor)  //specify the color of the circle.
    

  219. {
    

  220.         int x = -hwRadius, y = 0, err = 2 - 2 * hwRadius, e2;
    


  221. 

  222.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  223.                 return;
    

  224.         }
    

  225.         
    

  226.     do {
    

  227.         lcd_draw_point(hwXpos - x, hwYpos + y, hwColor);
    

  228.         lcd_draw_point(hwXpos + x, hwYpos + y, hwColor);
    

  229.         lcd_draw_point(hwXpos + x, hwYpos - y, hwColor);
    

  230.         lcd_draw_point(hwXpos - x, hwYpos - y, hwColor);
    

  231.         e2 = err;
    

  232.         if (e2 <= y) {
    

  233.             err += ++ y * 2 + 1;
    

  234.             if(-x == y && e2 <= x) e2 = 0;
    

  235.         }
    

  236.         if(e2 > x) err += ++ x * 2 + 1;
    

  237.     } while(x <= 0);
    

  238. }
    


  239. 

  240. //fill a rectangle out at the specified position on lcd.
    

  241. void lcd_fill_rect(uint16_t hwXpos,  //specify x position.
    

  242.                    uint16_t hwYpos,  //specify y position.
    

  243.                    uint16_t hwWidth, //specify the width of the rectangle.
    

  244.                    uint16_t hwHeight, //specify the height of the rectangle.
    

  245.                    uint16_t hwColor)  //specify the color of rectangle.
    

  246. {
    

  247.         uint16_t i, j;
    


  248. 

  249.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  250.                 return;
    

  251.         }
    

  252.         
    

  253.         for(i = 0; i < hwHeight; i ++){
    

  254.                 for(j = 0; j < hwWidth; j ++){
    

  255.                         lcd_draw_point(hwXpos + j, hwYpos + i, hwColor);
    

  256.                 }
    

  257.         }
    

  258. }
    


  259. 

  260. //draw a vertical line at the specified position on lcd.
    

  261. void lcd_draw_v_line(uint16_t hwXpos, //specify x position.
    

  262.                         uint16_t hwYpos, //specify y position. 
    

  263.                         uint16_t hwHeight, //specify the height of the vertical line.
    

  264.                         uint16_t hwColor)  //specify the color of the vertical line.
    

  265. {        
    

  266.         uint16_t i, y1 = MIN(hwYpos + hwHeight, LCD_HEIGHT - 1);
    


  267. 

  268.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  269.                 return;
    

  270.         }
    

  271.         
    

  272.     for (i = hwYpos; i < y1; i ++) {
    

  273.         lcd_draw_point(hwXpos, i, hwColor);
    

  274.     }
    

  275. }
    


  276. 

  277. //draw a horizonal line at the specified position on lcd.
    

  278. void lcd_draw_h_line(uint16_t hwXpos, //specify x position.
    

  279.                         uint16_t hwYpos,  //specify y position. 
    

  280.                         uint16_t hwWidth, //specify the width of the horizonal line.
    

  281.                         uint16_t hwColor) //specify the color of the horizonal line.
    

  282. {        
    

  283.         uint16_t i, x1 = MIN(hwXpos + hwWidth, LCD_WIDTH - 1);
    


  284. 

  285.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  286.                 return;
    

  287.         }
    

  288.         
    

  289.     for (i = hwXpos; i < x1; i ++) {
    

  290.         lcd_draw_point(i, hwYpos, hwColor);
    

  291.     }
    

  292. }
    


  293. 

  294. void lcd_draw_rect(uint16_t hwXpos,  //specify x position.
    

  295.                       uint16_t hwYpos,  //specify y position.
    

  296.                       uint16_t hwWidth, //specify the width of the rectangle.
    

  297.                       uint16_t hwHeight, //specify the height of the rectangle.
    

  298.                       uint16_t hwColor)  //specify the color of rectangle.
    

  299. {
    

  300.         if (hwXpos >= LCD_WIDTH || hwYpos >= LCD_HEIGHT) {
    

  301.                 return;
    

  302.         }
    


  303. 

  304.         lcd_draw_h_line(hwXpos, hwYpos, hwWidth, hwColor);
    

  305.         lcd_draw_h_line(hwXpos, hwYpos + hwHeight, hwWidth, hwColor);
    

  306.         lcd_draw_v_line(hwXpos, hwYpos, hwHeight, hwColor);
    

  307.         lcd_draw_v_line(hwXpos + hwWidth, hwYpos, hwHeight + 1, hwColor);
    

  308. }
    


  309. 


  310. 


  311. 

  312. //initialize the lcd.
    

  313. //phwDevId pointer to device ID of lcd
    

  314. void lcd_init(void)
    

  315. {
    

  316. //        __LCD_RST_CLR();
    

  317. //        delay_ms(100);
    

  318. //        __LCD_RST_SET();
    

  319.         __LCD_CS_SET();
    

  320.         __LCD_BKL_SET();
    


  321. 

  322.         //Driving ability Setting
    

  323.         lcd_write_register(0xEA,0x00); //PTBA[15:8]
    

  324.         lcd_write_register(0xEB,0x20); //PTBA[7:0]
    

  325.         lcd_write_register(0xEC,0x0C); //STBA[15:8]
    

  326.         lcd_write_register(0xED,0xC4); //STBA[7:0]
    

  327.         lcd_write_register(0xE8,0x38); //OPON[7:0]
    

  328.         lcd_write_register(0xE9,0x10); //OPON1[7:0]
    

  329.         lcd_write_register(0xF1,0x01); //OTPS1B
    

  330.         lcd_write_register(0xF2,0x10); //GEN
    

  331.         //Gamma 2.2 Setting
    

  332.         lcd_write_register(0x40,0x01); //
    

  333.         lcd_write_register(0x41,0x00); //
    

  334.         lcd_write_register(0x42,0x00); //
    

  335.         lcd_write_register(0x43,0x10); //
    

  336.         lcd_write_register(0x44,0x0E); //
    

  337.         lcd_write_register(0x45,0x24); //
    

  338.         lcd_write_register(0x46,0x04); //
    

  339.         lcd_write_register(0x47,0x50); //
    

  340.         lcd_write_register(0x48,0x02); //
    

  341.         lcd_write_register(0x49,0x13); //
    

  342.         lcd_write_register(0x4A,0x19); //
    

  343.         lcd_write_register(0x4B,0x19); //
    

  344.         lcd_write_register(0x4C,0x16); //
    

  345.         lcd_write_register(0x50,0x1B); //
    

  346.         lcd_write_register(0x51,0x31); //
    

  347.         lcd_write_register(0x52,0x2F); //
    

  348.         lcd_write_register(0x53,0x3F); //
    

  349.         lcd_write_register(0x54,0x3F); //
    

  350.         lcd_write_register(0x55,0x3E); //
    

  351.         lcd_write_register(0x56,0x2F); //
    

  352.         lcd_write_register(0x57,0x7B); //
    

  353.         lcd_write_register(0x58,0x09); //
    

  354.         lcd_write_register(0x59,0x06); //
    

  355.         lcd_write_register(0x5A,0x06); //
    

  356.         lcd_write_register(0x5B,0x0C); //
    

  357.         lcd_write_register(0x5C,0x1D); //
    

  358.         lcd_write_register(0x5D,0xCC); //
    

  359.         //Power Voltage Setting
    

  360.         lcd_write_register(0x1B,0x1B); //VRH=4.65V
    

  361.         lcd_write_register(0x1A,0x01); //BT (VGH~15V,VGL~-10V,DDVDH~5V)
    

  362.         lcd_write_register(0x24,0x2F); //VMH(VCOM High voltage ~3.2V)
    

  363.         lcd_write_register(0x25,0x57); //VML(VCOM Low voltage -1.2V)
    

  364.         //****VCOM offset**///
    

  365.         lcd_write_register(0x23,0x88); //for Flicker adjust //can reload from OTP
    

  366.         //Power on Setting
    

  367.         lcd_write_register(0x18,0x34); //I/P_RADJ,N/P_RADJ, Normal mode 60Hz
    

  368.         lcd_write_register(0x19,0x01); //OSC_EN='1', start Osc
    

  369.         lcd_write_register(0x01,0x00); //DP_STB='0', out deep sleep
    

  370.         lcd_write_register(0x1F,0x88);// GAS=1, VOMG=00, PON=0, DK=1, XDK=0, DVDH_TRI=0, STB=0
    

  371.         delay_ms(5);
    

  372.         lcd_write_register(0x1F,0x80);// GAS=1, VOMG=00, PON=0, DK=0, XDK=0, DVDH_TRI=0, STB=0
    

  373.         delay_ms(5);
    

  374.         lcd_write_register(0x1F,0x90);// GAS=1, VOMG=00, PON=1, DK=0, XDK=0, DVDH_TRI=0, STB=0
    

  375.         delay_ms(5);
    

  376.         lcd_write_register(0x1F,0xD0);// GAS=1, VOMG=10, PON=1, DK=0, XDK=0, DDVDH_TRI=0, STB=0
    

  377.         delay_ms(5);
    

  378.         //262k/65k color selection
    

  379.         lcd_write_register(0x17,0x05); //default 0x06 262k color // 0x05 65k color
    

  380.         //SET PANEL
    

  381.         lcd_write_register(0x36,0x00); //SS_P, GS_P,REV_P,BGR_P
    

  382.         //Display ON Setting
    

  383.         lcd_write_register(0x28,0x38); //GON=1, DTE=1, D=1000
    

  384.         delay_ms(40);
    

  385.         lcd_write_register(0x28,0x3F); //GON=1, DTE=1, D=1100
    


  386. 

  387.         lcd_write_register(0x16,0x18); 
    

  388.         //Set GRAM Area
    

  389.         lcd_write_register(0x02,0x00);
    

  390.         lcd_write_register(0x03,0x00); //Column Start
    

  391.         lcd_write_register(0x04,0x00);
    

  392.         lcd_write_register(0x05,0xEF); //Column End
    

  393.         lcd_write_register(0x06,0x00);
    

  394.         lcd_write_register(0x07,0x00); //Row Start
    

  395.         lcd_write_register(0x08,0x01);
    

  396.         lcd_write_register(0x09,0x3F); //Row End
    

  397.     
    

  398.   lcd_clear_screen(WHITE);
    

  399.         //lcd_clear_screen(RED);
    

  400. }
接下来，我们配置SD卡的驱动程序：
SD卡读写一样调用的SPI1的读写函数：
复制
  1. #define __SD_WRITE_BYTE(__DATA)  SPI1ReadWriteByte(__DATA)
SD开的CS端配置，其中触摸芯片XPT2046也挂在这个SPI上面，本例我们先不要，但是定义它的CS引脚，让它处于不选通状态：
复制
  1. void SD_port_init(void)
    

  2. {
    

  3.         GPIO_InitType GPIO_InitStructure;
    

  4.         
    

  5.         RCC_APB2PeriphClockCmd(RCC_APB2PERIPH_GPIOB, ENABLE);  
    

  6.         
    

  7.         GPIO_StructInit(&GPIO_InitStructure);
    

  8.         //PB4  PB5
    

  9.         GPIO_InitStructure.GPIO_Pins = SD_CS_PIN;                            
    

  10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  11.         GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_50MHz; 
    

  12.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  13.         
    

  14.         GPIO_InitStructure.GPIO_Pins = XPT2046_CS_PIN ;                            
    

  15.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT_PP;
    

  16.         //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  17.         GPIO_InitStructure.GPIO_MaxSpeed = GPIO_MaxSpeed_50MHz; 
    

  18.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  19.         
    

  20.         __SD_CS_SET();
    

  21.         __XPT2046_CS_SET();
    


  22. 

  23. }
SD其他操作函数：
复制
  1. //data: data to be written to sd card.
    

  2. //return: data read from sd card.
    

  3. uint8_t SD_SPI_ReadWriteByte(uint8_t data)
    

  4. {
    

  5.         return __SD_WRITE_BYTE(data);
    

  6. }          
    


  7. 

  8. //set spi in low speed mode.
    

  9. void SD_SPI_SpeedLow(void)
    

  10. {
    

  11.         SPI1->CTRL1&=0XFFC7; 
    

  12.         SPI1->CTRL1|=SPI_MCLKP_256;
    

  13.         SPI_Enable(SPI1, ENABLE);
    


  14. 

  15. }
    


  16. 


  17. 

  18. //set spi in high speed mode.
    

  19. void SD_SPI_SpeedHigh(void)
    

  20. {
    

  21.         SPI1->CTRL1&=0XFFC7; 
    

  22.         SPI1->CTRL1|=SPI_MCLKP_32;
    

  23.         SPI_Enable(SPI1, ENABLE);
    

  24. }
    


  25. 


  26. 

  27. //released spi bus
    

  28. void SD_DisSelect(void)
    

  29. {
    

  30.         __SD_CS_SET();
    

  31.          SD_SPI_ReadWriteByte(0xff);//providing extra 8 clocks  
    

  32. }
    


  33. 

  34. //pick sd card and waiting until until it's ready
    

  35. //return: 0: succed 1: failure
    

  36. uint8_t SD_Select(void)
    

  37. {
    

  38.         __SD_CS_CLR();
    

  39.         if(SD_WaitReady()==0)return 0; 
    

  40.         SD_DisSelect();
    

  41.         return 1;
    

  42. }
    


  43. 

  44. //waiting for sd card until it's ready
    

  45. uint8_t SD_WaitReady(void)
    

  46. {
    

  47.         uint32_t t=0;
    

  48.         do
    

  49.         {
    

  50.                 if(SD_SPI_ReadWriteByte(0XFF)==0XFF)return 0;
    

  51.                 t++;                          
    

  52.         }while(t<0XFFFFFF);
    

  53.         return 1;
    

  54. }
    


  55. 

  56. //waiting for response from sd card.
    

  57. //Response: expect from sd card.
    

  58. //return: succeed for 0, fail for other else 
    

  59. //return: 0 for success, other for failure.   
    

  60. uint8_t SD_GetResponse(uint8_t Response)
    

  61. {
    

  62.         uint16_t Count=0xFFFF;                                                             
    

  63.         while ((SD_SPI_ReadWriteByte(0XFF)!=Response)&&Count)Count--;           
    

  64.         if (Count==0)return MSD_RESPONSE_FAILURE;  
    

  65.         else return MSD_RESPONSE_NO_ERROR;
    

  66. }
    


  67. 

  68. //read a buffer from sd card.
    

  69. //*buf: pointer to a buffer.
    

  70. //len: length of the buffer.
    

  71. //return: 0 for success, other for failure.   
    

  72. uint8_t SD_RecvData(uint8_t*buf,uint16_t len)
    

  73. {                                    
    

  74.         if(SD_GetResponse(0xFE))return 1;//waiting for start command send back from sd card.
    

  75.     while(len--)//receiving data...
    

  76.     {
    

  77.         *buf=__SD_WRITE_BYTE(0xFF);
    

  78.         buf++;
    

  79.     }
    


  80. 

  81.     //send 2 dummy write (dummy CRC)
    

  82.     SD_SPI_ReadWriteByte(0xFF);
    

  83.     SD_SPI_ReadWriteByte(0xFF);                                                                                                                      
    

  84.     return 0;
    

  85. }
    


  86. 

  87. //write a buffer containing 512 bytes to sd card.
    

  88. //buf: data buffer
    

  89. //cmd: command
    

  90. //return: 0 for success, other for failure.   
    

  91. uint8_t SD_SendBlock(uint8_t*buf,uint8_t cmd)
    

  92. {        
    

  93.         uint16_t t;                            
    

  94.         if(SD_WaitReady())return 1;
    

  95.         SD_SPI_ReadWriteByte(cmd);
    

  96.         if(cmd!=0XFD)
    

  97.         {
    

  98.                 for(t=0;t<512;t++)__SD_WRITE_BYTE(buf[t]);
    

  99.             SD_SPI_ReadWriteByte(0xFF);//ignoring CRC
    

  100.             SD_SPI_ReadWriteByte(0xFF);
    

  101.                 t=SD_SPI_ReadWriteByte(0xFF);
    

  102.                 if((t&0x1F)!=0x05)return 2;                                                                                                              
    

  103.         }                                                                                                                                                                       
    

  104.     return 0;
    

  105. }
    


  106. 


  107. 

  108. //send a command to sd card 
    

  109. //cmd：command
    

  110. //arg: parameter
    

  111. //crc: crc
    

  112. //return: response sent back from sd card.
    

  113. uint8_t SD_SendCmd(uint8_t cmd, uint32_t arg, uint8_t crc)
    

  114. {
    

  115.     uint8_t r1;        
    

  116.         uint8_t Retry=0; 
    

  117.         SD_DisSelect();
    

  118.         if(SD_Select())return 0XFF;
    


  119. 

  120.     SD_SPI_ReadWriteByte(cmd | 0x40);
    

  121.     SD_SPI_ReadWriteByte(arg >> 24);
    

  122.     SD_SPI_ReadWriteByte(arg >> 16);
    

  123.     SD_SPI_ReadWriteByte(arg >> 8);
    

  124.     SD_SPI_ReadWriteByte(arg);          
    

  125.     SD_SPI_ReadWriteByte(crc); 
    

  126.         if(cmd==CMD12)SD_SPI_ReadWriteByte(0xff); //Skip a stuff byte when stop reading
    

  127.         Retry=0X1F;
    

  128.         do
    

  129.         {
    

  130.                 r1=SD_SPI_ReadWriteByte(0xFF);
    

  131.         }while((r1&0X80) && Retry--);         
    


  132. 

  133.     return r1;
    

  134. }
    


  135. 


  136. 

  137. //obtain CID including manufacturer informationfrom sd card  
    

  138. //*cid_dat: pointer to the buffer storing CID, at least 16 bytes.
    

  139. //return: 0 no error  1 error
    

  140. uint8_t SD_GetCID(uint8_t *cid_data)
    

  141. {
    

  142.     uint8_t r1;           
    


  143. 

  144.     r1=SD_SendCmd(CMD10,0,0x01);
    

  145.     if(r1==0x00)
    

  146.         {
    

  147.                 r1=SD_RecvData(cid_data,16);         
    

  148.     }
    

  149.         SD_DisSelect();
    

  150.         if(r1)return 1;
    

  151.         else return 0;
    

  152. }                                                                                                                                                                  
    


  153. 

  154. //obtain CSD including storage and speed.
    

  155. //*csd_data : pointer to the buffer storing CSD, at least 16 bytes.
    

  156. //return: 0 no error  1 error
    

  157. uint8_t SD_GetCSD(uint8_t *csd_data)
    

  158. {
    

  159.     uint8_t r1;         
    

  160.     r1=SD_SendCmd(CMD9,0,0x01);//发CMD9命令，读CSD send CMD9 in order to get CSD
    

  161.     if(r1==0)
    

  162.         {
    

  163.             r1=SD_RecvData(csd_data, 16);
    

  164.     }
    

  165.         SD_DisSelect();
    

  166.         if(r1)return 1;
    

  167.         else return 0;
    

  168. }  
    


  169. 

  170. //obtian the totals of sectors of sd card.
    

  171. //return: 0 error, other else for storage of sd card.
    

  172. //numbers of bytes of each sector must be 512, otherwise fail to initialization.  
    

  173. uint32_t SD_GetSectorCount(void)
    

  174. {
    

  175.     uint8_t csd[16];
    

  176.     uint32_t Capacity;  
    

  177.     uint8_t n;
    

  178.         uint16_t csize;                                              
    

  179.         
    

  180.     if(SD_GetCSD(csd)!=0) return 0;            
    

  181.     //calculation for SDHC below
    

  182.     if((csd[0]&0xC0)==0x40)         //V2.00
    

  183.     {        
    

  184.                 csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
    

  185.                 Capacity = (uint32_t)csize << 10;  //totals of sectors                    
    

  186.     }else//V1.XX
    

  187.     {        
    

  188.                 n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
    

  189.                 csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
    

  190.                 Capacity= (uint32_t)csize << (n - 9); 
    

  191.     }
    

  192.     return Capacity;
    

  193. }
    


  194. 

  195. //initialize sd card 
    

  196. uint8_t SD_Initialize(void)
    

  197. {
    

  198.     uint8_t r1;      
    

  199.     uint16_t retry;  
    

  200.     uint8_t buf[4];  
    

  201.         uint16_t i;
    

  202.     
    

  203.     __SD_CS_SET();
    

  204.          SD_SPI_SpeedLow();        
    

  205.          for(i=0;i<10;i++)SD_SPI_ReadWriteByte(0XFF);
    

  206.         retry=20;
    

  207.         do
    

  208.         {
    

  209.                 r1=SD_SendCmd(CMD0,0,0x95);//enter to idle state
    

  210.         }while((r1!=0X01) && retry--);
    

  211.          SD_Type=0;
    

  212.     
    

  213.         if(r1==0X01)
    

  214.         {
    

  215.                 if(SD_SendCmd(CMD8,0x1AA,0x87)==1)//SD V2.0
    

  216.                 {
    

  217.                         for(i=0;i<4;i++)buf[i]=SD_SPI_ReadWriteByte(0XFF);        //Get trailing return value of R7 resp
    

  218.                         if(buf[2]==0X01&&buf[3]==0XAA)//is it support of 2.7~3.6V 
    

  219.                         {
    

  220.                                 retry=0XFFFE;
    

  221.                                 do
    

  222.                                 {
    

  223.                                         SD_SendCmd(CMD55,0,0X01);        
    

  224.                                         r1=SD_SendCmd(CMD41,0x40000000,0X01);
    

  225.                                 }while(r1&&retry--);
    

  226.                                 if(retry&&SD_SendCmd(CMD58,0,0X01)==0) //start to identify the SD2.0 version of sd card.
    

  227.                                 {
    

  228.                                         for(i=0;i<4;i++)buf[i]=SD_SPI_ReadWriteByte(0XFF);//get OCR
    

  229.                                         if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC;    //check CCS
    

  230.                                         else SD_Type=SD_TYPE_V2;   
    

  231.                                 }
    

  232.                         }
    

  233.                 }else//SD V1.x/ MMC        V3
    

  234.                 {
    

  235.                         SD_SendCmd(CMD55,0,0X01);                
    

  236.                         r1=SD_SendCmd(CMD41,0,0X01);        
    

  237.                         if(r1<=1)
    

  238.                         {                
    

  239.                                 SD_Type=SD_TYPE_V1;
    

  240.                                 retry=0XFFFE;
    

  241.                                 do //exit idle state
    

  242.                                 {
    

  243.                                         SD_SendCmd(CMD55,0,0X01);        
    

  244.                                         r1=SD_SendCmd(CMD41,0,0X01);
    

  245.                                 }while(r1&&retry--);
    

  246.                         }else
    

  247.                         {
    

  248.                                 SD_Type=SD_TYPE_MMC;//MMC V3
    

  249.                                 retry=0XFFFE;
    

  250.                                 do 
    

  251.                                 {                                                                                            
    

  252.                                         r1=SD_SendCmd(CMD1,0,0X01);
    

  253.                                 }while(r1&&retry--);  
    

  254.                         }
    

  255.                         if(retry==0||SD_SendCmd(CMD16,512,0X01)!=0)SD_Type=SD_TYPE_ERR;
    

  256.                 }
    

  257.         }
    

  258.         SD_DisSelect();
    

  259.         SD_SPI_SpeedHigh();
    

  260.         if(SD_Type)return 0;
    

  261.         else if(r1)return r1;            
    

  262.         return 0xaa;
    

  263. }
    


  264. 


  265. 

  266. //read SD card
    

  267. //buf: data buffer
    

  268. //sector: sector
    

  269. //cnt: totals of sectors]
    

  270. //return: 0 ok, other for failure
    

  271. uint8_t SD_ReadDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
    

  272. {
    

  273.         uint8_t r1;
    

  274.         if(SD_Type!=SD_TYPE_V2HC)sector <<= 9;
    

  275.         if(cnt==1)
    

  276.         {
    

  277.                 r1=SD_SendCmd(CMD17,sector,0X01);
    

  278.                 if(r1==0)
    

  279.                 {
    

  280.                         r1=SD_RecvData(buf,512);   
    

  281.                 }
    

  282.         }else
    

  283.         {
    

  284.                 r1=SD_SendCmd(CMD18,sector,0X01);
    

  285.                 do
    

  286.                 {
    

  287.                         r1=SD_RecvData(buf,512);
    

  288.                         buf+=512;  
    

  289.                 }while(--cnt && r1==0);         
    

  290.                 SD_SendCmd(CMD12,0,0X01);        
    

  291.         }   
    

  292.         SD_DisSelect();
    

  293.         return r1;//
    

  294. }
    


  295. 


  296. 

  297. //write sd card 
    

  298. //buf: data buffer
    

  299. //sector: start sector
    

  300. //cnt: totals of sectors]
    

  301. //return: 0 ok, other for failure
    

  302. uint8_t SD_WriteDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
    

  303. {
    

  304.         uint8_t r1;
    

  305.         if(SD_Type!=SD_TYPE_V2HC)sector *= 512;
    

  306.         if(cnt==1)
    

  307.         {
    

  308.                 r1=SD_SendCmd(CMD24,sector,0X01);
    

  309.                 if(r1==0)
    

  310.                 {
    

  311.                         r1=SD_SendBlock(buf,0xFE); 
    

  312.                 }
    

  313.         }else
    

  314.         {
    

  315.                 if(SD_Type!=SD_TYPE_MMC)
    

  316.                 {
    

  317.                         SD_SendCmd(CMD55,0,0X01);        
    

  318.                         SD_SendCmd(CMD23,cnt,0X01);        
    

  319.                 }
    

  320.                  r1=SD_SendCmd(CMD25,sector,0X01);
    

  321.                 if(r1==0)
    

  322.                 {
    

  323.                         do
    

  324.                         {
    

  325.                                 r1=SD_SendBlock(buf,0xFC); 
    

  326.                                 buf+=512;  
    

  327.                         }while(--cnt && r1==0);
    

  328.                         r1=SD_SendBlock(0,0xFD);
    

  329.                 }
    

  330.         }   
    

  331.         SD_DisSelect();
    

  332.         return r1;
    

  333. }          
下面我们开始移植FATFS，这个主要就是diskio和ff的文件，这里也加载了FATFS常见操作的fatfs_storage文件。
主要修改的就是diskio文件，让我们本例程中的SD具体实现函数来替代FATFS里面的底层操作函数，当然也可在ff_config
头文件里面精简FATFS系统：
复制
  1. /*-----------------------------------------------------------------------*/
    

  2. /* Inidialize a Drive                                                    */
    


  3. 

  4. #define SD_CARD         0  //SD卡,卷标为0
    


  5. 

  6. #define FLASH_SECTOR_SIZE         512                          
    


  7. 

  8. //初始化磁盘
    

  9. DSTATUS disk_initialize (
    

  10.         BYTE drv                                /* Physical drive nmuber (0..) */
    

  11. )
    

  12. {        
    

  13.         uint8_t res=0;            
    

  14.         switch(drv)
    

  15.         {
    

  16.                 case SD_CARD://SD卡
    

  17.                         res = SD_Initialize();//SD_Initialize() 
    

  18.                          if(res)//STM32 SPI的bug,在sd卡操作失败的时候如果不执行下面的语句,可能导致SPI读写异常
    

  19.                         {
    

  20.                                 SD_SPI_SpeedLow();
    

  21.                                 SD_SPI_ReadWriteByte(0xff);//提供额外的8个时钟
    

  22.                                 SD_SPI_SpeedHigh();
    

  23.                         }
    

  24.                           break;
    

  25.                 default:
    

  26.                         res=1; 
    

  27.         }                 
    

  28.         if(res)return  STA_NOINIT;
    

  29.         else return 0; //初始化成功
    

  30. }   
    

  31. //获得磁盘状态
    

  32. DSTATUS disk_status (
    

  33.         BYTE drv                /* Physical drive nmuber (0..) */
    

  34. )
    

  35. {                   
    

  36.     return 0;
    

  37. }
    

  38.  //读扇区
    

  39.  //drv:磁盘编号0~9
    

  40.  //*buff:数据接收缓冲首地址
    

  41.  //sector:扇区地址
    

  42.  //count:需要读取的扇区数
    

  43. DRESULT disk_read (
    

  44.         BYTE drv,                /* Physical drive nmuber (0..) */
    

  45.         BYTE *buff,                /* Data buffer to store read data */
    

  46.         DWORD sector,        /* Sector address (LBA) */
    

  47.         BYTE count                /* Number of sectors to read (1..255) */
    

  48. )
    

  49. {
    

  50.         uint8_t res=0; 
    

  51.     if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误                          
    

  52.         switch(drv)
    

  53.         {
    

  54.                 case SD_CARD://SD卡
    

  55.                         res=SD_ReadDisk(buff,sector,count);         
    

  56.                          if(res)//STM32 SPI的bug,在sd卡操作失败的时候如果不执行下面的语句,可能导致SPI读写异常
    

  57.                         {
    

  58.                                 SD_SPI_SpeedLow();
    

  59.                                 SD_SPI_ReadWriteByte(0xff);//提供额外的8个时钟
    

  60.                                 SD_SPI_SpeedHigh();
    

  61.                         }
    

  62.                         break;
    

  63.                 default:
    

  64.                         res=1; 
    

  65.         }
    

  66.    //处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
    

  67.     if(res==0x00)return RES_OK;         
    

  68.     else return RES_ERROR;           
    

  69. }  
    

  70.  //写扇区
    

  71.  //drv:磁盘编号0~9
    

  72.  //*buff:发送数据首地址
    

  73.  //sector:扇区地址
    

  74.  //count:需要写入的扇区数            
    

  75. #if _READONLY == 0
    

  76. DRESULT disk_write (
    

  77.         BYTE drv,                        /* Physical drive nmuber (0..) */
    

  78.         const BYTE *buff,                /* Data to be written */
    

  79.         DWORD sector,                /* Sector address (LBA) */
    

  80.         BYTE count                        /* Number of sectors to write (1..255) */
    

  81. )
    

  82. {
    

  83.         uint8_t res=0;  
    

  84.     if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误                          
    

  85.         switch(drv)
    

  86.         {
    

  87.                 case SD_CARD://SD卡
    

  88.                         res=SD_WriteDisk((uint8_t*)buff,sector,count);
    

  89.                         break;
    

  90.                 default:
    

  91.                         res=1; 
    

  92.         }
    

  93.     //处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
    

  94.     if(res == 0x00)return RES_OK;         
    

  95.     else return RES_ERROR;                 
    

  96. }
    

  97. #endif /* _READONLY */
    


  98. 

  99. //其他表参数的获得
    

  100.  //drv:磁盘编号0~9
    

  101.  //ctrl:控制代码
    

  102.  //*buff:发送/接收缓冲区指针
    

  103. DRESULT disk_ioctl (
    

  104.         BYTE drv,                /* Physical drive nmuber (0..) */
    

  105.         BYTE ctrl,                /* Control code */
    

  106.         void *buff                /* Buffer to send/receive control data */
    

  107. )
    

  108. {        
    

  109.         DRESULT res;                                                                               
    

  110.         if(drv==SD_CARD)//SD卡
    

  111.         {
    

  112.             switch(ctrl)
    

  113.             {
    

  114.                     case CTRL_SYNC:
    

  115.                                 __SD_CS_CLR();
    

  116.                         if(SD_WaitReady()==0)res = RES_OK; 
    

  117.                         else res = RES_ERROR;          
    

  118.                                 __SD_CS_SET();
    

  119.                         break;         
    

  120.                     case GET_SECTOR_SIZE:
    

  121.                         *(WORD*)buff = 512;
    

  122.                         res = RES_OK;
    

  123.                         break;         
    

  124.                     case GET_BLOCK_SIZE:
    

  125.                         *(WORD*)buff = 8;
    

  126.                         res = RES_OK;
    

  127.                         break;         
    

  128.                     case GET_SECTOR_COUNT:
    

  129.                         *(DWORD*)buff = SD_GetSectorCount();
    

  130.                         res = RES_OK;
    

  131.                         break;
    

  132.                     default:
    

  133.                         res = RES_PARERR;
    

  134.                         break;
    

  135.             }
    

  136.         }else res=RES_ERROR;//其他的不支持
    

  137.     return res;
    

  138. } 
    


  139. 

  140. /*-----------------------------------------------------------------------*/
    

  141. /* User defined function to give a current time to fatfs module          */
    

  142. /* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */                                                                                                                                                                                                                                          
    

  143. /* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */                                                                                                                                                                                                                                                
    

  144. DWORD get_fattime (void)
    

  145. {
    

  146.     return 0;
    

  147. }
    

  148.        
其他不予多说，在main文件里面添加2个函数，一个是SD挂载FATFS，一个是轮流显示SD卡根目录里面的BMP:
复制
  1. char* pDirectoryFiles[MAX_BMP_FILES];
    

  2. FATFS microSDFatFs;
    

  3. uint8_t str[20];
    


  4. 

  5. void SDCard_Config(void)
    

  6. {
    

  7.   uint32_t counter = 0;
    

  8.   
    

  9.   /* Check the mounted device */
    

  10.   if(f_mount(µSDFatFs, (TCHAR const*)"/", 0) != FR_OK)
    

  11.   {
    

  12.       lcd_display_string(0, 16, "FATFS_NOT_MOUNTED", 16, RED);
    

  13.   }  
    

  14.   else
    

  15.   {
    

  16.     /* Initialize the Directory Files pointers (heap) */
    

  17.     for (counter = 0; counter < MAX_BMP_FILES; counter++)
    

  18.     {
    

  19.       pDirectoryFiles[counter] = malloc(11); 
    

  20.     }
    

  21.   }
    

  22. }
    


  23. 

  24. static void Display_Images(void)
    

  25. {    
    

  26.     uint32_t bmplen = 0x00;
    

  27.     uint32_t checkstatus = 0x00;
    

  28.     uint32_t filesnumbers = 0x00;
    

  29.     uint32_t bmpcounter = 0x00;
    

  30.     DIR directory;
    

  31.     FRESULT res;
    

  32.    
    

  33.     /* Open directory */
    

  34.     res= f_opendir(&directory, "/");
    

  35.     if((res != FR_OK))
    

  36.     {
    

  37.       if(res == FR_NO_FILESYSTEM)
    

  38.       {
    

  39.         /* Display message: SD card not FAT formated */
    

  40.         lcd_display_string(0, 32, "SD_CARD_NOT_FORMATTED", 16, RED);  
    

  41.           
    

  42.       }
    

  43.       else
    

  44.       {
    

  45.         /* Display message: Fail to open directory */
    

  46.          lcd_display_string(0, 48, "SD_CARD_OPEN_FAIL", 16, RED);           
    

  47.       }
    

  48.     }
    

  49.     
    

  50.     /* Get number of bitmap files */
    

  51.     filesnumbers = Storage_GetDirectoryBitmapFiles ("/", pDirectoryFiles);    
    

  52.     /* Set bitmap counter to display first image */
    

  53.     bmpcounter = 1; 
    

  54.     
    

  55.     while (1)
    

  56.     {     
    

  57.         sprintf((char*)str, "%-11.11s", pDirectoryFiles[bmpcounter -1]);
    

  58.         
    

  59.         checkstatus = Storage_CheckBitmapFile((const char*)str, &bmplen);
    

  60.         
    

  61.         if(checkstatus == 0)
    

  62.         {
    

  63.           /* Format the string */
    

  64.           Storage_OpenReadFile(0, 0, (const char*)str); 
    

  65.         }
    

  66.         else if (checkstatus == 1)
    

  67.         {
    

  68.           /* Display message: SD card does not exist */
    

  69.            lcd_display_string(0, 64, "SD_CARD_NOT_FOUND", 16, RED);  
    

  70.         }
    

  71.         else
    

  72.         {
    

  73.           /* Display message: File not supported */
    

  74.             lcd_display_string(0, 80, "SD_CARD_FILE_NOT_SUPPORTED", 16, RED); 
    

  75.         }
    

  76.         
    

  77.         bmpcounter ++;
    

  78.         if(bmpcounter > filesnumbers)
    

  79.         {
    

  80.           bmpcounter = 1;
    

  81.         }
    

  82.         
    

  83.         delay_ms(1000);
    

  84. //        delay_ms(1000);
    

  85. //        delay_ms(1000);
    

  86.     }
    

  87. }
最终main里面添加：
复制
  1. int main(void)
    

  2. {
    

  3.         /*!< At this stage the microcontroller clock setting is already configured, 
    

  4.          this is done through SystemInit() function which is called from startup
    

  5.          file (startup_at32f403_xx.s) before to branch to application main.
    

  6.          To reconfigure the default setting of SystemInit() function, refer to
    

  7.          system_at32f4xx.c file
    

  8.         */     
    

  9.          
    


  10. 

  11.   
    

  12.   /* Config LED */
    

  13.   AT32_Board_Init();
    

  14.   /* SPIy Config -------------------------------------------------------------*/
    

  15.   SPI1_Init();
    


  16. 

  17.         lcd_port_init();
    

  18.         lcd_init();
    

  19.         
    

  20.         SD_port_init();
    

  21.         SDCard_Config();
    

  22.         
    

  23.         
    

  24.         lcd_draw_rect(30, 40, 150, 100, RED);
    

  25.         lcd_draw_circle(120, 160, 50, BLUE);
    

  26.         lcd_draw_line(30, 40, 180, 140, RED);
    


  27. 

  28.         lcd_draw_line(30, 220, 210, 240, RED);
    

  29.         lcd_draw_line(30, 220, 120, 280, RED);
    

  30.         lcd_draw_line(120, 280, 210, 240, RED);
    


  31. 


  32. 

  33.         lcd_clear_screen(RED);
    

  34.         Delay_ms(300);
    

  35.         lcd_clear_screen(BLUE);
    

  36.         Delay_ms(300);
    

  37.         lcd_clear_screen(YELLOW);
    

  38.         Delay_ms(300);
    

  39.         lcd_clear_screen(BLACK);
    

  40.         Delay_ms(300);
    

  41.         lcd_clear_screen(GRAY);
    

  42.         Delay_ms(300);
    

  43.         lcd_clear_screen(GREEN);
    

  44.         Delay_ms(300);
    

  45.         lcd_clear_screen(WHITE);
    

  46.         Delay_ms(300);
    


  47. 

  48.         lcd_display_string(60, 120, (const uint8_t *)"Hello, world !", FONT_1608, BLUE);
    

  49.   lcd_display_string(30, 152, (const uint8_t *)"2.8' TFT Touch Shield", FONT_1608, RED);
    

  50.         lcd_display_string(30, 152+32, (const uint8_t *)"T want fly high !", FONT_1608, GREEN);
    

  51.   while (1)
    

  52.   {
    

  53. //                AT32_LEDn_Toggle(LED2);
    

  54. //                AT32_LEDn_Toggle(LED3);
    

  55. //                Delay_ms(300);        
    

  56.                 Display_Images();        
    

  57.                 
    

  58.         
    

  59.         }
    

  60. }
编译，下载，查看：
c0 (1).gif
代码(有需要的自取)：
SPI_LCD _FATFS_BMP.rar (5.74 MB, 下载次数: 38)


回复 赏

举报

评论

muyichuan2012
分享的图片无法显示，可否重新上传一下呢？  发表于 2021-3-2 14:46

相关帖子
muyichuan2012 发表于 2021-3-2 13:07 | 显示全部楼层
感谢楼主分享，写的很详细。
回复 赏

举报

 楼主| qjp1988113 发表于 2021-3-2 14:48 | 显示全部楼层
muyichuan2012 发表于 2021-3-2 13:07
感谢楼主分享，写的很详细。

你指什么图片？SD卡里面的BMP图片？？
回复 赏

举报

muyichuan2012 发表于 2021-3-2 15:51 | 显示全部楼层
如图
66.png
回复 赏

举报

 楼主| qjp1988113 发表于 2021-3-2 16:06 | 显示全部楼层
muyichuan2012 发表于 2021-3-2 15:51
如图

https://bbs.21ic.com/data/attach ... llmy1gzt0uwc00w.gif
回复 赏

举报

jinglixixi 发表于 2021-3-2 19:54 | 显示全部楼层
muyichuan2012 发表于 2021-3-2 15:51
如图

查了下记录，明白是什么了。
回复 赏

举报

trucyw 发表于 2021-3-3 08:50 | 显示全部楼层
                             不错
回复 赏

举报

单片小菜 发表于 2021-3-3 12:49 | 显示全部楼层
这个LCD驱动，还是比较实用的。
回复 赏

举报

huangcunxiake 发表于 2021-3-3 13:16 | 显示全部楼层
驱动起来。看看。
回复 赏

举报

goyhuan 发表于 2021-3-3 13:53 | 显示全部楼层
谢谢分享
回复 赏

举报

里面有晴雨 发表于 2021-3-3 15:07 | 显示全部楼层
感谢楼主分享，看一下，确实不错的。
回复 赏

举报

渔夫的烟斗 发表于 2021-3-4 23:02 | 显示全部楼层
有没有引脚连接方式的原理图？
回复 赏

举报

zhouyong77 发表于 2021-3-5 08:14 来自手机 | 显示全部楼层
谢谢楼主分享，看下资料。
回复 赏

举报

 楼主| qjp1988113 发表于 2021-3-5 09:16 | 显示全部楼层
渔夫的烟斗 发表于 2021-3-4 23:02
有没有引脚连接方式的原理图？

LCD.jpg
回复 赏

举报

便携手到老 发表于 2021-3-5 16:24 | 显示全部楼层
这个工程确实不错的，给楼主点个赞，比较好的应用哦。
回复 赏

举报

usysm 发表于 2021-3-6 22:22 | 显示全部楼层
如何在LCD上使bmp图片以指定大小显示？
回复 赏

举报

jkl21 发表于 2021-3-6 22:22 | 显示全部楼层
没有演示吗   
回复 赏

举报

wwppd 发表于 2021-3-6 22:22 | 显示全部楼层
这个FATFS自己移植的吗   
回复 赏

举报

maqianqu 发表于 2021-3-6 22:23 | 显示全部楼层
刷屏的速度怎么样   
回复 赏

举报

dspmana 发表于 2021-3-6 22:26 | 显示全部楼层
移植一个ucgui吧   
回复 赏

举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

qjp1988113

111

主题

627

帖子

2

粉丝
快速回复 返回顶部 返回列表