21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 硬件SPI——驱动LCD屏的一些尝试
返回列表 发新帖我要提问

[AT32F4212] 硬件SPI——驱动LCD屏的一些尝试

[复制链接]
4593|19
楼主
 楼主| 呐咯密密 发表于 2024-3-1 10:03 | 只看该作者 |只看大图 |倒序浏览 |阅读模式
spi, pi, lcd屏, LCD, CD
总感觉之前的AT32F421板子/片子 有点小毛病，出各种莫名其妙的BUG（实在找不出软件的问题，只能怀疑是硬件 QAQ）。

于是之后咕了很久，最近终于想继续折腾，拿AT32F435画了一块LCD驱动板，准备入坑LVGL。板上资源就一块某园的2.8存240x320带电阻膜的LCD屏、触摸IC用XPT2046，另外还画了一片W25Q64和CH340在上面，有空试试QSPI和ISP功能。

画板子的时候就在思考这个问题：

XPT2046 和 LCD(ST7789) 到底要不要共用1个SPI接口？

之前画过一个小的实验板参照LCD厂家提供的手册上的画法，LCD和XPT2046共用一个SPI。其中有一个我不理解的地方，那就是LCD明明不会发送数据（难道不是这样？），但是却有一个数据引脚SDD，在没有触摸IC的应用中，该引脚悬空；在有XPT2046的应用中，厂家的手册上推荐把该引脚同XPT2046的MISO（同时也是单片机的SPI输入引脚）相连。

这真的是必要的吗？为什么需要用4根线来驱动一个LCD，即使它不可能知道外部有没有触摸IC的存在？

于是新板子上我尝试了以下方法：

双线双工，和XPT2046共用SPI，软件管理CS
双线双工，单独使用一个SPI，硬件管理CS
双线双工，单独使用一个SPI，软件管理CS
单线半双工，单独使用一个SPI，硬件管理CS
基于几个基本逻辑：节约CPU资源：只要不是共用SPI，就用硬件CS；节约引脚：只要没有用到数据输入，就不使用双线双工。因此这里面合理的选项只有1和4。另外，只要和触摸IC共用SPI，就不得不用到MISO，且“一主多从”只支持软件CS。

1在之前的小板上就已经实现过了，但是觉得在IO资源足够的情况下，还是应当以节约CPU资源为主，所以舍弃了软件CS，想试试方法4：在LCD不与XPT2046共用SPI的时候，仅使用 SCLK, MOSI, CS(硬件控制) 3根线来驱动LCD。

然后理所当然的踩了一堆坑。。。调的头都要秃了，在此记录一下。

关于AT32F435开启单线半双工模式
刚开始我以为只要在 spi_init_struct 中配置下面这一项：
    spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
然后 在spi_init() 函数里传进去就够了，结果代码都运行了，没有任何现象，检查走信号的GPIO，初始化后只能看到有一点点毛刺。这种情况通常可能是

GPIO时钟没使能
SPI时钟没使能
SPI没使能
然而负责这三行代码都执行过了，怎么出的问题？

检查寄存器的时候才发现，每当我初始化SPI设置后、执行 spi_enable() 去使能SPI时，STS寄存器蹦出一个MMERR（主模式错误），同时把我的模式改成了从模式，还关掉了我的SPI使能。

查了AT的RM，上面也没说什么情况下会触发MMERR，仔细检查RM提供的信息，总结了下面几点：

单线半双工模式下ctrl1_bit.slben将使能，并且ctrl1_bit.slbtd决定是发还是收；
主模式下 ctrl1_bit.swcsil 必须置位；
ctrl2_bit.hwcsoe 在做主设备时，如果置位，测CS输出低电平；如果清零，必须保证CS电平为高电平。
事实上对于第一项，如果设置了SPI_TRANSMIT_HALF_DUPLEX_TX，则在spi_init()中这两个bit会被配置完成。第二项只有在使用软件CS时才有用。所以最后证明是 hwcsoe 背大锅。。。

RM表示 ctrl2_bit.hwcsoe 是一个 rw 位，它的名字虽然叫硬件CS使能，但描述的功能不像是使能，却像是在用软件控制CS啊？！

所以我只好在spi_enable()前加上把这一位置1的命令。结果就没有MMERR了。

遂舍弃方法4，为了继续追求硬件CS，只能尝试方法2
关于硬件管理CS

在单线半双工下通过 ctrl2_bit.hwcsoe=1 开启硬件CS输出使能，导致的结果就是 spi使能后 全过程 CS一直为低电平。

查看RM：

当 SPI 作主机，硬件 CS 输出时，HWCSOE 位置 1，SWCSEN 置 0，开启硬件 CS 控制，SPI 在使能之后会在 CS 管脚上输出低电平，在 SPI 关闭并且发送完成后，释放 CS 信号。

RM表示：一直开着CS有啥不好？反正你都只有这一个从设备了。你要是想发完一个frame就关CS，那你直接把SPI关了不就o了？


属于又颠覆我对SPI的认知了。这个 ctrl2_bit.hwcsoe()主要是为 MCU做从设备，拿来检测是否被片选用的；如果是做主机，那它就会一直把CS拉低。


然而有的SPI从设备会在CS的上下沿完成锁存等操作，甚至在时序要求里对CS的拉低、释放时间有具体的要求，比如下图

如上图，AD9833对CS的时序有一个最小setup time (t7)和最小hold time (t8)，甚至t8还有一个最大值要求：不能超过t4-5ns。总之需要只在每一个数据帧传输的时候拉低CS，而之后要能迅速释放。


不死心的我仍决定尝试在每发送完一个帧后关掉SPI，实现SPI通信的代码变成这个样子：

果令人失望，没能成功点屏。其中很令人在意的一点就是尽管硬件CS拉低很迅速，但释放（通过失能SPI实现）的速度非常慢，过程持续了百微妙级别：关掉SPI后CS信号的样子是典型RC充电曲线的形状。这就导致了在连续传输数据帧的时候，上一帧的CS根本没来得及完全释放，就马上被下一帧拉低了。


总之，硬件管理CS的尝试算是彻底失败了——因为硬件CS做不到只在一个数据帧传输的时候拉低CS。


如果干脆始终拉低CS，我也做了尝试，结果不行。怀疑是过早拉低CS导致多识别了一个时钟沿导致，我尝试了两种SPI时钟相位和两种SPI时钟空闲电平的4种组合。。，都不行。但是作为对照组，仅仅把CS改成软件管理，其余设置不变，就能在时钟POL=HIGH, PHA=2EDGE的组合下成功点屏。


所以排除时钟相位问题后，结论只能是LCD的驱动芯片需要每帧数据结束后CS的上升沿完成某些操作。


所以底层硬件就决定了即便该LCD单独使用一个SPI驱动，也不可能是单线半双工模式实现——因为它只支持硬件管理CS，而硬件管理CS又不能满足CS的时序要求。


那么答案只有一个，变成软件管理CS，MCU直接控制GPIO在每一帧数据结束后拉高CS。即上文的方法2同样不可行，只能改成方法3。那反正都软件管理CS了，干脆和触摸IC共用一个SPI得了，所以最后还是老老实实回到方法1。。


碎碎念：仔细想想，其实LCD的另一些控制信号如RST, DC 后者几乎快和CS一样常用,都只能靠软件实现。所以也许我真的不应该追求硬件CS？


我当前的GCC编译优化为O0，CPU主频288M，SPI通信用8分频（APB的144M / 8 = 18M），在这个速度下，实测方法2中一个8bit数据帧传输<500ns，最后一个时钟结束后约100ns 近300ns（用上图中的代码）CS被拉高，CS高电平又持续了近300ns（这个过程完成了DC的拉高，以及MCU数据搬运），然后CS进入下一帧的拉低，拉低后又是约300ns，才开始下一帧的数据传输。


回复

收藏 举报

相关帖子
沙发
 楼主| 呐咯密密 发表于 2024-3-1 10:05 | 只看该作者
后续优化了代码，所有图像输出均由DMA完成。

并尝试运行了LVGL demo：

