Subversion Repositories svnkaklik

/*! \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]();

}