Arduino  1.8.10
wiring.c ファイル
#include "wiring_private.h"

[ソースコード]

マクロ定義

#define MICROSECONDS_PER_TIMER0_OVERFLOW   (clockCyclesToMicroseconds(64 * 256))
 
#define MILLIS_INC   (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
 
#define FRACT_INC   ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
 
#define FRACT_MAX   (1000 >> 3)
 

関数

 if (f >=FRACT_MAX)
 
unsigned long millis ()
 
unsigned long micros ()
 
void delay (unsigned long ms)
 
void delayMicroseconds (unsigned int us)
 
void init ()
 

変数

volatile unsigned long timer0_overflow_count = 0
 
volatile unsigned long timer0_millis = 0
 
unsigned char f = timer0_fract
 
 m = MILLIS_INC
 

マクロ定義詳解

◆ FRACT_INC

#define FRACT_INC   ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)

wiring.c35 行目に定義があります。

◆ FRACT_MAX

#define FRACT_MAX   (1000 >> 3)

wiring.c36 行目に定義があります。

◆ MICROSECONDS_PER_TIMER0_OVERFLOW

#define MICROSECONDS_PER_TIMER0_OVERFLOW   (clockCyclesToMicroseconds(64 * 256))

wiring.c27 行目に定義があります。

◆ MILLIS_INC

#define MILLIS_INC   (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)

wiring.c30 行目に定義があります。

関数詳解

◆ delay()

void delay ( unsigned long  ms)

wiring.c106 行目に定義があります。

107 {
108  uint32_t start = micros();
109 
110  while (ms > 0) {
111  yield();
112  while ( ms > 0 && (micros() - start) >= 1000) {
113  ms--;
114  start += 1000;
115  }
116  }
117 }
void yield(void)
unsigned long micros()
Definition: wiring.c:79

◆ delayMicroseconds()

void delayMicroseconds ( unsigned int  us)

wiring.c120 行目に定義があります。

121 {
122  // call = 4 cycles + 2 to 4 cycles to init us(2 for constant delay, 4 for variable)
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 #if F_CPU >= 24000000L
128  // for the 24 MHz clock for the aventurous ones, trying to overclock
129 
130  // zero delay fix
131  if (!us) return; // = 3 cycles, (4 when true)
132 
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
135  // delay requested.
136  us *= 6; // x6 us, = 7 cycles
137 
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
141  us -= 5; //=2 cycles
142 
143 #elif F_CPU >= 20000000L
144  // for the 20 MHz clock on rare Arduino boards
145 
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__ (
149  "nop" "\n\t"
150  "nop" "\n\t"
151  "nop" "\n\t"
152  "nop"); //just waiting 4 cycles
153  if (us <= 1) return; // = 3 cycles, (4 when true)
154 
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
157  // delay requested.
158  us = (us << 2) + us; // x5 us, = 7 cycles
159 
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
163  us -= 7; // 2 cycles
164 
165 #elif F_CPU >= 16000000L
166  // for the 16 MHz clock on most Arduino boards
167 
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)
171 
172  // the following loop takes 1/4 of a microsecond (4 cycles)
173  // per iteration, so execute it four times for each microsecond of
174  // delay requested.
175  us <<= 2; // x4 us, = 4 cycles
176 
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,
181 
182 #elif F_CPU >= 12000000L
183  // for the 12 MHz clock if somebody is working with USB
184 
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)
188 
189  // the following loop takes 1/3 of a microsecond (4 cycles)
190  // per iteration, so execute it three times for each microsecond of
191  // delay requested.
192  us = (us << 1) + us; // x3 us, = 5 cycles
193 
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
197  us -= 5; //2 cycles
198 
199 #elif F_CPU >= 8000000L
200  // for the 8 MHz internal clock
201 
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)
205 
206  // the following loop takes 1/2 of a microsecond (4 cycles)
207  // per iteration, so execute it twice for each microsecond of
208  // delay requested.
209  us <<= 1; //x2 us, = 2 cycles
210 
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
215 
216 #else
217  // for the 1 MHz internal clock (default settings for common Atmega microcontrollers)
218 
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)
222 
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
229 
230 
231 #endif
232 
233  // busy wait
234  __asm__ __volatile__ (
235  "1: sbiw %0,1" "\n\t" // 2 cycles
236  "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
237  );
238  // return = 4 cycles
239 }

