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
23 #include "wiring_private.h"
25 // the prescaler is set so that timer0 ticks every 64 clock cycles, and the
26 // the overflow handler is called every 256 ticks.
27 #define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
29 // the whole number of milliseconds per timer0 overflow
30 #define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
32 // the fractional number of milliseconds per timer0 overflow. we shift right
33 // by three to fit these numbers into a byte. (for the clock speeds we care
34 // about - 8 and 16 MHz - this doesn't lose precision.)
35 #define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
36 #define FRACT_MAX (1000 >> 3)
38 volatile unsigned long timer0_overflow_count = 0;
39 volatile unsigned long timer0_millis = 0;
40 static unsigned char timer0_fract = 0;
42 #if defined(TIM0_OVF_vect)
48 // copy these to local variables so they can be stored in registers
49 // (volatile variables must be read from memory on every access)
50 unsigned long m = timer0_millis;
51 unsigned char f = timer0_fract;
62 timer0_overflow_count++;
65 unsigned long millis()
68 uint8_t oldSREG = SREG;
70 // disable interrupts while we read timer0_millis or we might get an
71 // inconsistent value (e.g. in the middle of a write to timer0_millis)
79 unsigned long micros() {
81 uint8_t oldSREG = SREG, t;
84 m = timer0_overflow_count;
90 #error TIMER 0 not defined
94 if ((TIFR0 & _BV(TOV0)) && (t < 255))
97 if ((TIFR & _BV(TOV0)) && (t < 255))
103 return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
106 void delay(unsigned long ms)
108 uint32_t start = micros();
112 while ( ms > 0 && (micros() - start) >= 1000) {
119 /* Delay for the given number of microseconds. Assumes a 1, 8, 12, 16, 20 or 24 MHz clock. */
120 void delayMicroseconds(unsigned int us)
122 // call = 4 cycles + 2 to 4 cycles to init us(2 for constant delay, 4 for variable)
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 >= 24000000L
128 // for the 24 MHz clock for the aventurous ones, trying to overclock
131 if (!us) return; // = 3 cycles, (4 when true)
133 // the following loop takes a 1/6 of a microsecond (4 cycles)
134 // per iteration, so execute it six times for each microsecond of
136 us *= 6; // x6 us, = 7 cycles
138 // account for the time taken in the preceeding commands.
139 // we just burned 22 (24) cycles above, remove 5, (5*4=20)
140 // us is at least 6 so we can substract 5
143 #elif F_CPU >= 20000000L
144 // for the 20 MHz clock on rare Arduino boards
146 // for a one-microsecond delay, simply return. the overhead
147 // of the function call takes 18 (20) cycles, which is 1us
148 __asm__ __volatile__ (
152 "nop"); //just waiting 4 cycles
153 if (us <= 1) return; // = 3 cycles, (4 when true)
155 // the following loop takes a 1/5 of a microsecond (4 cycles)
156 // per iteration, so execute it five times for each microsecond of
158 us = (us << 2) + us; // x5 us, = 7 cycles
160 // account for the time taken in the preceeding commands.
161 // we just burned 26 (28) cycles above, remove 7, (7*4=28)
162 // us is at least 10 so we can substract 7
165 #elif F_CPU >= 16000000L
166 // for the 16 MHz clock on most Arduino boards
168 // for a one-microsecond delay, simply return. the overhead
169 // of the function call takes 14 (16) cycles, which is 1us
170 if (us <= 1) return; // = 3 cycles, (4 when true)
172 // the following loop takes 1/4 of a microsecond (4 cycles)
173 // per iteration, so execute it four times for each microsecond of
175 us <<= 2; // x4 us, = 4 cycles
177 // account for the time taken in the preceeding commands.
178 // we just burned 19 (21) cycles above, remove 5, (5*4=20)
179 // us is at least 8 so we can substract 5
180 us -= 5; // = 2 cycles,
182 #elif F_CPU >= 12000000L
183 // for the 12 MHz clock if somebody is working with USB
185 // for a 1 microsecond delay, simply return. the overhead
186 // of the function call takes 14 (16) cycles, which is 1.5us
187 if (us <= 1) return; // = 3 cycles, (4 when true)
189 // the following loop takes 1/3 of a microsecond (4 cycles)
190 // per iteration, so execute it three times for each microsecond of
192 us = (us << 1) + us; // x3 us, = 5 cycles
194 // account for the time taken in the preceeding commands.
195 // we just burned 20 (22) cycles above, remove 5, (5*4=20)
196 // us is at least 6 so we can substract 5
199 #elif F_CPU >= 8000000L
200 // for the 8 MHz internal clock
202 // for a 1 and 2 microsecond delay, simply return. the overhead
203 // of the function call takes 14 (16) cycles, which is 2us
204 if (us <= 2) return; // = 3 cycles, (4 when true)
206 // the following loop takes 1/2 of a microsecond (4 cycles)
207 // per iteration, so execute it twice for each microsecond of
209 us <<= 1; //x2 us, = 2 cycles
211 // account for the time taken in the preceeding commands.
212 // we just burned 17 (19) cycles above, remove 4, (4*4=16)
213 // us is at least 6 so we can substract 4
214 us -= 4; // = 2 cycles
217 // for the 1 MHz internal clock (default settings for common Atmega microcontrollers)
219 // the overhead of the function calls is 14 (16) cycles
220 if (us <= 16) return; //= 3 cycles, (4 when true)
221 if (us <= 25) return; //= 3 cycles, (4 when true), (must be at least 25 if we want to substract 22)
223 // compensate for the time taken by the preceeding and next commands (about 22 cycles)
224 us -= 22; // = 2 cycles
225 // the following loop takes 4 microseconds (4 cycles)
226 // per iteration, so execute it us/4 times
227 // us is at least 4, divided by 4 gives us 1 (no zero delay bug)
228 us >>= 2; // us div 4, = 4 cycles
234 __asm__ __volatile__ (
235 "1: sbiw %0,1" "\n\t" // 2 cycles
236 "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
243 // this needs to be called before setup() or some functions won't
247 // on the ATmega168, timer 0 is also used for fast hardware pwm
248 // (using phase-correct PWM would mean that timer 0 overflowed half as often
249 // resulting in different millis() behavior on the ATmega8 and ATmega168)
250 #if defined(TCCR0A) && defined(WGM01)
255 // set timer 0 prescale factor to 64
256 #if defined(__AVR_ATmega128__)
257 // CPU specific: different values for the ATmega128
259 #elif defined(TCCR0) && defined(CS01) && defined(CS00)
260 // this combination is for the standard atmega8
263 #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
264 // this combination is for the standard 168/328/1280/2560
267 #elif defined(TCCR0A) && defined(CS01) && defined(CS00)
268 // this combination is for the __AVR_ATmega645__ series
272 #error Timer 0 prescale factor 64 not set correctly
275 // enable timer 0 overflow interrupt
276 #if defined(TIMSK) && defined(TOIE0)
278 #elif defined(TIMSK0) && defined(TOIE0)
281 #error Timer 0 overflow interrupt not set correctly
284 // timers 1 and 2 are used for phase-correct hardware pwm
285 // this is better for motors as it ensures an even waveform
286 // note, however, that fast pwm mode can achieve a frequency of up
287 // 8 MHz (with a 16 MHz clock) at 50% duty cycle
289 #if defined(TCCR1B) && defined(CS11) && defined(CS10)
292 // set timer 1 prescale factor to 64
294 #if F_CPU >= 8000000L
297 #elif defined(TCCR1) && defined(CS11) && defined(CS10)
299 #if F_CPU >= 8000000L
303 // put timer 1 in 8-bit phase correct pwm mode
304 #if defined(TCCR1A) && defined(WGM10)
308 // set timer 2 prescale factor to 64
309 #if defined(TCCR2) && defined(CS22)
311 #elif defined(TCCR2B) && defined(CS22)
314 // Timer 2 not finished (may not be present on this CPU)
317 // configure timer 2 for phase correct pwm (8-bit)
318 #if defined(TCCR2) && defined(WGM20)
320 #elif defined(TCCR2A) && defined(WGM20)
323 // Timer 2 not finished (may not be present on this CPU)
326 #if defined(TCCR3B) && defined(CS31) && defined(WGM30)
327 sbi(TCCR3B, CS31); // set timer 3 prescale factor to 64
329 sbi(TCCR3A, WGM30); // put timer 3 in 8-bit phase correct pwm mode
332 #if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
333 sbi(TCCR4B, CS42); // set timer4 prescale factor to 64
336 sbi(TCCR4D, WGM40); // put timer 4 in phase- and frequency-correct PWM mode
337 sbi(TCCR4A, PWM4A); // enable PWM mode for comparator OCR4A
338 sbi(TCCR4C, PWM4D); // enable PWM mode for comparator OCR4D
339 #else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
340 #if defined(TCCR4B) && defined(CS41) && defined(WGM40)
341 sbi(TCCR4B, CS41); // set timer 4 prescale factor to 64
343 sbi(TCCR4A, WGM40); // put timer 4 in 8-bit phase correct pwm mode
345 #endif /* end timer4 block for ATMEGA1280/2560 and similar */
347 #if defined(TCCR5B) && defined(CS51) && defined(WGM50)
348 sbi(TCCR5B, CS51); // set timer 5 prescale factor to 64
350 sbi(TCCR5A, WGM50); // put timer 5 in 8-bit phase correct pwm mode
354 // set a2d prescaler so we are inside the desired 50-200 KHz range.
355 #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
359 #elif F_CPU >= 8000000 // 8 MHz / 64 = 125 KHz
363 #elif F_CPU >= 4000000 // 4 MHz / 32 = 125 KHz
367 #elif F_CPU >= 2000000 // 2 MHz / 16 = 125 KHz
371 #elif F_CPU >= 1000000 // 1 MHz / 8 = 125 KHz
375 #else // 128 kHz / 2 = 64 KHz -> This is the closest you can get, the prescaler is 2
380 // enable a2d conversions
384 // the bootloader connects pins 0 and 1 to the USART; disconnect them
385 // here so they can be used as normal digital i/o; they will be
386 // reconnected in Serial.begin()
389 #elif defined(UCSR0B)