FreeRTOS：信号量是否适用于SPI转TCP代理MCU节点通信？

你当前开发的是基于FreeRTOS的SPI主设备与TCP数据互转代理，从设备通过GPIO中断触发SPI数据读取。先看你提供的代码：

char buffer1 [128];
char buffer2[128];
static QueueHandle_t rdySem1; //semaphore
static QueueHandle_t rdySem2; //semaphore
volatile atomic int GPIO_interrupt_pin;

void SPI_task(void* arg)
{
 while(1)
 {
  if (GPIO_interrupt_pin)
   {
   //TODO:read data from SPI bus and place in buffer1
   xSemaphoreGive(rdySem1);
   GPIO_interrupt_pin = 0;
   } 
 xSemaphoreTake(rdySem2, portMAX_DELAY);
 //TODO:send data from buffer2[] to SPI bus
 }
}

void tcp_task(void* arg)
{
 while(1)
 {
  int len; 
  char rx_buffer[128];
  len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0);
  if (len>0)
  {
   //TODO:process data from TCP socket and place in buffer2
   xSemaphoreGive(rdySem2);
  } 
 xSemaphoreTake(rdySem1, portMAX_DELAY);
 //TODO:send data from buffer1[] to TCP
 }
}

//only run when GPIO pin interrupt triggers
static void isr_handler(void* arg)
{
 GPIO_interrupt_pin = 1;
}

现有实现的问题 #

• GPIO中断处理低效且不可靠：用全局变量GPIO_interrupt_pin让SPI_task轮询的方式，会持续占用CPU资源；而且如果SPI_task正阻塞在xSemaphoreTake(rdySem2)上，根本无法响应GPIO中断的触发，导致从设备的数据无法及时读取。
• 全局缓冲区无同步保护：buffer1和buffer2是全局变量，SPI_task和tcp_task同时访问时会存在数据竞争，可能导致数据错乱。
• 任务逻辑阻塞冲突：SPI_task在轮询GPIO后直接阻塞等待rdySem2，如果没有TCP数据下发，任务会一直休眠，无法处理新的GPIO中断；tcp_task同理，recv如果是阻塞调用，再加上xSemaphoreTake的阻塞，可能导致SPI过来的数据无法及时发送到TCP。
• 信号量初始化缺失：代码中只声明了rdySem1和rdySem2，但没有调用xSemaphoreCreateBinary()完成初始化，运行时会出错。

优化方向与正确实现方式 #

1. 用信号量替代全局变量处理GPIO中断 #

FreeRTOS推荐在中断中直接通过信号量唤醒任务，避免轮询。修改ISR和SPI_task：

static SemaphoreHandle_t gpio_int_sem;

// 初始化（在任务创建前执行）
gpio_int_sem = xSemaphoreCreateBinary();

static void isr_handler(void* arg)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // 在ISR中必须使用FromISR版本的API
    xSemaphoreGiveFromISR(gpio_int_sem, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void SPI_task(void* arg)
{
 while(1)
 {
  // 阻塞等待GPIO中断触发，无CPU占用
  xSemaphoreTake(gpio_int_sem, portMAX_DELAY);
  // 读取SPI数据
  // TODO:read data from SPI bus and place in buffer1
  // 通知TCP任务发送数据
  xSemaphoreGive(rdySem1);

  // 处理TCP下发的SPI发送请求（非阻塞，优先保证中断响应）
  if(xSemaphoreTake(rdySem2, 0) == pdTRUE)
  {
      // TODO:send data from buffer2[] to SPI bus
  }
 }
}

2. 保证缓冲区的线程安全 #

• 方案一：用FreeRTOS队列替代全局缓冲区，队列天然自带同步机制，无需额外锁：

// 初始化队列（任务创建前）
QueueHandle_t spi_to_tcp_queue = xQueueCreate(1, sizeof(char[128]));
QueueHandle_t tcp_to_spi_queue = xQueueCreate(1, sizeof(char[128]));

// SPI_task中读取SPI后发送到队列
xQueueSend(spi_to_tcp_queue, spi_data_buffer, portMAX_DELAY);
// TCP_task中接收队列数据发送到TCP
xQueueReceive(spi_to_tcp_queue, tcp_send_buffer, portMAX_DELAY);

// TCP_task中接收TCP后发送到队列
xQueueSend(tcp_to_spi_queue, tcp_rx_buffer, portMAX_DELAY);
// SPI_task中接收队列数据发送到SPI（非阻塞）
xQueueReceive(tcp_to_spi_queue, spi_tx_buffer, 0);

• 方案二：给全局缓冲区加互斥锁，访问缓冲区前后调用xSemaphoreTake和xSemaphoreGive。

3. 合理使用阻塞/非阻塞API #

• 阻塞API是FreeRTOS的核心优势：xSemaphoreTake(portMAX_DELAY)是合理的，它会让任务进入休眠状态，不占用CPU资源，直到信号量可用时才唤醒，比轮询高效得多，完全不需要换成非阻塞版本。
• 调整任务逻辑，避免长时间阻塞导致事件丢失：比如SPI_task中处理TCP下发请求时用非阻塞的xSemaphoreTake(rdySem2, 0)，优先保证GPIO中断的响应及时性；tcp_task中可以把recv设置为非阻塞，避免recv阻塞导致无法及时响应rdySem1的信号量。

4. TCP_task的优化 #

避免recv阻塞导致无法处理SPI过来的数据，可将recv设为非阻塞：

void tcp_task(void* arg)
{
 // 设置套接字为非阻塞
 fcntl(sock, F_SETFL, O_NONBLOCK);
 while(1)
 {
  int len; 
  char rx_buffer[128];
  len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0);
  if (len>0)
  {
   // TODO:process data from TCP socket and send to tcp_to_spi_queue
   xQueueSend(tcp_to_spi_queue, rx_buffer, portMAX_DELAY);
  }
  else if(len == -1 && errno != EAGAIN)
  {
      // 处理套接字错误
  }

  // 阻塞等待SPI过来的数据，发送到TCP
  if(xQueueReceive(spi_to_tcp_queue, rx_buffer, portMAX_DELAY) == pdTRUE)
  {
      send(sock, rx_buffer, 128, 0);
  }
 }
}

总结 #

当前实现的核心问题是中断处理方式和任务逻辑的阻塞冲突，通过用信号量唤醒任务替代轮询、用队列保证数据同步、合理分配阻塞/非阻塞API的使用场景，就能实现高效可靠的SPI-TCP互转代理。阻塞API是FreeRTOS的正确用法，不用刻意换成非阻塞版本。

内容的提问来源于stack exchange，提问作者Iberico