d8: 0c 94 ce 01 jmp 0x39c ; 0x39c <_exit> 000000dc <__bad_interrupt>: dc: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000e0 : } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); e0: e1 eb ldi r30, 0xB1 ; 177 e2: f0 e0 ldi r31, 0x00 ; 0 e4: 24 91 lpm r18, Z uint8_t bit = digitalPinToBitMask(pin); e6: ed e9 ldi r30, 0x9D ; 157 e8: f0 e0 ldi r31, 0x00 ; 0 ea: 94 91 lpm r25, Z uint8_t port = digitalPinToPort(pin); ec: e9 e8 ldi r30, 0x89 ; 137 ee: f0 e0 ldi r31, 0x00 ; 0 f0: e4 91 lpm r30, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; f2: ee 23 and r30, r30 f4: 09 f4 brne .+2 ; 0xf8 f6: 3b c0 rjmp .+118 ; 0x16e // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); f8: 22 23 and r18, r18 fa: 39 f1 breq .+78 ; 0x14a // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) fc: 23 30 cpi r18, 0x03 ; 3 fe: 91 f0 breq .+36 ; 0x124 100: 38 f4 brcc .+14 ; 0x110 102: 21 30 cpi r18, 0x01 ; 1 104: a9 f0 breq .+42 ; 0x130 106: 22 30 cpi r18, 0x02 ; 2 108: 01 f5 brne .+64 ; 0x14a #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 10a: 24 b5 in r18, 0x24 ; 36 10c: 2f 7d andi r18, 0xDF ; 223 10e: 12 c0 rjmp .+36 ; 0x134 // //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); //static inline void turnOffPWM(uint8_t timer) static void turnOffPWM(uint8_t timer) { switch (timer) 110: 27 30 cpi r18, 0x07 ; 7 112: 91 f0 breq .+36 ; 0x138 114: 28 30 cpi r18, 0x08 ; 8 116: a1 f0 breq .+40 ; 0x140 118: 24 30 cpi r18, 0x04 ; 4 11a: b9 f4 brne .+46 ; 0x14a { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 11c: 20 91 80 00 lds r18, 0x0080 120: 2f 7d andi r18, 0xDF ; 223 122: 03 c0 rjmp .+6 ; 0x12a static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 124: 20 91 80 00 lds r18, 0x0080 128: 2f 77 andi r18, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 12a: 20 93 80 00 sts 0x0080, r18 12e: 0d c0 rjmp .+26 ; 0x14a #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 130: 24 b5 in r18, 0x24 ; 36 132: 2f 77 andi r18, 0x7F ; 127 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 134: 24 bd out 0x24, r18 ; 36 136: 09 c0 rjmp .+18 ; 0x14a #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 138: 20 91 b0 00 lds r18, 0x00B0 13c: 2f 77 andi r18, 0x7F ; 127 13e: 03 c0 rjmp .+6 ; 0x146 #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 140: 20 91 b0 00 lds r18, 0x00B0 144: 2f 7d andi r18, 0xDF ; 223 146: 20 93 b0 00 sts 0x00B0, r18 // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); out = portOutputRegister(port); 14a: f0 e0 ldi r31, 0x00 ; 0 14c: ee 0f add r30, r30 14e: ff 1f adc r31, r31 150: ee 58 subi r30, 0x8E ; 142 152: ff 4f sbci r31, 0xFF ; 255 154: a5 91 lpm r26, Z+ 156: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 158: 2f b7 in r18, 0x3f ; 63 cli(); 15a: f8 94 cli if (val == LOW) { *out &= ~bit; 15c: ec 91 ld r30, X out = portOutputRegister(port); uint8_t oldSREG = SREG; cli(); if (val == LOW) { 15e: 81 11 cpse r24, r1 160: 03 c0 rjmp .+6 ; 0x168 *out &= ~bit; 162: 90 95 com r25 164: 9e 23 and r25, r30 166: 01 c0 rjmp .+2 ; 0x16a } else { *out |= bit; 168: 9e 2b or r25, r30 16a: 9c 93 st X, r25 } SREG = oldSREG; 16c: 2f bf out 0x3f, r18 ; 63 16e: 08 95 ret 00000170 : return m; } unsigned long micros() { unsigned long m; uint8_t oldSREG = SREG, t; 170: 3f b7 in r19, 0x3f ; 63 cli(); 172: f8 94 cli m = timer0_overflow_count; 174: 80 91 05 01 lds r24, 0x0105 178: 90 91 06 01 lds r25, 0x0106 17c: a0 91 07 01 lds r26, 0x0107 180: b0 91 08 01 lds r27, 0x0108 #if defined(TCNT0) t = TCNT0; 184: 26 b5 in r18, 0x26 ; 38 #else #error TIMER 0 not defined #endif #ifdef TIFR0 if ((TIFR0 & _BV(TOV0)) && (t < 255)) 186: a8 9b sbis 0x15, 0 ; 21 188: 05 c0 rjmp .+10 ; 0x194 18a: 2f 3f cpi r18, 0xFF ; 255 18c: 19 f0 breq .+6 ; 0x194 m++; 18e: 01 96 adiw r24, 0x01 ; 1 190: a1 1d adc r26, r1 192: b1 1d adc r27, r1 #else if ((TIFR & _BV(TOV0)) && (t < 255)) m++; #endif SREG = oldSREG; 194: 3f bf out 0x3f, r19 ; 63 return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); 196: ba 2f mov r27, r26 198: a9 2f mov r26, r25 19a: 98 2f mov r25, r24 19c: 88 27 eor r24, r24 19e: 82 0f add r24, r18 1a0: 91 1d adc r25, r1 1a2: a1 1d adc r26, r1 1a4: b1 1d adc r27, r1 1a6: bc 01 movw r22, r24 1a8: cd 01 movw r24, r26 1aa: 42 e0 ldi r20, 0x02 ; 2 1ac: 66 0f add r22, r22 1ae: 77 1f adc r23, r23 1b0: 88 1f adc r24, r24 1b2: 99 1f adc r25, r25 1b4: 4a 95 dec r20 1b6: d1 f7 brne .-12 ; 0x1ac } 1b8: 08 95 ret 000001ba : void delay(unsigned long ms) 1ba: 8f 92 push r8 1bc: 9f 92 push r9 1be: af 92 push r10 1c0: bf 92 push r11 1c2: cf 92 push r12 1c4: df 92 push r13 1c6: ef 92 push r14 1c8: ff 92 push r15 { uint32_t start = micros(); 1ca: 0e 94 b8 00 call 0x170 ; 0x170 1ce: 4b 01 movw r8, r22 1d0: 5c 01 movw r10, r24 1d2: 88 ee ldi r24, 0xE8 ; 232 1d4: c8 2e mov r12, r24 1d6: 83 e0 ldi r24, 0x03 ; 3 1d8: d8 2e mov r13, r24 1da: e1 2c mov r14, r1 1dc: f1 2c mov r15, r1 while (ms > 0) { yield(); while ( ms > 0 && (micros() - start) >= 1000) { 1de: 0e 94 b8 00 call 0x170 ; 0x170 1e2: dc 01 movw r26, r24 1e4: cb 01 movw r24, r22 1e6: 88 19 sub r24, r8 1e8: 99 09 sbc r25, r9 1ea: aa 09 sbc r26, r10 1ec: bb 09 sbc r27, r11 1ee: 88 3e cpi r24, 0xE8 ; 232 1f0: 93 40 sbci r25, 0x03 ; 3 1f2: a1 05 cpc r26, r1 1f4: b1 05 cpc r27, r1 1f6: 58 f0 brcs .+22 ; 0x20e ms--; 1f8: 21 e0 ldi r18, 0x01 ; 1 1fa: c2 1a sub r12, r18 1fc: d1 08 sbc r13, r1 1fe: e1 08 sbc r14, r1 200: f1 08 sbc r15, r1 start += 1000; 202: 88 ee ldi r24, 0xE8 ; 232 204: 88 0e add r8, r24 206: 83 e0 ldi r24, 0x03 ; 3 208: 98 1e adc r9, r24 20a: a1 1c adc r10, r1 20c: b1 1c adc r11, r1 { uint32_t start = micros(); while (ms > 0) { yield(); while ( ms > 0 && (micros() - start) >= 1000) { 20e: c1 14 cp r12, r1 210: d1 04 cpc r13, r1 212: e1 04 cpc r14, r1 214: f1 04 cpc r15, r1 216: 19 f7 brne .-58 ; 0x1de ms--; start += 1000; } } } 218: ff 90 pop r15 21a: ef 90 pop r14 21c: df 90 pop r13 21e: cf 90 pop r12 220: bf 90 pop r11 222: af 90 pop r10 224: 9f 90 pop r9 226: 8f 90 pop r8 228: 08 95 ret 0000022a <__vector_16>: #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { 22a: 1f 92 push r1 22c: 0f 92 push r0 22e: 0f b6 in r0, 0x3f ; 63 230: 0f 92 push r0 232: 11 24 eor r1, r1 234: 2f 93 push r18 236: 3f 93 push r19 238: 8f 93 push r24 23a: 9f 93 push r25 23c: af 93 push r26 23e: bf 93 push r27 // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; 240: 80 91 01 01 lds r24, 0x0101 244: 90 91 02 01 lds r25, 0x0102 248: a0 91 03 01 lds r26, 0x0103 24c: b0 91 04 01 lds r27, 0x0104 unsigned char f = timer0_fract; 250: 30 91 00 01 lds r19, 0x0100 m += MILLIS_INC; f += FRACT_INC; 254: 23 e0 ldi r18, 0x03 ; 3 256: 23 0f add r18, r19 if (f >= FRACT_MAX) { 258: 2d 37 cpi r18, 0x7D ; 125 25a: 20 f4 brcc .+8 ; 0x264 <__vector_16+0x3a> // copy these to local variables so they can be stored in registers // (volatile variables must be read from memory on every access) unsigned long m = timer0_millis; unsigned char f = timer0_fract; m += MILLIS_INC; 25c: 01 96 adiw r24, 0x01 ; 1 25e: a1 1d adc r26, r1 260: b1 1d adc r27, r1 262: 05 c0 rjmp .+10 ; 0x26e <__vector_16+0x44> f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 264: 26 e8 ldi r18, 0x86 ; 134 266: 23 0f add r18, r19 m += 1; 268: 02 96 adiw r24, 0x02 ; 2 26a: a1 1d adc r26, r1 26c: b1 1d adc r27, r1 } timer0_fract = f; 26e: 20 93 00 01 sts 0x0100, r18 timer0_millis = m; 272: 80 93 01 01 sts 0x0101, r24 276: 90 93 02 01 sts 0x0102, r25 27a: a0 93 03 01 sts 0x0103, r26 27e: b0 93 04 01 sts 0x0104, r27 timer0_overflow_count++; 282: 80 91 05 01 lds r24, 0x0105 286: 90 91 06 01 lds r25, 0x0106 28a: a0 91 07 01 lds r26, 0x0107 28e: b0 91 08 01 lds r27, 0x0108 292: 01 96 adiw r24, 0x01 ; 1 294: a1 1d adc r26, r1 296: b1 1d adc r27, r1 298: 80 93 05 01 sts 0x0105, r24 29c: 90 93 06 01 sts 0x0106, r25 2a0: a0 93 07 01 sts 0x0107, r26 2a4: b0 93 08 01 sts 0x0108, r27 } 2a8: bf 91 pop r27 2aa: af 91 pop r26 2ac: 9f 91 pop r25 2ae: 8f 91 pop r24 2b0: 3f 91 pop r19 2b2: 2f 91 pop r18 2b4: 0f 90 pop r0 2b6: 0f be out 0x3f, r0 ; 63 2b8: 0f 90 pop r0 2ba: 1f 90 pop r1 2bc: 18 95 reti 000002be

