SylixOS 下的工作队列

于 2025-06-17 20:21:36 发布
阅读量563 收藏 12
点赞数 15
CC 4.0 BY-SA版权
分类专栏： SylixOS 嵌入式实时操作系统 文章标签： C 语言 操作系统 SylixOS 工作队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43275558/article/details/148676843

1、引言

1.1、工作队列的核心概念

  工作队列(Workqueue)是 Linux 内核提供的一种异步执行机制，它允许内核开发者将任务推迟执行或分配到其他线程处理。其核心架构由三个关键组件构成：

  • 工作项(Work)：描述待执行任务的数据结构，包含要执行的函数及其参数
  • 工作队列(Workqueue)：用于存放工作项的队列容器
  • 工作者(Worker)：负责执行工作队列中任务的独立内核线程

1.2、工作机制与特点

  工作队列的运行遵循以下机制：

  • 当工作项被加入队列时，空闲的工作者线程会被唤醒
  • 工作者按 FIFO 顺序依次执行队列中的工作项函数
  • 队列为空时，工作者线程进入空闲状态（阻塞状态）

1.3、典型应用场景

  工作队列特别适用于以下情况：

  • 中断处理：将中断服务程序(上半部)中的复杂逻辑推迟到工作队列(下半部)执行
  • 耗时操作：执行可能阻塞或需要调度的长耗时任务

  这种机制有效平衡了系统响应性与任务复杂性，是 Linux 内核异步编程的重要基础设施。

2、SylixOS 下的内核工作队列

  内核工作队列（JobQueue）位于内核文件 libsylixos/SylixOS/kernel/core/_JobQueue.c 中，是纯粹的针对工作队列对象的一些操作集合，供内核使用，系统工作队列和网络工作队列都是基于内核工作队列实现的。

  内核工作队列本质上是基于数组实现的，同时使用了自旋锁进行过程保护和使用了信号量进行资源同步。实现过程比较简单，可以看源码直接分析。

2.1 创建工作队列

/*********************************************************************************************************
** 函数名称: _JobQueueCreate
** 功能描述: 创建一个工作队列
** 输　入  : uiQueueSize       队列大小
**           bNonBlock         执行函数是否为非阻塞方式
** 输　出  : 工作队列控制块
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
PLW_JOB_QUEUE  _jobQueueCreate (UINT uiQueueSize, BOOL bNonBlock)
{
    PLW_JOB_QUEUE pjobq;
    /* 初始化一个工作队列、分配内存空间 */
    pjobq = (PLW_JOB_QUEUE)__KHEAP_ALLOC((size_t)(sizeof(LW_JOB_QUEUE) + 
                                         (uiQueueSize * sizeof(LW_JOB_MSG))));
    if (pjobq == LW_NULL) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n");
        _ErrorHandle(ERROR_KERNEL_LOW_MEMORY);
        return  (LW_NULL);
    }
    
    pjobq->JOBQ_pjobmsgQueue = (PLW_JOB_MSG)(pjobq + 1);
    pjobq->JOBQ_uiIn         = 0;
    pjobq->JOBQ_uiOut        = 0;
    pjobq->JOBQ_uiCnt        = 0;
    pjobq->JOBQ_uiSize       = uiQueueSize;
    pjobq->JOBQ_ulLost       = 0;
    
    /* 这里的同步信号量，可以确保工作队列线程在空闲时，处于阻塞状态，不占用系统资源 */
    if (bNonBlock == LW_FALSE) {
        pjobq->JOBQ_ulSync = API_SemaphoreBCreate("job_sync", LW_FALSE, LW_OPTION_OBJECT_GLOBAL, LW_NULL);
        if (pjobq->JOBQ_ulSync == LW_OBJECT_HANDLE_INVALID) {
            __KHEAP_FREE(pjobq);
            return  (LW_NULL);
        }
    } else {
        pjobq->JOBQ_ulSync = LW_OBJECT_HANDLE_INVALID;
    }
    
    LW_SPIN_INIT(&pjobq->JOBQ_slLock);
    
    return  (pjobq);
}

2.2 添加工作

