RT-Thread 隐藏的宝藏之管道

最新推荐文章于 2023-11-02 16:14:47 发布
最新推荐文章于 2023-11-02 16:14:47 发布
阅读量1.4k 收藏 7
点赞数
分类专栏： C/C++ RT-Thread 原创 文章标签： 多线程 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whj123999/article/details/115262355
版权
原创 同时被 3 个专栏收录
16 篇文章 12 订阅
订阅专栏
RT-Thread
9 篇文章 9 订阅
订阅专栏
C/C++
8 篇文章 0 订阅
订阅专栏

一. 什么是管道

pipe： 匿名管道。

对于熟悉 linux 开发的人来说，pipe 就很熟悉了。pipe 是一种 IPC 机制，他的作用是用作有血缘进程间完成数据传递，只能从一端写入，从另外一端读出。为了解决 pipe 的弊端，linux 的大神门又引入了 mkfifo(实名管道)。这些的讲解网络上有更清晰的讲解，就不再赘述。

RT-Thread 也实现了一套 pipe，不仅有自己的接口 rt_pipe_xxx , 也对接了 posix 接口。

二. 怎么 使用管道

在使用之前先看一下 pipe 的结构体

struct rt_pipe_device
{
    struct rt_device parent;
    rt_bool_t is_named;

    /* ring buffer in pipe device */
    struct rt_ringbuffer *fifo;
    rt_uint16_t bufsz;

    rt_uint8_t readers;
    rt_uint8_t writers;

    rt_wqueue_t reader_queue;
    rt_wqueue_t writer_queue;

    struct rt_mutex lock;
};
typedef struct rt_pipe_device rt_pipe_t;

通过上面的结构体可以先尝试分析以下管道的实现原理：

is_named ：确定是匿名管道，还是实名管道

fifo ：通过 ringbuff 来缓存数据

readers/writes : 确定读取/写入用户的数量

reader_queue/writer_queue ：通过工作队列来实现异步操作

lock ：使用互斥锁来实现半双工

用 RT-Thread 的管道的时候，有两个使用方法：

  1. 使用 RT-Thread 的 API , 即 rt_pipe_xxx 的API

  2. 使用 posix 的管道 API

使用 RT-Thread 管道 API

  1. 创建管道

    rt_pipe_t *rt_pipe_create(const char *name, int bufsz)

    name : 创建管道的名字，设备会注册到设备管理器

    bufsz：ringbuff 缓存去的大小

    返回管道的对象

  2. 删除管道

    int rt_pipe_delete(const char *name)

    name : 管道的名字，删除函数会自动在设备管理器查找到该设备

    删除成功返回 0

  3. 打开管道

    rt_err_t rt_pipe_open (rt_device_t device, rt_uint16_t oflag)

    device : 设备对象

    oflag : 没有用到

  4. 关闭管道

    rt_err_t rt_pipe_close (rt_device_t device)

    device : 设备对象

  5. 读取管道数据

    rt_size_t rt_pipe_read (rt_device_t device, rt_off_t pos, void *buffer, rt_size_t count)

    device : 设备对象

    pos : 未使用

    buffer : 读管道数据的存储区的指针

    count : 读取数据的长度

  6. 读取管道数据

    rt_size_t rt_pipe_write (rt_device_t device, rt_off_t pos, const void *buffer, rt_size_t count)

    device : 设备对象

    pos : 未使用

    buffer : 写管道数据的存储区的指针

    count : 写取数据的长度

使用 POSIX 管道 API

  1. 创建匿名管道

    int pipe(int fildes[2])

    fildes[0] : 读文件描述符

    fildes[1] : 写文件描述符

    成功返回 0

  2. 创建实名管道

    int mkfifo(const char *path, mode_t mode)

    path : 文件名

    mode : 未使用

    成功返回 0

  3. 读写数据

    使用 read/write 接口

三. 原理分析管道