: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 2be: 78 94 sei // on the ATmega168, timer 0 is also used for fast hardware pwm // (using phase-correct PWM would mean that timer 0 overflowed half as often // resulting in different millis() behavior on the ATmega8 and ATmega168) #if defined(TCCR0A) && defined(WGM01) sbi(TCCR0A, WGM01); 2c0: 84 b5 in r24, 0x24 ; 36 2c2: 82 60 ori r24, 0x02 ; 2 2c4: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 2c6: 84 b5 in r24, 0x24 ; 36 2c8: 81 60 ori r24, 0x01 ; 1 2ca: 84 bd out 0x24, r24 ; 36 // this combination is for the standard atmega8 sbi(TCCR0, CS01); sbi(TCCR0, CS00); #elif defined(TCCR0B) && defined(CS01) && defined(CS00) // this combination is for the standard 168/328/1280/2560 sbi(TCCR0B, CS01); 2cc: 85 b5 in r24, 0x25 ; 37 2ce: 82 60 ori r24, 0x02 ; 2 2d0: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 2d2: 85 b5 in r24, 0x25 ; 37 2d4: 81 60 ori r24, 0x01 ; 1 2d6: 85 bd out 0x25, r24 ; 37 // enable timer 0 overflow interrupt #if defined(TIMSK) && defined(TOIE0) sbi(TIMSK, TOIE0); #elif defined(TIMSK0) && defined(TOIE0) sbi(TIMSK0, TOIE0); 2d8: 80 91 6e 00 lds r24, 0x006E 2dc: 81 60 ori r24, 0x01 ; 1 2de: 80 93 6e 00 sts 0x006E, r24 // this is better for motors as it ensures an even waveform // note, however, that fast pwm mode can achieve a frequency of up // 8 MHz (with a 16 MHz clock) at 50% duty cycle #if defined(TCCR1B) && defined(CS11) && defined(CS10) TCCR1B = 0; 2e2: 10 92 81 00 sts 0x0081, r1 // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 2e6: 80 91 81 00 lds r24, 0x0081 2ea: 82 60 ori r24, 0x02 ; 2 2ec: 80 93 81 00 sts 0x0081, r24 #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 2f0: 80 91 81 00 lds r24, 0x0081 2f4: 81 60 ori r24, 0x01 ; 1 2f6: 80 93 81 00 sts 0x0081, r24 sbi(TCCR1, CS10); #endif #endif // put timer 1 in 8-bit phase correct pwm mode #if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); 2fa: 80 91 80 00 lds r24, 0x0080 2fe: 81 60 ori r24, 0x01 ; 1 300: 80 93 80 00 sts 0x0080, r24 // set timer 2 prescale factor to 64 #if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); #elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); 304: 80 91 b1 00 lds r24, 0x00B1 308: 84 60 ori r24, 0x04 ; 4 30a: 80 93 b1 00 sts 0x00B1, r24 // configure timer 2 for phase correct pwm (8-bit) #if defined(TCCR2) && defined(WGM20) sbi(TCCR2, WGM20); #elif defined(TCCR2A) && defined(WGM20) sbi(TCCR2A, WGM20); 30e: 80 91 b0 00 lds r24, 0x00B0 312: 81 60 ori r24, 0x01 ; 1 314: 80 93 b0 00 sts 0x00B0, r24 #endif #if defined(ADCSRA) // set a2d prescaler so we are inside the desired 50-200 KHz range. #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz sbi(ADCSRA, ADPS2); 318: 80 91 7a 00 lds r24, 0x007A 31c: 84 60 ori r24, 0x04 ; 4 31e: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS1); 322: 80 91 7a 00 lds r24, 0x007A 326: 82 60 ori r24, 0x02 ; 2 328: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS0); 32c: 80 91 7a 00 lds r24, 0x007A 330: 81 60 ori r24, 0x01 ; 1 332: 80 93 7a 00 sts 0x007A, r24 cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 336: 80 91 7a 00 lds r24, 0x007A 33a: 80 68 ori r24, 0x80 ; 128 33c: 80 93 7a 00 sts 0x007A, r24 // here so they can be used as normal digital i/o; they will be // reconnected in Serial.begin() #if defined(UCSRB) UCSRB = 0; #elif defined(UCSR0B) UCSR0B = 0; 340: 10 92 c1 00 sts 0x00C1, r1 #include "wiring_private.h" #include "pins_arduino.h" void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); 344: ed e9 ldi r30, 0x9D ; 157 346: f0 e0 ldi r31, 0x00 ; 0 348: 24 91 lpm r18, Z uint8_t port = digitalPinToPort(pin); 34a: e9 e8 ldi r30, 0x89 ; 137 34c: f0 e0 ldi r31, 0x00 ; 0 34e: 84 91 lpm r24, Z volatile uint8_t *reg, *out; if (port == NOT_A_PIN) return; 350: 88 23 and r24, r24 352: 99 f0 breq .+38 ; 0x37a // JWS: can I let the optimizer do this? reg = portModeRegister(port); 354: 90 e0 ldi r25, 0x00 ; 0 356: 88 0f add r24, r24 358: 99 1f adc r25, r25 35a: fc 01 movw r30, r24 35c: e8 59 subi r30, 0x98 ; 152 35e: ff 4f sbci r31, 0xFF ; 255 360: a5 91 lpm r26, Z+ 362: b4 91 lpm r27, Z out = portOutputRegister(port); 364: fc 01 movw r30, r24 366: ee 58 subi r30, 0x8E ; 142 368: ff 4f sbci r31, 0xFF ; 255 36a: 85 91 lpm r24, Z+ 36c: 94 91 lpm r25, Z cli(); *reg &= ~bit; *out |= bit; SREG = oldSREG; } else { uint8_t oldSREG = SREG; 36e: 8f b7 in r24, 0x3f ; 63 cli(); 370: f8 94 cli *reg |= bit; 372: ec 91 ld r30, X 374: e2 2b or r30, r18 376: ec 93 st X, r30 SREG = oldSREG; 378: 8f bf out 0x3f, r24 ; 63 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 37a: c0 e0 ldi r28, 0x00 ; 0 37c: d0 e0 ldi r29, 0x00 ; 0 pinMode(LED_BUILTIN, OUTPUT); } // the loop function runs over and over again forever void loop() { digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level) 37e: 81 e0 ldi r24, 0x01 ; 1 380: 0e 94 70 00 call 0xe0 ; 0xe0 delay(1000); // wait for a second 384: 0e 94 dd 00 call 0x1ba ; 0x1ba digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW 388: 80 e0 ldi r24, 0x00 ; 0 38a: 0e 94 70 00 call 0xe0 ; 0xe0 delay(1000); // wait for a second 38e: 0e 94 dd 00 call 0x1ba ; 0x1ba 392: 20 97 sbiw r28, 0x00 ; 0 394: a1 f3 breq .-24 ; 0x37e 396: 0e 94 00 00 call 0 ; 0x0 <__vectors> 39a: f1 cf rjmp .-30 ; 0x37e 0000039c <_exit>: 39c: f8 94 cli 0000039e <__stop_program>: 39e: ff cf rjmp .-2 ; 0x39e <__stop_program>