◆ if()

if ( f >=  FRACT_MAX)

wiring.c55 行目に定義があります。

55  {
56  f -= FRACT_MAX;
57  m += 1;
58  }
#define FRACT_MAX
Definition: wiring.c:36
m
Definition: wiring.c:53
unsigned char f
Definition: wiring.c:51

◆ init()

void init ( void  )

wiring.c241 行目に定義があります。

242 {
243  // this needs to be called before setup() or some functions won't
244  // work there
245  sei();
246 
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)
251  sbi(TCCR0A, WGM01);
252  sbi(TCCR0A, WGM00);
253 #endif
254 
255  // set timer 0 prescale factor to 64
256 #if defined(__AVR_ATmega128__)
257  // CPU specific: different values for the ATmega128
258  sbi(TCCR0, CS02);
259 #elif defined(TCCR0) && defined(CS01) && defined(CS00)
260  // this combination is for the standard atmega8
261  sbi(TCCR0, CS01);
262  sbi(TCCR0, CS00);
263 #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
264  // this combination is for the standard 168/328/1280/2560
265  sbi(TCCR0B, CS01);
266  sbi(TCCR0B, CS00);
267 #elif defined(TCCR0A) && defined(CS01) && defined(CS00)
268  // this combination is for the __AVR_ATmega645__ series
269  sbi(TCCR0A, CS01);
270  sbi(TCCR0A, CS00);
271 #else
272  #error Timer 0 prescale factor 64 not set correctly
273 #endif
274 
275  // enable timer 0 overflow interrupt
276 #if defined(TIMSK) && defined(TOIE0)
277  sbi(TIMSK, TOIE0);
278 #elif defined(TIMSK0) && defined(TOIE0)
279  sbi(TIMSK0, TOIE0);
280 #else
281  #error Timer 0 overflow interrupt not set correctly
282 #endif
283 
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
288 
289 #if defined(TCCR1B) && defined(CS11) && defined(CS10)
290  TCCR1B = 0;
291 
292  // set timer 1 prescale factor to 64
293  sbi(TCCR1B, CS11);
294 #if F_CPU >= 8000000L
295  sbi(TCCR1B, CS10);
296 #endif
297 #elif defined(TCCR1) && defined(CS11) && defined(CS10)
298  sbi(TCCR1, CS11);
299 #if F_CPU >= 8000000L
300  sbi(TCCR1, CS10);
301 #endif
302 #endif
303  // put timer 1 in 8-bit phase correct pwm mode
304 #if defined(TCCR1A) && defined(WGM10)
305  sbi(TCCR1A, WGM10);
306 #endif
307 
308  // set timer 2 prescale factor to 64
309 #if defined(TCCR2) && defined(CS22)
310  sbi(TCCR2, CS22);
311 #elif defined(TCCR2B) && defined(CS22)
312  sbi(TCCR2B, CS22);
313 //#else
314  // Timer 2 not finished (may not be present on this CPU)
315 #endif
316 
317  // configure timer 2 for phase correct pwm (8-bit)
318 #if defined(TCCR2) && defined(WGM20)
319  sbi(TCCR2, WGM20);
320 #elif defined(TCCR2A) && defined(WGM20)
321  sbi(TCCR2A, WGM20);
322 //#else
323  // Timer 2 not finished (may not be present on this CPU)
324 #endif
325 
326 #if defined(TCCR3B) && defined(CS31) && defined(WGM30)
327  sbi(TCCR3B, CS31); // set timer 3 prescale factor to 64
328  sbi(TCCR3B, CS30);
329  sbi(TCCR3A, WGM30); // put timer 3 in 8-bit phase correct pwm mode
330 #endif
331 
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
334  sbi(TCCR4B, CS41);
335  sbi(TCCR4B, CS40);
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
342  sbi(TCCR4B, CS40);
343  sbi(TCCR4A, WGM40); // put timer 4 in 8-bit phase correct pwm mode
344 #endif
345 #endif /* end timer4 block for ATMEGA1280/2560 and similar */
346 
347 #if defined(TCCR5B) && defined(CS51) && defined(WGM50)
348  sbi(TCCR5B, CS51); // set timer 5 prescale factor to 64
349  sbi(TCCR5B, CS50);
350  sbi(TCCR5A, WGM50); // put timer 5 in 8-bit phase correct pwm mode
351 #endif
352 
353 #if defined(ADCSRA)
354  // set a2d prescaler so we are inside the desired 50-200 KHz range.
355  #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
356  sbi(ADCSRA, ADPS2);
357  sbi(ADCSRA, ADPS1);
358  sbi(ADCSRA, ADPS0);
359  #elif F_CPU >= 8000000 // 8 MHz / 64 = 125 KHz
360  sbi(ADCSRA, ADPS2);
361  sbi(ADCSRA, ADPS1);
362  cbi(ADCSRA, ADPS0);
363  #elif F_CPU >= 4000000 // 4 MHz / 32 = 125 KHz
364  sbi(ADCSRA, ADPS2);
365  cbi(ADCSRA, ADPS1);
366  sbi(ADCSRA, ADPS0);
367  #elif F_CPU >= 2000000 // 2 MHz / 16 = 125 KHz
368  sbi(ADCSRA, ADPS2);
369  cbi(ADCSRA, ADPS1);
370  cbi(ADCSRA, ADPS0);
371  #elif F_CPU >= 1000000 // 1 MHz / 8 = 125 KHz
372  cbi(ADCSRA, ADPS2);
373  sbi(ADCSRA, ADPS1);
374  sbi(ADCSRA, ADPS0);
375  #else // 128 kHz / 2 = 64 KHz -> This is the closest you can get, the prescaler is 2
376  cbi(ADCSRA, ADPS2);
377  cbi(ADCSRA, ADPS1);
378  sbi(ADCSRA, ADPS0);
379  #endif
380  // enable a2d conversions
381  sbi(ADCSRA, ADEN);
382 #endif
383 
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()
387 #if defined(UCSRB)
388  UCSRB = 0;
389 #elif defined(UCSR0B)
390  UCSR0B = 0;
391 #endif
392 }
#define sei()
Definition: interrupt.h:81
#define TCCR3A
Definition: iocanxx.h:274
#define CS11
Definition: io2313.h:250
#define PWM4A
Definition: iom16u4.h:941
#define WGM00
Definition: io90pwm1.h:295
#define ADCSRA
Definition: io90pwm1.h:551
#define CS02
Definition: io1200.h:152
#define CS22
Definition: io4434.h:358
#define CS10
Definition: io2313.h:251
#define WGM01
Definition: io90pwm1.h:294
#define ADPS2
Definition: io2333.h:363
#define UCSRB
Definition: io2333.h:76
#define WGM40
Definition: iom1284rfr2.h:969
#define TCCR1A
Definition: pins_arduino.h:68
#define ADPS0
Definition: io2333.h:365
#define CS30
Definition: iocanxx.h:845
#define WGM10
Definition: io90pwm1.h:613
#define TIMSK
Definition: io1200.h:105
#define WGM20
Definition: io90scr100.h:989
#define TCCR5A
Definition: iom1284rfr2.h:1748
#define sbi(sfr, bit)
Definition: ATmegaBOOT.c:75
#define TCCR4C
Definition: iom1284rfr2.h:987
#define WGM50
Definition: iom1284rfr2.h:1749
#define CS51
Definition: iom1284rfr2.h:1760
#define TCCR2
Definition: io4434.h:149
#define TCCR5B
Definition: iom1284rfr2.h:1758
#define TCCR2A
Definition: io90scr100.h:988
#define CS42
Definition: iom1284rfr2.h:981
#define CS31
Definition: iocanxx.h:844
#define UCSR0B
Definition: io90scr100.h:1110
#define TCCR0
Definition: io1200.h:93
#define TOIE0
Definition: io1200.h:140
#define PWM4D
Definition: iom16u4.h:960
#define CS50
Definition: iom1284rfr2.h:1759
#define cbi(sfr, bit)
Definition: ATmegaBOOT.c:72
#define TCCR4B
Definition: iom1284rfr2.h:978
#define TCCR4A
Definition: iom1284rfr2.h:968
#define CS40
Definition: iom1284rfr2.h:979
#define ADPS1
Definition: io2333.h:364
#define TCCR3B
Definition: iocanxx.h:277
#define WGM30
Definition: iocanxx.h:823
#define TCCR0B
Definition: io90pwm1.h:298
#define TCCR1
Definition: io8534.h:100
#define ADEN
Definition: io2333.h:358
#define TIMSK0
Definition: io90pwm1.h:515
#define CS41
Definition: iom1284rfr2.h:980
#define CS00
Definition: io1200.h:154
#define TCCR0A
Definition: io90pwm1.h:288
#define TCCR2B
Definition: io90scr100.h:996
#define TCCR4D
Definition: iom16u4.h:969
#define CS01
Definition: io1200.h:153
#define TCCR1B
Definition: io2313.h:117