1. 创建管道
rt_pipe_t *rt_pipe_create(const char *name, int bufsz)
{
    rt_pipe_t *pipe;
    rt_device_t dev;

    pipe = (rt_pipe_t *)rt_malloc(sizeof(rt_pipe_t));// 申请内存
    if (pipe == RT_NULL) return RT_NULL;

    rt_memset(pipe, 0, sizeof(rt_pipe_t));
    pipe->is_named = RT_TRUE; /* initialize as a named pipe */
    rt_mutex_init(&(pipe->lock), name, RT_IPC_FLAG_FIFO);//初始化互斥锁
    rt_wqueue_init(&(pipe->reader_queue));//初始化读工作队列
    rt_wqueue_init(&(pipe->writer_queue));//初始化写工作队列

    RT_ASSERT(bufsz < 0xFFFF);
    pipe->bufsz = bufsz;//ringbuff 缓存区大小

    dev = &(pipe->parent);
    dev->type = RT_Device_Class_Pipe;// 设置设备类型

    dev->init        = RT_NULL;//对接 ops 接口
    dev->open        = rt_pipe_open;
    dev->read        = rt_pipe_read;
    dev->write       = rt_pipe_write;
    dev->close       = rt_pipe_close;
    dev->control     = rt_pipe_control;

    dev->rx_indicate = RT_NULL;// 不设置回调函数
    dev->tx_complete = RT_NULL;

    if (rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE) != 0) // 注册设备
    {
        rt_free(pipe);
        return RT_NULL;
    }
#ifdef RT_USING_POSIX
    dev->fops = (void*)&pipe_fops;
#endif

    return pipe;// 返回 pipe 
}
2. 删除管道
int rt_pipe_delete(const char *name)
{
    int result = 0;
    rt_device_t device;

    device = rt_device_find(name);//查找设备
    if (device)
    {
        if (device->type == RT_Device_Class_Pipe)//检查设备类型
        {
            rt_pipe_t *pipe;

            if (device->ref_count != 0)// 如果设备中还有任务没处理完，则不能删除
            {
                return -RT_EBUSY;
            }

            pipe = (rt_pipe_t *)device;

            rt_mutex_detach(&(pipe->lock));// 脱离互斥锁
            rt_device_unregister(device);// 取消设备注册

            /* close fifo ringbuffer */
            if (pipe->fifo) 
            {
                rt_ringbuffer_destroy(pipe->fifo);// 摧毁 ringbuff
                pipe->fifo = RT_NULL;
            }
            rt_free(pipe);// 释放内存
        }
        else
        {
            result = -ENODEV;
        }
    }
    else
    {
        result = -ENODEV;
    }

    return result;
}
3. 打开管道
rt_err_t  rt_pipe_open (rt_device_t device, rt_uint16_t oflag)
{
    rt_pipe_t *pipe = (rt_pipe_t *)device;
    rt_err_t ret = RT_EOK;

    if (device == RT_NULL)
    {
        ret = -RT_EINVAL;
        goto __exit;
    }
    
    rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);// 加锁

    if (pipe->fifo == RT_NULL)
    {
        pipe->fifo = rt_ringbuffer_create(pipe->bufsz);//创建 ringbuff
        if (pipe->fifo == RT_NULL)
        {
            ret = -RT_ENOMEM;
        }
    }

    rt_mutex_release(&(pipe->lock));// 释放锁

