Timer 定时任务列表

我正在寻找有关16位设备上嵌入式应用程序的帮助。 我需要通过函数指针运行几个简单的“任务/函数”。这些任务以预定的时间间隔运行

typedef struct
{
  int  timeToRun;
  void (*fcn)(void);

} task_t;

task_t tasks[] =
{
  { 13_MSEC,  fcn1 },
  { 50_MSEC,  fcn2 },
  { 0, NULL }
};

volatile unsigned int time;   

main()
{

  for (ptr = tasks; ptr->timeToRun !=0; ptr++)
  {
    if (!(time % ptr->timeToRun))
       (ptr->fcn)();
  }
}

我有可能以1ms运行计时器中断

interrupt void TimerTick(void)
{
 time++;
}

---

知道如何计算经过的时间吗？如果时间溢出，如何确保%（模）以定义的速率工作。无论如何，如何避免时间溢出并通过%（模）进行正确计时？

以下是我的一个非常类似的应用程序中的一些代码，适用于小型MCU应用程序，并且符合MISRA-C。它基于调用应用程序中静态分配的“软件计时器”。项目中的多个模块可以使用同一个计时器模块，因为它在内部使用链接列表来跟踪所有计时器

从1ms中断调用tim_traverse_timers（）。如果您有非常高的精度要求，您可能必须在调用函数之前清除中断源，以便函数本身的“代码抖动”开销不会影响计时器

如果需要更长的延迟65535ms，只需将计数器和间隔更改为uint32

    typedef struct timer
    {
      struct timer* next;                            /* Next timer in the linked list   */

      uint16 counter;                                /* 16-bit timer counter            */
      uint16 interval;                               /* The interval between triggers   */
      BOOL   is_enabled;                             /* Timer enabled/disabled          */

      void (*callback_func)(void);                   /* Callback timer function         */

    } Timer;



    static Timer* timer_list;


    void tim_init (void)
    {
      timer_list = NULL;
    }

    void tim_add (Timer*   timer,
                  void (*  callback_func)(void),
                  uint16   interval_ms,
                  BOOL     enabled)
    {
      tim_enable_interrupt (FALSE);                  /* hardware function disabling timer interrupt */

      timer->callback_func  = callback_func;
      timer->counter        = 0U;
      timer->interval       = interval_ms;
      timer->is_enabled     = enabled;

      timer->next           = timer_list;
      timer_list            = timer;

      tim_enable_interrupt (TRUE);
    }



    void tim_enable (Timer* timer, BOOL enable)
    {
      if(enable)
      {
        timer->counter    = 0U;                      /* Reset counter each time function is called */
      }

      timer->is_enabled = enable;
    }

    void tim_traverse_timers  (void)
    {
      Timer* timer;

      for(timer=timer_list; timer!=NULL; timer=timer->next)
      {
        if(timer->is_enabled == TRUE)
        {
          timer->counter++;

          if(timer->counter == timer->interval)
          {
            timer->counter = 0U;
            timer->callback_func();
          }

        }
      }
    }

---

---

我会这样做：

typedef struct
{
  unsigned int nextRunTime
  int  period;
  unsigned int  rollover;
  void (*fcn)(void);
} task_t;


main()
{
  //setup goes here
  /*...*/
  //loop
  while (1)
  {
     for (ptr = tasks; ptr->period!=0; ptr++)
     {
       if ((time > ptr->nextRunTime) && (time <= ptr->rollover) )
       {
           ptr->nextRunTime+=ptr->period;
           ptr->rollover = (ptr->nextRunTime < ptr->period)? 2*ptr->period : 0xFFFF;
           (ptr->fcn)();
       }
       ptr->nextRunTime = timeToRun;
     }
  }
}

typedef结构
{
无符号整数下个时点
整数周期；
无符号整数滚动；
无效（*fcn）（无效）；
}任务;；
main（）
{
//设置在这里
/*...*/
//环路
而(1)
{
对于（ptr=tasks；ptr->period！=0；ptr++）
{
如果（（时间>ptr->nextRunTime）和（&（时间滚动））
{
ptr->nextRunTime+=ptr->period；
ptr->rollover=（ptr->nextRunTimeperiod）？2*ptr->period:0xFFFF；
（ptr->fcn）（）；
}
ptr->nextRunTime=timeToRun；
}
}
}

只要您能够保证a）任何时间都不超过滚动时间（0x8000毫秒）的一半，并且b）您可以在最短的时间内执行所有功能，这应该是可行的

typedef struct
{
  unsigned int nextRunTime
  int  period;
  unsigned int  rollover;
  void (*fcn)(void);
} task_t;


main()
{
  //setup goes here
  /*...*/
  //loop
  while (1)
  {
     for (ptr = tasks; ptr->period!=0; ptr++)
     {
       if ((time > ptr->nextRunTime) && (time <= ptr->rollover) )
       {
           ptr->nextRunTime+=ptr->period;
           ptr->rollover = (ptr->nextRunTime < ptr->period)? 2*ptr->period : 0xFFFF;
           (ptr->fcn)();
       }
       ptr->nextRunTime = timeToRun;
     }
  }
}