VxWorks的环形缓冲区设计

概述

Vxwroks 环形缓冲模块主要定义在rngLib.c和rngLib.h中,对于数据结构比较了解的小伙伴应该知道,环形缓冲实际就是一个双向循环队列。

注意

关于循环队列,小编之前在《也没想象中那么神秘的数据结构-先来后到的“队列”(循环队列)》一文中有过详细阐述,这里就不在过多的赘述了。

开发环境:vxWorks6.9.4,workbench3.3.5,开发板:TLZ7x-EasyEVM-A3。

另外,小编所有文章均是自己亲手编写验证,若需要小编的工程代码,访问地址“实时系统vxWorks - 环形缓冲工程文件”获取。

文件内容如下:

obj:存放目标文件,包含vxWorks镜像,应用程序目标文件。

rng_test:vxWorks应用工程。

接口

官方接口

官方环形缓冲接口定义主要包含在rngLib.h头文件中。

环形缓冲接口定义


        typedef struct        /* RING - ring buffer */
        {
            size_t pToBuf;        /* 写指针 */
            size_t pFromBuf;    /* 读指针 */
            size_t bufSize;      /* 数据长度 */
            char *buf;              /* 存放数据 */
        } RING;
         
        /* END_HIDDEN */
        typedef RING *RING_ID;

创建/删除环形缓冲


        /**
         * @创建环形缓冲
         * @nbytes: 缓冲尺寸
         * @成功返回环形缓冲ID,失败返回NULL。
         */
        extern RING_ID rngCreate (size_t nbytes);
         
        /**
         * @删除环形缓冲
         * @ringId: 环形缓冲ID   
         */
        extern void rngDelete (RING_ID ringId);

判断缓冲是否空/满


        /**
         * @判断环形缓冲是否为空
         * @ringId: 环形缓冲ID   
         * @不为空返回0,否则返回其它。
         */
        extern BOOL rngIsEmpty (RING_ID ringId);
         
        /**
         * @判断环形缓冲是否为满
         * @ringId: 环形缓冲ID   
         * @不为满返回0,否则返回其它。
         */
        extern BOOL rngIsFull (RING_ID ringId);

读写数据


        /**
         * @从环形缓冲中读取数据
         * @ringId: 环形缓冲ID         buffer:数据         maxbytes:长度
         * @返回实际读取到的数据长度。
         */
        extern size_t rngBufGet (RING_ID rngId, char *buffer, size_t maxbytes);
         
        /**
         * @写数据到环形缓冲
         * @ringId: 环形缓冲ID         buffer:数据         nbytes:长度  
         * @返回实际写入数据长度
         */
        extern size_t rngBufPut (RING_ID rngId, char *buffer, size_t nbytes);

获取缓冲区剩余空间/已占空间


        /**
         * @获取环形缓冲剩余空间长度
         * @ringId: 环形缓冲ID 
         * @返回剩余空间长度。
         */
        extern size_t     rngFreeBytes (RING_ID ringId);
         
        /**
         * @获取环形缓冲已占空间长度
         * @ringId: 环形缓冲ID
         * @返回已占空间长度。
         */
        extern size_t     rngNBytes (RING_ID ringId);

清空缓冲


        /**
         * @清空环形缓冲
         * @ringId: 环形缓冲ID
         */
        extern void rngFlush (RING_ID ringId);

环形缓冲对象接口

属性定义


        /* 环形缓冲类 */
        struct t_rng {
            u8_t            flag;   /* 创建标志,=1已创建,=0未创建 */
            RING_ID       id;      /* 环形缓冲 */ 
            struct t_sem    msem;   /* 环形缓冲互斥信号量 */ 
        };

保存数据到环形缓冲


        /**
         * @保存数据到环形缓冲
         * @p_rng:环形缓冲类   buf: 数据   len:长度
         **/
        void put_rng(struct t_rng *p_rng, s8_t *buf, s32_t len);