__exit:
    return ret;
}
4. 关闭管道
rt_err_t  rt_pipe_close  (rt_device_t device)
{
    rt_pipe_t *pipe = (rt_pipe_t *)device;

    if (device == RT_NULL) return -RT_EINVAL;
    rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);// 加锁

    if (device->ref_count == 1)
    {
        rt_ringbuffer_destroy(pipe->fifo);//摧毁 ringbuff
        pipe->fifo = RT_NULL;
    }

    rt_mutex_release(&(pipe->lock));//释放锁

    return RT_EOK;
}
5. 管道读数据
rt_size_t rt_pipe_read(rt_device_t device, rt_off_t pos, void *buffer, rt_size_t count)
{
    uint8_t *pbuf;
    rt_size_t read_bytes = 0;
    rt_pipe_t *pipe = (rt_pipe_t *)device;

    if (device == RT_NULL)
    {
        rt_set_errno(-EINVAL);
        return 0;
    }
    if (count == 0) return 0;

    pbuf = (uint8_t*)buffer;
    rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);// 加锁

    while (read_bytes < count)
    {// 循环从 ringbuff 中读取数据
        int len = rt_ringbuffer_get(pipe->fifo, &pbuf[read_bytes], count - read_bytes);
        if (len <= 0) break;

        read_bytes += len;
    }
    rt_mutex_release(&pipe->lock);//释放锁

    return read_bytes;//返回读取到的数据的长度
}
6. 管道写数据
rt_size_t rt_pipe_write(rt_device_t device, rt_off_t pos, const void *buffer, rt_size_t count)
{
    uint8_t *pbuf;
    rt_size_t write_bytes = 0;
    rt_pipe_t *pipe = (rt_pipe_t *)device;

    if (device == RT_NULL)
    {
        rt_set_errno(-EINVAL);
        return 0;
    }
    if (count == 0) return 0;

    pbuf = (uint8_t*)buffer;
    rt_mutex_take(&pipe->lock, -1);//加锁

    while (write_bytes < count)
    {// 往 ringbuff 写数据
        int len = rt_ringbuffer_put(pipe->fifo, &pbuf[write_bytes], count - write_bytes);
        if (len <= 0) break;

        write_bytes += len;
    }
    rt_mutex_release(&pipe->lock);//释放锁

    return write_bytes;//返回写入数据的长度
}
7. 匿名管道的实现
int pipe(int fildes[2])
{
    rt_pipe_t *pipe;
    char dname[8];// 这里应该写 RT_NAME_MAX
    char dev_name[32];
    static int pipeno = 0;
    //拼接字符串，作为管道的名字
    rt_snprintf(dname, sizeof(dname), "pipe%d", pipeno++);

    pipe = rt_pipe_create(dname, PIPE_BUFSZ);// 创建管道
    if (pipe == RT_NULL)
    {
        return -1;
    }
    // 设置为匿名管道
    pipe->is_named = RT_FALSE; /* unamed pipe */
    //拼接字符串，作为管道的名字
    rt_snprintf(dev_name, sizeof(dev_name), "/dev/%s", dname);
    //只读的方式打开文件
    fildes[0] = open(dev_name, O_RDONLY, 0);
    if (fildes[0] < 0)
    {
        return -1;
    }
    //只写的方式打开文件
    fildes[1] = open(dev_name, O_WRONLY, 0);
    if (fildes[1] < 0)
    {
        close(fildes[0]);
        return -1;
    }

    return 0;
}
8. 实名管道的实现
int mkfifo(const char *path, mode_t mode)
{
    rt_pipe_t *pipe;
    
    pipe = rt_pipe_create(path, PIPE_BUFSZ);// 创建管道
    if (pipe == RT_NULL)
    {
        return -1;
    }

    return 0;
}

注意 mode 未使用。

9. POSIX 接口对接

posix 接口的实现是通过 fd 文件描述符来找到 pipe 的对象，这样就和前面一样的操作了。唯一的区别就是在 posix 接口实现里面对接了 readers/writers ，用来记录管道的使用者。

四. 总结

RT-Thread 的管道有什么特点呢？

  1. RTOS 中没有进程的概念，所以在 RTOS 中的管道用于线程间通讯
  2. RT-Thread 的管道也是半双工，半双工通过互斥锁实现
  3. 支持匿名管道和实名管道
  4. 支持 posix 标准，通过源码分析，posix 标准实现的功能更加完善
