[Tinyos-2-commits] CVS: tinyos-2.x/tos/chips/atm128/timer Atm128AlarmC.nc, 1.3, 1.4 HplAtm128Timer0AsyncC.nc, 1.2, 1.3

[David Gay]

Update of /cvsroot/tinyos/tinyos-2.x/tos/chips/atm128/timer
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv21602

Modified Files:
	Atm128AlarmC.nc HplAtm128Timer0AsyncC.nc 
Log Message:
minor alarm tweaks:
- enable interrupts in the HAL (to preserve correct stop/isRunning semantics)
- slight tweak to the mindt stuff


Index: Atm128AlarmC.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-2.x/tos/chips/atm128/timer/Atm128AlarmC.nc,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Atm128AlarmC.nc	7 Aug 2006 22:57:37 -0000	1.3
--- Atm128AlarmC.nc	10 Aug 2006 00:00:59 -0000	1.4
***************
*** 73,124 ****
  
    async command void Alarm.startAt( timer_size t0, timer_size dt ) {
!     timer_size now;
!     timer_size expires, guardedExpires;
! 
!     now = call HplAtm128Timer.get();
!     dbg("Atm128AlarmC", "   starting timer at %llu with dt %llu\n", (uint64_t)t0, (uint64_t) dt);
!     /* We require dt >= mindt to avoid setting an interrupt which is in
!        the past by the time we actually set it. mindt should always be
!        at least 2, because you cannot set an interrupt one cycle in the
!        future. It should be more than 2 if the timer's clock rate is
!        very high (e.g., equal to the processor clock). */
!     if (dt < mindt)
!       dt = mindt;
! 
!     expires = t0 + dt;
  
!     guardedExpires = expires - mindt;
  
!     /* t0 is assumed to be in the past. If it's numerically greater than
!        now, that just represents a time one wrap-around ago. This requires
!        handling the t0 <= now and t0 > now cases separately. 
  
!        Note also that casting compared quantities to timer_size produces
!        predictable comparisons (the C integer promotion rules would make it
!        hard to write correct code for the possible timer_size size's) */
!     /* Note: all HplAtm128Compare.set values have one subtracted, because
!        the comparisons are continuous, but the actual interrupt is signalled
!        at the next timer clock cycle. */
!     if (t0 <= now)
!       {
! 	/* if it's in the past or the near future, fire now (i.e., test
! 	   guardedExpires <= now in wrap-around arithmetic). */
! 	if (guardedExpires >= t0 && // if it wraps, it's > now
! 	    guardedExpires <= now) 
! 	  call HplAtm128Compare.set(call HplAtm128Timer.get() + mindt - 1);
! 	else
! 	  call HplAtm128Compare.set(expires - 1);
!       }
!     else
!       {
! 	/* again, guardedExpires <= now in wrap-around arithmetic */
! 	if (guardedExpires >= t0 || // didn't wrap so < now
! 	    guardedExpires <= now)
! 	  call HplAtm128Compare.set(call HplAtm128Timer.get() + mindt - 1);
  	else
! 	  call HplAtm128Compare.set(expires - 1);
        }
-     call HplAtm128Compare.reset();
-     call HplAtm128Compare.start();
    }
  
--- 73,121 ----
  
    async command void Alarm.startAt( timer_size t0, timer_size dt ) {
!     /* We don't set an interrupt before "now" + mindt to avoid setting an
!        interrupt which is in the past by the time we actually set
!        it. mindt should always be at least 2, because you cannot set an
!        interrupt one cycle in the future. mindt should also be large enough
!        to cover the execution time of this function. */
!     atomic
!       {
! 	timer_size now, expires, minExpires, guardedExpires;
  
! 	dbg("Atm128AlarmC", "   starting timer at %llu with dt %llu\n", (uint64_t)t0, (uint64_t) dt);
  
! 	if (dt < mindt) /* guardedExpires should not be less than t0 */
! 	  dt = mindt;
! 	expires = t0 + dt;
! 	guardedExpires = expires - mindt;
! 	now = call HplAtm128Timer.get();
! 	minExpires = now + mindt;
  
! 	/* t0 is assumed to be in the past. If it's numerically greater
! 	   than now, that just represents a time one wrap-around
! 	   ago. This requires handling the t0 <= now and t0 > now cases
! 	   separately. */
! 	if (t0 <= now)
! 	  {
! 	    /* if it's in the past or the near future, fire now (i.e., test
! 	       guardedExpires <= now in wrap-around arithmetic). */
! 	    if (guardedExpires >= t0 && // if it wraps, it's > now
! 		guardedExpires <= now)
! 	      expires = minExpires;
! 	  }
  	else
! 	  {
! 	    /* again, guardedExpires <= now in wrap-around arithmetic */
! 	    if (guardedExpires >= t0 || // didn't wrap so < now
! 		guardedExpires <= now)
! 	      expires = minExpires;
! 	  }
! 
! 	/* Note: all HplAtm128Compare.set values have one subtracted,
! 	   because the comparisons are continuous, but the actual
! 	   interrupt is signalled at the next timer clock cycle. */
! 	call HplAtm128Compare.set(expires - 1);
! 	call HplAtm128Compare.reset();
! 	call HplAtm128Compare.start();
        }
    }
  
***************
*** 126,129 ****
--- 123,127 ----
      call HplAtm128Compare.stop();
      dbg("Atm128AlarmC", " Compare fired, signal alarm above.\n");
+     __nesc_enable_interrupt();
      signal Alarm.fired();
    }

Index: HplAtm128Timer0AsyncC.nc
===================================================================
RCS file: /cvsroot/tinyos/tinyos-2.x/tos/chips/atm128/timer/HplAtm128Timer0AsyncC.nc,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** HplAtm128Timer0AsyncC.nc	12 Jul 2006 17:01:30 -0000	1.2
--- HplAtm128Timer0AsyncC.nc	10 Aug 2006 00:00:59 -0000	1.3
***************
*** 47,52 ****
  implementation
  {
-   bool inOverflow;
- 
    command error_t Init.init() {
      SET_BIT(ASSR, AS0);  // set Timer/Counter0 to asynchronous mode
--- 47,50 ----
***************
*** 163,167 ****
    AVR_ATOMIC_HANDLER(SIG_OUTPUT_COMPARE0) {
      stabiliseTimer0();
-     __nesc_enable_interrupt();
      signal Compare.fired();
    }
--- 161,164 ----
***************
*** 170,176 ****
    AVR_ATOMIC_HANDLER(SIG_OVERFLOW0) {
      stabiliseTimer0();
-     inOverflow = TRUE;
      signal Timer.overflow();
-     inOverflow = FALSE;
    }
  }
--- 167,171 ----