106: 0c 94 6e 03 jmp 0x6dc ; 0x6dc <_exit> 0000010a <__bad_interrupt>: 10a: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 0000010e : } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); 10e: 90 e0 ldi r25, 0x00 ; 0 110: fc 01 movw r30, r24 112: e8 59 subi r30, 0x98 ; 152 114: ff 4f sbci r31, 0xFF ; 255 116: 34 91 lpm r19, Z uint8_t bit = digitalPinToBitMask(pin); 118: fc 01 movw r30, r24 11a: ec 55 subi r30, 0x5C ; 92 11c: ff 4f sbci r31, 0xFF ; 255 11e: 24 91 lpm r18, Z uint8_t port = digitalPinToPort(pin); 120: fc 01 movw r30, r24 122: e0 57 subi r30, 0x70 ; 112 124: ff 4f sbci r31, 0xFF ; 255 126: e4 91 lpm r30, Z volatile uint8_t *out; if (port == NOT_A_PIN) return; 128: ee 23 and r30, r30 12a: 09 f4 brne .+2 ; 0x12e 12c: 3b c0 rjmp .+118 ; 0x1a4 // 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); 12e: 33 23 and r19, r19 130: 39 f1 breq .+78 ; 0x180 // //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) 132: 33 30 cpi r19, 0x03 ; 3 134: 91 f0 breq .+36 ; 0x15a 136: 38 f4 brcc .+14 ; 0x146 138: 31 30 cpi r19, 0x01 ; 1 13a: a9 f0 breq .+42 ; 0x166 13c: 32 30 cpi r19, 0x02 ; 2 13e: 01 f5 brne .+64 ; 0x180 #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 140: 84 b5 in r24, 0x24 ; 36 142: 8f 7d andi r24, 0xDF ; 223 144: 12 c0 rjmp .+36 ; 0x16a // //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) 146: 37 30 cpi r19, 0x07 ; 7 148: 91 f0 breq .+36 ; 0x16e 14a: 38 30 cpi r19, 0x08 ; 8 14c: a1 f0 breq .+40 ; 0x176 14e: 34 30 cpi r19, 0x04 ; 4 150: b9 f4 brne .+46 ; 0x180 { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 152: 80 91 80 00 lds r24, 0x0080 156: 8f 7d andi r24, 0xDF ; 223 158: 03 c0 rjmp .+6 ; 0x160 static void turnOffPWM(uint8_t timer) { switch (timer) { #if defined(TCCR1A) && defined(COM1A1) case TIMER1A: cbi(TCCR1A, COM1A1); break; 15a: 80 91 80 00 lds r24, 0x0080 15e: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR1A) && defined(COM1B1) case TIMER1B: cbi(TCCR1A, COM1B1); break; 160: 80 93 80 00 sts 0x0080, r24 164: 0d c0 rjmp .+26 ; 0x180 #if defined(TCCR2) && defined(COM21) case TIMER2: cbi(TCCR2, COM21); break; #endif #if defined(TCCR0A) && defined(COM0A1) case TIMER0A: cbi(TCCR0A, COM0A1); break; 166: 84 b5 in r24, 0x24 ; 36 168: 8f 77 andi r24, 0x7F ; 127 #endif #if defined(TCCR0A) && defined(COM0B1) case TIMER0B: cbi(TCCR0A, COM0B1); break; 16a: 84 bd out 0x24, r24 ; 36 16c: 09 c0 rjmp .+18 ; 0x180 #endif #if defined(TCCR2A) && defined(COM2A1) case TIMER2A: cbi(TCCR2A, COM2A1); break; 16e: 80 91 b0 00 lds r24, 0x00B0 172: 8f 77 andi r24, 0x7F ; 127 174: 03 c0 rjmp .+6 ; 0x17c #endif #if defined(TCCR2A) && defined(COM2B1) case TIMER2B: cbi(TCCR2A, COM2B1); break; 176: 80 91 b0 00 lds r24, 0x00B0 17a: 8f 7d andi r24, 0xDF ; 223 17c: 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); 180: f0 e0 ldi r31, 0x00 ; 0 182: ee 0f add r30, r30 184: ff 1f adc r31, r31 186: e4 58 subi r30, 0x84 ; 132 188: ff 4f sbci r31, 0xFF ; 255 18a: a5 91 lpm r26, Z+ 18c: b4 91 lpm r27, Z uint8_t oldSREG = SREG; 18e: 8f b7 in r24, 0x3f ; 63 cli(); 190: f8 94 cli if (val == LOW) { *out &= ~bit; 192: ec 91 ld r30, X out = portOutputRegister(port); uint8_t oldSREG = SREG; cli(); if (val == LOW) { 194: 61 11 cpse r22, r1 196: 03 c0 rjmp .+6 ; 0x19e *out &= ~bit; 198: 20 95 com r18 19a: 2e 23 and r18, r30 19c: 01 c0 rjmp .+2 ; 0x1a0 } else { *out |= bit; 19e: 2e 2b or r18, r30 1a0: 2c 93 st X, r18 } SREG = oldSREG; 1a2: 8f bf out 0x3f, r24 ; 63 1a4: 08 95 ret 000001a6 <__vector_16>: #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ISR(TIM0_OVF_vect) #else ISR(TIMER0_OVF_vect) #endif { 1a6: 1f 92 push r1 1a8: 0f 92 push r0 1aa: 0f b6 in r0, 0x3f ; 63 1ac: 0f 92 push r0 1ae: 11 24 eor r1, r1 1b0: 2f 93 push r18 1b2: 3f 93 push r19 1b4: 8f 93 push r24 1b6: 9f 93 push r25 1b8: af 93 push r26 1ba: 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; 1bc: 80 91 2e 01 lds r24, 0x012E 1c0: 90 91 2f 01 lds r25, 0x012F 1c4: a0 91 30 01 lds r26, 0x0130 1c8: b0 91 31 01 lds r27, 0x0131 unsigned char f = timer0_fract; 1cc: 30 91 2d 01 lds r19, 0x012D m += MILLIS_INC; f += FRACT_INC; 1d0: 23 e0 ldi r18, 0x03 ; 3 1d2: 23 0f add r18, r19 if (f >= FRACT_MAX) { 1d4: 2d 37 cpi r18, 0x7D ; 125 1d6: 20 f4 brcc .+8 ; 0x1e0 <__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; 1d8: 01 96 adiw r24, 0x01 ; 1 1da: a1 1d adc r26, r1 1dc: b1 1d adc r27, r1 1de: 05 c0 rjmp .+10 ; 0x1ea <__vector_16+0x44> f += FRACT_INC; if (f >= FRACT_MAX) { f -= FRACT_MAX; 1e0: 26 e8 ldi r18, 0x86 ; 134 1e2: 23 0f add r18, r19 m += 1; 1e4: 02 96 adiw r24, 0x02 ; 2 1e6: a1 1d adc r26, r1 1e8: b1 1d adc r27, r1 } timer0_fract = f; 1ea: 20 93 2d 01 sts 0x012D, r18 timer0_millis = m; 1ee: 80 93 2e 01 sts 0x012E, r24 1f2: 90 93 2f 01 sts 0x012F, r25 1f6: a0 93 30 01 sts 0x0130, r26 1fa: b0 93 31 01 sts 0x0131, r27 timer0_overflow_count++; 1fe: 80 91 29 01 lds r24, 0x0129 202: 90 91 2a 01 lds r25, 0x012A 206: a0 91 2b 01 lds r26, 0x012B 20a: b0 91 2c 01 lds r27, 0x012C 20e: 01 96 adiw r24, 0x01 ; 1 210: a1 1d adc r26, r1 212: b1 1d adc r27, r1 214: 80 93 29 01 sts 0x0129, r24 218: 90 93 2a 01 sts 0x012A, r25 21c: a0 93 2b 01 sts 0x012B, r26 220: b0 93 2c 01 sts 0x012C, r27 } 224: bf 91 pop r27 226: af 91 pop r26 228: 9f 91 pop r25 22a: 8f 91 pop r24 22c: 3f 91 pop r19 22e: 2f 91 pop r18 230: 0f 90 pop r0 232: 0f be out 0x3f, r0 ; 63 234: 0f 90 pop r0 236: 1f 90 pop r1 238: 18 95 reti 0000023a <__vector_11>: #ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform // Interrupt handlers for Arduino #if defined(_useTimer1) SIGNAL (TIMER1_COMPA_vect) { 23a: 1f 92 push r1 23c: 0f 92 push r0 23e: 0f b6 in r0, 0x3f ; 63 240: 0f 92 push r0 242: 11 24 eor r1, r1 244: 2f 93 push r18 246: 3f 93 push r19 248: 4f 93 push r20 24a: 5f 93 push r21 24c: 6f 93 push r22 24e: 7f 93 push r23 250: 8f 93 push r24 252: 9f 93 push r25 254: af 93 push r26 256: bf 93 push r27 258: ef 93 push r30 25a: ff 93 push r31 /************ static functions common to all instances ***********************/ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t *TCNTn, volatile uint16_t* OCRnA) { if( Channel[timer] < 0 ) 25c: 80 91 01 01 lds r24, 0x0101 260: 87 ff sbrs r24, 7 262: 05 c0 rjmp .+10 ; 0x26e <__vector_11+0x34> *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer 264: 10 92 85 00 sts 0x0085, r1 268: 10 92 84 00 sts 0x0084, r1 26c: 1b c0 rjmp .+54 ; 0x2a4 <__vector_11+0x6a> else{ if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive == true ) 26e: 20 91 01 01 lds r18, 0x0101 272: 02 2e mov r0, r18 274: 00 0c add r0, r0 276: 33 0b sbc r19, r19 278: 80 91 00 01 lds r24, 0x0100 27c: 90 e0 ldi r25, 0x00 ; 0 27e: 28 17 cp r18, r24 280: 39 07 cpc r19, r25 282: 84 f4 brge .+32 ; 0x2a4 <__vector_11+0x6a> 284: 80 91 01 01 lds r24, 0x0101 288: 08 2e mov r0, r24 28a: 00 0c add r0, r0 28c: 99 0b sbc r25, r25 28e: fc 01 movw r30, r24 290: ee 0f add r30, r30 292: ff 1f adc r31, r31 294: 8e 0f add r24, r30 296: 9f 1f adc r25, r31 298: fc 01 movw r30, r24 29a: ee 5f subi r30, 0xFE ; 254 29c: fe 4f sbci r31, 0xFE ; 254 29e: 80 81 ld r24, Z 2a0: 86 fd sbrc r24, 6 2a2: 15 c0 rjmp .+42 ; 0x2ce <__vector_11+0x94> digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW); // pulse this channel low if activated } Channel[timer]++; // increment to the next channel 2a4: 80 91 01 01 lds r24, 0x0101 2a8: 8f 5f subi r24, 0xFF ; 255 2aa: 80 93 01 01 sts 0x0101, r24 if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) { 2ae: 20 91 01 01 lds r18, 0x0101 2b2: 02 2e mov r0, r18 2b4: 00 0c add r0, r0 2b6: 33 0b sbc r19, r19 2b8: 80 91 00 01 lds r24, 0x0100 2bc: 90 e0 ldi r25, 0x00 ; 0 2be: 28 17 cp r18, r24 2c0: 39 07 cpc r19, r25 2c2: c4 f4 brge .+48 ; 0x2f4 <__vector_11+0xba> 2c4: 80 91 01 01 lds r24, 0x0101 2c8: 8c 30 cpi r24, 0x0C ; 12 2ca: 64 f1 brlt .+88 ; 0x324 <__vector_11+0xea> 2cc: 13 c0 rjmp .+38 ; 0x2f4 <__vector_11+0xba> { if( Channel[timer] < 0 ) *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer else{ if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive == true ) digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW); // pulse this channel low if activated 2ce: 80 91 01 01 lds r24, 0x0101 2d2: 08 2e mov r0, r24 2d4: 00 0c add r0, r0 2d6: 99 0b sbc r25, r25 2d8: fc 01 movw r30, r24 2da: ee 0f add r30, r30 2dc: ff 1f adc r31, r31 2de: 8e 0f add r24, r30 2e0: 9f 1f adc r25, r31 2e2: fc 01 movw r30, r24 2e4: ee 5f subi r30, 0xFE ; 254 2e6: fe 4f sbci r31, 0xFE ; 254 2e8: 80 81 ld r24, Z 2ea: 60 e0 ldi r22, 0x00 ; 0 2ec: 8f 73 andi r24, 0x3F ; 63 2ee: 0e 94 87 00 call 0x10e ; 0x10e 2f2: d8 cf rjmp .-80 ; 0x2a4 <__vector_11+0x6a> if(SERVO(timer,Channel[timer]).Pin.isActive == true) // check if activated digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH); // its an active channel so pulse it high } else { // finished all channels so wait for the refresh period to expire before starting over if( ((unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL) ) // allow a few ticks to ensure the next OCR1A not missed 2f4: 80 91 84 00 lds r24, 0x0084 2f8: 90 91 85 00 lds r25, 0x0085 2fc: 04 96 adiw r24, 0x04 ; 4 2fe: 80 34 cpi r24, 0x40 ; 64 300: 9c 49 sbci r25, 0x9C ; 156 302: 18 f4 brcc .+6 ; 0x30a <__vector_11+0xd0> *OCRnA = (unsigned int)usToTicks(REFRESH_INTERVAL); 304: 80 e4 ldi r24, 0x40 ; 64 306: 9c e9 ldi r25, 0x9C ; 156 308: 05 c0 rjmp .+10 ; 0x314 <__vector_11+0xda> else *OCRnA = *TCNTn + 4; // at least REFRESH_INTERVAL has elapsed 30a: 80 91 84 00 lds r24, 0x0084 30e: 90 91 85 00 lds r25, 0x0085 312: 04 96 adiw r24, 0x04 ; 4 314: 90 93 89 00 sts 0x0089, r25 318: 80 93 88 00 sts 0x0088, r24 Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel 31c: 8f ef ldi r24, 0xFF ; 255 31e: 80 93 01 01 sts 0x0101, r24 322: 3b c0 rjmp .+118 ; 0x39a <__vector_11+0x160> digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW); // pulse this channel low if activated } Channel[timer]++; // increment to the next channel if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) { *OCRnA = *TCNTn + SERVO(timer,Channel[timer]).ticks; 324: 20 91 84 00 lds r18, 0x0084 328: 30 91 85 00 lds r19, 0x0085 32c: 80 91 01 01 lds r24, 0x0101 330: 08 2e mov r0, r24 332: 00 0c add r0, r0 334: 99 0b sbc r25, r25 336: fc 01 movw r30, r24 338: ee 0f add r30, r30 33a: ff 1f adc r31, r31 33c: 8e 0f add r24, r30 33e: 9f 1f adc r25, r31 340: fc 01 movw r30, r24 342: ee 5f subi r30, 0xFE ; 254 344: fe 4f sbci r31, 0xFE ; 254 346: 81 81 ldd r24, Z+1 ; 0x01 348: 92 81 ldd r25, Z+2 ; 0x02 34a: 82 0f add r24, r18 34c: 93 1f adc r25, r19 34e: 90 93 89 00 sts 0x0089, r25 352: 80 93 88 00 sts 0x0088, r24 if(SERVO(timer,Channel[timer]).Pin.isActive == true) // check if activated 356: 80 91 01 01 lds r24, 0x0101 35a: 08 2e mov r0, r24 35c: 00 0c add r0, r0 35e: 99 0b sbc r25, r25 360: fc 01 movw r30, r24 362: ee 0f add r30, r30 364: ff 1f adc r31, r31 366: 8e 0f add r24, r30 368: 9f 1f adc r25, r31 36a: fc 01 movw r30, r24 36c: ee 5f subi r30, 0xFE ; 254 36e: fe 4f sbci r31, 0xFE ; 254 370: 80 81 ld r24, Z 372: 86 ff sbrs r24, 6 374: 12 c0 rjmp .+36 ; 0x39a <__vector_11+0x160> digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH); // its an active channel so pulse it high 376: 80 91 01 01 lds r24, 0x0101 37a: 08 2e mov r0, r24 37c: 00 0c add r0, r0 37e: 99 0b sbc r25, r25 380: fc 01 movw r30, r24 382: ee 0f add r30, r30 384: ff 1f adc r31, r31 386: 8e 0f add r24, r30 388: 9f 1f adc r25, r31 38a: fc 01 movw r30, r24 38c: ee 5f subi r30, 0xFE ; 254 38e: fe 4f sbci r31, 0xFE ; 254 390: 80 81 ld r24, Z 392: 61 e0 ldi r22, 0x01 ; 1 394: 8f 73 andi r24, 0x3F ; 63 396: 0e 94 87 00 call 0x10e ; 0x10e // Interrupt handlers for Arduino #if defined(_useTimer1) SIGNAL (TIMER1_COMPA_vect) { handle_interrupts(_timer1, &TCNT1, &OCR1A); } 39a: ff 91 pop r31 39c: ef 91 pop r30 39e: bf 91 pop r27 3a0: af 91 pop r26 3a2: 9f 91 pop r25 3a4: 8f 91 pop r24 3a6: 7f 91 pop r23 3a8: 6f 91 pop r22 3aa: 5f 91 pop r21 3ac: 4f 91 pop r20 3ae: 3f 91 pop r19 3b0: 2f 91 pop r18 3b2: 0f 90 pop r0 3b4: 0f be out 0x3f, r0 ; 63 3b6: 0f 90 pop r0 3b8: 1f 90 pop r1 3ba: 18 95 reti 000003bc

