Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Newer
Older
100644 690 lines (604 sloc) 17.826 kB
e9d0008 @lanwan inherited avrlib
authored
1 /*! \file timer128.c \brief System Timer function library for Mega128. */
2 //*****************************************************************************
3 //
4 // File Name : 'timer128.c'
5 // Title : System Timer function library for Mega128
6 // Author : Pascal Stang - Copyright (C) 2000-2003
7 // Created : 11/22/2000
8 // Revised : 02/24/2003
9 // Version : 1.2
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 "timer128.h"
25
26 // Program ROM constants
27 // the prescale division values stored in order of timer control register index
28 // STOP, CLK, CLK/8, CLK/64, CLK/256, CLK/1024
29 unsigned short __attribute__ ((progmem)) TimerPrescaleFactor[] = {0,1,8,64,256,1024};
30 // the prescale division values stored in order of timer control register index
31 // STOP, CLK, CLK/8, CLK/32, CLK/64, CLK/128, CLK/256, CLK/1024
32 unsigned short __attribute__ ((progmem)) TimerRTCPrescaleFactor[] = {0,1,8,32,64,128,256,1024};
33
34 // Global variables
35 // time registers
36 volatile unsigned long TimerPauseReg;
37 volatile unsigned long Timer0Reg0;
38 volatile unsigned long Timer0Reg1;
39 volatile unsigned long Timer2Reg0;
40 volatile unsigned long Timer2Reg1;
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 uint8_t 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 timer2Init();
87 timer3Init();
88 // enable interrupts
89 sei();
90 }
91
92 void timer0Init()
93 {
94 // initialize timer 0
95 timer0SetPrescaler( TIMER0PRESCALE ); // set prescaler
96 outb(TCNT0, 0); // reset TCNT0
97 sbi(TIMSK, TOIE0); // enable TCNT0 overflow interrupt
98
99 timer0ClearOverflowCount(); // initialize time registers
100 }
101
102 void timer1Init(void)
103 {
104 // initialize timer 1
105 timer1SetPrescaler( TIMER1PRESCALE ); // set prescaler
106 outb(TCNT1H, 0); // reset TCNT1
107 outb(TCNT1L, 0);
108 sbi(TIMSK, TOIE1); // enable TCNT1 overflow
109 }
110
111 void timer2Init(void)
112 {
113 // initialize timer 2
114 timer2SetPrescaler( TIMER2PRESCALE ); // set prescaler
115 outb(TCNT2, 0); // reset TCNT2
116 sbi(TIMSK, TOIE2); // enable TCNT2 overflow
117
118 timer2ClearOverflowCount(); // initialize time registers
119 }
120
121 void timer3Init(void)
122 {
123 // initialize timer 3
124 timer3SetPrescaler( TIMER3PRESCALE ); // set prescaler
125 outb(TCNT3H, 0); // reset TCNT3
126 outb(TCNT3L, 0);
127 sbi(ETIMSK, TOIE3); // enable TCNT3 overflow
128 }
129
130 void timer0SetPrescaler(uint8_t prescale)
131 {
132 // set prescaler on timer 0
133 outb(TCCR0, (inb(TCCR0) & ~TIMER_PRESCALE_MASK) | prescale);
134 }
135
136 void timer1SetPrescaler(uint8_t prescale)
137 {
138 // set prescaler on timer 1
139 outb(TCCR1B, (inb(TCCR1B) & ~TIMER_PRESCALE_MASK) | prescale);
140 }
141
142 void timer2SetPrescaler(uint8_t prescale)
143 {
144 // set prescaler on timer 2
145 outb(TCCR2, (inb(TCCR2) & ~TIMER_PRESCALE_MASK) | prescale);
146 }
147
148 void timer3SetPrescaler(uint8_t prescale)
149 {
150 // set prescaler on timer 2
151 outb(TCCR3B, (inb(TCCR3B) & ~TIMER_PRESCALE_MASK) | prescale);
152 }
153
154 uint16_t timer0GetPrescaler(void)
155 {
156 // get the current prescaler setting
157 return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR0) & TIMER_PRESCALE_MASK)));
158 }
159
160 uint16_t timer1GetPrescaler(void)
161 {
162 // get the current prescaler setting
163 return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR1B) & TIMER_PRESCALE_MASK)));
164 }
165
166 uint16_t timer2GetPrescaler(void)
167 {
168 // get the current prescaler setting
169 return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR2) & TIMER_PRESCALE_MASK)));
170 }
171
172 uint16_t timer3GetPrescaler(void)
173 {
174 // get the current prescaler setting
175 return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR3B) & TIMER_PRESCALE_MASK)));
176 }
177
178 void timerAttach(uint8_t interruptNum, void (*userFunc)(void) )
179 {
180 // make sure the interrupt number is within bounds
181 if(interruptNum < TIMER_NUM_INTERRUPTS)
182 {
183 // set the interrupt function to run
184 // the supplied user's function
185 TimerIntFunc[interruptNum] = userFunc;
186 }
187 }
188
189 void timerDetach(uint8_t interruptNum)
190 {
191 // make sure the interrupt number is within bounds
192 if(interruptNum < TIMER_NUM_INTERRUPTS)
193 {
194 // set the interrupt function to run nothing
195 TimerIntFunc[interruptNum] = 0;
196 }
197 }
198
199 void timerPause(unsigned short pause_ms)
200 {
201 // pauses for exactly <pause_ms> number of milliseconds
202 uint8_t timerThres;
203 uint32_t ticRateHz;
204 uint32_t pause;
205
206 // capture current pause timer value
207 timerThres = inb(TCNT2);
208 // reset pause timer overflow count
209 TimerPauseReg = 0;
210 // calculate delay for [pause_ms] milliseconds
211 // prescaler division = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR2)))
212 ticRateHz = F_CPU/timer2GetPrescaler();
213 // precision management
214 // prevent overflow and precision underflow
215 // -could add more conditions to improve accuracy
216 if( ((ticRateHz < 429497) && (pause_ms <= 10000)) )
217 pause = (pause_ms*ticRateHz)/1000;
218 else
219 pause = pause_ms*(ticRateHz/1000);
220
221 // loop until time expires
222 while( ((TimerPauseReg<<8) | inb(TCNT2)) < (pause+timerThres) )
223 {
224 if( TimerPauseReg < (pause>>8));
225 {
226 // save power by idling the processor
227 set_sleep_mode(SLEEP_MODE_IDLE);
228 sleep_mode();
229 }
230 }
231 }
232
233 void timer0ClearOverflowCount(void)
234 {
235 // clear the timer overflow counter registers
236 Timer0Reg0 = 0; // initialize time registers
237 Timer0Reg1 = 0; // initialize time registers
238 }
239
240 long timer0GetOverflowCount(void)
241 {
242 // return the current timer overflow count
243 // (this is since the last timer0ClearOverflowCount() command was called)
244 return Timer0Reg0;
245 }
246
247 void timer2ClearOverflowCount(void)
248 {
249 // clear the timer overflow counter registers
250 Timer2Reg0 = 0; // initialize time registers
251 Timer2Reg1 = 0; // initialize time registers
252 }
253
254 long timer2GetOverflowCount(void)
255 {
256 // return the current timer overflow count
257 // (this is since the last timer2ClearOverflowCount() command was called)
258 return Timer2Reg0;
259 }
260
261
262 void timer1PWMInit(uint8_t bitRes)
263 {
264 // configures timer1 for use with PWM output
265 // on pins OC1A, OC1B, and OC1C
266
267 // enable Timer1 as 8,9,10bit PWM
268 if(bitRes == 9)
269 { // 9bit mode
270 sbi(TCCR1A,WGMA1);
271 cbi(TCCR1A,WGMA0);
272 }
273 else if( bitRes == 10 )
274 { // 10bit mode
275 sbi(TCCR1A,WGMA1);
276 sbi(TCCR1A,WGMA0);
277 }
278 else
279 { // default 8bit mode
280 cbi(TCCR1A,WGMA1);
281 sbi(TCCR1A,WGMA0);
282 }
283
284 // set clear-timer-on-compare-match
285 //cbi(TCCR1B,CTC1);
286 // clear output compare value A
287 outb(OCR1AH, 0);
288 outb(OCR1AL, 0);
289 // clear output compare value B
290 outb(OCR1BH, 0);
291 outb(OCR1BL, 0);
292 // clear output compare value C
293 outb(OCR1CH, 0);
294 outb(OCR1CL, 0);
295 }
296
297 void timer1PWMInitICR(uint16_t topcount)
298 {
299 // set PWM mode with ICR top-count
300 cbi(TCCR1A,WGM10);
301 sbi(TCCR1A,WGM11);
302 sbi(TCCR1B,WGM12);
303 sbi(TCCR1B,WGM13);
304
305 // set top count value
306 ICR1H = (uint8_t)(topcount>>8);
307 ICR1L = (uint8_t)topcount;
308
309 // clear output compare value A
310 outb(OCR1AH, 0);
311 outb(OCR1AL, 0);
312 // clear output compare value B
313 outb(OCR1BH, 0);
314 outb(OCR1BL, 0);
315 // clear output compare value C
316 outb(OCR1CH, 0);
317 outb(OCR1CL, 0);
318 }
319
320 void timer1PWMOff(void)
321 {
322 // turn off PWM on Timer1
323 cbi(TCCR1A,WGMA1);
324 cbi(TCCR1A,WGMA0);
325 // clear (disable) clear-timer-on-compare-match
326 //cbi(TCCR1B,CTC1);
327 // set PWM1A/B/C (OutputCompare action) to none
328 timer1PWMAOff();
329 timer1PWMBOff();
330 timer1PWMCOff();
331 }
332
333 void timer1PWMAOn(void)
334 {
335 // turn on channel A (OC1A) PWM output
336 // set OC1A as non-inverted PWM
337 sbi(TCCR1A,COMA1);
338 cbi(TCCR1A,COMA0);
339 }
340
341 void timer1PWMBOn(void)
342 {
343 // turn on channel B (OC1B) PWM output
344 // set OC1B as non-inverted PWM
345 sbi(TCCR1A,COMB1);
346 cbi(TCCR1A,COMB0);
347 }
348
349 void timer1PWMCOn(void)
350 {
351 // turn on channel C (OC1C) PWM output
352 // set OC1C as non-inverted PWM
353 sbi(TCCR1A,COMC1);
354 cbi(TCCR1A,COMC0);
355 }
356
357 void timer1PWMAOff(void)
358 {
359 // turn off channel A (OC1A) PWM output
360 // set OC1A (OutputCompare action) to none
361 cbi(TCCR1A,COMA1);
362 cbi(TCCR1A,COMA0);
363 }
364
365 void timer1PWMBOff(void)
366 {
367 // turn off channel B (OC1B) PWM output
368 // set OC1B (OutputCompare action) to none
369 cbi(TCCR1A,COMB1);
370 cbi(TCCR1A,COMB0);
371 }
372
373 void timer1PWMCOff(void)
374 {
375 // turn off channel C (OC1C) PWM output
376 // set OC1C (OutputCompare action) to none
377 cbi(TCCR1A,COMC1);
378 cbi(TCCR1A,COMC0);
379 }
380
381 void timer1PWMASet(uint16_t pwmDuty)
382 {
383 // set PWM (output compare) duty for channel A
384 // this PWM output is generated on OC1A pin
385 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
386 // pwmDuty should be in the range 0-511 for 9bit PWM
387 // pwmDuty should be in the range 0-1023 for 10bit PWM
388 outb(OCR1AH, (pwmDuty>>8)); // set the high 8bits of OCR1A
389 outb(OCR1AL, (pwmDuty&0x00FF)); // set the low 8bits of OCR1A
390 }
391
392 void timer1PWMBSet(uint16_t pwmDuty)
393 {
394 // set PWM (output compare) duty for channel B
395 // this PWM output is generated on OC1B pin
396 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
397 // pwmDuty should be in the range 0-511 for 9bit PWM
398 // pwmDuty should be in the range 0-1023 for 10bit PWM
399 outb(OCR1BH, (pwmDuty>>8)); // set the high 8bits of OCR1B
400 outb(OCR1BL, (pwmDuty&0x00FF)); // set the low 8bits of OCR1B
401 }
402
403 void timer1PWMCSet(uint16_t pwmDuty)
404 {
405 // set PWM (output compare) duty for channel C
406 // this PWM output is generated on OC1C pin
407 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
408 // pwmDuty should be in the range 0-511 for 9bit PWM
409 // pwmDuty should be in the range 0-1023 for 10bit PWM
410 outb(OCR1CH, (pwmDuty>>8)); // set the high 8bits of OCR1C
411 outb(OCR1CL, (pwmDuty&0x00FF)); // set the low 8bits of OCR1C
412 }
413
414
415 void timer3PWMInit(uint8_t bitRes)
416 {
417 // configures timer1 for use with PWM output
418 // on pins OC3A, OC3B, and OC3C
419
420 // enable Timer3 as 8,9,10bit PWM
421 if(bitRes == 9)
422 { // 9bit mode
423 sbi(TCCR3A,WGMA1);
424 cbi(TCCR3A,WGMA0);
425 }
426 else if( bitRes == 10 )
427 { // 10bit mode
428 sbi(TCCR3A,WGMA1);
429 sbi(TCCR3A,WGMA0);
430 }
431 else
432 { // default 8bit mode
433 cbi(TCCR3A,WGMA1);
434 sbi(TCCR3A,WGMA0);
435 }
436
437 // set clear-timer-on-compare-match
438 //cbi(TCCR3B,CTC1);
439 // clear output compare value A
440 outb(OCR3AH, 0);
441 outb(OCR3AL, 0);
442 // clear output compare value B
443 outb(OCR3BH, 0);
444 outb(OCR3BL, 0);
445 // clear output compare value B
446 outb(OCR3CH, 0);
447 outb(OCR3CL, 0);
448 }
449
450 void timer3PWMInitICR(uint16_t topcount)
451 {
452 // set PWM mode with ICR top-count
453 cbi(TCCR3A,WGM30);
454 sbi(TCCR3A,WGM31);
455 sbi(TCCR3B,WGM32);
456 sbi(TCCR3B,WGM33);
457
458 // set top count value
459 ICR3H = (uint8_t)(topcount>>8);
460 ICR3L = (uint8_t)topcount;
461
462 // clear output compare value A
463 outb(OCR3AH, 0);
464 outb(OCR3AL, 0);
465 // clear output compare value B
466 outb(OCR3BH, 0);
467 outb(OCR3BL, 0);
468 // clear output compare value C
469 outb(OCR3CH, 0);
470 outb(OCR3CL, 0);
471 }
472
473 void timer3PWMOff(void)
474 {
475 // turn off PWM mode on Timer3
476 cbi(TCCR3A,WGMA1);
477 cbi(TCCR3A,WGMA0);
478 // clear (disable) clear-timer-on-compare-match
479 //cbi(TCCR3B,CTC1);
480 // set OC3A/B/C (OutputCompare action) to none
481 timer3PWMAOff();
482 timer3PWMBOff();
483 timer3PWMCOff();
484 }
485
486 void timer3PWMAOn(void)
487 {
488 // turn on channel A (OC3A) PWM output
489 // set OC3A as non-inverted PWM
490 sbi(TCCR3A,COMA1);
491 cbi(TCCR3A,COMA0);
492 }
493
494 void timer3PWMBOn(void)
495 {
496 // turn on channel B (OC3B) PWM output
497 // set OC3B as non-inverted PWM
498 sbi(TCCR3A,COMB1);
499 cbi(TCCR3A,COMB0);
500 }
501
502 void timer3PWMCOn(void)
503 {
504 // turn on channel C (OC3C) PWM output
505 // set OC3C as non-inverted PWM
506 sbi(TCCR3A,COMC1);
507 cbi(TCCR3A,COMC0);
508 }
509
510 void timer3PWMAOff(void)
511 {
512 // turn off channel A (OC3A) PWM output
513 // set OC3A (OutputCompare action) to none
514 cbi(TCCR3A,COMA1);
515 cbi(TCCR3A,COMA0);
516 }
517
518 void timer3PWMBOff(void)
519 {
520 // turn off channel B (OC3B) PWM output
521 // set OC3B (OutputCompare action) to none
522 cbi(TCCR3A,COMB1);
523 cbi(TCCR3A,COMB0);
524 }
525
526 void timer3PWMCOff(void)
527 {
528 // turn off channel C (OC3C) PWM output
529 // set OC3C (OutputCompare action) to none
530 cbi(TCCR3A,COMC1);
531 cbi(TCCR3A,COMC0);
532 }
533
534 void timer3PWMASet(uint16_t pwmDuty)
535 {
536 // set PWM (output compare) duty for channel A
537 // this PWM output is generated on OC3A pin
538 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
539 // pwmDuty should be in the range 0-511 for 9bit PWM
540 // pwmDuty should be in the range 0-1023 for 10bit PWM
541 outb(OCR3AH, (pwmDuty>>8)); // set the high 8bits of OCR3A
542 outb(OCR3AL, (pwmDuty&0x00FF)); // set the low 8bits of OCR3A
543 }
544
545 void timer3PWMBSet(uint16_t pwmDuty)
546 {
547 // set PWM (output compare) duty for channel B
548 // this PWM output is generated on OC3B pin
549 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
550 // pwmDuty should be in the range 0-511 for 9bit PWM
551 // pwmDuty should be in the range 0-1023 for 10bit PWM
552 outb(OCR3BH, (pwmDuty>>8)); // set the high 8bits of OCR3B
553 outb(OCR3BL, (pwmDuty&0x00FF)); // set the low 8bits of OCR3B
554 }
555
556 void timer3PWMCSet(uint16_t pwmDuty)
557 {
558 // set PWM (output compare) duty for channel B
559 // this PWM output is generated on OC3C pin
560 // NOTE: pwmDuty should be in the range 0-255 for 8bit PWM
561 // pwmDuty should be in the range 0-511 for 9bit PWM
562 // pwmDuty should be in the range 0-1023 for 10bit PWM
563 outb(OCR3CH, (pwmDuty>>8)); // set the high 8bits of OCR3C
564 outb(OCR3CL, (pwmDuty&0x00FF)); // set the low 8bits of OCR3C
565 }
566
567
568 //! Interrupt handler for tcnt0 overflow interrupt
569 TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW0)
570 {
571 Timer0Reg0++; // increment low-order counter
572 if(!Timer0Reg0) // if low-order counter rollover
573 Timer0Reg1++; // increment high-order counter
574
575 // if a user function is defined, execute it too
576 if(TimerIntFunc[TIMER0OVERFLOW_INT])
577 TimerIntFunc[TIMER0OVERFLOW_INT]();
578 }
579
580 //! Interrupt handler for Timer1 overflow interrupt
581 TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW1)
582 {
583 // if a user function is defined, execute it
584 if(TimerIntFunc[TIMER1OVERFLOW_INT])
585 TimerIntFunc[TIMER1OVERFLOW_INT]();
586 }
587
588 //! Interrupt handler for Timer2 overflow interrupt
589 TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW2)
590 {
591 Timer2Reg0++; // increment low-order counter
592 if(!Timer2Reg0) // if low-order counter rollover
593 Timer2Reg1++; // increment high-order counter
594
595 // increment pause counter
596 TimerPauseReg++;
597
598 // if a user function is defined, execute it
599 if(TimerIntFunc[TIMER2OVERFLOW_INT])
600 TimerIntFunc[TIMER2OVERFLOW_INT]();
601 }
602
603 //! Interrupt handler for Timer3 overflow interrupt
604 TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW3)
605 {
606 // if a user function is defined, execute it
607 if(TimerIntFunc[TIMER3OVERFLOW_INT])
608 TimerIntFunc[TIMER3OVERFLOW_INT]();
609 }
610
611 //! Interrupt handler for OutputCompare0 match (OC0) interrupt
612 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE0)
613 {
614 // if a user function is defined, execute it
615 if(TimerIntFunc[TIMER0OUTCOMPARE_INT])
616 TimerIntFunc[TIMER0OUTCOMPARE_INT]();
617 }
618
619 //! Interrupt handler for OutputCompare1A match (OC1A) interrupt
620 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1A)
621 {
622 // if a user function is defined, execute it
623 if(TimerIntFunc[TIMER1OUTCOMPAREA_INT])
624 TimerIntFunc[TIMER1OUTCOMPAREA_INT]();
625 }
626
627 //! Interrupt handler for OutputCompare1B match (OC1B) interrupt
628 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1B)
629 {
630 // if a user function is defined, execute it
631 if(TimerIntFunc[TIMER1OUTCOMPAREB_INT])
632 TimerIntFunc[TIMER1OUTCOMPAREB_INT]();
633 }
634
635 //! Interrupt handler for OutputCompare1C match (OC1C) interrupt
636 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1C)
637 {
638 // if a user function is defined, execute it
639 if(TimerIntFunc[TIMER1OUTCOMPAREC_INT])
640 TimerIntFunc[TIMER1OUTCOMPAREC_INT]();
641 }
642
643 //! Interrupt handler for InputCapture1(IC1) interrupt
644 TIMER_INTERRUPT_HANDLER(SIG_INPUT_CAPTURE1)
645 {
646 // if a user function is defined, execute it
647 if(TimerIntFunc[TIMER1INPUTCAPTURE_INT])
648 TimerIntFunc[TIMER1INPUTCAPTURE_INT]();
649 }
650
651 //! Interrupt handler for OutputCompare2 match (OC2) interrupt
652 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE2)
653 {
654 // if a user function is defined, execute it
655 if(TimerIntFunc[TIMER2OUTCOMPARE_INT])
656 TimerIntFunc[TIMER2OUTCOMPARE_INT]();
657 }
658
659 //! Interrupt handler for OutputCompare3A match (OC3A) interrupt
660 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE3A)
661 {
662 // if a user function is defined, execute it
663 if(TimerIntFunc[TIMER3OUTCOMPAREA_INT])
664 TimerIntFunc[TIMER3OUTCOMPAREA_INT]();
665 }
666
667 //! Interrupt handler for OutputCompare3B match (OC3B) interrupt
668 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE3B)
669 {
670 // if a user function is defined, execute it
671 if(TimerIntFunc[TIMER3OUTCOMPAREB_INT])
672 TimerIntFunc[TIMER3OUTCOMPAREB_INT]();
673 }
674
675 //! Interrupt handler for OutputCompare3C match (OC3C) interrupt
676 TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE3C)
677 {
678 // if a user function is defined, execute it
679 if(TimerIntFunc[TIMER3OUTCOMPAREC_INT])
680 TimerIntFunc[TIMER3OUTCOMPAREC_INT]();
681 }
682
683 //! Interrupt handler for InputCapture3 (IC3) interrupt
684 TIMER_INTERRUPT_HANDLER(SIG_INPUT_CAPTURE3)
685 {
686 // if a user function is defined, execute it
687 if(TimerIntFunc[TIMER3INPUTCAPTURE_INT])
688 TimerIntFunc[TIMER3INPUTCAPTURE_INT]();
689 }
Something went wrong with that request. Please try again.