◆ micros()

unsigned long micros ( void  )

wiring.c79 行目に定義があります。

79  {
80  unsigned long m;
81  uint8_t oldSREG = SREG, t;
82 
83  cli();
85 #if defined(TCNT0)
86  t = TCNT0;
87 #elif defined(TCNT0L)
88  t = TCNT0L;
89 #else
90  #error TIMER 0 not defined
91 #endif
92 
93 #ifdef TIFR0
94  if ((TIFR0 & _BV(TOV0)) && (t < 255))
95  m++;
96 #else
97  if ((TIFR & _BV(TOV0)) && (t < 255))
98  m++;
99 #endif
100 
101  SREG = oldSREG;
102 
103  return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
104 }
#define SREG
Definition: common.h:103
#define TCNT0L
Definition: iom16hva2.h:177
#define TIFR
Definition: io1200.h:102
volatile unsigned long timer0_overflow_count
Definition: wiring.c:38
m
Definition: wiring.c:53
#define clockCyclesPerMicrosecond()
Definition: Arduino.h:104
#define TIFR0
Definition: io90pwm1.h:153
#define cli()
Definition: interrupt.h:99
#define _BV(bit)
Definition: sfr_defs.h:208
#define TOV0
Definition: io1200.h:143
#define TCNT0
Definition: io1200.h:92

◆ millis()

unsigned long millis ( void  )

wiring.c65 行目に定義があります。

66 {
67  unsigned long m;
68  uint8_t oldSREG = SREG;
69 
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)
72  cli();
73  m = timer0_millis;
74  SREG = oldSREG;
75 
76  return m;
77 }
#define SREG
Definition: common.h:103
m
Definition: wiring.c:53
#define cli()
Definition: interrupt.h:99
volatile unsigned long timer0_millis
Definition: wiring.c:39

変数詳解

◆ f

f = timer0_fract

wiring.c51 行目に定義があります。

◆ m

wiring.c53 行目に定義があります。

◆ timer0_millis

timer0_millis = 0

wiring.c39 行目に定義があります。

◆ timer0_overflow_count

timer0_overflow_count = 0

wiring.c38 行目に定義があります。