whj123999
关注
专栏目录
rt-thread入门教程PPT
03-13
* 作为一款国产嵌入式操作系统，与其他 RTOS 的主要区别是：RT-Thread 自创建之初的定位就不仅是一个 RTOS 内核，而是包含网络、文件系统、GUI 界面等组件的中间件平台 * 高度稳定可靠，广泛应用于安防、医疗、新...
RT-Thread 隐藏的宝藏之 data_queue
whj123999的博客
02-27 2116
1. data_queue 是什么 data_queue 直接翻译过来是 数据队列。这个名字和 消息队列 很像。那么他们有什么区别呢？ 消息队列：消息队列能够接收来自线程或中断服务例程中不固定长度的消息，并把消息缓存在自己的内存空间中。其他线程也能够从消息队列中读取相应的消息，而当消息队列是空的时候，可以挂起读取线程。当有新的消息到达时，挂起的线程将被唤醒以接收并处理消息。消息队列是一种异步的通信方式。(摘自 RT-Thread文档中心). 数据队列：没有找到官方详细的说明，只是在 RT-Thread AP
RT-Thread pipe的简单demo
Nuko的博客
07-24 2461
文章目录pipe函数pipe demo 关键字：rtthread rtt pipe demo pipe，管道，在Linux里是一种基本的IPC（Inter Process Communication，进程间通讯），rtt中使用pipe这个函数需要打开RT_USING_POSIX，既然是POSIX，那么跟Linux中的pipe应该没有多大区别，可以直接参考linux的pipe。但是在linux中，管...
php socket非阻塞线程,组件类 - 多线程非阻塞 socket 编程 - 《RT-Thread应用笔记》 - 书栈网 · BookStack...
weixin_29762229的博客
03-11 325
基于多线程的非阻塞 socket 编程本文的目的和结构本文的目的和背景随着物联网的发展，越来越多产品需要基于网络进行数据传输。在实际开发中，往往要求网络传输时不能阻塞当前线程，以致无法及时处理其他消息。在用户无法直接套用简单的 socket demo 时，RT-Thread 提供基于多线程的非阻塞 socket 编程示例，方便用户进行应用程序开发。本文的结构本文首先介绍 socket 常规使用以及...
基于RT-Thread系统使用 QEMU 运行 RT-Thread 提供的基于多线程的非阻塞 socket 编程
qq_43643506的博客
02-02 2527
多线程非阻塞网络编程 简介： 在实际开发中，往往要求网络传输时不能阻塞当前线程，以致无法及时处理其他消息。在用户无法直接套用简单的 socket demo 时，RT-Thread 提供基于多线程的非阻塞 socket 编程示例，方便用户进行应用程序开发。 在 RT-Thread 使用 socket 网络编程时，当一个任务调用 socket的 recv()函数接收数据时，如果 socket 上并没有...
RT-Thread系统使用常见问题处理记录
qq_25186745的博客
11-02 961
解决办法：更改agile_telnet软件包里Set agile_telnet tx buffer size的大小。最近4.2版本的改成了HAL_TIM_Base_MspInit函数。解决办法：老版本的PWM里定时器时钟的初始化函数是HAL_TIM_PWM_MspInit。解决办法：更改paho_mqtt_pipe.c里PIPE_BUFSZ为2048。解决办法：在board.c里的CAN2打开时钟前增加CAN1时钟使能。原因：要先使能CAN1的时钟，再使能CAN2的时钟。原因：telnet发送缓存太小。
常用的Xenomai 原生API
CyberLabs的专栏
11-14 2652
http://www.cs.ru.nl/lab/xenomai/ 常用的Xenomai 原生API：   　　1、任务管理  　　　　Xenomai 本身提供的一系列多任务调度机制，主要有以下一些函数：  　　　　int rt_task_create (RT_TASK *task, const char *name, int stksize,int prio, int mode) ;
rt-thread mcp2515驱动程序参考
11-01
RT-Thread MCP2515驱动程序是专为在嵌入式系统中实现SPI到CAN（Controller Area Network）转换而设计的。MCP2515是一款由Microchip Technology公司生产的CAN控制器，它通过SPI（Serial Peripheral Interface）接口与...
RT-Thread API参考手册.pdf
12-20
RT-Thread是一款由国内团队开发并维护的嵌入式实时操作系统，拥有完全的自主知识产权。自成立以来，RT-Thread经过长时间的发展，已经成为了一个功能强大、组件丰富的物联网操作系统，尤其适应于资源受限的微控制器...
RT-thread相关介绍与面试问题+答案
最新发布
03-05
### RT-thread相关介绍与面试问题解析 #### 一、RT-thread概述 RT-thread是一款轻量级的嵌入式实时多线程操作系统，它支持多任务处理，并具备良好的移植性、可裁剪性和可扩展性。RT-thread的核心架构包括内核、...
rt-thread-3.1.3_rtthread_RT-Thread_nano_rtthreadopenocd_RT-Threa
09-30
RT-Thread是一个开源的实时操作系统（RTOS），专为嵌入式系统设计，具有高可靠性、低功耗和轻量级的特点。"rt-thread-3.1.3" 是该操作系统的特定版本，代表着该版本在功能和性能上的优化与改进。 RT-Thread Nano是...
RT-Thread学习笔记【IO设备模型】
qq_40500005的博客
02-18 965
I/O设备 IO设备模型框架 RTT提供了一套简单的IO设备模型框架，位于硬件和应用程序之间，分成三层，从上到下分别是IO设备管理层、设备驱动框架层、设备驱动层，示意图如下所示 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UBXm3fJ0-1613580344436)(C:\Users\NH55\AppData\Roaming\Typora\typora-user-images\image-20210126162352465.png)] 应用程序通过IO设备管理层提供的接口
rt-thread 使用宝典（2022-0516更新）
rtthreadiotos的博客
06-08 3877
接触 rt-thread 已有半年，混论坛也5个半月了，期间遇到过各种奇奇怪怪的棘手问题，有过尴尬，也自信曾经提供过比较妙的应对方案。所以产生了将一些典型的使用技巧汇总分享出来的想法，遂有此篇。...
.net thread操作串口_听说你不知道 RT-Thread 有个 ringbuffer
weixin_30895003的博客
12-03 485
在嵌入式开发中，我们经常需要用到 FIFO 数据结构来存储数据，比如任务间的通信、串口数据收发等场合。很多小伙伴不知道 RT-Thread 为我们提供了一个 ringbuffer 数据结构，代码位于：components/drivers/src/ringbuffer.ccomponents/drivers/include/ipc/ringbuffer.hRingBuffer 其实就是先进先出（FI...
RT-Thread 隐藏的宝藏之ringbuff
whj123999的博客
03-21 3661
一，什么是 ringbuff ringbuff: 翻译成中文就是环形缓冲区。 网上关于 ringbuff 的介绍已经非常多了，我也分享一下我对 ringbuff 的认识。ringbuff 可以理解为学校操场上的跑道，ringbuff 初始化就是新建了一个 400 的环形操场跑道，跑道上有 2 名同学 (write 和 read)，每次写入一个数据，write 往前跑一步，每次读一个数据，read 往前跑一步，read永远不可以超过 write。刚开始起点都是 0 ，如果 write 写的速度慢了，被 re
RTThread 调试MQTT数据太长导致报 hard fault 之后死机
Dwyer的博客
08-12 625
参考链接如下 添加链接描述 调整 RT_PIPE_BUFSZ 在ENV中的位置
I/O 设备模型-1
qq_37932504的博客
09-27 2110
RT-Thread 提供了一套简单的 I/O 设备模型框架，它位于硬件和应用程序之间，共分成三层，从上到下分别是 I/O 设备管理层、设备驱动框架层、设备驱动层。I/O 设备管理层实现对设备驱动程序的封装。应用程序通过 I/O 设备层提供的标准接口访问底层设备，设备驱动程序的升级、更替不会对上层应用产生影响。这种方式使得设备的硬件操作相关的代码能够独立于应用程序而存在，双方只需关注各自的功能实现，从而降低了代码的耦合性、复杂性，提高了系统的可靠性。设备驱动框架层。
20200223-01 RT-Thread 调试 mqtt 报 hard fault 之后死机
你学习了吗？咋办，先想法子忽悠成“砖家”呗
02-23 1978
一、问题描述 配置自动注册 onenet 之后，程序跑了一会就自己死了，并在终端打印如下信息 [D/mqtt.sample] inter mqtt_offline_callback! [D/mqtt.sample] inter mqtt_connect_callback! psr: 0x41000000 r00: 0x00000000 r01: 0x20000fe8 r02: 0x20009...
基于嵌入式操作系统VxWorks的多任务并发程序设计（4）――任务间通信B
weixin_34163553的博客
03-07 158
管道可以看作受驱动器pipeDrv管理的虚拟I/O设备，使用基本的I/O系统接口可以读、写和操作管道，这些函数包括read、write、open、close、ioctl和select等。与pipe密切相关的其它API还有：（1）pipeDrv( )：初始化pipeDrv，函数原型：STATUS pipeDrv (void);（2）pipeDevCreate( )：创建pipe，函数原型：STATU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值