| 1145 |
kaklik |
1 |
/*! \file timer.c \brief System Timer function library. */ |
|
|
2 |
//***************************************************************************** |
|
|
3 |
// |
|
|
4 |
// File Name : 'timer.c' |
|
|
5 |
// Title : System Timer function library |
|
|
6 |
// Author : Pascal Stang - Copyright (C) 2000-2002 |
|
|
7 |
// Created : 11/22/2000 |
|
|
8 |
// Revised : 07/09/2003 |
|
|
9 |
// Version : 1.1 |
|
|
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 |
//***************************************************************************** |
|
|
17 |
|
|
|
18 |
#include <avr/io.h> |
|
|
19 |
#include <avr/interrupt.h> |
|
|
20 |
#include <avr/pgmspace.h> |
|
|
21 |
#include <avr/sleep.h> |
|
|
22 |
|
|
|
23 |
#include "global.h" |
|
|
24 |
#include "timer.h" |
|
|
25 |
|
|
|
26 |
#include "rprintf.h" |
|
|
27 |
|
|
|
28 |
// Program ROM constants |
|
|
29 |
// the prescale division values stored in order of timer control register index |
|
|
30 |
// STOP, CLK, CLK/8, CLK/64, CLK/256, CLK/1024 |
|
|
31 |
unsigned short __attribute__ ((progmem)) TimerPrescaleFactor[] = {0,1,8,64,256,1024}; |
|
|
32 |
// the prescale division values stored in order of timer control register index |
|
|
33 |
// STOP, CLK, CLK/8, CLK/32, CLK/64, CLK/128, CLK/256, CLK/1024 |
|
|
34 |
unsigned short __attribute__ ((progmem)) TimerRTCPrescaleFactor[] = {0,1,8,32,64,128,256,1024}; |
|
|
35 |
|
|
|
36 |
// Global variables |
|
|
37 |
// time registers |
|
|
38 |
volatile unsigned long TimerPauseReg; |
|
|
39 |
volatile unsigned long Timer0Reg0; |
|
|
40 |
volatile unsigned long Timer2Reg0; |
|
|
41 |
|
|
|
42 |
typedef void (*voidFuncPtr)(void); |
|
|
43 |
volatile static voidFuncPtr TimerIntFunc[TIMER_NUM_INTERRUPTS]; |
|
|
44 |
|
|
|
45 |
// delay for a minimum of <us> microseconds |
|
|
46 |
// the time resolution is dependent on the time the loop takes |
|
|
47 |
// e.g. with 4Mhz and 5 cycles per loop, the resolution is 1.25 us |
|
|
48 |
void delay_us(unsigned short time_us) |
|
|
49 |
{ |
|
|
50 |
unsigned short delay_loops; |
|
|
51 |
register unsigned short i; |
|
|
52 |
|
|
|
53 |
delay_loops = (time_us+3)/5*CYCLES_PER_US; // +3 for rounding up (dirty) |
|
|
54 |
|
|
|
55 |
// one loop takes 5 cpu cycles |
|
|
56 |
for (i=0; i < delay_loops; i++) {}; |
|
|
57 |
} |
|
|
58 |
/* |
|
|
59 |
void delay_ms(unsigned char time_ms) |
|
|
60 |
{ |
|
|
61 |
unsigned short delay_count = F_CPU / 4000; |
|
|
62 |
|
|
|
63 |
unsigned short cnt; |
|
|
64 |
asm volatile ("\n" |
|
|
65 |
"L_dl1%=:\n\t" |
|
|
66 |
"mov %A0, %A2\n\t" |
|
|
67 |
"mov %B0, %B2\n" |
|
|
68 |
"L_dl2%=:\n\t" |
|
|
69 |
"sbiw %A0, 1\n\t" |
|
|
70 |
"brne L_dl2%=\n\t" |
|
|
71 |
"dec %1\n\t" "brne L_dl1%=\n\t":"=&w" (cnt) |
|
|
72 |
:"r"(time_ms), "r"((unsigned short) (delay_count)) |
|
|
73 |
); |
|
|
74 |
} |
|
|
75 |
*/ |
|
|
76 |
void timerInit(void) |
|
|
77 |
{ |
|
|
78 |
u08 intNum; |
|
|
79 |
// detach all user functions from interrupts |
|
|
80 |
for(intNum=0; intNum<TIMER_NUM_INTERRUPTS; intNum++) |
|
|
81 |
timerDetach(intNum); |
|
|
82 |
|
|
|
83 |
// initialize all timers |
|
|
84 |
timer0Init(); |
|
|
85 |
timer1Init(); |
|
|
86 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
87 |
timer2Init(); |
|
|
88 |
#endif |
|
|
89 |
// enable interrupts |
|
|
90 |
sei(); |
|
|
91 |
} |
|
|
92 |
|
|
|
93 |
void timer0Init() |
|
|
94 |
{ |
|
|
95 |
// initialize timer 0 |
|
|
96 |
timer0SetPrescaler( TIMER0PRESCALE ); // set prescaler |
|
|
97 |
outb(TCNT0, 0); // reset TCNT0 |
|
|
98 |
sbi(TIMSK, TOIE0); // enable TCNT0 overflow interrupt |
|
|
99 |
|
|
|
100 |
timer0ClearOverflowCount(); // initialize time registers |
|
|
101 |
} |
|
|
102 |
|
|
|
103 |
void timer1Init(void) |
|
|
104 |
{ |
|
|
105 |
// initialize timer 1 |
|
|
106 |
timer1SetPrescaler( TIMER1PRESCALE ); // set prescaler |
|
|
107 |
outb(TCNT1H, 0); // reset TCNT1 |
|
|
108 |
outb(TCNT1L, 0); |
|
|
109 |
sbi(TIMSK, TOIE1); // enable TCNT1 overflow |
|
|
110 |
} |
|
|
111 |
|
|
|
112 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
113 |
void timer2Init(void) |
|
|
114 |
{ |
|
|
115 |
// initialize timer 2 |
|
|
116 |
timer2SetPrescaler( TIMER2PRESCALE ); // set prescaler |
|
|
117 |
outb(TCNT2, 0); // reset TCNT2 |
|
|
118 |
sbi(TIMSK, TOIE2); // enable TCNT2 overflow |
|
|
119 |
|
|
|
120 |
timer2ClearOverflowCount(); // initialize time registers |
|
|
121 |
} |
|
|
122 |
#endif |
|
|
123 |
|
|
|
124 |
void timer0SetPrescaler(u08 prescale) |
|
|
125 |
{ |
|
|
126 |
// set prescaler on timer 0 |
|
|
127 |
outb(TCCR0, (inb(TCCR0) & ~TIMER_PRESCALE_MASK) | prescale); |
|
|
128 |
} |
|
|
129 |
|
|
|
130 |
void timer1SetPrescaler(u08 prescale) |
|
|
131 |
{ |
|
|
132 |
// set prescaler on timer 1 |
|
|
133 |
outb(TCCR1B, (inb(TCCR1B) & ~TIMER_PRESCALE_MASK) | prescale); |
|
|
134 |
} |
|
|
135 |
|
|
|
136 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
137 |
void timer2SetPrescaler(u08 prescale) |
|
|
138 |
{ |
|
|
139 |
// set prescaler on timer 2 |
|
|
140 |
outb(TCCR2, (inb(TCCR2) & ~TIMER_PRESCALE_MASK) | prescale); |
|
|
141 |
} |
|
|
142 |
#endif |
|
|
143 |
|
|
|
144 |
u16 timer0GetPrescaler(void) |
|
|
145 |
{ |
|
|
146 |
// get the current prescaler setting |
|
|
147 |
return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR0) & TIMER_PRESCALE_MASK))); |
|
|
148 |
} |
|
|
149 |
|
|
|
150 |
u16 timer1GetPrescaler(void) |
|
|
151 |
{ |
|
|
152 |
// get the current prescaler setting |
|
|
153 |
return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR1B) & TIMER_PRESCALE_MASK))); |
|
|
154 |
} |
|
|
155 |
|
|
|
156 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
157 |
u16 timer2GetPrescaler(void) |
|
|
158 |
{ |
|
|
159 |
//TODO: can we assume for all 3-timer AVR processors, |
|
|
160 |
// that timer2 is the RTC timer? |
|
|
161 |
|
|
|
162 |
// get the current prescaler setting |
|
|
163 |
return (pgm_read_word(TimerRTCPrescaleFactor+(inb(TCCR2) & TIMER_PRESCALE_MASK))); |
|
|
164 |
} |
|
|
165 |
#endif |
|
|
166 |
|
|
|
167 |
void timerAttach(u08 interruptNum, void (*userFunc)(void) ) |
|
|
168 |
{ |
|
|
169 |
// make sure the interrupt number is within bounds |
|
|
170 |
if(interruptNum < TIMER_NUM_INTERRUPTS) |
|
|
171 |
{ |
|
|
172 |
// set the interrupt function to run |
|
|
173 |
// the supplied user's function |
|
|
174 |
TimerIntFunc[interruptNum] = userFunc; |
|
|
175 |
} |
|
|
176 |
} |
|
|
177 |
|
|
|
178 |
void timerDetach(u08 interruptNum) |
|
|
179 |
{ |
|
|
180 |
// make sure the interrupt number is within bounds |
|
|
181 |
if(interruptNum < TIMER_NUM_INTERRUPTS) |
|
|
182 |
{ |
|
|
183 |
// set the interrupt function to run nothing |
|
|
184 |
TimerIntFunc[interruptNum] = 0; |
|
|
185 |
} |
|
|
186 |
} |
|
|
187 |
/* |
|
|
188 |
u32 timerMsToTics(u16 ms) |
|
|
189 |
{ |
|
|
190 |
// calculate the prescaler division rate |
|
|
191 |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
|
|
192 |
// calculate the number of timer tics in x milliseconds |
|
|
193 |
return (ms*(F_CPU/(prescaleDiv*256)))/1000; |
|
|
194 |
} |
|
|
195 |
|
|
|
196 |
u16 timerTicsToMs(u32 tics) |
|
|
197 |
{ |
|
|
198 |
// calculate the prescaler division rate |
|
|
199 |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
|
|
200 |
// calculate the number of milliseconds in x timer tics |
|
|
201 |
return (tics*1000*(prescaleDiv*256))/F_CPU; |
|
|
202 |
} |
|
|
203 |
*/ |
|
|
204 |
void timerPause(unsigned short pause_ms) |
|
|
205 |
{ |
|
|
206 |
// pauses for exactly <pause_ms> number of milliseconds |
|
|
207 |
u08 timerThres; |
|
|
208 |
u32 ticRateHz; |
|
|
209 |
u32 pause; |
|
|
210 |
|
|
|
211 |
// capture current pause timer value |
|
|
212 |
timerThres = inb(TCNT0); |
|
|
213 |
// reset pause timer overflow count |
|
|
214 |
TimerPauseReg = 0; |
|
|
215 |
// calculate delay for [pause_ms] milliseconds |
|
|
216 |
// prescaler division = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))) |
|
|
217 |
ticRateHz = F_CPU/timer0GetPrescaler(); |
|
|
218 |
// precision management |
|
|
219 |
// prevent overflow and precision underflow |
|
|
220 |
// -could add more conditions to improve accuracy |
|
|
221 |
if( ((ticRateHz < 429497) && (pause_ms <= 10000)) ) |
|
|
222 |
pause = (pause_ms*ticRateHz)/1000; |
|
|
223 |
else |
|
|
224 |
pause = pause_ms*(ticRateHz/1000); |
|
|
225 |
|
|
|
226 |
// loop until time expires |
|
|
227 |
while( ((TimerPauseReg<<8) | inb(TCNT0)) < (pause+timerThres) ) |
|
|
228 |
{ |
|
|
229 |
if( TimerPauseReg < (pause>>8)); |
|
|
230 |
{ |
|
|
231 |
// save power by idling the processor |
|
|
232 |
set_sleep_mode(SLEEP_MODE_IDLE); |
|
|
233 |
sleep_mode(); |
|
|
234 |
} |
|
|
235 |
} |
|
|
236 |
|
|
|
237 |
/* old inaccurate code, for reference |
|
|
238 |
|
|
|
239 |
// calculate delay for [pause_ms] milliseconds |
|
|
240 |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
|
|
241 |
u32 pause = (pause_ms*(F_CPU/(prescaleDiv*256)))/1000; |
|
|
242 |
|
|
|
243 |
TimerPauseReg = 0; |
|
|
244 |
while(TimerPauseReg < pause); |
|
|
245 |
|
|
|
246 |
*/ |
|
|
247 |
} |
|
|
248 |
|
|
|
249 |
void timer0ClearOverflowCount(void) |
|
|
250 |
{ |
|
|
251 |
// clear the timer overflow counter registers |
|
|
252 |
Timer0Reg0 = 0; // initialize time registers |
|
|
253 |
} |
|
|
254 |
|
|
|
255 |
long timer0GetOverflowCount(void) |
|
|
256 |
{ |
|
|
257 |
// return the current timer overflow count |
|
|
258 |
// (this is since the last timer0ClearOverflowCount() command was called) |
|
|
259 |
return Timer0Reg0; |
|
|
260 |
} |
|
|
261 |
|
|
|
262 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
263 |
void timer2ClearOverflowCount(void) |
|
|
264 |
{ |
|
|
265 |
// clear the timer overflow counter registers |
|
|
266 |
Timer2Reg0 = 0; // initialize time registers |
|
|
267 |
} |
|
|
268 |
|
|
|
269 |
long timer2GetOverflowCount(void) |
|
|
270 |
{ |
|
|
271 |
// return the current timer overflow count |
|
|
272 |
// (this is since the last timer2ClearOverflowCount() command was called) |
|
|
273 |
return Timer2Reg0; |
|
|
274 |
} |
|
|
275 |
#endif |
|
|
276 |
|
|
|
277 |
void timer1PWMInit(u08 bitRes) |
|
|
278 |
{ |
|
|
279 |
// configures timer1 for use with PWM output |
|
|
280 |
// on OC1A and OC1B pins |
|
|
281 |
|
|
|
282 |
// enable timer1 as 8,9,10bit PWM |
|
|
283 |
if(bitRes == 9) |
|
|
284 |
{ // 9bit mode |
|
|
285 |
sbi(TCCR1A,PWM11); |
|
|
286 |
cbi(TCCR1A,PWM10); |
|
|
287 |
} |
|
|
288 |
else if( bitRes == 10 ) |
|
|
289 |
{ // 10bit mode |
|
|
290 |
sbi(TCCR1A,PWM11); |
|
|
291 |
sbi(TCCR1A,PWM10); |
|
|
292 |
} |
|
|
293 |
else |
|
|
294 |
{ // default 8bit mode |
|
|
295 |
cbi(TCCR1A,PWM11); |
|
|
296 |
sbi(TCCR1A,PWM10); |
|
|
297 |
} |
|
|
298 |
|
|
|
299 |
// clear output compare value A |
|
|
300 |
outb(OCR1AH, 0); |
|
|
301 |
outb(OCR1AL, 0); |
|
|
302 |
// clear output compare value B |
|
|
303 |
outb(OCR1BH, 0); |
|
|
304 |
outb(OCR1BL, 0); |
|
|
305 |
} |
|
|
306 |
|
|
|
307 |
#ifdef WGM10 |
|
|
308 |
// include support for arbitrary top-count PWM |
|
|
309 |
// on new AVR processors that support it |
|
|
310 |
void timer1PWMInitICR(u16 topcount) |
|
|
311 |
{ |
|
|
312 |
// set PWM mode with ICR top-count |
|
|
313 |
cbi(TCCR1A,WGM10); |
|
|
314 |
sbi(TCCR1A,WGM11); |
|
|
315 |
sbi(TCCR1B,WGM12); |
|
|
316 |
sbi(TCCR1B,WGM13); |
|
|
317 |
|
|
|
318 |
// set top count value |
|
|
319 |
ICR1 = topcount; |
|
|
320 |
|
|
|
321 |
// clear output compare value A |
|
|
322 |
OCR1A = 0; |
|
|
323 |
// clear output compare value B |
|
|
324 |
OCR1B = 0; |
|
|
325 |
|
|
|
326 |
} |
|
|
327 |
#endif |
|
|
328 |
|
|
|
329 |
void timer1PWMOff(void) |
|
|
330 |
{ |
|
|
331 |
// turn off timer1 PWM mode |
|
|
332 |
cbi(TCCR1A,PWM11); |
|
|
333 |
cbi(TCCR1A,PWM10); |
|
|
334 |
// set PWM1A/B (OutputCompare action) to none |
|
|
335 |
timer1PWMAOff(); |
|
|
336 |
timer1PWMBOff(); |
|
|
337 |
} |
|
|
338 |
|
|
|
339 |
void timer1PWMAOn(void) |
|
|
340 |
{ |
|
|
341 |
// turn on channel A (OC1A) PWM output |
|
|
342 |
// set OC1A as non-inverted PWM |
|
|
343 |
sbi(TCCR1A,COM1A1); |
|
|
344 |
cbi(TCCR1A,COM1A0); |
|
|
345 |
} |
|
|
346 |
|
|
|
347 |
void timer1PWMBOn(void) |
|
|
348 |
{ |
|
|
349 |
// turn on channel B (OC1B) PWM output |
|
|
350 |
// set OC1B as non-inverted PWM |
|
|
351 |
sbi(TCCR1A,COM1B1); |
|
|
352 |
cbi(TCCR1A,COM1B0); |
|
|
353 |
} |
|
|
354 |
|
|
|
355 |
void timer1PWMAOff(void) |
|
|
356 |
{ |
|
|
357 |
// turn off channel A (OC1A) PWM output |
|
|
358 |
// set OC1A (OutputCompare action) to none |
|
|
359 |
cbi(TCCR1A,COM1A1); |
|
|
360 |
cbi(TCCR1A,COM1A0); |
|
|
361 |
} |
|
|
362 |
|
|
|
363 |
void timer1PWMBOff(void) |
|
|
364 |
{ |
|
|
365 |
// turn off channel B (OC1B) PWM output |
|
|
366 |
// set OC1B (OutputCompare action) to none |
|
|
367 |
cbi(TCCR1A,COM1B1); |
|
|
368 |
cbi(TCCR1A,COM1B0); |
|
|
369 |
} |
|
|
370 |
|
|
|
371 |
void timer1PWMASet(u16 pwmDuty) |
|
|
372 |
{ |
|
|
373 |
// set PWM (output compare) duty for channel A |
|
|
374 |
// this PWM output is generated on OC1A pin |
|
|
375 |
// NOTE: pwmDuty should be in the range 0-255 for 8bit PWM |
|
|
376 |
// pwmDuty should be in the range 0-511 for 9bit PWM |
|
|
377 |
// pwmDuty should be in the range 0-1023 for 10bit PWM |
|
|
378 |
//outp( (pwmDuty>>8), OCR1AH); // set the high 8bits of OCR1A |
|
|
379 |
//outp( (pwmDuty&0x00FF), OCR1AL); // set the low 8bits of OCR1A |
|
|
380 |
OCR1A = pwmDuty; |
|
|
381 |
} |
|
|
382 |
|
|
|
383 |
void timer1PWMBSet(u16 pwmDuty) |
|
|
384 |
{ |
|
|
385 |
// set PWM (output compare) duty for channel B |
|
|
386 |
// this PWM output is generated on OC1B pin |
|
|
387 |
// NOTE: pwmDuty should be in the range 0-255 for 8bit PWM |
|
|
388 |
// pwmDuty should be in the range 0-511 for 9bit PWM |
|
|
389 |
// pwmDuty should be in the range 0-1023 for 10bit PWM |
|
|
390 |
//outp( (pwmDuty>>8), OCR1BH); // set the high 8bits of OCR1B |
|
|
391 |
//outp( (pwmDuty&0x00FF), OCR1BL); // set the low 8bits of OCR1B |
|
|
392 |
OCR1B = pwmDuty; |
|
|
393 |
} |
|
|
394 |
|
|
|
395 |
//! Interrupt handler for tcnt0 overflow interrupt |
|
|
396 |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW0) |
|
|
397 |
{ |
|
|
398 |
Timer0Reg0++; // increment low-order counter |
|
|
399 |
|
|
|
400 |
// increment pause counter |
|
|
401 |
TimerPauseReg++; |
|
|
402 |
|
|
|
403 |
// if a user function is defined, execute it too |
|
|
404 |
if(TimerIntFunc[TIMER0OVERFLOW_INT]) |
|
|
405 |
TimerIntFunc[TIMER0OVERFLOW_INT](); |
|
|
406 |
} |
|
|
407 |
|
|
|
408 |
//! Interrupt handler for tcnt1 overflow interrupt |
|
|
409 |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW1) |
|
|
410 |
{ |
|
|
411 |
// if a user function is defined, execute it |
|
|
412 |
if(TimerIntFunc[TIMER1OVERFLOW_INT]) |
|
|
413 |
TimerIntFunc[TIMER1OVERFLOW_INT](); |
|
|
414 |
} |
|
|
415 |
|
|
|
416 |
#ifdef TCNT2 // support timer2 only if it exists |
|
|
417 |
//! Interrupt handler for tcnt2 overflow interrupt |
|
|
418 |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW2) |
|
|
419 |
{ |
|
|
420 |
Timer2Reg0++; // increment low-order counter |
|
|
421 |
|
|
|
422 |
// if a user function is defined, execute it |
|
|
423 |
if(TimerIntFunc[TIMER2OVERFLOW_INT]) |
|
|
424 |
TimerIntFunc[TIMER2OVERFLOW_INT](); |
|
|
425 |
} |
|
|
426 |
#endif |
|
|
427 |
|
|
|
428 |
#ifdef OCR0 |
|
|
429 |
// include support for Output Compare 0 for new AVR processors that support it |
|
|
430 |
//! Interrupt handler for OutputCompare0 match (OC0) interrupt |
|
|
431 |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE0) |
|
|
432 |
{ |
|
|
433 |
// if a user function is defined, execute it |
|
|
434 |
if(TimerIntFunc[TIMER0OUTCOMPARE_INT]) |
|
|
435 |
TimerIntFunc[TIMER0OUTCOMPARE_INT](); |
|
|
436 |
} |
|
|
437 |
#endif |
|
|
438 |
|
|
|
439 |
//! Interrupt handler for CutputCompare1A match (OC1A) interrupt |
|
|
440 |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1A) |
|
|
441 |
{ |
|
|
442 |
// if a user function is defined, execute it |
|
|
443 |
if(TimerIntFunc[TIMER1OUTCOMPAREA_INT]) |
|
|
444 |
TimerIntFunc[TIMER1OUTCOMPAREA_INT](); |
|
|
445 |
} |
|
|
446 |
|
|
|
447 |
//! Interrupt handler for OutputCompare1B match (OC1B) interrupt |
|
|
448 |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1B) |
|
|
449 |
{ |
|
|
450 |
// if a user function is defined, execute it |
|
|
451 |
if(TimerIntFunc[TIMER1OUTCOMPAREB_INT]) |
|
|
452 |
TimerIntFunc[TIMER1OUTCOMPAREB_INT](); |
|
|
453 |
} |
|
|
454 |
|
|
|
455 |
//! Interrupt handler for InputCapture1 (IC1) interrupt |
|
|
456 |
TIMER_INTERRUPT_HANDLER(SIG_INPUT_CAPTURE1) |
|
|
457 |
{ |
|
|
458 |
// if a user function is defined, execute it |
|
|
459 |
if(TimerIntFunc[TIMER1INPUTCAPTURE_INT]) |
|
|
460 |
TimerIntFunc[TIMER1INPUTCAPTURE_INT](); |
|
|
461 |
} |
|
|
462 |
|
|
|
463 |
//! Interrupt handler for OutputCompare2 match (OC2) interrupt |
|
|
464 |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE2) |
|
|
465 |
{ |
|
|
466 |
// if a user function is defined, execute it |
|
|
467 |
if(TimerIntFunc[TIMER2OUTCOMPARE_INT]) |
|
|
468 |
TimerIntFunc[TIMER2OUTCOMPARE_INT](); |
|
|
469 |
} |