10 串口回调函数被自己中断应该如何解决？

发布于 2022-05-28 13:22:49 浏览：675 订阅该版

RTT版本是4.0.5
在接收串口的数据时，有时候一帧数据会被分成2段或更多，所以在串口回调函数中写了一个拼接数据的函数，同时会打印出这组数据，这样能保证接收正确的数据，但是，在运行中发现，串口回调函数有时候会被自己中断掉，也就是说，第一次接收的数据在串口中断函数中还没有打印完毕，另一次的串口中断就开始进来打印数据了，这样会导致系统出错死机。这样应该如何解决？

```c
//初始化函数
int uart_dma_init(void)
{
    rt_err_t ret = RT_EOK;
    char uart_name[RT_NAME_MAX];
    static char msg_pool[8192];
		struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;  /* 初始化配置参数 */

rt_strncpy(uart_name, SX1302_UART_NAME, RT_NAME_MAX);
    /* 查找串口设备 */
    serial = rt_device_find(uart_name);
    if (!serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return RT_ERROR;
    }
		/* step2：修改串口配置参数 */
		config.baud_rate = BAUD_RATE_115200;        //修改波特率为 115200
		config.data_bits = DATA_BITS_8;           //数据位 8
		config.stop_bits = STOP_BITS_1;           //停止位 1
		config.bufsz     = 1024;                   //修改缓冲区 buff size 为 1024
		config.parity    = PARITY_NONE;           //无奇偶校验位

/* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
		rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);
    /* 初始化消息队列 */
    rt_mq_init(&rx_mq, "rx_mq",
               msg_pool,                 /* 存放消息的缓冲区 */
               sizeof(struct rx_msg),    /* 一条消息的最大长度 */
               sizeof(msg_pool),         /* 存放消息的缓冲区大小 */
               RT_IPC_FLAG_FIFO);        /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
    rt_mq_init(&rx_mq_sx1302, "rx_mq_sx1302",
               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));
		rt_kprintf("uart2 for sx1302-at is ready!\r\n");
    return ret;
}
```
```c
/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
	struct rx_msg msg,msg_rec;
	rt_err_t result;

uint16_t crc,crc16,framelenth;
	
	msg.size = size;
	
	
	
	rt_memset(msg.msgbuffer,0,sizeof(msg.msgbuffer));
	rt_kprintf("Lora rec size:%d,",msg.size);PrintTime(); //打印时间
	
	rt_device_read(dev, 0, msg.msgbuffer, msg.size);	/* 从串口读取数据*/
	
	for(int i=0;i<msg.size;i++)
	{
		rt_kprintf("%02x ",msg.msgbuffer[i]);
	}
	rt_kprintf("\n");
	
	if(Sx1302ConfigFlag == 1) //Sx1302ConfigFlag为1就直接发送消息，如果是0就要进行处理，防止被拆包
	{
    result = rt_mq_send(&rx_mq_sx1302, &msg, sizeof(msg));
    if ( result == -RT_EFULL)
    {
        /* 消息队列满 */
        rt_kprintf("message queue full！\n");
    }
	}
	else
	{
		//rt_kprintf("1..LoraRec.flag:%d,LoraRec.index:%d\n",LoraRec.flag,LoraRec.index);
		if(LoraRec.flag == 0)
		{
			if(msg.msgbuffer[0]==0x12)
			{
				  //rt_kprintf("1-msg.size%d\n",msg.size);
					rt_memcpy(LoraRec.buffer,msg.msgbuffer,msg.size);
					framelenth = LORA_Frameheadlenth +   Get16_FromFrame(LoraRec.buffer,LORA_Length_POS);
					//rt_kprintf("1-framelenth%d\n",framelenth);
					if(msg.size == (framelenth+2))
					{
						crc = Get16_FromFrame(LoraRec.buffer,framelenth);
						crc16=CRC16(LoraRec.buffer,framelenth);
						if(crc==crc16)
						{
							//完整数据包，发送
							result = rt_mq_send(&rx_mq, &msg, sizeof(msg));
							//rt_kprintf("xxxxxx\n");
							if ( result == -RT_EFULL)
							{
									/* 消息队列满 */
									rt_kprintf("message queue full！\n");
							}						
						}
					}
					else  //不完整的包
					{
						//rt_kprintf("2-msg.size%d\n",msg.size);
						LoraRec.flag = 1;
						LoraRec.index = msg.size;	
					}
			}
		}
		else if(LoraRec.flag == 1)
		{
			//rt_kprintf("3-msg.size%d\n",msg.size);
			rt_memcpy(&LoraRec.buffer[LoraRec.index],msg.msgbuffer,msg.size);
			if((LoraRec.buffer[0]==0x12)&&(LoraRec.buffer[1]==0x34))
			{
				framelenth = LORA_Frameheadlenth + Get16_FromFrame(LoraRec.buffer,LORA_Length_POS);
				//rt_kprintf("2-framelenth%d\n",framelenth);
				LoraRec.reclenth = LoraRec.index + msg.size;	 //计算长度
				//rt_kprintf("1-LoraRec.reclenth:%d\n",LoraRec.reclenth);
				if(LoraRec.reclenth == (framelenth+2))
				{
					crc = Get16_FromFrame(LoraRec.buffer,framelenth);
					crc16=CRC16(LoraRec.buffer,framelenth);
					if(crc==crc16)
					{
						//完整数据包，发送
						rt_memcpy(msg_rec.msgbuffer,LoraRec.buffer,sizeof(LoraRec.buffer));
						msg_rec.size = framelenth + 9; //数据帧头7加2个CRC
						result = rt_mq_send(&rx_mq, &msg_rec, sizeof(msg_rec));
						for(int i=0;i<LoraRec.reclenth;i++)
						{
							rt_kprintf("%02x ",LoraRec.buffer[i]);
						}
						//rt_kprintf("oooooooo\n");
						rt_memset(LoraRec.buffer,0,sizeof(LoraRec.buffer));
						LoraRec.index = 0;	
						LoraRec.flag =0;
						if ( result == -RT_EFULL)
						{
								/* 消息队列满 */
								rt_kprintf("message queue full！\n");
						}
					}
				}
				else  //不完整的包
				{
					//rt_kprintf("1message clear\n");
					rt_memset(LoraRec.buffer,0,sizeof(LoraRec.buffer));
					LoraRec.index = 0;	
					LoraRec.flag =0;
				}
			}
			else
			{
				//rt_kprintf("2message clear\n");
				rt_memset(LoraRec.buffer,0,sizeof(LoraRec.buffer));
				LoraRec.index = 0;	
				LoraRec.flag =0;
			}
		}
		else
		{
			rt_memset(LoraRec.buffer,0,sizeof(LoraRec.buffer));
			LoraRec.index = 0;	
			LoraRec.flag =0;
		}
	}
	//rt_kprintf("2  LoraRec.flag:%d,LoraRec.index:%d\n",LoraRec.flag,LoraRec.index);
	return result;
}
```

