在RT-Thread系统上进一步完善SPI+DMA配置

首先明确遇到的问题

使用 SPI 使用 SPI 接收频率为 1hz，接收频率为 1hz，22f407 主控，有 70 到 70 的发现 CPU 占用率和线程处理后发现 CPU 占用率 20%，占用 CPU 的 00%，线程释放率 0%50%恢复正常，看来这里要笔记本笔记本，便可以使用时钟DMA的连接了。（最后发现是SPI频率配置错误了）

使用SPI+DMA进行要的配置

RTT部分

1.开启RTT设备驱动。>RT-Thread 开启自己的工程驱动设备

2.在board.h中添加宏

开启设备驱动会调用HAL库，点击开启自动启动设备的初始化配置，并将spi注册到设备容器

int rt_hw_spi_init(void)

{

stm32_get_dma_info();

return rt_hw_spi_bus_init();

}

INIT_BOARD_EXPORT(rt_hw_spi_init);

HAL库部分

3.在board.c文件里的下面的函数中，此函数受控设备框架调用以进行初始化

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)

{

GPIO_InitTypeDef GPIO_InitStruct;

if(hspi->Instance == SPI2)

{

    /* Peripheral clock enable */

    __HAL_RCC_SPI2_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();

    /**SPI2 GPIO Configuration，这里配置自己的

    PB13     ------> SPI3_MISO

    PB14     ------> SPI3_SCK

    PB15     ------> SPI3_MOSI

    */

    GPIO_InitStruct.Pin = GPIO_PIN_13| GPIO_PIN_14 | GPIO_PIN_15;

    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

    GPIO_InitStruct.Pull = GPIO_PULLUP;

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;

    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;

    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

}

4.使HAL库-SPI，能够与RTT设备驱动对接

至此基础配置已经完成，下一个是用户配置，配置片选，并挂载到具体的SPI设备

选择想要的io作为一个选择，即一个设备

int spi_device_attach(void)

{

__HAL_RCC_GPIOC_CLK_ENABLE();

__HAL_RCC_GPIOD_CLK_ENABLE();

/*******传感器片选引脚*********/

rt_pin_mode(56, PIN_MODE_OUTPUT); //PD8,配置引脚为输出模式

rt_pin_mode(57, PIN_MODE_OUTPUT); //PD9

rt_pin_mode(58, PIN_MODE_OUTPUT); //PD10

rt_pin_mode(33, PIN_MODE_OUTPUT); //PC1

rt_pin_write(56, PIN_HIGH);//配置初始化引脚高电平（解除片选）

rt_pin_write(57, PIN_HIGH);

rt_pin_write(58, PIN_HIGH);

rt_pin_write(33, PIN_HIGH);

/*这里挂载了四个设备spi2-0,spi2-1,spi2-2,spi2-3*/

rt_hw_spi_device_attach("spi2",ICM20602_SPI_DEVICE_NAME, GPIOD, GPIO_PIN_8);      //片选引脚PD8

rt_hw_spi_device_attach("spi2",SPL06_SPI_DEVICE_NAME, SPL06_CS_GPIO,SPL06_CS_PIN);//片选引脚PD10

rt_hw_spi_device_attach("spi2","spi22", GPIOD,GPIO_PIN_9);//片选引脚PD9

rt_hw_spi_device_attach("spi2","spi23", GPIOC,GPIO_PIN_1);//片选引脚PC1

return RT_EOK;

}

INIT_DEVICE_EXPORT(spi_device_attach);//导出到自动初始化

初始化spi

struct rt_spi_device *spi_dev_icm20602 = RT_NULL; / spi设备句柄 /

int icm20602_spi_device_init(void)

{

struct rt_spi_configuration spi_cfg;

spi_dev_icm20602 = (struct rt_spi_device *)rt_device_find(ICM20602_SPI_DEVICE_NAME);/* 查找 spi2 设备获取设备句柄 */

spi_cfg.data_width = 8;

spi_cfg.mode       = RT_SPI_MASTER | RT_SPI_MODE_0 | RT_SPI_MSB;

spi_cfg.max_hz     = 10000000;  /*10M*/

rt_spi_configure(spi_dev_icm20602,&spi_cfg);

return RT_EOK;

}

/* 导出到自动初始化 */

INIT_COMPONENT_EXPORT(icm20602_spi_device_init);

配置完毕，开始使用

spi智能学习功能实现

/****************************************************************************************

*[url=home.php?mod=space&uid=2666770]@Brief[/url] 读取数据

*@param[in]

*****************************************************************************************/

void icm20602_reg_read(rt_uint8_t addr,rt_uint8_t *rev_buf,rt_uint32_t len)

{

struct rt_spi_message msg1,msg2;

rt_uint8_t reg =  addr|0x80;

msg1.send_buf    = ®

msg1.recv_buf    = RT_NULL;

msg1.length      = 1;

msg1.cs_take     = 1;

msg1.cs_release  = 0;

msg1.next        = &msg2;

msg2.send_buf    = RT_NULL;

msg2.recv_buf    = rev_buf;

msg2.length      = len;

msg2.cs_take     = 0;

msg2.cs_release  = 1;

msg2.next        = RT_NULL;

/*给icm20602设备读取和发送消息*/

rt_spi_transfer_message(spi_dev_icm20602, &msg1);//发送消息

}

/****************************************************************************************

*@brief 写数据

*@param[in]

*****************************************************************************************/

void icm20602_reg_write(rt_uint8_t addr,rt_uint8_t value)

{

struct rt_spi_message msg1;

rt_uint8_t send_buf[2];

send_buf[0] = addr;

send_buf[1] = value;

msg1.send_buf   = send_buf;

msg1.recv_buf   = RT_NULL;

msg1.length     = 2;

msg1.cs_take    = 1;

msg1.cs_release = 1;

msg1.next       = RT_NULL;

rt_spi_transfer_message(spi_dev_icm20602, &msg1);//发送消息

}

解决RTT的SPI设备驱动（drv_spi.c）缺陷（使用DMA）

rt_spi_transfer_message(spi_dev_icm20602, &msg1);发送消息

(这个函数在spi_core.c/后面会提到)

函数会调用这个函数进行数据传输

就是这个

static rt_uint32_t spixfer(struct rt_spi_device *device, struct rt_spi_message *message)

{

HAL_StatusTypeDef state;

rt_size_t message_length, already_send_length;

rt_uint16_t send_length;

rt_uint8_t *recv_buf;

const rt_uint8_t *send_buf;

RT_ASSERT(device != RT_NULL);

RT_ASSERT(device->bus != RT_NULL);

RT_ASSERT(device->bus->parent.user_data != RT_NULL);

RT_ASSERT(message != RT_NULL);

struct stm32_spi *spi_drv =  rt_container_of(device->bus, struct stm32_spi, spi_bus);

SPI_HandleTypeDef *spi_handle = &spi_drv->handle;

struct stm32_hw_spi_cs *cs = device->parent.user_data;

if (message->cs_take)

{

    HAL_GPIO_WritePin(cs->GPIOx, cs->GPIO_Pin, GPIO_PIN_RESET);

}

LOG_D("%s transfer prepare and start", spi_drv->config->bus_name);

LOG_D("%s sendbuf: %X, recvbuf: %X, length: %d",

      spi_drv->config->bus_name,

      (uint32_t)message->send_buf,

      (uint32_t)message->recv_buf, message->length);

message_length = message->length;

recv_buf = message->recv_buf;

send_buf = message->send_buf;

while (message_length)

{

    /* the HAL library use uint16 to save the data length */

    if (message_length > 65535)

    {

        send_length = 65535;

        message_length = message_length - 65535;

    }

    else

    {

        send_length = message_length;

        message_length = 0;

    }

    /* calculate the start address */

    already_send_length = message->length - send_length - message_length;

    send_buf = (rt_uint8_t *)message->send_buf + already_send_length;

    recv_buf = (rt_uint8_t *)message->recv_buf + already_send_length;

    /* start once data exchange in DMA mode */

    if (message->send_buf && message->recv_buf)

    {

        if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG))

        {

            state = HAL_SPI_TransmitReceive_DMA(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length);

        }

        else

        {

            state = HAL_SPI_TransmitReceive(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length, 1000);

        }

    }

    else if (message->send_buf)

    {

        if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG)

        {

            state = HAL_SPI_Transmit_DMA(spi_handle, (uint8_t *)send_buf, send_length);

        }

        else

        {

            state = HAL_SPI_Transmit(spi_handle, (uint8_t *)send_buf, send_length, 1000);

        }

    }

    else

    {

        memset((uint8_t *)recv_buf, 0xff, send_length);

        if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)

        {

            state = HAL_SPI_Receive_DMA(spi_handle, (uint8_t *)recv_buf, send_length);

        }

        else

        {

            state = HAL_SPI_Receive(spi_handle, (uint8_t *)recv_buf, send_length, 1000);

        }

    }

    if (state != HAL_OK)

    {

        LOG_I("spi transfer error : %d", state);

        message->length = 0;

        spi_handle->State = HAL_SPI_STATE_READY;

    }

    else

    {

        LOG_D("%s transfer done", spi_drv->config->bus_name);

    }

    /* For simplicity reasons, this example is just waiting till the end of the

       transfer, but application may perform other tasks while transfer operation

       is ongoing. */

    while (HAL_SPI_GetState(spi_handle) != HAL_SPI_STATE_READY);

}