/*********************************************************************************************************
** 函数名称: _JobQueueAdd
** 功能描述: 添加一个工作到工作队列
** 输　入  : pjobq         工作队列控制块
**           pfunc         要执行的函数
**           pvArg0 ~ 5    函数参数
** 输　出  : ERROR
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueAdd (PLW_JOB_QUEUE pjobq,
                     VOIDFUNCPTR   pfunc,
                     PVOID         pvArg0,
                     PVOID         pvArg1,
                     PVOID         pvArg2,
                     PVOID         pvArg3,
                     PVOID         pvArg4,
                     PVOID         pvArg5)
{
    INTREG           iregInterLevel;
    PLW_JOB_MSG      pjobmsg;
    
    LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    /* 工作队列是有大小限制的。在队列初始化时，设置队列大小 */
    if (pjobq->JOBQ_uiCnt == pjobq->JOBQ_uiSize) {
        pjobq->JOBQ_ulLost++;
        LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        _DebugHandle(__ERRORMESSAGE_LEVEL, "job message lost.\r\n");
        return  (ENOSPC);
    }
    
    /* 工作项，实际上就是一个函数 pfunc 和其入参 */
    pjobmsg                 = &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiIn];
    pjobmsg->JOBM_pfuncFunc = pfunc;
    pjobmsg->JOBM_pvArg[0]  = pvArg0;
    pjobmsg->JOBM_pvArg[1]  = pvArg1;
    pjobmsg->JOBM_pvArg[2]  = pvArg2;
    pjobmsg->JOBM_pvArg[3]  = pvArg3;
    pjobmsg->JOBM_pvArg[4]  = pvArg4;
    pjobmsg->JOBM_pvArg[5]  = pvArg5;
    
    if (pjobq->JOBQ_uiIn == (pjobq->JOBQ_uiSize - 1)) {
        pjobq->JOBQ_uiIn =  0;
    } else {
        pjobq->JOBQ_uiIn++;
    }
    
    pjobq->JOBQ_uiCnt++;
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
    
    /* 尝试唤醒工作队列（工作者） */
    if (pjobq->JOBQ_ulSync) {
        API_SemaphoreBPost(pjobq->JOBQ_ulSync);
    }
    
    return  (ERROR_NONE);
}

2.3 执行工作

/*********************************************************************************************************
** 函数名称: _jobQueueExec
** 功能描述: 执行工作队列中的工作
** 输　入  : pjobq         工作队列控制块
**           ulTimeout     等待超时时间
** 输　出  : 不为 ERROR_NONE 表示超时
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
ULONG  _jobQueueExec (PLW_JOB_QUEUE pjobq, ULONG  ulTimeout)
{
    INTREG          iregInterLevel;
    PLW_JOB_MSG     pjobmsg;
    LW_JOB_MSG      jobmsgRun;
    
    if (pjobq->JOBQ_ulSync) {
        for (;;) {
        	/* 这里是工作者阻塞的根源 */
            if (API_SemaphoreBPend(pjobq->JOBQ_ulSync, ulTimeout)) {
                return  (ERROR_THREAD_WAIT_TIMEOUT);
            }
            LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
            if (pjobq->JOBQ_uiCnt) {
                break;
            }
            LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        }
    } else {
        LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    }
    
    /* 从这里可以看到，工作者每被唤醒一次，会尝试把工作队列里面的所有工作项都完成 */
    while (pjobq->JOBQ_uiCnt) {
        pjobmsg = &pjobq->JOBQ_pjobmsgQueue[pjobq->JOBQ_uiOut];
        LW_JOB_MSG_COPY(&jobmsgRun, pjobmsg);
        if (pjobq->JOBQ_uiOut == (pjobq->JOBQ_uiSize - 1)) {
            pjobq->JOBQ_uiOut =  0;
        } else {
            pjobq->JOBQ_uiOut++;
        }
        pjobq->JOBQ_uiCnt--;
        LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
        
        if (jobmsgRun.JOBM_pfuncFunc) {
            jobmsgRun.JOBM_pfuncFunc(jobmsgRun.JOBM_pvArg[0],
                                     jobmsgRun.JOBM_pvArg[1],
                                     jobmsgRun.JOBM_pvArg[2],
                                     jobmsgRun.JOBM_pvArg[3],
                                     jobmsgRun.JOBM_pvArg[4],
                                     jobmsgRun.JOBM_pvArg[5]);
        }
        
        LW_SPIN_LOCK_QUICK(&pjobq->JOBQ_slLock, &iregInterLevel);
    }
    LW_SPIN_UNLOCK_QUICK(&pjobq->JOBQ_slLock, iregInterLevel);
    
    return  (ERROR_NONE);
}