出错信息
```
[2022-05-28 11:29:59]  1-process over.Sat May 28 11:30:07 2022
[2022-05-28 11:29:59]  Lora rec size:4,Sat MayLora rec size:26,Sat May 28 11:30:07 2022
[2022-05-28 11:29:59]  12 34 03 01 00 03 01 c2 84 00 00 03 41 a0 00 00 02 40 6f 25 9a fd 01 07 00 fc 
[2022-05-28 11:29:59]   28 11:30:07 2022
[2022-05-28 11:29:59]  00 00 00 00 
[2022-05-28 11:29:59]  psr: 0xa100000f
[2022-05-28 11:29:59]  r00: 0x00000001
[2022-05-28 11:29:59]  r01: 0x240015b8
[2022-05-28 11:29:59]  r02: 0x256f4002
[2022-05-28 11:29:59]  r03: 0x2400f098
[2022-05-28 11:29:59]  r04: 0x2400e788
[2022-05-28 11:29:59]  r05: 0x00000001
[2022-05-28 11:29:59]  r06: 0x00000001
[2022-05-28 11:29:59]  r07: 0x00000001
[2022-05-28 11:29:59]  r08: 0xdeadbeef
[2022-05-28 11:29:59]  r09: 0xdeadbeef
[2022-05-28 11:29:59]  r10: 0xdeadbeef
[2022-05-28 11:29:59]  r11: 0xdeadbeef
[2022-05-28 11:29:59]  r12: 0x00000000
[2022-05-28 11:29:59]   lr: 0x0804a02d
[2022-05-28 11:29:59]   pc: 0x080202c8
[2022-05-28 11:29:59]  hard fault on handler
```

![image.png](https://oss-club.rt-thread.org/uploads/20220528/faf5c7dfb04ed440ee1258daa10f725b.png)

如何才能让串口回调函数不中断自己？是因为我在串口回调函数中写的东西太长了吗？