最近遇到了如下需求：

MCU作為主控芯片通過SPI與藍牙芯片連接。
藍牙芯片會時不時向MCU發送大量定長的數據包。
這種情況下，如果MCU的SPI接口采用主模式，通過查詢的方式詢問藍牙芯片是否有數據要發送，就會非常占用資源，并且遇到突發大量數據也可能會來不及處理。

比較好的一種方法是，MCU采用從模式的SPI。藍牙芯片無腦向MCU吐數據。如果主控MCU的SPI時鐘最大頻率大于藍牙芯片的SPI最大頻率，此方法可以跑到藍牙芯片SPI的傳輸極限。

大體思路：

初始化SPI為從模式，并為SPI_CS引腳注冊中斷函數，下降沿觸發
在中斷函數中，啟動SPI的接收。
SPI接收完成后，做其他處理，比如解析，轉發等

代碼實現

下面是如何實現，平臺采用了STM32F1系列芯片，啟用SPI DMA傳輸，RT-Thread 4.0.2，SPI約定為Slave，MODE3，MSB，CS active low。一次傳輸長度為package_length。

使用內存池+郵箱的緩沖方式，當然也可以使用消息隊列，根據自己的喜好。此處對中斷做了底半處理。

初始化
SPI初始化
static struct rt_spi_device spi_device; //
static struct stm32_hw_spi_cs spi_cs; //中斷引腳
static int spi_init(void)
{
rt_pin_mode(CS_PIN, PIN_MODE_INPUT_PULLUP);
/ attach the device to spi bus /
spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device));
RT_ASSERT(uwb_device != RT_NULL);
spi_cs = (struct stm32_hw_spi_cs )rt_malloc(sizeof(struct stm32_hw_spi_cs));
RT_ASSERT(uwb_spi_cs != RT_NULL);
spi_cs->GPIOx = GPIOA;
spi_cs->GPIO_Pin = 4;
result = rt_spi_bus_attach_device(uwb_device, "spi10", "spi1", (void )uwb_spi_cs);
if (result != RT_EOK)
{
LOG_E("%s attach to %s faild, %dn", "spi10", "spi1", result);
return result;
}
LOG_D("%s attach to %s done", UWB_SPI_NAME, UWB_SPI_BUS);
/ get SPI bus /
spi_device->bus->owner = spi_device;
/ configure SPI device /
{
struct rt_spi_configuration cfg;
cfg.data_width = 8;
cfg.mode = RT_SPI_SLAVE | RT_SPI_MODE_3 | RT_SPI_MSB;
cfg.max_hz = 8 * 1000 * 1000;
rt_spi_configure(spi_device, &cfg);
}
if (rt_device_open((rt_device_t)spi_device, RT_DEVICE_FLAG_DMA_RX) != RT_EOK)
{
LOG_E("open UWB SPI device %s error.", "spi10");
return -RT_ERROR;
}
return RT_OK;
}
！！！注意，這里需要修改一下rt_spi_configure函數中的宏定義RT_SPI_MODE_MASK，從

(RT_SPI_CPHA | RT_SPI_CPOL | RT_SPI_MSB)
改為

(RT_SPI_SLAVE | RT_SPI_CPHA | RT_SPI_CPOL | RT_SPI_MSB)

否則無法將SPI接口配置為從模式，調用rt_spi_revice_message會崩潰。

初始化信號量，郵箱和內存池
/* create RX semaphore /
spi_start_sem = rt_sem_create("spi1_start", 0, RT_IPC_FLAG_FIFO);
/ create RX mp /
spi_mp = rt_mp_create("spi_mp", SPI_MB_LEN, RT_ALIGN(sizeof(rt_uint8_t), sizeof(intptr_t)) * package_length);
/ create RX mailbox /
rt_mb_init(&spi_mb, "UWB_mb", &spi_mb_pool[0], sizeof(spi_mb_pool) / 4, RT_IPC_FLAG_FIFO);
為CS引腳綁定中斷函數
rt_pin_attach_irq(4, PIN_IRQ_MODE_FALLING, (void ( )(void *))spi_cs_isr, RT_NULL);

此時，可以先不使能中斷，可以等待系統所有初始工作完成后，由其他線程使能中斷，以啟動SPI接收。

到此，初始化的工作就完成了。接下來，要進行數據的接收工作，為此我們需要創建一些其他的函數。

數據的接收

首先我們需要創建一個中斷函數，這個中斷函數通過CS引腳的下降沿觸發，用來通知系統開始接收數據。

static void spi_cs_isr(void)
{
/* enter interrupt /
rt_interrupt_enter();
rt_sem_release(spi_start_sem);
/ leave interrupt */
rt_interrupt_leave();
}

然后，我們還需要：一個線程用來啟動DMA接收；一個中斷函數用于通知系統DMA接收已經完成。

使用DMA方式的好處是，全部的SPI接收過程可以交給DMA。這種非阻塞的方式使得，系統在這個時候可以搞搞其他事情（相當于雙線程？？？）。在SPI大量傳輸數據時尤其好用。

static uint8_t *rx_buff = RT_NULL;
static void spi_start_thread_entry(void *parameter)
{
struct rt_spi_message spi_msg;
spi_msg.send_buf = RT_NULL;
spi_msg.length = uwb_package_length;
spi_msg.cs_take = 0;
spi_msg.cs_take = 0;
spi_msg.next = RT_NULL;
while (1)
{
if (rt_sem_take(spi_start_sem, RT_WAITING_FOREVER) == RT_EOK)
{
rx_buff = rt_mp_alloc(spi_mp, RT_WAITING_NO);
if (rx_buff != RT_NULL)
{
rt_spi_revice_message(spi_device, &spi_msg);
}
}
}
}

這里使用了RT_WAITING_NO的方式來申請空間，如果沒有申請到(緩沖區已滿)，就拋棄這條數據。

使用rt_spi_revice_message函數來啟動DMA接收，并且約定了接收的長度固定為package_length。

DMA接收完成函數

void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
{
if (hspi->Instance == SPI1)
{
if (rx_buff != RT_NULL)
{
rt_mb_send(&spi_mb, (rt_uint32_t)rx_buff); //發送郵件
}
}
}

最后，還需要一個線程用于處理接收到的數據

static void spi_dma_clp_thread_entry(void *parameter)
{
rt_uint8_t *net_tx_buff = RT_NULL;
while (1)
{
if (rt_mb_recv(&uwb_mb, (rt_ubase_t *)&net_tx_buff, RT_WAITING_FOREVER) == RT_EOK)
{
//TODO
//data process
}
rt_mp_free(net_tx_buff);
net_tx_buff = RT_NULL;
}
}

到此，基于RT-Thread的SPI從接收就基本完成了。這些只是一個大體的思路，也可以使用自己喜歡的方式，或者添加其他的功能。如果大家有更好的思路，歡迎分享出來。