_jobQueueExec 通常会放到一个线程中。内核工作队列文件中并没有这个操作，通常由具体使用者去创建。

3、SylixOS 下的系统工作队列

  系统工作队列（Work Queue）是 SylixOS 提供的系统级接口，供驱动和应用层直接调用。

  系统工作队列底层实现其实分两部分，简单工作队列（simple work queue）和 延时工作队列（delay work queue）。

  • 简单工作队列由 __wqS 打头的函数簇实现，本质是基于内核工作队列并结合了执行线程创建、同步保护等相关操作实现
  • 延时工作队列由 __wqD 打头的函数簇实现，本质和内核工作队无关，是基于单向链表和等待唤醒链表实现的

  系统工作队列相比于内核工作队列，不仅提供了执行线程，还提供了延时执行的功能，更便于被直接调用，是一种系统级调用接口。内核工作队列提供的则是更基础的调用方法，是一种半成品。对于一些不适合直接使用系统工作队列的地方，可以在内核工作队列的基础上构造自己独享的工作队列模块，如网络接收处理和系统中断下半部执行等都是基于内核工作队列单独实现的。

  下面仅以简单工作队列为例讲解，延时工作队列具体内容，感兴趣的可以自行研究 SylixOS 源码。

3.1 创建工作队列

/*********************************************************************************************************
** 函数名称: __wqSExec
** 功能描述: 执行一次工作队列
** 输　入  : pwq          工作队列控制块
** 输　出  : NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
static VOID  __wqSExec (PLW_WORK_QUEUE  pwq)
{
    _jobQueueExec(pwq->q.WQ_sq.SWQ_pjobQ, LW_OPTION_WAIT_INFINITE);
}
/*********************************************************************************************************
** 函数名称: __wqTask
** 功能描述: 工作队列服务线程
** 输　入  : pvArg        工作队列控制块
** 输　出  : NULL
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
static PVOID  __wqTask (PVOID  pvArg)
{
    PLW_WORK_QUEUE  pwq = (PLW_WORK_QUEUE)pvArg;
    
    for (;;) {
        switch (pwq->WQ_iType) {
        
        case LW_WQ_TYPE_S:
            __wqSExec(pwq);
            break;
            
        case LW_WQ_TYPE_D:
            __wqDExec(pwq);
            break;
            
        default:
            break;
        }
        
        if (pwq->WQ_bDelReq) {
            break;
        }
    }
    
    return  (LW_NULL);
}
/*********************************************************************************************************
** 函数名称: __wqSCreate
** 功能描述: 创建一个简单工作队列
** 输　入  : pwq           工作队列控制块
**           uiQSize       队列大小
** 输　出  : ERROR_CODE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
static PLW_WORK_QUEUE  __wqSCreate (PLW_WORK_QUEUE  pwq, UINT  uiQSize)
{
    pwq->WQ_iType = LW_WQ_TYPE_S;
    pwq->q.WQ_sq.SWQ_pjobQ = _jobQueueCreate(uiQSize, LW_FALSE);
    if (pwq->q.WQ_sq.SWQ_pjobQ == LW_NULL) {
        return  (LW_NULL);
    }
    
    return  (pwq);
}
/*********************************************************************************************************
** 函数名称: API_WorkQueueCreate
** 功能描述: 创建一个工作队列
** 输　入  : pcName            队列名称
**           uiQSize           队列大小
**           bDelayEn          是否创建带有延迟执行功能的工作队列
**           ulScanPeriod      如果带有延迟选项, 此参数指定服务线程扫描周期.
**           pthreadattr       队列服务线程选项
** 输　出  : 工作队列句柄
** 全局变量: 
** 调用模块: 
** 注  意  : 如果不需要延迟执行功能, 则系统自动创建为简单工作队列, 内存占用量小, 执行效率高.

                                           API 函数
*********************************************************************************************************/
LW_API  
PVOID  API_WorkQueueCreate (CPCHAR                  pcName,
                            UINT                    uiQSize, 
                            BOOL                    bDelayEn, 
                            ULONG                   ulScanPeriod, 
                            PLW_CLASS_THREADATTR    pthreadattr)
{
    PLW_WORK_QUEUE         pwq;
    LW_CLASS_THREADATTR    threadattr;
    
    if (!uiQSize || (bDelayEn && !ulScanPeriod)) {
        _ErrorHandle(EINVAL);
        return  (LW_NULL);
    }
    
    pwq = (PLW_WORK_QUEUE)__KHEAP_ALLOC(sizeof(LW_WORK_QUEUE));
    if (pwq == LW_NULL) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n");
        _ErrorHandle(ENOMEM);
        return  (LW_NULL);
    }
    lib_bzero(pwq, sizeof(LW_WORK_QUEUE));
    
    /* 这里区分是普通工作队列还是延迟工作队列 */
    if (bDelayEn) {
        if (__wqDCreate(pwq, uiQSize, ulScanPeriod) == LW_NULL) {
            __KHEAP_FREE(pwq);
            return  (LW_NULL);
        }
    
    } else {
    	/* 创建工作队列，调用创建内核工作队列接口 */
        if (__wqSCreate(pwq, uiQSize) == LW_NULL) {
            __KHEAP_FREE(pwq);
            return  (LW_NULL);
        }
    }
    
    if (pthreadattr) {
        threadattr = *pthreadattr;
    
    } else {
        threadattr = API_ThreadAttrGetDefault();
    }
    
    threadattr.THREADATTR_ulOption &= ~LW_OPTION_THREAD_DETACHED;
    threadattr.THREADATTR_ulOption |= LW_OPTION_OBJECT_GLOBAL;
    threadattr.THREADATTR_pvArg     = pwq;
    
    /*  创建用于执行工作队列的线程 __wqTask（工作者） */
    pwq->WQ_ulTask = API_ThreadCreate(pcName, __wqTask, &threadattr, LW_NULL);
    if (pwq->WQ_ulTask == LW_OBJECT_HANDLE_INVALID) {
        if (bDelayEn) {
            __wqDDelete(pwq);
        
        } else {
            __wqSDelete(pwq);
        }
        __KHEAP_FREE(pwq);
        return  (LW_NULL);
    }
    
    return  ((PVOID)pwq);
}

