10 关于拿网口作为调试口，不知道各位有没有经验可以分享

发布于 2021-11-04 17:06:00 浏览：1742 订阅该版

Mestic英 2021-11-05

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

agile console只是一个框架，框架下的每一个注册的设备对象接收到数据都会被acon线程读取出来并缓存到acon这个设备对象内，agile console组件启动的时候会接管console，finsh是直接访问console设备的，此时finsh将直接通过console（acon）来读取字节流。

- **rt_console_set_device(PKG_AGILE_CONSOLE_DEVICE_NAME);**

```c
int agile_console_board_init(void)
{
    rt_memset(&console, 0, sizeof(struct agile_console));

rt_memset(agile_console_rb_buffer, 0, PKG_AGILE_CONSOLE_RX_BUFFER_SIZE);
    rt_ringbuffer_init(&(console.rx_rb), agile_console_rb_buffer, PKG_AGILE_CONSOLE_RX_BUFFER_SIZE);

struct rt_device *device = &(console.parent);
    
    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;
    ...
        /* register a character device */
    rt_device_register(device, PKG_AGILE_CONSOLE_DEVICE_NAME, RT_DEVICE_FLAG_RDWR);

#if defined(RT_USING_POSIX)
    /* set fops */
    device->fops        = &_console_fops;
#endif
    
    rt_console_set_device(PKG_AGILE_CONSOLE_DEVICE_NAME);

return RT_EOK;
}
```

finsh通过getchar来侦听和获取acon接收到的字节流（getchar调用的是fops里的read，无数据时默认情况下是通过rt_wqueue_wait阻塞线程的）。

```c
static int console_fops_read(struct dfs_fd *fd, void *buf, size_t count)
{
    int size = 0;
    rt_device_t device;

device = (rt_device_t)fd->data;

do
    {
        size = rt_device_read(device, -1,  buf, count);
        if (size <= 0)
        {
            if (fd->flags & O_NONBLOCK)
            {
                size = -EAGAIN;
                break;
            }

rt_wqueue_wait(&(device->wait_queue), 0, RT_WAITING_FOREVER);
        }
    }while (size <= 0);

return size;
}
```

finsh通过rt_kprintf把数据发送给acon，acon的设备驱动会把需要发送的数据，发送到每一个注册到agile console的字符设备上。

```c
static rt_size_t agile_console_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    if(size == 0)
        return 0;

rt_slist_t *node;
    rt_slist_for_each(node, &backend_slist)
    {
        struct agile_console_backend *backend = rt_slist_entry(node, struct agile_console_backend, slist);
        if(backend->output == RT_NULL)
            continue;
        
        backend->output(buffer, size);
    }

return size;
}
```

可以仔细理顺中间的逻辑关系，alige telnet只是其中注册的一个设备对象而已，telnet接收到数据后，发送信号量给acon线程，acon线程获取telnet的数据缓存在acon的缓存buffer内，然后finsh因为acon有新数据接收后，将释放线程阻塞并接收字节流，通过rt_kprintf把响应回码的字节流通过acon的设备对象write接口分发到每一个注册的设备对象上（alige console注册时的output接口），触发telnet线程发送数据。
- `rt_wqueue_wakeup(&(telnet.tlnt_dev->wait_queue), (void*)POLLIN);`
- `rt_wqueue_wakeup(&(telnet.tlnt_dev->wait_queue), (void*)POLLIN);`
- `select(max_fd + 1, &readset, RT_NULL, &exceptset, &select_timeout);`

```c
static void telnet_backend_output(const uint8_t *buf, int len)
{
    int write_size;
    if(telnet.isconnected == 0)
        return;

rt_base_t level = rt_hw_interrupt_disable();
    write_size = 0;
    for (int i = 0; i < len; i ++)
    {
        if (buf[i] == '\n')
        {
            if (rt_ringbuffer_putchar(telnet.tx_rb, '\r') == 1)
                write_size ++;
        }
        if (rt_ringbuffer_putchar(telnet.tx_rb, buf[i]) == 1)
            write_size ++;
    }
    rt_hw_interrupt_enable(level);
    if(write_size > 0)
        rt_wqueue_wakeup(&(telnet.tlnt_dev->wait_queue), (void*)POLLIN);
}
```

```
static int tlnt_fops_poll(struct dfs_fd *fd, rt_pollreq_t *req)
{
    int mask = 0;
    rt_device_t device = (rt_device_t)fd->data;
    RT_ASSERT(device != RT_NULL);

rt_poll_add(&(device->wait_queue), req);

if(rt_ringbuffer_data_len(telnet.tx_rb) != 0)
        mask |= POLLIN;

return mask;
}
```

```c
static void telnet_thread(void* parameter)
{
    ...
         int rc = select(max_fd + 1, &readset, RT_NULL, &exceptset, &select_timeout);
    ...
}
```