RT-Thread一般讨论

OS 相同优先级错时调度的方法？

发布于 2013-09-12 13:26:36 浏览：3349 订阅该版

6 个回答

forsakening 2013-09-23

这家伙很懒，什么也没写！

fengzi 2013-09-23

这家伙很懒，什么也没写！

grissiom 2013-09-23

这家伙很懒，什么也没写！

taurus3g 2013-10-18

这家伙很懒，什么也没写！

谢谢各位的响应：
我提出这个想法是，利用最少的资源来完成这个无优先级抢占的应用。
这里根据最新的RT-THREAD 的定时模块章节的介绍：

软定时器最主要的目的是在系统经过设定的时间后，系统能够自动执行用户设定的动
作。当定时器设定的时间到了，即超时时，执行的动作函数称之为定时器的超时函数。与线
程不同的是，超时函数的执行上下文环境并未用显式给出。
在RT-Thread实时操作系统中，定时器超时函数存在着两种情况：
? 超时函数在（系统时钟）中断上下文环境中执行；
? 超时函数在线程的上下文环境中执行。
如果超时函数是在中断上下文环境中执行，显然对于超时函数的要求与中断服务例
程的要求相同：执行时间应该尽量短，执行时不应导致当前上下文挂起、等待。例如在
中断上下文中执行的超时函数它不应该试图去申请动态内存、释放动态内存等（其中一
个就包括rt_timer_delete函数调用）。 而超时函数在线程上下文中执行，则不会有这个限
制，但是通常也要求超时函数执行时间应该足够短，而不应该影响到其他定时器或本次
定时器的下一次周期性超时。 这两种情况在RT-Thread定时器控制块中分别使用参数：
RT_TIMER_FLAG_HARD_TIMER和RT_TIMER_FLAG_SOFT_TIMER指定。HARD_TIMER代表的是
定时器超时函数执行上下文是在中断上下文环境中执行；SOFT_TIMER代表的是定时器函
数执行的上下文是timer线程（在rtconfig.h头文件中应该定义宏RT_USING_TIMER_SOFT使
timer线程能被使用）。
这里是否简单的修改如下结构体定义，增加一个偏移量的属性。

struct rt_timer
{
struct rt_object_parent;
rt_list_t list; /* 用于链接定时器的链表 */
void (*timeout_func)(void* parameter); /* 定时器超时调用的函数 */
void *parameter; /* 超时函数用到的入口参数 */  
rt_tick_t init_tick; /* 定时器初始超时节拍数 */
**rt_tick_t rt_offset_tick; /* timer offset */ **
rt_tick_t timeout_tick; /* 定时器实际超时时的节拍数 */
};
typedef struct rt_timer* rt_timer_t

在系统创建定时器时，根据偏移量，自动在初始化加上这个偏移量，这样下次触发的时间就可以起到 错开执行 的目的，虽然都是10MS 的Tick。 但是各自的执行点不一样。

这样达到同样的目的，不用使用其它的线程，事件。

taurus3g 2013-10-19

这家伙很懒，什么也没写！

根据上面的思路， 今天对Timer.c 模块进行的少量的变动。
修改如下：

```
  
static void _rt_timer_init(rt_timer_t timer,
                           void (*timeoutfunc)(void *parameter),
                           void      *parameter,
                           rt_tick_t  time,
                         rt_tick_t  offset,
                           rt_uint8_t flag)
{
    /* set flag */
    timer->parent.flag  = flag;

/* set deactivated */
    timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

timer->timeout_func = timeoutfunc;
    timer->parameter    = parameter;

timer->timeout_tick = 0;
    timer->init_tick    = time;
    **timer->offset_tick  = offset;**
    /* initialize timer list */
    rt_list_init(&(timer->list));
}
```

对 rt_err_t rt_timer_start(rt_timer_t timer) 函数进行少量的修改：

```

if(timer->parent.flag & RT_TIMER_FLAG_OFFSET){
       timer->timeout_tick = rt_tick_get() + timer->init_tick;
	  }
    else{
	    timer->timeout_tick = rt_tick_get() + timer->init_tick + timer->offset_tick; 
		timer->parent.flag |= RT_TIMER_FLAG_OFFSET;
	  }	
```

在对函数申明的形参进行增加一个offset.

这样就基本完成了。

进行少量的代码测试:

```

void App_10msA(void *parameter)
{
	 
	  rt_kprintf(" 10msA Actived
 ");
	
	
}

void App_10msB(void *parameter)
{
	
	  rt_kprintf(" 10msB Actived
 ");
}

void App_20ms(void *parameter)
{
	
	  rt_kprintf(" 20ms Actived
 ");
}

void App_50ms(void *parameter)
{
	
	 rt_kprintf("  50ms Actived
 ");
}

void App_100ms(void *parameter)
{
	 rt_kprintf("  100ms Actived
 ");
}

int rt_application_init()
{
   
	    
	  rt_timer_init(&timer_10msA, "timer1", /* 定时器名字是 timer1 */
                  App_10msA, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
                  1,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
	
    rt_timer_init(&timer_10msB, "timer2", /* 定时器名字是 timer1 */
                  App_10msB, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
                  0,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
	  
		 rt_timer_init(&timer_20ms, "timer2", /* 定时器名字是 timer1 */
                  App_20ms, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  20, /* 定时长度，以OS Tick为单位，即20个OS Tick */
                  0,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */

rt_timer_init(&timer_50ms, "timer3", /* 定时器名字是 timer1 */
                  App_50ms, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  50, /* 定时长度，以OS Tick为单位，即50个OS Tick */
                  2,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
									
		 rt_timer_init(&timer_100ms, "timer4", /* 定时器名字是 timer1 */
                  App_100ms, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  100, /* 定时长度，以OS Tick为单位，即100个OS Tick */
                  7,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */		
									
	  rt_timer_start(&timer_10msA);
	  rt_timer_start(&timer_10msB);
	  rt_timer_start(&timer_20ms);
		rt_timer_start(&timer_50ms);
		rt_timer_start(&timer_100ms);		
		
    return 0;
}  
```

测试结构如下：

10msB Actived
  10msA Actived
  10msB Actived
  10msA Actived
   50ms Actived
  20ms Actived
  10msB Actived
  10msA Actived
  10msB Actived
  10msA Actived
  20ms Actived
  10msB Actived
  10msA Actived
  10msB Actived
  10msA Actived
  20ms Actived
  10msB Actived
  10msA Actived
   50ms Actived
   100ms Actived

下面10msTaskA在前， 10msTaskB 偏移1Tick. 测试结果：

```
	  rt_timer_init(&timer_10msA, "timer1", /* 定时器名字是 timer1 */
                  App_10msA, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
                  0,
	                RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
	
    rt_timer_init(&timer_10msB, "timer2", /* 定时器名字是 timer1 */
                  App_10msB, /* 超时时回调的处理函数 */
                  RT_NULL, /* 超时函数的入口参数 */
                  10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
                  1,
	       RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
```

测试结果: 
  100ms Actived
  10msA Actived
  10msB Actived
  20ms Actived
  10msA Actived
  10msB Actived
  10msA Actived
  10msB Actived
  20ms Actived
  10msA Actived
  10msB Actived
  10msA Actived
  10msB Actived
   50ms Actived
  20ms Actived
  10msA Actived
  10msB Actived
  10msA Actived
  10msB Actived
  20ms Actived
  10msA Actived
  10msB Actived
  10msA Actived
  10msB Actived
  20ms Actived
  10msA Actived
  10msB Actived
   50ms Actived
   100ms Actived

这样容易的实现的周期任务的错时。