复制
  1. #include "ST7789.h"
    

  2.  
    

  3. void LCD_GPIO_init(void)
    

  4. {
    

  5. #if LCD_USE_HARDWARE_SPI == 1
    

  6.  
    

  7.     gpio_init_type gpio_init_struct;
    

  8.  
    

  9.     // =========================> 初始化 SPI数据总线 GPIO <=========================
    

  10.     crm_periph_clock_enable(LCD_SPIx_GPIO_CRM, TRUE);
    

  11.  
    

  12.     gpio_default_para_init(&gpio_init_struct);
    

  13.  
    

  14.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    

  15.     gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
    

  16.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  17.     // SCLK
    

  18.     gpio_init_struct.gpio_pull = GPIO_PULL_DOWN;
    

  19.     gpio_init_struct.gpio_pins = LCD_SPIx_SCLK_GPIO_PIN;
    

  20.     gpio_init(LCD_SPIx_GPIO, &gpio_init_struct);
    

  21.     gpio_pin_mux_config(LCD_SPIx_GPIO, LCD_SPIx_SCLK_SOURCE, LCD_SPIx_MUX_SEL);
    

  22.  
    

  23.     // MOSI
    

  24.     gpio_init_struct.gpio_pull = GPIO_PULL_UP;
    

  25.     gpio_init_struct.gpio_pins = LCD_SPIx_MOSI_GPIO_PIN;
    

  26.     ;
    

  27.     gpio_init(LCD_SPIx_GPIO, &gpio_init_struct);
    

  28.     gpio_pin_mux_config(LCD_SPIx_GPIO, LCD_SPIx_MOSI_SOURCE, LCD_SPIx_MUX_SEL);
    

  29.  
    

  30. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  31.     // LCD和触摸IC共用SPI，CS由软件管理，此处不作配置
    

  32.     // 由于要接收触摸IC的数据，需要配置MISO，注意XPT2046的数据输出引脚外部不能上拉或下拉，只能配置成浮空输入
    

  33.     gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    

  34.     gpio_init_struct.gpio_pins = LCD_SPIx_MISO_GPIO_PIN;
    

  35.     gpio_init(LCD_SPIx_GPIO, &gpio_init_struct);
    

  36.     gpio_pin_mux_config(LCD_SPIx_GPIO, LCD_SPIx_MISO_SOURCE, LCD_SPIx_MUX_SEL);
    

  37. #else
    

  38.     // LCD单独使用SPI，无需配置MISO，并且为硬件管理CS，
    

  39.     gpio_init_struct.gpio_pull = GPIO_PULL_UP;
    

  40.     gpio_init_struct.gpio_pins = LCD_SPIx_CS_GPIO_PIN;
    

  41.     gpio_init(LCD_SPIx_GPIO, &gpio_init_struct);
    

  42.     gpio_pin_mux_config(LCD_SPIx_GPIO, LCD_SPIx_CS_SOURCE, LCD_SPIx_MUX_SEL);
    

  43. #endif
    

  44.  
    

  45.     // =========================> 初始化其余信号线的GPIO <=========================
    

  46.     crm_periph_clock_enable(LCD_GPIOPORT_CRM, TRUE);
    

  47.  
    

  48.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  49.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    

  50.     gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    

  51.     gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    

  52.  
    

  53. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  54.     // LCD和触摸IC共用SPI，CS由MCU直接控制GPIO实现
    

  55.     gpio_init_struct.gpio_pins = LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK | LCD_PINS_CS;
    

  56.     gpio_init(LCD_GPIOPORT, &gpio_init_struct);
    

  57.     gpio_bits_set(LCD_GPIOPORT, LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK | LCD_PINS_CS);
    

  58. #else
    

  59.     // LCD单独使用SPI，CS已经由硬件实现，此处不作配置
    

  60.     #error "Hardware CS is is a piece of shit, DO NOT try!"
    

  61.     gpio_init_struct.gpio_pins = LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK;
    

  62.     gpio_init(LCD_GPIOPORT, &gpio_init_struct);
    

  63.     gpio_bits_set(LCD_GPIOPORT, LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK);
    

  64. #endif
    

  65.  
    

  66. #else
    

  67.     // 使用软件SPI 且必定共用一个SPI
    

  68.     crm_periph_clock_enable(LCD_GPIOPORT_CRM, TRUE);
    

  69.  
    

  70.     gpio_init_type gpio_init_struct;
    

  71.     gpio_default_para_init(&gpio_init_struct);
    

  72.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  73.     gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    

  74.     gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    

  75.     gpio_init_struct.gpio_pins = LCD_PINS_SCLK | LCD_PINS_MOSI | LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK | LCD_PINS_CS;
    

  76.     gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    

  77.  
    

  78.     gpio_init(LCD_GPIOPORT, &gpio_init_struct);
    

  79.  
    

  80.     gpio_bits_set(LCD_GPIOPORT, LCD_PINS_SCLK | LCD_PINS_MOSI | LCD_PINS_RST | LCD_PINS_DC | LCD_PINS_BLK | LCD_PINS_CS);
    

  81. #endif
    

  82. }
    

  83.  
    

  84. #if LCD_USE_HARDWARE_SPI == 1 && LCD_HARDWARE_SPI_USE_DMA == 0
    

  85.  
    

  86. /**
    

  87.  
    

  88.   * [url=home.php?mod=space&uid=247401]@brief[/url]  spi configuration.
    

  89.   * @param  none
    

  90.   * @retval none
    

  91.   */
    

  92. void LCD_SPIx_init(void)
    

  93. {
    

  94.     spi_init_type spi_init_struct;
    

  95.  
    

  96.     spi_i2s_reset(LCD_SPIx);
    

  97.     crm_periph_clock_enable(LCD_SPIx_CRM, TRUE);
    

  98.     spi_default_para_init(&spi_init_struct);
    

  99.     spi_init_struct.master_slave_mode = SPI_MODE_MASTER;        // 设置SPI工作模式：主机模式
    

  100.     spi_init_struct.mclk_freq_division = LCD_SPI_SPEED;        // 288M / 8 = 36M
    

  101.     spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB; // 数据传输高位先行
    

  102.     spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;             // 设置SPI数据大小：8位帧结构
    

  103.     spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_HIGH;   // 串行同步时钟空闲时SCLK位高电平
    

  104. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  105.     spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;        // 串行同步时钟空第二个时钟沿捕获
    

  106.     spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX; // 要接收触模信息所以是全双工
    

  107.     spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;     // 片选信号由软件管理
    

  108. #else
    

  109.     spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;        // 串行同步时钟空第二个时钟沿捕获
    

  110.     spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX; // LCD只接收信息所以是单工
    

  111.     spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;        // 片选信号由硬件管理
    

  112.     #error "Hardware CS is is a piece of shit, DO NOT try!"
    

  113.     spi_hardware_cs_output_enable(LCD_SPIx, TRUE);
    

  114. #endif
    

  115.     spi_init(LCD_SPIx, &spi_init_struct);
    

  116.     spi_enable(LCD_SPIx, TRUE);
    

  117. }
    

  118.  
    

  119.  
    

  120.  
    

  121. #elif LCD_HARDWARE_SPI_USE_DMA == 1
    

  122.  
    

  123. // uint16_t LCD_SPIx_TX_buffer[LCD_SPI_TX_BUFFER_SIZE];
    

  124. // #if (LCD_SHARE_SPI_WITH_TOUCH_IC == 1)
    

  125. // uint16_t LCD_SPIx_RX_buffer[LCD_SPI_RX_BUFFER_SIZE];
    

  126. // #endif
    

  127.  
    

  128. void LCD_SPIx_init(void)
    

  129. {
    

  130.  
    

  131.     dma_init_type dma_init_struct;
    

  132.     spi_init_type spi_init_struct;
    

  133.     
    

  134.     /************** DMA 配置 *****************/
    

  135.  
    

  136.     /* LCD_SPI_TX_DMAx_CHy configuration */
    

  137.     // 时钟配置
    

  138.     crm_periph_clock_enable(LCD_SPI_TX_DMAx_CRM_CLOCK, TRUE);
    

  139.     dma_reset(LCD_SPI_TX_DMAx_CHy);
    

  140.     // DMA MUX 通道配置
    

  141.     dmamux_enable(LCD_SPI_TX_DMAx, TRUE);
    

  142.     dmamux_init(LCD_SPI_TX_DMAxMUX_CHy, LCD_SPI_TX_DMAMUX_REQ_ID);
    

  143.     // DMA 通道配置
    

  144.     dma_default_para_init(&dma_init_struct);
    

  145.     dma_init_struct.buffer_size = LCD_SPI_TX_BUFFER_SIZE;
    

  146.     dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
    

  147.     // dma_init_struct.memory_base_addr = (uint32_t)LCD_SPIx_TX_buffer;
    

  148.     dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
    

  149.     dma_init_struct.memory_inc_enable = TRUE;
    

  150.     dma_init_struct.peripheral_base_addr = (uint32_t)&(LCD_SPIx->dt);
    

  151.     // dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE; // 如果 MWIDTH 是16bit，但 PWIDTH 是8bit，方向是M2P，那么DMA只会搬运存MEM中每个半字的低8位，也即低地址处的字节。
    

  152.     dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
    

  153.     dma_init_struct.peripheral_inc_enable = FALSE;
    

  154.     dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
    

  155.     dma_init_struct.loop_mode_enable = FALSE; //是否循环模式
    

  156.     dma_init(LCD_SPI_TX_DMAx_CHy, &dma_init_struct);
    

  157.  
    

  158.     #if (LCD_SHARE_SPI_WITH_TOUCH_IC == 1)
    

  159.     /* LCD_SPI_TX_DMAx_CHy configuration */
    

  160.     // DMA MUX 通道配置
    

  161.     dmamux_init(LCD_SPI_RX_DMAxMUX_CHy, LCD_SPI_RX_DMAMUX_REQ_ID);
    

  162.     // DMA 通道配置
    

  163.     dma_default_para_init(&dma_init_struct);
    

  164.     dma_init_struct.buffer_size = LCD_SPI_RX_BUFFER_SIZE;
    

  165.     dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
    

  166.     // dma_init_struct.memory_base_addr = (uint32_t)LCD_SPIx_RX_buffer;
    

  167.     dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
    

  168.     dma_init_struct.memory_inc_enable = TRUE;
    

  169.     dma_init_struct.peripheral_base_addr = (uint32_t)&(LCD_SPIx->dt);
    

  170.     dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    

  171.     dma_init_struct.peripheral_inc_enable = FALSE;
    

  172.     dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
    

  173.     dma_init_struct.loop_mode_enable = FALSE; //是否循环模式
    

  174.     dma_init(LCD_SPI_RX_DMAx_CHy, &dma_init_struct);
    

  175.     #else
    

  176.     // 不需要 RX buffer 和 RX DMA
    

  177.     #endif
    

  178.  
    

  179.     /************** SPI 配置 *****************/
    

  180.  
    

  181.     crm_periph_clock_enable(LCD_SPIx_CRM, TRUE);
    

  182.     spi_default_para_init(&spi_init_struct);
    

  183.     #if (LCD_SHARE_SPI_WITH_TOUCH_IC == 1)
    

  184.     spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
    

  185.     #else
    

  186.     spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
    

  187.     #endif
    

  188.     spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
    

  189.     spi_init_struct.mclk_freq_division = LCD_SPI_SPEED;
    

  190.     spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
    

  191.     spi_init_struct.frame_bit_num = SPI_FRAME_16BIT;
    

  192.     spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_HIGH;
    

  193.     spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
    

  194.     spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
    

  195.  
    

  196.     spi_init(LCD_SPIx, &spi_init_struct);
    

  197.     spi_i2s_dma_transmitter_enable(LCD_SPIx, TRUE);
    

  198.     // spi_i2s_dma_receiver_enable(LCD_SPIx,TRUE);
    

  199.     spi_enable(LCD_SPIx, TRUE);
    

  200.  
    

  201.     #if (LCD_HARDWARE_SPI_TX_DMA_USE_INT == 1)
    

  202.     //中断配置
    

  203.     nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
    

  204.  
    

  205.     /* enable transfer full data intterrupt 当数据全部发送完毕后产生中断*/
    

  206.     dma_interrupt_enable(LCD_SPI_TX_DMAx_CHy, DMA_FDT_INT, TRUE);
    

  207.     /* LCD_SPI_TX_DMAx_CHy interrupt nvic init */
    

  208.     nvic_irq_enable(LCD_SPI_TX_DMAx_CHy_IRQn, 5, 0);
    

  209.     /* config flexible dma for LCD_SPI_TX_DMAxMUX_CHy 配置弹性映射 */
    

  210.     dma_flexible_config(LCD_SPI_TX_DMAx, LCD_SPI_TX_DMAxMUX_CHy, LCD_SPI_TX_DMAMUX_REQ_ID);
    

  211.  
    

  212.     #if (LCD_SHARE_SPI_WITH_TOUCH_IC == 1)
    

  213.     /* enable transfer full data intterrupt 当数据全部发送完毕后产生中断*/
    

  214.     dma_interrupt_enable(LCD_SPI_RX_DMAx_CHy, DMA_FDT_INT, TRUE);
    

  215.     /* LCD_SPI_RX_DMAx_CHy interrupt nvic init */
    

  216.     nvic_irq_enable(LCD_SPI_RX_DMAx_CHy_IRQn, 3, 0);
    

  217.     /* config flexible dma for LCD_SPI_RX_DMAxMUX_CHy 配置弹性映射 */
    

  218.     dma_flexible_config(LCD_SPI_TX_DMAx, LCD_SPI_RX_DMAxMUX_CHy, LCD_SPI_RX_DMAMUX_REQ_ID);
    

  219.     #endif
    

  220.     #endif
    

  221.     
    

  222. }
    

  223.  
    

  224. /**
    

  225.   * @brief  data transfer to LCD_SPIx using DMA
    

  226.   * @param  buf : buffer address
    

  227.   * @param  size : this uint32_t value should be less than 65535. Or otherwise size%0xFFFF is what finally takes effect.
    

  228.   * @retval none
    

  229.   */
    

  230. void LCD_SPI_data_send_use_DMA(const void *buf, uint32_t size)
    

  231. {
    

  232.     #if (LCD_HARDWARE_SPI_TX_DMA_USE_INT == 1)
    

  233.     // 在使用 SPI TX DMA 中断的情况下，如果此时DMA还在搬运，那么应该等DMA中断服务程序结束后再向DMA发送新的buf和size，否则DMA传输中断，屏幕收到数据不完整
    

  234.     if (LCD_SPI_TX_DMAx_CHy->ctrl_bit.chen == 1)
    

  235.     {
    

  236.         __WFI();
    

  237.     }
    

  238.     #endif
    

  239.     // 确保 LCD_SPIx 为16bit传输模式 且 频率为初始设定频率
    

  240.     if(LCD_SPIx->ctrl1_bit.fbn == SPI_FRAME_8BIT || LCD_SPIx->ctrl1_bit.mdiv_l != LCD_SPI_SPEED)
    

  241.     {
    

  242.         // 需要把SPI改为16bit模式 或 把频率改为设定频率
    

  243.  
    

  244.         // DMA搬运完成，但此时SPI还在发送，等待SPI通信忙结束
    

  245.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  246.         {
    

  247.             // 等待主机数据发送完毕
    

  248.         }
    

  249.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Rx dt buf满 清零，说明还有数据未发送
    

  250.         {
    

  251.             // 等待主机数据接收完毕
    

  252.         }
    

  253.         spi_i2s_data_receive(LCD_SPIx);
    

  254.         // SPI改为16bit模式
    

  255.         spi_frame_bit_num_set(LCD_SPIx, SPI_FRAME_16BIT);
    

  256.         // SPI时钟分频改为初始设定值
    

  257.         LCD_SPIx->ctrl1_bit.mdiv_l = LCD_SPI_SPEED;
    

  258.     }
    

  259.  
    

  260.     // 确保对应通道的 CHEN 位为 0，否则无法写入
    

  261.     dma_channel_enable(LCD_SPI_TX_DMAx_CHy, FALSE);
    

  262.     LCD_SPI_TX_DMAx_CHy->maddr = (uint32_t)buf;
    

  263.     LCD_SPI_TX_DMAx_CHy->dtcnt_bit.cnt = size; // 注意 dtcnt 是一个32位寄存器，但只有低16位是可用的
    

  264.     // 开启DMA搬运前拉低CS
    

  265.     LCD_CS_CLR();
    

  266.     // DMA开始搬运，随即SPI开始传输
    

  267.     dma_channel_enable(LCD_SPI_TX_DMAx_CHy, TRUE);
    

  268.     // =============================> 接收通道的DMA配置 <=============================
    

  269.     #if (LCD_SHARE_SPI_WITH_TOUCH_IC == 1)
    

  270.     dma_channel_enable(LCD_SPI_RX_DMAx_CHy, FALSE);
    

  271.     // 确保对应通道的 CHEN 位为 0，否则无法写入
    

  272.     // LCD_SPI_RX_DMAx_CHy->maddr = (uint32_t)LCD_SPIx_RX_buffer;
    

  273.     LCD_SPI_RX_DMAx_CHy->dtcnt_bit.cnt = size; // 注意 dtcnt 是一个32位寄存器，但只有低16位是可用的
    

  274.     dma_channel_enable(LCD_SPI_RX_DMAx_CHy, TRUE); // （在轮询结束或在中断服务程序的最后会关掉）
    

  275.     #endif
    

  276.  
    

  277.     #if LCD_HARDWARE_SPI_TX_DMA_USE_INT == 1
    

  278.     // 将在中断服务程序中完成 标志位清除、等待SPI发送结束并读一次数据（如果是全双工）、关闭DMA通道、拉高CS 的工作
    

  279.     #else
    

  280.     /*** 若不开DMA完成中断，则轮询DMAx_FDTy标志位 ***/
    

  281.     // while(spi_i2s_flag_get(LCD_SPIx,SPI_I2S_BF_FLAG) == SET){};
    

  282.     // while(dma_flag_get(DMA2_FDT1_FLAG) == RESET)
    

  283.     // {
    

  284.     // };
    

  285.     // dma_flag_clear(DMA2_FDT1_FLAG);
    

  286.     // LCD_CS_SET();
    

  287.     // // spi_i2s_dma_transmitter_enable(LCD_SPIx, FALSE);
    

  288.     // dma_channel_enable(LCD_SPI_TX_DMAx_CHy, FALSE);
    

  289.     // spi_i2s_data_receive(LCD_SPIx);
    

  290.     // // lv_disp_flush_complete();
    

  291.  
    

  292.     #endif
    

  293. }
    

  294. #if LCD_HARDWARE_SPI_TX_DMA_USE_INT == 1
    

  295. // 将在中断服务程序中完成 标志位清除、等待SPI发送结束并读一次数据（如果是全双工）、关闭DMA通道、拉高CS 的工作
    

  296.  
    

  297. void LCD_SPI_TX_DMAx_CHy_IRQHandler(void)
    

  298. {
    

  299.     /*DMA发送完成中断*/
    

  300.     if (dma_flag_get(LCD_SPI_TX_DMAx_FDTy_FLAG) == SET)
    

  301.     {
    

  302.         dma_channel_enable(LCD_SPI_TX_DMAx_CHy, FALSE);
    

  303.  
    

  304.         // DMA搬运完成，但此时SPI还在发送
    

  305.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET || spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == SET || spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET)// Tx dt buf非空 或者 Rx dt buf满 或者 通信忙
    

  306.         {
    

  307.             spi_i2s_data_receive(LCD_SPIx);
    

  308.         }
    

  309.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_ROERR_FLAG) == SET || spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET)// Tx dt buf非空 或者 Rx dt buf满 或者 通信忙
    

  310.         {
    

  311.             spi_i2s_data_receive(LCD_SPIx);
    

  312.         }
    

  313.         spi_i2s_data_receive(LCD_SPIx); // ！！！血泪教训！！全双工下DMA发完SPI后一定要读一次！！！
    

  314.         LCD_CS_SET();
    

  315.         // // DMA改回默认设置：MEM地址递增 （刷纯色的时候会改成FALSE）
    

  316.         // LCD_SPI_TX_DMAx_CHy->ctrl_bit.mincm = TRUE;
    

  317.         dma_flag_clear(LCD_SPI_TX_DMAx_FDTy_FLAG);
    

  318.     }
    

  319. }
    

  320.  
    

  321. #endif
    

  322.  
    

  323. void LCD_SPI_RX_DMAx_CHy_IRQHandler(void)
    

  324. {
    

  325.     /*DMA发送完成中断*/
    

  326.     if (dma_flag_get(LCD_SPI_RX_DMAx_FDTy_FLAG) == SET)
    

  327.     {
    

  328.         dma_flag_clear(LCD_SPI_RX_DMAx_FDTy_FLAG);
    

  329.         // LCD_SPI_RX_DMAx_CHy 将在发送数据的时候被再次使能
    

  330.         dma_channel_enable(LCD_SPI_RX_DMAx_CHy, FALSE);
    

  331.     }
    

  332. }
    

  333. #endif
    

  334.  
    

  335. /******************************************************************************
    

  336.      函数说明：LCD串行数据写入函数
    

  337.     入口数据：data  要写入的串行数据
    

  338.     返回值：  无
    

  339. ******************************************************************************/
    

  340. static void LCD_SPI_write_bus(uint16_t data)
    

  341. {
    

  342. #if (LCD_USE_HARDWARE_SPI == 1)
    

  343.     // #if (LCD_HARDWARE_SPI_USE_DMA == 1)
    

  344.     // LCD_SPI_data_send_use_DMA(&data, 1);
    

  345.     // #else
    

  346.     LCD_CS_CLR();
    

  347.     while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  348.     {
    

  349.         // 等待主机数据发送完毕
    

  350.     }
    

  351.     spi_i2s_data_transmit(LCD_SPIx, data);
    

  352.     while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Rx dt buf满 清零，说明还有数据未发送
    

  353.     {
    

  354.         // 等待主机数据接收完毕
    

  355.     }
    

  356.     spi_i2s_data_receive(LCD_SPIx);// 即使实际上没有用到 MISO，也需要读一次DT寄存器
    

  357.     // while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  358.     // {
    

  359.     //     // 等待主机数据发送完毕
    

  360.     //     // 他说他自己发完了，其实他发完个屁
    

  361.     // }
    

  362.     LCD_CS_SET();
    

  363.     // #endif
    

  364. #else
    

  365.     uint8_t i;
    

  366.     LCD_CS_CLR();
    

  367.     for (i = 0; i < 8; i++) {
    

  368.         LCD_SCLK_CLR();
    

  369.         if (data & 0x80) { 
    

  370.             LCD_MOSI_SET();
    

  371.         } else {
    

  372.             LCD_MOSI_CLR();
    

  373.         }
    

  374.         LCD_SCLK_SET();
    

  375.         data <<= 1;
    

  376.     }
    

  377.     LCD_CS_SET();
    

  378. #endif
    

  379. }
    

  380.  
    

  381. /******************************************************************************
    

  382.      函数说明：LCD写入数据
    

  383.     入口数据：data 写入的数据
    

  384.     返回值：  无
    

  385. ******************************************************************************/
    

  386. void LCD_write_byte(uint8_t data_byte)
    

  387. {
    

  388.     // 确保 LCD_SPIx 为8bit传输模式
    

  389.     if(LCD_SPIx->ctrl1_bit.fbn == SPI_FRAME_16BIT)
    

  390.     {
    

  391.         // 需要把SPI改为16bit模式
    

  392.         // 等待SPI通信忙结束
    

  393.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  394.         {
    

  395.             // 等待主机数据发送完毕
    

  396.         }
    

  397.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Rx dt buf满 清零，说明还有数据未发送
    

  398.         {
    

  399.             // 等待主机数据接收完毕
    

  400.         }
    

  401.         spi_i2s_data_receive(LCD_SPIx);
    

  402.         // SPI改为8bit模式
    

  403.         spi_frame_bit_num_set(LCD_SPIx, SPI_FRAME_8BIT);
    

  404.     }
    

  405.     LCD_SPI_write_bus(data_byte);
    

  406. }
    

  407.  
    

  408. /******************************************************************************
    

  409.      函数说明：LCD写入数据
    

  410.     入口数据：data 写入的数据
    

  411.     返回值：  无
    

  412. ******************************************************************************/
    

  413. void LCD_write_half(uint16_t data_half)
    

  414. {
    

  415.     // 确保 LCD_SPIx 为16bit传输模式
    

  416.     if(LCD_SPIx->ctrl1_bit.fbn == SPI_FRAME_8BIT)
    

  417.     {
    

  418.         // 需要把SPI改为16bit模式
    

  419.  
    

  420.         // 等待SPI通信忙结束
    

  421.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  422.         {
    

  423.             // 等待主机数据发送完毕
    

  424.         }
    

  425.         while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Rx dt buf满 清零，说明还有数据未发送
    

  426.         {
    

  427.             // 等待主机数据接收完毕
    

  428.         }
    

  429.         spi_i2s_data_receive(LCD_SPIx);
    

  430.         // SPI改为16bit模式
    

  431.         spi_frame_bit_num_set(LCD_SPIx, SPI_FRAME_16BIT);
    

  432.     }
    

  433.     LCD_SPI_write_bus(data_half);
    

  434.  
    

  435. }
    

  436.  
    

  437. /******************************************************************************
    

  438.      函数说明：LCD写入命令
    

  439.     入口数据：data 写入的命令
    

  440.     返回值：  无
    

  441. ******************************************************************************/
    

  442. void LCD_write_cmd(uint8_t data_byte)
    

  443. {
    

  444.     #if (LCD_HARDWARE_SPI_TX_DMA_USE_INT == 1)
    

  445.     // 在使用 SPI TX DMA 中断的情况下，如果此时DMA还在搬运，那么应该等DMA中断服务程序结束，并且SPI当前帧发送结束后再把DC拉低，否则将导致cmd数据和data数据错位，屏幕卡死
    

  446.     if (LCD_SPI_TX_DMAx_CHy->ctrl_bit.chen == 1)
    

  447.     {
    

  448.     __WFI();
    

  449.     }
    

  450.     // DMA搬运完成，但此时SPI还在发送
    

  451.     while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_TDBE_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Tx dt buf空 清零，说明还有数据在传输
    

  452.     {
    

  453.         // 等待主机数据发送完毕
    

  454.     }
    

  455.     while (spi_i2s_flag_get(LCD_SPIx, SPI_I2S_RDBF_FLAG) == RESET && spi_i2s_flag_get(LCD_SPIx, SPI_I2S_BF_FLAG) == SET) // Rx dt buf满 清零，说明还有数据未发送
    

  456.     {
    

  457.         // 等待主机数据接收完毕
    

  458.     }
    

  459.     spi_i2s_data_receive(LCD_SPIx);
    

  460.     #endif
    

  461.     LCD_DC_CLR(); //写命令
    

  462.     LCD_write_byte(data_byte);
    

  463.     LCD_DC_SET(); //写数据
    

  464. }
    

  465.  
    

  466.  
    

  467. /**
    

  468.   * @brief  设置区域的左上角（起始）和右下角（结束）
    

  469.   * @param  x1 : 列起始坐标
    

  470.   * @param  y1 : 行起始坐标
    

  471.   * @param  x2 : 列结束坐标
    

  472.   * @param  y2 : 行结束坐标
    

  473.   * @retval none
    

  474.   */
    

  475. void LCD_addr_set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
    

  476. {
    

  477.     // 列地址设置
    

  478.     LCD_write_cmd(0x2a); 
    

  479.     LCD_write_half(x1);
    

  480.     LCD_write_half(x2);
    

  481.     // 行地址设置
    

  482.     LCD_write_cmd(0x2b);
    

  483.     LCD_write_half(y1);
    

  484.     LCD_write_half(y2);
    

  485.     // 准备接收数据
    

  486.     LCD_write_cmd(0x2c); 
    

  487. }
    

  488.  
    

  489. /******************************************************************************
    

  490.      函数说明：LCD初始化函数
    

  491.     入口数据：无
    

  492.     返回值：  无
    

  493. ******************************************************************************/
    

  494. void LCD_init(void)
    

  495. {
    

  496. #if CHIP_USE_ST7789 == 0 //初始化ILI9341
    

  497.     {
    

  498.         LCD_RES_CLR(); //复位
    

  499.         delay_ms(100);
    

  500.         LCD_RES_SET();
    

  501.         delay_ms(100);
    

  502.  
    

  503.         LCD_BLK_SET(); //打开背光
    

  504.         delay_ms(100);
    

  505.  
    

  506.         //************* Start Initial Sequence **********//
    

  507.         LCD_write_cmd(0x11); // Sleep out
    

  508.         delay_ms(120);       // Delay 120ms
    

  509.         //************* Start Initial Sequence **********//
    

  510.         LCD_write_cmd(0xCF);
    

  511.         LCD_write_byte(0x00);
    

  512.         LCD_write_byte(0xC1);
    

  513.         LCD_write_byte(0X30);
    

  514.         LCD_write_cmd(0xED);
    

  515.         LCD_write_byte(0x64);
    

  516.         LCD_write_byte(0x03);
    

  517.         LCD_write_byte(0X12);
    

  518.         LCD_write_byte(0X81);
    

  519.         LCD_write_cmd(0xE8);
    

  520.         LCD_write_byte(0x85);
    

  521.         LCD_write_byte(0x00);
    

  522.         LCD_write_byte(0x79);
    

  523.         LCD_write_cmd(0xCB);
    

  524.         LCD_write_byte(0x39);
    

  525.         LCD_write_byte(0x2C);
    

  526.         LCD_write_byte(0x00);
    

  527.         LCD_write_byte(0x34);
    

  528.         LCD_write_byte(0x02);
    

  529.         LCD_write_cmd(0xF7);
    

  530.         LCD_write_byte(0x20);
    

  531.         LCD_write_cmd(0xEA);
    

  532.         LCD_write_byte(0x00);
    

  533.         LCD_write_byte(0x00);
    

  534.         LCD_write_cmd(0xC0);  // Power control
    

  535.         LCD_write_byte(0x1D); // VRH[5:0]
    

  536.         LCD_write_cmd(0xC1);  // Power control
    

  537.         LCD_write_byte(0x12); // SAP[2:0];BT[3:0]
    

  538.         LCD_write_cmd(0xC5);  // VCM control
    

  539.         LCD_write_byte(0x33);
    

  540.         LCD_write_byte(0x3F);
    

  541.         LCD_write_cmd(0xC7); // VCM control
    

  542.         LCD_write_byte(0x92);
    

  543.         LCD_write_cmd(0x3A); // Memory Access Control
    

  544.         LCD_write_byte(0x55);
    

  545.         LCD_write_cmd(0x36); // Memory Access Control
    

  546.         if (USE_HORIZONTAL == 0)
    

  547.             LCD_write_byte(0x08);
    

  548.         else if (USE_HORIZONTAL == 1)
    

  549.             LCD_write_byte(0xC8);
    

  550.         else if (USE_HORIZONTAL == 2)
    

  551.             LCD_write_byte(0x78);
    

  552.         else
    

  553.             LCD_write_byte(0xA8);
    

  554.         LCD_write_cmd(0xB1);
    

  555.         LCD_write_byte(0x00);
    

  556.         LCD_write_byte(0x12);
    

  557.         LCD_write_cmd(0xB6); // Display Function Control
    

  558.         LCD_write_byte(0x0A);
    

  559.         LCD_write_byte(0xA2);
    

  560.  
    

  561.         LCD_write_cmd(0x44);
    

  562.         LCD_write_byte(0x02);
    

  563.  
    

  564.         LCD_write_cmd(0xF2); // 3Gamma Function Disable
    

  565.         LCD_write_byte(0x00);
    

  566.         LCD_write_cmd(0x26); // Gamma curve selected
    

  567.         LCD_write_byte(0x01);
    

  568.         LCD_write_cmd(0xE0); // Set Gamma
    

  569.         LCD_write_byte(0x0F);
    

  570.         LCD_write_byte(0x22);
    

  571.         LCD_write_byte(0x1C);
    

  572.         LCD_write_byte(0x1B);
    

  573.         LCD_write_byte(0x08);
    

  574.         LCD_write_byte(0x0F);
    

  575.         LCD_write_byte(0x48);
    

  576.         LCD_write_byte(0xB8);
    

  577.         LCD_write_byte(0x34);
    

  578.         LCD_write_byte(0x05);
    

  579.         LCD_write_byte(0x0C);
    

  580.         LCD_write_byte(0x09);
    

  581.         LCD_write_byte(0x0F);
    

  582.         LCD_write_byte(0x07);
    

  583.         LCD_write_byte(0x00);
    

  584.         LCD_write_cmd(0XE1); // Set Gamma
    

  585.         LCD_write_byte(0x00);
    

  586.         LCD_write_byte(0x23);
    

  587.         LCD_write_byte(0x24);
    

  588.         LCD_write_byte(0x07);
    

  589.         LCD_write_byte(0x10);
    

  590.         LCD_write_byte(0x07);
    

  591.         LCD_write_byte(0x38);
    

  592.         LCD_write_byte(0x47);
    

  593.         LCD_write_byte(0x4B);
    

  594.         LCD_write_byte(0x0A);
    

  595.         LCD_write_byte(0x13);
    

  596.         LCD_write_byte(0x06);
    

  597.         LCD_write_byte(0x30);
    

  598.         LCD_write_byte(0x38);
    

  599.         LCD_write_byte(0x0F);
    

  600.         LCD_write_cmd(0x29); // Display on
    

  601.     }
    

  602. #else //初始化ST7789
    

  603.     {
    

  604.         LCD_RES_CLR(); //复位
    

  605.         delay_ms(100);
    

  606.         LCD_RES_SET();
    

  607.         delay_ms(100);
    

  608.         LCD_BLK_SET(); //打开背光
    

  609.         delay_ms(500);
    

  610.         LCD_write_cmd(0x11);
    

  611.         delay_ms(120); // Delay 120ms
    

  612.         //************* Start Initial Sequence **********//
    

  613.         //------------------------------display and color format setting--------------------------------//
    

  614.  
    

  615.         LCD_write_cmd(0X36); // Memory Access Control
    

  616.         if (USE_HORIZONTAL == 0)
    

  617.             LCD_write_byte(0x00);
    

  618.         else if (USE_HORIZONTAL == 1)
    

  619.             LCD_write_byte(0xC0);
    

  620.         else if (USE_HORIZONTAL == 2)
    

  621.             LCD_write_byte(0x70);
    

  622.         else
    

  623.             LCD_write_byte(0xA0);
    

  624.         LCD_write_cmd(0X3A);
    

  625.         LCD_write_byte(0X05);
    

  626.         //--------------------------------ST7789S Frame rate setting-------------------------
    

  627.  
    

  628.         LCD_write_cmd(0xb2);
    

  629.         LCD_write_byte(0x0c);
    

  630.         LCD_write_byte(0x0c);
    

  631.         LCD_write_byte(0x00);
    

  632.         LCD_write_byte(0x33);
    

  633.         LCD_write_byte(0x33);
    

  634.         LCD_write_cmd(0xb7);
    

  635.         LCD_write_byte(0x35);
    

  636.         //---------------------------------ST7789S Power setting-----------------------------
    

  637.  
    

  638.         LCD_write_cmd(0xbb);
    

  639.         LCD_write_byte(0x35);
    

  640.         LCD_write_cmd(0xc0);
    

  641.         LCD_write_byte(0x2c);
    

  642.         LCD_write_cmd(0xc2);
    

  643.         LCD_write_byte(0x01);
    

  644.         LCD_write_cmd(0xc3);
    

  645.         LCD_write_byte(0x13);
    

  646.         LCD_write_cmd(0xc4);
    

  647.         LCD_write_byte(0x20);
    

  648.         LCD_write_cmd(0xc6);
    

  649.         LCD_write_byte(0x0f);
    

  650.         LCD_write_cmd(0xca);
    

  651.         LCD_write_byte(0x0f);
    

  652.         LCD_write_cmd(0xc8);
    

  653.         LCD_write_byte(0x08);
    

  654.         LCD_write_cmd(0x55);
    

  655.         LCD_write_byte(0x90);
    

  656.         LCD_write_cmd(0xd0);
    

  657.         LCD_write_byte(0xa4);
    

  658.         LCD_write_byte(0xa1);
    

  659.         //--------------------------------ST7789S gamma setting------------------------------
    

  660.         LCD_write_cmd(0xe0);
    

  661.         LCD_write_byte(0xd0);
    

  662.         LCD_write_byte(0x00);
    

  663.         LCD_write_byte(0x06);
    

  664.         LCD_write_byte(0x09);
    

  665.         LCD_write_byte(0x0b);
    

  666.         LCD_write_byte(0x2a);
    

  667.         LCD_write_byte(0x3c);
    

  668.         LCD_write_byte(0x55);
    

  669.         LCD_write_byte(0x4b);
    

  670.         LCD_write_byte(0x08);
    

  671.         LCD_write_byte(0x16);
    

  672.         LCD_write_byte(0x14);
    

  673.         LCD_write_byte(0x19);
    

  674.         LCD_write_byte(0x20);
    

  675.         LCD_write_cmd(0xe1);
    

  676.         LCD_write_byte(0xd0);
    

  677.         LCD_write_byte(0x00);
    

  678.         LCD_write_byte(0x06);
    

  679.         LCD_write_byte(0x09);
    

  680.         LCD_write_byte(0x0b);
    

  681.         LCD_write_byte(0x29);
    

  682.         LCD_write_byte(0x36);
    

  683.         LCD_write_byte(0x54);
    

  684.         LCD_write_byte(0x4b);
    

  685.         LCD_write_byte(0x0d);
    

  686.         LCD_write_byte(0x16);
    

  687.         LCD_write_byte(0x14);
    

  688.         LCD_write_byte(0x21);
    

  689.         LCD_write_byte(0x20);
    

  690.         LCD_write_cmd(0x29);
    

  691.     }
    

  692. #endif
    

  693. }
