(STM32)从零开始的RT-Thread之旅--SPI驱动ST7735(3)使用DMA

已于 2023-02-03 17:22:22 修改
阅读量2.4k 收藏 20
点赞数 5
分类专栏： RT-Thread 文章标签： stm32 单片机 嵌入式硬件 STM32H7 rtthread
于 2022-11-22 14:55:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwe5959798/article/details/127968974
版权

上一篇完成了ST7735驱动的移植，并已经可以通过SPI在屏幕上显示字符了，这一章会把SPI修改为DMA的传输方式。由于RTT对于STM32H7的SPI的DMA传输方式目前支持的并不好，这就让上一章裸机方式驱动屏幕派上了用场。我们可以先把SPI+DMA打通，然后再修改内核驱动框架。

1.不使用驱动框架

把上一章中开启使用RTT驱动框架中的SPI的宏定义注释掉：

然后一定要在配置SPI前使能DMA的时钟：

然后到 stm32h7xx_hal_msp.c 中SPI引脚初始化下面添加相应SPI的DMA配置：

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
  if(hspi->Instance==SPI4)
  {
    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPI4;
    PeriphClkInitStruct.Spi45ClockSelection = RCC_SPI45CLKSOURCE_D2PCLK1;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    {
      Error_Handler();
    }
    __HAL_RCC_SPI4_CLK_ENABLE();

    __HAL_RCC_GPIOE_CLK_ENABLE();
    /**SPI4 GPIO Configuration
    PE12     ------> SPI4_SCK
    PE14     ------> SPI4_MOSI
    */
    GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_14;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF5_SPI4;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_12, GPIO_PIN_SET);

    /* SPI4 DMA Init */
    /* SPI4_TX Init */
    hdma_spi4_tx.Instance = DMA1_Stream0;
    hdma_spi4_tx.Init.Request = DMA_REQUEST_SPI4_TX;
    hdma_spi4_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi4_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi4_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi4_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi4_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi4_tx.Init.Mode = DMA_NORMAL;
    hdma_spi4_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
    hdma_spi4_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    hdma_spi4_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    hdma_spi4_tx.Init.MemBurst = DMA_MBURST_SINGLE;
    hdma_spi4_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_DeInit(&hdma_spi4_tx) != HAL_OK)
    {
      Error_Handler();
    }
    if (HAL_DMA_Init(&hdma_spi4_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(hspi,hdmatx,hdma_spi4_tx);

    HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);

    HAL_NVIC_SetPriority(SPI4_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(SPI4_IRQn);
  }
}

这里注意外设和内存对齐：

要和SPI前面配置的数据位数一致，我这里前面是：

还有就是配置结尾要打开相关中断，这里我只使用发送：

此时配置基本已经完成，相关配置详细信息可以参考我文末附的几篇教程，都写得很好很详细。

开启中断后，就必须要有中断函数，最最最开始的那一章我提到过，有关CubeMX生成的中断函数的那个.c我们没有加进整个工程里面，所以有些在CubeMX中添加了响应的中断，但是函数需要我们自己再添加进来，这里我添加的函数是：

这里添加的函数需要根据SPI配置的是双工还是单工来选择，所有的回调如下：

这里即使用的双工，也可以只配置一边是DMA，比如我使用的全双工，TX和RX都使用DMA，每次发送和接收只需调用 HAL_SPI_TransmitReceive_DMA ，它既包含发送又包含接收，那触发的中断肯定是 HAL_SPI_TxRxCpltCallback 了。这些由名字很好推断不再赘述。

剩下还需要修改的就是发送的数据所在内存。因为DMA1和2不能访问RTT Studio默认的RAM，默认RAM是从0x2000 0000开始，大小为128K的空间。像我使用的STM32H743VIT6这块芯片，有1M的RAM，但是实际上是分散为几块的，这里修改链接文件：

这里不要直接双击，而要选择打开方式：

这里根据芯片手册，添加剩余的RAM：

在.bss段后添加（ld脚本不熟悉可以看我很早之前写的关于GCC下stm32的ld文件的解析）：

这里我们就定义了一个名叫.spi4.txbuf的段，然后把这个段的全部数据放在RAM4的地址范围内。接下来，我们只需要把想要通过SPI的DMA传输的数据保存在这个段内就可以了。在GCC编译器下可以使用__attribute__ 关键字：

