Subversion Repositories svnkaklik

Rev

Details | Last modification | View Log

Rev Author Line No. Line
507 kaklik 1
/*! \file timer.h \brief System Timer function library. */
2
//*****************************************************************************
3
//
4
// File Name	: 'timer.h'
5
// Title		: System Timer function library
6
// Author		: Pascal Stang - Copyright (C) 2000-2002
7
// Created		: 11/22/2000
8
// Revised		: 02/10/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
///	\ingroup driver_avr
17
/// \defgroup timer Timer Function Library (timer.c)
18
/// \code #include "timer.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