复制
  1. /* Define to prevent recursive inclusion -------------------------------------*/
    

  2. #ifndef __ST7789_H
    

  3. #define __ST7789_H
    

  4.  
    

  5. #ifdef __cplusplus
    

  6. extern "C" {
    

  7. #endif
    

  8.  
    

  9. /* includes ------------------------------------------------------------------*/
    

  10. #include "at32f435_437.h"
    

  11.  
    

  12. #include "systick.h"
    

  13.  
    

  14. /* micro and typedef ---------------------------------------------------------*/
    

  15.  
    

  16. #define USE_HORIZONTAL  0 //设置横屏或者竖屏显示 0或1为竖屏 2或3为横屏
    

  17. #define CHIP_USE_ST7789 1 //设置芯片初始化 0为ILI9341  1为ST7789
    

  18.  
    

  19. #if USE_HORIZONTAL == 0 || USE_HORIZONTAL == 1
    

  20. #define LCD_W 240
    

  21. #define LCD_H 320
    

  22. #else
    

  23. #define LCD_W 320
    

  24. #define LCD_H 240
    

  25. #endif
    

  26.  
    

  27. //-----------------LCD端口定义----------------
    

  28.  
    

  29. /* 请按照以下逻辑修改宏定义：
    

  30.     1，使用硬件SPI？否则使用软件模拟时序。
    

  31.         若是，下一步；否则将配置为和触摸IC共用一个软件SPI。
    

  32.     2，判断触摸IC是否使用硬件SPI？
    

  33.         若是，下一步；否则LCD使用硬件SPI（本文件负责配置）而触摸IC使用软件SPI（不在本文件中配置）。
    

  34.     3，和触摸IC共用同一个SPI？否则使用两个硬件SPI。
    

  35.         若是，请指定SPIx，SPIx将设置成全双工模式，软件管理CS，触摸IC也使用此SPI，并下一步；
    

  36.         否则，请指定两个完全独立的SPI端口分别驱动LCD和触摸IC，硬件管理CS，下一步。
    

  37.     4，使用DMA？
    

  38.  
    

  39.  */
    

  40. #define LCD_USE_HARDWARE_SPI     1
    

  41. #define XPT2046_USE_HARDWARE_SPI 1
    

  42.  
    

  43. #if LCD_USE_HARDWARE_SPI == 1
    

  44. #include "at32f435_437_spi.h"
    

  45.  
    

  46. #if LCD_USE_HARDWARE_SPI == 1 && XPT2046_USE_HARDWARE_SPI == 1
    

  47. #define LCD_SHARE_SPI_WITH_TOUCH_IC 1 // 见 https://blog.csdn.net/m0_46882426/article/details/127568586?spm=1001.2014.3001.5501 ，共用SPI并软件管理CS是最优解，所以不要改动此宏
    

  48. #endif
    

  49.  
    

  50. #define LCD_HARDWARE_SPI_USE_DMA 1
    

  51. #define LCD_HARDWARE_SPI_TX_DMA_USE_INT 1
    

  52.  
    

  53. // SPI 通信速度选择
    

  54. #define LCD_SPI_USE_SPEED_LEVEL 1
    

  55.  
    

  56. // SPI 端口选择
    

  57. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  58. // 共用 LCD_SHARE_SPIx_NUM (该宏仅表示SPI序号)，且使用软件管理CS
    

  59. #define LCD_SHARE_SPIx_NUM   2
    

  60. #define LCD_USE_SPIx_NUM     LCD_SHARE_SPIx_NUM
    

  61. #define XPT2046_USE_SPIx_NUM LCD_SHARE_SPIx_NUM
    

  62. #else
    

  63. // 使用独立的两个SPI，且使用硬件管理CS
    

  64. #define LCD_USE_SPIx_NUM     1
    

  65. #define XPT2046_USE_SPIx_NUM 2
    

  66. #endif
    

  67.  
    

  68. // 非SPI控制 GPIO定义
    

  69.  
    

  70. #define LCD_GPIOPORT     GPIOA
    

  71. #define LCD_GPIOPORT_CRM CRM_GPIOA_PERIPH_CLOCK
    

  72.  
    

  73. #define LCD_PINS_RST     GPIO_PINS_0
    

  74. #define LCD_PINS_DC      GPIO_PINS_1
    

  75. #define LCD_PINS_BLK     GPIO_PINS_8
    

  76. #define LCD_PINS_CS      GPIO_PINS_4
    

  77.  
    

  78. // DMA 控制器定义
    

  79. #if LCD_HARDWARE_SPI_USE_DMA == 1
    

  80. #include "at32f435_437_dma.h"
    

  81. #define LCD_SPI_TX_DMAx                DMA2
    

  82. #define LCD_SPI_TX_DMAx_CRM_CLOCK      CRM_DMA2_PERIPH_CLOCK
    

  83. #define LCD_SPI_TX_DMAx_CHy            DMA2_CHANNEL1
    

  84. #define LCD_SPI_TX_DMAxMUX_CHy         DMA2MUX_CHANNEL1
    

  85. #define LCD_SPI_TX_DMAMUX_REQ_ID       DMAMUX_DMAREQ_ID_SPI2_TX
    

  86. #define LCD_SPI_TX_DMAx_CHy_IRQn       DMA2_Channel1_IRQn
    

  87. #define LCD_SPI_TX_DMAx_CHy_IRQHandler DMA2_Channel1_IRQHandler
    

  88. #define LCD_SPI_TX_DMAx_FDTy_FLAG      DMA2_FDT1_FLAG
    

  89.  
    

  90. #define LCD_SPI_RX_DMAx_CHy            DMA2_CHANNEL2
    

  91. #define LCD_SPI_RX_DMAxMUX_CHy         DMA2MUX_CHANNEL2
    

  92. #define LCD_SPI_RX_DMAMUX_REQ_ID       DMAMUX_DMAREQ_ID_SPI2_RX
    

  93. #define LCD_SPI_RX_DMAx_CHy_IRQn       DMA2_Channel2_IRQn
    

  94. #define LCD_SPI_RX_DMAx_CHy_IRQHandler DMA2_Channel2_IRQHandler
    

  95. #define LCD_SPI_RX_DMAx_FDTy_FLAG      DMA2_FDT2_FLAG
    

  96.  
    

  97. // 定义 SPI 数据发送缓冲区长度。LCD_SPI_TX_DMAx_CHy 负责将该缓冲区内的数据搬运至 LCD_SPIx
    

  98. #define LCD_SPI_TX_BUFFER_SIZE 65535 // 设置宽度为半字后，DMA一次最多连续搬运65545个半字
    

  99. #define LCD_SPI_RX_BUFFER_SIZE 1024/2
    

  100. #endif
    

  101.  
    

  102. // SPI 控制端口自动定义
    

  103. #if LCD_USE_SPIx_NUM == 1 // DO NOT MODIFY!
    

  104.  
    

  105. #define LCD_SPIx SPI1
    

  106. // SPI1 位于 GPIOA 的 MUX5
    

  107. #define LCD_SPIx_CRM            CRM_SPI1_PERIPH_CLOCK
    

  108.  
    

  109. #define LCD_SPIx_GPIO           GPIOA
    

  110. #define LCD_SPIx_GPIO_CRM       CRM_GPIOA_PERIPH_CLOCK
    

  111. #define LCD_SPIx_MUX_SEL        GPIO_MUX_5
    

  112.  
    

  113. #define LCD_SPIx_CS_GPIO_PIN    GPIO_PINS_4
    

  114. #define LCD_SPIx_SCLK_GPIO_PIN  GPIO_PINS_5
    

  115. #define LCD_SPIx_MISO_GPIO_PIN  GPIO_PINS_6
    

  116. #define LCD_SPIx_MOSI_GPIO_PIN  GPIO_PINS_7
    

  117.  
    

  118. #define LCD_SPIx_CS_SOURCE      GPIO_PINS_SOURCE4
    

  119. #define LCD_SPIx_SCLK_SOURCE    GPIO_PINS_SOURCE5
    

  120. #define LCD_SPIx_MISO_SOURCE    GPIO_PINS_SOURCE6
    

  121. #define LCD_SPIx_MOSI_SOURCE    GPIO_PINS_SOURCE7
    

  122.  
    

  123. #define LCD_SPIx_EXT_IQRn       SPI1_IRQn
    

  124. #define LCD_SPIx_EXT_IQRHandler SPI1_IRQHandler
    

  125.  
    

  126. #elif LCD_USE_SPIx_NUM == 2 // DO NOT MODIFY!
    

  127.  
    

  128. #define LCD_SPIx               SPI2
    

  129. // SPI2 位于 GPIOA 的 MUX5
    

  130. #define LCD_SPIx_CRM           CRM_SPI2_PERIPH_CLOCK
    

  131.  
    

  132. #define LCD_SPIx_GPIO          GPIOA
    

  133. #define LCD_SPIx_GPIO_CRM      CRM_GPIOA_PERIPH_CLOCK
    

  134. #define LCD_SPIx_MUX_SEL       GPIO_MUX_5
    

  135.  
    

  136. #define LCD_SPIx_SCLK_GPIO_PIN GPIO_PINS_9
    

  137. #define LCD_SPIx_MOSI_GPIO_PIN GPIO_PINS_10
    

  138. #define LCD_SPIx_CS_GPIO_PIN   GPIO_PINS_11
    

  139. #define LCD_SPIx_MISO_GPIO_PIN GPIO_PINS_12
    

  140.  
    

  141. #define LCD_SPIx_SCLK_SOURCE   GPIO_PINS_SOURCE9
    

  142. #define LCD_SPIx_MOSI_SOURCE   GPIO_PINS_SOURCE10
    

  143. #define LCD_SPIx_CS_SOURCE     GPIO_PINS_SOURCE11
    

  144. #define LCD_SPIx_MISO_SOURCE   GPIO_PINS_SOURCE12
    

  145.  
    

  146. #define LCD_SPIx_EXT_IQRn      SPI2_I2S2EXT_IRQn
    

  147. #else
    

  148. #error the specified SPI (Macro "LCD_SPIx") is unknown!
    

  149. #endif
    

  150.  
    

  151. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  152. #define XPT2046_SPIx LCD_SPIx
    

  153. #endif
    

  154.  
    

  155. #else
    

  156.  
    

  157. #define LCD_GPIOPORT     GPIOA
    

  158. #define LCD_GPIOPORT_CRM CRM_GPIOA_PERIPH_CLOCK
    

  159.  
    

  160. #define LCD_PINS_SCLK    GPIO_PINS_5
    

  161. #define LCD_PINS_MOSI    GPIO_PINS_7
    

  162. #define LCD_PINS_RST     GPIO_PINS_0
    

  163. #define LCD_PINS_DC      GPIO_PINS_1
    

  164. #define LCD_PINS_BLK     GPIO_PINS_8
    

  165. #define LCD_PINS_CS      GPIO_PINS_4
    

  166.  
    

  167. #define LCD_SCLK_CLR()   gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_SCLK)
    

  168. #define LCD_MOSI_CLR()   gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_MOSI)
    

  169. #define LCD_CS_CLR()     gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_CS)
    

  170.  
    

  171. #define LCD_SCLK_SET()   gpio_bits_set(LCD_GPIOPORT, LCD_PINS_SCLK)
    

  172. #define LCD_MOSI_SET()   gpio_bits_set(LCD_GPIOPORT, LCD_PINS_MOSI)
    

  173. #define LCD_CS_SET()     gpio_bits_set(LCD_GPIOPORT, LCD_PINS_CS)
    

  174.  
    

  175. #endif
    

  176.  
    

  177. #define LCD_RES_CLR() gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_RST)
    

  178. #define LCD_DC_CLR()  gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_DC)
    

  179. #define LCD_BLK_CLR() gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_BLK)
    

  180.  
    

  181. #define LCD_RES_SET() gpio_bits_set(LCD_GPIOPORT, LCD_PINS_RST)
    

  182. #define LCD_DC_SET()  gpio_bits_set(LCD_GPIOPORT, LCD_PINS_DC)
    

  183. #define LCD_BLK_SET() gpio_bits_set(LCD_GPIOPORT, LCD_PINS_BLK)
    

  184.  
    

  185. #if LCD_SHARE_SPI_WITH_TOUCH_IC == 1
    

  186. #define LCD_CS_CLR() gpio_bits_reset(LCD_GPIOPORT, LCD_PINS_CS)
    

  187. #define LCD_CS_SET() gpio_bits_set(LCD_GPIOPORT, LCD_PINS_CS)
    

  188. #else
    

  189. // LCD_SPIx 的硬件管理CS将在 ST7789.c 中配置
    

  190. // XPT2046_SPIx 的硬件管理CS将在 XPT2046.c 中配置
    

  191. #endif
    

  192.  
    

  193. #if LCD_SPI_USE_SPEED_LEVEL == 1
    

  194. #define LCD_SPI_SPEED SPI_MCLK_DIV_8 // 288M / 8 = 36M
    

  195. #elif LCD_SPI_USE_SPEED_LEVEL == 2
    

  196. #define LCD_SPI_SPEED SPI_MCLK_DIV_16 // 288M / 16 = 18M
    

  197. #elif LCD_SPI_USE_SPEED_LEVEL == 3
    

  198. #define LCD_SPI_SPEED SPI_MCLK_DIV_32 // 288M / 32 = 9M
    

  199. #endif
    

  200.  
    

  201. /* function ------------------------------------------------------------------*/
    

  202.  
    

  203. void LCD_GPIO_init(void); // GPIO初始化
    

  204. void LCD_SPIx_init(void); // SPI初始化
    

  205. #if (LCD_HARDWARE_SPI_USE_DMA == 1)
    

  206. void LCD_SPI_data_send_use_DMA(const void *buf, uint32_t size);
    

  207. #endif
    

  208. void LCD_write_half(uint16_t data);                                    
    

  209. void LCD_addr_set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2); 
    

  210. void LCD_init(void);                                                   
    

  211. void LCD_fill_color(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);
    

  212.  
    

  213. #ifdef __cplusplus
    

  214. }
    

  215. #endif
    

  216.  
    

  217. #endif
