simple_analog_write.ino.elf: file format elf32-avr Disassembly of section .text: 00000000 <__vectors>: 0: 0c 94 5c 00 jmp 0xb8 ; 0xb8 <__ctors_end> 4: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 8: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 10: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 14: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 18: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 1c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 20: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 24: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 28: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 2c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 30: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 34: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 38: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 3c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 40: 0c 94 8c 00 jmp 0x118 ; 0x118 <__vector_16> 44: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 48: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 4c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 50: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 54: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 58: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 5c: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 60: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 64: 0c 94 6e 00 jmp 0xdc ; 0xdc <__bad_interrupt> 00000068 <__trampolines_end>: 68: 00 00 nop 6a: 00 08 sbc r0, r0 6c: 00 02 muls r16, r16 6e: 01 00 .word 0x0001 ; ???? 70: 00 03 mulsu r16, r16 72: 04 07 cpc r16, r20 ... 0000007c : 7c: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+. 00000086 : 86: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*. 00000090 : 90: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ a0: 03 03 03 03 .... 000000a4 : a4: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. b4: 04 08 10 20 ... 000000b8 <__ctors_end>: b8: 11 24 eor r1, r1 ba: 1f be out 0x3f, r1 ; 63 bc: cf ef ldi r28, 0xFF ; 255 be: d8 e0 ldi r29, 0x08 ; 8 c0: de bf out 0x3e, r29 ; 62 c2: cd bf out 0x3d, r28 ; 61 000000c4 <__do_clear_bss>: c4: 21 e0 ldi r18, 0x01 ; 1 c6: a0 e0 ldi r26, 0x00 ; 0 c8: b1 e0 ldi r27, 0x01 ; 1 ca: 01 c0 rjmp .+2 ; 0xce <.do_clear_bss_start> 000000cc <.do_clear_bss_loop>: cc: 1d 92 st X+, r1 000000ce <.do_clear_bss_start>: ce: a9 30 cpi r26, 0x09 ; 9 d0: b2 07 cpc r27, r18 d2: e1 f7 brne .-8 ; 0xcc <.do_clear_bss_loop> d4: 0e 94 d6 00 call 0x1ac ; 0x1ac
d8: 0c 94 ad 01 jmp 0x35a ; 0x35a <_exit> 000000dc <__bad_interrupt>: dc: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000e0 : #include "wiring_private.h" #include "pins_arduino.h" void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); e0: e7 ea ldi r30, 0xA7 ; 167 e2: f0 e0 ldi r31, 0x00 ; 0 e4: 24 91 lpm r18, Z uint8_t port = digitalPinToPort(pin); e6: e3 e9 ldi r30, 0x93 ; 147 e8: f0 e0 ldi r31, 0x00 ; 0 ea: 84 91 lpm r24, Z volatile uint8_t *reg, *out; if (port == NOT_A_PIN) return; ec: 88 23 and r24, r24 ee: 99 f0 breq .+38 ; 0x116 // JWS: can I let the optimizer do this? reg = portModeRegister(port); f0: 90 e0 ldi r25, 0x00 ; 0 f2: 88 0f add r24, r24 f4: 99 1f adc r25, r25 f6: fc 01 movw r30, r24 f8: ea 57 subi r30, 0x7A ; 122 fa: ff 4f sbci r31, 0xFF ; 255 fc: a5 91 lpm r26, Z+ fe: b4 91 lpm r27, Z out = portOutputRegister(port); 100: fc 01 movw r30, r24 102: e4 58 subi r30, 0x84 ; 132 104: ff 4f sbci r31, 0xFF ; 255 106: 85 91 lpm r24, Z+ 108: 94 91 lpm r25, Z cli(); *reg &= ~bit; *out |= bit; SREG = oldSREG; } else { uint8_t oldSREG = SREG; 10a: 8f b7 in r24, 0x3f ; 63 cli(); 10c: f8 94 cli *reg |= bit; 10e: ec 91 ld r30, X 110: e2 2b or r30, r18 112: ec 93 st X, r30 SREG = oldSREG; 114: 8f bf out 0x3f, r24 ; 63 116: 08 95 ret 00000118 <__vector_16>: #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { 118: 1f 92 push r1 11a: 0f 92 push r0 11c: 0f b6 in r0, 0x3f ; 63 11e: 0f 92 push r0 120: 11 24 eor r1, r1 122: 2f 93 push r18 124: 3f 93 push r19 126: 8f 93 push r24 128: 9f 93 push r25 12a: af 93 push r26 12c: 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; 12e: 80 91 05 01 lds r24, 0x0105 132: 90 91 06 01 lds r25, 0x0106 136: a0 91 07 01 lds r26, 0x0107 13a: b0 91 08 01 lds r27, 0x0108 unsigned char f = timer0_fract; 13e: 30 91 04 01 lds r19, 0x0104 m += MILLIS_INC; f += FRACT_INC; 142: 23 e0 ldi r18, 0x03 ; 3 144: 23 0f add r18, r19 if (f >= FRACT_MAX) { 146: 2d 37 cpi r18, 0x7D ; 125 148: 20 f4 brcc .+8 ; 0x152 <__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; 14a: 01 96 adiw r24, 0x01 ; 1 14c: a1 1d adc r26, r1 14e: b1 1d adc r27, r1 150: 05 c0 rjmp .+10 ; 0x15c <__vector_16+0x44> f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 152: 26 e8 ldi r18, 0x86 ; 134 154: 23 0f add r18, r19 m += 1; 156: 02 96 adiw r24, 0x02 ; 2 158: a1 1d adc r26, r1 15a: b1 1d adc r27, r1 } timer0_fract = f; 15c: 20 93 04 01 sts 0x0104, r18 timer0_millis = m; 160: 80 93 05 01 sts 0x0105, r24 164: 90 93 06 01 sts 0x0106, r25 168: a0 93 07 01 sts 0x0107, r26 16c: b0 93 08 01 sts 0x0108, r27 timer0_overflow_count++; 170: 80 91 00 01 lds r24, 0x0100 174: 90 91 01 01 lds r25, 0x0101 178: a0 91 02 01 lds r26, 0x0102 17c: b0 91 03 01 lds r27, 0x0103 180: 01 96 adiw r24, 0x01 ; 1 182: a1 1d adc r26, r1 184: b1 1d adc r27, r1 186: 80 93 00 01 sts 0x0100, r24 18a: 90 93 01 01 sts 0x0101, r25 18e: a0 93 02 01 sts 0x0102, r26 192: b0 93 03 01 sts 0x0103, r27 } 196: bf 91 pop r27 198: af 91 pop r26 19a: 9f 91 pop r25 19c: 8f 91 pop r24 19e: 3f 91 pop r19 1a0: 2f 91 pop r18 1a2: 0f 90 pop r0 1a4: 0f be out 0x3f, r0 ; 63 1a6: 0f 90 pop r0 1a8: 1f 90 pop r1 1aa: 18 95 reti 000001ac
: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 1ac: 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); 1ae: 84 b5 in r24, 0x24 ; 36 1b0: 82 60 ori r24, 0x02 ; 2 1b2: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 1b4: 84 b5 in r24, 0x24 ; 36 1b6: 81 60 ori r24, 0x01 ; 1 1b8: 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); 1ba: 85 b5 in r24, 0x25 ; 37 1bc: 82 60 ori r24, 0x02 ; 2 1be: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 1c0: 85 b5 in r24, 0x25 ; 37 1c2: 81 60 ori r24, 0x01 ; 1 1c4: 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); 1c6: 80 91 6e 00 lds r24, 0x006E 1ca: 81 60 ori r24, 0x01 ; 1 1cc: 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; 1d0: 10 92 81 00 sts 0x0081, r1 // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 1d4: 80 91 81 00 lds r24, 0x0081 1d8: 82 60 ori r24, 0x02 ; 2 1da: 80 93 81 00 sts 0x0081, r24 #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 1de: 80 91 81 00 lds r24, 0x0081 1e2: 81 60 ori r24, 0x01 ; 1 1e4: 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); 1e8: 80 91 80 00 lds r24, 0x0080 1ec: 81 60 ori r24, 0x01 ; 1 1ee: 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); 1f2: 80 91 b1 00 lds r24, 0x00B1 1f6: 84 60 ori r24, 0x04 ; 4 1f8: 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); 1fc: 80 91 b0 00 lds r24, 0x00B0 200: 81 60 ori r24, 0x01 ; 1 202: 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); 206: 80 91 7a 00 lds r24, 0x007A 20a: 84 60 ori r24, 0x04 ; 4 20c: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS1); 210: 80 91 7a 00 lds r24, 0x007A 214: 82 60 ori r24, 0x02 ; 2 216: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS0); 21a: 80 91 7a 00 lds r24, 0x007A 21e: 81 60 ori r24, 0x01 ; 1 220: 80 93 7a 00 sts 0x007A, r24 cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 224: 80 91 7a 00 lds r24, 0x007A 228: 80 68 ori r24, 0x80 ; 128 22a: 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; 22e: 10 92 c1 00 sts 0x00C1, r1 #include Servo myservo; // create servo object to control a servo int val=50; void setup() { 232: 0e 94 70 00 call 0xe0 ; 0xe0 // We need to make sure the PWM output is enabled for those pins // that support it, as we turn it off when digitally reading or // writing with them. Also, make sure the pin is in output mode // for consistenty with Wiring, which doesn't require a pinMode // call for the analog output pins. pinMode(pin, OUTPUT); 236: 0e 94 70 00 call 0xe0 ; 0xe0 { digitalWrite(pin, HIGH); } else { switch(digitalPinToTimer(pin)) 23a: eb e6 ldi r30, 0x6B ; 107 23c: f0 e0 ldi r31, 0x00 ; 0 23e: e4 91 lpm r30, Z 240: e3 30 cpi r30, 0x03 ; 3 242: 19 f1 breq .+70 ; 0x28a 244: 50 f4 brcc .+20 ; 0x25a 246: e1 30 cpi r30, 0x01 ; 1 248: d1 f0 breq .+52 ; 0x27e 24a: e2 30 cpi r30, 0x02 ; 2 24c: f1 f5 brne .+124 ; 0x2ca #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: // connect pwm to pin on timer 0, channel B sbi(TCCR0A, COM0B1); 24e: 84 b5 in r24, 0x24 ; 36 250: 80 62 ori r24, 0x20 ; 32 252: 84 bd out 0x24, r24 ; 36 OCR0B = val; // set pwm duty 254: 82 e3 ldi r24, 0x32 ; 50 256: 88 bd out 0x28, r24 ; 40 258: 35 c0 rjmp .+106 ; 0x2c4 { digitalWrite(pin, HIGH); } else { switch(digitalPinToTimer(pin)) 25a: e7 30 cpi r30, 0x07 ; 7 25c: 11 f1 breq .+68 ; 0x2a2 25e: e8 30 cpi r30, 0x08 ; 8 260: 49 f1 breq .+82 ; 0x2b4 262: e4 30 cpi r30, 0x04 ; 4 264: 91 f5 brne .+100 ; 0x2ca #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: // connect pwm to pin on timer 1, channel B sbi(TCCR1A, COM1B1); 266: 80 91 80 00 lds r24, 0x0080 26a: 80 62 ori r24, 0x20 ; 32 26c: 80 93 80 00 sts 0x0080, r24 OCR1B = val; // set pwm duty 270: 82 e3 ldi r24, 0x32 ; 50 272: 90 e0 ldi r25, 0x00 ; 0 274: 90 93 8b 00 sts 0x008B, r25 278: 80 93 8a 00 sts 0x008A, r24 27c: 23 c0 rjmp .+70 ; 0x2c4 #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: // connect pwm to pin on timer 0, channel A sbi(TCCR0A, COM0A1); 27e: 84 b5 in r24, 0x24 ; 36 280: 80 68 ori r24, 0x80 ; 128 282: 84 bd out 0x24, r24 ; 36 OCR0A = val; // set pwm duty 284: 82 e3 ldi r24, 0x32 ; 50 286: 87 bd out 0x27, r24 ; 39 288: 1d c0 rjmp .+58 ; 0x2c4 #endif #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: // connect pwm to pin on timer 1, channel A sbi(TCCR1A, COM1A1); 28a: 80 91 80 00 lds r24, 0x0080 28e: 80 68 ori r24, 0x80 ; 128 290: 80 93 80 00 sts 0x0080, r24 OCR1A = val; // set pwm duty 294: 82 e3 ldi r24, 0x32 ; 50 296: 90 e0 ldi r25, 0x00 ; 0 298: 90 93 89 00 sts 0x0089, r25 29c: 80 93 88 00 sts 0x0088, r24 2a0: 11 c0 rjmp .+34 ; 0x2c4 #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: // connect pwm to pin on timer 2, channel A sbi(TCCR2A, COM2A1); 2a2: 80 91 b0 00 lds r24, 0x00B0 2a6: 80 68 ori r24, 0x80 ; 128 2a8: 80 93 b0 00 sts 0x00B0, r24 OCR2A = val; // set pwm duty 2ac: 82 e3 ldi r24, 0x32 ; 50 2ae: 80 93 b3 00 sts 0x00B3, r24 2b2: 08 c0 rjmp .+16 ; 0x2c4 #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: // connect pwm to pin on timer 2, channel B sbi(TCCR2A, COM2B1); 2b4: 80 91 b0 00 lds r24, 0x00B0 2b8: 80 62 ori r24, 0x20 ; 32 2ba: 80 93 b0 00 sts 0x00B0, r24 OCR2B = val; // set pwm duty 2be: 82 e3 ldi r24, 0x32 ; 50 2c0: 80 93 b4 00 sts 0x00B4, r24 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 2c4: c0 e0 ldi r28, 0x00 ; 0 2c6: d0 e0 ldi r29, 0x00 ; 0 2c8: 45 c0 rjmp .+138 ; 0x354 } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); 2ca: eb e6 ldi r30, 0x6B ; 107 2cc: f0 e0 ldi r31, 0x00 ; 0 2ce: 84 91 lpm r24, Z uint8_t bit = digitalPinToBitMask(pin); 2d0: e7 ea ldi r30, 0xA7 ; 167 2d2: f0 e0 ldi r31, 0x00 ; 0 2d4: 94 91 lpm r25, Z uint8_t port = digitalPinToPort(pin); 2d6: e3 e9 ldi r30, 0x93 ; 147 2d8: f0 e0 ldi r31, 0x00 ; 0 2da: e4 91 lpm r30, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; 2dc: ee 23 and r30, r30 2de: 91 f3 breq .-28 ; 0x2c4 // 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); 2e0: 88 23 and r24, r24 2e2: 39 f1 breq .+78 ; 0x332 // //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) 2e4: 83 30 cpi r24, 0x03 ; 3 2e6: 91 f0 breq .+36 ; 0x30c 2e8: 38 f4 brcc .+14 ; 0x2f8 2ea: 81 30 cpi r24, 0x01 ; 1 2ec: a9 f0 breq .+42 ; 0x318 2ee: 82 30 cpi r24, 0x02 ; 2 2f0: 01 f5 brne .+64 ; 0x332 #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 2f2: 84 b5 in r24, 0x24 ; 36 2f4: 8f 7d andi r24, 0xDF ; 223 2f6: 12 c0 rjmp .+36 ; 0x31c // //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) 2f8: 87 30 cpi r24, 0x07 ; 7 2fa: 91 f0 breq .+36 ; 0x320 2fc: 88 30 cpi r24, 0x08 ; 8 2fe: a1 f0 breq .+40 ; 0x328 300: 84 30 cpi r24, 0x04 ; 4 302: b9 f4 brne .+46 ; 0x332 { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 304: 80 91 80 00 lds r24, 0x0080 308: 8f 7d andi r24, 0xDF ; 223 30a: 03 c0 rjmp .+6 ; 0x312 static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 30c: 80 91 80 00 lds r24, 0x0080 310: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 312: 80 93 80 00 sts 0x0080, r24 316: 0d c0 rjmp .+26 ; 0x332 #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 318: 84 b5 in r24, 0x24 ; 36 31a: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 31c: 84 bd out 0x24, r24 ; 36 31e: 09 c0 rjmp .+18 ; 0x332 #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 320: 80 91 b0 00 lds r24, 0x00B0 324: 8f 77 andi r24, 0x7F ; 127 326: 03 c0 rjmp .+6 ; 0x32e #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 328: 80 91 b0 00 lds r24, 0x00B0 32c: 8f 7d andi r24, 0xDF ; 223 32e: 80 93 b0 00 sts 0x00B0, r24 // 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); 332: f0 e0 ldi r31, 0x00 ; 0 334: ee 0f add r30, r30 336: ff 1f adc r31, r31 338: e4 58 subi r30, 0x84 ; 132 33a: ff 4f sbci r31, 0xFF ; 255 33c: a5 91 lpm r26, Z+ 33e: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 340: 8f b7 in r24, 0x3f ; 63 cli(); 342: f8 94 cli if (val == LOW) { *out &= ~bit; 344: ec 91 ld r30, X 346: 90 95 com r25 348: 9e 23 and r25, r30 34a: 9c 93 st X, r25 } else { *out |= bit; } SREG = oldSREG; 34c: 8f bf out 0x3f, r24 ; 63 34e: ba cf rjmp .-140 ; 0x2c4 350: 0e 94 00 00 call 0 ; 0x0 <__vectors> 354: 20 97 sbiw r28, 0x00 ; 0 356: f1 f3 breq .-4 ; 0x354 358: fb cf rjmp .-10 ; 0x350 0000035a <_exit>: 35a: f8 94 cli 0000035c <__stop_program>: 35c: ff cf rjmp .-2 ; 0x35c <__stop_program>