if (message->cs_release)

{

    HAL_GPIO_WritePin(cs->GPIOx, cs->GPIO_Pin, GPIO_PIN_SET);

}

return message->length;

}

使用 DMA 时也是死等，这让我们失去了在这里使用 DMA 的初衷，现在优化这个函数，在 DMA 传输数据时释放 CPU 去干事

/* For simplicity reasons, this example is just waiting till the end of the

       transfer, but application may perform other tasks while transfer operation

       is ongoing. */

    while (HAL_SPI_GetState(spi_handle) != HAL_SPI_STATE_READY);

添加函数如下，这里的方法是使用信号量释放CPU

static rt_uint32_t spixfer_my(struct rt_spi_device *device, struct rt_spi_message *message, rt_sem_t sem)

{

HAL_StatusTypeDef state;

rt_size_t message_length, already_send_length;

rt_uint16_t send_length;

rt_uint8_t *recv_buf;

const rt_uint8_t *send_buf;

RT_ASSERT(device != RT_NULL);

RT_ASSERT(device->bus != RT_NULL);

RT_ASSERT(device->bus->parent.user_data != RT_NULL);

RT_ASSERT(message != RT_NULL);

struct stm32_spi *spi_drv =  rt_container_of(device->bus, struct stm32_spi, spi_bus);

SPI_HandleTypeDef *spi_handle = &spi_drv->handle;

struct stm32_hw_spi_cs *cs = device->parent.user_data;

if (message->cs_take)

{

    HAL_GPIO_WritePin(cs->GPIOx, cs->GPIO_Pin, GPIO_PIN_RESET);

}

LOG_D("%s transfer prepare and start", spi_drv->config->bus_name);

LOG_D("%s sendbuf: %X, recvbuf: %X, length: %d",

      spi_drv->config->bus_name,

      (uint32_t)message->send_buf,

      (uint32_t)message->recv_buf, message->length);

message_length = message->length;

recv_buf = message->recv_buf;

send_buf = message->send_buf;

while (message_length)

{

    /* the HAL library use uint16 to save the data length */

    if (message_length > 65535)

    {

        send_length = 65535;

        message_length = message_length - 65535;

    }

    else

    {

        send_length = message_length;

        message_length = 0;

    }

    /* calculate the start address */

    already_send_length = message->length - send_length - message_length;

    send_buf = (rt_uint8_t *)message->send_buf + already_send_length;

    recv_buf = (rt_uint8_t *)message->recv_buf + already_send_length;

    /* start once data exchange in DMA mode */

    if (message->send_buf && message->recv_buf)

    {

        if ((spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG) && (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG))

        {

            state = HAL_SPI_TransmitReceive_DMA(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length);

        }

        else

        {

            state = HAL_SPI_TransmitReceive(spi_handle, (uint8_t *)send_buf, (uint8_t *)recv_buf, send_length, 1000);

        }

    }

    else if (message->send_buf)

    {

        if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG)

        {

            state = HAL_SPI_Transmit_DMA(spi_handle, (uint8_t *)send_buf, send_length);

        }

        else

        {

            state = HAL_SPI_Transmit(spi_handle, (uint8_t *)send_buf, send_length, 1000);

        }

    }

    else

    {

        memset((uint8_t *)recv_buf, 0xff, send_length);

        if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)

        {

            state = HAL_SPI_Receive_DMA(spi_handle, (uint8_t *)recv_buf, send_length);

        }

        else

        {

            state = HAL_SPI_Receive(spi_handle, (uint8_t *)recv_buf, send_length, 1000);

        }

    }

    if (state != HAL_OK)

    {

        LOG_I("spi transfer error : %d", state);

        message->length = 0;

        spi_handle->State = HAL_SPI_STATE_READY;

    }

    else

    {

        LOG_D("%s transfer done", spi_drv->config->bus_name);

    }

    /* For simplicity reasons, this example is just waiting till the end of the

       transfer, but application may perform other tasks while transfer operation

       is ongoing. */

    while (HAL_SPI_GetState(spi_handle) != HAL_SPI_STATE_READY)

        {

            rt_sem_take(sem, RT_WAITING_FOREVER);

        }

}