复制
  1. /**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url] lv_port_disp_templ.c
    

  3.  *
    

  4.  */
    

  5. /*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
    

  6. #if 1
    

  7.  
    

  8. /*********************
    

  9.  *      INCLUDES
    

  10.  *********************/
    

  11. #include "lv_port_disp.h"
    

  12. #include <stdbool.h>
    

  13. #include "LCD/ST7789.h"
    

  14.  
    

  15. /*********************
    

  16.  *      DEFINES
    

  17.  *********************/
    

  18. #ifndef MY_DISP_HOR_RES
    

  19.     #define MY_DISP_HOR_RES    240
    

  20. #endif
    

  21.  
    

  22. #ifndef MY_DISP_VER_RES
    

  23.     #define MY_DISP_VER_RES    320
    

  24. #endif
    

  25.  
    

  26. /*-----------------------------
    

  27. * Create a buffer for drawing
    

  28. *----------------------------*/
    

  29.     /**
    

  30.      * LVGL requires a buffer where it internally draws the widgets.
    

  31.      * Later this buffer will passed to your display driver's `flush_cb` to copy its content to your display.
    

  32.      * The buffer has to be greater than 1 display row
    

  33.      *
    

  34.      * There are 3 buffering configurations:
    

  35.      * 1. Create ONE buffer:
    

  36.      *      LVGL will draw the display's content here and writes it to your display
    

  37.      *
    

  38.      * 2. Create TWO buffer:
    

  39.      *      LVGL will draw the display's content to a buffer and writes it your display.
    

  40.      *      You should use DMA to write the buffer's content to the display.
    

  41.      *      It will enable LVGL to draw the next part of the screen to the other buffer while
    

  42.      *      the data is being sent form the first buffer. It makes rendering and flushing parallel.
    

  43.      *
    

  44.      * 3. Double buffering
    

  45.      *      Set 2 screens sized buffers and set disp_drv.full_refresh = 1.
    

  46.      *      This way LVGL will always provide the whole rendered screen in `flush_cb`
    

  47.      *      and you only need to change the frame buffer's address.
    

  48.      */
    

  49. #define BUFFER_METHOD 2
    

  50.  
    

  51.  
    

  52.  
    

  53. /**********************
    

  54.  *      TYPEDEFS
    

  55.  **********************/
    

  56. /**********************
    

  57.  *  STATIC PROTOTYPES
    

  58.  **********************/
    

  59. static void disp_init(void);
    

  60.  
    

  61. static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
    

  62. //static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
    

  63. //        const lv_area_t * fill_area, lv_color_t color);
    

  64.  
    

  65. /**********************
    

  66.  *  STATIC VARIABLES
    

  67.  **********************/
    

  68. /**********************
    

  69.  *      MACROS
    

  70.  **********************/
    

  71. /**********************
    

  72.  *   GLOBAL FUNCTIONS
    

  73.  **********************/
    

  74. void lv_port_disp_init(void)
    

  75. {
    

  76.     /*-------------------------
    

  77.      * Initialize your display
    

  78.      * -----------------------*/
    

  79.     disp_init();
    

  80.  
    

  81.     /*-----------------------------
    

  82.      * Create a buffer for drawing
    

  83.      *----------------------------*/
    

  84.     #if (BUFFER_METHOD == 1)
    

  85.     /* Example for 1) */
    

  86.     static lv_disp_draw_buf_t draw_buf_dsc_1;
    

  87.     static lv_color_t buf_1[MY_DISP_HOR_RES * 10];                          /*A buffer for 10 rows*/
    

  88.     lv_disp_draw_buf_init(&draw_buf_dsc_1, buf_1, NULL, MY_DISP_HOR_RES * 10);   /*Initialize the display buffer*/
    

  89.     #elif (BUFFER_METHOD == 2)
    

  90.     /* Example for 2) */
    

  91.     static lv_disp_draw_buf_t draw_buf_dsc_2;
    

  92.     static lv_color_t buf_2_1[MY_DISP_HOR_RES * 10];                        /*A buffer for 10 rows*/
    

  93.     static lv_color_t buf_2_2[MY_DISP_HOR_RES * 10];                        /*An other buffer for 10 rows*/
    

  94.     lv_disp_draw_buf_init(&draw_buf_dsc_2, buf_2_1, buf_2_2, MY_DISP_HOR_RES * 10);   /*Initialize the display buffer*/
    

  95.     #elif (BUFFER_METHOD == 3)
    

  96.     /* Example for 3) also set disp_drv.full_refresh = 1 below*/
    

  97.     static lv_disp_draw_buf_t draw_buf_dsc_3;
    

  98.     static lv_color_t buf_3_1[MY_DISP_HOR_RES * MY_DISP_VER_RES];            /*A screen sized buffer*/
    

  99.     static lv_color_t buf_3_2[MY_DISP_HOR_RES * MY_DISP_VER_RES];            /*Another screen sized buffer*/
    

  100.     lv_disp_draw_buf_init(&draw_buf_dsc_3, buf_3_1, buf_3_2,
    

  101.                           MY_DISP_VER_RES * MY_DISP_HOR_RES);   /*Initialize the display buffer*/
    

  102.     #else
    

  103.         #error "the specified macro 'BUFFER_METHOD' is unknown!"
    

  104.     #endif
    

  105.  
    

  106.  
    

  107.     /*-----------------------------------
    

  108.      * Register the display in LVGL
    

  109.      *----------------------------------*/
    

  110.     static lv_disp_drv_t disp_drv;                         /*Descriptor of a display driver*/
    

  111.     lv_disp_drv_init(&disp_drv);                    /*Basic initialization*/
    

  112.  
    

  113.     /*Set up the functions to access to your display*/
    

  114.  
    

  115.     /*Set the resolution of the display*/
    

  116.     disp_drv.hor_res = MY_DISP_HOR_RES;
    

  117.     disp_drv.ver_res = MY_DISP_VER_RES;
    

  118.  
    

  119.     /*Used to copy the buffer's content to the display*/
    

  120.     disp_drv.flush_cb = disp_flush;
    

  121.     /*Set a display buffer*/
    

  122.     #if (BUFFER_METHOD == 1)
    

  123.     disp_drv.draw_buf = &draw_buf_dsc_1;
    

  124.     #elif (BUFFER_METHOD == 2)
    

  125.     disp_drv.draw_buf = &draw_buf_dsc_2;
    

  126.     #else
    

  127.     disp_drv.draw_buf = &draw_buf_dsc_3;
    

  128.     #endif
    

  129.     #if (BUFFER_METHOD == 3)
    

  130.     /*Required for Example 3)*/
    

  131.     disp_drv.full_refresh = 1;
    

  132.     #endif
    

  133.     /* Fill a memory array with a color if you have GPU.
    

  134.      * Note that, in lv_conf.h you can enable GPUs that has built-in support in LVGL.
    

  135.      * But if you have a different GPU you can use with this callback.*/
    

  136.     //disp_drv.gpu_fill_cb = gpu_fill;
    

  137.     /*Finally register the driver*/
    

  138.     lv_disp_drv_register(&disp_drv);
    

  139. }
    

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

  141.  *   STATIC FUNCTIONS
    

  142.  **********************/
    

  143. /*Initialize your display and the required peripherals.*/
    

  144. static void disp_init(void)
    

  145. {
    

  146.     LCD_GPIO_init();
    

  147.     #if LCD_USE_HARDWARE_SPI == 1
    

  148.     LCD_SPIx_init();
    

  149.     #endif
    

  150.     // 注意在此之前确保已经初始化 GPIO 和 SPI
    

  151.     LCD_init();
    

  152. }
    

  153. volatile bool disp_flush_enabled = true;
    

  154. /* Enable updating the screen (the flushing process) when disp_flush() is called by LVGL
    

  155.  */
    

  156. void disp_enable_update(void)
    

  157. {
    

  158.     disp_flush_enabled = true;
    

  159. }
    

  160. /* Disable updating the screen (the flushing process) when disp_flush() is called by LVGL
    

  161.  */
    

  162. void disp_disable_update(void)
    

  163. {
    

  164.     disp_flush_enabled = false;
    

  165. }
    

  166. /*Flush the content of the internal buffer the specific area on the display
    

  167.  *You can use DMA or any hardware acceleration to do this operation in the background but
    

  168.  *'lv_disp_flush_ready()' has to be called when finished.*/
    

  169. static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
    

  170. {
    

  171.     if(disp_flush_enabled)
    

  172.     {
    

  173.         /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
    

  174.         // int32_t x;
    

  175.         // int32_t y;
    

  176.         // for(y = area->y1; y <= area->y2; y++) {
    

  177.         //     for(x = area->x1; x <= area->x2; x++) {
    

  178.         //         /*Put a pixel to the display. For example:*/
    

  179.         //         /*put_px(x, y, *color_p)*/
    

  180.         //         color_p++;
    

  181.         //     }
    

  182.         // }
    

  183.         // 如果采用写点函数来做，刷屏会很慢，所以推荐的方式如下：
    

  184.         uint16_t  x1, y1, x2, y2;
    

  185.         uint16_t total_half;
    

  186.         x1 = area->x1;
    

  187.         y1 = area->y1;
    

  188.         x2 = area->x2;
    

  189.         y2 = area->y2;
    

  190.         
    

  191.         total_half = (x2 - x1 + 1) * (y2 - y1 + 1);
    

  192.         LCD_addr_set(x1, y1, x2, y2);
    

  193.         // st7789_cfg_dcx_set();
    

  194.         // st7789_cfg_spi_write((uint8_t*)color_p, total_half );
    

  195.         LCD_SPI_data_send_use_DMA((uint16_t *) color_p, total_half);
    

  196.     }
    

  197.     /*IMPORTANT!!!
    

  198.      *Inform the graphics library that you are ready with the flushing*/
    

  199.     lv_disp_flush_ready(disp_drv);
    

  200. }
    

  201. /*OPTIONAL: GPU INTERFACE*/
    

  202. /*If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color*/
    

  203. //static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
    

  204. //                    const lv_area_t * fill_area, lv_color_t color)
    

  205. //{
    

  206. //    /*It's an example code which should be done by your GPU*/
    

  207. //    int32_t x, y;
    

  208. //    dest_buf += dest_width * fill_area->y1; /*Go to the first line*/
    

  209. //
    

  210. //    for(y = fill_area->y1; y <= fill_area->y2; y++) {
    

  211. //        for(x = fill_area->x1; x <= fill_area->x2; x++) {
    

  212. //            dest_buf[x] = color;
    

  213. //        }
    

  214. //        dest_buf+=dest_width;    /*Go to the next line*/
    

  215. //    }
    

  216. //}
    

  217.  
    

  218.  
    

  219. #else /*Enable this file at the top*/
    

  220.  
    

  221. /*This dummy typedef exists purely to silence -Wpedantic.*/
    

  222. typedef int keep_pedantic_happy;
    

  223. #endif