uint8_t ram4_spi4_buf[RAM4_SPI4_BUF] __attribute__((section(".spi4.txbuf")));

然后在map文件中查看是否定义成功：

可以看到ram4_spi4_buf这个数组使用了0x3800 0000~0x3800 0400这段地址空间。 这段空间是可以被DMA1访问的。

使用DMA之后最后还需要注意cache设置，这里可能出现数据一致性问题。什么是数据一致性问题？

当MCU运行频率过高时，代码执行效率就会收到RAM频率影响，因为很多时候代码执行需要把寄存器的数据加载到RAM中或者从RAM中读取到寄存器中，但是RAM的频率比MCU低时，MCU必须等待RAM的读写操作，大大降低了MCU的执行效率。这时候出现了一种方案，在RAM和MCU之间多加一块缓存，就是cache，它的读写很快能够跟上MCU，每次MCU需要RAM数据时，会先取一部分数据保存在cache中，如果MCU需要的数据已经在cache中有了，那就直接使用cache中的即可。这就会出现一个问题，我们DMA一定使用的是RAM到外设，而MCU有可能使用的cache中的缓存数据，这两个数据是每时每刻都一样的吗？肯定不是，MCU<-CACHE<-RAM，这cache和RAM之间数据肯定是需要时机和一定时间同步的，说到底，快只是快在MCU和cache已经保存有MCU需要的RAM数据的情况，当MCU需要的数据cache里面没有时，cache一样需要慢慢等待RAM的数据备份到cache里。当MCU需要的数据在cache中存在时，即使DMA改变了RAM中相应的数据，MCU并不知道，它还是会使用cache中的缓存数据，此时就会出现一致性问题。更多详细内容可以参考文末附的文章。

要解决这个问题，我们可以通过配置MPU来关闭某块内存的cache功能。 在 hw_board_init 中可以看到，当有定义使能cache的函数时，会自动调用这些函数：

在这之前我们配置RAM4的MPU：

完整函数如下：

/**
 * This function will initial STM32 board.
 */
void hw_board_init(char *clock_src, int32_t clock_src_freq, int32_t clock_target_freq)
{
    extern void rt_hw_systick_init(void);
    extern void clk_init(char *clk_source, int source_freq, int target_freq);
    
    MPU_Region_InitTypeDef MPU_InitStruct;
    HAL_MPU_Disable();
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x38000000;
    MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

    HAL_MPU_ConfigRegion(&MPU_InitStruct);
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

#ifdef SCB_EnableICache
    /* Enable I-Cache---------------------------------------------------------*/
    SCB_EnableICache();
#endif

#ifdef SCB_EnableDCache
    /* Enable D-Cache---------------------------------------------------------*/
    SCB_EnableDCache();
#endif

    /* HAL_Init() function is called at the beginning of the program */
    HAL_Init();

    /* enable interrupt */
    __set_PRIMASK(0);
    /* System clock initialization */
    clk_init(clock_src, clock_src_freq, clock_target_freq);
    /* disbale interrupt */
    __set_PRIMASK(1);

    rt_hw_systick_init();
    /* Pin driver initialization is open by default */
#ifdef RT_USING_PIN
    extern int rt_hw_pin_init(void);
    rt_hw_pin_init();
#endif

    /* USART driver initialization is open by default */
#ifdef RT_USING_SERIAL
    extern int rt_hw_usart_init(void);
    rt_hw_usart_init();
#endif

}

如果你使用的不是RAM4，可以只简单修改起始地址和大小。

最后回到mspi.c中修改发送接收函数。其中 mspi_send_reg 与 mspi_read_reg 函数我决定不再修改，因为读写reg通常都是一个字节，而使用DMA需要先把我们需要传输的数据copy到 ram4_spi4_buf 这个分配在RAM4的buf中，再使用SPI_DMA传输函数发送，感觉提升并不明显。所以只修改了 mspi_send_data 函数，它通常用来发送需要显示的大量数据，修改如下：

可以看到主要就是先把数据copy到ram4_spi4_buf里，然后用专用于DMA发送的HAL_SPI_Transmit_DMA函数传输。这里DMA传输用的是阻塞等待，发送前把一个全局状态置为busy，等待发送完成后的回调函数里再把状态置idle：

这个函数前面讲需要添加的中断里已经见到过了 ，至于状态定义，如下：

至此所有修改已经完成，正常已经可以测试DMA是否使用正常。 

