Main Page | Modules | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

# timer128.h

Go to the documentation of this file.

    00001 /*! \file timer128.h \brief System Timer function library for Mega128. */
    00002 //*****************************************************************************
    00003 //
    00004 // File Name    : 'timer128.h'
    00005 // Title        : System Timer function library for Mega128
    00006 // Author       : Pascal Stang - Copyright (C) 2000-2003
    00007 // Created      : 11/22/2000
    00008 // Revised      : 02/10/2003
    00009 // Version      : 1.1
    00010 // Target MCU   : Atmel AVR Series
    00011 // Editor Tabs  : 4
    00012 //
    00013 // This code is distributed under the GNU Public License
    00014 //      which can be found at http://www.gnu.org/licenses/gpl.txt
    00015 //
    00016 /// \ingroup driver_avr
    00017 /// \defgroup timer128 Timer Function Library for ATmega128 (timer128.c)
    00018 /// \code #include "timer128.h" \endcode
    00019 /// \par Overview
    00020 ///     This library provides functions for use with the timers internal to the
    00021 ///     AVR ATmega128.  Functions include initialization, set prescaler,
    00022 ///     calibrated pause function (in milliseconds), attaching and detaching
    00023 ///     of user functions to interrupts, overflow counters, and PWM.
    00024 ///
    00025 /// \par About Timers
    00026 ///     The Atmel AVR-series processors each contain at least one
    00027 ///     hardware timer/counter.  Many of the processors contain 2 or 3
    00028 ///     timers.  Generally speaking, a timer is a hardware counter inside
    00029 ///     the processor which counts at a rate related to the main CPU clock
    00030 ///     frequency.  Because the counter value increasing (counting up) at
    00031 ///     a precise rate, we can use it as a timer to create or measure
    00032 ///     precise delays, schedule events, or generate signals of a certain
    00033 ///     frequency or pulse-width.
    00034 /// \par
    00035 ///     As an example, the ATmega163 processor has 3 timer/counters.
    00036 ///     Timer0, Timer1, and Timer2 are 8, 16, and 8 bits wide respectively.
    00037 ///     This means that they overflow, or roll over back to zero, at a
    00038 ///     count value of 256 for 8bits or 65536 for 16bits.  A prescaler is
    00039 ///     avaiable for each timer, and the prescaler allows you to pre-divide
    00040 ///     the main CPU clock rate down to a slower speed before feeding it to
    00041 ///     the counting input of a timer.  For example, if the CPU clock
    00042 ///     frequency is 3.69MHz, and Timer0's prescaler is set to divide-by-8,
    00043 ///     then Timer0 will "tic" at 3690000/8 = 461250Hz.  Because Timer0 is
    00044 ///     an 8bit timer, it will count to 256 in just 256/461250Hz = 0.555ms.
    00045 ///     In fact, when it hits 255, it will overflow and start again at
    00046 ///     zero.  In this case, Timer0 will overflow 461250/256 = 1801.76
    00047 ///     times per second.
    00048 /// \par
    00049 ///     Timer0 can be used a number of ways simultaneously.  First, the
    00050 ///     value of the timer can be read by accessing the CPU register \c TCNT0.
    00051 ///     We could, for example, figure out how long it takes to execute a
    00052 ///     C command by recording the value of \c TCNT0 before and after
    00053 ///     execution, then subtract (after-before) = time elapsed.  Or we can
    00054 ///     enable the overflow interrupt which goes off every time T0
    00055 ///     overflows and count out longer delays (multiple overflows), or
    00056 ///     execute a special periodic function at every overflow.
    00057 /// \par
    00058 ///     The other timers (Timer1 and Timer2) offer all the abilities of
    00059 ///     Timer0 and many more features.  Both T1 and T2 can operate as
    00060 ///     general-purpose timers, but T1 has special hardware allowing it to
    00061 ///     generate PWM signals, while T2 is specially designed to help count
    00062 ///     out real time (like hours, minutes, seconds).  See the
    00063 ///     Timer/Counter section of the processor datasheet for more info.
    00064 ///
    00065 //*****************************************************************************
    00066 //@{
    00067
    00068 #ifndef TIMER128_H
    00069 #define TIMER128_H
    00070
    00071 #include "global.h"
    00072
    00073 // constants/macros/typdefs
    00074
    00075 // Timer/clock prescaler values and timer overflow rates
    00076 // tics = rate at which the timer counts up
    00077 // 8bitoverflow = rate at which the timer overflows 8bits (or reaches 256)
    00078 // 16bit [overflow] = rate at which the timer overflows 16bits (65536)
    00079 //
    00080 // overflows can be used to generate periodic interrupts
    00081 //
    00082 // for 8MHz crystal
    00083 // 0 = STOP (Timer not counting)
    00084 // 1 = CLOCK        tics= 8MHz          8bitoverflow= 31250Hz       16bit= 122.070Hz
    00085 // 2 = CLOCK/8      tics= 1MHz          8bitoverflow= 3906.25Hz     16bit=  15.259Hz
    00086 // 3 = CLOCK/64     tics= 125kHz        8bitoverflow=  488.28Hz     16bit=   1.907Hz
    00087 // 4 = CLOCK/256    tics= 31250Hz       8bitoverflow=  122.07Hz     16bit=  0.477Hz
    00088 // 5 = CLOCK/1024   tics= 7812.5Hz      8bitoverflow=   30.52Hz     16bit=   0.119Hz
    00089 // 6 = External Clock on T(x) pin (falling edge)
    00090 // 7 = External Clock on T(x) pin (rising edge)
    00091
    00092 // for 4MHz crystal
    00093 // 0 = STOP (Timer not counting)
    00094 // 1 = CLOCK        tics= 4MHz          8bitoverflow= 15625Hz       16bit=  61.035Hz
    00095 // 2 = CLOCK/8      tics= 500kHz        8bitoverflow= 1953.125Hz    16bit=   7.629Hz
    00096 // 3 = CLOCK/64     tics= 62500Hz       8bitoverflow=  244.141Hz    16bit=   0.954Hz
    00097 // 4 = CLOCK/256    tics= 15625Hz       8bitoverflow=   61.035Hz    16bit=   0.238Hz
    00098 // 5 = CLOCK/1024   tics= 3906.25Hz     8bitoverflow=   15.259Hz    16bit=   0.060Hz
    00099 // 6 = External Clock on T(x) pin (falling edge)
    00100 // 7 = External Clock on T(x) pin (rising edge)
    00101
    00102 // for 3.69MHz crystal
    00103 // 0 = STOP (Timer not counting)
    00104 // 1 = CLOCK        tics= 3.69MHz       8bitoverflow= 14414Hz       16bit=  56.304Hz
    00105 // 2 = CLOCK/8      tics= 461250Hz      8bitoverflow= 1801.758Hz    16bit=   7.038Hz
    00106 // 3 = CLOCK/64     tics= 57625.25Hz    8bitoverflow=  225.220Hz    16bit=   0.880Hz
    00107 // 4 = CLOCK/256    tics= 14414.063Hz   8bitoverflow=   56.305Hz    16bit=   0.220Hz
    00108 // 5 = CLOCK/1024   tics=  3603.516Hz   8bitoverflow=   14.076Hz    16bit=   0.055Hz
    00109 // 6 = External Clock on T(x) pin (falling edge)
    00110 // 7 = External Clock on T(x) pin (rising edge)
    00111
    00112 // for 32.768KHz crystal on timer 2 (use for real-time clock)
    00113 // 0 = STOP
    00114 // 1 = CLOCK        tics= 32.768kHz 8bitoverflow= 128Hz
    00115 // 2 = CLOCK/8      tics= 4096kHz       8bitoverflow=  16Hz
    00116 // 3 = CLOCK/64     tics= 512Hz         8bitoverflow=   2Hz
    00117 // 4 = CLOCK/256    tics= 128Hz         8bitoverflow=   0.5Hz
    00118 // 5 = CLOCK/1024   tics= 32Hz          8bitoverflow=   0.125Hz
    00119
    00120 #define TIMER_CLK_STOP          0x00    ///< Timer Stopped
    00121 #define TIMER_CLK_DIV1          0x01    ///< Timer clocked at F_CPU
    00122 #define TIMER_CLK_DIV8          0x02    ///< Timer clocked at F_CPU/8
    00123 #define TIMER_CLK_DIV64         0x03    ///< Timer clocked at F_CPU/64
    00124 #define TIMER_CLK_DIV256        0x04    ///< Timer clocked at F_CPU/256
    00125 #define TIMER_CLK_DIV1024       0x05    ///< Timer clocked at F_CPU/1024
    00126 #define TIMER_CLK_T_FALL        0x06    ///< Timer clocked at T falling edge
    00127 #define TIMER_CLK_T_RISE        0x07    ///< Timer clocked at T rising edge
    00128 #define TIMER_PRESCALE_MASK     0x07    ///< Timer Prescaler Bit-Mask
    00129
    00130 #define TIMERRTC_CLK_STOP       0x00    ///< RTC Timer Stopped
    00131 #define TIMERRTC_CLK_DIV1       0x01    ///< RTC Timer clocked at F_CPU
    00132 #define TIMERRTC_CLK_DIV8       0x02    ///< RTC Timer clocked at F_CPU/8
    00133 #define TIMERRTC_CLK_DIV32      0x03    ///< RTC Timer clocked at F_CPU/32
    00134 #define TIMERRTC_CLK_DIV64      0x04    ///< RTC Timer clocked at F_CPU/64
    00135 #define TIMERRTC_CLK_DIV128     0x05    ///< RTC Timer clocked at F_CPU/128
    00136 #define TIMERRTC_CLK_DIV256     0x06    ///< RTC Timer clocked at F_CPU/256
    00137 #define TIMERRTC_CLK_DIV1024    0x07    ///< RTC Timer clocked at F_CPU/1024
    00138 #define TIMERRTC_PRESCALE_MASK  0x07    ///< RTC Timer Prescaler Bit-Mask
    00139
    00140 // default prescale settings for the timers
    00141 // these settings are applied when you call
    00142 // timerInit or any of the timer<x>Init
    00143 #define TIMER0PRESCALE      TIMERRTC_CLK_DIV64  ///< timer 0 prescaler default
    00144 #define TIMER1PRESCALE      TIMER_CLK_DIV64     ///< timer 1 prescaler default
    00145 #define TIMER2PRESCALE      TIMER_CLK_DIV8      ///< timer 2 prescaler default
    00146 #define TIMER3PRESCALE      TIMER_CLK_DIV64     ///< timer 3 prescaler default
    00147
    00148 // interrupt macros for attaching user functions to timer interrupts
    00149 // use these with timerAttach( intNum, function )
    00150 // timer 0
    00151 #define TIMER0OVERFLOW_INT          0
    00152 #define TIMER0OUTCOMPARE_INT        1
    00153 // timer 1
    00154 #define TIMER1OVERFLOW_INT          2
    00155 #define TIMER1OUTCOMPAREA_INT       3
    00156 #define TIMER1OUTCOMPAREB_INT       4
    00157 #define TIMER1OUTCOMPAREC_INT       5
    00158 #define TIMER1INPUTCAPTURE_INT      6
    00159 // timer 2
    00160 #define TIMER2OVERFLOW_INT          7
    00161 #define TIMER2OUTCOMPARE_INT        8
    00162 // timer 3
    00163 #define TIMER3OVERFLOW_INT          9
    00164 #define TIMER3OUTCOMPAREA_INT       10
    00165 #define TIMER3OUTCOMPAREB_INT       11
    00166 #define TIMER3OUTCOMPAREC_INT       12
    00167 #define TIMER3INPUTCAPTURE_INT      13
    00168
    00169 #define TIMER_NUM_INTERRUPTS        14
    00170
    00171 // type of interrupt handler to use for timers
    00172 // *do not change unless you know what you're doing
    00173 // Value may be SIGNAL or INTERRUPT
    00174 #ifndef TIMER_INTERRUPT_HANDLER
    00175 #define TIMER_INTERRUPT_HANDLER     SIGNAL
    00176 #endif
    00177
    00178 // functions
    00179 #define delay       delay_us
    00180 #define delay_ms    timerPause
    00181 void delay_us(unsigned short time_us);
    00182
    00183 // initializes timing system
    00184 // runs all timer init functions
    00185 // sets all timers to default prescale values #defined in systimer.c
    00186 void timerInit(void);
    00187
    00188 // default initialization routines for each timer
    00189 void timer0Init(void);
    00190 void timer1Init(void);
    00191 void timer2Init(void);
    00192 void timer3Init(void);
    00193
    00194 // Clock prescaler set/get commands for each timer/counter
    00195 // For setting the prescaler, you should use one of the #defines
    00196 // above like TIMER_CLK_DIVx, where [x] is the division rate
    00197 // you want.
    00198 // When getting the current prescaler setting, the return value
    00199 // will be the [x] division value currently set.
    00200 void timer0SetPrescaler(u08 prescale);      ///< set timer0 prescaler division index
    00201 void timer1SetPrescaler(u08 prescale);      ///< set timer1 prescaler division index
    00202 void timer2SetPrescaler(u08 prescale);      ///< set timer2 prescaler division index
    00203 void timer3SetPrescaler(u08 prescale);      ///< set timer3 prescaler division index
    00204 u16  timer0GetPrescaler(void);              ///< get timer0 prescaler division rate
    00205 u16  timer1GetPrescaler(void);              ///< get timer1 prescaler division rate
    00206 u16  timer2GetPrescaler(void);              ///< get timer2 prescaler division rate
    00207 u16  timer3GetPrescaler(void);              ///< get timer3 prescaler division rate
    00208
    00209
    00210 // TimerAttach and Detach commands
    00211 //      These functions allow the attachment (or detachment) of any user function
    00212 //      to a timer interrupt.  "Attaching" one of your own functions to a timer
    00213 //      interrupt means that it will be called whenever that interrupt happens.
    00214 //      Using attach is better than rewriting the actual INTERRUPT() function
    00215 //      because your code will still work and be compatible if the timer library
    00216 //      is updated.  Also, using Attach allows your code and any predefined timer
    00217 //      code to work together and at the same time.  (ie. "attaching" your own
    00218 //      function to the timer0 overflow doesn't prevent timerPause from working,
    00219 //      but rather allows you to share the interrupt.)
    00220 //
    00221 //      timerAttach(TIMER1OVERFLOW_INT, myOverflowFunction);
    00222 //      timerDetach(TIMER1OVERFLOW_INT)
    00223 //
    00224 //      timerAttach causes the myOverflowFunction() to be attached, and therefore
    00225 //      execute, whenever an overflow on timer1 occurs.  timerDetach removes the
    00226 //      association and executes no user function when the interrupt occurs.
    00227 //      myOverflowFunction must be defined with no return value and no arguments:
    00228 //
    00229 //      void myOverflowFunction(void) { ... }
    00230
    00231 void timerAttach(u08 interruptNum, void (*userFunc)(void) );
    00232 void timerDetach(u08 interruptNum);
    00233
    00234
    00235 // timing commands
    00236 // timerPause pauses for the number of milliseconds specified in <pause_ms>
    00237 void timerPause(unsigned short pause_ms);
    00238
    00239 // overflow counters
    00240 // to be documented
    00241 void timer0ClearOverflowCount(void);
    00242 long timer0GetOverflowCount(void);
    00243 void timer2ClearOverflowCount(void);
    00244 long timer2GetOverflowCount(void);
    00245
    00246 // PWM initialization and set commands for timerX (where X is either 1 or 3)
    00247 // timerXPWMInit()
    00248 //      configures the timerX hardware for PWM mode on pins OCXA, OCXB, and OCXC.
    00249 //      bitRes should be 8,9,or 10 for 8,9,or 10bit PWM resolution
    00250 //
    00251 // timerXPWMOff()
    00252 //      turns off all timerX PWM output and set timer mode to normal state
    00253 //
    00254 // timerXPWMAOn(), timerXPWMBOn(), timerXPWMCOn()
    00255 //      turn on output of PWM signals to OCXA,B,C pins
    00256 //      NOTE: Until you define the OCXA,B,C pins as outputs, and run
    00257 //      this "on" command, no PWM output will be output
    00258 //
    00259 // timerXPWMAOff(), timerXPWMBOff(), timerXPWMCOff()
    00260 //      turn off output of PWM signals to OCXA,B,C pins
    00261 //
    00262 // timerXPWMASet(), timer1PWMBSet(), timerXPWMCSet()
    00263 //      sets the PWM duty cycle for each channel
    00264 //  NOTE:   <pwmDuty> should be in the range 0-255 for 8bit PWM
    00265 //          <pwmDuty> should be in the range 0-511 for 9bit PWM
    00266 //          <pwmDuty> should be in the range 0-1023 for 10bit PWM
    00267 // NOTE: the PWM frequency can be controlled in increments by setting the
    00268 //          prescaler for timer1
    00269
    00270 void timer1PWMInit(u08 bitRes);     ///< initialize and set timer1 mode to PWM
    00271 void timer1PWMInitICR(u16 topcount);///< initialize and set timer1 mode to PWM with specific top count
    00272 void timer1PWMOff(void);            ///< turn off all timer1 PWM output and set timer mode to normal
    00273 void timer1PWMAOn(void);            ///< turn on timer1 Channel A (OC1A) PWM output
    00274 void timer1PWMBOn(void);            ///< turn on timer1 Channel B (OC1B) PWM output
    00275 void timer1PWMCOn(void);            ///< turn on timer1 Channel C (OC1C) PWM output
    00276 void timer1PWMAOff(void);           ///< turn off timer1 Channel A (OC1A) PWM output
    00277 void timer1PWMBOff(void);           ///< turn off timer1 Channel B (OC1B) PWM output
    00278 void timer1PWMCOff(void);           ///< turn off timer1 Channel C (OC1C) PWM output
    00279 void timer1PWMASet(u16 pwmDuty);    ///< set duty of timer1 Channel A (OC1A) PWM output
    00280 void timer1PWMBSet(u16 pwmDuty);    ///< set duty of timer1 Channel B (OC1B) PWM output
    00281 void timer1PWMCSet(u16 pwmDuty);    ///< set duty of timer1 Channel C (OC1C) PWM output
    00282
    00283 void timer3PWMInit(u08 bitRes);     ///< initialize and set timer3 mode to PWM
    00284 void timer3PWMInitICR(u16 topcount);///< initialize and set timer3 mode to PWM with specific top count
    00285 void timer3PWMOff(void);            ///< turn off all timer3 PWM output and set timer mode to normal
    00286 void timer3PWMAOn(void);            ///< turn on timer3 Channel A (OC3A) PWM output
    00287 void timer3PWMBOn(void);            ///< turn on timer3 Channel B (OC3B) PWM output
    00288 void timer3PWMCOn(void);            ///< turn on timer3 Channel C (OC3C) PWM output
    00289 void timer3PWMAOff(void);           ///< turn off timer3 Channel A (OC3A) PWM output
    00290 void timer3PWMBOff(void);           ///< turn off timer3 Channel B (OC3B) PWM output
    00291 void timer3PWMCOff(void);           ///< turn off timer3 Channel C (OC3C) PWM output
    00292 void timer3PWMASet(u16 pwmDuty);    ///< set duty of timer3 Channel A (OC3A) PWM output
    00293 void timer3PWMBSet(u16 pwmDuty);    ///< set duty of timer3 Channel B (OC3B) PWM output
    00294 void timer3PWMCSet(u16 pwmDuty);    ///< set duty of timer3 Channel C (OC3C) PWM output
    00295
    00296 //@}
    00297
    00298 // Pulse generation commands have been moved to the pulse.c library
    00299
    00300 #endif