求助：刚刚下载的2.1.0版本，使用rt_device_read，为什么每次都只能读到一个字节。在哪里修改？

发布于 2016-08-22 09:15:06 浏览：3773 订阅该版

12 个回答

aozima 2016-08-22

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

yuzeyuan1 2016-08-22

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

不可能只有一个字节。传感器一秒钟发过来几十个字节，我是两秒读一次。在过去的框架中是好使的，新下载的2.1.0不好使。是不是我有什么东西没开？我一共就加了下面四个函数：

```
rt_CO2_set_device("uart3");

static rt_device_t CO2_device = RT_NULL;

rt_size_t rt_UartReadCO2(uint8 *buf)
{
    return rt_device_read(CO2_device, 0, buf, 30);
}

rt_device_t rt_CO2_set_device(const char *name)
{
    rt_device_t new, old;

/* save old device */
    old = CO2_device;

/* find new console device */
    new = rt_device_find(name);
    if (new != RT_NULL)
    {
        if (CO2_device != RT_NULL)
        {
            /* close old console device */
            rt_device_close(CO2_device);
        }

/* set new console device */
        CO2_device = new;
        rt_device_open(CO2_device, RT_DEVICE_OFLAG_RDWR);
    }

return old;
}
```

然后LED线程里写：

```
    while (1)
    {
	    uint16 com_data_len;
	    uint8 buf[40];
	    rt_kprintf("length of buf = %d
",sizeof(buf));
	    // 读取串口数据
	    com_data_len = rt_UartReadCO2(buf);
		rt_thread_delay(200);
    }
```

读到的com_data_len就一直是1.

一个潘一个锐 2016-08-22

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

yuzeyuan1 2016-08-22

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

aozima 2016-08-22

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

yuzeyuan1 2016-08-22

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

bernard 2016-08-22

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

xiaolinmuyu 2016-08-24

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

我理解的是之前版本的框架是轮询读的，现在是中断读，每中断一次读一个字节，那就一个一个读，（当然这么理解不知道对不对，求指正 [s:186] ）写个小例程，具体的看finsh中串口的读写实现

```

#if 1

struct com_test
{
	struct rt_semaphore rx_sem;

rt_device_t device;
};

struct com_test* g_test_com;

rt_device_t com_set_device(const char *name)
{
    rt_device_t new;

/* find new console device */
    new = rt_device_find(name);
    if (new != RT_NULL)
    {
        if (g_test_com->device != RT_NULL)
        {
            /* close old console device */
            rt_device_close(g_test_com->device);
        }

/* set new console device */
        g_test_com->device = new;
    }

return g_test_com->device;
}

static rt_err_t com_rx_ind(rt_device_t dev, rt_size_t size)
{
    RT_ASSERT(g_test_com != RT_NULL);

/* release semaphore to let finsh thread rx data */
    rt_sem_release(&g_test_com->rx_sem);

return RT_EOK;
}

void com_thread_entry(void *parameter)
{
    char ch;
    
    if (g_test_com->device == RT_NULL)
    {
        com_set_device("uart2");
        RT_ASSERT(g_test_com->device);
        rt_device_set_rx_indicate(g_test_com->device, com_rx_ind);
        rt_device_open(g_test_com->device, (RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX));
    }

while (1)
    {
        if (rt_sem_take(&g_test_com->rx_sem, RT_WAITING_FOREVER) != RT_EOK)
        {
        continue;
        }

while (rt_device_read(g_test_com->device, 0, &ch, 1) == 1)
        {
           rt_kprintf("%02x", ch);
        }
    }
    
}

void com_init(void)
{
    g_test_com = (struct com_test *)rt_malloc(sizeof(struct com_test));
    if (g_test_com == RT_NULL)
    {
        rt_kprintf("no memory for com
");
        return;
    }

memset(g_test_com, 0, sizeof(struct finsh_shell));

rt_sem_init(&(g_test_com->rx_sem), "com", 0, 0);

}

static rt_uint8_t g_com_stack[ 512 ];
static struct rt_thread g_com_thread;

void com_thread_startup(void)
{
    rt_err_t result;

com_init();
    
    result = rt_thread_init(&g_com_thread,
                                        	"com",
                                        	com_thread_entry, RT_NULL,
                                        	&g_com_stack[0], sizeof(g_com_stack),
                                        	4, 10);
 
	if (result == RT_EOK)
		rt_thread_startup(&g_com_thread);
 }
#endif

```