Statistics
| Branch: | Revision:

root / arduino-1.0 / hardware / arduino / cores / arduino / wiring.c @ 58d82c77

History | View | Annotate | Download (8.09 KB)

1
/*
2
  wiring.c - Partial implementation of the Wiring API for the ATmega8.
3
  Part of Arduino - http://www.arduino.cc/
4

5
  Copyright (c) 2005-2006 David A. Mellis
6

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.
11

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.
16

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
21

22
  $Id$
23
*/
24

    
25
#include "wiring_private.h"
26

    
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))
30

    
31
// the whole number of milliseconds per timer0 overflow
32
#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
33

    
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)
39

    
40
volatile unsigned long timer0_overflow_count = 0;
41
volatile unsigned long timer0_millis = 0;
42
static unsigned char timer0_fract = 0;
43

    
44
#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
45
SIGNAL(TIM0_OVF_vect)
46
#else
47
SIGNAL(TIMER0_OVF_vect)
48
#endif
49
{
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;
54

    
55
        m += MILLIS_INC;
56
        f += FRACT_INC;
57
        if (f >= FRACT_MAX) {
58
                f -= FRACT_MAX;
59
                m += 1;
60
        }
61

    
62
        timer0_fract = f;
63
        timer0_millis = m;
64
        timer0_overflow_count++;
65
}
66

    
67
unsigned long millis()
68
{
69
        unsigned long m;
70
        uint8_t oldSREG = SREG;
71

    
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)
74
        cli();
75
        m = timer0_millis;
76
        SREG = oldSREG;
77

    
78
        return m;