if (message->cs_release)

{

    HAL_GPIO_WritePin(cs->GPIOx, cs->GPIO_Pin, GPIO_PIN_SET);

}

return message->length;

}

替换本文件的方法结构体

static const struct rt_spi_ops stm_spi_ops =

{

.configure = spi_configure,

.xfer = spixfer,

.xfer_my = spixfer_my,

};

好的，drv_spi.c 更改完成

下面更改spi.h文件

同理，替换这个结构体

/**

• SPI operators

*/

struct rt_spi_ops

{

rt_err_t (*configure)(struct rt_spi_device *device, struct rt_spi_configuration *configuration);

rt_uint32_t (*xfer)(struct rt_spi_device *device, struct rt_spi_message *message);

rt_uint32_t (*xfer_my)(struct rt_spi_device *device, struct rt_spi_message *message, rt_sem_t sem);

};

OK，spi.h文件更改完成

下面更改spi_core.c文件

使这个函数支持我们自定义的函数

struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device *device,

struct rt_spi_message *message)

添加功能

struct rt_spi_message *rt_spi_transfer_message_my(struct rt_spi_device *device,

struct rt_spi_message *message, rt_sem_t sem)

{

rt_err_t result;

struct rt_spi_message *index;

RT_ASSERT(device != RT_NULL);

/* get first message */

index = message;

if (index == RT_NULL)

