如何清空系统下的串口中断接收buff stm32 RTT v2.0.3 【已解决】

发布于 2017-08-07 16:20:53 浏览：7056 订阅该版

项目需要通过串口传输大量数据到电脑上位机，但是由于数据量上来了，数据就难免会出错。为了纠正错误，我在程序中引入了校验机制，校验机制的工作流程如下：

下位机流程：
单片机发送一帧数据到上位机（6个字节，包含帧头数据校验和）  -> 等待串口接收到反馈，若接收到校验成功反馈，就发送下一帧数据，否则重复发送本帧数据；

上位机流程：
接收一帧数据->判断帧头、校验和是否全部正确->全部正确则返回正确反馈（一个字节）以读取下一帧数据，错误则校验失败，放弃本次接收并反馈错误反馈；

校验部分的具体代码实现为：
```							rt_device_write(device2,0,&sendResult,6);	      //发送第一帧数据
							while(1)
							{
								rt_device_read(device2,0,&tempBuff,1);              //等待反馈回传
								if(tempBuff == 0xe0) 
									break;		//正确反馈，退出校验发送下一帧
								else if (tempBuff == 0xeb)  
									rt_device_write(device2,0,&sendResult,6); //错误反馈，再次发送本帧数据
							}```

现在的问题是，第一帧数据发送完成后，接收到了正确的反馈，那么执行rt_device_read(device2,0,&tempBuff,1); 这句代码，每次得到的数值都是正确反馈0xe0，也就是说串口接收的buffer接收一次后设备每次读到的都是之前接收的那个值，于是就默认数据反馈成功，即便下次下位机发送数据，上位机没有任何反馈，下位机读buffer得到的仍然是校验正确，这使得校验无法完成。

请问各位，如何才能在设备访问usart之前，将系统的串口接收buffer清空？

补充说明一下，mcu是STM32F407ZE  ，串口接收方式是中断接收，由系统函数rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND);实现

2017年9月4日14:03:59更新：
该问题目前已解决，经过资料查询和多方请教，对RTT的串口机制终于有了比较彻底的了解；
RTT系统层的串口设备BUFF是FIFO形式，每次读取全部数据之后就会清空缓存BUFF，在接收时通过判断rt_device_read(device2,0,&tempBuff,1)函数的返回值判断是否收到数据，收到数据再读出。
具体到我的代码上，造成该问题的原因并不是串口BUFF未清空，是我设置的20ms触发一次系统的软件定时器执行打断了串口的中断接收，在对接收数据代码优化为接收的时候关闭软件定时器，数据接收就不会再出错。
![QQ截图20170828114337.png](https://oss-club.rt-thread.org/uploads/10129_885461d60f3c06e936ea845b8fd106e4.png)

12 个回答

pan16309 2017-08-23

这家伙很懒，什么也没写！

aozima 2017-08-07

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

aozima 2017-08-07

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

```
static rt_err_t _rym_rx_ind(rt_device_t dev, rt_size_t size)
{
    if(sem)
    {
        rt_sem_release(sem);
    }

//debug_printf("_rym_rx_ind
");

return 0;
}

static int _rym_clean_up(rt_device_t dev)
{
	char buf[1] = {0};
	int count = 0;

while (rt_device_read(dev, 0, buf, 1) == 1)
	{
		count++;

if(count > 256)
		{
			return -1;
		}
	}

return 0;
}

static enum rym_code _rym_read_code(rt_device_t dev, rt_tick_t timeout)
{
	char buf[1] = {0};

/* Fast path */
    if (rt_device_read(dev, 0, buf, 1) == 1)
        return (enum rym_code)buf[0];

/* Slow path */
    do {
        rt_size_t rsz;

/* No data yet, wait for one */
        if (rt_sem_take(sem, timeout) != RT_EOK)
            return RYM_CODE_NONE;

/* Try to read one */
        rsz = rt_device_read(dev, 0, buf, 1);
        if (rsz == 1)
            return (enum rym_code)buf[0];
    } while (1);
}

void foo(void)
{
_start:
    debug_printf("wait handshake ......
");
    start = rt_tick_get();
	retry = 3;
    while(1)
    {
        code = _rym_read_code(dev, RYM_CHD_INTV_TICK);
        end = rt_tick_get();
        if(code == RYM_CODE_C)
		{
			break;
		}
		else
        {
            debug_printf("wait handshake C err: %s
", _get_code_name(code));

if( retry )
			{
				retry--;
				continue;
			}

if( (end - start) > (RYM_CHD_INTV_TICK * 10) )
            {
                debug_printf("wait handshake timeout: %dms
", end-start);
                result = -RT_ERROR;
                goto _exit;
            }
        }
    }
    debug_printf("wait handshake C OK! need: %dms
", end-start);
	_rym_clean_up(dev);
}
```

pan16309 2017-08-07

这家伙很懒，什么也没写！

pan16309 2017-08-07

这家伙很懒，什么也没写！

>```
>static rt_err_t _rym_rx_ind(rt_device_t dev, rt_size_t size)
>{
>    if(sem)
>    {
>        rt_sem_release(sem);
>    }
>
>    //debug_printf("_rym_rx_ind
>");
>
>    return 0;
>}
>
>static int _rym_clean_up(rt_device_t dev)
>{
>	char buf[1] = {0};
>	int count = 0;
>
>    while (rt_device_read(dev, 0, buf, 1) == 1)
>	{
>		count++;
>
>		if(count > 256)
>		{
>			return -1;
>		}
>	}
>
>	return 0;
>}
>
>static enum rym_code _rym_read_code(rt_device_t dev, rt_tick_t timeout)
>{
>	char buf[1] = {0};
>
>    /* Fast path */
>    if (rt_device_read(dev, 0, buf, 1) == 1)
>        return (enum rym_code)buf[0];
>
>    /* Slow path */
>    do {
>        rt_size_t rsz;
>
>        /* No data yet, wait for one */
>        if (rt_sem_take(sem, timeout) != RT_EOK)
>            return RYM_CODE_NONE;
>
>        /* Try to read one */
>        rsz = rt_device_read(dev, 0, buf, 1);
>        if (rsz == 1)
>            return (enum rym_code)buf[0];
>    } while (1);
>}
>
>void foo(void)
>{
>_start:
>    debug_printf("wait handshake ......
>");
>    start = rt_tick_get();
>	retry = 3;
>    while(1)
>    {
>        code = _rym_read_code(dev, RYM_CHD_INTV_TICK);
>        end = rt_tick_get();
>        if(code == RYM_CODE_C)
>		{
>			break;
>		}
>		else
>        {
>            debug_printf("wait handshake C err: %s
>", _get_code_name(code));
>
>			if( retry )
>			{
>				retry--;
>				continue;
>			}
>
>            if( (end - start) > (RYM_CHD_INTV_TICK * 10) )
>            {
>                debug_printf("wait handshake timeout: %dms
>", end-start);
>                result = -RT_ERROR;
>                goto _exit;
>            }
>        }
>    }
>    debug_printf("wait handshake C OK! need: %dms
>", end-start);
>	_rym_clean_up(dev);
>}
>```

---

这里的 clean_up 是把buff里的所有数据都读一次实现清空buff的意思吗？