复制
  1. #include "at32f435_437_clock.h"
    

  2.  
    

  3. #include "systick.h"
    

  4. #include "usart.h"
    

  5. #include "LCD/XPT2046.h"
    

  6.  
    

  7. #include "lvgl.h"
    

  8. #include "examples/porting/lv_port_disp.h"
    

  9. #include "examples/porting/lv_port_indev.h"
    

  10. #include "examples/lv_examples.h"
    

  11.  
    

  12. #define LVGL_TICK         1
    

  13.  
    

  14. static void lvgl_init( void ) 
    

  15. {
    

  16.     lv_init();
    

  17.     lv_port_disp_init();        // 显示器初始化
    

  18.     lv_port_indev_init();       // 输入设备初始化
    

  19.     // lv_port_fs_init();          // 文件系统设备初始化
    

  20. }
    

  21.  
    

  22.  
    

  23. /**
    

  24.  * @brief  main function.
    

  25.  * @param  none
    

  26.  * @retval none
    

  27.  */
    

  28. int main()
    

  29. {
    

  30.  
    

  31.     system_clock_config();
    

  32.     delay_init();
    

  33.  
    

  34.         // LED init
    

  35.     gpio_init_type gpio_init_struct;
    

  36.     crm_periph_clock_enable(CRM_GPIOD_PERIPH_CLOCK, TRUE);
    

  37.     gpio_default_para_init(&gpio_init_struct);
    

  38.     gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  39.     gpio_init_struct.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  40.     gpio_init_struct.gpio_mode           = GPIO_MODE_OUTPUT;
    

  41.     gpio_init_struct.gpio_pins           = GPIO_PINS_2;
    

  42.     gpio_init_struct.gpio_pull           = GPIO_PULL_NONE;
    

  43.     gpio_init(GPIOD, &gpio_init_struct);
    

  44.  
    

  45.         // //USART init
    

  46.     uart_print_init(115200);
    

  47.  
    

  48.     printf("UART initialized successfully!\r\n");
    

  49.         // =============================> LCD app <=============================    
    

  50.         lvgl_init();
    

  51.  
    

  52.     lv_example_obj_2();
    

  53.  
    

  54.         while(1) {
    

  55.                 // 先调用 lv_tick_inc 再调用 lv_timer_handler
    

  56.                 lv_tick_inc(LVGL_TICK);
    

  57.                 lv_timer_handler();
    

  58.                 delay_ms(LVGL_TICK);
    

  59.         GPIOD->odt ^= GPIO_PINS_2;
    

  60.         }
    

  61. }
    

  62.  
    

  63.