: void init() { // this needs to be called before setup() or some functions won't // work there sei(); 3bc: 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); 3be: 84 b5 in r24, 0x24 ; 36 3c0: 82 60 ori r24, 0x02 ; 2 3c2: 84 bd out 0x24, r24 ; 36 sbi(TCCR0A, WGM00); 3c4: 84 b5 in r24, 0x24 ; 36 3c6: 81 60 ori r24, 0x01 ; 1 3c8: 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); 3ca: 85 b5 in r24, 0x25 ; 37 3cc: 82 60 ori r24, 0x02 ; 2 3ce: 85 bd out 0x25, r24 ; 37 sbi(TCCR0B, CS00); 3d0: 85 b5 in r24, 0x25 ; 37 3d2: 81 60 ori r24, 0x01 ; 1 3d4: 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); 3d6: 80 91 6e 00 lds r24, 0x006E 3da: 81 60 ori r24, 0x01 ; 1 3dc: 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; 3e0: 10 92 81 00 sts 0x0081, r1 // set timer 1 prescale factor to 64 sbi(TCCR1B, CS11); 3e4: 80 91 81 00 lds r24, 0x0081 3e8: 82 60 ori r24, 0x02 ; 2 3ea: 80 93 81 00 sts 0x0081, r24 #if F_CPU >= 8000000L sbi(TCCR1B, CS10); 3ee: 80 91 81 00 lds r24, 0x0081 3f2: 81 60 ori r24, 0x01 ; 1 3f4: 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); 3f8: 80 91 80 00 lds r24, 0x0080 3fc: 81 60 ori r24, 0x01 ; 1 3fe: 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); 402: 80 91 b1 00 lds r24, 0x00B1 406: 84 60 ori r24, 0x04 ; 4 408: 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); 40c: 80 91 b0 00 lds r24, 0x00B0 410: 81 60 ori r24, 0x01 ; 1 412: 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); 416: 80 91 7a 00 lds r24, 0x007A 41a: 84 60 ori r24, 0x04 ; 4 41c: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS1); 420: 80 91 7a 00 lds r24, 0x007A 424: 82 60 ori r24, 0x02 ; 2 426: 80 93 7a 00 sts 0x007A, r24 sbi(ADCSRA, ADPS0); 42a: 80 91 7a 00 lds r24, 0x007A 42e: 81 60 ori r24, 0x01 ; 1 430: 80 93 7a 00 sts 0x007A, r24 cbi(ADCSRA, ADPS2); cbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); #endif // enable a2d conversions sbi(ADCSRA, ADEN); 434: 80 91 7a 00 lds r24, 0x007A 438: 80 68 ori r24, 0x80 ; 128 43a: 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; 43e: 10 92 c1 00 sts 0x00C1, r1 return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH); } uint8_t Servo::attach(int pin, int min, int max) { if(this->servoIndex < MAX_SERVOS ) { 442: 80 91 26 01 lds r24, 0x0126 446: 8c 30 cpi r24, 0x0C ; 12 448: 08 f0 brcs .+2 ; 0x44c <__LOCK_REGION_LENGTH__+0x4c> 44a: 68 c0 rjmp .+208 ; 0x51c <__LOCK_REGION_LENGTH__+0x11c> #include "wiring_private.h" #include "pins_arduino.h" void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); 44c: ed ea ldi r30, 0xAD ; 173 44e: f0 e0 ldi r31, 0x00 ; 0 450: 24 91 lpm r18, Z uint8_t port = digitalPinToPort(pin); 452: e9 e9 ldi r30, 0x99 ; 153 454: f0 e0 ldi r31, 0x00 ; 0 456: 84 91 lpm r24, Z volatile uint8_t *reg, *out; if (port == NOT_A_PIN) return; 458: 88 23 and r24, r24 45a: 99 f0 breq .+38 ; 0x482 <__LOCK_REGION_LENGTH__+0x82> // JWS: can I let the optimizer do this? reg = portModeRegister(port); 45c: 90 e0 ldi r25, 0x00 ; 0 45e: 88 0f add r24, r24 460: 99 1f adc r25, r25 462: fc 01 movw r30, r24 464: ea 57 subi r30, 0x7A ; 122 466: ff 4f sbci r31, 0xFF ; 255 468: a5 91 lpm r26, Z+ 46a: b4 91 lpm r27, Z out = portOutputRegister(port); 46c: fc 01 movw r30, r24 46e: e4 58 subi r30, 0x84 ; 132 470: ff 4f sbci r31, 0xFF ; 255 472: 85 91 lpm r24, Z+ 474: 94 91 lpm r25, Z cli(); *reg &= ~bit; *out |= bit; SREG = oldSREG; } else { uint8_t oldSREG = SREG; 476: 8f b7 in r24, 0x3f ; 63 cli(); 478: f8 94 cli *reg |= bit; 47a: ec 91 ld r30, X 47c: e2 2b or r30, r18 47e: ec 93 st X, r30 SREG = oldSREG; 480: 8f bf out 0x3f, r24 ; 63 pinMode( pin, OUTPUT) ; // set servo pin to output servos[this->servoIndex].Pin.nbr = pin; 482: 80 91 26 01 lds r24, 0x0126 486: e8 2f mov r30, r24 488: f0 e0 ldi r31, 0x00 ; 0 48a: 9f 01 movw r18, r30 48c: 22 0f add r18, r18 48e: 33 1f adc r19, r19 490: e2 0f add r30, r18 492: f3 1f adc r31, r19 494: ee 5f subi r30, 0xFE ; 254 496: fe 4f sbci r31, 0xFE ; 254 498: 90 81 ld r25, Z 49a: 90 7c andi r25, 0xC0 ; 192 49c: 99 60 ori r25, 0x09 ; 9 49e: 90 83 st Z, r25 // todo min/max check: abs(min - MIN_PULSE_WIDTH) /4 < 128 this->min = (MIN_PULSE_WIDTH - min)/4; //resolution of min/max is 4 uS 4a0: 10 92 27 01 sts 0x0127, r1 this->max = (MAX_PULSE_WIDTH - max)/4; 4a4: 10 92 28 01 sts 0x0128, r1 // initialize the timer if it has not already been initialized timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex); 4a8: 6c e0 ldi r22, 0x0C ; 12 4aa: 0e 94 5c 03 call 0x6b8 ; 0x6b8 <__udivmodqi4> static boolean isTimerActive(timer16_Sequence_t timer) { // returns true if any servo is active on this timer for(uint8_t channel=0; channel < SERVOS_PER_TIMER; channel++) { if(SERVO(timer,channel).Pin.isActive == true) 4ae: 9c e0 ldi r25, 0x0C ; 12 4b0: 89 9f mul r24, r25 4b2: b0 01 movw r22, r0 4b4: 11 24 eor r1, r1 4b6: 40 e0 ldi r20, 0x00 ; 0 4b8: 50 e0 ldi r21, 0x00 ; 0 4ba: 9a 01 movw r18, r20 4bc: 26 0f add r18, r22 4be: 37 1f adc r19, r23 4c0: f9 01 movw r30, r18 4c2: ee 0f add r30, r30 4c4: ff 1f adc r31, r31 4c6: 2e 0f add r18, r30 4c8: 3f 1f adc r19, r31 4ca: f9 01 movw r30, r18 4cc: ee 5f subi r30, 0xFE ; 254 4ce: fe 4f sbci r31, 0xFE ; 254 4d0: 90 81 ld r25, Z 4d2: 96 fd sbrc r25, 6 4d4: 16 c0 rjmp .+44 ; 0x502 <__LOCK_REGION_LENGTH__+0x102> 4d6: 4f 5f subi r20, 0xFF ; 255 4d8: 5f 4f sbci r21, 0xFF ; 255 } static boolean isTimerActive(timer16_Sequence_t timer) { // returns true if any servo is active on this timer for(uint8_t channel=0; channel < SERVOS_PER_TIMER; channel++) { 4da: 4c 30 cpi r20, 0x0C ; 12 4dc: 51 05 cpc r21, r1 4de: 69 f7 brne .-38 ; 0x4ba <__LOCK_REGION_LENGTH__+0xba> static void initISR(timer16_Sequence_t timer) { #if defined (_useTimer1) if(timer == _timer1) { 4e0: 81 11 cpse r24, r1 4e2: 0f c0 rjmp .+30 ; 0x502 <__LOCK_REGION_LENGTH__+0x102> TCCR1A = 0; // normal counting mode 4e4: 10 92 80 00 sts 0x0080, r1 TCCR1B = _BV(CS11); // set prescaler of 8 4e8: 82 e0 ldi r24, 0x02 ; 2 4ea: 80 93 81 00 sts 0x0081, r24 TCNT1 = 0; // clear the timer count 4ee: 10 92 85 00 sts 0x0085, r1 4f2: 10 92 84 00 sts 0x0084, r1 #if defined(__AVR_ATmega8__)|| defined(__AVR_ATmega128__) TIFR |= _BV(OCF1A); // clear any pending interrupts; TIMSK |= _BV(OCIE1A) ; // enable the output compare interrupt #else // here if not ATmega8 or ATmega128 TIFR1 |= _BV(OCF1A); // clear any pending interrupts; 4f6: b1 9a sbi 0x16, 1 ; 22 TIMSK1 |= _BV(OCIE1A) ; // enable the output compare interrupt 4f8: 80 91 6f 00 lds r24, 0x006F 4fc: 82 60 ori r24, 0x02 ; 2 4fe: 80 93 6f 00 sts 0x006F, r24 this->max = (MAX_PULSE_WIDTH - max)/4; // initialize the timer if it has not already been initialized timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex); if(isTimerActive(timer) == false) initISR(timer); servos[this->servoIndex].Pin.isActive = true; // this must be set after the check for isTimerActive 502: e0 91 26 01 lds r30, 0x0126 506: f0 e0 ldi r31, 0x00 ; 0 508: cf 01 movw r24, r30 50a: 88 0f add r24, r24 50c: 99 1f adc r25, r25 50e: e8 0f add r30, r24 510: f9 1f adc r31, r25 512: ee 5f subi r30, 0xFE ; 254 514: fe 4f sbci r31, 0xFE ; 254 516: 80 81 ld r24, Z 518: 80 64 ori r24, 0x40 ; 64 51a: 80 83 st Z, r24 { if(value < MIN_PULSE_WIDTH) { // treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds) if(value < 0) value = 0; if(value > 180) value = 180; value = map(value, 0, 180, SERVO_MIN(), SERVO_MAX()); 51c: 80 91 27 01 lds r24, 0x0127 520: c8 e8 ldi r28, 0x88 ; 136 522: d0 e0 ldi r29, 0x00 ; 0 524: c8 1b sub r28, r24 526: d1 09 sbc r29, r1 528: 87 fd sbrc r24, 7 52a: d3 95 inc r29 52c: cc 0f add r28, r28 52e: dd 1f adc r29, r29 530: cc 0f add r28, r28 532: dd 1f adc r29, r29 534: 6e 01 movw r12, r28 536: 0d 2e mov r0, r29 538: 00 0c add r0, r0 53a: ee 08 sbc r14, r14 53c: ff 08 sbc r15, r15 53e: 80 91 28 01 lds r24, 0x0128 542: 28 e5 ldi r18, 0x58 ; 88 544: 32 e0 ldi r19, 0x02 ; 2 546: 28 1b sub r18, r24 548: 31 09 sbc r19, r1 54a: 87 fd sbrc r24, 7 54c: 33 95 inc r19 54e: 22 0f add r18, r18 550: 33 1f adc r19, r19 552: 22 0f add r18, r18 554: 33 1f adc r19, r19 556: c9 01 movw r24, r18 558: 33 0f add r19, r19 55a: aa 0b sbc r26, r26 55c: bb 0b sbc r27, r27 return random(diff) + howsmall; } long map(long x, long in_min, long in_max, long out_min, long out_max) { return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; 55e: 9c 01 movw r18, r24 560: ad 01 movw r20, r26 562: 2c 19 sub r18, r12 564: 3d 09 sbc r19, r13 566: 4e 09 sbc r20, r14 568: 5f 09 sbc r21, r15 56a: a2 e3 ldi r26, 0x32 ; 50 56c: b0 e0 ldi r27, 0x00 ; 0 56e: 0e 94 20 03 call 0x640 ; 0x640 <__muluhisi3> 572: 24 eb ldi r18, 0xB4 ; 180 574: 30 e0 ldi r19, 0x00 ; 0 576: 40 e0 ldi r20, 0x00 ; 0 578: 50 e0 ldi r21, 0x00 ; 0 57a: 0e 94 01 03 call 0x602 ; 0x602 <__divmodsi4> 57e: c2 0e add r12, r18 580: d3 1e adc r13, r19 582: e4 1e adc r14, r20 584: f5 1e adc r15, r21 } void Servo::writeMicroseconds(int value) { // calculate and store the values for the given channel byte channel = this->servoIndex; 586: 80 91 26 01 lds r24, 0x0126 if( (channel < MAX_SERVOS) ) // ensure channel is valid 58a: 8c 30 cpi r24, 0x0C ; 12 58c: b8 f4 brcc .+46 ; 0x5bc <__LOCK_REGION_LENGTH__+0x1bc> 58e: cc 16 cp r12, r28 590: dd 06 cpc r13, r29 592: 0c f4 brge .+2 ; 0x596 <__LOCK_REGION_LENGTH__+0x196> 594: 6e 01 movw r12, r28 if( value < SERVO_MIN() ) // ensure pulse width is valid value = SERVO_MIN(); else if( value > SERVO_MAX() ) value = SERVO_MAX(); value = value - TRIM_DURATION; 596: 92 e0 ldi r25, 0x02 ; 2 598: c9 1a sub r12, r25 59a: d1 08 sbc r13, r1 value = usToTicks(value); // convert to ticks after compensating for interrupt overhead - 12 Aug 2009 59c: cc 0c add r12, r12 59e: dd 1c adc r13, r13 uint8_t oldSREG = SREG; 5a0: 2f b7 in r18, 0x3f ; 63 cli(); 5a2: f8 94 cli servos[channel].ticks = value; 5a4: 90 e0 ldi r25, 0x00 ; 0 5a6: fc 01 movw r30, r24 5a8: ee 0f add r30, r30 5aa: ff 1f adc r31, r31 5ac: 8e 0f add r24, r30 5ae: 9f 1f adc r25, r31 5b0: fc 01 movw r30, r24 5b2: ee 5f subi r30, 0xFE ; 254 5b4: fe 4f sbci r31, 0xFE ; 254 5b6: d2 82 std Z+2, r13 ; 0x02 5b8: c1 82 std Z+1, r12 ; 0x01 SREG = oldSREG; 5ba: 2f bf out 0x3f, r18 ; 63 setup(); for (;;) { loop(); if (serialEventRun) serialEventRun(); 5bc: c0 e0 ldi r28, 0x00 ; 0 5be: d0 e0 ldi r29, 0x00 ; 0 5c0: 20 97 sbiw r28, 0x00 ; 0 5c2: f1 f3 breq .-4 ; 0x5c0 <__LOCK_REGION_LENGTH__+0x1c0> 5c4: 0e 94 00 00 call 0 ; 0x0 <__vectors> 5c8: fb cf rjmp .-10 ; 0x5c0 <__LOCK_REGION_LENGTH__+0x1c0> 000005ca <_GLOBAL__sub_I_myservo>: /****************** end of static functions ******************************/ Servo::Servo() { if( ServoCount < MAX_SERVOS) { 5ca: 80 91 00 01 lds r24, 0x0100 5ce: 8c 30 cpi r24, 0x0C ; 12 5d0: a0 f4 brcc .+40 ; 0x5fa <_GLOBAL__sub_I_myservo+0x30> this->servoIndex = ServoCount++; // assign a servo index to this instance 5d2: 91 e0 ldi r25, 0x01 ; 1 5d4: 98 0f add r25, r24 5d6: 90 93 00 01 sts 0x0100, r25 5da: 80 93 26 01 sts 0x0126, r24 servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH); // store default values - 12 Aug 2009 5de: 90 e0 ldi r25, 0x00 ; 0 5e0: fc 01 movw r30, r24 5e2: ee 0f add r30, r30 5e4: ff 1f adc r31, r31 5e6: 8e 0f add r24, r30 5e8: 9f 1f adc r25, r31 5ea: fc 01 movw r30, r24 5ec: ee 5f subi r30, 0xFE ; 254 5ee: fe 4f sbci r31, 0xFE ; 254 5f0: 88 eb ldi r24, 0xB8 ; 184 5f2: 9b e0 ldi r25, 0x0B ; 11 5f4: 92 83 std Z+2, r25 ; 0x02 5f6: 81 83 std Z+1, r24 ; 0x01 5f8: 08 95 ret } else this->servoIndex = INVALID_SERVO ; // too many servos 5fa: 8f ef ldi r24, 0xFF ; 255 5fc: 80 93 26 01 sts 0x0126, r24 600: 08 95 ret 00000602 <__divmodsi4>: 602: 05 2e mov r0, r21 604: 97 fb bst r25, 7 606: 1e f4 brtc .+6 ; 0x60e <__divmodsi4+0xc> 608: 00 94 com r0 60a: 0e 94 18 03 call 0x630 ; 0x630 <__negsi2> 60e: 57 fd sbrc r21, 7 610: 07 d0 rcall .+14 ; 0x620 <__divmodsi4_neg2> 612: 0e 94 2b 03 call 0x656 ; 0x656 <__udivmodsi4> 616: 07 fc sbrc r0, 7 618: 03 d0 rcall .+6 ; 0x620 <__divmodsi4_neg2> 61a: 4e f4 brtc .+18 ; 0x62e <__divmodsi4_exit> 61c: 0c 94 18 03 jmp 0x630 ; 0x630 <__negsi2> 00000620 <__divmodsi4_neg2>: 620: 50 95 com r21 622: 40 95 com r20 624: 30 95 com r19 626: 21 95 neg r18 628: 3f 4f sbci r19, 0xFF ; 255 62a: 4f 4f sbci r20, 0xFF ; 255 62c: 5f 4f sbci r21, 0xFF ; 255 0000062e <__divmodsi4_exit>: 62e: 08 95 ret 00000630 <__negsi2>: 630: 90 95 com r25 632: 80 95 com r24 634: 70 95 com r23 636: 61 95 neg r22 638: 7f 4f sbci r23, 0xFF ; 255 63a: 8f 4f sbci r24, 0xFF ; 255 63c: 9f 4f sbci r25, 0xFF ; 255 63e: 08 95 ret 00000640 <__muluhisi3>: 640: 0e 94 4d 03 call 0x69a ; 0x69a <__umulhisi3> 644: a5 9f mul r26, r21 646: 90 0d add r25, r0 648: b4 9f mul r27, r20 64a: 90 0d add r25, r0 64c: a4 9f mul r26, r20 64e: 80 0d add r24, r0 650: 91 1d adc r25, r1 652: 11 24 eor r1, r1 654: 08 95 ret 00000656 <__udivmodsi4>: 656: a1 e2 ldi r26, 0x21 ; 33 658: 1a 2e mov r1, r26 65a: aa 1b sub r26, r26 65c: bb 1b sub r27, r27 65e: fd 01 movw r30, r26 660: 0d c0 rjmp .+26 ; 0x67c <__udivmodsi4_ep> 00000662 <__udivmodsi4_loop>: 662: aa 1f adc r26, r26 664: bb 1f adc r27, r27 666: ee 1f adc r30, r30 668: ff 1f adc r31, r31 66a: a2 17 cp r26, r18 66c: b3 07 cpc r27, r19 66e: e4 07 cpc r30, r20 670: f5 07 cpc r31, r21 672: 20 f0 brcs .+8 ; 0x67c <__udivmodsi4_ep> 674: a2 1b sub r26, r18 676: b3 0b sbc r27, r19 678: e4 0b sbc r30, r20 67a: f5 0b sbc r31, r21 0000067c <__udivmodsi4_ep>: 67c: 66 1f adc r22, r22 67e: 77 1f adc r23, r23 680: 88 1f adc r24, r24 682: 99 1f adc r25, r25 684: 1a 94 dec r1 686: 69 f7 brne .-38 ; 0x662 <__udivmodsi4_loop> 688: 60 95 com r22 68a: 70 95 com r23 68c: 80 95 com r24 68e: 90 95 com r25 690: 9b 01 movw r18, r22 692: ac 01 movw r20, r24 694: bd 01 movw r22, r26 696: cf 01 movw r24, r30 698: 08 95 ret 0000069a <__umulhisi3>: 69a: a2 9f mul r26, r18 69c: b0 01 movw r22, r0 69e: b3 9f mul r27, r19 6a0: c0 01 movw r24, r0 6a2: a3 9f mul r26, r19 6a4: 70 0d add r23, r0 6a6: 81 1d adc r24, r1 6a8: 11 24 eor r1, r1 6aa: 91 1d adc r25, r1 6ac: b2 9f mul r27, r18 6ae: 70 0d add r23, r0 6b0: 81 1d adc r24, r1 6b2: 11 24 eor r1, r1 6b4: 91 1d adc r25, r1 6b6: 08 95 ret 000006b8 <__udivmodqi4>: 6b8: 99 1b sub r25, r25 6ba: 79 e0 ldi r23, 0x09 ; 9 6bc: 04 c0 rjmp .+8 ; 0x6c6 <__udivmodqi4_ep> 000006be <__udivmodqi4_loop>: 6be: 99 1f adc r25, r25 6c0: 96 17 cp r25, r22 6c2: 08 f0 brcs .+2 ; 0x6c6 <__udivmodqi4_ep> 6c4: 96 1b sub r25, r22 000006c6 <__udivmodqi4_ep>: 6c6: 88 1f adc r24, r24 6c8: 7a 95 dec r23 6ca: c9 f7 brne .-14 ; 0x6be <__udivmodqi4_loop> 6cc: 80 95 com r24 6ce: 08 95 ret 000006d0 <__tablejump2__>: 6d0: ee 0f add r30, r30 6d2: ff 1f adc r31, r31 6d4: 05 90 lpm r0, Z+ 6d6: f4 91 lpm r31, Z 6d8: e0 2d mov r30, r0 6da: 09 94 ijmp 000006dc <_exit>: 6dc: f8 94 cli 000006de <__stop_program>: 6de: ff cf rjmp .-2 ; 0x6de <__stop_program>