获取环形缓冲数据



        /**
         * @获取环形缓冲数据
         * @p_rng:环形缓冲类    buf装载数据, len数据长度
         * 成功返回实际数据长度,失败返回ERROR
         **/
        s32_t get_rng(struct t_rng *p_rng, s8_t *buf, s32_t len);

创建环形缓冲


        /**
         * @创建环形缓冲
         * @p_rng:环形缓冲类   nbyte申请缓冲大小, name互斥信号名
         **/
        void create_rng(struct t_rng *p_rng, size_t nbytes, s8_t *name);

示例

★示例创建两个任务(生产者/消费者),生产者向缓冲写入数据,消费者从缓冲读取数据,缓冲访问时使用互斥信号量进行互斥。

★关于信号量和任务部分可参加小编的《实时系统vxWorks - 信号量(重要)》和《实时系统vxWorks - 任务(重要)》文章。

★包含环形缓冲类rng.c/rng.h和演示程序main.c(已验证通过)。

rng.h



        /**
         * @Filename : rng.h
         * @Revision : $Revision: 1.00 $
         * @Author : Feng
         * @Description : 环形缓冲类,在系统自带环形缓冲基础上封装互斥信号量
        **/
         
        #ifndef __RNG_CLASS_H__
        #define __RNG_CLASS_H__
         
        #include   
        #include 
        #include 
        #include 
        #include 
        #include "sem.h"
         
        extern struct sem sem; /* 保存系统信号量信息 */
         
        /* 环形缓冲类 */
        struct t_rng {
            u8_t            flag;   /* 创建标志,=1已创建,=0未创建 */
            RING_ID       id;      /* 环形缓冲 */ 
            struct t_sem    msem;   /* 环形缓冲互斥信号量 */ 
        };
         
        /**
         * @保存数据到环形缓冲
         * @p_rng:环形缓冲类   buf: 数据   len:长度
         **/
        void put_rng(struct t_rng *p_rng, s8_t *buf, s32_t len);
         
        /**
         * @获取环形缓冲数据
         * @p_rng:环形缓冲类    buf装载数据, len数据长度
         * 成功返回实际数据长度,失败返回ERROR
         **/
        s32_t get_rng(struct t_rng *p_rng, s8_t *buf, s32_t len);
         
        /**
         * @创建环形缓冲
         * @p_rng:环形缓冲类   nbyte申请缓冲大小, name互斥信号名
         **/
        void create_rng(struct t_rng *p_rng, size_t nbytes, s8_t *name);
         
        #endif

rng.c



        /**
         * @Filename : rng.c
         * @Revision : $Revision: 1.00 $
         * @Author : Feng
         * @Description : 环形缓冲类,在系统自带环形缓冲基础上封装互斥信号量
        **/
         
        #include "rng.h"
         
        /**
         * @保存数据到环形缓冲
         * @p_rng:环形缓冲类   buf: 数据   len:长度
         **/
        void put_rng(struct t_rng *p_rng, s8_t *buf, s32_t len)
        {  
            if (p_rng->flag == 0)
                return;
         
            get_sem(&p_rng->msem);                  
            if (!(rngIsFull(p_rng->id)))
                rngBufPut(p_rng->id, buf, len); 
            lose_sem(&p_rng->msem); 
        }
         
        /**
         * @获取环形缓冲数据
         * buf装载数据, len数据长度
         * 成功返回实际数据长度,失败返回ERROR
         **/
        s32_t get_rng(struct t_rng *p_rng, s8_t *buf, s32_t len)
        {  
            s32_t rLen = ERROR;
         
            if (p_rng->flag == 0)
                return ERROR;
         
            get_sem(&p_rng->msem);                  
            if (!(rngIsEmpty(p_rng->id)))
                rLen = rngBufGet(p_rng->id, buf, len);
            lose_sem(&p_rng->msem); 
         
            return (rLen);
        }
         
        /**
         * @创建环形缓冲
         * nbyte申请缓冲大小, name互斥信号名
         **/
        void create_rng(struct t_rng *p_rng, size_t nbytes, s8_t *name)
        {
            if (p_rng->flag == 1)
                return;
         
            p_rng->id = rngCreate(nbytes);
         
            p_rng->msem.sem = NULL;
            p_rng->msem.type = SEM_MUTEX;   
            strcpy(p_rng->msem.name, name);
            resgister_sem(&sem, &p_rng->msem);  
         
            p_rng->flag = 1;
        }