2.使用驱动框架

首先在board.h中添加使用SPI的TX的DMA的宏定义：

此时编译会发现有好几个错误：

那是因为内核驱动框架根本没有适配STM32H7，我们先修改drv_dma.h中对于DMA相关结构体定义：

然后再修改dma_config.h中对于SPI4的配置：

这里可以根据上面不使用内核驱动框架的时候的 stm32h7xx_hal_msp.c 中的配置修改，反正使用DMA1还是2的哪个流都可以。注意H7没有channel，但有request。 然后配置完成后，就可以把 stm32h7xx_hal_msp.c 中相关配置给注释掉了。这些配置实际应用是在 spi_config.h 中：

有关这些配置的使用都在drv_spi.c中的rt_hw_spi_bus_init函数里，对照上面注释掉的配置，修改如下，具体参数请根据实际需求配置：

注意drv_spi.c中是有SPI4_IRQHandler和SPI4_DMA_TX_IRQHandler中断函数的，所以请注意mspi.c中的中断函数会和它重复定义，请把mspi.c中的中断函数加到USE_RTT_SPI宏定义else代码块内。

添加完这些正常应该可以使用了，但是实际使用会发现代码卡在，返回状态一直是HAL_SPI_STATE_BUSY_TX：

调用它的上层函数是spixfer ：

在这个函数中可以看到当只有发送buf，且使能了TX发送DMA时调用的是：

这个函数中正常发送会把hspi->State 赋值为HAL_SPI_STATE_BUSY_TX：

而这个状态在发送完成后没有被修改回来就会一直处于busy状态，它是在哪里被修改回来呢？

答案是 HAL_SPI_IRQHandler 函数 。而RTT内核默认是没有使用SPI的中断传输方式的，这可以从 spixfer 这个函数中调用的底层发送接收函数得知，所以当开启DMA后，又没有开启SPI中断就会出现这种情况。可以在中断函数内打上断点测试：

修改方式也很简单，假如没有使用RTT，可以直接在DMA使能中断的地方直接添加SPI中断配置与使能，这里我介绍一下在使用RTT下如何修改。在drv_spi.h中修改结构体：

在spi_config.h中添加：

在 drv_spi.c 中初始化函数 stm32_spi_init 的最后使能DMA中断处添加：

至此框架修改完毕，最后在上一章的基础上修改我们的发送接收函数，因为我们调用的是驱动框架的接口，不修改接口的情况下没办法像不使用框架那样，把普通SPI传输和SPI-DMA传输混合使用，这里只能都使用DMA传输，修改如下：

其他几个函数附在文章最后，仅供参考。 

mspi.c 

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-11-14     cx       the first version
 */
#include<string.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <stm32h7xx.h>
#include <drv_spi.h>
#include <mspi.h>
#include "st7735_reg.h"
#include "st7735.h"
enum
{
    idle,
    busy,
    error
};
volatile uint32_t spi4_dma_status = idle;

uint8_t ram4_spi4_buf[RAM4_SPI4_BUF] __attribute__((section(".spi4.txbuf")));


#define USE_RTT_SPI

SPI_HandleTypeDef *spi_handle;

#ifdef USE_RTT_SPI

static struct rt_spi_device *spi_lcd;

#define LCD_RD_HIGH rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH)
#define LCD_RD_LOW  rt_pin_write(SPI_RD_PIN_NUM, PIN_LOW)
#else
extern SPI_HandleTypeDef hspi4;
#define SPI_Drv (&hspi4)
#define LCD_CS_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_SET)
#define LCD_CS_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_RESET)

#define LCD_RD_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET)
#define LCD_RD_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_RESET)
#endif

