二氧化碳传感器串口调试问题

发布于 2021-11-05 15:12:17 浏览：800 订阅该版

背景：senseAIR S8二氧化碳传感器需要串口先发送一串字符串给传感器，然后MCU接收一段传感器发送回的字符串进行解析

刚学习了串口消息队列收发和事件之后，打算采用两个线程，一个发送字符串给传感器，一个接收传感器发回的字符串，然后用接收完成事件来同步两个线程。
问题：当前这份代码，启动程序后，接收线程一直在等待，接收不到消息。但是调试时，就可以接收到，并且发送一次，会接收两次，一次是有用的字符串，一次是没用的字符串。
想请教大佬，如何调整这个思路，让程序运行的时候，自动执行MCU发送给传感器的代码。这个思路还是没想明白。

```c
//串口接收完成事件
static struct rt_event event;
#define EVENT_FLAG3 (1 << 3)
#define SAMPLE_UART_NAME                 "uart3"
unsigned char CO2_TxBuffer[8] = { 0xFE, 0x04, 0x00, 0x03, 0x00, 0x01, 0xD5, 0xC5 };
/* 串口设备句柄 */
static rt_device_t serial;
/* 消息队列控制块 */
static struct rt_messagequeue rx_mq;

rt_uint16_t CO2_HIGH_NUM = 0;
rt_uint16_t CO2_LOW_NUM = 0;
rt_uint16_t Co2_concentration = 0;

#define THREAD_PRIORITY         25
#define THREAD_STACK_SIZE       4096
#define THREAD_TIMESLICE        10

/* 串口接收消息结构*/
struct rx_msg
{
    rt_device_t dev;
    rt_size_t size;
};

/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    struct rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;

result = rt_mq_send(&rx_mq, &msg, sizeof(msg));
    if (result == -RT_EFULL)
    {
        /* 消息队列满 */
        rt_kprintf("message queue full！\n");
    }
    return result;
}

ALIGN(RT_ALIGN_SIZE)
static void recieve_thread_entry(void *parameter)
{
    struct rx_msg msg;
    rt_err_t result;
    rt_uint32_t rx_length;
    static char rx_buffer[10];
    while (1)
    {
        rt_memset(&msg, 0, sizeof(msg));
        /* 从消息队列中读取消息*/
        result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
        if (result == RT_EOK)
        {
            /* 从串口读取数据*/
            rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
            rx_buffer[rx_length] = '\0';
             if (rx_buffer[0]==0xFE&&rx_buffer[1]==0x04&&rx_buffer[2]==0x02) {
                 CO2_HIGH_NUM=rx_buffer[3];
                 CO2_LOW_NUM=rx_buffer[4];
                 Co2_concentration=(CO2_HIGH_NUM<<8)+CO2_LOW_NUM;
                 rt_kprintf("Co2_concentration: %4d ppm! \r\n",Co2_concentration);
            }
            rt_device_write(serial, 0, rx_buffer, rx_length);
            rt_event_send(&event, EVENT_FLAG3);
            rt_thread_mdelay(200);
        }
    }
}

static void send_thread_entry(void *parameter)
{
    rt_uint32_t e;

while (1)
    {
        if (rt_event_recv(&event, (EVENT_FLAG3), RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e) == RT_EOK)
        {
            rt_device_write(serial, 0, CO2_TxBuffer, sizeof(CO2_TxBuffer));
            rt_kprintf("co2 send success! \r\n");
        }
    }
}

int sensor_co2_task()
{
    rt_err_t ret = RT_EOK;
    static char msg_pool[256];
    rt_err_t result;

/* 初始化事件对象 */
    result = rt_event_init(&event, "event", RT_IPC_FLAG_PRIO);
    if (result != RT_EOK)
    {
        rt_kprintf("init event failed.\n");
        return -1;
    }
    /* 查找串口设备 */
    serial = rt_device_find(SAMPLE_UART_NAME);
    if (!serial)
    {
        rt_kprintf("find %s failed!\n", SAMPLE_UART_NAME);
        return RT_ERROR;
    }
    rt_kprintf("find %s success!\n", SAMPLE_UART_NAME);
    /* 初始化消息队列 */
    rt_mq_init(&rx_mq, "rx_mq", msg_pool, /* 存放消息的缓冲区 */
            sizeof(struct rx_msg), /* 一条消息的最大长度 */
            sizeof(msg_pool), /* 存放消息的缓冲区大小 */
            RT_IPC_FLAG_FIFO); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */

/* 以 DMA 接收及轮询发送方式打开串口设备 */
    rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX);
    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(serial, uart_input);
    /* 发送字符串 */
    //        / rt_device_write(serial, 0, str, (sizeof(str) - 1));
    /* 创建 serial 线程 */
    rt_thread_t re_thread = rt_thread_create("serial_recieve", recieve_thread_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
    /* 创建成功则启动线程 */
    if (re_thread != RT_NULL)
    {
        rt_thread_startup(re_thread);
    }
    else
    {
        ret = RT_ERROR;
    }

/* 创建 serial 线程 */
    rt_thread_t send_thread = rt_thread_create("serial_send", send_thread_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
    /* 创建成功则启动线程 */
    if (send_thread != RT_NULL)
    {
        rt_thread_startup(send_thread);

}
    else
    {
        ret = RT_ERROR;
    }
    rt_device_write(serial, 0, CO2_TxBuffer, sizeof(CO2_TxBuffer));

return ret;
}
```