src/timer.c

   1 /*
   2 This file is part of CanFestival, a library implementing CanOpen Stack.
   3
   4 Copyright (C): Edouard TISSERANT and Francis DUPIN
   5
   6 See COPYING file for copyrights details.
   7
   8 This library is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU Lesser General Public
  10 License as published by the Free Software Foundation; either
  11 version 2.1 of the License, or (at your option) any later version.
  12
  13 This library is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 Lesser General Public License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public
  19 License along with this library; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22 /*!
  23 ** @file   timer.c
  24 ** @author Edouard TISSERANT and Francis DUPIN
  25 ** @date   Tue Jun  5 09:32:32 2007
  26 **
  27 ** @brief
  28 **
  29 **
  30 */
  31
  32 /* #define DEBUG_WAR_CONSOLE_ON */
  33 /* #define DEBUG_ERR_CONSOLE_ON */
  34
  35 #include <applicfg.h>
  36 #include "timer.h"
  37
  38 /*  ---------  The timer table --------- */
  39 s_timer_entry timers[MAX_NB_TIMER] = {{TIMER_FREE, NULL, NULL, 0, 0, 0},};
  40
  41 TIMEVAL total_sleep_time = TIMEVAL_MAX;
  42 TIMER_HANDLE last_timer_raw = -1;
  43
  44 #define min_val(a,b) ((a<b)?a:b)
  45
  46 /*!
  47 ** -------  Use this to declare a new alarm ------
  48 **
  49 ** @param d
  50 ** @param id
  51 ** @param callback
  52 ** @param value
  53 ** @param period
  54 **
  55 ** @return
  56 **/
  57 TIMER_HANDLE SetAlarm(CO_Data* d, UNS32 id, TimerCallback_t callback, TIMEVAL value, TIMEVAL period)
  58 {
  59         /*printf("SetAlarm(UNS32 id=%d, TimerCallback_t callback=%x, TIMEVAL value=%d, TIMEVAL period=%d)\n", id, callback, value, period); */
  60         TIMER_HANDLE i;
  61         TIMER_HANDLE row_number = TIMER_NONE;
  62         s_timer_entry *row;
  63
  64         /* in order to decide new timer setting we have to run over all timer rows */
  65         for(i=0, row=timers; i <= last_timer_raw + 1 && i < MAX_NB_TIMER; i++, row++)
  66         {
  67                 if (callback &&         /* if something to store */
  68                    row->state == TIMER_FREE) /* and empty row */
  69                 {       /* just store */
  70                         row->callback = callback;
  71                         row->d = d;
  72                         row->id = id;
  73                         row->val = value;
  74                         row->interval = period;
  75                         row->state = TIMER_ARMED;
  76                         row_number = i;
  77                         break;
  78                 }
  79         }
  80
  81         if (row_number != TIMER_NONE) /* if successfull **/
  82         {
  83                 TIMEVAL real_timer_value;
  84                 TIMEVAL elapsed_time;
  85
  86                 if (row_number == last_timer_raw + 1) last_timer_raw++;
  87
  88                 /* set next wakeup alarm if new entry is sooner than others, or if it is alone */
  89                 real_timer_value = min_val(value, TIMEVAL_MAX);
  90                 elapsed_time = getElapsedTime();
  91
  92                 /*printf("elapsed_time=%d real_timer_value=%d total_sleep_time=%d\n", elapsed_time, real_timer_value, total_sleep_time); */
  93                 if (total_sleep_time > elapsed_time && total_sleep_time - elapsed_time > real_timer_value)
  94                 {
  95                         total_sleep_time = elapsed_time + real_timer_value;
  96                         setTimer(real_timer_value);
  97                 }
  98                 /*printf("SetAlarm() return %d\n", row_number); */
  99                 return row_number;
 100         }
 101         return TIMER_NONE;
 102 }
 103
 104 /*!
 105 **  -----  Use this to remove an alarm ----
 106 **
 107 ** @param handle
 108 **
 109 ** @return
 110 **/
 111 TIMER_HANDLE DelAlarm(TIMER_HANDLE handle)
 112 {
 113         /* Quick and dirty. system timer will continue to be trigged, but no action will be preformed. */
 114         MSG_WAR(0x3320, "DelAlarm. handle = ", handle);
 115         if(handle != TIMER_NONE)
 116         {
 117                 if(handle == last_timer_raw)
 118                         last_timer_raw--;
 119                 timers[handle].state = TIMER_FREE;
 120         }
 121         return TIMER_NONE;
 122 }
 123
 124 /*!
 125 ** ------  TimeDispatch is called on each timer expiration ----
 126 **
 127 **/
 128 void TimeDispatch(void)
 129 {
 130         TIMER_HANDLE i;
 131         TIMEVAL next_wakeup = TIMEVAL_MAX; /* used to compute when should normaly occur next wakeup */
 132         /* First run : change timer state depending on time */
 133         /* Get time since timer signal */
 134         TIMEVAL overrun = getElapsedTime();
 135
 136         TIMEVAL real_total_sleep_time = total_sleep_time + overrun;
 137         /*printf("total_sleep_time %d + overrun %d\n", total_sleep_time , overrun); */
 138
 139         s_timer_entry *row;
 140
 141         for(i=0, row = timers; i <= last_timer_raw; i++, row++)
 142         {
 143                 if (row->state & TIMER_ARMED) /* if row is active */
 144                 {
 145                         if (row->val <= real_total_sleep_time) /* to be trigged */
 146                         {
 147                                 /*printf("row->val(%d) <= (%d)real_total_sleep_time\n", row->val, real_total_sleep_time); */
 148                                 if (!row->interval) /* if simply outdated */
 149                                 {
 150                                         row->state = TIMER_TRIG; /* ask for trig */
 151                                 }
 152                                 else /* or period have expired */
 153                                 {
 154                                         /* set val as interval, with overrun correction */
 155                                         row->val = row->interval - (overrun % row->interval);
 156                                         row->state = TIMER_TRIG_PERIOD; /* ask for trig, periodic */
 157                                         /* Check if this new timer value is the soonest */
 158                                         if(row->val < next_wakeup)
 159                                                 next_wakeup = row->val;
 160                                 }
 161                         }
 162                         else
 163                         {
 164                                 /* Each armed timer value in decremented. */
 165                                 row->val -= real_total_sleep_time;
 166
 167                                 /* Check if this new timer value is the soonest */
 168                                 if(row->val < next_wakeup)
 169                                         next_wakeup = row->val;
 170                         }
 171                 }
 172         }
 173
 174         /* Remember how much time we should sleep. */
 175         total_sleep_time = next_wakeup;
 176
 177         /* Set timer to soonest occurence */
 178         setTimer(next_wakeup);
 179
 180         /* Then trig them or not. */
 181         for(i=0, row = timers; i<=last_timer_raw; i++, row++)
 182         {
 183                 if (row->state & TIMER_TRIG)
 184                 {
 185                         row->state &= ~TIMER_TRIG; /* reset trig state (will be free if not periodic) */
 186                         if(row->callback)
 187                                 (*row->callback)(row->d, row->id); /* trig ! */
 188                 }
 189         }
 190 }