3.2 添加工作

/*********************************************************************************************************
** 函数名称: __wqSInsert
** 功能描述: 将一个工作插入到工作队列
** 输　入  : pwq          工作队列控制块
**           pfunc        执行函数
**           pvArg0 ~ 5   执行参数
** 输　出  : ERROR_CODE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
static ULONG  __wqSInsert (PLW_WORK_QUEUE  pwq, 
                           VOIDFUNCPTR     pfunc, 
                           PVOID           pvArg0,
                           PVOID           pvArg1,
                           PVOID           pvArg2,
                           PVOID           pvArg3,
                           PVOID           pvArg4,
                           PVOID           pvArg5)
{
	/* 可以看到，这里是直接调用的内核工作队列 */
    return  (_jobQueueAdd(pwq->q.WQ_sq.SWQ_pjobQ,
                          pfunc, pvArg0, pvArg1, pvArg2,
                          pvArg3, pvArg4, pvArg5));
}
/*********************************************************************************************************
** 函数名称: API_WorkQueueInsert
** 功能描述: 将一个工作插入到工作队列
** 输　入  : pvWQ         工作队列句柄
**           ulDelay      最小延迟执行时间
**           pfunc        执行函数
**           pvArg0 ~ 5   执行参数
** 输　出  : ERROR_CODE
** 全局变量: 
** 调用模块: 
                                           API 函数
*********************************************************************************************************/
LW_API  
ULONG  API_WorkQueueInsert (PVOID           pvWQ, 
                            ULONG           ulDelay,
                            VOIDFUNCPTR     pfunc, 
                            PVOID           pvArg0,
                            PVOID           pvArg1,
                            PVOID           pvArg2,
                            PVOID           pvArg3,
                            PVOID           pvArg4,
                            PVOID           pvArg5)
{
    PLW_WORK_QUEUE  pwq = (PLW_WORK_QUEUE)pvWQ;
    ULONG           ulRet;
    
    if (!pwq) {
        _ErrorHandle(EINVAL);
        return  (EINVAL);
    }
    
    switch (pwq->WQ_iType) {
        
    case LW_WQ_TYPE_S:
        ulRet = __wqSInsert(pwq, pfunc, pvArg0, pvArg1, pvArg2,
                            pvArg3, pvArg4, pvArg5);
        break;
        
    case LW_WQ_TYPE_D:
        ulRet = __wqDInsert(pwq, ulDelay, pfunc, pvArg0, pvArg1, pvArg2,
                            pvArg3, pvArg4, pvArg5);
        break;
        
    default:
        _ErrorHandle(ENXIO);
        ulRet = ENXIO;
        break;
    }
    
    return  (ulRet);
}
SylixOS上EtherCAT实现
Jackstraw瑞的博客
11-01 3181
1 EtherCAT开源协议栈介绍     目前常见开源的主站代码为RT-LAB开发的SOEM(Simple OpenSource EtherCAT Master)和EtherLab的the IgH EtherCAT® Master，SylixOS对两者都支持。其中IgH作为常用的EtherCAT开源协议栈，SylixOS已移植支持。 2 SylixOS-IgH使用框架     SylixO
SylixOS介绍
09-12
这个文档介绍了中国人自己写的一个实时操作系统SylixOS
SylixOS启程之旅
03-05
随着SylixOS在各领域的广泛应用，更多的工程师想深入了解SylixOS的产品特性、功能特点、应用场景。翼辉信息针对客户需求与当前疫情特殊情况，首批推出10节网络公开课。通过课程您将全面了解SylixOS的功能与使用方法。这也将为您后续产品选型提供一个优秀产品的选择。
SylixOS学习三—— SylixOS的引导与安装1
graceyun的博客
10-04 4086
自学SylixOS启程之旅笔记一、SylixOS 引导过程分析1. SylixOS 常用引导程序2. SylixOS 支持ARM设备的几种引导方式3.SylixOS引导过程分析——总流程分析3.1 一个设备从上电到启动完成的整个流程3.2 引导程序和操作系统镜像的存储3.3 U-Boot引导SylixOS3.4 引导过程中的几个基本概念 《SylixOS启程之旅》是一门公开课，点开下面链接即可观看： SylixOS启程之旅 一、SylixOS 引导过程分析 1. SylixOS 常用引导程序 U-Boo
SylixOS 大型实时操作系统
weixin_68540764的博客
01-26 1369
SylixOS的简介
SylixOS 中 select 原理及使用分析
最新发布
日常学习记录
03-26 941
select 是操作系统多路 I/O 复用技术实现的方式之一。select 函数允许程序监视多个文件描述符，等待所监视的一个或者多个文件描述符变为“准备好”的状态。所谓的”准备好“状态是指：文件描述符不再是阻塞状态，可以用于某类 IO 操作了，包括可读，可写，发生异常三种。
SylixOS的来龙去脉
热门推荐
ScilogyHunter的博客
09-10 1万+
什么是SylixOS SylixOS是一款诞生于2006年、由中国人自己开发的、大型、嵌入式、实时、类UNIX、操作系统。现由翼辉信息有限公司专门推广和开发。 特别强调一下，SylixOS不是Linux的衍生版，也不是照抄了其他操作系统的内核，SylixOS内核完全是国人自主开发的，另外配套移植了一些第三方开源软件（如FAT文件系统，QT图形界面等，其他操作系统的很多中间件也大多是移植第三方开源软件）而组成的操作系统。 之所以强调是自主开发，是因为在SylixOS推广的初期，用户都会有太多误解和疑问。最经典
SylixOS实验指导书1
08-08
SylixOS 提供了丰富的内核服务，如任务管理、信号量、消息队列、内存管理等．它支持多种处理器架构，包括ARM，能够满足不同硬件平台的需求．此外，SylixOS 支持硬实时和软实时应用，适用于工业自动化、航空航天、...
SylixOS can驱动框架分析
12-24
本文档旨在深入剖析SylixOS中的CAN驱动框架，并详细介绍其关键函数的工作原理。 #### 二、适用范围 本文档适用于以下人群： - 正在开发基于SylixOS的应用程序的工程师； - 对SylixOS内核有基本了解的技术人员； -...
SylixOS驱动开发指南：消息队列接收与并发同步
在SylixOS这款先进的实时嵌入式操作系统中，消息队列是实现进程间通信（IPC）的关键组件。本文档主要关注消息队列的接收选项，这对于理解SylixOS中的并发和同步机制至关重要。 在SylixOS驱动开发中，`API_...
SylixOS驱动开发详解：并发、同步与消息队列
在《消息队列的使用-美国国防体系dodaf2.02》中，主要探讨的是如何在SylixOS操作系统环境下有效地利用消息队列这一并发控制机制。消息队列是进程间通信的重要工具，它允许一个进程发送消息到另一个进程，而接收进程...
SylixOS 系统初探
增阅笔记
07-18 1万+
国产嵌入式硬实时操作系统 SylixOS 初体验 关于 SylixOS 详细了解请见：http://wiki.sylixos.com/index.php/%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B SylixOS是一款嵌入式硬实时操作系统，同其类似的操作系统，全球比较知名的还有VxWorks(主要应用于航空航天、军事与工业自动化领域)、RTEMS(起源于美国国防...
SylixOS系统简介
糊涂岁月的专栏
06-30 5413
SylixOS是一款嵌入式硬实时操作系统，同其类似的操作系统，全球比较知名的还有VxWorks(主要应用于航空航天、军事与工业自动化领域)、 RTEMS(起源于美国国防部导弹与火箭控制实时系统)、ThreadX(主要应用于航空航天与数码通讯)等。 从全球范围上看，SylixOS作为实时操作系统 的后来者，在设计思路上借鉴了众多实时操作系统的设计思想，其中就包括RTEMS、VxWorks
SylixOS Makefile 源代码解析
兔兔里个花兔的博客
02-24 1160
word版下载地址：https://download.csdn.net/download/qq_28637193/10871601 原来是在word上写的，粘贴复制过来了，格式显示的不是很好。    SylixOS  Makefile  源代码解析 SylixOS 是由base，bsp，app三部分组成，一下将分别介绍着三部分中的Makefile以及他们之间Makefile相互联系。 1....
走进SylixOS代码
smmlzp的专栏
09-13 3377
程序设计绝对是一门艺术，而不仅仅是一门技术。首先，程序设计的出发点是给别人看，可读、易理解、好维护。如果你的程序只能自己来维护，到你离开这个程序时，你程序也就与你一起离开了这个世界。为了可读、易理解、好维护，你的程序要有好的设计，而不是一接手就进行东抄抄、西抄抄的写代码工作。
SylixOS的初探
贴吧尚书的博客
10-07 7335
SylixOS是第一个国产开源嵌入式实时操作系统，能够支持smp对称多核处理器的运行。它是目前国内唯一可以和vxworks抗衡的系统，也被视为将来在国内可以替换掉vxworks系统的希望。 在此对SylixOS系统做一个最初的了解。
认识SylixOS
smmlzp的专栏
09-12 1368
作为一个嵌入式开发爱好者，一直
ucGUI在SylixOS下的应用
渀波儿灞
01-22 991
工作准备 环境准备 在使用之前，须安装有SylixOS的集成开发套件，由于系统上安装的防火墙软件或者杀毒软件，可能会影响到集成开发软件的使用，因此，在使用本套件前请关闭计算机上的windows 防火墙以及杀毒软件。 因后续操作需要在模拟器上进行展示（本文档以mini2440模拟器进行模拟展示），所以在进行后续章节操作前，请完成 mini2440模拟器的配置并启动。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值