Line No. | Rev | Author | Line |
---|---|---|---|
1 | 6 | kaklik | /*! \file timerx8.h \brief Timer function library for ATmegaXX8 Processors. */ |
2 | //***************************************************************************** |
||
3 | // |
||
4 | // File Name : 'timerx8.h' |
||
5 | // Title : Timer function library for ATmegaXX8 Processors |
||
6 | // Author : Pascal Stang - Copyright (C) 2000-2005 |
||
7 | // Created : 11/22/2000 |
||
8 | // Revised : 06/15/2005 |
||
9 | // Version : 1.0 |
||
10 | // Target MCU : Atmel AVR Series |
||
11 | // Editor Tabs : 4 |
||
12 | // |
||
13 | // This code is distributed under the GNU Public License |
||
14 | // which can be found at http://www.gnu.org/licenses/gpl.txt |
||
15 | // |
||
16 | /// \ingroup driver_avr |
||
17 | /// \defgroup timerx8 Timer Function Library for ATmegaXX8 (timerx8.c) |
||
18 | /// \code #include "timerx8.h" \endcode |
||
19 | /// \par Overview |
||
20 | /// This library provides functions for use with the timers internal |
||
21 | /// to the AVR processors. Functions include initialization, set prescaler, |
||
22 | /// calibrated pause function (in milliseconds), attaching and detaching of |
||
23 | /// user functions to interrupts, overflow counters, PWM. Arbitrary |
||
24 | /// frequency generation has been moved to the Pulse Library. |
||
25 | /// |
||
26 | /// \par About Timers |
||
27 | /// The Atmel AVR-series processors each contain at least one |
||
28 | /// hardware timer/counter. Many of the processors contain 2 or 3 |
||
29 | /// timers. Generally speaking, a timer is a hardware counter inside |
||
30 | /// the processor which counts at a rate related to the main CPU clock |
||
31 | /// frequency. Because the counter value increasing (counting up) at |
||
32 | /// a precise rate, we can use it as a timer to create or measure |
||
33 | /// precise delays, schedule events, or generate signals of a certain |
||
34 | /// frequency or pulse-width. |
||
35 | /// \par |
||
36 | /// As an example, the ATmega163 processor has 3 timer/counters. |
||
37 | /// Timer0, Timer1, and Timer2 are 8, 16, and 8 bits wide respectively. |
||
38 | /// This means that they overflow, or roll over back to zero, at a |
||
39 | /// count value of 256 for 8bits or 65536 for 16bits. A prescaler is |
||
40 | /// avaiable for each timer, and the prescaler allows you to pre-divide |
||
41 | /// the main CPU clock rate down to a slower speed before feeding it to |
||
42 | /// the counting input of a timer. For example, if the CPU clock |
||
43 | /// frequency is 3.69MHz, and Timer0's prescaler is set to divide-by-8, |
||
44 | /// then Timer0 will "tic" at 3690000/8 = 461250Hz. Because Timer0 is |
||
45 | /// an 8bit timer, it will count to 256 in just 256/461250Hz = 0.555ms. |
||
46 | /// In fact, when it hits 255, it will overflow and start again at |
||
47 | /// zero. In this case, Timer0 will overflow 461250/256 = 1801.76 |
||
48 | /// times per second. |
||
49 | /// \par |
||
50 | /// Timer0 can be used a number of ways simultaneously. First, the |
||
51 | /// value of the timer can be read by accessing the CPU register \c TCNT0. |
||
52 | /// We could, for example, figure out how long it takes to execute a |
||
53 | /// C command by recording the value of \c TCNT0 before and after |
||
54 | /// execution, then subtract (after-before) = time elapsed. Or we can |
||
55 | /// enable the overflow interrupt which goes off every time T0 |
||
56 | /// overflows and count out longer delays (multiple overflows), or |
||
57 | /// execute a special periodic function at every overflow. |
||
58 | /// \par |
||
59 | /// The other timers (Timer1 and Timer2) offer all the abilities of |
||
60 | /// Timer0 and many more features. Both T1 and T2 can operate as |
||
61 | /// general-purpose timers, but T1 has special hardware allowing it to |
||
62 | /// generate PWM signals, while T2 is specially designed to help count |
||
63 | /// out real time (like hours, minutes, seconds). See the |
||
64 | /// Timer/Counter section of the processor datasheet for more info. |
||
65 | /// |
||
66 | //***************************************************************************** |
||
67 | //@{ |
||
68 | |||
69 | #ifndef TIMER_H |
||
70 | #define TIMER_H |
||
71 | |||
72 | #include "global.h" |
||
73 | |||
74 | // constants/macros/typdefs |
||
75 | |||
76 | // processor compatibility fixes |
||
77 | #ifdef __AVR_ATmega323__ |
||
78 | // redefinition for the Mega323 |
||
79 | #define CTC1 CTC10 |
||
80 | #endif |
||
81 | #ifndef PWM10 |
||
82 | // mega128 PWM bits |
||
83 | #define PWM10 WGM10 |
||
84 | #define PWM11 WGM11 |
||
85 | #endif |
||
86 | |||
87 | |||
88 | // Timer/clock prescaler values and timer overflow rates |
||
89 | // tics = rate at which the timer counts up |
||
90 | // 8bitoverflow = rate at which the timer overflows 8bits (or reaches 256) |
||
91 | // 16bit [overflow] = rate at which the timer overflows 16bits (65536) |
||
92 | // |
||
93 | // overflows can be used to generate periodic interrupts |
||
94 | // |
||
95 | // for 8MHz crystal |
||
96 | // 0 = STOP (Timer not counting) |
||
97 | // 1 = CLOCK tics= 8MHz 8bitoverflow= 31250Hz 16bit= 122.070Hz |
||
98 | // 2 = CLOCK/8 tics= 1MHz 8bitoverflow= 3906.25Hz 16bit= 15.259Hz |
||
99 | // 3 = CLOCK/64 tics= 125kHz 8bitoverflow= 488.28Hz 16bit= 1.907Hz |
||
100 | // 4 = CLOCK/256 tics= 31250Hz 8bitoverflow= 122.07Hz 16bit= 0.477Hz |
||
101 | // 5 = CLOCK/1024 tics= 7812.5Hz 8bitoverflow= 30.52Hz 16bit= 0.119Hz |
||
102 | // 6 = External Clock on T(x) pin (falling edge) |
||
103 | // 7 = External Clock on T(x) pin (rising edge) |
||
104 | |||
105 | // for 4MHz crystal |
||
106 | // 0 = STOP (Timer not counting) |
||
107 | // 1 = CLOCK tics= 4MHz 8bitoverflow= 15625Hz 16bit= 61.035Hz |
||
108 | // 2 = CLOCK/8 tics= 500kHz 8bitoverflow= 1953.125Hz 16bit= 7.629Hz |
||
109 | // 3 = CLOCK/64 tics= 62500Hz 8bitoverflow= 244.141Hz 16bit= 0.954Hz |
||
110 | // 4 = CLOCK/256 tics= 15625Hz 8bitoverflow= 61.035Hz 16bit= 0.238Hz |
||
111 | // 5 = CLOCK/1024 tics= 3906.25Hz 8bitoverflow= 15.259Hz 16bit= 0.060Hz |
||
112 | // 6 = External Clock on T(x) pin (falling edge) |
||
113 | // 7 = External Clock on T(x) pin (rising edge) |
||
114 | |||
115 | // for 3.69MHz crystal |
||
116 | // 0 = STOP (Timer not counting) |
||
117 | // 1 = CLOCK tics= 3.69MHz 8bitoverflow= 14414Hz 16bit= 56.304Hz |
||
118 | // 2 = CLOCK/8 tics= 461250Hz 8bitoverflow= 1801.758Hz 16bit= 7.038Hz |
||
119 | // 3 = CLOCK/64 tics= 57625.25Hz 8bitoverflow= 225.220Hz 16bit= 0.880Hz |
||
120 | // 4 = CLOCK/256 tics= 14414.063Hz 8bitoverflow= 56.305Hz 16bit= 0.220Hz |
||
121 | // 5 = CLOCK/1024 tics= 3603.516Hz 8bitoverflow= 14.076Hz 16bit= 0.055Hz |
||
122 | // 6 = External Clock on T(x) pin (falling edge) |
||
123 | // 7 = External Clock on T(x) pin (rising edge) |
||
124 | |||
125 | // for 32.768KHz crystal on timer 2 (use for real-time clock) |
||
126 | // 0 = STOP |
||
127 | // 1 = CLOCK tics= 32.768kHz 8bitoverflow= 128Hz |
||
128 | // 2 = CLOCK/8 tics= 4096kHz 8bitoverflow= 16Hz |
||
129 | // 3 = CLOCK/32 tics= 1024kHz 8bitoverflow= 4Hz |
||
130 | // 4 = CLOCK/64 tics= 512Hz 8bitoverflow= 2Hz |
||
131 | // 5 = CLOCK/128 tics= 256Hz 8bitoverflow= 1Hz |
||
132 | // 6 = CLOCK/256 tics= 128Hz 8bitoverflow= 0.5Hz |
||
133 | // 7 = CLOCK/1024 tics= 32Hz 8bitoverflow= 0.125Hz |
||
134 | |||
135 | #define TIMER_CLK_STOP 0x00 ///< Timer Stopped |
||
136 | #define TIMER_CLK_DIV1 0x01 ///< Timer clocked at F_CPU |
||
137 | #define TIMER_CLK_DIV8 0x02 ///< Timer clocked at F_CPU/8 |
||
138 | #define TIMER_CLK_DIV64 0x03 ///< Timer clocked at F_CPU/64 |
||
139 | #define TIMER_CLK_DIV256 0x04 ///< Timer clocked at F_CPU/256 |
||
140 | #define TIMER_CLK_DIV1024 0x05 ///< Timer clocked at F_CPU/1024 |
||
141 | #define TIMER_CLK_T_FALL 0x06 ///< Timer clocked at T falling edge |
||
142 | #define TIMER_CLK_T_RISE 0x07 ///< Timer clocked at T rising edge |
||
143 | #define TIMER_PRESCALE_MASK 0x07 ///< Timer Prescaler Bit-Mask |
||
144 | |||
145 | #define TIMERRTC_CLK_STOP 0x00 ///< RTC Timer Stopped |
||
146 | #define TIMERRTC_CLK_DIV1 0x01 ///< RTC Timer clocked at F_CPU |
||
147 | #define TIMERRTC_CLK_DIV8 0x02 ///< RTC Timer clocked at F_CPU/8 |
||
148 | #define TIMERRTC_CLK_DIV32 0x03 ///< RTC Timer clocked at F_CPU/32 |
||
149 | #define TIMERRTC_CLK_DIV64 0x04 ///< RTC Timer clocked at F_CPU/64 |
||
150 | #define TIMERRTC_CLK_DIV128 0x05 ///< RTC Timer clocked at F_CPU/128 |
||
151 | #define TIMERRTC_CLK_DIV256 0x06 ///< RTC Timer clocked at F_CPU/256 |
||
152 | #define TIMERRTC_CLK_DIV1024 0x07 ///< RTC Timer clocked at F_CPU/1024 |
||
153 | #define TIMERRTC_PRESCALE_MASK 0x07 ///< RTC Timer Prescaler Bit-Mask |
||
154 | |||
155 | // default prescale settings for the timers |
||
156 | // these settings are applied when you call |
||
157 | // timerInit or any of the timer<x>Init |
||
158 | #define TIMER0PRESCALE TIMER_CLK_DIV8 ///< timer 0 prescaler default |
||
159 | #define TIMER1PRESCALE TIMER_CLK_DIV64 ///< timer 1 prescaler default |
||
160 | #define TIMER2PRESCALE TIMERRTC_CLK_DIV64 ///< timer 2 prescaler default |
||
161 | |||
162 | // interrupt macros for attaching user functions to timer interrupts |
||
163 | // use these with timerAttach( intNum, function ) |
||
164 | #define TIMER0OVERFLOW_INT 0 |
||
165 | #define TIMER1OVERFLOW_INT 1 |
||
166 | #define TIMER1OUTCOMPAREA_INT 2 |
||
167 | #define TIMER1OUTCOMPAREB_INT 3 |
||
168 | #define TIMER1INPUTCAPTURE_INT 4 |
||
169 | #define TIMER2OVERFLOW_INT 5 |
||
170 | #define TIMER2OUTCOMPARE_INT 6 |
||
171 | #ifdef OCR0 // for processors that support output compare on Timer0 |
||
172 | #define TIMER0OUTCOMPARE_INT 7 |
||
173 | #define TIMER_NUM_INTERRUPTS 8 |
||
174 | #else |
||
175 | #define TIMER_NUM_INTERRUPTS 7 |
||
176 | #endif |
||
177 | |||
178 | // default type of interrupt handler to use for timers |
||
179 | // *do not change unless you know what you're doing |
||
180 | // Value may be SIGNAL or INTERRUPT |
||
181 | #ifndef TIMER_INTERRUPT_HANDLER |
||
182 | #define TIMER_INTERRUPT_HANDLER SIGNAL |
||
183 | #endif |
||
184 | |||
185 | // functions |
||
186 | #define delay delay_us |
||
187 | #define delay_ms timerPause |
||
188 | void delay_us(unsigned short time_us); |
||
189 | |||
190 | //! initializes timing system (all timers) |
||
191 | // runs all timer init functions |
||
192 | // sets all timers to default prescale values #defined in systimer.c |
||
193 | void timerInit(void); |
||
194 | |||
195 | // default initialization routines for each timer |
||
196 | void timer0Init(void); ///< initialize timer0 |
||
197 | void timer1Init(void); ///< initialize timer1 |
||
198 | #ifdef TCNT2 // support timer2 only if it exists |
||
199 | void timer2Init(void); ///< initialize timer2 |
||
200 | #endif |
||
201 | |||
202 | // Clock prescaler set/get commands for each timer/counter |
||
203 | // For setting the prescaler, you should use one of the #defines |
||
204 | // above like TIMER_CLK_DIVx, where [x] is the division rate |
||
205 | // you want. |
||
206 | // When getting the current prescaler setting, the return value |
||
207 | // will be the [x] division value currently set. |
||
208 | void timer0SetPrescaler(u08 prescale); ///< set timer0 prescaler |
||
209 | u16 timer0GetPrescaler(void); ///< get timer0 prescaler |
||
210 | void timer1SetPrescaler(u08 prescale); ///< set timer1 prescaler |
||
211 | u16 timer1GetPrescaler(void); ///< get timer0 prescaler |
||
212 | #ifdef TCNT2 // support timer2 only if it exists |
||
213 | void timer2SetPrescaler(u08 prescale); ///< set timer2 prescaler |
||
214 | u16 timer2GetPrescaler(void); ///< get timer2 prescaler |
||
215 | #endif |
||
216 | |||
217 | |||
218 | // TimerAttach and Detach commands |
||
219 | // These functions allow the attachment (or detachment) of any user function |
||
220 | // to a timer interrupt. "Attaching" one of your own functions to a timer |
||
221 | // interrupt means that it will be called whenever that interrupt happens. |
||
222 | // Using attach is better than rewriting the actual INTERRUPT() function |
||
223 | // because your code will still work and be compatible if the timer library |
||
224 | // is updated. Also, using Attach allows your code and any predefined timer |
||
225 | // code to work together and at the same time. (ie. "attaching" your own |
||
226 | // function to the timer0 overflow doesn't prevent timerPause from working, |
||
227 | // but rather allows you to share the interrupt.) |
||
228 | // |
||
229 | // timerAttach(TIMER1OVERFLOW_INT, myOverflowFunction); |
||
230 | // timerDetach(TIMER1OVERFLOW_INT) |
||
231 | // |
||
232 | // timerAttach causes the myOverflowFunction() to be attached, and therefore |
||
233 | // execute, whenever an overflow on timer1 occurs. timerDetach removes the |
||
234 | // association and executes no user function when the interrupt occurs. |
||
235 | // myOverflowFunction must be defined with no return value and no arguments: |
||
236 | // |
||
237 | // void myOverflowFunction(void) { ... } |
||
238 | |||
239 | //! Attach a user function to a timer interrupt |
||
240 | void timerAttach(u08 interruptNum, void (*userFunc)(void) ); |
||
241 | //! Detach a user function from a timer interrupt |
||
242 | void timerDetach(u08 interruptNum); |
||
243 | |||
244 | |||
245 | // timing commands |
||
246 | /// A timer-based delay/pause function |
||
247 | /// @param pause_ms Number of integer milliseconds to wait. |
||
248 | void timerPause(unsigned short pause_ms); |
||
249 | |||
250 | // overflow counters |
||
251 | void timer0ClearOverflowCount(void); ///< Clear timer0's overflow counter. |
||
252 | long timer0GetOverflowCount(void); ///< read timer0's overflow counter |
||
253 | #ifdef TCNT2 // support timer2 only if it exists |
||
254 | void timer2ClearOverflowCount(void); ///< clear timer2's overflow counter |
||
255 | long timer2GetOverflowCount(void); ///< read timer0's overflow counter |
||
256 | #endif |
||
257 | |||
258 | /// @defgroup timerpwm Timer PWM Commands |
||
259 | /// @ingroup timer |
||
260 | /// These commands control PWM functionality on timer1 |
||
261 | // PWM initialization and set commands for timer1 |
||
262 | // timer1PWMInit() |
||
263 | // configures the timer1 hardware for PWM mode on pins OC1A and OC1B. |
||
264 | // bitRes should be 8,9,or 10 for 8,9,or 10bit PWM resolution |
||
265 | // |
||
266 | // timer1PWMOff() |
||
267 | // turns off all timer1 PWM output and set timer mode to normal state |
||
268 | // |
||
269 | // timer1PWMAOn() and timer1PWMBOn() |
||
270 | // turn on output of PWM signals to OC1A or OC1B pins |
||
271 | // NOTE: Until you define the OC1A and OC1B pins as outputs, and run |
||
272 | // this "on" command, no PWM output will be output |
||
273 | // |
||
274 | // timer1PWMAOff() and timer1PWMBOff() |
||
275 | // turn off output of PWM signals to OC1A or OC1B pins |
||
276 | // |
||
277 | // timer1PWMASet() and timer1PWMBSet() |
||
278 | // sets the PWM duty cycle for each channel |
||
279 | // NOTE: <pwmDuty> should be in the range 0-255 for 8bit PWM |
||
280 | // <pwmDuty> should be in the range 0-511 for 9bit PWM |
||
281 | // <pwmDuty> should be in the range 0-1023 for 10bit PWM |
||
282 | // NOTE: the PWM frequency can be controlled in increments by setting the |
||
283 | // prescaler for timer1 |
||
284 | //@{ |
||
285 | |||
286 | |||
287 | /// Enter standard PWM Mode on timer1. |
||
288 | /// \param bitRes indicates the period/resolution to use for PWM output in timer bits. |
||
289 | /// Must be either 8, 9, or 10 bits corresponding to PWM periods of 256, 512, or 1024 timer tics. |
||
290 | void timer1PWMInit(u08 bitRes); |
||
291 | |||
292 | /// Enter PWM Mode on timer1 with a specific top-count value. |
||
293 | /// \param topcount indicates the desired PWM period in timer tics. |
||
294 | /// Can be a number between 1 and 65535 (16-bit). |
||
295 | void timer1PWMInitICR(u16 topcount); |
||
296 | |||
297 | /// Turn off all timer1 PWM output and set timer mode to normal. |
||
298 | void timer1PWMOff(void); |
||
299 | |||
300 | /// Turn on/off Timer1 PWM outputs. |
||
301 | void timer1PWMAOn(void); ///< Turn on timer1 Channel A (OC1A) PWM output. |
||
302 | void timer1PWMBOn(void); ///< Turn on timer1 Channel B (OC1B) PWM output. |
||
303 | void timer1PWMAOff(void); ///< turn off timer1 Channel A (OC1A) PWM output |
||
304 | void timer1PWMBOff(void); ///< turn off timer1 Channel B (OC1B) PWM output |
||
305 | |||
306 | void timer1PWMASet(u16 pwmDuty); ///< set duty of timer1 Channel A (OC1A) PWM output |
||
307 | void timer1PWMBSet(u16 pwmDuty); ///< set duty of timer1 Channel B (OC1B) PWM output |
||
308 | |||
309 | //@} |
||
310 | //@} |
||
311 | |||
312 | // Pulse generation commands have been moved to the pulse.c library |
||
313 | |||
314 | #endif |
Powered by WebSVN v2.8.3