• (STM32)从零开始的RT-Thread之旅--SPI驱动ST7735(2)

    本篇使用的驱动来自ST官方提供：

    https://github.com/STMicroelectronics/stm32-st7735.git

    需要的可以直接git clone下来移植，核心代码无关芯片型号，可移植性很不错！本篇用的ST7735库比官方新添加了一些内容，是开发板卖家提供的，地址：

    WeActStudio

    第一篇中我们打通了SPI，读取到了芯片ID，这一篇只要完善几个接口函数就可以直接使用官方的驱动库了。至于要完善哪几个接口，需要看一下官方驱动库需要哪些函数。

    1.添加官方源代码

    可以参照我上图的结构把几个源文件添加进去，其中font.h可以在WeAct那个github上找到。

    添加完后记得把头文件路径也包含进去。

    2.官方库使用方法

    在添加完成后，新建lcd相关源文件，比如我的文件结构：

    修改 st7735.h 中一处地方：

    这个变量在st7735.c中被定义。 怎么使用库如下：

    其中ST7735Ctx是库里面定义好的，我们直接使用即可。但是还需要两个变量：

    st7735_pObj就是设备驱动实例，实际在屏幕上显示都是操作的它。关键是st7735_pIO这个变量，它负责提供底层接口。它里面包含的一些函数指针正是我们需要完成的。

    在上一章的基础上，使用了两套SPI使用方式，如果定义 USE_RTT_SPI ，就是用RTT驱动框架提供的SPI接口函数，如果把它注释掉，则直接使用HAL库的SPI函数，具体实现我会附在后面。

    实际我们使用的时候调用的函数是：

    比如要填充整个屏幕为黑色：

    附：

    mspi.c

    1. /*
    2.  * Copyright (c) 2006-2021, RT-Thread Development Team
    3.  *
    4.  * SPDX-License-Identifier: Apache-2.0
    5.  *
    6.  * Change Logs:
    7.  * Date           Author       Notes
    8.  * 2022-11-14     cx       the first version
    9.  */
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include "st7735_reg.h"
    16. #include "st7735.h"
    17.  
    18. #define USE_RTT_SPI
    19.  
    20. SPI_HandleTypeDef *spi_handle;
    21.  
    22. #ifdef USE_RTT_SPI
    23.  
    24. static struct rt_spi_device *spi_lcd;
    25.  
    26. #define LCD_RD_HIGH rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH)
    27. #define LCD_RD_LOW  rt_pin_write(SPI_RD_PIN_NUM, PIN_LOW)
    28. #else
    29. SPI_HandleTypeDef hspi4;
    30. #define SPI_Drv (&hspi4)
    31. #define LCD_CS_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_SET)
    32. #define LCD_CS_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_RESET)
    33.  
    34. #define LCD_RD_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET)
    35. #define LCD_RD_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_RESET)
    36. #endif
    37.  
    38. #ifdef USE_RTT_SPI
    39. int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
    40. {
    41.     struct rt_spi_message msg;
    42.     uint32_t remsg = RT_NULL;
    43.     msg.send_buf = ®
    44.     msg.recv_buf = RT_NULL;
    45.     msg.length = 1;
    46.     msg.cs_take = 1;
    47.     msg.cs_release = 0;
    48.     msg.next = RT_NULL;
    49.     LCD_RD_LOW;
    50.     remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    51.     LCD_RD_HIGH;
    52.     if(len > 0)
    53.     {
    54.         msg.send_buf = data;
    55.         msg.recv_buf = RT_NULL;
    56.         msg.length = len;
    57.         msg.cs_take = 0;
    58.         msg.cs_release = 1;
    59.         msg.next = RT_NULL;
    60.         remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    61.     }
    62.     if(remsg!=RT_NULL)
    63.         return -1;
    64.     else
    65.         return 0;
    66. }
    67. int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
    68. {
    69.     struct rt_spi_message msg;
    70.     uint32_t remsg = RT_NULL;
    71.     uint8_t reg1 = reg;
    72.     msg.send_buf = ®1;
    73.     msg.recv_buf = RT_NULL;
    74.     msg.length = 1;
    75.     msg.cs_take = 1;
    76.     msg.cs_release = 0;
    77.     msg.next = RT_NULL;
    78.     LCD_RD_LOW;
    79.     remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    80.     LCD_RD_HIGH;
    81.     if(remsg == 0)
    82.     {
    83.         msg.send_buf = RT_NULL;
    84.         msg.recv_buf = data;
    85.         msg.length = 1;
    86.         msg.cs_take = 0;
    87.         msg.cs_release = 1;
    88.         msg.next = RT_NULL;
    89.         remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    90.     }
    91.     if(remsg!=RT_NULL)
    92.         return -1;
    93.     else
    94.         return 0;
    95. }
    96. int32_t mspi_send_data(uint8_t *data,uint32_t len)
    97. {
    98.     struct rt_spi_message msg;
    99.     msg.send_buf = data;
    100.     msg.recv_buf = RT_NULL;
    101.     msg.length = len;
    102.     msg.cs_take = 1;
    103.     msg.cs_release = 1;
    104.     msg.next = RT_NULL;
    105.     return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    106. }
    107. int32_t mspi_read_data(uint8_t *data,uint32_t len)
    108. {
    109.     struct rt_spi_message msg;
    110.     msg.send_buf = RT_NULL;
    111.     msg.recv_buf = data;
    112.     msg.length = len;
    113.     msg.cs_take = 1;
    114.     msg.cs_release = 1;
    115.     msg.next = RT_NULL;
    116.     return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    117. }
    118.  
    119. #else
    120. int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
    121. {
    122.     int32_t result;
    123.     LCD_CS_LOW;
    124.     LCD_RD_LOW;
    125.     result = HAL_SPI_Transmit(SPI_Drv,®,1,100);
    126.     LCD_RD_HIGH;
    127.     if(len > 0)
    128.         result += HAL_SPI_Transmit(SPI_Drv,data,len,500);
    129.     LCD_CS_HIGH;
    130.     if(result>0){
    131.         result = -1;}
    132.     else{
    133.         result = 0;}
    134.     return result;
    135. }
    136.  
    137. int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
    138. {
    139.     int32_t result;
    140.     LCD_CS_LOW;
    141.     LCD_RD_LOW;
    142.  
    143.     result = HAL_SPI_Transmit(SPI_Drv,®,1,100);
    144.     LCD_RD_HIGH;
    145.     result += HAL_SPI_Receive(SPI_Drv,data,1,500);
    146.     LCD_CS_HIGH;
    147.     if(result>0){
    148.         result = -1;}
    149.     else{
    150.         result = 0;}
    151.     return result;
    152. }
    153.  
    154. int32_t mspi_send_data(uint8_t *data,uint32_t len)
    155. {
    156.     int32_t result;
    157.     LCD_CS_LOW;
    158.     //LCD_RD_HIGH;
    159.     result =HAL_SPI_Transmit(SPI_Drv,data,len,100);
    160.     LCD_CS_HIGH;
    161.     if(result>0){
    162.         result = -1;}
    163.     else{
    164.         result = 0;}
    165.     return result;
    166. }
    167.  
    168. int32_t mspi_read_data(uint8_t *data,uint32_t len)
    169. {
    170.     int32_t result;
    171.     LCD_CS_LOW;
    172.     //LCD_RD_HIGH;
    173.     result = HAL_SPI_Receive(SPI_Drv,data,len,500);
    174.     LCD_CS_HIGH;
    175.     if(result>0){
    176.         result = -1;}
    177.     else{
    178.         result = 0;}
    179.     return result;
    180. }
    181. #endif
    182. int32_t mspi_get_tick(void)
    183. {
    184.     return HAL_GetTick();
    185. }
    186. void mspi_rw_gpio_init(void)
    187. {
    188. #ifdef USE_RTT_SPI
    189.     rt_pin_mode(SPI_RD_PIN_NUM, PIN_MODE_OUTPUT);
    190.     rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH);
    191. #else
    192.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    193.     __HAL_RCC_GPIOE_CLK_ENABLE();
    194.     HAL_GPIO_WritePin(GPIOE, GPIO_PIN_11|GPIO_PIN_13, GPIO_PIN_SET);
    195.     GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_13;
    196.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    197.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    198.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    199.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
    200. #endif
    201. }
    202. void mspi_init(void)
    203. {
    204.     mspi_rw_gpio_init();
    205. #ifdef USE_RTT_SPI
    206.     struct rt_spi_configuration cfg;
    207.     rt_hw_spi_device_attach("spi4", "spi40", GPIOE, GPIO_PIN_11);
    208.     spi_lcd = (struct rt_spi_device *)rt_device_find("spi40");
    209.     if(!spi_lcd)
    210.     {
    211.         rt_kprintf("spi40 can't find\n");
    212.     }
    213.     else
    214.     {
    215.         spi_lcd->bus->owner = spi_lcd;
    216.         cfg.data_width = 8;
    217.         cfg.mode = RT_SPI_MASTER | RT_SPI_3WIRE | RT_SPI_MODE_0 | RT_SPI_MSB;
    218.         cfg.max_hz = 12.5 * 1000 * 1000;
    219.         rt_spi_configure(spi_lcd, &cfg);
    220.     }
    221.     //也可以初始化使用框架提供的函数，发送接收使用HAL库函数，操作对象就是下面的 spi_handle
    222. //    struct stm32_spi *spi_drv =  rt_container_of(spi_lcd->bus, struct stm32_spi, spi_bus);
    223. //    spi_handle = &spi_drv->handle;
    224. #else
    225.     hspi4.Instance = SPI4;
    226.     hspi4.Init.Mode = SPI_MODE_MASTER;
    227.     hspi4.Init.Direction = SPI_DIRECTION_1LINE;
    228.     hspi4.Init.DataSize = SPI_DATASIZE_8BIT;
    229.     hspi4.Init.CLKPolarity = SPI_POLARITY_LOW;
    230.     hspi4.Init.CLKPhase = SPI_PHASE_1EDGE;
    231.     hspi4.Init.NSS = SPI_NSS_SOFT;
    232.     hspi4.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
    233.     hspi4.Init.FirstBit = SPI_FIRSTBIT_MSB;
    234.     hspi4.Init.TIMode = SPI_TIMODE_DISABLE;
    235.     hspi4.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    236.     hspi4.Init.CRCPolynomial = 0x0;
    237.     hspi4.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
    238.     hspi4.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
    239.     hspi4.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
    240.     hspi4.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    241.     hspi4.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    242.     hspi4.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
    243.     hspi4.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
    244.     hspi4.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
    245.     hspi4.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
    246.     hspi4.Init.IOSwap = SPI_IO_SWAP_DISABLE;
    247.     if (HAL_SPI_Init(&hspi4) != HAL_OK)
    248.     {
    249.       rt_kprintf("ERROR\n");
    250.     }
    251. #endif
    252. }
    253.

    mlcd.c

    1. /*
    2.  * Copyright (c) 2006-2021, RT-Thread Development Team
    3.  *
    4.  * SPDX-License-Identifier: Apache-2.0
    5.  *
    6.  * Change Logs:
    7.  * Date           Author       Notes
    8.  * 2022-11-15     cx       the first version
    9.  */
    10. #include 
    11. #include 
    12. #include 
    13. #define DBG_TAG "mlcd"
    14. #define DBG_LVL DBG_LOG
    15. #include 
    16. #include "mpwm.h"
    17. #include "mspi.h"
    18. #include "st7735_reg.h"
    19. #include "st7735.h"
    20. #include "mlcd.h"
    21. #include "font.h"
    22. #include 
    23.  
    24. int32_t mlcd_st7735_init(void);
    25.  
    26. ST7735_IO_t st7735_pIO = {
    27.     mlcd_st7735_init,
    28.     NULL,
    29.     0,
    30.     mspi_send_reg,
    31.     mspi_read_reg,
    32.     mspi_send_data,
    33.     mspi_read_data,
    34.     mspi_get_tick
    35. };
    36.  
    37. ST7735_Object_t st7735_pObj;
    38.  
    39. int32_t mlcd_st7735_init(void)
    40. {
    41.     int32_t result = ST7735_OK;
    42.     mpwm_init();
    43.     mspi_init();
    44.     return result;
    45. }
    46.  
    47. int mlcd_init(void)
    48. {
    49.     uint32_t st7735_id;
    50.     uint8_t text[50];
    51.     #ifdef TFT96
    52.     ST7735Ctx.Orientation = ST7735_ORIENTATION_LANDSCAPE_ROT180;
    53.     ST7735Ctx.Panel = HannStar_Panel;
    54.     ST7735Ctx.Type = ST7735_0_9_inch_screen;
    55.     #elif TFT18
    56.     ST7735Ctx.Orientation = ST7735_ORIENTATION_PORTRAIT;
    57.     ST7735Ctx.Panel = BOE_Panel;
    58.     ST7735Ctx.Type = ST7735_1_8_inch_screen;
    59.     #else
    60.     LOG_E("Unknown Screen");
    61.     #endif
    62.     ST7735_RegisterBusIO(&st7735_pObj,&st7735_pIO);
    63.     ST7735_LCD_Driver.Init(&st7735_pObj,ST7735_FORMAT_RBG565,&ST7735Ctx);
    64.     ST7735_LCD_Driver.ReadID(&st7735_pObj,&st7735_id);
    65.     rt_kprintf("LCD ID:%08X\n",st7735_id);
    66.  
    67.     ST7735_LCD_Driver.FillRect(&st7735_pObj, 0, 0, ST7735Ctx.Width,ST7735Ctx.Height, BLACK);
    68.  
    69.     sprintf((char *)&text, "Something V1.0");
    70.     LCD_ShowString(4, 4, ST7735Ctx.Width, 16, 16, text);
    71.  
    72.     return 0;
    73. }
    74.  
    75. uint16_t POINT_COLOR=0xFFFF;    //画笔颜色
    76. uint16_t BACK_COLOR=BLACK;  //背景色
    77. //在指定位置显示一个字符
    78. //x,y:起始坐标
    79. //num:要显示的字符:" "--->"~"
    80. //size:字体大小 12/16
    81. //mode:叠加方式(1)还是非叠加方式(0)
    82.  
    83. void LCD_ShowChar(uint16_t x,uint16_t y,uint8_t num,uint8_t size,uint8_t mode)
    84. {
    85.   uint8_t temp,t1,t;
    86.     uint16_t y0=y;
    87.     uint16_t x0=x;
    88.     uint16_t colortemp=POINT_COLOR;
    89.   uint32_t h,w;
    90.  
    91.     uint16_t write[size][size==12?6:8];
    92.     uint16_t count;
    93.  
    94.   ST7735_GetXSize(&st7735_pObj,&w);
    95.     ST7735_GetYSize(&st7735_pObj,&h);
    96.  
    97.     //设置窗口
    98.     num=num-' ';//得到偏移后的值
    99.     count = 0;
    100.  
    101.     if(!mode) //非叠加方式
    102.     {
    103.         for(t=0;t
    104.         {
    105.             if(size==12)temp=asc2_1206[num][t];  //调用1206字体
    106.             else temp=asc2_1608[num][t];         //调用1608字体
    107.  
    108.             for(t1=0;t1<8;t1++)
    109.             {
    110.                 if(temp&0x80)
    111.                     POINT_COLOR=(colortemp&0xFF)<<8|colortemp>>8;
    112.                 else
    113.                     POINT_COLOR=(BACK_COLOR&0xFF)<<8|BACK_COLOR>>8;
    114.  
    115.                 write[count][t/2]=POINT_COLOR;
    116.                 count ++;
    117.                 if(count >= size) count =0;
    118.  
    119.                 temp<<=1;
    120.                 y++;
    121.                 if(y>=h){POINT_COLOR=colortemp;return;}//超区域了
    122.                 if((y-y0)==size)
    123.                 {
    124.                     y=y0;
    125.                     x++;
    126.                     if(x>=w){POINT_COLOR=colortemp;return;}//超区域了
    127.                     break;
    128.                 }
    129.             }
    130.         }
    131.     }
    132.     else//叠加方式
    133.     {
    134.         for(t=0;t
    135.         {
    136.             if(size==12)temp=asc2_1206[num][t];  //调用1206字体
    137.             else temp=asc2_1608[num][t];         //调用1608字体
    138.             for(t1=0;t1<8;t1++)
    139.             {
    140.                 if(temp&0x80)
    141.                     write[count][t/2]=(POINT_COLOR&0xFF)<<8|POINT_COLOR>>8;
    142.                 count ++;
    143.                 if(count >= size) count =0;
    144.  
    145.                 temp<<=1;
    146.                 y++;
    147.                 if(y>=h){POINT_COLOR=colortemp;return;}//超区域了
    148.                 if((y-y0)==size)
    149.                 {
    150.                     y=y0;
    151.                     x++;
    152.                     if(x>=w){POINT_COLOR=colortemp;return;}//超区域了
    153.                     break;
    154.                 }
    155.             }
    156.         }
    157.     }
    158.     ST7735_FillRGBRect(&st7735_pObj,x0,y0,(uint8_t *)&write,size==12?6:8,size);
    159.     POINT_COLOR=colortemp;
    160. }
    161.  
    162. //显示字符串
    163. //x,y:起点坐标
    164. //width,height:区域大小
    165. //size:字体大小
    166. //*p:字符串起始地址
    167. void LCD_ShowString(uint16_t x,uint16_t y,uint16_t width,uint16_t height,uint8_t size,uint8_t *p)
    168. {
    169.     uint8_t x0=x;
    170.     width+=x;
    171.     height+=y;
    172.     while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
    173.     {
    174.         if(x>=width){x=x0;y+=size;}
    175.         if(y>=height)break;//退出
    176.         LCD_ShowChar(x,y,*p,size,0);
    177.         x+=size/2;
    178.         p++;
    179.     }
    180. }
    181.  
    182.  
    183.  
    184.  
    185.  
    186.  
    187.  
    188.  
    189.  
    190.  
    191.  
    192.

  • 相关阅读:
    系统架构设计师-第13章-层次式架构设计理论与实践-软考学习笔记
    题目 1074: 数字整除
    qml保姆级教程四:按钮组件
    高优先线程
    Laravel Routes Group-Prefix 使用变量问题
    AI模型精确解析果蝇行为，未来或可预测人类行为
    JaVers：自动化数据审计
    Java阻塞队列中的异类，SynchronousQueue底层实现原理剖析
    Java集合知识点
    android 解决AVC问题
  • 原文地址：https://blog.csdn.net/qwe5959798/article/details/127924308