xenomai 应用开发 2：单触发模式与周期性模式运行多任务--WT

一、多任务模式

当下的实时系统基于多任务和任务间通信的互补概念。多任务环境允许将实时应用程序构建为一组独立的任务，每个任务都有单独的执行线程和自己的一组系统资源。任务间通信设施允许这些任务同步和协调它们的活动。Xenomai多任务调度程序使用中断驱动的、基于优先级的抢占式任务调度。它具有快速的上下文切换和低中断延迟。
多任务处理造成了许多并发执行的任务，而实际上，内核根据调度算法交错执行这些任务。每个任务都有自己的上下文，它是任务每次计划由内核运行时看到的CPU环境和系统资源。在上下文切换时，任务的上下文保存在任务控制块(TCB)中。任务的上下文包括:

一个执行的线程，即任务的程序计数器
CPU寄存器和浮点寄存器(如果需要)
一组动态变量和函数调用的返回地址
I/O分配标准输入，输出，错误
延迟计时器
一个时间片计时器
内核控制结构
信号处理程序
调试和性能监视值

在Xenomai中，时间是由系统时钟给出的。
系统时钟可以通过函数rt_timer_read()读取，例如:
RTIME now; now = rt_timer_read();

二、单触发（one-shot）模式创建运行多任务

单触发模式如上篇文章xenomai 应用开发 1模式
1、单触发模式启用5个任务，并且为五个任务分别命名：
#define NTASKS 5
RT_TASK task[NTASKS];
可按这种方式进行创建，并给予相同的优先级。 程序与结果如下所示：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include <alchemy/task.h>

#define NTASKS 5
RT_TASK task[NTASKS];
//RT_TASK hello_task;


// function to be executed by task
void demo(void *arg) {
    RT_TASK_INFO curtaskinfo;
    rt_task_inquire(NULL,&curtaskinfo);
    rt_printf("Task name: %s \n", curtaskinfo.name);
}


int main(int argc, char* argv[])
{
   int i;
     char  str[20] ;
     char  name[]={'A','B','C','D','D'};//为5个任务分别命名
     
      
     for(i=0; i < NTASKS; i++) {
       printf("start task  : %d\n",i);
       sprintf(str,"task%c",name[i]);
       rt_task_create(&task[i], str, 0, 50, 0);
       rt_task_start(&task[i], &demo, 0);} 
}

如图示：第一个实时任务序号为0，名字叫 taskA,第二个为taskB,以此类推。
2、第一个程序中有个参数arg，它是指向void类型的指针。在调用rt_task_start()期间，可以将整数参数作为对任务的引用传递（arg是给任务函数的void类型指针参数）。例如，对于一个变量int index，使用
rt_task_start(&taskd…, &demo, &index)
修改第一个程序，使五个任务中的每一个都有唯一的参数。让任务通过强制类型转换和取消引用该编号来打印该编号，例如，
int num = * (int *)arg;
同样，每个任务具有相同的优先级。执行程序并描述其输出。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include <alchemy/task.h>

#define NTASKS 5
RT_TASK task[NTASKS];
//RT_TASK hello_task;


// function to be executed by task
void demo(void *arg) {
    int num = * (int *)arg;
    rt_printf("The number is %d \n", num);
    RT_TASK_INFO curtaskinfo;
    rt_task_inquire(NULL,&curtaskinfo);
    rt_printf("Task name: %s \n", curtaskinfo.name);
}


int main(int argc, char* argv[])
{
   int i;
     char  str[20] ;
     char  name[]={'A','B','C','D','E'};
     
      
     for(i=0; i < NTASKS; i++) {
       printf("start task  : %c\n",name[i]);
       sprintf(str,"task%d",i);
       rt_task_create(&task[i], str, 0, 50, 0);
       rt_task_start(&task[i], &demo, &i);}
}

3、以one-shot模式创建不同优先级的任务，观察终端打印结果。
修改1例子中的程序，赋予五个任务以不同的优先级：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include <alchemy/task.h>

#define NTASKS 5
RT_TASK task[NTASKS];
//RT_TASK hello_task;


// function to be executed by task
void demo(void *arg) {
 
    RT_TASK_INFO curtaskinfo;
    rt_task_inquire(NULL,&curtaskinfo);
    rt_printf("Task name: %s \n", curtaskinfo.name);
    rt_printf("Task priority is %d \n" ,curtaskinfo.prio);
}