main.c



        /**
         * @Filename : main.c
         * @Revision : $Revision: 1.00 $
         * @Author : Feng
         * @Description : 环形缓冲类使用示例
        **/
         
        #include      
        #include     
        #include "stdioLib.h"     
        #include "strLib.h"     
        #include "task.h"
        #include "sem.h"
        #include "rng.h"
        #include "feng_type.h"
         
        #define RNG_SIZE    100 /* 缓冲大小 */
        struct sem     sem; /* 保存系统信号量信息 */
        struct t_task s_task, s_task1;
        struct t_sem s_sem, s_sem1;
        struct t_rng rng;
         
        /**
         * @生产者:定时存储数据到环形缓冲
        **/
        static void _thread(void)
        {  
            static int cnt = 77;
         
            while (1) { 
                get_sem(&s_sem);        
                put_rng(&rng, &cnt, sizeof(int));       
                printf("put data : %d...\n", cnt++);
            }
        }
         
        /**
         * @消费者:定时从环形缓冲中取出数据
        **/
        static void _thread1(void)
        {  
            int cnt1 = 0;
         
            while (1) { 
                get_sem(&s_sem1);
         
                if (get_rng(&rng, &cnt1, sizeof(int)) > 0)
                    printf("get data : %d...\n", cnt1);
            }
        }
         
        /**
         * @创建任务
         * @p_task:任务类    name:任务名        thread:函数
        **/
        void _create_task(struct t_task *p_task, char *name, FUNCPTR thread)
        {
            strcpy(p_task->name, name);     
            p_task->options    = VX_FP_TASK;
            p_task->stackSize  = 50 * 1024;
            p_task->pFunc      = thread;
            p_task->tid        = NULL;
            p_task->core       = 0;
            p_task->priority   = 102;
         
            create_task(p_task);
            start_task(p_task);
        }
         
        /**
         * @创建信号量
         * @p_sem:信号量类        name:信号量名       type:类型
        **/
        void _create_sem(struct t_sem *p_sem, char *name, E_SEM_TYPE type)
        {
            strcpy(p_sem->name, name);      
            p_sem->period = 100;
            p_sem->type = type;
            p_sem->sem = SEM_ID_NULL;
         
            resgister_sem(&sem, p_sem);
        }
         
         
        int main(void)
        {
            sysClkRateSet(100);         /* 时间片设置 */
         
            create_rng(&rng, RNG_SIZE, "my_rng");
         
            _create_sem(&s_sem, "my_sem", SEM_BIN);
            _create_sem(&s_sem1, "my_sem1", SEM_BIN);
         
            _create_task(&s_task, "my_task", (FUNCPTR)_thread);
            _create_task(&s_task1, "my_task1", (FUNCPTR)_thread1);
         
            while (1) { 
                taskDelay(500);     /* 5s */
                lose_sem_by_name(&sem, "my_sem");
                lose_sem_by_name(&sem, "my_sem1");  
            }
         
            return 0;
        }

验证

使用环形缓冲之前需要先添加INCLUDE_RNG_BUF组件。

打开镜像工程,选择kernel Configuration。按住Ctrl+F,输入rng,找到ring buffers,添加组件。

添加完组件后,编译镜像,将镜像拷贝到目标机加载指定目录。

创建应用工程rng_test,输入相关测试代码,运行后如下图所示。

注意:若不知道工程如何创建以及运行,可参见小编文章《实时系统vxWorks - 任务(重要)》和《实时系统vxWorks - 加载应用程序的方法》。

下一篇
« Prev Post
上一篇
Next Post »