79
}
80

    
81
unsigned long micros() {
82
        unsigned long m;
83
        uint8_t oldSREG = SREG, t;
84
        
85
        cli();
86
        m = timer0_overflow_count;
87
#if defined(TCNT0)
88
        t = TCNT0;
89
#elif defined(TCNT0L)
90
        t = TCNT0L;
91
#else
92
        #error TIMER 0 not defined
93
#endif
94

    
95
  
96
#ifdef TIFR0
97
        if ((TIFR0 & _BV(TOV0)) && (t < 255))
98
                m++;
99
#else
100
        if ((TIFR & _BV(TOV0)) && (t < 255))
101
                m++;
102
#endif
103

    
104
        SREG = oldSREG;
105
        
106
        return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
107
}
108

    
109
void delay(unsigned long ms)
110
{
111
        uint16_t start = (uint16_t)micros();
112

    
113
        while (ms > 0) {
114
                if (((uint16_t)micros() - start) >= 1000) {
115
                        ms--;
116
                        start += 1000;
117
                }
118
        }
119
}
120

    
121
/* Delay for the given number of microseconds.  Assumes a 8 or 16 MHz clock. */
122
void delayMicroseconds(unsigned int us)
123
{
124
        // calling avrlib's delay_us() function with low values (e.g. 1 or
125
        // 2 microseconds) gives delays longer than desired.
126
        //delay_us(us);
127

    
128
#if F_CPU >= 16000000L
129
        // for the 16 MHz clock on most Arduino boards
130

    
131
        // for a one-microsecond delay, simply return.  the overhead
132
        // of the function call yields a delay of approximately 1 1/8 us.
133
        if (--us == 0)
134
                return;
135

    
136
        // the following loop takes a quarter of a microsecond (4 cycles)
137
        // per iteration, so execute it four times for each microsecond of
138
        // delay requested.
139
        us <<= 2;
140

    
141
        // account for the time taken in the preceeding commands.
142
        us -= 2;
143
#else
144
        // for the 8 MHz internal clock on the ATmega168
145

    
146
        // for a one- or two-microsecond delay, simply return.  the overhead of
147
        // the function calls takes more than two microseconds.  can't just
148
        // subtract two, since us is unsigned; we'd overflow.
149
        if (--us == 0)
150
                return;
151
        if (--us == 0)
152
                return;
153

    
154
        // the following loop takes half of a microsecond (4 cycles)
155
        // per iteration, so execute it twice for each microsecond of
156
        // delay requested.
157
        us <<= 1;
158
    
159
        // partially compensate for the time taken by the preceeding commands.
160
        // we can't subtract any more than this or we'd overflow w/ small delays.
161
        us--;
162
#endif
163

    
164
        // busy wait
165
        __asm__ __volatile__ (
166
                "1: sbiw %0,1" "\n\t" // 2 cycles
167
                "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
168
        );
169
}
170

    
171
void init()
172
{
173
        // this needs to be called before setup() or some functions won't
174
        // work there
175
        sei();
176
        
177
        // on the ATmega168, timer 0 is also used for fast hardware pwm
178
        // (using phase-correct PWM would mean that timer 0 overflowed half as often
179
        // resulting in different millis() behavior on the ATmega8 and ATmega168)
180
#if defined(TCCR0A) && defined(WGM01)
181
        sbi(TCCR0A, WGM01);
182
        sbi(TCCR0A, WGM00);
183
#endif  
184

    
185
        // set timer 0 prescale factor to 64
186
#if defined(__AVR_ATmega128__)
187
        // CPU specific: different values for the ATmega128
188
        sbi(TCCR0, CS02);
189
#elif defined(TCCR0) && defined(CS01) && defined(CS00)
190
        // this combination is for the standard atmega8
191
        sbi(TCCR0, CS01);
192
        sbi(TCCR0, CS00);
193
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
194
        // this combination is for the standard 168/328/1280/2560
195
        sbi(TCCR0B, CS01);
196
        sbi(TCCR0B, CS00);
197
#elif defined(TCCR0A) && defined(CS01) && defined(CS00)
198
        // this combination is for the __AVR_ATmega645__ series
199
        sbi(TCCR0A, CS01);
200
        sbi(TCCR0A, CS00);
201
#else
202
        #error Timer 0 prescale factor 64 not set correctly
203
#endif
204

    
205
        // enable timer 0 overflow interrupt
206
#if defined(TIMSK) && defined(TOIE0)
207
        sbi(TIMSK, TOIE0);
208
#elif defined(TIMSK0) && defined(TOIE0)
209
        sbi(TIMSK0, TOIE0);
210
#else
211
        #error        Timer 0 overflow interrupt not set correctly
212
#endif
213

    
214
        // timers 1 and 2 are used for phase-correct hardware pwm
215
        // this is better for motors as it ensures an even waveform
216
        // note, however, that fast pwm mode can achieve a frequency of up
217
        // 8 MHz (with a 16 MHz clock) at 50% duty cycle
218

    
219
#if defined(TCCR1B) && defined(CS11) && defined(CS10)
220
        TCCR1B = 0;
221

    
222
        // set timer 1 prescale factor to 64
223
        sbi(TCCR1B, CS11);
224
#if F_CPU >= 8000000L
225
        sbi(TCCR1B, CS10);
226
#endif
227
#elif defined(TCCR1) && defined(CS11) && defined(CS10)
228
        sbi(TCCR1, CS11);
229
#if F_CPU >= 8000000L
230
        sbi(TCCR1, CS10);
231
#endif
232
#endif
233
        // put timer 1 in 8-bit phase correct pwm mode
234
#if defined(TCCR1A) && defined(WGM10)
235
        sbi(TCCR1A, WGM10);
236
#elif defined(TCCR1)
237
        #warning this needs to be finished
238
#endif
239

    
240
        // set timer 2 prescale factor to 64
241
#if defined(TCCR2) && defined(CS22)
242
        sbi(TCCR2, CS22);
243
#elif defined(TCCR2B) && defined(CS22)
244
        sbi(TCCR2B, CS22);
245
#else
246
        #warning Timer 2 not finished (may not be present on this CPU)
247
#endif
248

    
249
        // configure timer 2 for phase correct pwm (8-bit)
250
#if defined(TCCR2) && defined(WGM20)
251
        sbi(TCCR2, WGM20);
252
#elif defined(TCCR2A) && defined(WGM20)
253
        sbi(TCCR2A, WGM20);
254
#else
255
        #warning Timer 2 not finished (may not be present on this CPU)
256
#endif
257

    
258
#if defined(TCCR3B) && defined(CS31) && defined(WGM30)
259
        sbi(TCCR3B, CS31);                // set timer 3 prescale factor to 64
260
        sbi(TCCR3B, CS30);
261
        sbi(TCCR3A, WGM30);                // put timer 3 in 8-bit phase correct pwm mode
262
#endif
263
        
264
#if defined(TCCR4B) && defined(CS41) && defined(WGM40)
265
        sbi(TCCR4B, CS41);                // set timer 4 prescale factor to 64
266
        sbi(TCCR4B, CS40);
267
        sbi(TCCR4A, WGM40);                // put timer 4 in 8-bit phase correct pwm mode
268
#endif
269

    
270
#if defined(TCCR5B) && defined(CS51) && defined(WGM50)
271
        sbi(TCCR5B, CS51);                // set timer 5 prescale factor to 64
272
        sbi(TCCR5B, CS50);
273
        sbi(TCCR5A, WGM50);                // put timer 5 in 8-bit phase correct pwm mode
274
#endif
275

    
276
#if defined(ADCSRA)
277
        // set a2d prescale factor to 128
278
        // 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
279
        // XXX: this will not work properly for other clock speeds, and
280
        // this code should use F_CPU to determine the prescale factor.
281
        sbi(ADCSRA, ADPS2);
282
        sbi(ADCSRA, ADPS1);
283
        sbi(ADCSRA, ADPS0);
284

    
285
        // enable a2d conversions
286
        sbi(ADCSRA, ADEN);
287
#endif
288

    
289
        // the bootloader connects pins 0 and 1 to the USART; disconnect them
290
        // here so they can be used as normal digital i/o; they will be
291
        // reconnected in Serial.begin()
292
#if defined(UCSRB)
293
        UCSRB = 0;
294
#elif defined(UCSR0B)
295
        UCSR0B = 0;
296
#endif
297
}