嵌入式操作系统VxWorks简介
%A
%A VxWorks操作系统是美国WindRiver公司于1983年设计开发的一种嵌入式实时操作系统（RTOS），是嵌入式开发环境的关键组成部分。良好的持续发展能力、高性能的内核以及友好的用户开发环境，在嵌入式实时操作系统领域占据一席之地。它以其良好的可靠性和卓越的实时性被广泛地应用在通信、军事、航空、航天等高精尖技术及实时性要求极高的领域中，如卫星通讯、军事演习、弹道制导、飞机导航等。在美国的 F-16、FA-18 战斗机、B-2 隐形轰炸机和爱国者导弹上，甚至连1997年4月在火星表面登陆的火星探测器上也使用到了VxWorks。
%A
%A WindRiver公司网址
%A
%A 　
%A
%A 实时操作系统和分时操作系统的区别
%A
%A      从操作系统能否满足实时性要求来区分，可把操作系统分成分时操作系统和实时操作系统。
%A
%A   分时操作系统按照相等的时间片调度进程轮流运行，分时操作系统由调度程序自动计算进程的优先级，而不是由用户控制进程的优先级。这样的系统无法实时响应外部异步事件。
%A
%A     实时操作系统能够在限定的时间内执行完所规定的功能，并能在限定的时间内对外部的异步事件作出响应。 分时系统主要应用于科学计算和一般实时性要求不高的场合。实时性系统主要应用于过程控制、数据采集、通信、多媒体信息处理等对时间敏感的场合。
%A
%A VxWorks的特点
%A
%A 可靠性
%A
%A     操作系统的用户希望在一个工作稳定，可以信赖的环境中工作，所以操作系统的可靠性是用户首先要考虑的问题。而稳定、可靠一直是VxWorks的一个突出优点。自从对中国的销售解禁以来，VxWorks以其良好的可靠性在中国赢得了越来越多的用户。
%A
%A 实时性
%A
%A    实时性是指能够在限定时间内执行完规定的功能并对外部的异步事件作出响应的能力。实时性的强弱是以完成规定功能和作出响应时间的长短来衡量的。
%A
%A     VxWorks 的实时性做得非常好，其系统本身的开销很小，进程调度、进程间通信、中断处理等系统公用程序精练而有效，它们造成的延迟很短。VxWorks 提供的多任务机制中对任务的控制采用了优先级抢占（Preemptive Priority Scheduling）和轮转调度（Round-Robin Scheduling）机制，也充分保证了可靠的实时性，使同样的硬件配置能满足更强的实时性要求，为应用的开发留下更大的余地。
%A
%A 可裁减性
%A
%A    用户在使用操作系统时，并不是操作系统中的每一个部件都要用到。例如图形显示、文件系统以及一些设备驱动在某些嵌入系统中往往并不使用。
%A
%A   VxWorks 由一个体积很小的内核及一些可以根据需要进行定制的系统模块组成。VxWorks 内核最小为 8kB，即便加上其它必要模块，所占用的空间也很小，且不失其实时、多任务的系统特征。由于它的高度灵活性，用户可以很容易地对这一操作系统进行定制或作适当开发，来满足自己的实际应用需要。
%A
%A 对一个实时内核的要求
%A
%A 一个实时操作系统内核需满足许多特定的实时环境所提出的基本要求，这些包括：
%A
%A 多任务：由于真实世界的事件的异步性，能够运行许多并发进程或任务是很重要的。多任务提供了一个较好的对真实世界的匹配，因为它允许对应于许多外部事件的多线程执行。系统内核分配CPU给这些任务来获得并发性。
%A
%A 抢占调度：真实世界的事件具有继承的优先级，在分配CPU的时候要注意到这些优先级。基于优先级的抢占调度，任务都被指定了优先级，在能够执行的任务（没有被挂起或正在等待资源）中，优先级最高的任务被分配CPU资源。换句话说，当一个高优先级的任务变为可执行态，它会立即抢占当前正在运行的较低优先级的任务。
%A
%A 任务间的通讯与同步：在一个实时系统中，可能有许多任务作为一个应用的一部分执行。系统必须提供这些任务间的快速且功能强大的通信机制。内核也要提供为了有效地共享不可抢占的资源或临界区所需的同步机制。
%A
%A 任务与中断之间的通信：尽管真实世界的事件通常作为中断方式到来，但为了提供有效的排队、优先化和减少中断延时，我们通常希望在任务级处理相应的工作。所以需要杂任务级和中断级之间存在通信。
%A
%A 　
%A
%A 二.系统编程方法
%A
%A 　
%A
%A 实时系统主要包括:多任务调度（采用优先级抢占方式），任务间的同步和进程间通信机制.
%A
%A 一个多任务环境允许实时应用程序以一套独立任务的方式构筑，每个任务拥有独立的执行线程和它自己的一套系统资源。进程间通信机制使得这些任务的行为同步、协调。 wind使用中断驱动和优先级的方式。它缩短了上下文转换的时间开销和中断的时延。在 VxWorks 中，任何例程都可以被启动为一个单独的任务，拥有它自己的上下文和堆栈。还有一些其它的任务机制可以使任务挂起、继续、删除、延时或改变优先级。
%A
%A 另一个重要内容是:硬件中断处理。硬件产生中断,统治系统调用相应的中断历程(ISR),位是系统得到尽快的响应,ISR在它自己独立的上下文和堆栈中运行.它的优先级高于任何任务优先级.
%A
%A Task State Transitions
%A
%A 　
%A
%A 　
%A
%A 中断延迟(Interrupt Latency) 中断延迟是指从硬件中断发生到开始执行中断处理程序第一条指令之间的这段时间。
%A
%A 优先级驱动(Priority-Driven)  优先级驱动是指多任务系统中，当前运行任务总是具有最高优先级的就绪任务。
%A
%A 多任务调度
%A
%A 两种方式: 优先抢占和轮转调度(Preemptive Priority,Round-Robin Scheduling).
%A
%A 优先抢占(Preemptive Priority): 每一个任务都有一个优先级,系统核心保证优先级最高的任务运行于CPU.如果有任务优先级高于当前的任务优先级,系统立刻保存当前任务的上下文,切换到优先级高的上下文.
%A
%A Priority Preemption
%A
%A 　
%A
%A 　
%A
%A 抢占(Preemptive): 抢占是指当系统处于核心态运行时, 允许任务的重新调度。换句话说就是指正在执行的任务可以被打断，让另一个任务运行。抢占提高了应用对异步事件的响应性能力。操作系统内核可抢占，并不是说任务调度在任何时候都可以发生。例如当一个任务正在通过一个系统调用访问共享数据时，重新调度和中断都被禁止.
%A
%A 任务上下文(Task Context): 任务上下文是指任务运行的环境。例如，针对x86的CPU，任务上下文可包括程序计数器、堆栈指针、通用寄存器的内容.
%A
%A 上下文切换（Context Switching）: 多任务系统中，上下文切换是指CPU的控制权由运行任务转移到另外一个就绪任务时所发生的事件，当前运行任务转为就绪（或者挂起、删除）状态，另一个被选定的就绪任务成为当前任务。上下文切换包括保存当前任务的运行环境，恢复将要运行任务的运行环境。上下文的内容依赖于具体的CPU.
%A
%A 　
%A
%A 轮转调度(Round-Robin Scheduling):使所有相同优先级,状态为ready的任务公平分享CPU(分配一定的时间间隔,使个任务轮流享有CPU).
%A
%A Round-Robin Scheduling
%A
%A 　
%A
%A 系统由256个优先级,从0到255,0为最高,255为最低. 任务在被创建时设定了优先级.也可用taskPrioritySet  ( ) 来改变任务优先级.
%A
%A 任务的主要状态: READY,PEND,DELAY,SUSPEND...
%A
%A ready-------->pended -----------semTake(　)/msgQReceive(　)-其他任务
%A ready-------->delayed-----------taskDelay(　)
%A ready-------->suspended---------taskSuspend(　)
%A pended------->ready-------------semaGive(　)/msgQSend(　)-其他任务
%A pended------->suspended---------taskSuspend(　)
%A delayed------>ready-------------expired delay
%A delayed------>suspended---------taskSuspend(　)
%A suspended---->ready-------------taskResume(　)/taskActivate(　)
%A suspended---->pended------------taskResume(　)
%A suspended---->delayed-----------taskResume(　)
%A 　
%A
%A 轮转调度 (Round-Robin): 轮转调度可以扩充到优先抢占方式中,当多个任务优先级相同的情况下,轮转调度算法使任务按平等的时间片运行于CPU,共享CPU.避免一个任务长时间占用CPU,而导致其他任务不能运行.可以用 kernelTimeSlice(　) 来定义时间长度.
%A
%A taskLock  ( )和 taskUnlock ( ) 用来取消优先抢占方式 和恢复优先抢占方式.
%A
%A 注意: 一个任务可以调用taskDelete ( ) 删除另一个任务,但是如果一个当前正在运行的任务被删除后,该任务的内存没有释放,而其他任务不知道,依然在等待,结果导致系统stop.用 taskSafe ( ) 和 taskUnsafe ( ) 来保证正在运行的任务不被删除.
%A
%A 用法如下:
%A
%A taskSafe ();
%A semTake (semId, WAIT_FOREVER);
%A /* Block until semaphore available */
%A . .　. .　critical region .
%A semGive (semId);　semGive (semId);　　
%A /* Release semaphore */
%A taskUnsafe ();
%A
%A 　
%A
%A 任务间的同步和进程间协调
%A
%A 信号量作为任务间同步和互斥的机制。在 wind 核中有几种类型的信号量，它们分别针对不同的应用需求：二进制信号量、计数信号量、互斥信号量和 POSIX 信号量。所有的这些信号量是快速和高效的，它们除了被应用在开发设计过程中外，还被广泛地应用在VxWorks 高层应用系统中。对于进程间通信，wind 核也提供了诸如消息队列、管道、套接字和信号等机制。
%A
%A 任务间的同步和进程间协调的几种方式:
%A
%A 内存共享(Shared Memory),对简单的数据共享而言.
%A
%A 信号量(Semaphore),基本的互斥和同步.
%A
%A 消息队列(Message queues)和管道(Pipe),单个CPU中,任务间的信息传递.
%A
%A 套结字(Socket)和远程调用(Remote procedure calls),相对于网络任务间的通信.
%A
%A 信号(Signals),出错处理(Exception handling).
%A
%A 　
%A
%A      内存共享(Shared Memory)        
%A
%A 任务间通信最通常的方式是通过共享的数据结构进行通信,因为所有VxWorks的任务存在于一个单一的线性地址空间，任务间共享数据。全局变量、线性队列、环形队列、链表、指针都可被运行在不同上下文的代码所指向。
%A
%A Shared Data Structures
%A
%A 　
%A
%A 互斥(Mutual Exclusion)
%A
%A 互斥是用来控制多任务对共享数据进行串行访问的同步机制。在多任务应用中，当两个或多个任务同时访问共享数据时，可能会造成数据破坏。互斥使它们串行地访问数据，从而达到保护数据的目的.
%A
%A 解决互斥的几种方法:
%A
%A 1. 关闭中断的方法(intLock): 能解决任务和中断ISR之间产生的互斥.
%A
%A funcA ()
%A {   int lock = intLock();
%A . .   critical region that cannot be interrupted .
%A intUnlock (lock);   }
%A 但在实时系统中采取这个办法会影响系统对外部中断及时响应和处理的能力.
%A
%A 2. 关闭系统优先级(taskLock): 关闭系统优先级,这样在当前任务执行时,除了中断外,不会有其他优先级高的任务来抢占CPU,影响当前程序运行.
%A
%A funcA ()
%A
%A { taskLock ();
%A
%A . .  critical region that cannot be interrupted .
%A
%A taskUnlock (); }
%A
%A 这种方法阻止了高优先级的任务抢先运行,在实时系统中也是不适合的,除非关闭优先级的时间特别短.
%A
%A   
%A
%A 信号量(Semaphore): 信号量是解决互斥和同步协调进程最好的方法
%A
%A VxWorks信号量提供最快速的任务间通信机制，它主要用于解决任务间的互斥和同步。针对不同类型的问题，有以下三种信号量：
%A
%A Ÿ         二进制信号量（binary) 使用最快捷、最广泛，主要用于同步或互斥；
%A
%A Ÿ         互斥信号量(mutual exclusion)  特殊的二进制信号量，主要用于优先级继承、安全删除和回溯；
%A
%A Ÿ         计数器信号量(counting) 和二进制信号量类似，保持信号量被释放（gaven)的次数 ,主要用于保护一个资源的多个例程（multiple instances of a resource）
%A
%A 信号量控制，函数介绍:
%A
%A semBCreate( ) 分配并初始化一个二进制信号量
%A
%A semMCreate( ) 分配并初始化一个互斥信号量
%A
%A semCCreate( ) 分配并初始化一个计数信号量
%A
%A semDelete( ) 终止一个自由的信号量
%A
%A emTake( ) 占有一个信号量
%A
%A semGive( ) 释放一个信号量
%A
%A semFlush( ) 解锁所有等待信号量的任务
%A
%A semBCreate( ), semMCreate( ), and semCCreate( )返回一个信号量ID作为其它后续任务使用该信号量的的句柄。当一个信号量被创建，它的队列（queue)类型就被确定。等待信号量的任务队列以优先级的高低排列(SEM_Q_PRIORITY)，或者一先到先得的方式排列（SEM_Q_FIFO).
%A
%A 当一个Semaphore创建时,指定了任务队列的种类
%A
%A semBCreat( SEM_Q_PRIORITY, SEM_FULL),   SEM_Q_PRIORITY 指明处于等待状态的任务在等待队列中以优先级的顺序排列
%A
%A semBCreat(SEM_Q_FIFO,SEM_FULL),   SEM_Q_FIFO指明 处于等待状态的任务在等待队列中以先进先出的顺序排列
%A
%A                         
%A
%A 二进制信号量（binary)  
%A
%A Taking a Semaphore
%A
%A Giving a Semaphore
%A
%A 　
%A
%A 互斥进程（Mutual Exclusion）
%A
%A 互斥信号量有效的内锁对共享资源的进入，与屏蔽中断(disabling interrupts)和优先级锁定（preemptive locks）相比，二进制信号量将互斥的范围限制在仅与其有关的资源上。从技术上说，创建一个信号量来保护(guarding)资源。信号量初始化位可用的（FULL）。
%A
%A 当一个Semaphore创建时,指定了这个semaphore是用在解决互斥还是用来同步任务
%A
%A semBCreat( SEM_Q_FIFO, SEM_FULL) ,  SEM_FULL 指明用于任务间互斥.
%A
%A SEM_ID semMutex;
%A
%A semMutex = semBCreate (SEM_Q_PRIORITY, SEM_FULL);
%A
%A     当一个任务要进入资源，首先要得到一个信号量（take that semaphore），只要有任务在使用这个信号量，其它的要进入资源的任务要停止执行（blocked from execution），当这个任务完成了对资源的使用，它会释放信号量，允许另一个任务来使用资源。
%A
%A semTake (semMutex, WAIT_FOREVER);
%A
%A . .  critical region, only accessible by a single task at a time .
%A
%A semGive (semMutex);
%A
%A 　
%A
%A 同步协调进程（Synchronization）    
%A
%A semBCreat(SEM_Q_FIFO,SEM_EMPTY),  SEM_EMPTY 指明用于任务间同步.
%A
%A /* includes */
%A #include "vxWorks.h"
%A #include "semLib.h"
%A SEM_ID syncSem;
%A /* ID of sync semaphore */
%A init ( int someIntNum )
%A { /* connect interrupt service routine */
%A intConnect (INUM_TO_IVEC (someIntNum), eventInterruptSvcRout, 0);
%A /* create semaphore */
%A syncSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
%A /* spawn task used for synchronization. */
%A taskSpawn ("sample", 100, 0, 20000, task1, 0,0,0,0,0,0,0,0,0,0);
%A }
%A task1 (void)
%A { ...
%A semTake (syncSem, WAIT_FOREVER);
%A /* wait for event to occur */
%A printf ("task 1 got the semaphore\n");
%A ...
%A /* process event */
%A }
%A eventInterruptSvcRout (void)
%A { ...
%A semGive (syncSem);
%A /* let task 1 process event */
%A ...
%A }
%A        semTake(semID,time out)--------有Semaphore空闲,就Take, 如果没有,由time out 定,超时则向下执行
%A
%A 　
%A
%A 互斥信号量
%A
%A 互斥信号量是一个特殊的二进制信号量，设计用于优先级继承，安全删除和回归。
%A
%A 互斥信号量的使用基本和二进制信号量是类似的。但有以下不同：
%A
%A 仅仅被用做互斥。
%A
%A 只能被使用它的任务释放.(It can be given only by the task that took it.)
%A
%A ISR 不能释放它。
%A
%A 不能使用函数semFlush( )。
%A
%A
%A 优先级反转(Priority Inversion)
%A
%A 优先级反转是指一个任务等待比它优先级低的任务释放资源而被阻塞，如果这时有中等优先级的就绪任务，阻塞会进一步恶化。优先级继承技术可用来解决优先级反转问题。
%A
%A
%A 　
%A
%A Priority inversion arises when a higher-priority task is forced to wait an indefinite period of time for a lower-priority task to complete.
%A
%A 优先级继承(Priority Inheritance)
%A
%A 优先级继承可用来解决优先级反转问题。当优先级反转发生时，优先级较低的任务被暂时地提高它的优先级，使得该任务能尽快执行，释放出优先级较高的任务所需要的资源。
%A
%A Priority Inheritance
%A
%A 　
%A
%A The mutual-exclusion semaphore has the option SEM_INVERSION_SAFE, which enables a priority-inheritance algorithm. The priority-inheritance protocol assures that a task that owns a resource executes at the priority of the highest-priority task blocked on that resource. Once the task priority has been elevated, it remains at the higher level until all mutual-exclusion semaphores that the task owns are released; then the task returns to its normal, or standard, priority. Hence, the "inheriting" task is protected from preemption by any intermediate-priority tasks. This option must be used in conjunction with a priority queue (SEM_Q_PRIORITY).
%A
%A
%A 计数信号量（Counting Semaphores）
%A
%A 计数信号量是任务同步和互斥的另一种实现方式.计数信号量除了保留信号量被释放的次数以外和二进制信号量是一样的。每次信号量被释放（gaven)一次，计数增加；每次信号量被占用（taken)一次，计数减少;当计数减少为0时，要求得到信号量的任务被阻塞（blocked)。二进制信号量是如果一个信号量被释放，有一个任务阻塞等待，则这个任务就被unblock.而计数信号量如果一个信号量被释放，没有任务阻塞等待，则计数增加。这说明一个被释放两次的计数信号量可以被占用(taken)两次,没有阻塞。
%A
%A Counting semaphores are useful for guarding multiple copies of resources. For example, the use of five tape drives might be coordinated using a counting semaphore with an initial count of 5, or a ring buffer with 256 entries might be implemented using a counting semaphore with an initial count of 256. The initial count is specified as an argument to the semCCreate( ) routine.
%A
%A Counting Semaphore Example
%A
%A --------------------------------------------------------------------------------
%A
%A Semaphore Call
%A Count after Call
%A Resulting Behavior
%A
%A
%A --------------------------------------------------------------------------------
%A
%A semCCreate( )  
%A 3
%A Semaphore initialized with initial count of 3.  
%A
%A semTake( )  
%A 2
%A Semaphore taken.  
%A
%A semTake( )  
%A 1
%A Semaphore taken.  
%A
%A semTake( )  
%A 0
%A Semaphore taken.  
%A
%A semTake( )  
%A 0
%A Task blocks waiting for semaphore to be available.  
%A
%A semGive( )  
%A 0
%A Task waiting is given semaphore.  
%A
%A semGive( )  
%A 1
%A No task waiting for semaphore; count incremented.  
%A
%A
%A --------------------------------------------------------------------------------
%A
%A
%A
%A
%A 　
%A
%A 　
%A
%A             消息队列(Message queues)
%A
%A 现实的实时应用由一系列互相独立又协同工作的任务组成。信号量为任务间同步和联锁提供了高效机制。在VxWorks中，用于但一CPU任务之间通信主要（primary）的机制是消息队列。
%A
%A Full Duplex Communication Using Message Queues
%A
%A 　
%A
%A 消息队列允许一定数量不同长度的消息进行排列。任何任务或中断服务程序(ISR)能够发送消息给消息队列。任何任务可以从消息队列接受消息。多任务可以从同意消息队列发送和接受消息。两个任务之间的全双工（Full-duplex）通信需要针对不同方向的两个消息队列。
%A
%A 消息队列函数介绍    
%A
%A msgQCreate( )  创建斌初始化一个消息队列
%A
%A msgQDelete( ) 终止并释放一个消息队列
%A
%A msgQSend( )  发送一个消息到消息队列
%A
%A msgQReceive( ) 从消息队列接受一个消息
%A
%A 消息队列是由函数msgQCreate (MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY)创建。它的参数MAX_MSGS指定了消息队列中可允许最多可以排列的消息数和每个消息允许的最大的字节数MAX_MSG_LEN。
%A
%A 一个任务或中断服务程序(ISR)用函数msgQSend( )发送一个消息到消息队列。如果没有任务等待消息队列的消息，这个消息被添加消息缓存的队列里。如果某些任务已经在等待消息队列中的消息，消息立刻被传递给第一个等待的消息的任务。
%A
%A 一个任务用函数msgQReceive( )从消息队列得到一个消息。如果消息队列缓存中有消息存在，第一个消息立刻出列并回到调用处(caller).如果没有消息存在，则任务（calling task）停止（blocks)并被添加到等待消息的任务队列中。这个等待的任务队列按照优先级或先进先出（FIFO)规则排列，这个规则有消息队列创建时所指定。
%A
%A 等待时间限制（time out)
%A
%A msgQSend( ) 和 msgQReceive( )都有时间限制参数。当发送一个消息，如果消息队列缓存这时没有空间，这个参数指定允许等待的时间（ticks数），直到队列缓存有空间来接收消息。当接收消息时，如果消息队列没有消息，这个参数指定允许等待的时间（ticks数），直到消息队列有消息。
%A
%A 　
%A
%A /* In this example, task t1 creates the message queue and sends a message
%A * to task t2. Task t2 receives the message from the queue and simply
%A * displays the message.
%A */
%A
%A /* includes */
%A #include "vxWorks.h"
%A #include "msgQLib.h"
%A
%A /* defines */
%A #define MAX_MSGS (10)
%A #define MAX_MSG_LEN (100)
%A
%A MSG_Q_ID myMsgQId;
%A
%A task2 (void)
%A     {
%A     char msgBuf[MAX_MSG_LEN];
%A
%A     /* get message from queue; if necessary wait until msg is available */
%A     if (msgQReceive(myMsgQId, msgBuf, MAX_MSG_LEN, WAIT_FOREVER) == ERROR)
%A         return (ERROR);
%A
%A     /* display message */
%A     printf ("Message from task 1:\n%s\n", msgBuf);
%A     }
%A
%A #define MESSAGE "Greetings from Task 1"
%A task1 (void)
%A     {
%A     /* create message queue */
%A     if ((myMsgQId = msgQCreate (MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY))  
%A         == NULL)
%A         return (ERROR);
%A
%A     /* send a normal priority message, blocking if queue is full */
%A     if (msgQSend (myMsgQId, MESSAGE, sizeof (MESSAGE), WAIT_FOREVER,
%A                   MSG_PRI_NORMAL) == ERROR)
%A         return (ERROR);
%A     }
%A 　
%A
%A 管道（Pipes）
%A
%A 管道对消息队列提供了一个可供选择的接口，VxWorks的I/O系统。管道是虚拟的I/O设备，由驱动pipeDrv管理。函数pipeDevCreate()创建一个管道设备，这个调用指定管道的名字，能被排列的最多的消息数，和每个消息允许的长度。
%A
%A status = pipeDevCreate ("/pipe/name", max_msgs, max_length);
%A
%A 被创建的管道是一个通常命名（named)的I/O设备,任务能用标准的I/O函数打开，读，写管道，并能调用ioctl例程。当任务试图从一个空的管道中读取数据，或向一个满的管道中写入数据时，任务被阻塞。和消息队列一样，ISR可以向管道写入，但不能从管道读取。
%A
%A 做为I/O设备，管道提供了消息队列所没有的重要特性，调用select()
%A
%A 　
%A
%A