回复

收藏 举报

板凳
xiaoyaodz 发表于 2024-3-1 20:40 | 只看该作者
硬件SPI（串行外设接口）是一种常用的通信协议，用于微控制器与各种外设（如传感器、显示模块、存储器等）之间的快速数据交换。
回复

收藏 举报

地板
bartonalfred 发表于 2024-3-1 21:34 | 只看该作者
如果LCD屏幕的驱动芯片是ST7789，那么需要配置与之对应的SPI参数。
回复

收藏 举报

5楼
jackcat 发表于 2024-3-2 02:07 | 只看该作者
设置SPI时钟速率，以确保它能够与LCD屏的要求相匹配。
配置SPI端口的工作模式，包括数据位宽（通常是8位）、时钟极性和相位等。
回复

收藏 举报

6楼
zerorobert 发表于 2024-3-2 09:56 | 只看该作者
需要按照LCD屏幕的数据手册来配置屏幕。 包括设置屏幕的分辨率、颜色深度、背光等。
回复

收藏 举报

7楼
wwppd 发表于 2024-3-2 17:18 | 只看该作者
不同的LCD屏幕可能具有不同的时序要求和控制逻辑
回复

收藏 举报

8楼
rosemoore 发表于 2024-3-2 19:15 | 只看该作者
LCD屏幕与MCU之间的SPI连接正确无误。检查SPI时钟（SCLK）、数据输入（MISO）和数据输出（MOSI）线的连接。同时，确保CS（片选）线的连接和控制正确。
回复