int main(int argc, char* argv[])
{
   int i;
     char  str[20] ;
     char  name[]={'A','B','C','D','D'};
     int   priority[]={50,51,52,53,54};
      
     for(i=0; i < NTASKS; i++) 
	{
       printf("start task  : %c\n",name[i]);
       sprintf(str,"task%d",i);
       rt_task_create(&task[i], str, 0, priority[i], 0);
       rt_task_start(&task[i], &demo, 0);
	}
}

设置了优先级过后，第一个任务获得最低优先级，最后一个任务获得最大的优先级，但是打印每个任务的顺序并没变，因为根据for循环，几个任务并不是同时发生的，当第一个任务创建并且执行完自己的function时，第二个任务才会被创建，受到任务调度的影响。

三、以周期性模式运行多任务

实现多任务运行，并且占用较少的CPU资源，xenomai 提供了一些常用的API以供实时任务使用：

1、设定实时任务周期

int rt_task_set_periodic(RT_TASK *task, RTIME start_time,RTIME period);

通过在处理器时间线中编程任务的第一个发布点及其周期，使任务具有周期性。然后，任务应该调rt_task_wait_period（）来休眠，直到到达处理器时间线中的下一个定期释放点。
*task 任务描述符，如果任务为空，则将当前任务设为定期任务。
start_time 第一个释放点的初始（绝对）日期，以时钟节拍表示。如果start_time等于TM_NOW，则使用当前系统日期。
period 任务的周期。如果已启用一个周期计时器任务，可以通过传递 TM_INFINITE给period 以停止周期性任务。
2、当周期性任务完成其功能时，它释放处理器并开始使用以下命令等待下一个周期的到来：
void rt_task_wait_period(NULL);
3、程序及结果：周期性运行3个实时任务，分别以一秒，两秒，三秒为周期进行运行任务。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <alchemy/task.h>
#include <sys/mman.h>
#include <alchemy/timer.h>
#include <math.h>

#define NTASKS 3
RT_TASK task[NTASKS];
// function to be executed by task

void task_function(void *arg)
{   RTIME now; 
    int i=1;
    
   int num = * (int *)arg;
   float period[]={1e9,2e9,3e9};
   //rt_printf("The arg is %d \n", num);
   
    rt_task_set_periodic(NULL, TM_INFINITE, period[num]);
   
   //开始任务循环
  while (1) {
    /*
      Do your thing here
     */
    
    RT_TASK_INFO curtaskinfo;
    rt_task_inquire(NULL,&curtaskinfo);
    rt_printf(" 第 %d 次循环 %s 任务 -- 循环时间： %.5f s\n",i,curtaskinfo.name,(rt_timer_read()-now)/1000000000.0);
    i=i+1;
   now = rt_timer_read();
   rt_task_wait_period(NULL);
   
  }
  return;
}

int main(int argc, char* argv[])
{
     int i;
     char  str[20] ;
     char  name[]={'A','B','C','D','E'};
     mlockall(MCL_CURRENT|MCL_FUTURE);//锁定内存以避免此程序的内存交换
      
     for(i=0; i < NTASKS; i++) 
      {
       //printf("start task  : %c\n",name[i]);
       sprintf(str,"task%d",i);
       rt_task_create(&task[i], str, 0, 50, 0);
       rt_task_start(&task[i], &task_function, &i);
       }
       
       pause();
}

 第 1 次循环 task0 任务 -- 循环时间： 24339.75194 s
 第 1 次循环 task1 任务 -- 循环时间： 24313.98238 s
 第 1 次循环 task2 任务 -- 循环时间： 24288.21280 s
 第 2 次循环 task0 任务 -- 循环时间： 0.99999 s
 第 3 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 2 次循环 task1 任务 -- 循环时间： 1.99999 s
 第 4 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 2 次循环 task2 任务 -- 循环时间： 3.00000 s
 第 5 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 3 次循环 task1 任务 -- 循环时间： 2.00000 s
 第 6 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 7 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 4 次循环 task1 任务 -- 循环时间： 1.99999 s
 第 3 次循环 task2 任务 -- 循环时间： 2.99999 s
 第 8 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 9 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 5 次循环 task1 任务 -- 循环时间： 2.00000 s
 第 10 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 4 次循环 task2 任务 -- 循环时间： 3.00000 s
 第 11 次循环 task0 任务 -- 循环时间： 0.99998 s
 第 6 次循环 task1 任务 -- 循环时间： 1.99999 s
 第 12 次循环 task0 任务 -- 循环时间： 0.99998 s

前面3条打印信息为任务在系统中的起始时间.后面的均为该任务运行的头一次与后一次在系统时钟中的差值,我们从结果可以看出，task0以1秒为周期，task1以2为周期，task2以3秒为周期。但周期有少量的出入，是系统延时所导致的。