#ifdef USE_RTT_SPI
int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    uint32_t remsg = RT_NULL;
    ram4_spi4_buf[0] = reg;
    memcpy(&ram4_spi4_buf[1],data,len);
    msg.send_buf = &ram4_spi4_buf[0];
    msg.recv_buf = RT_NULL;
    msg.length = 1;
    msg.cs_take = 1;
    msg.cs_release = 0;
    msg.next = RT_NULL;
    LCD_RD_LOW;
    remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    LCD_RD_HIGH;
    if(len > 0)
    {
        msg.send_buf = &ram4_spi4_buf[1];
        msg.recv_buf = RT_NULL;
        msg.length = len;
        msg.cs_take = 0;
        msg.cs_release = 1;
        msg.next = RT_NULL;
        remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    }
    if(remsg!=RT_NULL)
        return -1;
    else
        return 0;
}
int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
{
    struct rt_spi_message msg;
    uint32_t remsg = RT_NULL;
    ram4_spi4_buf[0] = reg;
    msg.send_buf = &ram4_spi4_buf[0];
    msg.recv_buf = RT_NULL;
    msg.length = 1;
    msg.cs_take = 1;
    msg.cs_release = 0;
    msg.next = RT_NULL;
    LCD_RD_LOW;
    remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    LCD_RD_HIGH;
    if(remsg == 0)
    {
        msg.send_buf = RT_NULL;
        msg.recv_buf = data;
        msg.length = 1;
        msg.cs_take = 0;
        msg.cs_release = 1;
        msg.next = RT_NULL;
        remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    }
    if(remsg!=RT_NULL)
        return -1;
    else
        return 0;
}
int32_t mspi_send_data(uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    memcpy(ram4_spi4_buf,data,len);
    msg.send_buf = ram4_spi4_buf;
    msg.recv_buf = RT_NULL;
    msg.length = len;
    msg.cs_take = 1;
    msg.cs_release = 1;
    msg.next = RT_NULL;
    return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
}
int32_t mspi_read_data(uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    msg.send_buf = RT_NULL;
    msg.recv_buf = data;
    msg.length = len;
    msg.cs_take = 1;
    msg.cs_release = 1;
    msg.next = RT_NULL;
    return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
}

#else
int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
{
    int32_t result;
    LCD_CS_LOW;
    LCD_RD_LOW;
    result = HAL_SPI_Transmit(SPI_Drv,&reg,1,100);
    LCD_RD_HIGH;
    if(len > 0)
        result += HAL_SPI_Transmit(SPI_Drv,data,len,500);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}

int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
{
    int32_t result;
    LCD_CS_LOW;
    LCD_RD_LOW;

    result = HAL_SPI_Transmit(SPI_Drv,&reg,1,100);
    LCD_RD_HIGH;
    result += HAL_SPI_Receive(SPI_Drv,data,1,500);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}

int32_t mspi_send_data(uint8_t *data,uint32_t len)
{
    int32_t result;
    memcpy(ram4_spi4_buf,data,len);
    LCD_CS_LOW;
//    result =HAL_SPI_Transmit(SPI_Drv,data,len,100);
    spi4_dma_status = busy;
    if(HAL_SPI_Transmit_DMA(SPI_Drv,ram4_spi4_buf,len) != HAL_OK)
    {
        rt_kprintf("SPI4 DMA trans err\n");
        return -1;
    }
    else
    {
        while(spi4_dma_status==busy);
        result = 0;
    }
    LCD_CS_HIGH;
    if(result>0)
    {
        result = -1;
    }
    else
    {
        result = 0;
    }
    return result;
}

int32_t mspi_read_data(uint8_t *data,uint32_t len)
{
    int32_t result;
    LCD_CS_LOW;
    result = HAL_SPI_Receive(SPI_Drv,data,len,500);
    LCD_CS_HIGH;
    if(result>0)
    {
        result = -1;
    }
    else
    {
        result = 0;
    }
    return result;
}

extern DMA_HandleTypeDef hdma_spi4_tx;

void DMA1_Stream0_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&hdma_spi4_tx);
}
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
{
    spi4_dma_status = idle;
}
void SPI4_IRQHandler(void)
{
  HAL_SPI_IRQHandler(&hspi4);
}
void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)
{
    spi4_dma_status = error;
}

#endif
int32_t mspi_get_tick(void)
{
    return HAL_GetTick();
}
void mspi_rw_gpio_init(void)
{
#ifdef USE_RTT_SPI
    rt_pin_mode(SPI_RD_PIN_NUM, PIN_MODE_OUTPUT);
    rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH);
#else
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    __HAL_RCC_GPIOE_CLK_ENABLE();
    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_11|GPIO_PIN_13, GPIO_PIN_SET);
    GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_13;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
