0,0 → 1,469 |
/*! \file timer.c \brief System Timer function library. */ |
//***************************************************************************** |
// |
// File Name : 'timer.c' |
// Title : System Timer function library |
// Author : Pascal Stang - Copyright (C) 2000-2002 |
// Created : 11/22/2000 |
// Revised : 07/09/2003 |
// Version : 1.1 |
// Target MCU : Atmel AVR Series |
// Editor Tabs : 4 |
// |
// This code is distributed under the GNU Public License |
// which can be found at http://www.gnu.org/licenses/gpl.txt |
// |
//***************************************************************************** |
|
#include <avr/io.h> |
#include <avr/interrupt.h> |
#include <avr/pgmspace.h> |
#include <avr/sleep.h> |
|
#include "global.h" |
#include "timer.h" |
|
#include "rprintf.h" |
|
// Program ROM constants |
// the prescale division values stored in order of timer control register index |
// STOP, CLK, CLK/8, CLK/64, CLK/256, CLK/1024 |
unsigned short __attribute__ ((progmem)) TimerPrescaleFactor[] = {0,1,8,64,256,1024}; |
// the prescale division values stored in order of timer control register index |
// STOP, CLK, CLK/8, CLK/32, CLK/64, CLK/128, CLK/256, CLK/1024 |
unsigned short __attribute__ ((progmem)) TimerRTCPrescaleFactor[] = {0,1,8,32,64,128,256,1024}; |
|
// Global variables |
// time registers |
volatile unsigned long TimerPauseReg; |
volatile unsigned long Timer0Reg0; |
volatile unsigned long Timer2Reg0; |
|
typedef void (*voidFuncPtr)(void); |
volatile static voidFuncPtr TimerIntFunc[TIMER_NUM_INTERRUPTS]; |
|
// delay for a minimum of <us> microseconds |
// the time resolution is dependent on the time the loop takes |
// e.g. with 4Mhz and 5 cycles per loop, the resolution is 1.25 us |
void delay_us(unsigned short time_us) |
{ |
unsigned short delay_loops; |
register unsigned short i; |
|
delay_loops = (time_us+3)/5*CYCLES_PER_US; // +3 for rounding up (dirty) |
|
// one loop takes 5 cpu cycles |
for (i=0; i < delay_loops; i++) {}; |
} |
/* |
void delay_ms(unsigned char time_ms) |
{ |
unsigned short delay_count = F_CPU / 4000; |
|
unsigned short cnt; |
asm volatile ("\n" |
"L_dl1%=:\n\t" |
"mov %A0, %A2\n\t" |
"mov %B0, %B2\n" |
"L_dl2%=:\n\t" |
"sbiw %A0, 1\n\t" |
"brne L_dl2%=\n\t" |
"dec %1\n\t" "brne L_dl1%=\n\t":"=&w" (cnt) |
:"r"(time_ms), "r"((unsigned short) (delay_count)) |
); |
} |
*/ |
void timerInit(void) |
{ |
u08 intNum; |
// detach all user functions from interrupts |
for(intNum=0; intNum<TIMER_NUM_INTERRUPTS; intNum++) |
timerDetach(intNum); |
|
// initialize all timers |
timer0Init(); |
timer1Init(); |
#ifdef TCNT2 // support timer2 only if it exists |
timer2Init(); |
#endif |
// enable interrupts |
sei(); |
} |
|
void timer0Init() |
{ |
// initialize timer 0 |
timer0SetPrescaler( TIMER0PRESCALE ); // set prescaler |
outb(TCNT0, 0); // reset TCNT0 |
sbi(TIMSK, TOIE0); // enable TCNT0 overflow interrupt |
|
timer0ClearOverflowCount(); // initialize time registers |
} |
|
void timer1Init(void) |
{ |
// initialize timer 1 |
timer1SetPrescaler( TIMER1PRESCALE ); // set prescaler |
outb(TCNT1H, 0); // reset TCNT1 |
outb(TCNT1L, 0); |
sbi(TIMSK, TOIE1); // enable TCNT1 overflow |
} |
|
#ifdef TCNT2 // support timer2 only if it exists |
void timer2Init(void) |
{ |
// initialize timer 2 |
timer2SetPrescaler( TIMER2PRESCALE ); // set prescaler |
outb(TCNT2, 0); // reset TCNT2 |
sbi(TIMSK, TOIE2); // enable TCNT2 overflow |
|
timer2ClearOverflowCount(); // initialize time registers |
} |
#endif |
|
void timer0SetPrescaler(u08 prescale) |
{ |
// set prescaler on timer 0 |
outb(TCCR0, (inb(TCCR0) & ~TIMER_PRESCALE_MASK) | prescale); |
} |
|
void timer1SetPrescaler(u08 prescale) |
{ |
// set prescaler on timer 1 |
outb(TCCR1B, (inb(TCCR1B) & ~TIMER_PRESCALE_MASK) | prescale); |
} |
|
#ifdef TCNT2 // support timer2 only if it exists |
void timer2SetPrescaler(u08 prescale) |
{ |
// set prescaler on timer 2 |
outb(TCCR2, (inb(TCCR2) & ~TIMER_PRESCALE_MASK) | prescale); |
} |
#endif |
|
u16 timer0GetPrescaler(void) |
{ |
// get the current prescaler setting |
return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR0) & TIMER_PRESCALE_MASK))); |
} |
|
u16 timer1GetPrescaler(void) |
{ |
// get the current prescaler setting |
return (pgm_read_word(TimerPrescaleFactor+(inb(TCCR1B) & TIMER_PRESCALE_MASK))); |
} |
|
#ifdef TCNT2 // support timer2 only if it exists |
u16 timer2GetPrescaler(void) |
{ |
//TODO: can we assume for all 3-timer AVR processors, |
// that timer2 is the RTC timer? |
|
// get the current prescaler setting |
return (pgm_read_word(TimerRTCPrescaleFactor+(inb(TCCR2) & TIMER_PRESCALE_MASK))); |
} |
#endif |
|
void timerAttach(u08 interruptNum, void (*userFunc)(void) ) |
{ |
// make sure the interrupt number is within bounds |
if(interruptNum < TIMER_NUM_INTERRUPTS) |
{ |
// set the interrupt function to run |
// the supplied user's function |
TimerIntFunc[interruptNum] = userFunc; |
} |
} |
|
void timerDetach(u08 interruptNum) |
{ |
// make sure the interrupt number is within bounds |
if(interruptNum < TIMER_NUM_INTERRUPTS) |
{ |
// set the interrupt function to run nothing |
TimerIntFunc[interruptNum] = 0; |
} |
} |
/* |
u32 timerMsToTics(u16 ms) |
{ |
// calculate the prescaler division rate |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
// calculate the number of timer tics in x milliseconds |
return (ms*(F_CPU/(prescaleDiv*256)))/1000; |
} |
|
u16 timerTicsToMs(u32 tics) |
{ |
// calculate the prescaler division rate |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
// calculate the number of milliseconds in x timer tics |
return (tics*1000*(prescaleDiv*256))/F_CPU; |
} |
*/ |
void timerPause(unsigned short pause_ms) |
{ |
// pauses for exactly <pause_ms> number of milliseconds |
u08 timerThres; |
u32 ticRateHz; |
u32 pause; |
|
// capture current pause timer value |
timerThres = inb(TCNT0); |
// reset pause timer overflow count |
TimerPauseReg = 0; |
// calculate delay for [pause_ms] milliseconds |
// prescaler division = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))) |
ticRateHz = F_CPU/timer0GetPrescaler(); |
// precision management |
// prevent overflow and precision underflow |
// -could add more conditions to improve accuracy |
if( ((ticRateHz < 429497) && (pause_ms <= 10000)) ) |
pause = (pause_ms*ticRateHz)/1000; |
else |
pause = pause_ms*(ticRateHz/1000); |
|
// loop until time expires |
while( ((TimerPauseReg<<8) | inb(TCNT0)) < (pause+timerThres) ) |
{ |
if( TimerPauseReg < (pause>>8)); |
{ |
// save power by idling the processor |
set_sleep_mode(SLEEP_MODE_IDLE); |
sleep_mode(); |
} |
} |
|
/* old inaccurate code, for reference |
|
// calculate delay for [pause_ms] milliseconds |
u16 prescaleDiv = 1<<(pgm_read_byte(TimerPrescaleFactor+inb(TCCR0))); |
u32 pause = (pause_ms*(F_CPU/(prescaleDiv*256)))/1000; |
|
TimerPauseReg = 0; |
while(TimerPauseReg < pause); |
|
*/ |
} |
|
void timer0ClearOverflowCount(void) |
{ |
// clear the timer overflow counter registers |
Timer0Reg0 = 0; // initialize time registers |
} |
|
long timer0GetOverflowCount(void) |
{ |
// return the current timer overflow count |
// (this is since the last timer0ClearOverflowCount() command was called) |
return Timer0Reg0; |
} |
|
#ifdef TCNT2 // support timer2 only if it exists |
void timer2ClearOverflowCount(void) |
{ |
// clear the timer overflow counter registers |
Timer2Reg0 = 0; // initialize time registers |
} |
|
long timer2GetOverflowCount(void) |
{ |
// return the current timer overflow count |
// (this is since the last timer2ClearOverflowCount() command was called) |
return Timer2Reg0; |
} |
#endif |
|
void timer1PWMInit(u08 bitRes) |
{ |
// configures timer1 for use with PWM output |
// on OC1A and OC1B pins |
|
// enable timer1 as 8,9,10bit PWM |
if(bitRes == 9) |
{ // 9bit mode |
sbi(TCCR1A,PWM11); |
cbi(TCCR1A,PWM10); |
} |
else if( bitRes == 10 ) |
{ // 10bit mode |
sbi(TCCR1A,PWM11); |
sbi(TCCR1A,PWM10); |
} |
else |
{ // default 8bit mode |
cbi(TCCR1A,PWM11); |
sbi(TCCR1A,PWM10); |
} |
|
// clear output compare value A |
outb(OCR1AH, 0); |
outb(OCR1AL, 0); |
// clear output compare value B |
outb(OCR1BH, 0); |
outb(OCR1BL, 0); |
} |
|
#ifdef WGM10 |
// include support for arbitrary top-count PWM |
// on new AVR processors that support it |
void timer1PWMInitICR(u16 topcount) |
{ |
// set PWM mode with ICR top-count |
cbi(TCCR1A,WGM10); |
sbi(TCCR1A,WGM11); |
sbi(TCCR1B,WGM12); |
sbi(TCCR1B,WGM13); |
|
// set top count value |
ICR1 = topcount; |
|
// clear output compare value A |
OCR1A = 0; |
// clear output compare value B |
OCR1B = 0; |
|
} |
#endif |
|
void timer1PWMOff(void) |
{ |
// turn off timer1 PWM mode |
cbi(TCCR1A,PWM11); |
cbi(TCCR1A,PWM10); |
// set PWM1A/B (OutputCompare action) to none |
timer1PWMAOff(); |
timer1PWMBOff(); |
} |
|
void timer1PWMAOn(void) |
{ |
// turn on channel A (OC1A) PWM output |
// set OC1A as non-inverted PWM |
sbi(TCCR1A,COM1A1); |
cbi(TCCR1A,COM1A0); |
} |
|
void timer1PWMBOn(void) |
{ |
// turn on channel B (OC1B) PWM output |
// set OC1B as non-inverted PWM |
sbi(TCCR1A,COM1B1); |
cbi(TCCR1A,COM1B0); |
} |
|
void timer1PWMAOff(void) |
{ |
// turn off channel A (OC1A) PWM output |
// set OC1A (OutputCompare action) to none |
cbi(TCCR1A,COM1A1); |
cbi(TCCR1A,COM1A0); |
} |
|
void timer1PWMBOff(void) |
{ |
// turn off channel B (OC1B) PWM output |
// set OC1B (OutputCompare action) to none |
cbi(TCCR1A,COM1B1); |
cbi(TCCR1A,COM1B0); |
} |
|
void timer1PWMASet(u16 pwmDuty) |
{ |
// set PWM (output compare) duty for channel A |
// this PWM output is generated on OC1A pin |
// NOTE: pwmDuty should be in the range 0-255 for 8bit PWM |
// pwmDuty should be in the range 0-511 for 9bit PWM |
// pwmDuty should be in the range 0-1023 for 10bit PWM |
//outp( (pwmDuty>>8), OCR1AH); // set the high 8bits of OCR1A |
//outp( (pwmDuty&0x00FF), OCR1AL); // set the low 8bits of OCR1A |
OCR1A = pwmDuty; |
} |
|
void timer1PWMBSet(u16 pwmDuty) |
{ |
// set PWM (output compare) duty for channel B |
// this PWM output is generated on OC1B pin |
// NOTE: pwmDuty should be in the range 0-255 for 8bit PWM |
// pwmDuty should be in the range 0-511 for 9bit PWM |
// pwmDuty should be in the range 0-1023 for 10bit PWM |
//outp( (pwmDuty>>8), OCR1BH); // set the high 8bits of OCR1B |
//outp( (pwmDuty&0x00FF), OCR1BL); // set the low 8bits of OCR1B |
OCR1B = pwmDuty; |
} |
|
//! Interrupt handler for tcnt0 overflow interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW0) |
{ |
Timer0Reg0++; // increment low-order counter |
|
// increment pause counter |
TimerPauseReg++; |
|
// if a user function is defined, execute it too |
if(TimerIntFunc[TIMER0OVERFLOW_INT]) |
TimerIntFunc[TIMER0OVERFLOW_INT](); |
} |
|
//! Interrupt handler for tcnt1 overflow interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW1) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER1OVERFLOW_INT]) |
TimerIntFunc[TIMER1OVERFLOW_INT](); |
} |
|
#ifdef TCNT2 // support timer2 only if it exists |
//! Interrupt handler for tcnt2 overflow interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OVERFLOW2) |
{ |
Timer2Reg0++; // increment low-order counter |
|
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER2OVERFLOW_INT]) |
TimerIntFunc[TIMER2OVERFLOW_INT](); |
} |
#endif |
|
#ifdef OCR0 |
// include support for Output Compare 0 for new AVR processors that support it |
//! Interrupt handler for OutputCompare0 match (OC0) interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE0) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER0OUTCOMPARE_INT]) |
TimerIntFunc[TIMER0OUTCOMPARE_INT](); |
} |
#endif |
|
//! Interrupt handler for CutputCompare1A match (OC1A) interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1A) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER1OUTCOMPAREA_INT]) |
TimerIntFunc[TIMER1OUTCOMPAREA_INT](); |
} |
|
//! Interrupt handler for OutputCompare1B match (OC1B) interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE1B) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER1OUTCOMPAREB_INT]) |
TimerIntFunc[TIMER1OUTCOMPAREB_INT](); |
} |
|
//! Interrupt handler for InputCapture1 (IC1) interrupt |
TIMER_INTERRUPT_HANDLER(SIG_INPUT_CAPTURE1) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER1INPUTCAPTURE_INT]) |
TimerIntFunc[TIMER1INPUTCAPTURE_INT](); |
} |
|
//! Interrupt handler for OutputCompare2 match (OC2) interrupt |
TIMER_INTERRUPT_HANDLER(SIG_OUTPUT_COMPARE2) |
{ |
// if a user function is defined, execute it |
if(TimerIntFunc[TIMER2OUTCOMPARE_INT]) |
TimerIntFunc[TIMER2OUTCOMPARE_INT](); |
} |