    return index;

result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);

if (result != RT_EOK)

{

    rt_set_errno(-RT_EBUSY);

    return index;

}

/* reset errno */

rt_set_errno(RT_EOK);

/* configure SPI bus */

if (device->bus->owner != device)

{

    /* not the same owner as current, re-configure SPI bus */

    result = device->bus->ops->configure(device, &device->config);

    if (result == RT_EOK)

    {

        /* set SPI bus owner */

        device->bus->owner = device;

    }

    else

    {

        /* configure SPI bus failed */

        rt_set_errno(-RT_EIO);

        goto __exit;

    }

}

/* transmit each SPI message */

while (index != RT_NULL)

{

    /* transmit SPI message */

    result = device->bus->ops->xfer_my(device, index, sem);

    if (result == 0)

    {

        rt_set_errno(-RT_EIO);

        break;

    }

    index = index->next;

}

__exit:

/* release bus lock */

rt_mutex_release(&(device->bus->lock));

return index;

}

在spi.h里新加入这个函数的声明，供外部调用

struct rt_spi_message *rt_spi_transfer_message_my(struct rt_spi_device *device,

struct rt_spi_message *message, rt_sem_t sem);

OK，全部搞定

回过头来

spi智能学习功能实现小改一下

static rt_sem_t spidma_sem = RT_NULL;//定义信号量，供我们的自定义函数使用

void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)

{

rt_sem_release(spidma_sem);//读完成回调，释放信号量

}

void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)

{

rt_sem_release(spidma_sem);//写完成回调，释放信号量

}

/****************************************************************************************

*@brief 读取数据

*@param[in]

*****************************************************************************************/

void icm20602_reg_read(rt_uint8_t addr,rt_uint8_t *rev_buf,rt_uint32_t len)

{

struct rt_spi_message msg1,msg2;

rt_uint8_t reg =  addr|0x80;

msg1.send_buf    = ®

msg1.recv_buf    = RT_NULL;

msg1.length      = 1;

msg1.cs_take     = 1;

msg1.cs_release  = 0;

msg1.next        = &msg2;

msg2.send_buf    = RT_NULL;

msg2.recv_buf    = rev_buf;

msg2.length      = len;

msg2.cs_take     = 0;

msg2.cs_release  = 1;

msg2.next        = RT_NULL;

/*给icm20602设备读取和发送消息*/

rt_spi_transfer_message_my(spi_dev_icm20602, &msg1, spidma_sem);//发送消息

}

/****************************************************************************************

*@brief 写数据

*@param[in]

*****************************************************************************************/

void icm20602_reg_write(rt_uint8_t addr,rt_uint8_t value)

{

struct rt_spi_message msg1;

rt_uint8_t send_buf[2];

send_buf[0] = addr;

send_buf[1] = value;

msg1.send_buf   = send_buf;

msg1.recv_buf   = RT_NULL;

msg1.length     = 2;

msg1.cs_take    = 1;

msg1.cs_release = 1;

msg1.next       = RT_NULL;

rt_spi_transfer_message_my(spi_dev_icm20602, &msg1, spidma_sem);//发送消息

}

全部完成，可以愉快的使用spi+dma干活了

CPU，DMA用于干活不累^ _ ^

" class="reference-link">最后附上一张导图

第一次写这么长的文章，有恰到好处还请批评指正~

原作者：my_dream