Search  

---

C:/temp/src/j2k/QNX4/TimerBook.cpp

Go to the documentation of this file.

// From O'Reilly

enum TimerState { Idle, Active, Done };
enum TimerType  { OneShot, Periodic  };

class Timer
{
public:
  Timer();
  virtual ~Timer();

  int  start( unsigned int nMilliseconds, TimerType  =OneShot);
  int  waitfor();
  void cancel();

  volatile TimerState  state;  // Changed by some other process.
           TimerType   type;

  ULONG   length;

  ULONG   count;      // The number of ticks remaining.
  Timer*  pNext;      // For a Linked List of Timer
                      // Ordered by the number of ticks
                      // remaining for each timer.

private:
  // It's static because it can't manipulate software timer variable
  // Our interrupt service routine.
  static void interrupt  Interrupt();   
};

#include "i8018xEB.h"   // Declare the gProcessor global object
#include "Timer.hpp"

#define  CYCLES_PER_TICK   (25000/4)
/* Number of clock cycles per tick.
   for a 25 MHz => 25,000,000 cycles/s  OR  25,000 cycles/ms
   and a tick takes 4 ms.

   The software timer can have a duration from 1 to 65,535 ms,
   a bit more than a minute.
*/


/**************************************************************************
*                                                                         *
*  Method:       Timer()                                                  *
*  Description:  Constructor for the Timer Class.                         *
*                                                                         *
*  Returns:      None defined.                                            *
*                                                                         *
**************************************************************************/

Timer::Timer (void)
{
    static int bInitialized = 0;

    // Initialize the new software timer.

    state  = Idle;
    type   = OneShot;
    length = 0;
    count  = 0;
    pNext  = NULL;

    // Initialize the timer hardware, if not previously done.

    if ( !bInitialized )
    {
        // Install the interrupt handler and enable timer interrupts.
        gProcessor.installHandler( TIMER2_INT, Timer::Interrupt);
        gProcessor.pPCB->intControl.timerControl &= ~(TIMER_MASK | TIMER_PRIORITY );

        // Initialize the hardware device (using Timer #2)
        gProcessor.pPCB->timer[2].count     = 0;
        gProcessor.pPCB->timer[2].maxCountA = CYCLES_PER_TICK;
        gProcessor.pPCB->timer[2].control   = TIMER_ENABLE | TIMER_INTERRUPT | TIMER_PERIODIC;

        // Mark the timer hardware initialized.
        bInitialized = 1;
    }

} /* Timer constructor */

/**************************************************************************
*                                                                         *
*  Method:       Start()                                                  *
*  Description:  Start a software timer, based on the tick                *
*                from the underlying hardware timer.                      *
*                                                                         *
*  Returns:      0 on success, -1 if the timer is already in use.         *
*                                                                         *
**************************************************************************/

int Timer::start( unsigned int nMilliseconds, TimerType timerType )
{
    if ( state != Idle ) {   // Timer already in use.
        return (-1);
    }

    // Initialize the software timer.
    state  = Active;
    type   = timerType;
    length = nMilliseconds / MS_PER_TICK;

    // Add this timer to the active timer list.
    timerList.insert( this );
              
    return (0);

} /* start() */

/**************************************************************************
*                                                                         *
*  Method:       Interrupt()                                              *
*  Description:  An interrupt handler for the timer hardware              *
*                                                                         *
*  Notes:      - This method is declared static, so that we cannot        *
*                inadvertently modify any of the software timers.         *
*              - The keyword interrupt is to ask a x86 compiler           *
*                to save and restore every registers before and after     *
*                that specific method (more than ordinary method call).   *
*                                                                         *
*  Returns:      None defined.                                            *
*                                                                         *
**************************************************************************/
void interrupt  Timer::Interrupt()
{
    // Decrement the active timer's count.
    timerList.tick();

    // Acknowledge the timer interrupt.
    gProcessor.pPCB->intControl.eoi = EOI_NONSPECIFIC;

    // Clear the Maximum Count bit (to start the next cycle).
    gProcessor.pPCB->timer[2].control &= ~TIMER_MAXCOUNT;

} /* Interrupt() */

/**************************************************************************
*                                                                         *
*  Method:       waitfor()                                                *
*  Description:  Wait for the software timer to finish.                   *
*                                                                         *
*  Returns:      0 on success, -1 if the timer is not running.            *
*                                                                         *
**************************************************************************/
int Timer::waitfor()
{
    if (state != Active)
    {
        return (-1);
    }

    // Wait for the timer to expire in a stupid busy-loop.
    while ( state != Done);

    // Restart or idle the timer, depending on its type.
    if ( type == Periodic )
    {
        state = Active;
        timerList.insert( this );
    }
    else
    {
        state = Idle;
    }

    return (0);

} /* waitfor() */

/**************************************************************************
*                                                                         *
*  Method:       cancel()                                                 *
*  Description:  Stop a running timer                                     *
*                                                                         *
*  Returns:      None defined.                                            *
*                                                                         *
**************************************************************************/
void Timer::cancel( void )
{
    // Remove the timer from the timer list.
    if ( state == Active )
    {
        timerList.remove( this );
    }

    // Reset the timer's state.
    state = Idle;

} /* cancel() */

Timer::~Timer()
{
    cancel();
}

// Careful with Periodic timer that waitfor is never called.
int Timer::poll()
{
    return ( state == Done );
}

// Asynchronous CallBack

      

---