2 wiring.c - Partial implementation of the Wiring API for the ATmega8.
3 Part of Arduino - http://www.arduino.cc/
5 Copyright (c) 2005-2006 David A. Mellis
7 This library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
12 This library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General
18 Public License along with this library; if not, write to the
19 Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 Boston, MA 02111-1307 USA
25 #include "wiring_private.h"
27 // the prescaler is set so that timer0 ticks every 64 clock cycles, and the
28 // the overflow handler is called every 256 ticks.
29 #define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
31 // the whole number of milliseconds per timer0 overflow
32 #define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
34 // the fractional number of milliseconds per timer0 overflow. we shift right
35 // by three to fit these numbers into a byte. (for the clock speeds we care
36 // about - 8 and 16 MHz - this doesn't lose precision.)
37 #define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
38 #define FRACT_MAX (1000 >> 3)
40 volatile unsigned long timer0_overflow_count = 0;
41 volatile unsigned long timer0_millis = 0;
42 static unsigned char timer0_fract = 0;
44 #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
47 SIGNAL(TIMER0_OVF_vect)
50 // copy these to local variables so they can be stored in registers
51 // (volatile variables must be read from memory on every access)
52 unsigned long m = timer0_millis;
53 unsigned char f = timer0_fract;
64 timer0_overflow_count++;
67 unsigned long millis()
70 uint8_t oldSREG = SREG;
72 // disable interrupts while we read timer0_millis or we might get an
73 // inconsistent value (e.g. in the middle of a write to timer0_millis)
81 unsigned long micros() {
83 uint8_t oldSREG = SREG, t;
86 m = timer0_overflow_count;
92 #error TIMER 0 not defined
97 if ((TIFR0 & _BV(TOV0)) && (t < 255))
100 if ((TIFR & _BV(TOV0)) && (t < 255))
106 return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
109 void delay(unsigned long ms)
111 uint16_t start = (uint16_t)micros();
114 if (((uint16_t)micros() - start) >= 1000) {
121 /* Delay for the given number of microseconds. Assumes a 8 or 16 MHz clock. */
122 void delayMicroseconds(unsigned int us)
124 // calling avrlib's delay_us() function with low values (e.g. 1 or
125 // 2 microseconds) gives delays longer than desired.
127 #if F_CPU >= 20000000L
128 // for the 20 MHz clock on rare Arduino boards
130 // for a one-microsecond delay, simply wait 2 cycle and return. The overhead
131 // of the function call yields a delay of exactly a one microsecond.
132 __asm__ __volatile__ (
134 "nop"); //just waiting 2 cycle
138 // the following loop takes a 1/5 of a microsecond (4 cycles)
139 // per iteration, so execute it five times for each microsecond of
141 us = (us<<2) + us; // x5 us
143 // account for the time taken in the preceeding commands.
146 #elif F_CPU >= 16000000L
147 // for the 16 MHz clock on most Arduino boards
149 // for a one-microsecond delay, simply return. the overhead
150 // of the function call yields a delay of approximately 1 1/8 us.
154 // the following loop takes a quarter of a microsecond (4 cycles)
155 // per iteration, so execute it four times for each microsecond of
159 // account for the time taken in the preceeding commands.
162 // for the 8 MHz internal clock on the ATmega168
164 // for a one- or two-microsecond delay, simply return. the overhead of
165 // the function calls takes more than two microseconds. can't just
166 // subtract two, since us is unsigned; we'd overflow.
172 // the following loop takes half of a microsecond (4 cycles)
173 // per iteration, so execute it twice for each microsecond of
177 // partially compensate for the time taken by the preceeding commands.
178 // we can't subtract any more than this or we'd overflow w/ small delays.
183 __asm__ __volatile__ (
184 "1: sbiw %0,1" "\n\t" // 2 cycles
185 "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
191 // this needs to be called before setup() or some functions won't
195 // on the ATmega168, timer 0 is also used for fast hardware pwm
196 // (using phase-correct PWM would mean that timer 0 overflowed half as often
197 // resulting in different millis() behavior on the ATmega8 and ATmega168)
198 #if defined(TCCR0A) && defined(WGM01)
203 // set timer 0 prescale factor to 64
204 #if defined(__AVR_ATmega128__)
205 // CPU specific: different values for the ATmega128
207 #elif defined(TCCR0) && defined(CS01) && defined(CS00)
208 // this combination is for the standard atmega8
211 #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
212 // this combination is for the standard 168/328/1280/2560
215 #elif defined(TCCR0A) && defined(CS01) && defined(CS00)
216 // this combination is for the __AVR_ATmega645__ series
220 #error Timer 0 prescale factor 64 not set correctly
223 // enable timer 0 overflow interrupt
224 #if defined(TIMSK) && defined(TOIE0)
226 #elif defined(TIMSK0) && defined(TOIE0)
229 #error Timer 0 overflow interrupt not set correctly
232 // timers 1 and 2 are used for phase-correct hardware pwm
233 // this is better for motors as it ensures an even waveform
234 // note, however, that fast pwm mode can achieve a frequency of up
235 // 8 MHz (with a 16 MHz clock) at 50% duty cycle
237 #if defined(TCCR1B) && defined(CS11) && defined(CS10)
240 // set timer 1 prescale factor to 64
242 #if F_CPU >= 8000000L
245 #elif defined(TCCR1) && defined(CS11) && defined(CS10)
247 #if F_CPU >= 8000000L
251 // put timer 1 in 8-bit phase correct pwm mode
252 #if defined(TCCR1A) && defined(WGM10)
255 #warning this needs to be finished
258 // set timer 2 prescale factor to 64
259 #if defined(TCCR2) && defined(CS22)
261 #elif defined(TCCR2B) && defined(CS22)
264 #warning Timer 2 not finished (may not be present on this CPU)
267 // configure timer 2 for phase correct pwm (8-bit)
268 #if defined(TCCR2) && defined(WGM20)
270 #elif defined(TCCR2A) && defined(WGM20)
273 #warning Timer 2 not finished (may not be present on this CPU)
276 #if defined(TCCR3B) && defined(CS31) && defined(WGM30)
277 sbi(TCCR3B, CS31); // set timer 3 prescale factor to 64
279 sbi(TCCR3A, WGM30); // put timer 3 in 8-bit phase correct pwm mode
282 #if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
283 sbi(TCCR4B, CS42); // set timer4 prescale factor to 64
286 sbi(TCCR4D, WGM40); // put timer 4 in phase- and frequency-correct PWM mode
287 sbi(TCCR4A, PWM4A); // enable PWM mode for comparator OCR4A
288 sbi(TCCR4C, PWM4D); // enable PWM mode for comparator OCR4D
289 #else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
290 #if defined(TCCR4B) && defined(CS41) && defined(WGM40)
291 sbi(TCCR4B, CS41); // set timer 4 prescale factor to 64
293 sbi(TCCR4A, WGM40); // put timer 4 in 8-bit phase correct pwm mode
295 #endif /* end timer4 block for ATMEGA1280/2560 and similar */
297 #if defined(TCCR5B) && defined(CS51) && defined(WGM50)
298 sbi(TCCR5B, CS51); // set timer 5 prescale factor to 64
300 sbi(TCCR5A, WGM50); // put timer 5 in 8-bit phase correct pwm mode
304 // set a2d prescale factor to 128
305 // 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
306 // XXX: this will not work properly for other clock speeds, and
307 // this code should use F_CPU to determine the prescale factor.
312 // enable a2d conversions
316 // the bootloader connects pins 0 and 1 to the USART; disconnect them
317 // here so they can be used as normal digital i/o; they will be
318 // reconnected in Serial.begin()
321 #elif defined(UCSR0B)