#endif
}
void mspi_init(void)
{
    mspi_rw_gpio_init();
#ifdef USE_RTT_SPI
    struct rt_spi_configuration cfg;
    rt_hw_spi_device_attach("spi4", "spi40", GPIOE, GPIO_PIN_11);
    spi_lcd = (struct rt_spi_device *)rt_device_find("spi40");
    if(!spi_lcd)
    {
        rt_kprintf("spi40 can't find\n");
    }
    else
    {
        spi_lcd->bus->owner = spi_lcd;
        cfg.data_width = 8;
        cfg.mode = RT_SPI_MASTER | RT_SPI_3WIRE | RT_SPI_MODE_0 | RT_SPI_MSB;
        cfg.max_hz = 12.5 * 1000 * 1000;
        rt_spi_configure(spi_lcd, &cfg);
    }
    //也可以初始化使用框架提供的函数，发送接收使用HAL库函数，操作对象就是下面的 spi_handle
//    struct stm32_spi *spi_drv =  rt_container_of(spi_lcd->bus, struct stm32_spi, spi_bus);
//    spi_handle = &spi_drv->handle;
#else
    __HAL_RCC_DMA1_CLK_ENABLE();
    hspi4.Instance = SPI4;
    hspi4.Init.Mode = SPI_MODE_MASTER;
    hspi4.Init.Direction = SPI_DIRECTION_1LINE;
    hspi4.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi4.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi4.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi4.Init.NSS = SPI_NSS_SOFT;
    hspi4.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
    hspi4.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi4.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi4.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi4.Init.CRCPolynomial = 0x0;
    hspi4.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    hspi4.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
    hspi4.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
    hspi4.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    hspi4.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    hspi4.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
    hspi4.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
    hspi4.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
    hspi4.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
    hspi4.Init.IOSwap = SPI_IO_SWAP_DISABLE;
    if (HAL_SPI_Init(&hspi4) != HAL_OK)
    {
      rt_kprintf("ERROR\n");
    }
#endif
}

参考文章：

【STM32H7教程】第72章 STM32H7的SPI总线基础知识和HAL库API

【STM32H7教程】第94章 STM32H7的SPI总线应用之双机通信（DMA方式）

 STM32 H7 配置SPI&DMA小结

STM32H7---高速缓存Cache(一)

