protocol/usb_hid/arduino-1.0.1/cores/arduino/wiring.c

   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 //PORTB &= ~(1<<0);
 112         uint16_t start = (uint16_t)micros();
 113
 114         while (ms > 0) {
 115                 if (((uint16_t)micros() - start) >= 1000) {
 116                         ms--;
 117                         start += 1000;
 118                 }
 119         }
 120 //PORTB |= (1<<0);
 121 }
 122
 123 /* Delay for the given number of microseconds.  Assumes a 8 or 16 MHz clock. */
 124 void delayMicroseconds(unsigned int us)
 125 {
 126         // calling avrlib's delay_us() function with low values (e.g. 1 or
 127         // 2 microseconds) gives delays longer than desired.
 128         //delay_us(us);
 129 #if F_CPU >= 20000000L
 130         // for the 20 MHz clock on rare Arduino boards
 131
 132         // for a one-microsecond delay, simply wait 2 cycle and return. The overhead
 133         // of the function call yields a delay of exactly a one microsecond.
 134         __asm__ __volatile__ (
 135                 "nop" "\n\t"
 136                 "nop"); //just waiting 2 cycle
 137         if (--us == 0)
 138                 return;
 139
 140         // the following loop takes a 1/5 of a microsecond (4 cycles)
 141         // per iteration, so execute it five times for each microsecond of
 142         // delay requested.
 143         us = (us<<2) + us; // x5 us
 144
 145         // account for the time taken in the preceeding commands.
 146         us -= 2;
 147
 148 #elif F_CPU >= 16000000L
 149         // for the 16 MHz clock on most Arduino boards
 150
 151         // for a one-microsecond delay, simply return.  the overhead
 152         // of the function call yields a delay of approximately 1 1/8 us.
 153         if (--us == 0)
 154                 return;
 155
 156         // the following loop takes a quarter of a microsecond (4 cycles)
 157         // per iteration, so execute it four times for each microsecond of
 158         // delay requested.
 159         us <<= 2;
 160
 161         // account for the time taken in the preceeding commands.
 162         us -= 2;
 163 #else
 164         // for the 8 MHz internal clock on the ATmega168
 165
 166         // for a one- or two-microsecond delay, simply return.  the overhead of
 167         // the function calls takes more than two microseconds.  can't just
 168         // subtract two, since us is unsigned; we'd overflow.
 169         if (--us == 0)
 170                 return;
 171         if (--us == 0)
 172                 return;
 173
 174         // the following loop takes half of a microsecond (4 cycles)
 175         // per iteration, so execute it twice for each microsecond of
 176         // delay requested.
 177         us <<= 1;
 178
 179         // partially compensate for the time taken by the preceeding commands.
 180         // we can't subtract any more than this or we'd overflow w/ small delays.
 181         us--;
 182 #endif
 183
 184         // busy wait
 185         __asm__ __volatile__ (
 186                 "1: sbiw %0,1" "\n\t" // 2 cycles
 187                 "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
 188         );
 189 }
 190
 191 void init()
 192 {
 193         // this needs to be called before setup() or some functions won't
 194         // work there
 195         sei();
 196
 197         // on the ATmega168, timer 0 is also used for fast hardware pwm
 198         // (using phase-correct PWM would mean that timer 0 overflowed half as often
 199         // resulting in different millis() behavior on the ATmega8 and ATmega168)
 200 #if defined(TCCR0A) && defined(WGM01)
 201         sbi(TCCR0A, WGM01);
 202         sbi(TCCR0A, WGM00);
 203 #endif
 204
 205         // set timer 0 prescale factor to 64
 206 #if defined(__AVR_ATmega128__)
 207         // CPU specific: different values for the ATmega128
 208         sbi(TCCR0, CS02);
 209 #elif defined(TCCR0) && defined(CS01) && defined(CS00)
 210         // this combination is for the standard atmega8
 211         sbi(TCCR0, CS01);
 212         sbi(TCCR0, CS00);
 213 #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
 214         // this combination is for the standard 168/328/1280/2560
 215         sbi(TCCR0B, CS01);
 216         sbi(TCCR0B, CS00);
 217 #elif defined(TCCR0A) && defined(CS01) && defined(CS00)
 218         // this combination is for the __AVR_ATmega645__ series
 219         sbi(TCCR0A, CS01);
 220         sbi(TCCR0A, CS00);
 221 #else
 222         #error Timer 0 prescale factor 64 not set correctly
 223 #endif
 224
 225         // enable timer 0 overflow interrupt
 226 #if defined(TIMSK) && defined(TOIE0)
 227         sbi(TIMSK, TOIE0);
 228 #elif defined(TIMSK0) && defined(TOIE0)
 229         sbi(TIMSK0, TOIE0);
 230 #else
 231         #error  Timer 0 overflow interrupt not set correctly
 232 #endif
 233
 234         // timers 1 and 2 are used for phase-correct hardware pwm
 235         // this is better for motors as it ensures an even waveform
 236         // note, however, that fast pwm mode can achieve a frequency of up
 237         // 8 MHz (with a 16 MHz clock) at 50% duty cycle
 238
 239 #if defined(TCCR1B) && defined(CS11) && defined(CS10)
 240         TCCR1B = 0;
 241
 242         // set timer 1 prescale factor to 64
 243         sbi(TCCR1B, CS11);
 244 #if F_CPU >= 8000000L
 245         sbi(TCCR1B, CS10);
 246 #endif
 247 #elif defined(TCCR1) && defined(CS11) && defined(CS10)
 248         sbi(TCCR1, CS11);
 249 #if F_CPU >= 8000000L
 250         sbi(TCCR1, CS10);
 251 #endif
 252 #endif
 253         // put timer 1 in 8-bit phase correct pwm mode
 254 #if defined(TCCR1A) && defined(WGM10)
 255         sbi(TCCR1A, WGM10);
 256 #elif defined(TCCR1)
 257         #warning this needs to be finished
 258 #endif
 259
 260         // set timer 2 prescale factor to 64
 261 #if defined(TCCR2) && defined(CS22)
 262         sbi(TCCR2, CS22);
 263 #elif defined(TCCR2B) && defined(CS22)
 264         sbi(TCCR2B, CS22);
 265 #else
 266         #warning Timer 2 not finished (may not be present on this CPU)
 267 #endif
 268
 269         // configure timer 2 for phase correct pwm (8-bit)
 270 #if defined(TCCR2) && defined(WGM20)
 271         sbi(TCCR2, WGM20);
 272 #elif defined(TCCR2A) && defined(WGM20)
 273         sbi(TCCR2A, WGM20);
 274 #else
 275         #warning Timer 2 not finished (may not be present on this CPU)
 276 #endif
 277
 278 #if defined(TCCR3B) && defined(CS31) && defined(WGM30)
 279         sbi(TCCR3B, CS31);              // set timer 3 prescale factor to 64
 280         sbi(TCCR3B, CS30);
 281         sbi(TCCR3A, WGM30);             // put timer 3 in 8-bit phase correct pwm mode
 282 #endif
 283
 284 #if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
 285         sbi(TCCR4B, CS42);              // set timer4 prescale factor to 64
 286         sbi(TCCR4B, CS41);
 287         sbi(TCCR4B, CS40);
 288         sbi(TCCR4D, WGM40);             // put timer 4 in phase- and frequency-correct PWM mode
 289         sbi(TCCR4A, PWM4A);             // enable PWM mode for comparator OCR4A
 290         sbi(TCCR4C, PWM4D);             // enable PWM mode for comparator OCR4D
 291 #else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
 292 #if defined(TCCR4B) && defined(CS41) && defined(WGM40)
 293         sbi(TCCR4B, CS41);              // set timer 4 prescale factor to 64
 294         sbi(TCCR4B, CS40);
 295         sbi(TCCR4A, WGM40);             // put timer 4 in 8-bit phase correct pwm mode
 296 #endif
 297 #endif /* end timer4 block for ATMEGA1280/2560 and similar */
 298
 299 #if defined(TCCR5B) && defined(CS51) && defined(WGM50)
 300         sbi(TCCR5B, CS51);              // set timer 5 prescale factor to 64
 301         sbi(TCCR5B, CS50);
 302         sbi(TCCR5A, WGM50);             // put timer 5 in 8-bit phase correct pwm mode
 303 #endif
 304
 305 #if defined(ADCSRA)
 306         // set a2d prescale factor to 128
 307         // 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
 308         // XXX: this will not work properly for other clock speeds, and
 309         // this code should use F_CPU to determine the prescale factor.
 310         sbi(ADCSRA, ADPS2);
 311         sbi(ADCSRA, ADPS1);
 312         sbi(ADCSRA, ADPS0);
 313
 314         // enable a2d conversions
 315         sbi(ADCSRA, ADEN);
 316 #endif
 317
 318         // the bootloader connects pins 0 and 1 to the USART; disconnect them
 319         // here so they can be used as normal digital i/o; they will be
 320         // reconnected in Serial.begin()
 321 #if defined(UCSRB)
 322         UCSRB = 0;
 323 #elif defined(UCSR0B)
 324         UCSR0B = 0;
 325 #endif
 326 }