收藏 举报

9楼
jtracy3 发表于 2024-3-2 22:31 | 只看该作者
根据你的LCD屏型号、SPI接口的配置以及你使用的编程语言或框架而有所不同。
回复

收藏 举报

10楼
mikewalpole 发表于 2024-3-3 09:22 | 只看该作者
编写函数用于通过SPI接口发送数据到LCD屏。通常会有专门的函数负责数据打包和解包，以及发送命令和数据到SPI总线。
回复

收藏 举报

11楼
averyleigh 发表于 2024-3-3 11:25 | 只看该作者
在微控制器上配置硬件SPI，包括设置SPI时钟速率、模式（如主从模式、CPOL、CPHA等）和数据位宽（如8位或16位）。
回复

收藏 举报

12楼
yeates333 发表于 2024-3-3 13:30 | 只看该作者
一旦SPI和LCD屏幕都配置好了，你就可以开始发送命令和数据。通常，你会先发送一系列的命令来设置屏幕的模式、画布、颜色等。
回复

收藏 举报

13楼
mollylawrence 发表于 2024-3-3 15:22 | 只看该作者
SPI驱动代码正确地配置了时钟、数据输入和数据输出。检查CS线的控制逻辑，确保在正确的时间激活和释放。
回复

收藏 举报

14楼
benjaminka 发表于 2024-3-3 17:13 | 只看该作者
如果LCD屏幕支持背光调节，还需要编写相应的代码来实现这一功能。
回复