我我我只会printf
关注
专栏目录
STM32的SPI采用DMA方式传输测试
qq_44949768的博客
04-22 1806
STM32的SPI采用DMA方式传输测试
基于STM32f103c6t6芯片，使用HAl库的硬件SPI+DMA的驱动ST7735s芯片的keil工程包含CubeMX工程
04-23
2、驱动ST7735s芯片的1.8寸spi屏幕 3、资源包含了CubeMX工程文件和对应的Keil工程 4、配置好了硬件SPI以及DMA 5、注意：工程内配置了屏幕的按键，但是并未使用 6、工程内已经配置好了串口2，并且配置了对应的DMA，...
STM32f103+RGB-TFT_LCD(ST7735)+硬件SPI+DMA+CUBEMX配置
08-13
MCU:STM32f103 LCD: 128*160 ST7735 SPI :18MHZ 硬件SPI（spi1）+ DMA传输
ST7735+stm32硬件SPI+DMA.zip
04-01
使用STM32f103单片机驱动TFT液晶彩屏，使用硬件SPI1 CLK 36MHz + DMA，液晶屏驱动芯片ST7735，分辨率128*160（程序内宏控制，不同分辨率改一下宏就行），实测全屏刷新时间12ms左右，每秒可刷75帧左右，主要代码有中文注释
（学习记录）使用HAL库 STM32CubeMX——spi（DMA）配置OLED
最新发布
Wang2869902214的博客
09-25 1438
（学习记录）使用STM32CubeMX配置硬件SPI利用江科大代码驱动OLED显示屏 外加DMA驱动OLED显示屏
解决rt-thread上使用SPI+DMA
响望的博客
12-07 5964
首先阐述下遇到的问题 使用SPI读取icm20602数据，读取频率为1000hz，使用stm32f407主控，发现CPU占用率达到了70%，将此线程注释掉后CPU占用率掉到25%，看来这里要着重优化，便萌生了使用DMA的想法。 使用SPI+DMA要进行的配置 1.开启RTT设备驱动。点击自己的工程 ->RT-Thread Setting2.在board.hzhong3.在board.c文件里加入以下函数，此函数受设备框架调用 void HAL_SPI_MspInit(SPI_HandleTypeDef
RT-Thread：SPI万能驱动 SFUD 驱动Flash W25Q64，通过 STM32CubeMX 配置 STM32 SPI 驱动
yutian0606的博客
01-09 2592
说明：RT-Thread 系统 使用SPI万能驱动 SFUD 驱动 Flash W25Q64，通过 STM32CubeMX 配置 STM32 SPI 驱动。
STM32F1基于HAL库DMA方式驱动ST7735 1.8‘‘屏幕demo
perseverance51博客
07-10 2236
STM32F1基于HAL库DMA方式驱动ST7735 1.8‘‘屏幕demo
stm32f103c8t6软件spi驱动st7735s屏幕
09-25
在本项目中，我们将探讨如何使用STM32F103C8T6通过软件SPI来驱动ST7735S屏幕。 1. **STM32F103C8T6与SPI通信**： STM32F103C8T6包含多个SPI接口，可以作为主设备控制其他外设。SPI通信基于四线制同步串行协议，...
stm32f103rct6 st7735 硬件spi＋dma驱动
10-18
stm32f103rct6 st7735 硬件spi＋dma驱动 1，驱动为st7735s 2，屏幕尺寸为128x160，可修改 3，连接到rct6的spi1接口，里面的显示图片和显示颜色采用dma传输。 4，带有fatfs文件系统，可用
STM32F103C8T6HAL库模拟SPI ST7735屏幕驱动
04-14
在标题和描述中提到的"STM32F103C8T6HAL库模拟SPI"，是指在STM32F103C8T6上使用HAL库来实现SPI（Serial Peripheral Interface）通信协议的模拟。SPI是一种同步串行通信接口，常用于连接微控制器和外部设备，如LCD...
STM32的使用之SPI通信DMA模式
08-03
MCU:STM32F303VC，在SPI通信中，可以同时开启发送和接收DMA请求，自动数据的发送和接收，完成数据的交换。
八针LCD彩色屏 ST7735S驱动芯片 SPI接口
08-07
23年电赛E题附加题作品 八针LCD彩色屏 ST7735S驱动芯片 SPI接口
硬件SPI+DMA驱动0.96寸ST7735S（含代码）
abc565846881的博客
01-10 2275
前段时间做了一个软件模拟SPI驱动ST7735S的0.96寸彩屏，但是觉得屏幕的刷新率不太够用，于是打算改用硬件SPI+DMA的方式。具体ST7735S的底层逻辑以及如何根据数据手册设计底层驱动我前面的文章有讲解，感兴趣的可以先去看一下更好理解。
RT-Thread下的串口驱动程序分析【转载】
weixin_33824363的博客
08-29 981
编写本文稿的目的，在于通过分析stm32平台上的串口中断源码，学习 RTT中如何编写中断处理程序 如何编写RTT设备驱动接口代码 了解串行设备的常见处理机制 先以RTT官方源码中的STM32 BSP包来分析。rt-thread\bsp\stm32f10x 下,涉及的文件为： usart.c usart.h serail.c serail.h RTT的设备驱动程序概述 编写u...
RT-thread 设备驱动组件之SPI设备
weixin_33749131的博客
07-18 956
本文主要介绍RT-thread中的SPI设备驱动，涉及到的文件主要有：驱动框架文件（spi_dev.c，spi_core.c，spi.h），底层硬件驱动文件（spi_hard.c，spi_hard.h）。这里spi_hard.c和spi_hard.h是指利用MCU的硬件SPI接口，而不是通过GPIO口来模拟SPI时序。应用SPI设备驱动时，需要在rtconfig.h中宏定义#define...
STM32开发(屏幕驱动ST7735S-SPI方式)用RT-Thread驱动测试
scl8295的博客
02-28 1028
【代码】STM32开发(屏幕驱动ST7735S-SPI方式)用RT-Thread驱动测试。
【原理学习】rt-thread SPI 双向DMA驱动的开发
weixin_41892612的博客
10-24 1925
问题描述 之前开发程序的时候是直接使用的 硬件 SPI 采用 DMA 方式来释放CPU，但是一直没有使用 rt_thread 原来的 DMA 历程，原因是原生的 drv_spi 驱动，实际上没有发挥DMA的真实性能，虽然开启DMA但是还是要等数据发送完成之后才释放CPU: 当发送数据较长，且比较密集的时候如果采用死等的方发送数据就会导致数据发送性能极差，如何将这个死等的时间释放出来且发送和接收数据需要灵活可控 先看电路图： 说明：此时SPI是通讯的交互的重点，十分密集 IRQ_NRF1: 值做个32的一中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值