收藏 举报

15楼
jackcat 发表于 2024-3-3 19:06 | 只看该作者
使用硬件SPI将数据发送到LCD屏。这通常包括发送像素数据、命令和参数。你可以使用微控制器的硬件SPI接口来实现这一点。
回复

收藏 举报

16楼
mikewalpole 发表于 2024-3-3 22:30 | 只看该作者
将LCD屏的SPI引脚连接到微控制器的相应引脚。通常，你需要连接SCLK、MOSI、MISO和CS引脚。此外，还需要连接LCD屏的电源引脚（如VCC、GND、VDD等）。
回复

收藏 举报

17楼
elsaflower 发表于 2024-3-4 11:26 | 只看该作者
微控制器的SPI引脚（通常是SCK - 时钟线、MISO - 主设备输入从设备输出、MOSI - 主设备输出从设备输入，以及NSS/CS - 片选信号）正确连接到LCD屏的SPI接口。
回复

收藏 举报

18楼
wilhelmina2 发表于 2024-3-4 16:00 | 只看该作者
配置SPI外设，设置SPI的时钟频率、工作模式（如主/从模式、CPOL/CPHA极性与时钟相位）、数据宽度（8位、16位等）和片选信号的GPIO口。
回复

收藏 举报

19楼
claretttt 发表于 2024-3-5 09:55 | 只看该作者
可以考虑使用DMA（Direct Memory Access）来发送数据，这样可以减轻CPU的负担。
回复

收藏 举报

20楼
fengm 发表于 2024-3-5 12:12 | 只看该作者
需要选择一个支持硬件SPI接口的LCD屏。 LCD屏需要具有专用的SPI引脚，如SCLK、MOSI、MISO和CS。
回复

收藏 举报

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

本版积分规则

呐咯密密 Image Image
认证：苏州澜宭自动化科技嵌入式工程师
简介：本人从事磁编码器研发工作，负责开发2500线增量式磁编码器以及17位、23位绝对值式磁编码器，拥有多年嵌入式开发经验，精通STM32、GD32、N32等多种品牌单片机，熟练使用单片机各种外设。

568

主题

4087

帖子

56

粉丝
快速回复 在线客服 返回列表 返回顶部