diff --git a/Computer_Switchboard/pcb/layout.pdf b/Computer_Switchboard/pcb/layout.pdf new file mode 100644 index 0000000..f7031b9 Binary files /dev/null and b/Computer_Switchboard/pcb/layout.pdf differ diff --git a/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.dis b/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.dis new file mode 100644 index 0000000..c8cd216 --- /dev/null +++ b/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.dis @@ -0,0 +1,3245 @@ + +gassensor_reva.ino.elf: file format elf32-avr + + +Disassembly of section .text: + +00000000 <__vectors>: + 0: 0c 94 5e 00 jmp 0xbc ; 0xbc <__ctors_end> + 4: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 8: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + c: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 10: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 14: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 18: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 1c: 0c 94 ef 04 jmp 0x9de ; 0x9de <__vector_7> + 20: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 24: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 28: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 2c: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 30: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 34: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 38: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 3c: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 40: 0c 94 a5 04 jmp 0x94a ; 0x94a <__vector_16> + 44: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 48: 0c 94 97 05 jmp 0xb2e ; 0xb2e <__vector_18> + 4c: 0c 94 71 05 jmp 0xae2 ; 0xae2 <__vector_19> + 50: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 54: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 58: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 5c: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 60: 0c 94 86 00 jmp 0x10c ; 0x10c <__bad_interrupt> + 64: 0c 94 86 00 jmp 0x10c ; 0x10c <__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 <_ZL21tone_pin_to_timer_PGM>: + 7c: 02 . + +0000007d : + 7d: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+. + +00000087 : + 87: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*. + +00000091 : + 91: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ + a1: 03 03 03 03 .... + +000000a5 : + a5: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. + b5: 04 08 10 20 00 ... . + +000000ba <__ctors_start>: + ba: 50 08 sbc r5, r0 + +000000bc <__ctors_end>: + bc: 11 24 eor r1, r1 + be: 1f be out 0x3f, r1 ; 63 + c0: cf ef ldi r28, 0xFF ; 255 + c2: d8 e0 ldi r29, 0x08 ; 8 + c4: de bf out 0x3e, r29 ; 62 + c6: cd bf out 0x3d, r28 ; 61 + +000000c8 <__do_copy_data>: + c8: 11 e0 ldi r17, 0x01 ; 1 + ca: a0 e0 ldi r26, 0x00 ; 0 + cc: b1 e0 ldi r27, 0x01 ; 1 + ce: e4 eb ldi r30, 0xB4 ; 180 + d0: f1 e1 ldi r31, 0x11 ; 17 + d2: 02 c0 rjmp .+4 ; 0xd8 <__do_copy_data+0x10> + d4: 05 90 lpm r0, Z+ + d6: 0d 92 st X+, r0 + d8: a2 33 cpi r26, 0x32 ; 50 + da: b1 07 cpc r27, r17 + dc: d9 f7 brne .-10 ; 0xd4 <__do_copy_data+0xc> + +000000de <__do_clear_bss>: + de: 21 e0 ldi r18, 0x01 ; 1 + e0: a2 e3 ldi r26, 0x32 ; 50 + e2: b1 e0 ldi r27, 0x01 ; 1 + e4: 01 c0 rjmp .+2 ; 0xe8 <.do_clear_bss_start> + +000000e6 <.do_clear_bss_loop>: + e6: 1d 92 st X+, r1 + +000000e8 <.do_clear_bss_start>: + e8: ab 3e cpi r26, 0xEB ; 235 + ea: b2 07 cpc r27, r18 + ec: e1 f7 brne .-8 ; 0xe6 <.do_clear_bss_loop> + +000000ee <__do_global_ctors>: + ee: 10 e0 ldi r17, 0x00 ; 0 + f0: ce e5 ldi r28, 0x5E ; 94 + f2: d0 e0 ldi r29, 0x00 ; 0 + f4: 04 c0 rjmp .+8 ; 0xfe <__do_global_ctors+0x10> + f6: 21 97 sbiw r28, 0x01 ; 1 + f8: fe 01 movw r30, r28 + fa: 0e 94 cd 08 call 0x119a ; 0x119a <__tablejump2__> + fe: cd 35 cpi r28, 0x5D ; 93 + 100: d1 07 cpc r29, r17 + 102: c9 f7 brne .-14 ; 0xf6 <__do_global_ctors+0x8> + 104: 0e 94 c9 05 call 0xb92 ; 0xb92
+ 108: 0c 94 d8 08 jmp 0x11b0 ; 0x11b0 <_exit> + +0000010c <__bad_interrupt>: + 10c: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> + +00000110 : +#include "wiring_private.h" +#include "pins_arduino.h" + +void pinMode(uint8_t pin, uint8_t mode) +{ + uint8_t bit = digitalPinToBitMask(pin); + 110: 90 e0 ldi r25, 0x00 ; 0 + 112: fc 01 movw r30, r24 + 114: eb 55 subi r30, 0x5B ; 91 + 116: ff 4f sbci r31, 0xFF ; 255 + 118: 24 91 lpm r18, Z + uint8_t port = digitalPinToPort(pin); + 11a: fc 01 movw r30, r24 + 11c: ef 56 subi r30, 0x6F ; 111 + 11e: ff 4f sbci r31, 0xFF ; 255 + 120: 84 91 lpm r24, Z + volatile uint8_t *reg, *out; + + if (port == NOT_A_PIN) return; + 122: 88 23 and r24, r24 + 124: 99 f0 breq .+38 ; 0x14c + + // JWS: can I let the optimizer do this? + reg = portModeRegister(port); + 126: 90 e0 ldi r25, 0x00 ; 0 + 128: 88 0f add r24, r24 + 12a: 99 1f adc r25, r25 + 12c: fc 01 movw r30, r24 + 12e: e9 57 subi r30, 0x79 ; 121 + 130: ff 4f sbci r31, 0xFF ; 255 + 132: a5 91 lpm r26, Z+ + 134: b4 91 lpm r27, Z + out = portOutputRegister(port); + 136: fc 01 movw r30, r24 + 138: e3 58 subi r30, 0x83 ; 131 + 13a: ff 4f sbci r31, 0xFF ; 255 + 13c: 85 91 lpm r24, Z+ + 13e: 94 91 lpm r25, Z + cli(); + *reg &= ~bit; + *out |= bit; + SREG = oldSREG; + } else { + uint8_t oldSREG = SREG; + 140: 8f b7 in r24, 0x3f ; 63 + cli(); + 142: f8 94 cli + *reg |= bit; + 144: ec 91 ld r30, X + 146: e2 2b or r30, r18 + 148: ec 93 st X, r30 + SREG = oldSREG; + 14a: 8f bf out 0x3f, r24 ; 63 + 14c: 08 95 ret + +0000014e <_Z4tonehjm.constprop.15>: + + + +// frequency (in hertz) and duration (in milliseconds). + +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration) + 14e: 4f 92 push r4 + 150: 5f 92 push r5 + 152: 6f 92 push r6 + 154: 7f 92 push r7 + 156: 8f 92 push r8 + 158: 9f 92 push r9 + 15a: af 92 push r10 + 15c: bf 92 push r11 + 15e: cf 92 push r12 + 160: df 92 push r13 + 162: ef 92 push r14 + 164: ff 92 push r15 + 166: 1f 93 push r17 + 168: cf 93 push r28 + 16a: df 93 push r29 + 16c: ec 01 movw r28, r24 +{ + int8_t _timer = -1; + + // if we're already using the pin, the timer should be configured. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == _pin) { + 16e: 80 91 00 01 lds r24, 0x0100 ; 0x800100 <__data_start> + 172: 85 30 cpi r24, 0x05 ; 5 + 174: 21 f0 breq .+8 ; 0x17e <_Z4tonehjm.constprop.15+0x30> + } + } + + // search for an unused timer. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == 255) { + 176: 8f 3f cpi r24, 0xFF ; 255 + 178: 09 f0 breq .+2 ; 0x17c <_Z4tonehjm.constprop.15+0x2e> + 17a: 07 c2 rjmp .+1038 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + 17c: 04 c0 rjmp .+8 ; 0x186 <_Z4tonehjm.constprop.15+0x38> + int8_t _timer = -1; + + // if we're already using the pin, the timer should be configured. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == _pin) { + return pgm_read_byte(tone_pin_to_timer_PGM + i); + 17e: ec e7 ldi r30, 0x7C ; 124 + 180: f0 e0 ldi r31, 0x00 ; 0 + 182: 14 91 lpm r17, Z + 184: 6e c0 rjmp .+220 ; 0x262 <_Z4tonehjm.constprop.15+0x114> + } + + // search for an unused timer. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == 255) { + tone_pins[i] = _pin; + 186: 85 e0 ldi r24, 0x05 ; 5 + 188: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> + _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); + 18c: ec e7 ldi r30, 0x7C ; 124 + 18e: f0 e0 ldi r31, 0x00 ; 0 + 190: 14 91 lpm r17, Z + break; + } + } + + if (_timer != -1) + 192: 1f 3f cpi r17, 0xFF ; 255 + 194: 09 f4 brne .+2 ; 0x198 <_Z4tonehjm.constprop.15+0x4a> + 196: f9 c1 rjmp .+1010 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + { + // Set timer specific stuff + // All timers in CTC mode + // 8 bit timers will require changing prescalar values, + // whereas 16 bit timers are set to either ck/1 or ck/64 prescalar + switch (_timer) + 198: 11 30 cpi r17, 0x01 ; 1 + 19a: 09 f4 brne .+2 ; 0x19e <_Z4tonehjm.constprop.15+0x50> + 19c: 40 c0 rjmp .+128 ; 0x21e <_Z4tonehjm.constprop.15+0xd0> + 19e: 30 f1 brcs .+76 ; 0x1ec <_Z4tonehjm.constprop.15+0x9e> + 1a0: 12 30 cpi r17, 0x02 ; 2 + 1a2: 09 f0 breq .+2 ; 0x1a6 <_Z4tonehjm.constprop.15+0x58> + 1a4: 5e c0 rjmp .+188 ; 0x262 <_Z4tonehjm.constprop.15+0x114> + #endif + + #if defined(TCCR2A) && defined(TCCR2B) + case 2: + // 8 bit timer + TCCR2A = 0; + 1a6: 10 92 b0 00 sts 0x00B0, r1 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + TCCR2B = 0; + 1aa: 10 92 b1 00 sts 0x00B1, r1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + bitWrite(TCCR2A, WGM21, 1); + 1ae: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + 1b2: 82 60 ori r24, 0x02 ; 2 + 1b4: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + bitWrite(TCCR2B, CS20, 1); + 1b8: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + 1bc: 81 60 ori r24, 0x01 ; 1 + 1be: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + timer2_pin_port = portOutputRegister(digitalPinToPort(_pin)); + 1c2: e6 e9 ldi r30, 0x96 ; 150 + 1c4: f0 e0 ldi r31, 0x00 ; 0 + 1c6: e4 91 lpm r30, Z + 1c8: f0 e0 ldi r31, 0x00 ; 0 + 1ca: ee 0f add r30, r30 + 1cc: ff 1f adc r31, r31 + 1ce: e3 58 subi r30, 0x83 ; 131 + 1d0: ff 4f sbci r31, 0xFF ; 255 + 1d2: 85 91 lpm r24, Z+ + 1d4: 94 91 lpm r25, Z + 1d6: 90 93 dc 01 sts 0x01DC, r25 ; 0x8001dc + 1da: 80 93 db 01 sts 0x01DB, r24 ; 0x8001db + timer2_pin_mask = digitalPinToBitMask(_pin); + 1de: ea ea ldi r30, 0xAA ; 170 + 1e0: f0 e0 ldi r31, 0x00 ; 0 + 1e2: e4 91 lpm r30, Z + 1e4: e0 93 da 01 sts 0x01DA, r30 ; 0x8001da + 1e8: 12 e0 ldi r17, 0x02 ; 2 + 1ea: cb c1 rjmp .+918 ; 0x582 <__LOCK_REGION_LENGTH__+0x182> + switch (_timer) + { + #if defined(TCCR0A) && defined(TCCR0B) && defined(WGM01) + case 0: + // 8 bit timer + TCCR0A = 0; + 1ec: 14 bc out 0x24, r1 ; 36 + TCCR0B = 0; + 1ee: 15 bc out 0x25, r1 ; 37 + bitWrite(TCCR0A, WGM01, 1); + 1f0: 84 b5 in r24, 0x24 ; 36 + 1f2: 82 60 ori r24, 0x02 ; 2 + 1f4: 84 bd out 0x24, r24 ; 36 + bitWrite(TCCR0B, CS00, 1); + 1f6: 85 b5 in r24, 0x25 ; 37 + 1f8: 81 60 ori r24, 0x01 ; 1 + 1fa: 85 bd out 0x25, r24 ; 37 + timer0_pin_port = portOutputRegister(digitalPinToPort(_pin)); + 1fc: e6 e9 ldi r30, 0x96 ; 150 + 1fe: f0 e0 ldi r31, 0x00 ; 0 + 200: e4 91 lpm r30, Z + 202: f0 e0 ldi r31, 0x00 ; 0 + 204: ee 0f add r30, r30 + 206: ff 1f adc r31, r31 + 208: e3 58 subi r30, 0x83 ; 131 + 20a: ff 4f sbci r31, 0xFF ; 255 + 20c: 85 91 lpm r24, Z+ + 20e: 94 91 lpm r25, Z + timer0_pin_mask = digitalPinToBitMask(_pin); + 210: ea ea ldi r30, 0xAA ; 170 + 212: f0 e0 ldi r31, 0x00 ; 0 + 214: e4 91 lpm r30, Z + 216: e0 93 de 01 sts 0x01DE, r30 ; 0x8001de + 21a: 10 e0 ldi r17, 0x00 ; 0 + 21c: b2 c1 rjmp .+868 ; 0x582 <__LOCK_REGION_LENGTH__+0x182> + #endif + + #if defined(TCCR1A) && defined(TCCR1B) && defined(WGM12) + case 1: + // 16 bit timer + TCCR1A = 0; + 21e: 10 92 80 00 sts 0x0080, r1 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + TCCR1B = 0; + 222: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + bitWrite(TCCR1B, WGM12, 1); + 226: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + 22a: 88 60 ori r24, 0x08 ; 8 + 22c: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + bitWrite(TCCR1B, CS10, 1); + 230: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + 234: 81 60 ori r24, 0x01 ; 1 + 236: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + timer1_pin_port = portOutputRegister(digitalPinToPort(_pin)); + 23a: e6 e9 ldi r30, 0x96 ; 150 + 23c: f0 e0 ldi r31, 0x00 ; 0 + 23e: e4 91 lpm r30, Z + 240: f0 e0 ldi r31, 0x00 ; 0 + 242: ee 0f add r30, r30 + 244: ff 1f adc r31, r31 + 246: e3 58 subi r30, 0x83 ; 131 + 248: ff 4f sbci r31, 0xFF ; 255 + 24a: 85 91 lpm r24, Z+ + 24c: 94 91 lpm r25, Z + timer1_pin_mask = digitalPinToBitMask(_pin); + 24e: ea ea ldi r30, 0xAA ; 170 + 250: f0 e0 ldi r31, 0x00 ; 0 + 252: e4 91 lpm r30, Z + 254: e0 93 dd 01 sts 0x01DD, r30 ; 0x8001dd + _timer = toneBegin(_pin); + + if (_timer >= 0) + { + // Set the pinMode as OUTPUT + pinMode(_pin, OUTPUT); + 258: 85 e0 ldi r24, 0x05 ; 5 + 25a: 0e 94 88 00 call 0x110 ; 0x110 + 25e: 11 e0 ldi r17, 0x01 ; 1 + 260: b0 c0 rjmp .+352 ; 0x3c2 <_Z4tonehjm.constprop.15+0x274> + uint32_t ocr = 0; + int8_t _timer; + + _timer = toneBegin(_pin); + + if (_timer >= 0) + 262: 17 fd sbrc r17, 7 + 264: 92 c1 rjmp .+804 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + { + // Set the pinMode as OUTPUT + pinMode(_pin, OUTPUT); + 266: 85 e0 ldi r24, 0x05 ; 5 + 268: 0e 94 88 00 call 0x110 ; 0x110 + + // if we are using an 8 bit timer, scan through prescalars to find the best fit + if (_timer == 0 || _timer == 2) + 26c: 81 2f mov r24, r17 + 26e: 8d 7f andi r24, 0xFD ; 253 + 270: 09 f0 breq .+2 ; 0x274 <_Z4tonehjm.constprop.15+0x126> + 272: a7 c0 rjmp .+334 ; 0x3c2 <_Z4tonehjm.constprop.15+0x274> + { + ocr = F_CPU / frequency / 2 - 1; + 274: 4e 01 movw r8, r28 + 276: a1 2c mov r10, r1 + 278: b1 2c mov r11, r1 + 27a: 60 e0 ldi r22, 0x00 ; 0 + 27c: 72 e1 ldi r23, 0x12 ; 18 + 27e: 8a e7 ldi r24, 0x7A ; 122 + 280: 90 e0 ldi r25, 0x00 ; 0 + 282: a5 01 movw r20, r10 + 284: 94 01 movw r18, r8 + 286: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 28a: 29 01 movw r4, r18 + 28c: 3a 01 movw r6, r20 + 28e: 69 01 movw r12, r18 + 290: 7a 01 movw r14, r20 + 292: 21 e0 ldi r18, 0x01 ; 1 + 294: c2 1a sub r12, r18 + 296: d1 08 sbc r13, r1 + 298: e1 08 sbc r14, r1 + 29a: f1 08 sbc r15, r1 + prescalarbits = 0b001; // ck/1: same for both timers + if (ocr > 255) + 29c: 8f ef ldi r24, 0xFF ; 255 + 29e: c8 16 cp r12, r24 + 2a0: d1 04 cpc r13, r1 + 2a2: e1 04 cpc r14, r1 + 2a4: f1 04 cpc r15, r1 + 2a6: 09 f0 breq .+2 ; 0x2aa <_Z4tonehjm.constprop.15+0x15c> + 2a8: 08 f4 brcc .+2 ; 0x2ac <_Z4tonehjm.constprop.15+0x15e> + 2aa: 4b c0 rjmp .+150 ; 0x342 <_Z4tonehjm.constprop.15+0x1f4> + { + ocr = F_CPU / frequency / 2 / 8 - 1; + 2ac: 60 e4 ldi r22, 0x40 ; 64 + 2ae: 72 e4 ldi r23, 0x42 ; 66 + 2b0: 8f e0 ldi r24, 0x0F ; 15 + 2b2: 90 e0 ldi r25, 0x00 ; 0 + 2b4: a5 01 movw r20, r10 + 2b6: 94 01 movw r18, r8 + 2b8: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 2bc: 69 01 movw r12, r18 + 2be: 7a 01 movw r14, r20 + 2c0: 81 e0 ldi r24, 0x01 ; 1 + 2c2: c8 1a sub r12, r24 + 2c4: d1 08 sbc r13, r1 + 2c6: e1 08 sbc r14, r1 + 2c8: f1 08 sbc r15, r1 + prescalarbits = 0b010; // ck/8: same for both timers + + if (_timer == 2 && ocr > 255) + 2ca: 12 30 cpi r17, 0x02 ; 2 + 2cc: 01 f5 brne .+64 ; 0x30e <_Z4tonehjm.constprop.15+0x1c0> + 2ce: 2f ef ldi r18, 0xFF ; 255 + 2d0: c2 16 cp r12, r18 + 2d2: d1 04 cpc r13, r1 + 2d4: e1 04 cpc r14, r1 + 2d6: f1 04 cpc r15, r1 + 2d8: 09 f0 breq .+2 ; 0x2dc <_Z4tonehjm.constprop.15+0x18e> + 2da: 08 f4 brcc .+2 ; 0x2de <_Z4tonehjm.constprop.15+0x190> + 2dc: ea c0 rjmp .+468 ; 0x4b2 <__LOCK_REGION_LENGTH__+0xb2> + { + ocr = F_CPU / frequency / 2 / 32 - 1; + 2de: 60 e9 ldi r22, 0x90 ; 144 + 2e0: 70 ed ldi r23, 0xD0 ; 208 + 2e2: 83 e0 ldi r24, 0x03 ; 3 + 2e4: 90 e0 ldi r25, 0x00 ; 0 + 2e6: a5 01 movw r20, r10 + 2e8: 94 01 movw r18, r8 + 2ea: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 2ee: 69 01 movw r12, r18 + 2f0: 7a 01 movw r14, r20 + 2f2: 81 e0 ldi r24, 0x01 ; 1 + 2f4: c8 1a sub r12, r24 + 2f6: d1 08 sbc r13, r1 + 2f8: e1 08 sbc r14, r1 + 2fa: f1 08 sbc r15, r1 + prescalarbits = 0b011; + } + + if (ocr > 255) + 2fc: 2f ef ldi r18, 0xFF ; 255 + 2fe: c2 16 cp r12, r18 + 300: d1 04 cpc r13, r1 + 302: e1 04 cpc r14, r1 + 304: f1 04 cpc r15, r1 + 306: 09 f0 breq .+2 ; 0x30a <_Z4tonehjm.constprop.15+0x1bc> + 308: 30 f5 brcc .+76 ; 0x356 <_Z4tonehjm.constprop.15+0x208> + prescalarbits = 0b010; // ck/8: same for both timers + + if (_timer == 2 && ocr > 255) + { + ocr = F_CPU / frequency / 2 / 32 - 1; + prescalarbits = 0b011; + 30a: 83 e0 ldi r24, 0x03 ; 3 + 30c: 53 c0 rjmp .+166 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + } + + if (ocr > 255) + 30e: 8f ef ldi r24, 0xFF ; 255 + 310: c8 16 cp r12, r24 + 312: d1 04 cpc r13, r1 + 314: e1 04 cpc r14, r1 + 316: f1 04 cpc r15, r1 + 318: b1 f0 breq .+44 ; 0x346 <_Z4tonehjm.constprop.15+0x1f8> + 31a: a8 f0 brcs .+42 ; 0x346 <_Z4tonehjm.constprop.15+0x1f8> + { + ocr = F_CPU / frequency / 2 / 64 - 1; + 31c: 68 e4 ldi r22, 0x48 ; 72 + 31e: 78 ee ldi r23, 0xE8 ; 232 + 320: 81 e0 ldi r24, 0x01 ; 1 + 322: 90 e0 ldi r25, 0x00 ; 0 + 324: a5 01 movw r20, r10 + 326: 94 01 movw r18, r8 + 328: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 32c: 69 01 movw r12, r18 + 32e: 7a 01 movw r14, r20 + 330: 81 e0 ldi r24, 0x01 ; 1 + 332: c8 1a sub r12, r24 + 334: d1 08 sbc r13, r1 + 336: e1 08 sbc r14, r1 + 338: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b011 : 0b100; + 33a: 11 23 and r17, r17 + 33c: 09 f4 brne .+2 ; 0x340 <_Z4tonehjm.constprop.15+0x1f2> + 33e: ee c0 rjmp .+476 ; 0x51c <__LOCK_REGION_LENGTH__+0x11c> + 340: e4 c0 rjmp .+456 ; 0x50a <__LOCK_REGION_LENGTH__+0x10a> + + // if we are using an 8 bit timer, scan through prescalars to find the best fit + if (_timer == 0 || _timer == 2) + { + ocr = F_CPU / frequency / 2 - 1; + prescalarbits = 0b001; // ck/1: same for both timers + 342: 81 e0 ldi r24, 0x01 ; 1 + 344: 01 c0 rjmp .+2 ; 0x348 <_Z4tonehjm.constprop.15+0x1fa> + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 8 - 1; + prescalarbits = 0b010; // ck/8: same for both timers + 346: 82 e0 ldi r24, 0x02 ; 2 + } + } + } + +#if defined(TCCR0B) + if (_timer == 0) + 348: 11 11 cpse r17, r1 + 34a: 34 c0 rjmp .+104 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + { + TCCR0B = (TCCR0B & 0b11111000) | prescalarbits; + 34c: 95 b5 in r25, 0x25 ; 37 + 34e: 98 7f andi r25, 0xF8 ; 248 + 350: 89 2b or r24, r25 + 352: 85 bd out 0x25, r24 ; 37 + 354: 68 c0 rjmp .+208 ; 0x426 <__LOCK_REGION_LENGTH__+0x26> + prescalarbits = 0b011; + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + 356: 68 e4 ldi r22, 0x48 ; 72 + 358: 78 ee ldi r23, 0xE8 ; 232 + 35a: 81 e0 ldi r24, 0x01 ; 1 + 35c: 90 e0 ldi r25, 0x00 ; 0 + 35e: a5 01 movw r20, r10 + 360: 94 01 movw r18, r8 + 362: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 366: 69 01 movw r12, r18 + 368: 7a 01 movw r14, r20 + 36a: 81 e0 ldi r24, 0x01 ; 1 + 36c: c8 1a sub r12, r24 + 36e: d1 08 sbc r13, r1 + 370: e1 08 sbc r14, r1 + 372: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b011 : 0b100; + + if (_timer == 2 && ocr > 255) + 374: 2f ef ldi r18, 0xFF ; 255 + 376: c2 16 cp r12, r18 + 378: d1 04 cpc r13, r1 + 37a: e1 04 cpc r14, r1 + 37c: f1 04 cpc r15, r1 + 37e: 09 f0 breq .+2 ; 0x382 <_Z4tonehjm.constprop.15+0x234> + 380: 08 f4 brcc .+2 ; 0x384 <_Z4tonehjm.constprop.15+0x236> + 382: 95 c0 rjmp .+298 ; 0x4ae <__LOCK_REGION_LENGTH__+0xae> + { + ocr = F_CPU / frequency / 2 / 128 - 1; + 384: 64 e2 ldi r22, 0x24 ; 36 + 386: 74 ef ldi r23, 0xF4 ; 244 + 388: 80 e0 ldi r24, 0x00 ; 0 + 38a: 90 e0 ldi r25, 0x00 ; 0 + 38c: a5 01 movw r20, r10 + 38e: 94 01 movw r18, r8 + 390: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 394: 69 01 movw r12, r18 + 396: 7a 01 movw r14, r20 + 398: 81 e0 ldi r24, 0x01 ; 1 + 39a: c8 1a sub r12, r24 + 39c: d1 08 sbc r13, r1 + 39e: e1 08 sbc r14, r1 + 3a0: f1 08 sbc r15, r1 + prescalarbits = 0b101; + } + + if (ocr > 255) + 3a2: 2f ef ldi r18, 0xFF ; 255 + 3a4: c2 16 cp r12, r18 + 3a6: d1 04 cpc r13, r1 + 3a8: e1 04 cpc r14, r1 + 3aa: f1 04 cpc r15, r1 + 3ac: 11 f0 breq .+4 ; 0x3b2 <_Z4tonehjm.constprop.15+0x264> + 3ae: 08 f0 brcs .+2 ; 0x3b2 <_Z4tonehjm.constprop.15+0x264> + 3b0: 82 c0 rjmp .+260 ; 0x4b6 <__LOCK_REGION_LENGTH__+0xb6> + prescalarbits = _timer == 0 ? 0b011 : 0b100; + + if (_timer == 2 && ocr > 255) + { + ocr = F_CPU / frequency / 2 / 128 - 1; + prescalarbits = 0b101; + 3b2: 85 e0 ldi r24, 0x05 ; 5 + } + else +#endif +#if defined(TCCR2B) + { + TCCR2B = (TCCR2B & 0b11111000) | prescalarbits; + 3b4: 90 91 b1 00 lds r25, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + 3b8: 98 7f andi r25, 0xF8 ; 248 + 3ba: 89 2b or r24, r25 + 3bc: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + 3c0: 32 c0 rjmp .+100 ; 0x426 <__LOCK_REGION_LENGTH__+0x26> +#endif + } + else + { + // two choices for the 16 bit timers: ck/1 or ck/64 + ocr = F_CPU / frequency / 2 - 1; + 3c2: 4e 01 movw r8, r28 + 3c4: a1 2c mov r10, r1 + 3c6: b1 2c mov r11, r1 + 3c8: 60 e0 ldi r22, 0x00 ; 0 + 3ca: 72 e1 ldi r23, 0x12 ; 18 + 3cc: 8a e7 ldi r24, 0x7A ; 122 + 3ce: 90 e0 ldi r25, 0x00 ; 0 + 3d0: a5 01 movw r20, r10 + 3d2: 94 01 movw r18, r8 + 3d4: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 3d8: 69 01 movw r12, r18 + 3da: 7a 01 movw r14, r20 + 3dc: 81 e0 ldi r24, 0x01 ; 1 + 3de: c8 1a sub r12, r24 + 3e0: d1 08 sbc r13, r1 + 3e2: e1 08 sbc r14, r1 + 3e4: f1 08 sbc r15, r1 + + prescalarbits = 0b001; + if (ocr > 0xffff) + 3e6: c1 14 cp r12, r1 + 3e8: d1 04 cpc r13, r1 + 3ea: 21 e0 ldi r18, 0x01 ; 1 + 3ec: e2 06 cpc r14, r18 + 3ee: f1 04 cpc r15, r1 + 3f0: 88 f0 brcs .+34 ; 0x414 <__LOCK_REGION_LENGTH__+0x14> + { + ocr = F_CPU / frequency / 2 / 64 - 1; + 3f2: 68 e4 ldi r22, 0x48 ; 72 + 3f4: 78 ee ldi r23, 0xE8 ; 232 + 3f6: 81 e0 ldi r24, 0x01 ; 1 + 3f8: 90 e0 ldi r25, 0x00 ; 0 + 3fa: a5 01 movw r20, r10 + 3fc: 94 01 movw r18, r8 + 3fe: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 402: 69 01 movw r12, r18 + 404: 7a 01 movw r14, r20 + 406: 81 e0 ldi r24, 0x01 ; 1 + 408: c8 1a sub r12, r24 + 40a: d1 08 sbc r13, r1 + 40c: e1 08 sbc r14, r1 + 40e: f1 08 sbc r15, r1 + prescalarbits = 0b011; + 410: 83 e0 ldi r24, 0x03 ; 3 + 412: 01 c0 rjmp .+2 ; 0x416 <__LOCK_REGION_LENGTH__+0x16> + else + { + // two choices for the 16 bit timers: ck/1 or ck/64 + ocr = F_CPU / frequency / 2 - 1; + + prescalarbits = 0b001; + 414: 81 e0 ldi r24, 0x01 ; 1 + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = 0b011; + } + + if (_timer == 1) + 416: 11 30 cpi r17, 0x01 ; 1 + 418: 31 f4 brne .+12 ; 0x426 <__LOCK_REGION_LENGTH__+0x26> + { +#if defined(TCCR1B) + TCCR1B = (TCCR1B & 0b11111000) | prescalarbits; + 41a: 90 91 81 00 lds r25, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + 41e: 98 7f andi r25, 0xF8 ; 248 + 420: 89 2b or r24, r25 + 422: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + + + // Calculate the toggle count + if (duration > 0) + { + toggle_count = 2 * frequency * duration / 1000; + 426: 9e 01 movw r18, r28 + 428: 22 0f add r18, r18 + 42a: 33 1f adc r19, r19 + 42c: a4 e6 ldi r26, 0x64 ; 100 + 42e: b0 e0 ldi r27, 0x00 ; 0 + 430: 0e 94 be 08 call 0x117c ; 0x117c <__umulhisi3> + 434: 28 ee ldi r18, 0xE8 ; 232 + 436: 33 e0 ldi r19, 0x03 ; 3 + 438: 40 e0 ldi r20, 0x00 ; 0 + 43a: 50 e0 ldi r21, 0x00 ; 0 + 43c: 0e 94 7d 08 call 0x10fa ; 0x10fa <__udivmodsi4> + } + + // Set the OCR for the given timer, + // set the toggle count, + // then turn on the interrupts + switch (_timer) + 440: 11 30 cpi r17, 0x01 ; 1 + 442: 99 f0 breq .+38 ; 0x46a <__LOCK_REGION_LENGTH__+0x6a> + 444: 12 30 cpi r17, 0x02 ; 2 + 446: 19 f1 breq .+70 ; 0x48e <__LOCK_REGION_LENGTH__+0x8e> + 448: 11 11 cpse r17, r1 + 44a: 9f c0 rjmp .+318 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + { + +#if defined(OCR0A) && defined(TIMSK0) && defined(OCIE0A) + case 0: + OCR0A = ocr; + 44c: c7 bc out 0x27, r12 ; 39 + timer0_toggle_count = toggle_count; + 44e: 20 93 e7 01 sts 0x01E7, r18 ; 0x8001e7 + 452: 30 93 e8 01 sts 0x01E8, r19 ; 0x8001e8 + 456: 40 93 e9 01 sts 0x01E9, r20 ; 0x8001e9 + 45a: 50 93 ea 01 sts 0x01EA, r21 ; 0x8001ea + bitWrite(TIMSK0, OCIE0A, 1); + 45e: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + 462: 82 60 ori r24, 0x02 ; 2 + 464: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + 468: 90 c0 rjmp .+288 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + break; +#endif + + case 1: +#if defined(OCR1A) && defined(TIMSK1) && defined(OCIE1A) + OCR1A = ocr; + 46a: d0 92 89 00 sts 0x0089, r13 ; 0x800089 <__TEXT_REGION_LENGTH__+0x7e0089> + 46e: c0 92 88 00 sts 0x0088, r12 ; 0x800088 <__TEXT_REGION_LENGTH__+0x7e0088> + timer1_toggle_count = toggle_count; + 472: 20 93 e3 01 sts 0x01E3, r18 ; 0x8001e3 + 476: 30 93 e4 01 sts 0x01E4, r19 ; 0x8001e4 + 47a: 40 93 e5 01 sts 0x01E5, r20 ; 0x8001e5 + 47e: 50 93 e6 01 sts 0x01E6, r21 ; 0x8001e6 + bitWrite(TIMSK1, OCIE1A, 1); + 482: 80 91 6f 00 lds r24, 0x006F ; 0x80006f <__TEXT_REGION_LENGTH__+0x7e006f> + 486: 82 60 ori r24, 0x02 ; 2 + 488: 80 93 6f 00 sts 0x006F, r24 ; 0x80006f <__TEXT_REGION_LENGTH__+0x7e006f> + 48c: 7e c0 rjmp .+252 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> +#endif + break; + +#if defined(OCR2A) && defined(TIMSK2) && defined(OCIE2A) + case 2: + OCR2A = ocr; + 48e: c0 92 b3 00 sts 0x00B3, r12 ; 0x8000b3 <__TEXT_REGION_LENGTH__+0x7e00b3> + timer2_toggle_count = toggle_count; + 492: 20 93 df 01 sts 0x01DF, r18 ; 0x8001df + 496: 30 93 e0 01 sts 0x01E0, r19 ; 0x8001e0 + 49a: 40 93 e1 01 sts 0x01E1, r20 ; 0x8001e1 + 49e: 50 93 e2 01 sts 0x01E2, r21 ; 0x8001e2 + bitWrite(TIMSK2, OCIE2A, 1); + 4a2: 80 91 70 00 lds r24, 0x0070 ; 0x800070 <__TEXT_REGION_LENGTH__+0x7e0070> + 4a6: 82 60 ori r24, 0x02 ; 2 + 4a8: 80 93 70 00 sts 0x0070, r24 ; 0x800070 <__TEXT_REGION_LENGTH__+0x7e0070> + 4ac: 6e c0 rjmp .+220 ; 0x58a <__LOCK_REGION_LENGTH__+0x18a> + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = _timer == 0 ? 0b011 : 0b100; + 4ae: 84 e0 ldi r24, 0x04 ; 4 + 4b0: 81 cf rjmp .-254 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + ocr = F_CPU / frequency / 2 - 1; + prescalarbits = 0b001; // ck/1: same for both timers + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 8 - 1; + prescalarbits = 0b010; // ck/8: same for both timers + 4b2: 82 e0 ldi r24, 0x02 ; 2 + 4b4: 7f cf rjmp .-258 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + prescalarbits = 0b101; + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 256 - 1; + 4b6: 62 e1 ldi r22, 0x12 ; 18 + 4b8: 7a e7 ldi r23, 0x7A ; 122 + 4ba: 80 e0 ldi r24, 0x00 ; 0 + 4bc: 90 e0 ldi r25, 0x00 ; 0 + 4be: a5 01 movw r20, r10 + 4c0: 94 01 movw r18, r8 + 4c2: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 4c6: 69 01 movw r12, r18 + 4c8: 7a 01 movw r14, r20 + 4ca: 81 e0 ldi r24, 0x01 ; 1 + 4cc: c8 1a sub r12, r24 + 4ce: d1 08 sbc r13, r1 + 4d0: e1 08 sbc r14, r1 + 4d2: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b100 : 0b110; + if (ocr > 255) + 4d4: 8f ef ldi r24, 0xFF ; 255 + 4d6: c8 16 cp r12, r24 + 4d8: d1 04 cpc r13, r1 + 4da: e1 04 cpc r14, r1 + 4dc: f1 04 cpc r15, r1 + 4de: 99 f0 breq .+38 ; 0x506 <__LOCK_REGION_LENGTH__+0x106> + 4e0: 90 f0 brcs .+36 ; 0x506 <__LOCK_REGION_LENGTH__+0x106> + { + // can't do any better than /1024 + ocr = F_CPU / frequency / 2 / 1024 - 1; + 4e2: d3 01 movw r26, r6 + 4e4: c2 01 movw r24, r4 + 4e6: 2a e0 ldi r18, 0x0A ; 10 + 4e8: b5 95 asr r27 + 4ea: a7 95 ror r26 + 4ec: 97 95 ror r25 + 4ee: 87 95 ror r24 + 4f0: 2a 95 dec r18 + 4f2: d1 f7 brne .-12 ; 0x4e8 <__LOCK_REGION_LENGTH__+0xe8> + 4f4: 6c 01 movw r12, r24 + 4f6: 7d 01 movw r14, r26 + 4f8: 21 e0 ldi r18, 0x01 ; 1 + 4fa: c2 1a sub r12, r18 + 4fc: d1 08 sbc r13, r1 + 4fe: e1 08 sbc r14, r1 + 500: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b101 : 0b111; + 502: 87 e0 ldi r24, 0x07 ; 7 + 504: 57 cf rjmp .-338 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 256 - 1; + prescalarbits = _timer == 0 ? 0b100 : 0b110; + 506: 86 e0 ldi r24, 0x06 ; 6 + 508: 55 cf rjmp .-342 ; 0x3b4 <_Z4tonehjm.constprop.15+0x266> + { + ocr = F_CPU / frequency / 2 / 128 - 1; + prescalarbits = 0b101; + } + + if (ocr > 255) + 50a: 2f ef ldi r18, 0xFF ; 255 + 50c: c2 16 cp r12, r18 + 50e: d1 04 cpc r13, r1 + 510: e1 04 cpc r14, r1 + 512: f1 04 cpc r15, r1 + 514: 09 f0 breq .+2 ; 0x518 <__LOCK_REGION_LENGTH__+0x118> + 516: 78 f6 brcc .-98 ; 0x4b6 <__LOCK_REGION_LENGTH__+0xb6> + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = _timer == 0 ? 0b011 : 0b100; + 518: 84 e0 ldi r24, 0x04 ; 4 + 51a: 16 cf rjmp .-468 ; 0x348 <_Z4tonehjm.constprop.15+0x1fa> + { + ocr = F_CPU / frequency / 2 / 128 - 1; + prescalarbits = 0b101; + } + + if (ocr > 255) + 51c: 8f ef ldi r24, 0xFF ; 255 + 51e: c8 16 cp r12, r24 + 520: d1 04 cpc r13, r1 + 522: e1 04 cpc r14, r1 + 524: f1 04 cpc r15, r1 + 526: 59 f1 breq .+86 ; 0x57e <__LOCK_REGION_LENGTH__+0x17e> + 528: 50 f1 brcs .+84 ; 0x57e <__LOCK_REGION_LENGTH__+0x17e> + { + ocr = F_CPU / frequency / 2 / 256 - 1; + 52a: 62 e1 ldi r22, 0x12 ; 18 + 52c: 7a e7 ldi r23, 0x7A ; 122 + 52e: 80 e0 ldi r24, 0x00 ; 0 + 530: 90 e0 ldi r25, 0x00 ; 0 + 532: a5 01 movw r20, r10 + 534: 94 01 movw r18, r8 + 536: 0e 94 9f 08 call 0x113e ; 0x113e <__divmodsi4> + 53a: 69 01 movw r12, r18 + 53c: 7a 01 movw r14, r20 + 53e: 81 e0 ldi r24, 0x01 ; 1 + 540: c8 1a sub r12, r24 + 542: d1 08 sbc r13, r1 + 544: e1 08 sbc r14, r1 + 546: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b100 : 0b110; + if (ocr > 255) + 548: 2f ef ldi r18, 0xFF ; 255 + 54a: c2 16 cp r12, r18 + 54c: d1 04 cpc r13, r1 + 54e: e1 04 cpc r14, r1 + 550: f1 04 cpc r15, r1 + 552: 99 f0 breq .+38 ; 0x57a <__LOCK_REGION_LENGTH__+0x17a> + 554: 90 f0 brcs .+36 ; 0x57a <__LOCK_REGION_LENGTH__+0x17a> + { + // can't do any better than /1024 + ocr = F_CPU / frequency / 2 / 1024 - 1; + 556: d3 01 movw r26, r6 + 558: c2 01 movw r24, r4 + 55a: 3a e0 ldi r19, 0x0A ; 10 + 55c: b5 95 asr r27 + 55e: a7 95 ror r26 + 560: 97 95 ror r25 + 562: 87 95 ror r24 + 564: 3a 95 dec r19 + 566: d1 f7 brne .-12 ; 0x55c <__LOCK_REGION_LENGTH__+0x15c> + 568: 6c 01 movw r12, r24 + 56a: 7d 01 movw r14, r26 + 56c: 21 e0 ldi r18, 0x01 ; 1 + 56e: c2 1a sub r12, r18 + 570: d1 08 sbc r13, r1 + 572: e1 08 sbc r14, r1 + 574: f1 08 sbc r15, r1 + prescalarbits = _timer == 0 ? 0b101 : 0b111; + 576: 85 e0 ldi r24, 0x05 ; 5 + 578: e9 ce rjmp .-558 ; 0x34c <_Z4tonehjm.constprop.15+0x1fe> + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 256 - 1; + prescalarbits = _timer == 0 ? 0b100 : 0b110; + 57a: 84 e0 ldi r24, 0x04 ; 4 + 57c: e7 ce rjmp .-562 ; 0x34c <_Z4tonehjm.constprop.15+0x1fe> + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = _timer == 0 ? 0b011 : 0b100; + 57e: 83 e0 ldi r24, 0x03 ; 3 + 580: e5 ce rjmp .-566 ; 0x34c <_Z4tonehjm.constprop.15+0x1fe> + _timer = toneBegin(_pin); + + if (_timer >= 0) + { + // Set the pinMode as OUTPUT + pinMode(_pin, OUTPUT); + 582: 85 e0 ldi r24, 0x05 ; 5 + 584: 0e 94 88 00 call 0x110 ; 0x110 + 588: 75 ce rjmp .-790 ; 0x274 <_Z4tonehjm.constprop.15+0x126> + break; +#endif + + } + } +} + 58a: df 91 pop r29 + 58c: cf 91 pop r28 + 58e: 1f 91 pop r17 + 590: ff 90 pop r15 + 592: ef 90 pop r14 + 594: df 90 pop r13 + 596: cf 90 pop r12 + 598: bf 90 pop r11 + 59a: af 90 pop r10 + 59c: 9f 90 pop r9 + 59e: 8f 90 pop r8 + 5a0: 7f 90 pop r7 + 5a2: 6f 90 pop r6 + 5a4: 5f 90 pop r5 + 5a6: 4f 90 pop r4 + 5a8: 08 95 ret + +000005aa : + } +} + +void digitalWrite(uint8_t pin, uint8_t val) +{ + uint8_t timer = digitalPinToTimer(pin); + 5aa: 90 e0 ldi r25, 0x00 ; 0 + 5ac: fc 01 movw r30, r24 + 5ae: e8 59 subi r30, 0x98 ; 152 + 5b0: ff 4f sbci r31, 0xFF ; 255 + 5b2: 24 91 lpm r18, Z + uint8_t bit = digitalPinToBitMask(pin); + 5b4: fc 01 movw r30, r24 + 5b6: eb 55 subi r30, 0x5B ; 91 + 5b8: ff 4f sbci r31, 0xFF ; 255 + 5ba: 34 91 lpm r19, Z + uint8_t port = digitalPinToPort(pin); + 5bc: fc 01 movw r30, r24 + 5be: ef 56 subi r30, 0x6F ; 111 + 5c0: ff 4f sbci r31, 0xFF ; 255 + 5c2: e4 91 lpm r30, Z + volatile uint8_t *out; + + if (port == NOT_A_PIN) return; + 5c4: ee 23 and r30, r30 + 5c6: 09 f4 brne .+2 ; 0x5ca + 5c8: 3c c0 rjmp .+120 ; 0x642 + + // 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); + 5ca: 22 23 and r18, r18 + 5cc: 39 f1 breq .+78 ; 0x61c +// +//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) + 5ce: 23 30 cpi r18, 0x03 ; 3 + 5d0: 91 f0 breq .+36 ; 0x5f6 + 5d2: 38 f4 brcc .+14 ; 0x5e2 + 5d4: 21 30 cpi r18, 0x01 ; 1 + 5d6: a9 f0 breq .+42 ; 0x602 + 5d8: 22 30 cpi r18, 0x02 ; 2 + 5da: 01 f5 brne .+64 ; 0x61c + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: cbi(TCCR0A, COM0A1); break; + #endif + + #if defined(TCCR0A) && defined(COM0B1) + case TIMER0B: cbi(TCCR0A, COM0B1); break; + 5dc: 84 b5 in r24, 0x24 ; 36 + 5de: 8f 7d andi r24, 0xDF ; 223 + 5e0: 12 c0 rjmp .+36 ; 0x606 +// +//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) + 5e2: 27 30 cpi r18, 0x07 ; 7 + 5e4: 91 f0 breq .+36 ; 0x60a + 5e6: 28 30 cpi r18, 0x08 ; 8 + 5e8: a1 f0 breq .+40 ; 0x612 + 5ea: 24 30 cpi r18, 0x04 ; 4 + 5ec: b9 f4 brne .+46 ; 0x61c + { + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: cbi(TCCR1A, COM1A1); break; + #endif + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: cbi(TCCR1A, COM1B1); break; + 5ee: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 5f2: 8f 7d andi r24, 0xDF ; 223 + 5f4: 03 c0 rjmp .+6 ; 0x5fc +static void turnOffPWM(uint8_t timer) +{ + switch (timer) + { + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: cbi(TCCR1A, COM1A1); break; + 5f6: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 5fa: 8f 77 andi r24, 0x7F ; 127 + #endif + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: cbi(TCCR1A, COM1B1); break; + 5fc: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 600: 0d c0 rjmp .+26 ; 0x61c + #if defined(TCCR2) && defined(COM21) + case TIMER2: cbi(TCCR2, COM21); break; + #endif + + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: cbi(TCCR0A, COM0A1); break; + 602: 84 b5 in r24, 0x24 ; 36 + 604: 8f 77 andi r24, 0x7F ; 127 + #endif + + #if defined(TCCR0A) && defined(COM0B1) + case TIMER0B: cbi(TCCR0A, COM0B1); break; + 606: 84 bd out 0x24, r24 ; 36 + 608: 09 c0 rjmp .+18 ; 0x61c + #endif + #if defined(TCCR2A) && defined(COM2A1) + case TIMER2A: cbi(TCCR2A, COM2A1); break; + 60a: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + 60e: 8f 77 andi r24, 0x7F ; 127 + 610: 03 c0 rjmp .+6 ; 0x618 + #endif + #if defined(TCCR2A) && defined(COM2B1) + case TIMER2B: cbi(TCCR2A, COM2B1); break; + 612: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + 616: 8f 7d andi r24, 0xDF ; 223 + 618: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + + // 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); + 61c: f0 e0 ldi r31, 0x00 ; 0 + 61e: ee 0f add r30, r30 + 620: ff 1f adc r31, r31 + 622: e3 58 subi r30, 0x83 ; 131 + 624: ff 4f sbci r31, 0xFF ; 255 + 626: a5 91 lpm r26, Z+ + 628: b4 91 lpm r27, Z + + uint8_t oldSREG = SREG; + 62a: 9f b7 in r25, 0x3f ; 63 + cli(); + 62c: f8 94 cli + + if (val == LOW) { + 62e: 61 11 cpse r22, r1 + 630: 04 c0 rjmp .+8 ; 0x63a + *out &= ~bit; + 632: 8c 91 ld r24, X + 634: 30 95 com r19 + 636: 38 23 and r19, r24 + 638: 02 c0 rjmp .+4 ; 0x63e + } else { + *out |= bit; + 63a: ec 91 ld r30, X + 63c: 3e 2b or r19, r30 + 63e: 3c 93 st X, r19 + } + + SREG = oldSREG; + 640: 9f bf out 0x3f, r25 ; 63 + 642: 08 95 ret + +00000644 : + return m; +} + +unsigned long micros() { + unsigned long m; + uint8_t oldSREG = SREG, t; + 644: 3f b7 in r19, 0x3f ; 63 + + cli(); + 646: f8 94 cli + m = timer0_overflow_count; + 648: 80 91 39 01 lds r24, 0x0139 ; 0x800139 + 64c: 90 91 3a 01 lds r25, 0x013A ; 0x80013a + 650: a0 91 3b 01 lds r26, 0x013B ; 0x80013b + 654: b0 91 3c 01 lds r27, 0x013C ; 0x80013c +#if defined(TCNT0) + t = TCNT0; + 658: 26 b5 in r18, 0x26 ; 38 +#else + #error TIMER 0 not defined +#endif + +#ifdef TIFR0 + if ((TIFR0 & _BV(TOV0)) && (t < 255)) + 65a: a8 9b sbis 0x15, 0 ; 21 + 65c: 05 c0 rjmp .+10 ; 0x668 + 65e: 2f 3f cpi r18, 0xFF ; 255 + 660: 19 f0 breq .+6 ; 0x668 + m++; + 662: 01 96 adiw r24, 0x01 ; 1 + 664: a1 1d adc r26, r1 + 666: b1 1d adc r27, r1 +#else + if ((TIFR & _BV(TOV0)) && (t < 255)) + m++; +#endif + + SREG = oldSREG; + 668: 3f bf out 0x3f, r19 ; 63 + + return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); + 66a: ba 2f mov r27, r26 + 66c: a9 2f mov r26, r25 + 66e: 98 2f mov r25, r24 + 670: 88 27 eor r24, r24 + 672: 82 0f add r24, r18 + 674: 91 1d adc r25, r1 + 676: a1 1d adc r26, r1 + 678: b1 1d adc r27, r1 + 67a: bc 01 movw r22, r24 + 67c: cd 01 movw r24, r26 + 67e: 42 e0 ldi r20, 0x02 ; 2 + 680: 66 0f add r22, r22 + 682: 77 1f adc r23, r23 + 684: 88 1f adc r24, r24 + 686: 99 1f adc r25, r25 + 688: 4a 95 dec r20 + 68a: d1 f7 brne .-12 ; 0x680 +} + 68c: 08 95 ret + +0000068e : + +void delay(unsigned long ms) +{ + 68e: 8f 92 push r8 + 690: 9f 92 push r9 + 692: af 92 push r10 + 694: bf 92 push r11 + 696: cf 92 push r12 + 698: df 92 push r13 + 69a: ef 92 push r14 + 69c: ff 92 push r15 + 69e: 6b 01 movw r12, r22 + 6a0: 7c 01 movw r14, r24 + uint32_t start = micros(); + 6a2: 0e 94 22 03 call 0x644 ; 0x644 + 6a6: 4b 01 movw r8, r22 + 6a8: 5c 01 movw r10, r24 + + while (ms > 0) { + 6aa: c1 14 cp r12, r1 + 6ac: d1 04 cpc r13, r1 + 6ae: e1 04 cpc r14, r1 + 6b0: f1 04 cpc r15, r1 + 6b2: f1 f0 breq .+60 ; 0x6f0 + yield(); + while ( ms > 0 && (micros() - start) >= 1000) { + 6b4: 0e 94 22 03 call 0x644 ; 0x644 + 6b8: dc 01 movw r26, r24 + 6ba: cb 01 movw r24, r22 + 6bc: 88 19 sub r24, r8 + 6be: 99 09 sbc r25, r9 + 6c0: aa 09 sbc r26, r10 + 6c2: bb 09 sbc r27, r11 + 6c4: 88 3e cpi r24, 0xE8 ; 232 + 6c6: 93 40 sbci r25, 0x03 ; 3 + 6c8: a1 05 cpc r26, r1 + 6ca: b1 05 cpc r27, r1 + 6cc: 70 f3 brcs .-36 ; 0x6aa + ms--; + 6ce: 21 e0 ldi r18, 0x01 ; 1 + 6d0: c2 1a sub r12, r18 + 6d2: d1 08 sbc r13, r1 + 6d4: e1 08 sbc r14, r1 + 6d6: f1 08 sbc r15, r1 + start += 1000; + 6d8: 88 ee ldi r24, 0xE8 ; 232 + 6da: 88 0e add r8, r24 + 6dc: 83 e0 ldi r24, 0x03 ; 3 + 6de: 98 1e adc r9, r24 + 6e0: a1 1c adc r10, r1 + 6e2: b1 1c adc r11, r1 +{ + uint32_t start = micros(); + + while (ms > 0) { + yield(); + while ( ms > 0 && (micros() - start) >= 1000) { + 6e4: c1 14 cp r12, r1 + 6e6: d1 04 cpc r13, r1 + 6e8: e1 04 cpc r14, r1 + 6ea: f1 04 cpc r15, r1 + 6ec: 19 f7 brne .-58 ; 0x6b4 + 6ee: dd cf rjmp .-70 ; 0x6aa + ms--; + start += 1000; + } + } +} + 6f0: ff 90 pop r15 + 6f2: ef 90 pop r14 + 6f4: df 90 pop r13 + 6f6: cf 90 pop r12 + 6f8: bf 90 pop r11 + 6fa: af 90 pop r10 + 6fc: 9f 90 pop r9 + 6fe: 8f 90 pop r8 + 700: 08 95 ret + +00000702 <_ZN5Print5writeEPKhj>: + +// Public Methods ////////////////////////////////////////////////////////////// + +/* default implementation: may be overridden */ +size_t Print::write(const uint8_t *buffer, size_t size) +{ + 702: cf 92 push r12 + 704: df 92 push r13 + 706: ef 92 push r14 + 708: ff 92 push r15 + 70a: 0f 93 push r16 + 70c: 1f 93 push r17 + 70e: cf 93 push r28 + 710: df 93 push r29 + 712: 6c 01 movw r12, r24 + 714: 7a 01 movw r14, r20 + 716: 8b 01 movw r16, r22 + size_t n = 0; + 718: c0 e0 ldi r28, 0x00 ; 0 + 71a: d0 e0 ldi r29, 0x00 ; 0 + while (size--) { + 71c: ce 15 cp r28, r14 + 71e: df 05 cpc r29, r15 + 720: 81 f0 breq .+32 ; 0x742 <_ZN5Print5writeEPKhj+0x40> + if (write(*buffer++)) n++; + 722: d8 01 movw r26, r16 + 724: 6d 91 ld r22, X+ + 726: 8d 01 movw r16, r26 + 728: d6 01 movw r26, r12 + 72a: ed 91 ld r30, X+ + 72c: fc 91 ld r31, X + 72e: 01 90 ld r0, Z+ + 730: f0 81 ld r31, Z + 732: e0 2d mov r30, r0 + 734: c6 01 movw r24, r12 + 736: 09 95 icall + 738: 89 2b or r24, r25 + 73a: 11 f0 breq .+4 ; 0x740 <_ZN5Print5writeEPKhj+0x3e> + 73c: 21 96 adiw r28, 0x01 ; 1 + 73e: ee cf rjmp .-36 ; 0x71c <_ZN5Print5writeEPKhj+0x1a> + 740: 7e 01 movw r14, r28 + else break; + } + return n; +} + 742: c7 01 movw r24, r14 + 744: df 91 pop r29 + 746: cf 91 pop r28 + 748: 1f 91 pop r17 + 74a: 0f 91 pop r16 + 74c: ff 90 pop r15 + 74e: ef 90 pop r14 + 750: df 90 pop r13 + 752: cf 90 pop r12 + 754: 08 95 ret + +00000756 <_ZN5Print5flushEv>: + size_t println(unsigned long, int = DEC); + size_t println(double, int = 2); + size_t println(const Printable&); + size_t println(void); + + virtual void flush() { /* Empty implementation for backward compatibility */ } + 756: 08 95 ret + +00000758 <_ZN5Print17availableForWriteEv>: + return write((const uint8_t *)buffer, size); + } + + // default to zero, meaning "a single write may block" + // should be overriden by subclasses with buffering + virtual int availableForWrite() { return 0; } + 758: 80 e0 ldi r24, 0x00 ; 0 + 75a: 90 e0 ldi r25, 0x00 ; 0 + 75c: 08 95 ret + +0000075e <_ZN14HardwareSerial17availableForWriteEv>: +{ + tx_buffer_index_t head; + tx_buffer_index_t tail; + + TX_BUFFER_ATOMIC { + head = _tx_buffer_head; + 75e: fc 01 movw r30, r24 + 760: 53 8d ldd r21, Z+27 ; 0x1b + tail = _tx_buffer_tail; + 762: 44 8d ldd r20, Z+28 ; 0x1c + 764: 25 2f mov r18, r21 + 766: 30 e0 ldi r19, 0x00 ; 0 + 768: 84 2f mov r24, r20 + 76a: 90 e0 ldi r25, 0x00 ; 0 + } + if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; + 76c: 82 1b sub r24, r18 + 76e: 93 0b sbc r25, r19 + 770: 54 17 cp r21, r20 + 772: 10 f0 brcs .+4 ; 0x778 <_ZN14HardwareSerial17availableForWriteEv+0x1a> + 774: cf 96 adiw r24, 0x3f ; 63 + 776: 08 95 ret + return tail - head - 1; + 778: 01 97 sbiw r24, 0x01 ; 1 +} + 77a: 08 95 ret + +0000077c <_ZN14HardwareSerial4readEv>: + return _rx_buffer[_rx_buffer_tail]; + } +} + +int HardwareSerial::read(void) +{ + 77c: fc 01 movw r30, r24 + // if the head isn't ahead of the tail, we don't have any characters + if (_rx_buffer_head == _rx_buffer_tail) { + 77e: 91 8d ldd r25, Z+25 ; 0x19 + 780: 82 8d ldd r24, Z+26 ; 0x1a + 782: 98 17 cp r25, r24 + 784: 61 f0 breq .+24 ; 0x79e <_ZN14HardwareSerial4readEv+0x22> + return -1; + } else { + unsigned char c = _rx_buffer[_rx_buffer_tail]; + 786: 82 8d ldd r24, Z+26 ; 0x1a + 788: df 01 movw r26, r30 + 78a: a8 0f add r26, r24 + 78c: b1 1d adc r27, r1 + 78e: 5d 96 adiw r26, 0x1d ; 29 + 790: 8c 91 ld r24, X + _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE; + 792: 92 8d ldd r25, Z+26 ; 0x1a + 794: 9f 5f subi r25, 0xFF ; 255 + 796: 9f 73 andi r25, 0x3F ; 63 + 798: 92 8f std Z+26, r25 ; 0x1a + return c; + 79a: 90 e0 ldi r25, 0x00 ; 0 + 79c: 08 95 ret + +int HardwareSerial::read(void) +{ + // if the head isn't ahead of the tail, we don't have any characters + if (_rx_buffer_head == _rx_buffer_tail) { + return -1; + 79e: 8f ef ldi r24, 0xFF ; 255 + 7a0: 9f ef ldi r25, 0xFF ; 255 + } else { + unsigned char c = _rx_buffer[_rx_buffer_tail]; + _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE; + return c; + } +} + 7a2: 08 95 ret + +000007a4 <_ZN14HardwareSerial4peekEv>: +{ + return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; +} + +int HardwareSerial::peek(void) +{ + 7a4: fc 01 movw r30, r24 + if (_rx_buffer_head == _rx_buffer_tail) { + 7a6: 91 8d ldd r25, Z+25 ; 0x19 + 7a8: 82 8d ldd r24, Z+26 ; 0x1a + 7aa: 98 17 cp r25, r24 + 7ac: 31 f0 breq .+12 ; 0x7ba <_ZN14HardwareSerial4peekEv+0x16> + return -1; + } else { + return _rx_buffer[_rx_buffer_tail]; + 7ae: 82 8d ldd r24, Z+26 ; 0x1a + 7b0: e8 0f add r30, r24 + 7b2: f1 1d adc r31, r1 + 7b4: 85 8d ldd r24, Z+29 ; 0x1d + 7b6: 90 e0 ldi r25, 0x00 ; 0 + 7b8: 08 95 ret +} + +int HardwareSerial::peek(void) +{ + if (_rx_buffer_head == _rx_buffer_tail) { + return -1; + 7ba: 8f ef ldi r24, 0xFF ; 255 + 7bc: 9f ef ldi r25, 0xFF ; 255 + } else { + return _rx_buffer[_rx_buffer_tail]; + } +} + 7be: 08 95 ret + +000007c0 <_ZN14HardwareSerial9availableEv>: + // clear any received data + _rx_buffer_head = _rx_buffer_tail; +} + +int HardwareSerial::available(void) +{ + 7c0: fc 01 movw r30, r24 + return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; + 7c2: 91 8d ldd r25, Z+25 ; 0x19 + 7c4: 22 8d ldd r18, Z+26 ; 0x1a + 7c6: 89 2f mov r24, r25 + 7c8: 90 e0 ldi r25, 0x00 ; 0 + 7ca: 80 5c subi r24, 0xC0 ; 192 + 7cc: 9f 4f sbci r25, 0xFF ; 255 + 7ce: 82 1b sub r24, r18 + 7d0: 91 09 sbc r25, r1 +} + 7d2: 8f 73 andi r24, 0x3F ; 63 + 7d4: 99 27 eor r25, r25 + 7d6: 08 95 ret + +000007d8 <_Z17Serial0_availablev>: +#endif + +// Function that can be weakly referenced by serialEventRun to prevent +// pulling in this file if it's not otherwise used. +bool Serial0_available() { + return Serial.available(); + 7d8: 8d e3 ldi r24, 0x3D ; 61 + 7da: 91 e0 ldi r25, 0x01 ; 1 + 7dc: 0e 94 e0 03 call 0x7c0 ; 0x7c0 <_ZN14HardwareSerial9availableEv> + 7e0: 21 e0 ldi r18, 0x01 ; 1 + 7e2: 89 2b or r24, r25 + 7e4: 09 f4 brne .+2 ; 0x7e8 <_Z17Serial0_availablev+0x10> + 7e6: 20 e0 ldi r18, 0x00 ; 0 +} + 7e8: 82 2f mov r24, r18 + 7ea: 08 95 ret + +000007ec <_ZN14HardwareSerial17_tx_udr_empty_irqEv>: +#endif + +// Actual interrupt handlers ////////////////////////////////////////////////////////////// + +void HardwareSerial::_tx_udr_empty_irq(void) +{ + 7ec: fc 01 movw r30, r24 + // If interrupts are enabled, there must be more data in the output + // buffer. Send the next byte + unsigned char c = _tx_buffer[_tx_buffer_tail]; + 7ee: 84 8d ldd r24, Z+28 ; 0x1c + 7f0: df 01 movw r26, r30 + 7f2: a8 0f add r26, r24 + 7f4: b1 1d adc r27, r1 + 7f6: a3 5a subi r26, 0xA3 ; 163 + 7f8: bf 4f sbci r27, 0xFF ; 255 + 7fa: 2c 91 ld r18, X + _tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE; + 7fc: 84 8d ldd r24, Z+28 ; 0x1c + 7fe: 90 e0 ldi r25, 0x00 ; 0 + 800: 01 96 adiw r24, 0x01 ; 1 + 802: 8f 73 andi r24, 0x3F ; 63 + 804: 99 27 eor r25, r25 + 806: 84 8f std Z+28, r24 ; 0x1c + + *_udr = c; + 808: a6 89 ldd r26, Z+22 ; 0x16 + 80a: b7 89 ldd r27, Z+23 ; 0x17 + 80c: 2c 93 st X, r18 + // location". This makes sure flush() won't return until the bytes + // actually got written. Other r/w bits are preserved, and zeroes + // written to the rest. + +#ifdef MPCM0 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); + 80e: a0 89 ldd r26, Z+16 ; 0x10 + 810: b1 89 ldd r27, Z+17 ; 0x11 + 812: 8c 91 ld r24, X + 814: 83 70 andi r24, 0x03 ; 3 + 816: 80 64 ori r24, 0x40 ; 64 + 818: 8c 93 st X, r24 +#else + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); +#endif + + if (_tx_buffer_head == _tx_buffer_tail) { + 81a: 93 8d ldd r25, Z+27 ; 0x1b + 81c: 84 8d ldd r24, Z+28 ; 0x1c + 81e: 98 13 cpse r25, r24 + 820: 06 c0 rjmp .+12 ; 0x82e <_ZN14HardwareSerial17_tx_udr_empty_irqEv+0x42> + // Buffer empty, so disable interrupts + cbi(*_ucsrb, UDRIE0); + 822: 02 88 ldd r0, Z+18 ; 0x12 + 824: f3 89 ldd r31, Z+19 ; 0x13 + 826: e0 2d mov r30, r0 + 828: 80 81 ld r24, Z + 82a: 8f 7d andi r24, 0xDF ; 223 + 82c: 80 83 st Z, r24 + 82e: 08 95 ret + +00000830 <_ZN14HardwareSerial5writeEh>: + // If we get here, nothing is queued anymore (DRIE is disabled) and + // the hardware finished tranmission (TXC is set). +} + +size_t HardwareSerial::write(uint8_t c) +{ + 830: ef 92 push r14 + 832: ff 92 push r15 + 834: 0f 93 push r16 + 836: 1f 93 push r17 + 838: cf 93 push r28 + 83a: df 93 push r29 + 83c: ec 01 movw r28, r24 + _written = true; + 83e: 81 e0 ldi r24, 0x01 ; 1 + 840: 88 8f std Y+24, r24 ; 0x18 + // If the buffer and the data register is empty, just write the byte + // to the data register and be done. This shortcut helps + // significantly improve the effective datarate at high (> + // 500kbit/s) bitrates, where interrupt overhead becomes a slowdown. + if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) { + 842: 9b 8d ldd r25, Y+27 ; 0x1b + 844: 8c 8d ldd r24, Y+28 ; 0x1c + 846: 98 13 cpse r25, r24 + 848: 05 c0 rjmp .+10 ; 0x854 <_ZN14HardwareSerial5writeEh+0x24> + 84a: e8 89 ldd r30, Y+16 ; 0x10 + 84c: f9 89 ldd r31, Y+17 ; 0x11 + 84e: 80 81 ld r24, Z + 850: 85 fd sbrc r24, 5 + 852: 26 c0 rjmp .+76 ; 0x8a0 <_ZN14HardwareSerial5writeEh+0x70> + 854: f6 2e mov r15, r22 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); +#endif + } + return 1; + } + tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE; + 856: 0b 8d ldd r16, Y+27 ; 0x1b + 858: 10 e0 ldi r17, 0x00 ; 0 + 85a: 0f 5f subi r16, 0xFF ; 255 + 85c: 1f 4f sbci r17, 0xFF ; 255 + 85e: 0f 73 andi r16, 0x3F ; 63 + 860: 11 27 eor r17, r17 + 862: e0 2e mov r14, r16 + + // If the output buffer is full, there's nothing for it other than to + // wait for the interrupt handler to empty it a bit + while (i == _tx_buffer_tail) { + 864: 8c 8d ldd r24, Y+28 ; 0x1c + 866: e8 12 cpse r14, r24 + 868: 0c c0 rjmp .+24 ; 0x882 <_ZN14HardwareSerial5writeEh+0x52> + if (bit_is_clear(SREG, SREG_I)) { + 86a: 0f b6 in r0, 0x3f ; 63 + 86c: 07 fc sbrc r0, 7 + 86e: fa cf rjmp .-12 ; 0x864 <_ZN14HardwareSerial5writeEh+0x34> + // Interrupts are disabled, so we'll have to poll the data + // register empty flag ourselves. If it is set, pretend an + // interrupt has happened and call the handler to free up + // space for us. + if(bit_is_set(*_ucsra, UDRE0)) + 870: e8 89 ldd r30, Y+16 ; 0x10 + 872: f9 89 ldd r31, Y+17 ; 0x11 + 874: 80 81 ld r24, Z + 876: 85 ff sbrs r24, 5 + 878: f5 cf rjmp .-22 ; 0x864 <_ZN14HardwareSerial5writeEh+0x34> + _tx_udr_empty_irq(); + 87a: ce 01 movw r24, r28 + 87c: 0e 94 f6 03 call 0x7ec ; 0x7ec <_ZN14HardwareSerial17_tx_udr_empty_irqEv> + 880: f1 cf rjmp .-30 ; 0x864 <_ZN14HardwareSerial5writeEh+0x34> + } else { + // nop, the interrupt handler will free up space for us + } + } + + _tx_buffer[_tx_buffer_head] = c; + 882: 8b 8d ldd r24, Y+27 ; 0x1b + 884: fe 01 movw r30, r28 + 886: e8 0f add r30, r24 + 888: f1 1d adc r31, r1 + 88a: e3 5a subi r30, 0xA3 ; 163 + 88c: ff 4f sbci r31, 0xFF ; 255 + 88e: f0 82 st Z, r15 + + // make atomic to prevent execution of ISR between setting the + // head pointer and setting the interrupt flag resulting in buffer + // retransmission + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + 890: 9f b7 in r25, 0x3f ; 63 + return 1; +} + +static __inline__ uint8_t __iCliRetVal(void) +{ + cli(); + 892: f8 94 cli + _tx_buffer_head = i; + 894: 0b 8f std Y+27, r16 ; 0x1b + sbi(*_ucsrb, UDRIE0); + 896: ea 89 ldd r30, Y+18 ; 0x12 + 898: fb 89 ldd r31, Y+19 ; 0x13 + 89a: 80 81 ld r24, Z + 89c: 80 62 ori r24, 0x20 ; 32 + 89e: 0a c0 rjmp .+20 ; 0x8b4 <_ZN14HardwareSerial5writeEh+0x84> + // So writing UDR must happen first. + // Writing UDR and clearing TC must be done atomically, otherwise + // interrupts might delay the TXC clear so the byte written to UDR + // is transmitted (setting TXC) before clearing TXC. Then TXC will + // be cleared when no bytes are left, causing flush() to hang + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + 8a0: 9f b7 in r25, 0x3f ; 63 + 8a2: f8 94 cli + *_udr = c; + 8a4: ee 89 ldd r30, Y+22 ; 0x16 + 8a6: ff 89 ldd r31, Y+23 ; 0x17 + 8a8: 60 83 st Z, r22 +#ifdef MPCM0 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); + 8aa: e8 89 ldd r30, Y+16 ; 0x10 + 8ac: f9 89 ldd r31, Y+17 ; 0x11 + 8ae: 80 81 ld r24, Z + 8b0: 83 70 andi r24, 0x03 ; 3 + 8b2: 80 64 ori r24, 0x40 ; 64 + 8b4: 80 83 st Z, r24 + (void)__s; +} + +static __inline__ void __iRestore(const uint8_t *__s) +{ + SREG = *__s; + 8b6: 9f bf out 0x3f, r25 ; 63 + _tx_buffer_head = i; + sbi(*_ucsrb, UDRIE0); + } + + return 1; +} + 8b8: 81 e0 ldi r24, 0x01 ; 1 + 8ba: 90 e0 ldi r25, 0x00 ; 0 + 8bc: df 91 pop r29 + 8be: cf 91 pop r28 + 8c0: 1f 91 pop r17 + 8c2: 0f 91 pop r16 + 8c4: ff 90 pop r15 + 8c6: ef 90 pop r14 + 8c8: 08 95 ret + +000008ca <_ZN14HardwareSerial5flushEv>: + if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; + return tail - head - 1; +} + +void HardwareSerial::flush() +{ + 8ca: cf 93 push r28 + 8cc: df 93 push r29 + 8ce: ec 01 movw r28, r24 + // If we have never written a byte, no need to flush. This special + // case is needed since there is no way to force the TXC (transmit + // complete) bit to 1 during initialization + if (!_written) + 8d0: 88 8d ldd r24, Y+24 ; 0x18 + 8d2: 88 23 and r24, r24 + 8d4: c9 f0 breq .+50 ; 0x908 <__stack+0x9> + return; + + while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) { + 8d6: ea 89 ldd r30, Y+18 ; 0x12 + 8d8: fb 89 ldd r31, Y+19 ; 0x13 + 8da: 80 81 ld r24, Z + 8dc: 85 fd sbrc r24, 5 + 8de: 05 c0 rjmp .+10 ; 0x8ea <_ZN14HardwareSerial5flushEv+0x20> + 8e0: a8 89 ldd r26, Y+16 ; 0x10 + 8e2: b9 89 ldd r27, Y+17 ; 0x11 + 8e4: 8c 91 ld r24, X + 8e6: 86 fd sbrc r24, 6 + 8e8: 0f c0 rjmp .+30 ; 0x908 <__stack+0x9> + if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0)) + 8ea: 0f b6 in r0, 0x3f ; 63 + 8ec: 07 fc sbrc r0, 7 + 8ee: f5 cf rjmp .-22 ; 0x8da <_ZN14HardwareSerial5flushEv+0x10> + 8f0: 80 81 ld r24, Z + 8f2: 85 ff sbrs r24, 5 + 8f4: f2 cf rjmp .-28 ; 0x8da <_ZN14HardwareSerial5flushEv+0x10> + // Interrupts are globally disabled, but the DR empty + // interrupt should be enabled, so poll the DR empty flag to + // prevent deadlock + if (bit_is_set(*_ucsra, UDRE0)) + 8f6: a8 89 ldd r26, Y+16 ; 0x10 + 8f8: b9 89 ldd r27, Y+17 ; 0x11 + 8fa: 8c 91 ld r24, X + 8fc: 85 ff sbrs r24, 5 + 8fe: ed cf rjmp .-38 ; 0x8da <_ZN14HardwareSerial5flushEv+0x10> + _tx_udr_empty_irq(); + 900: ce 01 movw r24, r28 + 902: 0e 94 f6 03 call 0x7ec ; 0x7ec <_ZN14HardwareSerial17_tx_udr_empty_irqEv> + 906: e7 cf rjmp .-50 ; 0x8d6 <_ZN14HardwareSerial5flushEv+0xc> + } + // If we get here, nothing is queued anymore (DRIE is disabled) and + // the hardware finished tranmission (TXC is set). +} + 908: df 91 pop r29 + 90a: cf 91 pop r28 + 90c: 08 95 ret + +0000090e <_Z14serialEventRunv>: +#endif + +void serialEventRun(void) +{ +#if defined(HAVE_HWSERIAL0) + if (Serial0_available && serialEvent && Serial0_available()) serialEvent(); + 90e: 80 e0 ldi r24, 0x00 ; 0 + 910: 90 e0 ldi r25, 0x00 ; 0 + 912: 89 2b or r24, r25 + 914: 29 f0 breq .+10 ; 0x920 <_Z14serialEventRunv+0x12> + 916: 0e 94 ec 03 call 0x7d8 ; 0x7d8 <_Z17Serial0_availablev> + 91a: 81 11 cpse r24, r1 + 91c: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> + 920: 08 95 ret + +00000922 <_ZN5Print5writeEPKc.constprop.14>: + int getWriteError() { return write_error; } + void clearWriteError() { setWriteError(0); } + + virtual size_t write(uint8_t) = 0; + size_t write(const char *str) { + if (str == NULL) return 0; + 922: 00 97 sbiw r24, 0x00 ; 0 + 924: 69 f0 breq .+26 ; 0x940 <_ZN5Print5writeEPKc.constprop.14+0x1e> + return write((const uint8_t *)str, strlen(str)); + 926: fc 01 movw r30, r24 + 928: 01 90 ld r0, Z+ + 92a: 00 20 and r0, r0 + 92c: e9 f7 brne .-6 ; 0x928 <_ZN5Print5writeEPKc.constprop.14+0x6> + 92e: 31 97 sbiw r30, 0x01 ; 1 + 930: af 01 movw r20, r30 + 932: 48 1b sub r20, r24 + 934: 59 0b sbc r21, r25 + 936: bc 01 movw r22, r24 + 938: 8d e3 ldi r24, 0x3D ; 61 + 93a: 91 e0 ldi r25, 0x01 ; 1 + 93c: 0c 94 81 03 jmp 0x702 ; 0x702 <_ZN5Print5writeEPKhj> + } + 940: 80 e0 ldi r24, 0x00 ; 0 + 942: 90 e0 ldi r25, 0x00 ; 0 + 944: 08 95 ret + +00000946 <__cxa_pure_virtual>: +extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); + +void __cxa_pure_virtual(void) { + // We might want to write some diagnostics to uart in this case + //std::terminate(); + abort(); + 946: 0e 94 d3 08 call 0x11a6 ; 0x11a6 + +0000094a <__vector_16>: +#if defined(TIM0_OVF_vect) +ISR(TIM0_OVF_vect) +#else +ISR(TIMER0_OVF_vect) +#endif +{ + 94a: 1f 92 push r1 + 94c: 0f 92 push r0 + 94e: 0f b6 in r0, 0x3f ; 63 + 950: 0f 92 push r0 + 952: 11 24 eor r1, r1 + 954: 2f 93 push r18 + 956: 3f 93 push r19 + 958: 8f 93 push r24 + 95a: 9f 93 push r25 + 95c: af 93 push r26 + 95e: 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; + 960: 80 91 35 01 lds r24, 0x0135 ; 0x800135 + 964: 90 91 36 01 lds r25, 0x0136 ; 0x800136 + 968: a0 91 37 01 lds r26, 0x0137 ; 0x800137 + 96c: b0 91 38 01 lds r27, 0x0138 ; 0x800138 + unsigned char f = timer0_fract; + 970: 30 91 34 01 lds r19, 0x0134 ; 0x800134 + + m += MILLIS_INC; + f += FRACT_INC; + 974: 23 e0 ldi r18, 0x03 ; 3 + 976: 23 0f add r18, r19 + if (f >= FRACT_MAX) { + 978: 2d 37 cpi r18, 0x7D ; 125 + 97a: 20 f4 brcc .+8 ; 0x984 <__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; + 97c: 01 96 adiw r24, 0x01 ; 1 + 97e: a1 1d adc r26, r1 + 980: b1 1d adc r27, r1 + 982: 05 c0 rjmp .+10 ; 0x98e <__vector_16+0x44> + f += FRACT_INC; + if (f >= FRACT_MAX) { + f -= FRACT_MAX; + 984: 26 e8 ldi r18, 0x86 ; 134 + 986: 23 0f add r18, r19 + m += 1; + 988: 02 96 adiw r24, 0x02 ; 2 + 98a: a1 1d adc r26, r1 + 98c: b1 1d adc r27, r1 + } + + timer0_fract = f; + 98e: 20 93 34 01 sts 0x0134, r18 ; 0x800134 + timer0_millis = m; + 992: 80 93 35 01 sts 0x0135, r24 ; 0x800135 + 996: 90 93 36 01 sts 0x0136, r25 ; 0x800136 + 99a: a0 93 37 01 sts 0x0137, r26 ; 0x800137 + 99e: b0 93 38 01 sts 0x0138, r27 ; 0x800138 + timer0_overflow_count++; + 9a2: 80 91 39 01 lds r24, 0x0139 ; 0x800139 + 9a6: 90 91 3a 01 lds r25, 0x013A ; 0x80013a + 9aa: a0 91 3b 01 lds r26, 0x013B ; 0x80013b + 9ae: b0 91 3c 01 lds r27, 0x013C ; 0x80013c + 9b2: 01 96 adiw r24, 0x01 ; 1 + 9b4: a1 1d adc r26, r1 + 9b6: b1 1d adc r27, r1 + 9b8: 80 93 39 01 sts 0x0139, r24 ; 0x800139 + 9bc: 90 93 3a 01 sts 0x013A, r25 ; 0x80013a + 9c0: a0 93 3b 01 sts 0x013B, r26 ; 0x80013b + 9c4: b0 93 3c 01 sts 0x013C, r27 ; 0x80013c +} + 9c8: bf 91 pop r27 + 9ca: af 91 pop r26 + 9cc: 9f 91 pop r25 + 9ce: 8f 91 pop r24 + 9d0: 3f 91 pop r19 + 9d2: 2f 91 pop r18 + 9d4: 0f 90 pop r0 + 9d6: 0f be out 0x3f, r0 ; 63 + 9d8: 0f 90 pop r0 + 9da: 1f 90 pop r1 + 9dc: 18 95 reti + +000009de <__vector_7>: +#endif + + +#ifdef USE_TIMER2 +ISR(TIMER2_COMPA_vect) +{ + 9de: 1f 92 push r1 + 9e0: 0f 92 push r0 + 9e2: 0f b6 in r0, 0x3f ; 63 + 9e4: 0f 92 push r0 + 9e6: 11 24 eor r1, r1 + 9e8: 2f 93 push r18 + 9ea: 3f 93 push r19 + 9ec: 4f 93 push r20 + 9ee: 5f 93 push r21 + 9f0: 6f 93 push r22 + 9f2: 7f 93 push r23 + 9f4: 8f 93 push r24 + 9f6: 9f 93 push r25 + 9f8: af 93 push r26 + 9fa: bf 93 push r27 + 9fc: ef 93 push r30 + 9fe: ff 93 push r31 + + if (timer2_toggle_count != 0) + a00: 80 91 df 01 lds r24, 0x01DF ; 0x8001df + a04: 90 91 e0 01 lds r25, 0x01E0 ; 0x8001e0 + a08: a0 91 e1 01 lds r26, 0x01E1 ; 0x8001e1 + a0c: b0 91 e2 01 lds r27, 0x01E2 ; 0x8001e2 + a10: 89 2b or r24, r25 + a12: 8a 2b or r24, r26 + a14: 8b 2b or r24, r27 + a16: 59 f1 breq .+86 ; 0xa6e <__vector_7+0x90> + { + // toggle the pin + *timer2_pin_port ^= timer2_pin_mask; + a18: 90 91 da 01 lds r25, 0x01DA ; 0x8001da + a1c: e0 91 db 01 lds r30, 0x01DB ; 0x8001db + a20: f0 91 dc 01 lds r31, 0x01DC ; 0x8001dc + a24: 80 81 ld r24, Z + a26: 89 27 eor r24, r25 + a28: 80 83 st Z, r24 + + if (timer2_toggle_count > 0) + a2a: 80 91 df 01 lds r24, 0x01DF ; 0x8001df + a2e: 90 91 e0 01 lds r25, 0x01E0 ; 0x8001e0 + a32: a0 91 e1 01 lds r26, 0x01E1 ; 0x8001e1 + a36: b0 91 e2 01 lds r27, 0x01E2 ; 0x8001e2 + a3a: 18 16 cp r1, r24 + a3c: 19 06 cpc r1, r25 + a3e: 1a 06 cpc r1, r26 + a40: 1b 06 cpc r1, r27 + a42: 0c f0 brlt .+2 ; 0xa46 <__vector_7+0x68> + a44: 3d c0 rjmp .+122 ; 0xac0 <__vector_7+0xe2> + timer2_toggle_count--; + a46: 80 91 df 01 lds r24, 0x01DF ; 0x8001df + a4a: 90 91 e0 01 lds r25, 0x01E0 ; 0x8001e0 + a4e: a0 91 e1 01 lds r26, 0x01E1 ; 0x8001e1 + a52: b0 91 e2 01 lds r27, 0x01E2 ; 0x8001e2 + a56: 01 97 sbiw r24, 0x01 ; 1 + a58: a1 09 sbc r26, r1 + a5a: b1 09 sbc r27, r1 + a5c: 80 93 df 01 sts 0x01DF, r24 ; 0x8001df + a60: 90 93 e0 01 sts 0x01E0, r25 ; 0x8001e0 + a64: a0 93 e1 01 sts 0x01E1, r26 ; 0x8001e1 + a68: b0 93 e2 01 sts 0x01E2, r27 ; 0x8001e2 + a6c: 29 c0 rjmp .+82 ; 0xac0 <__vector_7+0xe2> + else + { + // need to call noTone() so that the tone_pins[] entry is reset, so the + // timer gets initialized next time we call tone(). + // XXX: this assumes timer 2 is always the first one used. + noTone(tone_pins[0]); + a6e: 80 91 00 01 lds r24, 0x0100 ; 0x800100 <__data_start> +{ + int8_t _timer = -1; + + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == _pin) { + _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); + a72: ec e7 ldi r30, 0x7C ; 124 + a74: f0 e0 ldi r31, 0x00 ; 0 + a76: e4 91 lpm r30, Z + tone_pins[i] = 255; + a78: 9f ef ldi r25, 0xFF ; 255 + a7a: 90 93 00 01 sts 0x0100, r25 ; 0x800100 <__data_start> +// XXX: this function only works properly for timer 2 (the only one we use +// currently). for the others, it should end the tone, but won't restore +// proper PWM functionality for the timer. +void disableTimer(uint8_t _timer) +{ + switch (_timer) + a7e: e1 30 cpi r30, 0x01 ; 1 + a80: b9 f0 breq .+46 ; 0xab0 <__vector_7+0xd2> + a82: 98 f0 brcs .+38 ; 0xaaa <__vector_7+0xcc> + a84: e2 30 cpi r30, 0x02 ; 2 + a86: c9 f4 brne .+50 ; 0xaba <__vector_7+0xdc> + break; +#endif + + case 2: + #if defined(TIMSK2) && defined(OCIE2A) + bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt + a88: 90 91 70 00 lds r25, 0x0070 ; 0x800070 <__TEXT_REGION_LENGTH__+0x7e0070> + a8c: 9d 7f andi r25, 0xFD ; 253 + a8e: 90 93 70 00 sts 0x0070, r25 ; 0x800070 <__TEXT_REGION_LENGTH__+0x7e0070> + #endif + #if defined(TCCR2A) && defined(WGM20) + TCCR2A = (1 << WGM20); + a92: 91 e0 ldi r25, 0x01 ; 1 + a94: 90 93 b0 00 sts 0x00B0, r25 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + #endif + #if defined(TCCR2B) && defined(CS22) + TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22); + a98: 90 91 b1 00 lds r25, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + a9c: 98 7f andi r25, 0xF8 ; 248 + a9e: 94 60 ori r25, 0x04 ; 4 + aa0: 90 93 b1 00 sts 0x00B1, r25 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + #endif + #if defined(OCR2A) + OCR2A = 0; + aa4: 10 92 b3 00 sts 0x00B3, r1 ; 0x8000b3 <__TEXT_REGION_LENGTH__+0x7e00b3> + aa8: 08 c0 rjmp .+16 ; 0xaba <__vector_7+0xdc> +{ + switch (_timer) + { + case 0: + #if defined(TIMSK0) + TIMSK0 = 0; + aaa: 10 92 6e 00 sts 0x006E, r1 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + aae: 05 c0 rjmp .+10 ; 0xaba <__vector_7+0xdc> + #endif + break; + +#if defined(TIMSK1) && defined(OCIE1A) + case 1: + bitWrite(TIMSK1, OCIE1A, 0); + ab0: 90 91 6f 00 lds r25, 0x006F ; 0x80006f <__TEXT_REGION_LENGTH__+0x7e006f> + ab4: 9d 7f andi r25, 0xFD ; 253 + ab6: 90 93 6f 00 sts 0x006F, r25 ; 0x80006f <__TEXT_REGION_LENGTH__+0x7e006f> + } + } + + disableTimer(_timer); + + digitalWrite(_pin, 0); + aba: 60 e0 ldi r22, 0x00 ; 0 + abc: 0e 94 d5 02 call 0x5aa ; 0x5aa + // XXX: this assumes timer 2 is always the first one used. + noTone(tone_pins[0]); +// disableTimer(2); +// *timer2_pin_port &= ~(timer2_pin_mask); // keep pin low after stop + } +} + ac0: ff 91 pop r31 + ac2: ef 91 pop r30 + ac4: bf 91 pop r27 + ac6: af 91 pop r26 + ac8: 9f 91 pop r25 + aca: 8f 91 pop r24 + acc: 7f 91 pop r23 + ace: 6f 91 pop r22 + ad0: 5f 91 pop r21 + ad2: 4f 91 pop r20 + ad4: 3f 91 pop r19 + ad6: 2f 91 pop r18 + ad8: 0f 90 pop r0 + ada: 0f be out 0x3f, r0 ; 63 + adc: 0f 90 pop r0 + ade: 1f 90 pop r1 + ae0: 18 95 reti + +00000ae2 <__vector_19>: +#elif defined(USART_UDRE_vect) +ISR(USART_UDRE_vect) +#else + #error "Don't know what the Data Register Empty vector is called for Serial" +#endif +{ + ae2: 1f 92 push r1 + ae4: 0f 92 push r0 + ae6: 0f b6 in r0, 0x3f ; 63 + ae8: 0f 92 push r0 + aea: 11 24 eor r1, r1 + aec: 2f 93 push r18 + aee: 3f 93 push r19 + af0: 4f 93 push r20 + af2: 5f 93 push r21 + af4: 6f 93 push r22 + af6: 7f 93 push r23 + af8: 8f 93 push r24 + afa: 9f 93 push r25 + afc: af 93 push r26 + afe: bf 93 push r27 + b00: ef 93 push r30 + b02: ff 93 push r31 + Serial._tx_udr_empty_irq(); + b04: 8d e3 ldi r24, 0x3D ; 61 + b06: 91 e0 ldi r25, 0x01 ; 1 + b08: 0e 94 f6 03 call 0x7ec ; 0x7ec <_ZN14HardwareSerial17_tx_udr_empty_irqEv> +} + b0c: ff 91 pop r31 + b0e: ef 91 pop r30 + b10: bf 91 pop r27 + b12: af 91 pop r26 + b14: 9f 91 pop r25 + b16: 8f 91 pop r24 + b18: 7f 91 pop r23 + b1a: 6f 91 pop r22 + b1c: 5f 91 pop r21 + b1e: 4f 91 pop r20 + b20: 3f 91 pop r19 + b22: 2f 91 pop r18 + b24: 0f 90 pop r0 + b26: 0f be out 0x3f, r0 ; 63 + b28: 0f 90 pop r0 + b2a: 1f 90 pop r1 + b2c: 18 95 reti + +00000b2e <__vector_18>: +#elif defined(USART_RXC_vect) + ISR(USART_RXC_vect) // ATmega8 +#else + #error "Don't know what the Data Received vector is called for Serial" +#endif + { + b2e: 1f 92 push r1 + b30: 0f 92 push r0 + b32: 0f b6 in r0, 0x3f ; 63 + b34: 0f 92 push r0 + b36: 11 24 eor r1, r1 + b38: 2f 93 push r18 + b3a: 8f 93 push r24 + b3c: 9f 93 push r25 + b3e: ef 93 push r30 + b40: ff 93 push r31 + +// Actual interrupt handlers ////////////////////////////////////////////////////////////// + +void HardwareSerial::_rx_complete_irq(void) +{ + if (bit_is_clear(*_ucsra, UPE0)) { + b42: e0 91 4d 01 lds r30, 0x014D ; 0x80014d + b46: f0 91 4e 01 lds r31, 0x014E ; 0x80014e + b4a: 80 81 ld r24, Z + b4c: e0 91 53 01 lds r30, 0x0153 ; 0x800153 + b50: f0 91 54 01 lds r31, 0x0154 ; 0x800154 + b54: 82 fd sbrc r24, 2 + b56: 12 c0 rjmp .+36 ; 0xb7c <__vector_18+0x4e> + // No Parity error, read byte and store it in the buffer if there is + // room + unsigned char c = *_udr; + b58: 90 81 ld r25, Z + rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE; + b5a: 80 91 56 01 lds r24, 0x0156 ; 0x800156 + b5e: 8f 5f subi r24, 0xFF ; 255 + b60: 8f 73 andi r24, 0x3F ; 63 + + // if we should be storing the received character into the location + // just before the tail (meaning that the head would advance to the + // current location of the tail), we're about to overflow the buffer + // and so we don't write the character or advance the head. + if (i != _rx_buffer_tail) { + b62: 20 91 57 01 lds r18, 0x0157 ; 0x800157 + b66: 82 17 cp r24, r18 + b68: 51 f0 breq .+20 ; 0xb7e <__vector_18+0x50> + _rx_buffer[_rx_buffer_head] = c; + b6a: e0 91 56 01 lds r30, 0x0156 ; 0x800156 + b6e: f0 e0 ldi r31, 0x00 ; 0 + b70: e3 5c subi r30, 0xC3 ; 195 + b72: fe 4f sbci r31, 0xFE ; 254 + b74: 95 8f std Z+29, r25 ; 0x1d + _rx_buffer_head = i; + b76: 80 93 56 01 sts 0x0156, r24 ; 0x800156 + b7a: 01 c0 rjmp .+2 ; 0xb7e <__vector_18+0x50> + } + } else { + // Parity error, read byte but discard it + *_udr; + b7c: 80 81 ld r24, Z + Serial._rx_complete_irq(); + } + b7e: ff 91 pop r31 + b80: ef 91 pop r30 + b82: 9f 91 pop r25 + b84: 8f 91 pop r24 + b86: 2f 91 pop r18 + b88: 0f 90 pop r0 + b8a: 0f be out 0x3f, r0 ; 63 + b8c: 0f 90 pop r0 + b8e: 1f 90 pop r1 + b90: 18 95 reti + +00000b92
: + +void setupUSB() __attribute__((weak)); +void setupUSB() { } + +int main(void) +{ + b92: cf 93 push r28 + b94: df 93 push r29 + b96: cd b7 in r28, 0x3d ; 61 + b98: de b7 in r29, 0x3e ; 62 + b9a: a1 97 sbiw r28, 0x21 ; 33 + b9c: 0f b6 in r0, 0x3f ; 63 + b9e: f8 94 cli + ba0: de bf out 0x3e, r29 ; 62 + ba2: 0f be out 0x3f, r0 ; 63 + ba4: cd bf out 0x3d, r28 ; 61 + +void init() +{ + // this needs to be called before setup() or some functions won't + // work there + sei(); + ba6: 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); + ba8: 84 b5 in r24, 0x24 ; 36 + baa: 82 60 ori r24, 0x02 ; 2 + bac: 84 bd out 0x24, r24 ; 36 + sbi(TCCR0A, WGM00); + bae: 84 b5 in r24, 0x24 ; 36 + bb0: 81 60 ori r24, 0x01 ; 1 + bb2: 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); + bb4: 85 b5 in r24, 0x25 ; 37 + bb6: 82 60 ori r24, 0x02 ; 2 + bb8: 85 bd out 0x25, r24 ; 37 + sbi(TCCR0B, CS00); + bba: 85 b5 in r24, 0x25 ; 37 + bbc: 81 60 ori r24, 0x01 ; 1 + bbe: 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); + bc0: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + bc4: 81 60 ori r24, 0x01 ; 1 + bc6: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + // 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; + bca: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + + // set timer 1 prescale factor to 64 + sbi(TCCR1B, CS11); + bce: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + bd2: 82 60 ori r24, 0x02 ; 2 + bd4: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> +#if F_CPU >= 8000000L + sbi(TCCR1B, CS10); + bd8: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + bdc: 81 60 ori r24, 0x01 ; 1 + bde: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + sbi(TCCR1, CS10); +#endif +#endif + // put timer 1 in 8-bit phase correct pwm mode +#if defined(TCCR1A) && defined(WGM10) + sbi(TCCR1A, WGM10); + be2: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + be6: 81 60 ori r24, 0x01 ; 1 + be8: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + + // set timer 2 prescale factor to 64 +#if defined(TCCR2) && defined(CS22) + sbi(TCCR2, CS22); +#elif defined(TCCR2B) && defined(CS22) + sbi(TCCR2B, CS22); + bec: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + bf0: 84 60 ori r24, 0x04 ; 4 + bf2: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + + // 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); + bf6: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + bfa: 81 60 ori r24, 0x01 ; 1 + bfc: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> +#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); + c00: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + c04: 84 60 ori r24, 0x04 ; 4 + c06: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + sbi(ADCSRA, ADPS1); + c0a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + c0e: 82 60 ori r24, 0x02 ; 2 + c10: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + sbi(ADCSRA, ADPS0); + c14: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + c18: 81 60 ori r24, 0x01 ; 1 + c1a: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + cbi(ADCSRA, ADPS2); + cbi(ADCSRA, ADPS1); + sbi(ADCSRA, ADPS0); + #endif + // enable a2d conversions + sbi(ADCSRA, ADEN); + c1e: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + c22: 80 68 ori r24, 0x80 ; 128 + c24: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + // 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; + c28: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> + +void HardwareSerial::begin(unsigned long baud, byte config) +{ + // Try u2x mode first + uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2; + *_ucsra = 1 << U2X0; + c2c: e0 91 4d 01 lds r30, 0x014D ; 0x80014d + c30: f0 91 4e 01 lds r31, 0x014E ; 0x80014e + c34: 82 e0 ldi r24, 0x02 ; 2 + c36: 80 83 st Z, r24 + *_ucsra = 0; + baud_setting = (F_CPU / 8 / baud - 1) / 2; + } + + // assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register) + *_ubrrh = baud_setting >> 8; + c38: e0 91 49 01 lds r30, 0x0149 ; 0x800149 + c3c: f0 91 4a 01 lds r31, 0x014A ; 0x80014a + c40: 10 82 st Z, r1 + *_ubrrl = baud_setting; + c42: e0 91 4b 01 lds r30, 0x014B ; 0x80014b + c46: f0 91 4c 01 lds r31, 0x014C ; 0x80014c + c4a: 8f ec ldi r24, 0xCF ; 207 + c4c: 80 83 st Z, r24 + + _written = false; + c4e: 10 92 55 01 sts 0x0155, r1 ; 0x800155 + + //set the data bits, parity, and stop bits +#if defined(__AVR_ATmega8__) + config |= 0x80; // select UCSRC register (shared with UBRRH) +#endif + *_ucsrc = config; + c52: e0 91 51 01 lds r30, 0x0151 ; 0x800151 + c56: f0 91 52 01 lds r31, 0x0152 ; 0x800152 + c5a: 86 e0 ldi r24, 0x06 ; 6 + c5c: 80 83 st Z, r24 + + sbi(*_ucsrb, RXEN0); + c5e: e0 91 4f 01 lds r30, 0x014F ; 0x80014f + c62: f0 91 50 01 lds r31, 0x0150 ; 0x800150 + c66: 80 81 ld r24, Z + c68: 80 61 ori r24, 0x10 ; 16 + c6a: 80 83 st Z, r24 + sbi(*_ucsrb, TXEN0); + c6c: e0 91 4f 01 lds r30, 0x014F ; 0x80014f + c70: f0 91 50 01 lds r31, 0x0150 ; 0x800150 + c74: 80 81 ld r24, Z + c76: 88 60 ori r24, 0x08 ; 8 + c78: 80 83 st Z, r24 + sbi(*_ucsrb, RXCIE0); + c7a: e0 91 4f 01 lds r30, 0x014F ; 0x80014f + c7e: f0 91 50 01 lds r31, 0x0150 ; 0x800150 + c82: 80 81 ld r24, Z + c84: 80 68 ori r24, 0x80 ; 128 + c86: 80 83 st Z, r24 + cbi(*_ucsrb, UDRIE0); + c88: e0 91 4f 01 lds r30, 0x014F ; 0x80014f + c8c: f0 91 50 01 lds r31, 0x0150 ; 0x800150 + c90: 80 81 ld r24, Z + c92: 8f 7d andi r24, 0xDF ; 223 + c94: 80 83 st Z, r24 + +void setup() { + // put your setup code here, to run once: +Serial.begin(9600); + +pinMode(LED1, OUTPUT); + c96: 8e e0 ldi r24, 0x0E ; 14 + c98: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED2, OUTPUT); + c9c: 8f e0 ldi r24, 0x0F ; 15 + c9e: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED3, OUTPUT); + ca2: 80 e1 ldi r24, 0x10 ; 16 + ca4: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED4, OUTPUT); + ca8: 81 e1 ldi r24, 0x11 ; 17 + caa: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED5, OUTPUT); + cae: 82 e1 ldi r24, 0x12 ; 18 + cb0: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED6, OUTPUT); + cb4: 83 e1 ldi r24, 0x13 ; 19 + cb6: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED7, OUTPUT); + cba: 87 e0 ldi r24, 0x07 ; 7 + cbc: 0e 94 88 00 call 0x110 ; 0x110 +pinMode(LED8, OUTPUT); + cc0: 88 e0 ldi r24, 0x08 ; 8 + cc2: 0e 94 88 00 call 0x110 ; 0x110 + +pinMode(SPKR, OUTPUT); + cc6: 85 e0 ldi r24, 0x05 ; 5 + cc8: 0e 94 88 00 call 0x110 ; 0x110 + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + ccc: 83 e1 ldi r24, 0x13 ; 19 + cce: 91 e0 ldi r25, 0x01 ; 1 + cd0: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> + return x.printTo(*this); +} + +size_t Print::println(void) +{ + return write("\r\n"); + cd4: 88 e2 ldi r24, 0x28 ; 40 + cd6: 91 e0 ldi r25, 0x01 ; 1 + cd8: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + cdc: 8b e2 ldi r24, 0x2B ; 43 + cde: 91 e0 ldi r25, 0x01 ; 1 + ce0: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> + return x.printTo(*this); +} + +size_t Print::println(void) +{ + return write("\r\n"); + ce4: 88 e2 ldi r24, 0x28 ; 40 + ce6: 91 e0 ldi r25, 0x01 ; 1 + ce8: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> + +Serial.println("Flammable Gas Sensor"); +Serial.println("Begin"); + +int yy = 0; +for(yy=200;yy<1200;yy+=150){ + cec: 08 ec ldi r16, 0xC8 ; 200 + cee: 10 e0 ldi r17, 0x00 ; 0 + tone(SPKR,yy,100); + cf0: c8 01 movw r24, r16 + cf2: 0e 94 a7 00 call 0x14e ; 0x14e <_Z4tonehjm.constprop.15> + delay(100); + cf6: 64 e6 ldi r22, 0x64 ; 100 + cf8: 70 e0 ldi r23, 0x00 ; 0 + cfa: 80 e0 ldi r24, 0x00 ; 0 + cfc: 90 e0 ldi r25, 0x00 ; 0 + cfe: 0e 94 47 03 call 0x68e ; 0x68e + +Serial.println("Flammable Gas Sensor"); +Serial.println("Begin"); + +int yy = 0; +for(yy=200;yy<1200;yy+=150){ + d02: 0a 56 subi r16, 0x6A ; 106 + d04: 1f 4f sbci r17, 0xFF ; 255 + d06: 02 3e cpi r16, 0xE2 ; 226 + d08: 24 e0 ldi r18, 0x04 ; 4 + d0a: 12 07 cpc r17, r18 + d0c: 89 f7 brne .-30 ; 0xcf0 + tone(SPKR,yy,100); + delay(50); +}*/ + + +digitalWrite(LED1,HIGH); + d0e: 61 e0 ldi r22, 0x01 ; 1 + d10: 8e e0 ldi r24, 0x0E ; 14 + d12: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED2,HIGH); + d16: 61 e0 ldi r22, 0x01 ; 1 + d18: 8f e0 ldi r24, 0x0F ; 15 + d1a: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED3,HIGH); + d1e: 61 e0 ldi r22, 0x01 ; 1 + d20: 80 e1 ldi r24, 0x10 ; 16 + d22: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED4,HIGH); + d26: 61 e0 ldi r22, 0x01 ; 1 + d28: 81 e1 ldi r24, 0x11 ; 17 + d2a: 0e 94 d5 02 call 0x5aa ; 0x5aa + +delay(500); + d2e: 64 ef ldi r22, 0xF4 ; 244 + d30: 71 e0 ldi r23, 0x01 ; 1 + d32: 80 e0 ldi r24, 0x00 ; 0 + d34: 90 e0 ldi r25, 0x00 ; 0 + d36: 0e 94 47 03 call 0x68e ; 0x68e +digitalWrite(LED1,LOW); + d3a: 60 e0 ldi r22, 0x00 ; 0 + d3c: 8e e0 ldi r24, 0x0E ; 14 + d3e: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED2,LOW); + d42: 60 e0 ldi r22, 0x00 ; 0 + d44: 8f e0 ldi r24, 0x0F ; 15 + d46: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED3,LOW); + d4a: 60 e0 ldi r22, 0x00 ; 0 + d4c: 80 e1 ldi r24, 0x10 ; 16 + d4e: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED4,LOW); + d52: 60 e0 ldi r22, 0x00 ; 0 + d54: 81 e1 ldi r24, 0x11 ; 17 + d56: 0e 94 d5 02 call 0x5aa ; 0x5aa + +digitalWrite(LED5,HIGH); + d5a: 61 e0 ldi r22, 0x01 ; 1 + d5c: 82 e1 ldi r24, 0x12 ; 18 + d5e: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED6,HIGH); + d62: 61 e0 ldi r22, 0x01 ; 1 + d64: 83 e1 ldi r24, 0x13 ; 19 + d66: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED7,HIGH); + d6a: 61 e0 ldi r22, 0x01 ; 1 + d6c: 87 e0 ldi r24, 0x07 ; 7 + d6e: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED8,HIGH); + d72: 61 e0 ldi r22, 0x01 ; 1 + d74: 88 e0 ldi r24, 0x08 ; 8 + d76: 0e 94 d5 02 call 0x5aa ; 0x5aa + +delay(500); + d7a: 64 ef ldi r22, 0xF4 ; 244 + d7c: 71 e0 ldi r23, 0x01 ; 1 + d7e: 80 e0 ldi r24, 0x00 ; 0 + d80: 90 e0 ldi r25, 0x00 ; 0 + d82: 0e 94 47 03 call 0x68e ; 0x68e +digitalWrite(LED5,LOW); + d86: 60 e0 ldi r22, 0x00 ; 0 + d88: 82 e1 ldi r24, 0x12 ; 18 + d8a: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED6,LOW); + d8e: 60 e0 ldi r22, 0x00 ; 0 + d90: 83 e1 ldi r24, 0x13 ; 19 + d92: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED7,LOW); + d96: 60 e0 ldi r22, 0x00 ; 0 + d98: 87 e0 ldi r24, 0x07 ; 7 + d9a: 0e 94 d5 02 call 0x5aa ; 0x5aa +digitalWrite(LED8,LOW); + d9e: 60 e0 ldi r22, 0x00 ; 0 + da0: 88 e0 ldi r24, 0x08 ; 8 + da2: 0e 94 d5 02 call 0x5aa ; 0x5aa + // to 0 (the default). +#if defined(ADMUX) +#if defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) + ADMUX = (analog_reference << 4) | (pin & 0x07); +#else + ADMUX = (analog_reference << 6) | (pin & 0x07); + da6: 86 e4 ldi r24, 0x46 ; 70 + da8: b8 2e mov r11, r24 + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + char c = n % base; + daa: 9a e0 ldi r25, 0x0A ; 10 + dac: c9 2e mov r12, r25 + dae: d1 2c mov r13, r1 + db0: e1 2c mov r14, r1 + db2: f1 2c mov r15, r1 + db4: b0 92 7c 00 sts 0x007C, r11 ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c> + // without a delay, we seem to read from the wrong channel + //delay(1); + +#if defined(ADCSRA) && defined(ADCL) + // start the conversion + sbi(ADCSRA, ADSC); + db8: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + dbc: 80 64 ori r24, 0x40 ; 64 + dbe: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + + // ADSC is cleared when the conversion finishes + while (bit_is_set(ADCSRA, ADSC)); + dc2: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + dc6: 86 fd sbrc r24, 6 + dc8: fc cf rjmp .-8 ; 0xdc2 + + // we have to read ADCL first; doing so locks both ADCL + // and ADCH until ADCH is read. reading ADCL second would + // cause the results of each conversion to be discarded, + // as ADCL and ADCH would be locked when it completed. + low = ADCL; + dca: 20 91 78 00 lds r18, 0x0078 ; 0x800078 <__TEXT_REGION_LENGTH__+0x7e0078> + high = ADCH; + dce: 80 91 79 00 lds r24, 0x0079 ; 0x800079 <__TEXT_REGION_LENGTH__+0x7e0079> +} + +void loop() { + // put your main code here, to run repeatedly: + +gasVAL = analogRead(Sensor); + dd2: 30 e0 ldi r19, 0x00 ; 0 + dd4: 38 2b or r19, r24 + dd6: 30 93 33 01 sts 0x0133, r19 ; 0x800133 <__data_end+0x1> + dda: 20 93 32 01 sts 0x0132, r18 ; 0x800132 <__data_end> + return print((long) n, base); +} + +size_t Print::print(unsigned int n, int base) +{ + return print((unsigned long) n, base); + dde: 40 e0 ldi r20, 0x00 ; 0 + de0: 50 e0 ldi r21, 0x00 ; 0 +size_t Print::printNumber(unsigned long n, uint8_t base) +{ + char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte. + char *str = &buf[sizeof(buf) - 1]; + + *str = '\0'; + de2: 19 a2 std Y+33, r1 ; 0x21 + de4: 8e 01 movw r16, r28 + de6: 0f 5d subi r16, 0xDF ; 223 + de8: 1f 4f sbci r17, 0xFF ; 255 + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + char c = n % base; + n /= base; + dea: ca 01 movw r24, r20 + dec: b9 01 movw r22, r18 + dee: a7 01 movw r20, r14 + df0: 96 01 movw r18, r12 + df2: 0e 94 7d 08 call 0x10fa ; 0x10fa <__udivmodsi4> + + *--str = c < 10 ? c + '0' : c + 'A' - 10; + df6: 60 5d subi r22, 0xD0 ; 208 + df8: f8 01 movw r30, r16 + dfa: 62 93 st -Z, r22 + dfc: 8f 01 movw r16, r30 + *str = '\0'; + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + dfe: 21 15 cp r18, r1 + e00: 31 05 cpc r19, r1 + e02: 41 05 cpc r20, r1 + e04: 51 05 cpc r21, r1 + e06: 89 f7 brne .-30 ; 0xdea + n /= base; + + *--str = c < 10 ? c + '0' : c + 'A' - 10; + } while(n); + + return write(str); + e08: cf 01 movw r24, r30 + e0a: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> + return x.printTo(*this); +} + +size_t Print::println(void) +{ + return write("\r\n"); + e0e: 88 e2 ldi r24, 0x28 ; 40 + e10: 91 e0 ldi r25, 0x01 ; 1 + e12: 0e 94 91 04 call 0x922 ; 0x922 <_ZN5Print5writeEPKc.constprop.14> +Serial.println(gasVAL); +lightLED(gasVAL); + e16: 80 91 32 01 lds r24, 0x0132 ; 0x800132 <__data_end> + e1a: 90 91 33 01 lds r25, 0x0133 ; 0x800133 <__data_end+0x1> + +} + +void lightLED( uint16_t reading){ + +if (reading >= 750){ + e1e: 8e 3e cpi r24, 0xEE ; 238 + e20: f2 e0 ldi r31, 0x02 ; 2 + e22: 9f 07 cpc r25, r31 + e24: 18 f1 brcs .+70 ; 0xe6c + digitalWrite(LED1,HIGH); + e26: 61 e0 ldi r22, 0x01 ; 1 + e28: 8e e0 ldi r24, 0x0E ; 14 + e2a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + e2e: 61 e0 ldi r22, 0x01 ; 1 + e30: 8f e0 ldi r24, 0x0F ; 15 + e32: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + e36: 61 e0 ldi r22, 0x01 ; 1 + e38: 80 e1 ldi r24, 0x10 ; 16 + e3a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,HIGH); + e3e: 61 e0 ldi r22, 0x01 ; 1 + e40: 81 e1 ldi r24, 0x11 ; 17 + e42: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,HIGH); + e46: 61 e0 ldi r22, 0x01 ; 1 + e48: 82 e1 ldi r24, 0x12 ; 18 + e4a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,HIGH); + e4e: 61 e0 ldi r22, 0x01 ; 1 + e50: 83 e1 ldi r24, 0x13 ; 19 + e52: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,HIGH); + e56: 61 e0 ldi r22, 0x01 ; 1 + e58: 87 e0 ldi r24, 0x07 ; 7 + e5a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,HIGH); + e5e: 61 e0 ldi r22, 0x01 ; 1 + e60: 88 e0 ldi r24, 0x08 ; 8 + e62: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,750,100); + e66: 8e ee ldi r24, 0xEE ; 238 + e68: 92 e0 ldi r25, 0x02 ; 2 + e6a: 26 c0 rjmp .+76 ; 0xeb8 +} +else if (reading >= 700){ + e6c: 8c 3b cpi r24, 0xBC ; 188 + e6e: 22 e0 ldi r18, 0x02 ; 2 + e70: 92 07 cpc r25, r18 + e72: 28 f1 brcs .+74 ; 0xebe + digitalWrite(LED1,HIGH); + e74: 61 e0 ldi r22, 0x01 ; 1 + e76: 8e e0 ldi r24, 0x0E ; 14 + e78: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + e7c: 61 e0 ldi r22, 0x01 ; 1 + e7e: 8f e0 ldi r24, 0x0F ; 15 + e80: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + e84: 61 e0 ldi r22, 0x01 ; 1 + e86: 80 e1 ldi r24, 0x10 ; 16 + e88: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,HIGH); + e8c: 61 e0 ldi r22, 0x01 ; 1 + e8e: 81 e1 ldi r24, 0x11 ; 17 + e90: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,HIGH); + e94: 61 e0 ldi r22, 0x01 ; 1 + e96: 82 e1 ldi r24, 0x12 ; 18 + e98: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,HIGH); + e9c: 61 e0 ldi r22, 0x01 ; 1 + e9e: 83 e1 ldi r24, 0x13 ; 19 + ea0: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,HIGH); + ea4: 61 e0 ldi r22, 0x01 ; 1 + ea6: 87 e0 ldi r24, 0x07 ; 7 + ea8: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + eac: 60 e0 ldi r22, 0x00 ; 0 + eae: 88 e0 ldi r24, 0x08 ; 8 + eb0: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,700,100); + eb4: 8c eb ldi r24, 0xBC ; 188 + eb6: 92 e0 ldi r25, 0x02 ; 2 + eb8: 0e 94 a7 00 call 0x14e ; 0x14e <_Z4tonehjm.constprop.15> + ebc: e8 c0 rjmp .+464 ; 0x108e +} +else if (reading >= 650){ + ebe: 8a 38 cpi r24, 0x8A ; 138 + ec0: e2 e0 ldi r30, 0x02 ; 2 + ec2: 9e 07 cpc r25, r30 + ec4: 18 f1 brcs .+70 ; 0xf0c + digitalWrite(LED1,HIGH); + ec6: 61 e0 ldi r22, 0x01 ; 1 + ec8: 8e e0 ldi r24, 0x0E ; 14 + eca: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + ece: 61 e0 ldi r22, 0x01 ; 1 + ed0: 8f e0 ldi r24, 0x0F ; 15 + ed2: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + ed6: 61 e0 ldi r22, 0x01 ; 1 + ed8: 80 e1 ldi r24, 0x10 ; 16 + eda: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,HIGH); + ede: 61 e0 ldi r22, 0x01 ; 1 + ee0: 81 e1 ldi r24, 0x11 ; 17 + ee2: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,HIGH); + ee6: 61 e0 ldi r22, 0x01 ; 1 + ee8: 82 e1 ldi r24, 0x12 ; 18 + eea: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,HIGH); + eee: 61 e0 ldi r22, 0x01 ; 1 + ef0: 83 e1 ldi r24, 0x13 ; 19 + ef2: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + ef6: 60 e0 ldi r22, 0x00 ; 0 + ef8: 87 e0 ldi r24, 0x07 ; 7 + efa: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + efe: 60 e0 ldi r22, 0x00 ; 0 + f00: 88 e0 ldi r24, 0x08 ; 8 + f02: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,650,100); + f06: 8a e8 ldi r24, 0x8A ; 138 + f08: 92 e0 ldi r25, 0x02 ; 2 + f0a: d6 cf rjmp .-84 ; 0xeb8 +} +else if (reading >= 600){ + f0c: 88 35 cpi r24, 0x58 ; 88 + f0e: f2 e0 ldi r31, 0x02 ; 2 + f10: 9f 07 cpc r25, r31 + f12: 18 f1 brcs .+70 ; 0xf5a + digitalWrite(LED1,HIGH); + f14: 61 e0 ldi r22, 0x01 ; 1 + f16: 8e e0 ldi r24, 0x0E ; 14 + f18: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + f1c: 61 e0 ldi r22, 0x01 ; 1 + f1e: 8f e0 ldi r24, 0x0F ; 15 + f20: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + f24: 61 e0 ldi r22, 0x01 ; 1 + f26: 80 e1 ldi r24, 0x10 ; 16 + f28: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,HIGH); + f2c: 61 e0 ldi r22, 0x01 ; 1 + f2e: 81 e1 ldi r24, 0x11 ; 17 + f30: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,HIGH); + f34: 61 e0 ldi r22, 0x01 ; 1 + f36: 82 e1 ldi r24, 0x12 ; 18 + f38: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,LOW); + f3c: 60 e0 ldi r22, 0x00 ; 0 + f3e: 83 e1 ldi r24, 0x13 ; 19 + f40: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + f44: 60 e0 ldi r22, 0x00 ; 0 + f46: 87 e0 ldi r24, 0x07 ; 7 + f48: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + f4c: 60 e0 ldi r22, 0x00 ; 0 + f4e: 88 e0 ldi r24, 0x08 ; 8 + f50: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,600,100); + f54: 88 e5 ldi r24, 0x58 ; 88 + f56: 92 e0 ldi r25, 0x02 ; 2 + f58: af cf rjmp .-162 ; 0xeb8 +} +else if (reading >= 550){ + f5a: 86 32 cpi r24, 0x26 ; 38 + f5c: 22 e0 ldi r18, 0x02 ; 2 + f5e: 92 07 cpc r25, r18 + f60: 18 f1 brcs .+70 ; 0xfa8 + digitalWrite(LED1,HIGH); + f62: 61 e0 ldi r22, 0x01 ; 1 + f64: 8e e0 ldi r24, 0x0E ; 14 + f66: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + f6a: 61 e0 ldi r22, 0x01 ; 1 + f6c: 8f e0 ldi r24, 0x0F ; 15 + f6e: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + f72: 61 e0 ldi r22, 0x01 ; 1 + f74: 80 e1 ldi r24, 0x10 ; 16 + f76: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,HIGH); + f7a: 61 e0 ldi r22, 0x01 ; 1 + f7c: 81 e1 ldi r24, 0x11 ; 17 + f7e: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,LOW); + f82: 60 e0 ldi r22, 0x00 ; 0 + f84: 82 e1 ldi r24, 0x12 ; 18 + f86: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,LOW); + f8a: 60 e0 ldi r22, 0x00 ; 0 + f8c: 83 e1 ldi r24, 0x13 ; 19 + f8e: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + f92: 60 e0 ldi r22, 0x00 ; 0 + f94: 87 e0 ldi r24, 0x07 ; 7 + f96: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + f9a: 60 e0 ldi r22, 0x00 ; 0 + f9c: 88 e0 ldi r24, 0x08 ; 8 + f9e: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,550,100); + fa2: 86 e2 ldi r24, 0x26 ; 38 + fa4: 92 e0 ldi r25, 0x02 ; 2 + fa6: 88 cf rjmp .-240 ; 0xeb8 +} +else if (reading >= 500){ + fa8: 84 3f cpi r24, 0xF4 ; 244 + faa: e1 e0 ldi r30, 0x01 ; 1 + fac: 9e 07 cpc r25, r30 + fae: 18 f1 brcs .+70 ; 0xff6 + digitalWrite(LED1,HIGH); + fb0: 61 e0 ldi r22, 0x01 ; 1 + fb2: 8e e0 ldi r24, 0x0E ; 14 + fb4: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + fb8: 61 e0 ldi r22, 0x01 ; 1 + fba: 8f e0 ldi r24, 0x0F ; 15 + fbc: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,HIGH); + fc0: 61 e0 ldi r22, 0x01 ; 1 + fc2: 80 e1 ldi r24, 0x10 ; 16 + fc4: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,LOW); + fc8: 60 e0 ldi r22, 0x00 ; 0 + fca: 81 e1 ldi r24, 0x11 ; 17 + fcc: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,LOW); + fd0: 60 e0 ldi r22, 0x00 ; 0 + fd2: 82 e1 ldi r24, 0x12 ; 18 + fd4: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,LOW); + fd8: 60 e0 ldi r22, 0x00 ; 0 + fda: 83 e1 ldi r24, 0x13 ; 19 + fdc: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + fe0: 60 e0 ldi r22, 0x00 ; 0 + fe2: 87 e0 ldi r24, 0x07 ; 7 + fe4: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + fe8: 60 e0 ldi r22, 0x00 ; 0 + fea: 88 e0 ldi r24, 0x08 ; 8 + fec: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,500,100); + ff0: 84 ef ldi r24, 0xF4 ; 244 + ff2: 91 e0 ldi r25, 0x01 ; 1 + ff4: 61 cf rjmp .-318 ; 0xeb8 +} +else if (reading >= 410){ + ff6: 8a 39 cpi r24, 0x9A ; 154 + ff8: f1 e0 ldi r31, 0x01 ; 1 + ffa: 9f 07 cpc r25, r31 + ffc: 18 f1 brcs .+70 ; 0x1044 + digitalWrite(LED1,HIGH); + ffe: 61 e0 ldi r22, 0x01 ; 1 + 1000: 8e e0 ldi r24, 0x0E ; 14 + 1002: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,HIGH); + 1006: 61 e0 ldi r22, 0x01 ; 1 + 1008: 8f e0 ldi r24, 0x0F ; 15 + 100a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,LOW); + 100e: 60 e0 ldi r22, 0x00 ; 0 + 1010: 80 e1 ldi r24, 0x10 ; 16 + 1012: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,LOW); + 1016: 60 e0 ldi r22, 0x00 ; 0 + 1018: 81 e1 ldi r24, 0x11 ; 17 + 101a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,LOW); + 101e: 60 e0 ldi r22, 0x00 ; 0 + 1020: 82 e1 ldi r24, 0x12 ; 18 + 1022: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,LOW); + 1026: 60 e0 ldi r22, 0x00 ; 0 + 1028: 83 e1 ldi r24, 0x13 ; 19 + 102a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + 102e: 60 e0 ldi r22, 0x00 ; 0 + 1030: 87 e0 ldi r24, 0x07 ; 7 + 1032: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + 1036: 60 e0 ldi r22, 0x00 ; 0 + 1038: 88 e0 ldi r24, 0x08 ; 8 + 103a: 0e 94 d5 02 call 0x5aa ; 0x5aa + tone(SPKR,410,100); + 103e: 8a e9 ldi r24, 0x9A ; 154 + 1040: 91 e0 ldi r25, 0x01 ; 1 + 1042: 3a cf rjmp .-396 ; 0xeb8 +} +else if (reading >= 300){ + 1044: 8c 32 cpi r24, 0x2C ; 44 + 1046: 91 40 sbci r25, 0x01 ; 1 + 1048: 10 f0 brcs .+4 ; 0x104e + digitalWrite(LED1,HIGH); + 104a: 61 e0 ldi r22, 0x01 ; 1 + 104c: 01 c0 rjmp .+2 ; 0x1050 + digitalWrite(LED6,LOW); + digitalWrite(LED7,LOW); + digitalWrite(LED8,LOW); +} +else if (reading >= 0){ + digitalWrite(LED1,LOW); + 104e: 60 e0 ldi r22, 0x00 ; 0 + 1050: 8e e0 ldi r24, 0x0E ; 14 + 1052: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED2,LOW); + 1056: 60 e0 ldi r22, 0x00 ; 0 + 1058: 8f e0 ldi r24, 0x0F ; 15 + 105a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED3,LOW); + 105e: 60 e0 ldi r22, 0x00 ; 0 + 1060: 80 e1 ldi r24, 0x10 ; 16 + 1062: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED4,LOW); + 1066: 60 e0 ldi r22, 0x00 ; 0 + 1068: 81 e1 ldi r24, 0x11 ; 17 + 106a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED5,LOW); + 106e: 60 e0 ldi r22, 0x00 ; 0 + 1070: 82 e1 ldi r24, 0x12 ; 18 + 1072: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED6,LOW); + 1076: 60 e0 ldi r22, 0x00 ; 0 + 1078: 83 e1 ldi r24, 0x13 ; 19 + 107a: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED7,LOW); + 107e: 60 e0 ldi r22, 0x00 ; 0 + 1080: 87 e0 ldi r24, 0x07 ; 7 + 1082: 0e 94 d5 02 call 0x5aa ; 0x5aa + digitalWrite(LED8,LOW); + 1086: 60 e0 ldi r22, 0x00 ; 0 + 1088: 88 e0 ldi r24, 0x08 ; 8 + 108a: 0e 94 d5 02 call 0x5aa ; 0x5aa + // put your main code here, to run repeatedly: + +gasVAL = analogRead(Sensor); +Serial.println(gasVAL); +lightLED(gasVAL); +delay(30); + 108e: 6e e1 ldi r22, 0x1E ; 30 + 1090: 70 e0 ldi r23, 0x00 ; 0 + 1092: 80 e0 ldi r24, 0x00 ; 0 + 1094: 90 e0 ldi r25, 0x00 ; 0 + 1096: 0e 94 47 03 call 0x68e ; 0x68e + + setup(); + + for (;;) { + loop(); + if (serialEventRun) serialEventRun(); + 109a: 0e 94 87 04 call 0x90e ; 0x90e <_Z14serialEventRunv> + 109e: 8a ce rjmp .-748 ; 0xdb4 + +000010a0 <_GLOBAL__sub_I___vector_18>: + size_t printNumber(unsigned long, uint8_t); + size_t printFloat(double, uint8_t); + protected: + void setWriteError(int err = 1) { write_error = err; } + public: + Print() : write_error(0) {} + 10a0: ed e3 ldi r30, 0x3D ; 61 + 10a2: f1 e0 ldi r31, 0x01 ; 1 + 10a4: 13 82 std Z+3, r1 ; 0x03 + 10a6: 12 82 std Z+2, r1 ; 0x02 + public: + virtual int available() = 0; + virtual int read() = 0; + virtual int peek() = 0; + + Stream() {_timeout=1000;} + 10a8: 88 ee ldi r24, 0xE8 ; 232 + 10aa: 93 e0 ldi r25, 0x03 ; 3 + 10ac: a0 e0 ldi r26, 0x00 ; 0 + 10ae: b0 e0 ldi r27, 0x00 ; 0 + 10b0: 84 83 std Z+4, r24 ; 0x04 + 10b2: 95 83 std Z+5, r25 ; 0x05 + 10b4: a6 83 std Z+6, r26 ; 0x06 + 10b6: b7 83 std Z+7, r27 ; 0x07 + volatile uint8_t *ucsrc, volatile uint8_t *udr) : + _ubrrh(ubrrh), _ubrrl(ubrrl), + _ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc), + _udr(udr), + _rx_buffer_head(0), _rx_buffer_tail(0), + _tx_buffer_head(0), _tx_buffer_tail(0) + 10b8: 85 e0 ldi r24, 0x05 ; 5 + 10ba: 91 e0 ldi r25, 0x01 ; 1 + 10bc: 91 83 std Z+1, r25 ; 0x01 + 10be: 80 83 st Z, r24 + 10c0: 85 ec ldi r24, 0xC5 ; 197 + 10c2: 90 e0 ldi r25, 0x00 ; 0 + 10c4: 95 87 std Z+13, r25 ; 0x0d + 10c6: 84 87 std Z+12, r24 ; 0x0c + 10c8: 84 ec ldi r24, 0xC4 ; 196 + 10ca: 90 e0 ldi r25, 0x00 ; 0 + 10cc: 97 87 std Z+15, r25 ; 0x0f + 10ce: 86 87 std Z+14, r24 ; 0x0e + 10d0: 80 ec ldi r24, 0xC0 ; 192 + 10d2: 90 e0 ldi r25, 0x00 ; 0 + 10d4: 91 8b std Z+17, r25 ; 0x11 + 10d6: 80 8b std Z+16, r24 ; 0x10 + 10d8: 81 ec ldi r24, 0xC1 ; 193 + 10da: 90 e0 ldi r25, 0x00 ; 0 + 10dc: 93 8b std Z+19, r25 ; 0x13 + 10de: 82 8b std Z+18, r24 ; 0x12 + 10e0: 82 ec ldi r24, 0xC2 ; 194 + 10e2: 90 e0 ldi r25, 0x00 ; 0 + 10e4: 95 8b std Z+21, r25 ; 0x15 + 10e6: 84 8b std Z+20, r24 ; 0x14 + 10e8: 86 ec ldi r24, 0xC6 ; 198 + 10ea: 90 e0 ldi r25, 0x00 ; 0 + 10ec: 97 8b std Z+23, r25 ; 0x17 + 10ee: 86 8b std Z+22, r24 ; 0x16 + 10f0: 11 8e std Z+25, r1 ; 0x19 + 10f2: 12 8e std Z+26, r1 ; 0x1a + 10f4: 13 8e std Z+27, r1 ; 0x1b + 10f6: 14 8e std Z+28, r1 ; 0x1c + 10f8: 08 95 ret + +000010fa <__udivmodsi4>: + 10fa: a1 e2 ldi r26, 0x21 ; 33 + 10fc: 1a 2e mov r1, r26 + 10fe: aa 1b sub r26, r26 + 1100: bb 1b sub r27, r27 + 1102: fd 01 movw r30, r26 + 1104: 0d c0 rjmp .+26 ; 0x1120 <__udivmodsi4_ep> + +00001106 <__udivmodsi4_loop>: + 1106: aa 1f adc r26, r26 + 1108: bb 1f adc r27, r27 + 110a: ee 1f adc r30, r30 + 110c: ff 1f adc r31, r31 + 110e: a2 17 cp r26, r18 + 1110: b3 07 cpc r27, r19 + 1112: e4 07 cpc r30, r20 + 1114: f5 07 cpc r31, r21 + 1116: 20 f0 brcs .+8 ; 0x1120 <__udivmodsi4_ep> + 1118: a2 1b sub r26, r18 + 111a: b3 0b sbc r27, r19 + 111c: e4 0b sbc r30, r20 + 111e: f5 0b sbc r31, r21 + +00001120 <__udivmodsi4_ep>: + 1120: 66 1f adc r22, r22 + 1122: 77 1f adc r23, r23 + 1124: 88 1f adc r24, r24 + 1126: 99 1f adc r25, r25 + 1128: 1a 94 dec r1 + 112a: 69 f7 brne .-38 ; 0x1106 <__udivmodsi4_loop> + 112c: 60 95 com r22 + 112e: 70 95 com r23 + 1130: 80 95 com r24 + 1132: 90 95 com r25 + 1134: 9b 01 movw r18, r22 + 1136: ac 01 movw r20, r24 + 1138: bd 01 movw r22, r26 + 113a: cf 01 movw r24, r30 + 113c: 08 95 ret + +0000113e <__divmodsi4>: + 113e: 05 2e mov r0, r21 + 1140: 97 fb bst r25, 7 + 1142: 1e f4 brtc .+6 ; 0x114a <__divmodsi4+0xc> + 1144: 00 94 com r0 + 1146: 0e 94 b6 08 call 0x116c ; 0x116c <__negsi2> + 114a: 57 fd sbrc r21, 7 + 114c: 07 d0 rcall .+14 ; 0x115c <__divmodsi4_neg2> + 114e: 0e 94 7d 08 call 0x10fa ; 0x10fa <__udivmodsi4> + 1152: 07 fc sbrc r0, 7 + 1154: 03 d0 rcall .+6 ; 0x115c <__divmodsi4_neg2> + 1156: 4e f4 brtc .+18 ; 0x116a <__divmodsi4_exit> + 1158: 0c 94 b6 08 jmp 0x116c ; 0x116c <__negsi2> + +0000115c <__divmodsi4_neg2>: + 115c: 50 95 com r21 + 115e: 40 95 com r20 + 1160: 30 95 com r19 + 1162: 21 95 neg r18 + 1164: 3f 4f sbci r19, 0xFF ; 255 + 1166: 4f 4f sbci r20, 0xFF ; 255 + 1168: 5f 4f sbci r21, 0xFF ; 255 + +0000116a <__divmodsi4_exit>: + 116a: 08 95 ret + +0000116c <__negsi2>: + 116c: 90 95 com r25 + 116e: 80 95 com r24 + 1170: 70 95 com r23 + 1172: 61 95 neg r22 + 1174: 7f 4f sbci r23, 0xFF ; 255 + 1176: 8f 4f sbci r24, 0xFF ; 255 + 1178: 9f 4f sbci r25, 0xFF ; 255 + 117a: 08 95 ret + +0000117c <__umulhisi3>: + 117c: a2 9f mul r26, r18 + 117e: b0 01 movw r22, r0 + 1180: b3 9f mul r27, r19 + 1182: c0 01 movw r24, r0 + 1184: a3 9f mul r26, r19 + 1186: 70 0d add r23, r0 + 1188: 81 1d adc r24, r1 + 118a: 11 24 eor r1, r1 + 118c: 91 1d adc r25, r1 + 118e: b2 9f mul r27, r18 + 1190: 70 0d add r23, r0 + 1192: 81 1d adc r24, r1 + 1194: 11 24 eor r1, r1 + 1196: 91 1d adc r25, r1 + 1198: 08 95 ret + +0000119a <__tablejump2__>: + 119a: ee 0f add r30, r30 + 119c: ff 1f adc r31, r31 + 119e: 05 90 lpm r0, Z+ + 11a0: f4 91 lpm r31, Z + 11a2: e0 2d mov r30, r0 + 11a4: 09 94 ijmp + +000011a6 : + 11a6: 81 e0 ldi r24, 0x01 ; 1 + 11a8: 90 e0 ldi r25, 0x00 ; 0 + 11aa: f8 94 cli + 11ac: 0c 94 d8 08 jmp 0x11b0 ; 0x11b0 <_exit> + +000011b0 <_exit>: + 11b0: f8 94 cli + +000011b2 <__stop_program>: + 11b2: ff cf rjmp .-2 ; 0x11b2 <__stop_program> diff --git a/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.elf b/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.elf new file mode 100755 index 0000000..c0ff368 Binary files /dev/null and b/FlammableGasSensor/arduino/gassensor_reva/gassensor_reva.ino.elf differ diff --git a/FlammableGasSensor/pcb/mainboard/gassensor.pro b/FlammableGasSensor/pcb/mainboard/gassensor.pro index ff5741b..51c643d 100644 --- a/FlammableGasSensor/pcb/mainboard/gassensor.pro +++ b/FlammableGasSensor/pcb/mainboard/gassensor.pro @@ -1,4 +1,4 @@ -update=Tue 11 Oct 2016 05:25:07 PM PDT +update=Tue 25 Aug 2020 12:28:47 AM EDT version=1 last_client=kicad [cvpcb] @@ -27,6 +27,8 @@ ModuleOutlineThickness=0.152400000000 version=1 LibDir= [eeschema/libraries] +[general] +version=1 [schematic_editor] version=1 PageLayoutDescrFile= @@ -34,8 +36,6 @@ PlotDirectoryName= SubpartIdSeparator=0 SubpartFirstId=65 NetFmtName= -SpiceForceRefPrefix=0 -SpiceUseNetNumbers=0 +SpiceAjustPassiveValues=0 LabSize=50 -[general] -version=1 +ERC_TestSimilarLabels=1 diff --git a/FlammableGasSensor/pcb/mainboard/layout.pdf b/FlammableGasSensor/pcb/mainboard/layout.pdf new file mode 100644 index 0000000..0d81c0e Binary files /dev/null and b/FlammableGasSensor/pcb/mainboard/layout.pdf differ diff --git a/FlammableGasSensor/pcb/mainboard/schematic.pdf b/FlammableGasSensor/pcb/mainboard/schematic.pdf new file mode 100644 index 0000000..9d84d69 Binary files /dev/null and b/FlammableGasSensor/pcb/mainboard/schematic.pdf differ diff --git a/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.dcm b/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.dcm new file mode 100644 index 0000000..5f3ed79 --- /dev/null +++ b/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.dcm @@ -0,0 +1,3 @@ +EESchema-DOCLIB Version 2.0 +# +#End Doc Library diff --git a/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.lib b/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.lib new file mode 100644 index 0000000..228d44f --- /dev/null +++ b/HomeSolarDataLogger_Two/pcb/homesolar2-rescue.lib @@ -0,0 +1,196 @@ +EESchema-LIBRARY Version 2.4 +#encoding utf-8 +# +# CONN_01X04-conn +# +DEF CONN_01X04-conn P 0 40 Y N 1 F N +F0 "P" 0 250 50 H V C CNN +F1 "CONN_01X04-conn" 100 0 50 V V C CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + Pin_Header_Straight_1X04 + Pin_Header_Angled_1X04 + Socket_Strip_Straight_1X04 + Socket_Strip_Angled_1X04 +$ENDFPLIST +DRAW +S -50 -145 10 -155 0 1 0 N +S -50 -45 10 -55 0 1 0 N +S -50 55 10 45 0 1 0 N +S -50 155 10 145 0 1 0 N +S -50 200 50 -200 0 1 0 N +X P1 1 -200 150 150 R 50 50 1 1 P +X P2 2 -200 50 150 R 50 50 1 1 P +X P3 3 -200 -50 150 R 50 50 1 1 P +X P4 4 -200 -150 150 R 50 50 1 1 P +ENDDRAW +ENDDEF +# +# CONN_01X05-conn +# +DEF CONN_01X05-conn P 0 40 Y N 1 F N +F0 "P" 0 300 50 H V C CNN +F1 "CONN_01X05-conn" 100 0 50 V V C CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + Pin_Header_Straight_1X05 + Pin_Header_Angled_1X05 + Socket_Strip_Straight_1X05 + Socket_Strip_Angled_1X05 +$ENDFPLIST +DRAW +S -50 -195 10 -205 0 1 0 N +S -50 -95 10 -105 0 1 0 N +S -50 5 10 -5 0 1 0 N +S -50 105 10 95 0 1 0 N +S -50 205 10 195 0 1 0 N +S -50 250 50 -250 0 1 0 N +X P1 1 -200 200 150 R 50 50 1 1 P +X P2 2 -200 100 150 R 50 50 1 1 P +X P3 3 -200 0 150 R 50 50 1 1 P +X P4 4 -200 -100 150 R 50 50 1 1 P +X P5 5 -200 -200 150 R 50 50 1 1 P +ENDDRAW +ENDDEF +# +# C_Small-device +# +DEF C_Small-device C 0 10 N N 1 F N +F0 "C" 10 70 50 H V L CNN +F1 "C_Small-device" 10 -80 50 H V L CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + C? + C_????_* + C_???? + SMD*_c + Capacitor* +$ENDFPLIST +DRAW +P 2 0 1 13 -60 -20 60 -20 N +P 2 0 1 12 -60 20 60 20 N +X ~ 1 0 100 80 D 50 50 1 1 P +X ~ 2 0 -100 80 U 50 50 1 1 P +ENDDRAW +ENDDEF +# +# D_Schottky-device +# +DEF D_Schottky-device D 0 40 N N 1 F N +F0 "D" 0 100 50 H V C CNN +F1 "D_Schottky-device" 0 -100 50 H V C CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + Diode_* + D-* + *SingleDiode + *_Diode_* + *SingleDiode* + D_* +$ENDFPLIST +DRAW +P 2 0 1 0 50 0 -50 0 N +P 4 0 1 8 50 50 50 -50 -50 0 50 50 N +P 6 0 1 8 -75 25 -75 50 -50 50 -50 -50 -25 -50 -25 -25 N +X K 1 -150 0 100 R 50 50 1 1 P +X A 2 150 0 100 L 50 50 1 1 P +ENDDRAW +ENDDEF +# +# Fuse-device +# +DEF Fuse-device F 0 0 N Y 1 F N +F0 "F" 80 0 50 V V C CNN +F1 "Fuse-device" -75 0 50 V V C CNN +F2 "" -70 0 50 V V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + *Fuse* +$ENDFPLIST +DRAW +S -30 -100 30 100 0 1 10 N +P 2 0 1 0 0 100 0 -100 N +X ~ 1 0 150 50 D 50 50 1 1 P +X ~ 2 0 -150 50 U 50 50 1 1 P +ENDDRAW +ENDDEF +# +# MIC4690-regul +# +DEF MIC4690-regul U 0 40 Y Y 1 F N +F0 "U" 0 300 50 H V C CNN +F1 "MIC4690-regul" 250 -300 50 H V L CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +DRAW +S -450 250 450 -250 0 1 0 N +X ShDn 1 -750 -150 300 R 50 50 1 1 I +X VIN 2 -750 150 300 R 50 50 1 1 I +X Sw 3 750 150 300 L 50 50 1 1 O +X Fb 4 750 -150 300 L 50 50 1 1 I +X GND 5 -150 -450 200 U 50 50 1 1 I +X GND 6 -50 -450 200 U 50 50 1 1 I +X GND 7 50 -450 200 U 50 50 1 1 I +X GND 8 150 -450 200 U 50 50 1 1 I +ENDDRAW +ENDDEF +# +# POT-device +# +DEF POT-device RV 0 40 N N 1 F N +F0 "RV" -175 0 50 V V C CNN +F1 "POT-device" -100 0 50 V V C CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +DRAW +S 40 100 -40 -100 0 1 10 N +P 2 0 1 0 100 0 60 0 N +P 3 0 1 0 45 0 90 20 90 -20 F +X 1 1 0 150 50 D 50 50 1 1 P +X 2 2 150 0 50 L 50 50 1 1 P +X 3 3 0 -150 50 U 50 50 1 1 P +ENDDRAW +ENDDEF +# +# R-device +# +DEF R-device R 0 0 N Y 1 F N +F0 "R" 80 0 50 V V C CNN +F1 "R-device" 0 0 50 V V C CNN +F2 "" -70 0 50 V V C CNN +F3 "" 0 0 50 H V C CNN +$FPLIST + R_* + Resistor_* +$ENDFPLIST +DRAW +S -40 -100 40 100 0 1 10 N +X ~ 1 0 150 50 D 50 50 1 1 P +X ~ 2 0 -150 50 U 50 50 1 1 P +ENDDRAW +ENDDEF +# +# SW_Push_SPDT-switches +# +DEF SW_Push_SPDT-switches SW 0 0 Y N 1 F N +F0 "SW" 0 170 50 H V C CNN +F1 "SW_Push_SPDT-switches" 0 -200 50 H V C CNN +F2 "" 0 0 50 H V C CNN +F3 "" 0 0 50 H V C CNN +DRAW +C -80 0 20 0 0 0 N +C 80 -100 20 0 0 0 N +C 80 100 20 0 1 0 N +P 2 0 0 0 0 40 0 120 N +P 2 0 1 0 -60 10 100 80 N +X A 1 200 100 100 L 50 50 1 1 P +X B 2 -200 0 100 R 50 50 1 1 P +X C 3 200 -100 100 L 50 50 1 1 P +ENDDRAW +ENDDEF +# +#End Library diff --git a/HomeSolarDataLogger_Two/pcb/sym-lib-table b/HomeSolarDataLogger_Two/pcb/sym-lib-table index 4c9ebc7..92bdd87 100644 --- a/HomeSolarDataLogger_Two/pcb/sym-lib-table +++ b/HomeSolarDataLogger_Two/pcb/sym-lib-table @@ -1,3 +1,4 @@ (sym_lib_table (lib (name MCU_Microchip_ATmega)(type Legacy)(uri /home/layoutdev/Desktop/code/documentation_general/Electronics_Projects_2019/HomeSolarDataLogger_Two/symbols/MCU_Microchip_ATmega.lib)(options "")(descr "")) + (lib (name homesolar2-rescue)(type Legacy)(uri ${KIPRJMOD}/homesolar2-rescue.lib)(options "")(descr "")) ) diff --git a/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.dis b/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.dis new file mode 100644 index 0000000..97d23f5 --- /dev/null +++ b/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.dis @@ -0,0 +1,3294 @@ + +BasicPHSensor.ino.elf: file format elf32-avr + + +Disassembly of section .text: + +00000000 <__vectors>: + 0: 0c 94 38 02 jmp 0x470 ; 0x470 <__ctors_end> + 4: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 8: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 10: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 14: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 18: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 1c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 20: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 24: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 28: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 2c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 30: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 34: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 38: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 3c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 40: 0c 94 c3 05 jmp 0xb86 ; 0xb86 <__vector_16> + 44: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 48: 0c 94 33 06 jmp 0xc66 ; 0xc66 <__vector_18> + 4c: 0c 94 0d 06 jmp 0xc1a ; 0xc1a <__vector_19> + 50: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 54: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 58: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 5c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 60: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt> + 64: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__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 <_ZL10characters>: + 7c: 3f 3f 02 01 51 09 06 00 05 00 41 41 7c 12 11 12 ??..Q.....AA|... + 8c: 7c 00 05 00 42 42 7f 49 49 49 36 00 05 00 43 43 |...BB.III6...CC + 9c: 3e 41 41 41 22 00 05 00 44 44 7f 41 41 41 3e 00 >AAA"...DD.AAA>. + ac: 05 00 45 45 7f 49 49 49 41 00 05 00 46 46 7f 09 ..EE.IIIA...FF.. + bc: 09 09 01 00 05 00 47 47 3e 41 49 49 3a 00 05 00 ......GG>AII:... + cc: 48 48 7f 08 08 08 7f 00 05 00 49 49 00 41 7f 41 HH........II.A.A + dc: 00 00 05 00 4a 4a 30 40 40 40 3f 00 05 00 4b 4b ....JJ0@@@?...KK + ec: 7f 08 08 14 63 00 05 00 4c 4c 7f 40 40 40 40 00 ....c...LL.@@@@. + fc: 05 00 4d 4d 7f 06 0c 06 7f 00 05 00 4e 4e 7f 04 ..MM........NN.. + 10c: 08 10 7f 00 05 00 4f 4f 3e 41 41 41 3e 00 05 00 ......OO>AAA>... + 11c: 50 50 7f 09 09 09 06 00 05 00 51 51 3e 41 51 61 PP........QQ>AQa + 12c: 7e 00 05 00 52 52 7f 09 19 29 46 00 05 00 53 53 ~...RR...)F...SS + 13c: 26 49 49 49 32 00 05 00 54 54 01 01 7f 01 01 00 &III2...TT...... + 14c: 05 00 55 55 3f 40 40 40 3f 00 05 00 56 56 1f 20 ..UU?@@@?...VV. + 15c: 40 20 1f 00 05 00 57 57 3f 40 38 40 3f 00 05 00 @ ....WW?@8@?... + 16c: 58 58 63 14 08 14 63 00 05 00 59 59 07 08 70 08 XXc...c...YY..p. + 17c: 07 00 05 00 5a 5a 61 51 49 45 43 00 05 00 2d 2d ....ZZaQIEC...-- + 18c: 08 08 08 08 08 00 05 00 21 21 00 00 5f 00 00 00 ........!!.._... + 19c: 05 00 2e 2e 00 40 00 00 00 00 03 00 31 31 42 42 .....@......11BB + 1ac: 7f 40 40 00 05 00 32 32 62 51 49 45 42 00 05 00 .@@...22bQIEB... + 1bc: 33 33 22 41 49 49 3e 00 05 00 34 34 1f 10 7c 10 33"AII>...44..|. + 1cc: 10 00 05 00 35 35 4f 49 49 49 31 00 05 00 36 36 ....55OIII1...66 + 1dc: 3e 49 49 49 32 00 05 00 37 37 01 01 79 05 03 00 >III2...77..y... + 1ec: 05 00 38 38 36 49 49 49 36 00 05 00 39 39 26 49 ..886III6...99&I + 1fc: 49 49 3e 00 05 00 30 30 3e 41 41 41 3e 00 05 00 II>...00>AAA>... + 20c: 2b 2b 08 08 3e 08 08 00 05 00 3a 3a 00 28 00 00 ++..>.....::.(.. + 21c: 00 00 03 00 3d 3d 14 14 14 14 14 00 05 00 20 20 ....==........ + 22c: 00 00 00 00 00 00 02 00 61 61 20 54 54 54 78 00 ........aa TTTx. + 23c: 05 00 62 62 7f 48 48 48 30 00 05 00 63 63 38 44 ..bb.HHH0...cc8D + 24c: 44 44 28 00 05 00 64 64 20 50 50 50 7f 00 05 00 DD(...dd PPP.... + 25c: 65 65 38 54 54 54 48 00 05 00 66 66 08 7e 09 01 ee8TTTH...ff.~.. + 26c: 02 00 05 00 67 67 48 54 54 54 38 00 05 00 68 68 ....ggHTTT8...hh + 27c: 7f 08 08 08 70 00 05 00 69 69 40 44 7d 40 40 00 ....p...ii@D}@@. + 28c: 05 00 6a 6a 20 40 44 3d 00 00 05 00 6b 6b 7f 10 ..jj @D=....kk.. + 29c: 10 28 44 00 05 00 6c 6c 01 01 7f 40 40 00 05 00 .(D...ll...@@... + 2ac: 6d 6d 7c 04 7c 04 78 00 05 00 6e 6e 7c 04 04 04 mm|.|.x...nn|... + 2bc: 78 00 05 00 6f 6f 38 44 44 44 38 00 05 00 70 70 x...oo8DDD8...pp + 2cc: 7c 14 14 14 08 00 05 00 71 71 08 14 14 14 7c 00 |.......qq....|. + 2dc: 05 00 72 72 7c 08 04 04 04 00 05 00 73 73 48 54 ..rr|.......ssHT + 2ec: 54 54 24 00 05 00 74 74 02 02 3f 42 42 00 05 00 TT$...tt..?BB... + 2fc: 75 75 3c 40 40 20 7c 00 05 00 76 76 1c 20 40 20 uu<@@ |...vv. @ + 30c: 1c 00 05 00 77 77 7c 20 70 20 7c 00 05 00 78 78 ....ww| p |...xx + 31c: 44 28 10 28 44 00 05 00 79 79 4c 50 50 50 3c 00 D(.(D...yyLPPP<. + 32c: 05 00 7a 7a 44 64 54 4c 44 00 05 00 5b 5b 00 7f ..zzDdTLD...[[.. + 33c: 41 41 00 00 05 00 5d 5d 00 41 41 7f 00 00 05 00 AA....]].AA..... + 34c: 7b 7b 08 08 36 41 41 00 05 00 7d 7d 41 41 36 08 {{..6AA...}}AA6. + 35c: 08 00 05 00 28 28 00 1c 22 41 00 00 05 00 29 29 ....((.."A....)) + 36c: 00 41 22 1c 00 00 05 00 40 40 3e 41 5d 55 1e 00 .A".....@@>A]U.. + 37c: 05 00 23 23 14 3e 14 3e 14 00 05 00 24 24 2c 2a ..##.>.>....$$,* + 38c: 7f 2a 12 00 05 00 25 25 26 16 08 34 32 00 05 00 .*....%%&..42... + 39c: 5e 5e 04 02 01 02 04 00 05 00 5f 5f 40 40 40 40 ^^........__@@@@ + 3ac: 40 00 05 00 27 27 07 00 00 00 00 00 01 00 22 22 @...''........"" + 3bc: 00 07 00 07 00 00 05 00 3b 3b 00 40 76 36 00 00 ........;;.@v6.. + 3cc: 05 00 2f 2f 20 10 08 04 02 00 05 00 5c 5c 02 04 ..// .......\\.. + 3dc: 08 10 20 00 05 00 3c 3c 00 10 28 44 00 00 05 00 .. ...<<..(D.... + 3ec: 3e 3e 00 44 28 10 00 00 05 00 2a 2a 12 0c 3f 0c >>.D(.....**..?. + 3fc: 12 00 05 00 60 60 01 02 00 00 00 00 02 00 7e 7e ....``........~~ + 40c: 02 01 03 02 01 00 05 00 26 26 30 4a 45 2a 10 28 ........&&0JE*.( + 41c: 06 00 0a 0a 00 00 00 00 00 00 00 00 0d 0d 00 00 ................ + 42c: 00 00 00 00 00 00 ...... + +00000432 : + 432: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+. + +0000043c : + 43c: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*. + +00000446 : + 446: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................ + 456: 03 03 03 03 .... + +0000045a : + 45a: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... .. + 46a: 04 08 10 20 ... + +0000046e <__ctors_start>: + 46e: 65 06 cpc r6, r21 + +00000470 <__ctors_end>: + 470: 11 24 eor r1, r1 + 472: 1f be out 0x3f, r1 ; 63 + 474: cf ef ldi r28, 0xFF ; 255 + 476: d8 e0 ldi r29, 0x08 ; 8 + 478: de bf out 0x3e, r29 ; 62 + 47a: cd bf out 0x3d, r28 ; 61 + +0000047c <__do_copy_data>: + 47c: 11 e0 ldi r17, 0x01 ; 1 + 47e: a0 e0 ldi r26, 0x00 ; 0 + 480: b1 e0 ldi r27, 0x01 ; 1 + 482: e8 e2 ldi r30, 0x28 ; 40 + 484: f5 e1 ldi r31, 0x15 ; 21 + 486: 02 c0 rjmp .+4 ; 0x48c <__do_copy_data+0x10> + 488: 05 90 lpm r0, Z+ + 48a: 0d 92 st X+, r0 + 48c: a4 34 cpi r26, 0x44 ; 68 + 48e: b1 07 cpc r27, r17 + 490: d9 f7 brne .-10 ; 0x488 <__do_copy_data+0xc> + +00000492 <__do_clear_bss>: + 492: 22 e0 ldi r18, 0x02 ; 2 + 494: a4 e4 ldi r26, 0x44 ; 68 + 496: b1 e0 ldi r27, 0x01 ; 1 + 498: 01 c0 rjmp .+2 ; 0x49c <.do_clear_bss_start> + +0000049a <.do_clear_bss_loop>: + 49a: 1d 92 st X+, r1 + +0000049c <.do_clear_bss_start>: + 49c: a2 30 cpi r26, 0x02 ; 2 + 49e: b2 07 cpc r27, r18 + 4a0: e1 f7 brne .-8 ; 0x49a <.do_clear_bss_loop> + +000004a2 <__do_global_ctors>: + 4a2: 12 e0 ldi r17, 0x02 ; 2 + 4a4: c8 e3 ldi r28, 0x38 ; 56 + 4a6: d2 e0 ldi r29, 0x02 ; 2 + 4a8: 04 c0 rjmp .+8 ; 0x4b2 <__do_global_ctors+0x10> + 4aa: 21 97 sbiw r28, 0x01 ; 1 + 4ac: fe 01 movw r30, r28 + 4ae: 0e 94 87 0a call 0x150e ; 0x150e <__tablejump2__> + 4b2: c7 33 cpi r28, 0x37 ; 55 + 4b4: d1 07 cpc r29, r17 + 4b6: c9 f7 brne .-14 ; 0x4aa <__do_global_ctors+0x8> + 4b8: 0e 94 ea 06 call 0xdd4 ; 0xdd4
+ 4bc: 0c 94 92 0a jmp 0x1524 ; 0x1524 <_exit> + +000004c0 <__bad_interrupt>: + 4c0: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> + +000004c4 : +#include "wiring_private.h" +#include "pins_arduino.h" + +void pinMode(uint8_t pin, uint8_t mode) +{ + uint8_t bit = digitalPinToBitMask(pin); + 4c4: 90 e0 ldi r25, 0x00 ; 0 + 4c6: fc 01 movw r30, r24 + 4c8: e6 5a subi r30, 0xA6 ; 166 + 4ca: fb 4f sbci r31, 0xFB ; 251 + 4cc: 24 91 lpm r18, Z + uint8_t port = digitalPinToPort(pin); + 4ce: fc 01 movw r30, r24 + 4d0: ea 5b subi r30, 0xBA ; 186 + 4d2: fb 4f sbci r31, 0xFB ; 251 + 4d4: 84 91 lpm r24, Z + volatile uint8_t *reg, *out; + + if (port == NOT_A_PIN) return; + 4d6: 88 23 and r24, r24 + 4d8: 99 f0 breq .+38 ; 0x500 + + // JWS: can I let the optimizer do this? + reg = portModeRegister(port); + 4da: 90 e0 ldi r25, 0x00 ; 0 + 4dc: 88 0f add r24, r24 + 4de: 99 1f adc r25, r25 + 4e0: fc 01 movw r30, r24 + 4e2: e4 5c subi r30, 0xC4 ; 196 + 4e4: fb 4f sbci r31, 0xFB ; 251 + 4e6: a5 91 lpm r26, Z+ + 4e8: b4 91 lpm r27, Z + out = portOutputRegister(port); + 4ea: fc 01 movw r30, r24 + 4ec: ee 5c subi r30, 0xCE ; 206 + 4ee: fb 4f sbci r31, 0xFB ; 251 + 4f0: 85 91 lpm r24, Z+ + 4f2: 94 91 lpm r25, Z + cli(); + *reg &= ~bit; + *out |= bit; + SREG = oldSREG; + } else { + uint8_t oldSREG = SREG; + 4f4: 8f b7 in r24, 0x3f ; 63 + cli(); + 4f6: f8 94 cli + *reg |= bit; + 4f8: ec 91 ld r30, X + 4fa: e2 2b or r30, r18 + 4fc: ec 93 st X, r30 + SREG = oldSREG; + 4fe: 8f bf out 0x3f, r24 ; 63 + 500: 08 95 ret + +00000502 <_ZN6Cursor9moveYAxisEt.constprop.10>: +} + +/** + * Moves cursor in y axis by a number sepcified in method's parameter + */ +void Cursor::moveYAxis(position by){ + 502: fc 01 movw r30, r24 + if(by == 0) + return; + + _y++; + 504: 80 81 ld r24, Z + 506: 91 81 ldd r25, Z+1 ; 0x01 + 508: 01 96 adiw r24, 0x01 ; 1 + 50a: 91 83 std Z+1, r25 ; 0x01 + 50c: 80 83 st Z, r24 + _x = 0; // for each y incrementation, reset the x axis :D + 50e: 13 82 std Z+3, r1 ; 0x03 + 510: 12 82 std Z+2, r1 ; 0x02 + + if(_y > 5){ + 512: 06 97 sbiw r24, 0x06 ; 6 + 514: 10 f0 brcs .+4 ; 0x51a <_ZN6Cursor9moveYAxisEt.constprop.10+0x18> + _y = 0; + 516: 11 82 std Z+1, r1 ; 0x01 + 518: 10 82 st Z, r1 + 51a: 08 95 ret + +0000051c : + } +} + +void digitalWrite(uint8_t pin, uint8_t val) +{ + uint8_t timer = digitalPinToTimer(pin); + 51c: 90 e0 ldi r25, 0x00 ; 0 + 51e: fc 01 movw r30, r24 + 520: e8 59 subi r30, 0x98 ; 152 + 522: ff 4f sbci r31, 0xFF ; 255 + 524: 24 91 lpm r18, Z + uint8_t bit = digitalPinToBitMask(pin); + 526: fc 01 movw r30, r24 + 528: e6 5a subi r30, 0xA6 ; 166 + 52a: fb 4f sbci r31, 0xFB ; 251 + 52c: 34 91 lpm r19, Z + uint8_t port = digitalPinToPort(pin); + 52e: fc 01 movw r30, r24 + 530: ea 5b subi r30, 0xBA ; 186 + 532: fb 4f sbci r31, 0xFB ; 251 + 534: e4 91 lpm r30, Z + volatile uint8_t *out; + + if (port == NOT_A_PIN) return; + 536: ee 23 and r30, r30 + 538: 09 f4 brne .+2 ; 0x53c + 53a: 3c c0 rjmp .+120 ; 0x5b4 + + // 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); + 53c: 22 23 and r18, r18 + 53e: 39 f1 breq .+78 ; 0x58e +// +//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) + 540: 23 30 cpi r18, 0x03 ; 3 + 542: 91 f0 breq .+36 ; 0x568 + 544: 38 f4 brcc .+14 ; 0x554 + 546: 21 30 cpi r18, 0x01 ; 1 + 548: a9 f0 breq .+42 ; 0x574 + 54a: 22 30 cpi r18, 0x02 ; 2 + 54c: 01 f5 brne .+64 ; 0x58e + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: cbi(TCCR0A, COM0A1); break; + #endif + + #if defined(TCCR0A) && defined(COM0B1) + case TIMER0B: cbi(TCCR0A, COM0B1); break; + 54e: 84 b5 in r24, 0x24 ; 36 + 550: 8f 7d andi r24, 0xDF ; 223 + 552: 12 c0 rjmp .+36 ; 0x578 +// +//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) + 554: 27 30 cpi r18, 0x07 ; 7 + 556: 91 f0 breq .+36 ; 0x57c + 558: 28 30 cpi r18, 0x08 ; 8 + 55a: a1 f0 breq .+40 ; 0x584 + 55c: 24 30 cpi r18, 0x04 ; 4 + 55e: b9 f4 brne .+46 ; 0x58e + { + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: cbi(TCCR1A, COM1A1); break; + #endif + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: cbi(TCCR1A, COM1B1); break; + 560: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 564: 8f 7d andi r24, 0xDF ; 223 + 566: 03 c0 rjmp .+6 ; 0x56e +static void turnOffPWM(uint8_t timer) +{ + switch (timer) + { + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: cbi(TCCR1A, COM1A1); break; + 568: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 56c: 8f 77 andi r24, 0x7F ; 127 + #endif + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: cbi(TCCR1A, COM1B1); break; + 56e: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + 572: 0d c0 rjmp .+26 ; 0x58e + #if defined(TCCR2) && defined(COM21) + case TIMER2: cbi(TCCR2, COM21); break; + #endif + + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: cbi(TCCR0A, COM0A1); break; + 574: 84 b5 in r24, 0x24 ; 36 + 576: 8f 77 andi r24, 0x7F ; 127 + #endif + + #if defined(TCCR0A) && defined(COM0B1) + case TIMER0B: cbi(TCCR0A, COM0B1); break; + 578: 84 bd out 0x24, r24 ; 36 + 57a: 09 c0 rjmp .+18 ; 0x58e + #endif + #if defined(TCCR2A) && defined(COM2A1) + case TIMER2A: cbi(TCCR2A, COM2A1); break; + 57c: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + 580: 8f 77 andi r24, 0x7F ; 127 + 582: 03 c0 rjmp .+6 ; 0x58a + #endif + #if defined(TCCR2A) && defined(COM2B1) + case TIMER2B: cbi(TCCR2A, COM2B1); break; + 584: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + 588: 8f 7d andi r24, 0xDF ; 223 + 58a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + + // 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); + 58e: f0 e0 ldi r31, 0x00 ; 0 + 590: ee 0f add r30, r30 + 592: ff 1f adc r31, r31 + 594: ee 5c subi r30, 0xCE ; 206 + 596: fb 4f sbci r31, 0xFB ; 251 + 598: a5 91 lpm r26, Z+ + 59a: b4 91 lpm r27, Z + + uint8_t oldSREG = SREG; + 59c: 9f b7 in r25, 0x3f ; 63 + cli(); + 59e: f8 94 cli + + if (val == LOW) { + 5a0: 61 11 cpse r22, r1 + 5a2: 04 c0 rjmp .+8 ; 0x5ac + *out &= ~bit; + 5a4: 8c 91 ld r24, X + 5a6: 30 95 com r19 + 5a8: 38 23 and r19, r24 + 5aa: 02 c0 rjmp .+4 ; 0x5b0 + } else { + *out |= bit; + 5ac: ec 91 ld r30, X + 5ae: 3e 2b or r19, r30 + 5b0: 3c 93 st X, r19 + } + + SREG = oldSREG; + 5b2: 9f bf out 0x3f, r25 ; 63 + 5b4: 08 95 ret + +000005b6 : + return m; +} + +unsigned long micros() { + unsigned long m; + uint8_t oldSREG = SREG, t; + 5b6: 3f b7 in r19, 0x3f ; 63 + + cli(); + 5b8: f8 94 cli + m = timer0_overflow_count; + 5ba: 80 91 4f 01 lds r24, 0x014F ; 0x80014f + 5be: 90 91 50 01 lds r25, 0x0150 ; 0x800150 + 5c2: a0 91 51 01 lds r26, 0x0151 ; 0x800151 + 5c6: b0 91 52 01 lds r27, 0x0152 ; 0x800152 +#if defined(TCNT0) + t = TCNT0; + 5ca: 26 b5 in r18, 0x26 ; 38 +#else + #error TIMER 0 not defined +#endif + +#ifdef TIFR0 + if ((TIFR0 & _BV(TOV0)) && (t < 255)) + 5cc: a8 9b sbis 0x15, 0 ; 21 + 5ce: 05 c0 rjmp .+10 ; 0x5da + 5d0: 2f 3f cpi r18, 0xFF ; 255 + 5d2: 19 f0 breq .+6 ; 0x5da + m++; + 5d4: 01 96 adiw r24, 0x01 ; 1 + 5d6: a1 1d adc r26, r1 + 5d8: b1 1d adc r27, r1 +#else + if ((TIFR & _BV(TOV0)) && (t < 255)) + m++; +#endif + + SREG = oldSREG; + 5da: 3f bf out 0x3f, r19 ; 63 + + return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); + 5dc: ba 2f mov r27, r26 + 5de: a9 2f mov r26, r25 + 5e0: 98 2f mov r25, r24 + 5e2: 88 27 eor r24, r24 + 5e4: 82 0f add r24, r18 + 5e6: 91 1d adc r25, r1 + 5e8: a1 1d adc r26, r1 + 5ea: b1 1d adc r27, r1 + 5ec: bc 01 movw r22, r24 + 5ee: cd 01 movw r24, r26 + 5f0: 42 e0 ldi r20, 0x02 ; 2 + 5f2: 66 0f add r22, r22 + 5f4: 77 1f adc r23, r23 + 5f6: 88 1f adc r24, r24 + 5f8: 99 1f adc r25, r25 + 5fa: 4a 95 dec r20 + 5fc: d1 f7 brne .-12 ; 0x5f2 +} + 5fe: 08 95 ret + +00000600 : + +void delay(unsigned long ms) +{ + 600: 8f 92 push r8 + 602: 9f 92 push r9 + 604: af 92 push r10 + 606: bf 92 push r11 + 608: cf 92 push r12 + 60a: df 92 push r13 + 60c: ef 92 push r14 + 60e: ff 92 push r15 + 610: 6b 01 movw r12, r22 + 612: 7c 01 movw r14, r24 + uint32_t start = micros(); + 614: 0e 94 db 02 call 0x5b6 ; 0x5b6 + 618: 4b 01 movw r8, r22 + 61a: 5c 01 movw r10, r24 + + while (ms > 0) { + 61c: c1 14 cp r12, r1 + 61e: d1 04 cpc r13, r1 + 620: e1 04 cpc r14, r1 + 622: f1 04 cpc r15, r1 + 624: f1 f0 breq .+60 ; 0x662 + yield(); + while ( ms > 0 && (micros() - start) >= 1000) { + 626: 0e 94 db 02 call 0x5b6 ; 0x5b6 + 62a: dc 01 movw r26, r24 + 62c: cb 01 movw r24, r22 + 62e: 88 19 sub r24, r8 + 630: 99 09 sbc r25, r9 + 632: aa 09 sbc r26, r10 + 634: bb 09 sbc r27, r11 + 636: 88 3e cpi r24, 0xE8 ; 232 + 638: 93 40 sbci r25, 0x03 ; 3 + 63a: a1 05 cpc r26, r1 + 63c: b1 05 cpc r27, r1 + 63e: 70 f3 brcs .-36 ; 0x61c + ms--; + 640: 21 e0 ldi r18, 0x01 ; 1 + 642: c2 1a sub r12, r18 + 644: d1 08 sbc r13, r1 + 646: e1 08 sbc r14, r1 + 648: f1 08 sbc r15, r1 + start += 1000; + 64a: 88 ee ldi r24, 0xE8 ; 232 + 64c: 88 0e add r8, r24 + 64e: 83 e0 ldi r24, 0x03 ; 3 + 650: 98 1e adc r9, r24 + 652: a1 1c adc r10, r1 + 654: b1 1c adc r11, r1 +{ + uint32_t start = micros(); + + while (ms > 0) { + yield(); + while ( ms > 0 && (micros() - start) >= 1000) { + 656: c1 14 cp r12, r1 + 658: d1 04 cpc r13, r1 + 65a: e1 04 cpc r14, r1 + 65c: f1 04 cpc r15, r1 + 65e: 19 f7 brne .-58 ; 0x626 + 660: dd cf rjmp .-70 ; 0x61c + ms--; + start += 1000; + } + } +} + 662: ff 90 pop r15 + 664: ef 90 pop r14 + 666: df 90 pop r13 + 668: cf 90 pop r12 + 66a: bf 90 pop r11 + 66c: af 90 pop r10 + 66e: 9f 90 pop r9 + 670: 8f 90 pop r8 + 672: 08 95 ret + +00000674 <_ZN5Print5writeEPKhj>: + +// Public Methods ////////////////////////////////////////////////////////////// + +/* default implementation: may be overridden */ +size_t Print::write(const uint8_t *buffer, size_t size) +{ + 674: cf 92 push r12 + 676: df 92 push r13 + 678: ef 92 push r14 + 67a: ff 92 push r15 + 67c: 0f 93 push r16 + 67e: 1f 93 push r17 + 680: cf 93 push r28 + 682: df 93 push r29 + 684: 6c 01 movw r12, r24 + 686: 7a 01 movw r14, r20 + 688: 8b 01 movw r16, r22 + size_t n = 0; + 68a: c0 e0 ldi r28, 0x00 ; 0 + 68c: d0 e0 ldi r29, 0x00 ; 0 + while (size--) { + 68e: ce 15 cp r28, r14 + 690: df 05 cpc r29, r15 + 692: 81 f0 breq .+32 ; 0x6b4 <_ZN5Print5writeEPKhj+0x40> + if (write(*buffer++)) n++; + 694: d8 01 movw r26, r16 + 696: 6d 91 ld r22, X+ + 698: 8d 01 movw r16, r26 + 69a: d6 01 movw r26, r12 + 69c: ed 91 ld r30, X+ + 69e: fc 91 ld r31, X + 6a0: 01 90 ld r0, Z+ + 6a2: f0 81 ld r31, Z + 6a4: e0 2d mov r30, r0 + 6a6: c6 01 movw r24, r12 + 6a8: 09 95 icall + 6aa: 89 2b or r24, r25 + 6ac: 11 f0 breq .+4 ; 0x6b2 <_ZN5Print5writeEPKhj+0x3e> + 6ae: 21 96 adiw r28, 0x01 ; 1 + 6b0: ee cf rjmp .-36 ; 0x68e <_ZN5Print5writeEPKhj+0x1a> + 6b2: 7e 01 movw r14, r28 + else break; + } + return n; +} + 6b4: c7 01 movw r24, r14 + 6b6: df 91 pop r29 + 6b8: cf 91 pop r28 + 6ba: 1f 91 pop r17 + 6bc: 0f 91 pop r16 + 6be: ff 90 pop r15 + 6c0: ef 90 pop r14 + 6c2: df 90 pop r13 + 6c4: cf 90 pop r12 + 6c6: 08 95 ret + +000006c8 <_ZN14HardwareSerial17availableForWriteEv>: +{ + tx_buffer_index_t head; + tx_buffer_index_t tail; + + TX_BUFFER_ATOMIC { + head = _tx_buffer_head; + 6c8: fc 01 movw r30, r24 + 6ca: 53 8d ldd r21, Z+27 ; 0x1b + tail = _tx_buffer_tail; + 6cc: 44 8d ldd r20, Z+28 ; 0x1c + 6ce: 25 2f mov r18, r21 + 6d0: 30 e0 ldi r19, 0x00 ; 0 + 6d2: 84 2f mov r24, r20 + 6d4: 90 e0 ldi r25, 0x00 ; 0 + } + if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; + 6d6: 82 1b sub r24, r18 + 6d8: 93 0b sbc r25, r19 + 6da: 54 17 cp r21, r20 + 6dc: 10 f0 brcs .+4 ; 0x6e2 <_ZN14HardwareSerial17availableForWriteEv+0x1a> + 6de: cf 96 adiw r24, 0x3f ; 63 + 6e0: 08 95 ret + return tail - head - 1; + 6e2: 01 97 sbiw r24, 0x01 ; 1 +} + 6e4: 08 95 ret + +000006e6 <_ZN14HardwareSerial4readEv>: + return _rx_buffer[_rx_buffer_tail]; + } +} + +int HardwareSerial::read(void) +{ + 6e6: fc 01 movw r30, r24 + // if the head isn't ahead of the tail, we don't have any characters + if (_rx_buffer_head == _rx_buffer_tail) { + 6e8: 91 8d ldd r25, Z+25 ; 0x19 + 6ea: 82 8d ldd r24, Z+26 ; 0x1a + 6ec: 98 17 cp r25, r24 + 6ee: 61 f0 breq .+24 ; 0x708 <_ZN14HardwareSerial4readEv+0x22> + return -1; + } else { + unsigned char c = _rx_buffer[_rx_buffer_tail]; + 6f0: 82 8d ldd r24, Z+26 ; 0x1a + 6f2: df 01 movw r26, r30 + 6f4: a8 0f add r26, r24 + 6f6: b1 1d adc r27, r1 + 6f8: 5d 96 adiw r26, 0x1d ; 29 + 6fa: 8c 91 ld r24, X + _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE; + 6fc: 92 8d ldd r25, Z+26 ; 0x1a + 6fe: 9f 5f subi r25, 0xFF ; 255 + 700: 9f 73 andi r25, 0x3F ; 63 + 702: 92 8f std Z+26, r25 ; 0x1a + return c; + 704: 90 e0 ldi r25, 0x00 ; 0 + 706: 08 95 ret + +int HardwareSerial::read(void) +{ + // if the head isn't ahead of the tail, we don't have any characters + if (_rx_buffer_head == _rx_buffer_tail) { + return -1; + 708: 8f ef ldi r24, 0xFF ; 255 + 70a: 9f ef ldi r25, 0xFF ; 255 + } else { + unsigned char c = _rx_buffer[_rx_buffer_tail]; + _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE; + return c; + } +} + 70c: 08 95 ret + +0000070e <_ZN14HardwareSerial4peekEv>: +{ + return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; +} + +int HardwareSerial::peek(void) +{ + 70e: fc 01 movw r30, r24 + if (_rx_buffer_head == _rx_buffer_tail) { + 710: 91 8d ldd r25, Z+25 ; 0x19 + 712: 82 8d ldd r24, Z+26 ; 0x1a + 714: 98 17 cp r25, r24 + 716: 31 f0 breq .+12 ; 0x724 <_ZN14HardwareSerial4peekEv+0x16> + return -1; + } else { + return _rx_buffer[_rx_buffer_tail]; + 718: 82 8d ldd r24, Z+26 ; 0x1a + 71a: e8 0f add r30, r24 + 71c: f1 1d adc r31, r1 + 71e: 85 8d ldd r24, Z+29 ; 0x1d + 720: 90 e0 ldi r25, 0x00 ; 0 + 722: 08 95 ret +} + +int HardwareSerial::peek(void) +{ + if (_rx_buffer_head == _rx_buffer_tail) { + return -1; + 724: 8f ef ldi r24, 0xFF ; 255 + 726: 9f ef ldi r25, 0xFF ; 255 + } else { + return _rx_buffer[_rx_buffer_tail]; + } +} + 728: 08 95 ret + +0000072a <_ZN14HardwareSerial9availableEv>: + // clear any received data + _rx_buffer_head = _rx_buffer_tail; +} + +int HardwareSerial::available(void) +{ + 72a: fc 01 movw r30, r24 + return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE; + 72c: 91 8d ldd r25, Z+25 ; 0x19 + 72e: 22 8d ldd r18, Z+26 ; 0x1a + 730: 89 2f mov r24, r25 + 732: 90 e0 ldi r25, 0x00 ; 0 + 734: 80 5c subi r24, 0xC0 ; 192 + 736: 9f 4f sbci r25, 0xFF ; 255 + 738: 82 1b sub r24, r18 + 73a: 91 09 sbc r25, r1 +} + 73c: 8f 73 andi r24, 0x3F ; 63 + 73e: 99 27 eor r25, r25 + 740: 08 95 ret + +00000742 <_Z17Serial0_availablev>: +#endif + +// Function that can be weakly referenced by serialEventRun to prevent +// pulling in this file if it's not otherwise used. +bool Serial0_available() { + return Serial.available(); + 742: 83 e5 ldi r24, 0x53 ; 83 + 744: 91 e0 ldi r25, 0x01 ; 1 + 746: 0e 94 95 03 call 0x72a ; 0x72a <_ZN14HardwareSerial9availableEv> + 74a: 21 e0 ldi r18, 0x01 ; 1 + 74c: 89 2b or r24, r25 + 74e: 09 f4 brne .+2 ; 0x752 <_Z17Serial0_availablev+0x10> + 750: 20 e0 ldi r18, 0x00 ; 0 +} + 752: 82 2f mov r24, r18 + 754: 08 95 ret + +00000756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv>: +#endif + +// Actual interrupt handlers ////////////////////////////////////////////////////////////// + +void HardwareSerial::_tx_udr_empty_irq(void) +{ + 756: fc 01 movw r30, r24 + // If interrupts are enabled, there must be more data in the output + // buffer. Send the next byte + unsigned char c = _tx_buffer[_tx_buffer_tail]; + 758: 84 8d ldd r24, Z+28 ; 0x1c + 75a: df 01 movw r26, r30 + 75c: a8 0f add r26, r24 + 75e: b1 1d adc r27, r1 + 760: a3 5a subi r26, 0xA3 ; 163 + 762: bf 4f sbci r27, 0xFF ; 255 + 764: 2c 91 ld r18, X + _tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE; + 766: 84 8d ldd r24, Z+28 ; 0x1c + 768: 90 e0 ldi r25, 0x00 ; 0 + 76a: 01 96 adiw r24, 0x01 ; 1 + 76c: 8f 73 andi r24, 0x3F ; 63 + 76e: 99 27 eor r25, r25 + 770: 84 8f std Z+28, r24 ; 0x1c + + *_udr = c; + 772: a6 89 ldd r26, Z+22 ; 0x16 + 774: b7 89 ldd r27, Z+23 ; 0x17 + 776: 2c 93 st X, r18 + // location". This makes sure flush() won't return until the bytes + // actually got written. Other r/w bits are preserved, and zeroes + // written to the rest. + +#ifdef MPCM0 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); + 778: a0 89 ldd r26, Z+16 ; 0x10 + 77a: b1 89 ldd r27, Z+17 ; 0x11 + 77c: 8c 91 ld r24, X + 77e: 83 70 andi r24, 0x03 ; 3 + 780: 80 64 ori r24, 0x40 ; 64 + 782: 8c 93 st X, r24 +#else + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); +#endif + + if (_tx_buffer_head == _tx_buffer_tail) { + 784: 93 8d ldd r25, Z+27 ; 0x1b + 786: 84 8d ldd r24, Z+28 ; 0x1c + 788: 98 13 cpse r25, r24 + 78a: 06 c0 rjmp .+12 ; 0x798 <_ZN14HardwareSerial17_tx_udr_empty_irqEv+0x42> + // Buffer empty, so disable interrupts + cbi(*_ucsrb, UDRIE0); + 78c: 02 88 ldd r0, Z+18 ; 0x12 + 78e: f3 89 ldd r31, Z+19 ; 0x13 + 790: e0 2d mov r30, r0 + 792: 80 81 ld r24, Z + 794: 8f 7d andi r24, 0xDF ; 223 + 796: 80 83 st Z, r24 + 798: 08 95 ret + +0000079a <_ZN14HardwareSerial5writeEh>: + // If we get here, nothing is queued anymore (DRIE is disabled) and + // the hardware finished tranmission (TXC is set). +} + +size_t HardwareSerial::write(uint8_t c) +{ + 79a: ef 92 push r14 + 79c: ff 92 push r15 + 79e: 0f 93 push r16 + 7a0: 1f 93 push r17 + 7a2: cf 93 push r28 + 7a4: df 93 push r29 + 7a6: ec 01 movw r28, r24 + _written = true; + 7a8: 81 e0 ldi r24, 0x01 ; 1 + 7aa: 88 8f std Y+24, r24 ; 0x18 + // If the buffer and the data register is empty, just write the byte + // to the data register and be done. This shortcut helps + // significantly improve the effective datarate at high (> + // 500kbit/s) bitrates, where interrupt overhead becomes a slowdown. + if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) { + 7ac: 9b 8d ldd r25, Y+27 ; 0x1b + 7ae: 8c 8d ldd r24, Y+28 ; 0x1c + 7b0: 98 13 cpse r25, r24 + 7b2: 05 c0 rjmp .+10 ; 0x7be <_ZN14HardwareSerial5writeEh+0x24> + 7b4: e8 89 ldd r30, Y+16 ; 0x10 + 7b6: f9 89 ldd r31, Y+17 ; 0x11 + 7b8: 80 81 ld r24, Z + 7ba: 85 fd sbrc r24, 5 + 7bc: 26 c0 rjmp .+76 ; 0x80a <_ZN14HardwareSerial5writeEh+0x70> + 7be: f6 2e mov r15, r22 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0))); +#endif + } + return 1; + } + tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE; + 7c0: 0b 8d ldd r16, Y+27 ; 0x1b + 7c2: 10 e0 ldi r17, 0x00 ; 0 + 7c4: 0f 5f subi r16, 0xFF ; 255 + 7c6: 1f 4f sbci r17, 0xFF ; 255 + 7c8: 0f 73 andi r16, 0x3F ; 63 + 7ca: 11 27 eor r17, r17 + 7cc: e0 2e mov r14, r16 + + // If the output buffer is full, there's nothing for it other than to + // wait for the interrupt handler to empty it a bit + while (i == _tx_buffer_tail) { + 7ce: 8c 8d ldd r24, Y+28 ; 0x1c + 7d0: e8 12 cpse r14, r24 + 7d2: 0c c0 rjmp .+24 ; 0x7ec <_ZN14HardwareSerial5writeEh+0x52> + if (bit_is_clear(SREG, SREG_I)) { + 7d4: 0f b6 in r0, 0x3f ; 63 + 7d6: 07 fc sbrc r0, 7 + 7d8: fa cf rjmp .-12 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34> + // Interrupts are disabled, so we'll have to poll the data + // register empty flag ourselves. If it is set, pretend an + // interrupt has happened and call the handler to free up + // space for us. + if(bit_is_set(*_ucsra, UDRE0)) + 7da: e8 89 ldd r30, Y+16 ; 0x10 + 7dc: f9 89 ldd r31, Y+17 ; 0x11 + 7de: 80 81 ld r24, Z + 7e0: 85 ff sbrs r24, 5 + 7e2: f5 cf rjmp .-22 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34> + _tx_udr_empty_irq(); + 7e4: ce 01 movw r24, r28 + 7e6: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv> + 7ea: f1 cf rjmp .-30 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34> + } else { + // nop, the interrupt handler will free up space for us + } + } + + _tx_buffer[_tx_buffer_head] = c; + 7ec: 8b 8d ldd r24, Y+27 ; 0x1b + 7ee: fe 01 movw r30, r28 + 7f0: e8 0f add r30, r24 + 7f2: f1 1d adc r31, r1 + 7f4: e3 5a subi r30, 0xA3 ; 163 + 7f6: ff 4f sbci r31, 0xFF ; 255 + 7f8: f0 82 st Z, r15 + + // make atomic to prevent execution of ISR between setting the + // head pointer and setting the interrupt flag resulting in buffer + // retransmission + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + 7fa: 9f b7 in r25, 0x3f ; 63 + return 1; +} + +static __inline__ uint8_t __iCliRetVal(void) +{ + cli(); + 7fc: f8 94 cli + _tx_buffer_head = i; + 7fe: 0b 8f std Y+27, r16 ; 0x1b + sbi(*_ucsrb, UDRIE0); + 800: ea 89 ldd r30, Y+18 ; 0x12 + 802: fb 89 ldd r31, Y+19 ; 0x13 + 804: 80 81 ld r24, Z + 806: 80 62 ori r24, 0x20 ; 32 + 808: 0a c0 rjmp .+20 ; 0x81e <_ZN14HardwareSerial5writeEh+0x84> + // So writing UDR must happen first. + // Writing UDR and clearing TC must be done atomically, otherwise + // interrupts might delay the TXC clear so the byte written to UDR + // is transmitted (setting TXC) before clearing TXC. Then TXC will + // be cleared when no bytes are left, causing flush() to hang + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + 80a: 9f b7 in r25, 0x3f ; 63 + 80c: f8 94 cli + *_udr = c; + 80e: ee 89 ldd r30, Y+22 ; 0x16 + 810: ff 89 ldd r31, Y+23 ; 0x17 + 812: 60 83 st Z, r22 +#ifdef MPCM0 + *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0); + 814: e8 89 ldd r30, Y+16 ; 0x10 + 816: f9 89 ldd r31, Y+17 ; 0x11 + 818: 80 81 ld r24, Z + 81a: 83 70 andi r24, 0x03 ; 3 + 81c: 80 64 ori r24, 0x40 ; 64 + 81e: 80 83 st Z, r24 + (void)__s; +} + +static __inline__ void __iRestore(const uint8_t *__s) +{ + SREG = *__s; + 820: 9f bf out 0x3f, r25 ; 63 + _tx_buffer_head = i; + sbi(*_ucsrb, UDRIE0); + } + + return 1; +} + 822: 81 e0 ldi r24, 0x01 ; 1 + 824: 90 e0 ldi r25, 0x00 ; 0 + 826: df 91 pop r29 + 828: cf 91 pop r28 + 82a: 1f 91 pop r17 + 82c: 0f 91 pop r16 + 82e: ff 90 pop r15 + 830: ef 90 pop r14 + 832: 08 95 ret + +00000834 <_ZN14HardwareSerial5flushEv>: + if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail; + return tail - head - 1; +} + +void HardwareSerial::flush() +{ + 834: cf 93 push r28 + 836: df 93 push r29 + 838: ec 01 movw r28, r24 + // If we have never written a byte, no need to flush. This special + // case is needed since there is no way to force the TXC (transmit + // complete) bit to 1 during initialization + if (!_written) + 83a: 88 8d ldd r24, Y+24 ; 0x18 + 83c: 88 23 and r24, r24 + 83e: c9 f0 breq .+50 ; 0x872 <_ZN14HardwareSerial5flushEv+0x3e> + return; + + while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) { + 840: ea 89 ldd r30, Y+18 ; 0x12 + 842: fb 89 ldd r31, Y+19 ; 0x13 + 844: 80 81 ld r24, Z + 846: 85 fd sbrc r24, 5 + 848: 05 c0 rjmp .+10 ; 0x854 <_ZN14HardwareSerial5flushEv+0x20> + 84a: a8 89 ldd r26, Y+16 ; 0x10 + 84c: b9 89 ldd r27, Y+17 ; 0x11 + 84e: 8c 91 ld r24, X + 850: 86 fd sbrc r24, 6 + 852: 0f c0 rjmp .+30 ; 0x872 <_ZN14HardwareSerial5flushEv+0x3e> + if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0)) + 854: 0f b6 in r0, 0x3f ; 63 + 856: 07 fc sbrc r0, 7 + 858: f5 cf rjmp .-22 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10> + 85a: 80 81 ld r24, Z + 85c: 85 ff sbrs r24, 5 + 85e: f2 cf rjmp .-28 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10> + // Interrupts are globally disabled, but the DR empty + // interrupt should be enabled, so poll the DR empty flag to + // prevent deadlock + if (bit_is_set(*_ucsra, UDRE0)) + 860: a8 89 ldd r26, Y+16 ; 0x10 + 862: b9 89 ldd r27, Y+17 ; 0x11 + 864: 8c 91 ld r24, X + 866: 85 ff sbrs r24, 5 + 868: ed cf rjmp .-38 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10> + _tx_udr_empty_irq(); + 86a: ce 01 movw r24, r28 + 86c: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv> + 870: e7 cf rjmp .-50 ; 0x840 <_ZN14HardwareSerial5flushEv+0xc> + } + // If we get here, nothing is queued anymore (DRIE is disabled) and + // the hardware finished tranmission (TXC is set). +} + 872: df 91 pop r29 + 874: cf 91 pop r28 + 876: 08 95 ret + +00000878 <_Z14serialEventRunv>: +#endif + +void serialEventRun(void) +{ +#if defined(HAVE_HWSERIAL0) + if (Serial0_available && serialEvent && Serial0_available()) serialEvent(); + 878: 80 e0 ldi r24, 0x00 ; 0 + 87a: 90 e0 ldi r25, 0x00 ; 0 + 87c: 89 2b or r24, r25 + 87e: 29 f0 breq .+10 ; 0x88a <_Z14serialEventRunv+0x12> + 880: 0e 94 a1 03 call 0x742 ; 0x742 <_Z17Serial0_availablev> + 884: 81 11 cpse r24, r1 + 886: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> + 88a: 08 95 ret + +0000088c <_ZN5Print5flushEv>: + size_t println(unsigned long, int = DEC); + size_t println(double, int = 2); + size_t println(const Printable&); + size_t println(void); + + virtual void flush() { /* Empty implementation for backward compatibility */ } + 88c: 08 95 ret + +0000088e <_ZN5Print17availableForWriteEv>: + return write((const uint8_t *)buffer, size); + } + + // default to zero, meaning "a single write may block" + // should be overriden by subclasses with buffering + virtual int availableForWrite() { return 0; } + 88e: 80 e0 ldi r24, 0x00 ; 0 + 890: 90 e0 ldi r25, 0x00 ; 0 + 892: 08 95 ret + +00000894 <_ZN5Print5writeEPKc.constprop.24>: + int getWriteError() { return write_error; } + void clearWriteError() { setWriteError(0); } + + virtual size_t write(uint8_t) = 0; + size_t write(const char *str) { + if (str == NULL) return 0; + 894: 00 97 sbiw r24, 0x00 ; 0 + 896: 69 f0 breq .+26 ; 0x8b2 <_ZN5Print5writeEPKc.constprop.24+0x1e> + return write((const uint8_t *)str, strlen(str)); + 898: fc 01 movw r30, r24 + 89a: 01 90 ld r0, Z+ + 89c: 00 20 and r0, r0 + 89e: e9 f7 brne .-6 ; 0x89a <_ZN5Print5writeEPKc.constprop.24+0x6> + 8a0: 31 97 sbiw r30, 0x01 ; 1 + 8a2: af 01 movw r20, r30 + 8a4: 48 1b sub r20, r24 + 8a6: 59 0b sbc r21, r25 + 8a8: bc 01 movw r22, r24 + 8aa: 80 ef ldi r24, 0xF0 ; 240 + 8ac: 91 e0 ldi r25, 0x01 ; 1 + 8ae: 0c 94 3a 03 jmp 0x674 ; 0x674 <_ZN5Print5writeEPKhj> + } + 8b2: 80 e0 ldi r24, 0x00 ; 0 + 8b4: 90 e0 ldi r25, 0x00 ; 0 + 8b6: 08 95 ret + +000008b8 <_ZN5Print11printNumberEmh.constprop.20>: + return n; +} + +// Private Methods ///////////////////////////////////////////////////////////// + +size_t Print::printNumber(unsigned long n, uint8_t base) + 8b8: 8f 92 push r8 + 8ba: 9f 92 push r9 + 8bc: af 92 push r10 + 8be: bf 92 push r11 + 8c0: 0f 93 push r16 + 8c2: 1f 93 push r17 + 8c4: cf 93 push r28 + 8c6: df 93 push r29 + 8c8: cd b7 in r28, 0x3d ; 61 + 8ca: de b7 in r29, 0x3e ; 62 + 8cc: a1 97 sbiw r28, 0x21 ; 33 + 8ce: 0f b6 in r0, 0x3f ; 63 + 8d0: f8 94 cli + 8d2: de bf out 0x3e, r29 ; 62 + 8d4: 0f be out 0x3f, r0 ; 63 + 8d6: cd bf out 0x3d, r28 ; 61 +{ + char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte. + char *str = &buf[sizeof(buf) - 1]; + + *str = '\0'; + 8d8: 19 a2 std Y+33, r1 ; 0x21 + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + 8da: 42 30 cpi r20, 0x02 ; 2 + 8dc: 08 f4 brcc .+2 ; 0x8e0 <_ZN5Print11printNumberEmh.constprop.20+0x28> + 8de: 4a e0 ldi r20, 0x0A ; 10 + 8e0: 8e 01 movw r16, r28 + 8e2: 0f 5d subi r16, 0xDF ; 223 + 8e4: 1f 4f sbci r17, 0xFF ; 255 + + do { + char c = n % base; + 8e6: 84 2e mov r8, r20 + 8e8: 91 2c mov r9, r1 + 8ea: a1 2c mov r10, r1 + 8ec: b1 2c mov r11, r1 + 8ee: a5 01 movw r20, r10 + 8f0: 94 01 movw r18, r8 + 8f2: 0e 94 65 0a call 0x14ca ; 0x14ca <__udivmodsi4> + 8f6: e6 2f mov r30, r22 + n /= base; + 8f8: b9 01 movw r22, r18 + 8fa: ca 01 movw r24, r20 + + *--str = c < 10 ? c + '0' : c + 'A' - 10; + 8fc: 01 50 subi r16, 0x01 ; 1 + 8fe: 11 09 sbc r17, r1 + 900: ea 30 cpi r30, 0x0A ; 10 + 902: 14 f4 brge .+4 ; 0x908 <__stack+0x9> + 904: e0 5d subi r30, 0xD0 ; 208 + 906: 01 c0 rjmp .+2 ; 0x90a <__stack+0xb> + 908: e9 5c subi r30, 0xC9 ; 201 + 90a: d8 01 movw r26, r16 + 90c: ec 93 st X, r30 + *str = '\0'; + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + 90e: 23 2b or r18, r19 + 910: 24 2b or r18, r20 + 912: 25 2b or r18, r21 + 914: 61 f7 brne .-40 ; 0x8ee <_ZN5Print11printNumberEmh.constprop.20+0x36> + n /= base; + + *--str = c < 10 ? c + '0' : c + 'A' - 10; + } while(n); + + return write(str); + 916: c8 01 movw r24, r16 + 918: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> +} + 91c: a1 96 adiw r28, 0x21 ; 33 + 91e: 0f b6 in r0, 0x3f ; 63 + 920: f8 94 cli + 922: de bf out 0x3e, r29 ; 62 + 924: 0f be out 0x3f, r0 ; 63 + 926: cd bf out 0x3d, r28 ; 61 + 928: df 91 pop r29 + 92a: cf 91 pop r28 + 92c: 1f 91 pop r17 + 92e: 0f 91 pop r16 + 930: bf 90 pop r11 + 932: af 90 pop r10 + 934: 9f 90 pop r9 + 936: 8f 90 pop r8 + 938: 08 95 ret + +0000093a <_ZN10Nokia_511019transmitInformationEh>: + +void Nokia_5110::endTransmission(){ + digitalWrite(_CE, HIGH); +} + +void Nokia_5110::transmitInformation(byte information){ + 93a: cf 92 push r12 + 93c: df 92 push r13 + 93e: ef 92 push r14 + 940: ff 92 push r15 + 942: 0f 93 push r16 + 944: 1f 93 push r17 + 946: cf 93 push r28 + 948: df 93 push r29 + 94a: ec 01 movw r28, r24 + 94c: e6 2e mov r14, r22 + setBiasSystem(Mux_Rate::FORTY); + setContrast(60); +} + +void Nokia_5110::startTransmission(){ + digitalWrite(_CE, LOW); + 94e: 60 e0 ldi r22, 0x00 ; 0 + 950: 8e 81 ldd r24, Y+6 ; 0x06 + 952: 0e 94 8e 02 call 0x51c ; 0x51c + digitalWrite(_CE, HIGH); +} + +void Nokia_5110::transmitInformation(byte information){ + startTransmission(); + shiftOut(_DIN, _CLK, MSBFIRST, information); + 956: dc 84 ldd r13, Y+12 ; 0x0c + 958: ca 84 ldd r12, Y+10 ; 0x0a + 95a: 07 e0 ldi r16, 0x07 ; 7 + 95c: 10 e0 ldi r17, 0x00 ; 0 + + for (i = 0; i < 8; i++) { + if (bitOrder == LSBFIRST) + digitalWrite(dataPin, !!(val & (1 << i))); + else + digitalWrite(dataPin, !!(val & (1 << (7 - i)))); + 95e: f1 2c mov r15, r1 + 960: b7 01 movw r22, r14 + 962: 00 2e mov r0, r16 + 964: 02 c0 rjmp .+4 ; 0x96a <_ZN10Nokia_511019transmitInformationEh+0x30> + 966: 75 95 asr r23 + 968: 67 95 ror r22 + 96a: 0a 94 dec r0 + 96c: e2 f7 brpl .-8 ; 0x966 <_ZN10Nokia_511019transmitInformationEh+0x2c> + 96e: 61 70 andi r22, 0x01 ; 1 + 970: 8c 2d mov r24, r12 + 972: 0e 94 8e 02 call 0x51c ; 0x51c + + digitalWrite(clockPin, HIGH); + 976: 61 e0 ldi r22, 0x01 ; 1 + 978: 8d 2d mov r24, r13 + 97a: 0e 94 8e 02 call 0x51c ; 0x51c + digitalWrite(clockPin, LOW); + 97e: 60 e0 ldi r22, 0x00 ; 0 + 980: 8d 2d mov r24, r13 + 982: 0e 94 8e 02 call 0x51c ; 0x51c + 986: 01 50 subi r16, 0x01 ; 1 + 988: 11 09 sbc r17, r1 + 98a: 50 f7 brcc .-44 ; 0x960 <_ZN10Nokia_511019transmitInformationEh+0x26> +void Nokia_5110::startTransmission(){ + digitalWrite(_CE, LOW); +} + +void Nokia_5110::endTransmission(){ + digitalWrite(_CE, HIGH); + 98c: 61 e0 ldi r22, 0x01 ; 1 + 98e: 8e 81 ldd r24, Y+6 ; 0x06 + +void Nokia_5110::transmitInformation(byte information){ + startTransmission(); + shiftOut(_DIN, _CLK, MSBFIRST, information); + endTransmission(); +} + 990: df 91 pop r29 + 992: cf 91 pop r28 + 994: 1f 91 pop r17 + 996: 0f 91 pop r16 + 998: ff 90 pop r15 + 99a: ef 90 pop r14 + 99c: df 90 pop r13 + 99e: cf 90 pop r12 +void Nokia_5110::startTransmission(){ + digitalWrite(_CE, LOW); +} + +void Nokia_5110::endTransmission(){ + digitalWrite(_CE, HIGH); + 9a0: 0c 94 8e 02 jmp 0x51c ; 0x51c + +000009a4 <_ZN10Nokia_51107executeEh>: + startTransmission(); + shiftOut(_DIN, _CLK, MSBFIRST, information); + endTransmission(); +} + +void Nokia_5110::execute(byte command){ + 9a4: 1f 93 push r17 + 9a6: cf 93 push r28 + 9a8: df 93 push r29 + 9aa: ec 01 movw r28, r24 + 9ac: 16 2f mov r17, r22 + initializeForSendingCommand(); + transmitInformation(command); +} + +void Nokia_5110::initializeForSendingCommand(){ + digitalWrite(_DC, LOW); + 9ae: 60 e0 ldi r22, 0x00 ; 0 + 9b0: 88 85 ldd r24, Y+8 ; 0x08 + 9b2: 0e 94 8e 02 call 0x51c ; 0x51c + endTransmission(); +} + +void Nokia_5110::execute(byte command){ + initializeForSendingCommand(); + transmitInformation(command); + 9b6: 61 2f mov r22, r17 + 9b8: ce 01 movw r24, r28 +} + 9ba: df 91 pop r29 + 9bc: cf 91 pop r28 + 9be: 1f 91 pop r17 + endTransmission(); +} + +void Nokia_5110::execute(byte command){ + initializeForSendingCommand(); + transmitInformation(command); + 9c0: 0c 94 9d 04 jmp 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh> + +000009c4 <_ZN10Nokia_51109setCursorEtt>: + + transmitInformation(0x0); // add an empty line after each chars + _cursor.moveXAxis(fontData.definition_total_bytes + 1); +} + +void Nokia_5110::setCursor(position x, position y){ + 9c4: 0f 93 push r16 + 9c6: 1f 93 push r17 + 9c8: cf 93 push r28 + 9ca: df 93 push r29 + 9cc: ec 01 movw r28, r24 + 9ce: 06 2f mov r16, r22 + 9d0: 14 2f mov r17, r20 +#include "Cursor.h" + +void Cursor::setCursor(position x, position y){ + _x = x; + 9d2: 68 8b std Y+16, r22 ; 0x10 + 9d4: 79 8b std Y+17, r23 ; 0x11 + _y = y; + 9d6: 4e 87 std Y+14, r20 ; 0x0e + 9d8: 5f 87 std Y+15, r21 ; 0x0f +void Nokia_5110::extendedInstruction(){ + execute(0x21); +} + +void Nokia_5110::basicInstruction(){ + execute(0x20); + 9da: 60 e2 ldi r22, 0x20 ; 32 + 9dc: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + + basicInstruction(); + + //set x position + unsigned short int leastXPositionValue = 128; + execute(byte(leastXPositionValue + x)); + 9e0: 60 e8 ldi r22, 0x80 ; 128 + 9e2: 60 0f add r22, r16 + 9e4: ce 01 movw r24, r28 + 9e6: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + + + //set y position + unsigned short int leastYPositionValue = 64; + execute(byte(leastYPositionValue + y)); + 9ea: 60 e4 ldi r22, 0x40 ; 64 + 9ec: 61 0f add r22, r17 + 9ee: ce 01 movw r24, r28 +} + 9f0: df 91 pop r29 + 9f2: cf 91 pop r28 + 9f4: 1f 91 pop r17 + 9f6: 0f 91 pop r16 + execute(byte(leastXPositionValue + x)); + + + //set y position + unsigned short int leastYPositionValue = 64; + execute(byte(leastYPositionValue + y)); + 9f8: 0c 94 d2 04 jmp 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + +000009fc <_ZN10Nokia_51105clearEv.constprop.31>: +} + +void Nokia_5110::clear(){ + 9fc: cf 93 push r28 + 9fe: df 93 push r29 + digitalWrite(_RST, LOW); + digitalWrite(_RST, HIGH); +} + +void Nokia_5110::initializeForSendingData(){ + digitalWrite(_DC, HIGH); + a00: 61 e0 ldi r22, 0x01 ; 1 + a02: 80 91 f8 01 lds r24, 0x01F8 ; 0x8001f8 + a06: 0e 94 8e 02 call 0x51c ; 0x51c + a0a: c9 ef ldi r28, 0xF9 ; 249 + a0c: d1 e0 ldi r29, 0x01 ; 1 +void Nokia_5110::clear(){ + initializeForSendingData(); + + int i = 504; + while(i >= 0){ + transmitInformation(0x0); + a0e: 60 e0 ldi r22, 0x00 ; 0 + a10: 80 ef ldi r24, 0xF0 ; 240 + a12: 91 e0 ldi r25, 0x01 ; 1 + a14: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh> + a18: 21 97 sbiw r28, 0x01 ; 1 + +void Nokia_5110::clear(){ + initializeForSendingData(); + + int i = 504; + while(i >= 0){ + a1a: c9 f7 brne .-14 ; 0xa0e <_ZN10Nokia_51105clearEv.constprop.31+0x12> + transmitInformation(0x0); + i--; + } + + setCursor(0, 0); + a1c: 40 e0 ldi r20, 0x00 ; 0 + a1e: 50 e0 ldi r21, 0x00 ; 0 + a20: 60 e0 ldi r22, 0x00 ; 0 + a22: 70 e0 ldi r23, 0x00 ; 0 + a24: 80 ef ldi r24, 0xF0 ; 240 + a26: 91 e0 ldi r25, 0x01 ; 1 +} + a28: df 91 pop r29 + a2a: cf 91 pop r28 + while(i >= 0){ + transmitInformation(0x0); + i--; + } + + setCursor(0, 0); + a2c: 0c 94 e2 04 jmp 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + +00000a30 <_ZN10Nokia_51106_printEh.constprop.6>: + _cursor.moveYAxis(1); + setCursor(_cursor.getPosition().x, _cursor.getPosition().y); + initializeForSendingData(); +} + +void Nokia_5110::_print(uint8_t charAsciiCode){ + a30: 8f 92 push r8 + a32: 9f 92 push r9 + a34: af 92 push r10 + a36: bf 92 push r11 + a38: cf 92 push r12 + a3a: df 92 push r13 + a3c: ef 92 push r14 + a3e: ff 92 push r15 + a40: 0f 93 push r16 + a42: 1f 93 push r17 + a44: cf 93 push r28 + a46: df 93 push r29 + a48: cd b7 in r28, 0x3d ; 61 + a4a: de b7 in r29, 0x3e ; 62 + a4c: 2a 97 sbiw r28, 0x0a ; 10 + a4e: 0f b6 in r0, 0x3f ; 63 + a50: f8 94 cli + a52: de bf out 0x3e, r29 ; 62 + a54: 0f be out 0x3f, r0 ; 63 + a56: cd bf out 0x3d, r28 ; 61 + a58: 8c 01 movw r16, r24 + a5a: d6 2e mov r13, r22 + a5c: 0e 96 adiw r24, 0x0e ; 14 + a5e: 5c 01 movw r10, r24 + + if (charAsciiCode == 0x0a){ // \n for jumping to the beginning of a new line. + a60: 9a e0 ldi r25, 0x0A ; 10 + a62: 69 13 cpse r22, r25 + a64: 04 c0 rjmp .+8 ; 0xa6e <_ZN10Nokia_51106_printEh.constprop.6+0x3e> + _cursor.moveYAxis(1); + a66: c5 01 movw r24, r10 + a68: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10> + a6c: 72 c0 rjmp .+228 ; 0xb52 <_ZN10Nokia_51106_printEh.constprop.6+0x122> + return; + } + + setCursor(_cursor.getPosition().x, _cursor.getPosition().y); + a6e: f8 01 movw r30, r16 + a70: 46 85 ldd r20, Z+14 ; 0x0e + a72: 57 85 ldd r21, Z+15 ; 0x0f + a74: 60 89 ldd r22, Z+16 ; 0x10 + a76: 71 89 ldd r23, Z+17 ; 0x11 + a78: c8 01 movw r24, r16 + a7a: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + digitalWrite(_RST, LOW); + digitalWrite(_RST, HIGH); +} + +void Nokia_5110::initializeForSendingData(){ + digitalWrite(_DC, HIGH); + a7e: 61 e0 ldi r22, 0x01 ; 1 + a80: f8 01 movw r30, r16 + a82: 80 85 ldd r24, Z+8 ; 0x08 + a84: 0e 94 8e 02 call 0x51c ; 0x51c + a88: 8c e7 ldi r24, 0x7C ; 124 + a8a: e8 2e mov r14, r24 + a8c: 80 e0 ldi r24, 0x00 ; 0 + a8e: f8 2e mov r15, r24 + unsigned short int total_characters = sizeof(characters) / sizeof(*characters); + character temp; + + for (unsigned short int i = 0; i < total_characters; i++) { + //Retrieve character from FLASH MEMORY + memcpy_P(&temp, &characters[i], sizeof(character)); + a90: 4a e0 ldi r20, 0x0A ; 10 + a92: 50 e0 ldi r21, 0x00 ; 0 + a94: b7 01 movw r22, r14 + a96: ce 01 movw r24, r28 + a98: 01 96 adiw r24, 0x01 ; 1 + a9a: 0e 94 92 08 call 0x1124 ; 0x1124 + if (temp.ascii_code == ascii_code) return temp; + a9e: 8a 81 ldd r24, Y+2 ; 0x02 + aa0: d8 16 cp r13, r24 + aa2: 81 f0 breq .+32 ; 0xac4 <_ZN10Nokia_51106_printEh.constprop.6+0x94> + aa4: fa e0 ldi r31, 0x0A ; 10 + aa6: ef 0e add r14, r31 + aa8: f1 1c adc r15, r1 + +character findCorrespondingByte(uint8_t ascii_code){ + unsigned short int total_characters = sizeof(characters) / sizeof(*characters); + character temp; + + for (unsigned short int i = 0; i < total_characters; i++) { + aaa: 82 e3 ldi r24, 0x32 ; 50 + aac: e8 16 cp r14, r24 + aae: 84 e0 ldi r24, 0x04 ; 4 + ab0: f8 06 cpc r15, r24 + ab2: 71 f7 brne .-36 ; 0xa90 <_ZN10Nokia_51106_printEh.constprop.6+0x60> + //Retrieve character from FLASH MEMORY + memcpy_P(&temp, &characters[i], sizeof(character)); + if (temp.ascii_code == ascii_code) return temp; + } + memcpy_P(&temp, &characters[0], sizeof(character)); + ab4: 4a e0 ldi r20, 0x0A ; 10 + ab6: 50 e0 ldi r21, 0x00 ; 0 + ab8: 6c e7 ldi r22, 0x7C ; 124 + aba: 70 e0 ldi r23, 0x00 ; 0 + abc: ce 01 movw r24, r28 + abe: 01 96 adiw r24, 0x01 ; 1 + ac0: 0e 94 92 08 call 0x1124 ; 0x1124 + + setCursor(_cursor.getPosition().x, _cursor.getPosition().y); + + initializeForSendingData(); + + character fontData = findCorrespondingByte(charAsciiCode); + ac4: c9 84 ldd r12, Y+9 ; 0x09 + ac6: da 84 ldd r13, Y+10 ; 0x0a +void Nokia_5110::initializeForSendingData(){ + digitalWrite(_DC, HIGH); +} + +void Nokia_5110::makeEnoughSpaceForPrinting(unsigned short int newCharacterLength){ + if((newCharacterLength + _cursor.getPosition().x) < 85) + ac8: f8 01 movw r30, r16 + aca: 80 89 ldd r24, Z+16 ; 0x10 + acc: 91 89 ldd r25, Z+17 ; 0x11 + ace: 8c 0d add r24, r12 + ad0: 9d 1d adc r25, r13 + ad2: 85 35 cpi r24, 0x55 ; 85 + ad4: 91 05 cpc r25, r1 + ad6: 80 f0 brcs .+32 ; 0xaf8 <_ZN10Nokia_51106_printEh.constprop.6+0xc8> + return; + + _cursor.moveYAxis(1); + ad8: c5 01 movw r24, r10 + ada: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10> + setCursor(_cursor.getPosition().x, _cursor.getPosition().y); + ade: f8 01 movw r30, r16 + ae0: 46 85 ldd r20, Z+14 ; 0x0e + ae2: 57 85 ldd r21, Z+15 ; 0x0f + ae4: 60 89 ldd r22, Z+16 ; 0x10 + ae6: 71 89 ldd r23, Z+17 ; 0x11 + ae8: c8 01 movw r24, r16 + aea: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + digitalWrite(_RST, LOW); + digitalWrite(_RST, HIGH); +} + +void Nokia_5110::initializeForSendingData(){ + digitalWrite(_DC, HIGH); + aee: 61 e0 ldi r22, 0x01 ; 1 + af0: f8 01 movw r30, r16 + af2: 80 85 ldd r24, Z+8 ; 0x08 + af4: 0e 94 8e 02 call 0x51c ; 0x51c + af8: ce 01 movw r24, r28 + afa: 01 96 adiw r24, 0x01 ; 1 + afc: 7c 01 movw r14, r24 + afe: 4c 01 movw r8, r24 + b00: 8c 0c add r8, r12 + b02: 9d 1c adc r9, r13 + initializeForSendingData(); + + character fontData = findCorrespondingByte(charAsciiCode); + makeEnoughSpaceForPrinting(fontData.definition_total_bytes); + + for(unsigned int i = 0; i < fontData.definition_total_bytes; i++){ + b04: e8 14 cp r14, r8 + b06: f9 04 cpc r15, r9 + b08: 49 f0 breq .+18 ; 0xb1c <_ZN10Nokia_51106_printEh.constprop.6+0xec> + transmitInformation(fontData.definition[i]); + b0a: f7 01 movw r30, r14 + b0c: 62 81 ldd r22, Z+2 ; 0x02 + b0e: c8 01 movw r24, r16 + b10: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh> + b14: ff ef ldi r31, 0xFF ; 255 + b16: ef 1a sub r14, r31 + b18: ff 0a sbc r15, r31 + b1a: f4 cf rjmp .-24 ; 0xb04 <_ZN10Nokia_51106_printEh.constprop.6+0xd4> + } + + transmitInformation(0x0); // add an empty line after each chars + b1c: 60 e0 ldi r22, 0x00 ; 0 + b1e: c8 01 movw r24, r16 + b20: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh> + +/** + * Moves cursor in x axis by a number sepcified in method's parameter + */ +void Cursor::moveXAxis(position by){ + if(by == 0) + b24: 8f ef ldi r24, 0xFF ; 255 + b26: c8 16 cp r12, r24 + b28: d8 06 cpc r13, r24 + b2a: 99 f0 breq .+38 ; 0xb52 <_ZN10Nokia_51106_printEh.constprop.6+0x122> + return; + + _x++; + b2c: f8 01 movw r30, r16 + b2e: 80 89 ldd r24, Z+16 ; 0x10 + b30: 91 89 ldd r25, Z+17 ; 0x11 + b32: 01 96 adiw r24, 0x01 ; 1 + b34: 91 8b std Z+17, r25 ; 0x11 + b36: 80 8b std Z+16, r24 ; 0x10 + + if(_x > 83){ + b38: 84 35 cpi r24, 0x54 ; 84 + b3a: 91 05 cpc r25, r1 + b3c: 30 f0 brcs .+12 ; 0xb4a <_ZN10Nokia_51106_printEh.constprop.6+0x11a> + moveYAxis(1); + b3e: c5 01 movw r24, r10 + b40: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10> + _x = 0; + b44: f8 01 movw r30, r16 + b46: 11 8a std Z+17, r1 ; 0x11 + b48: 10 8a std Z+16, r1 ; 0x10 + b4a: f1 e0 ldi r31, 0x01 ; 1 + b4c: cf 1a sub r12, r31 + b4e: d1 08 sbc r13, r1 + b50: e9 cf rjmp .-46 ; 0xb24 <_ZN10Nokia_51106_printEh.constprop.6+0xf4> + _cursor.moveXAxis(fontData.definition_total_bytes + 1); +} + b52: 2a 96 adiw r28, 0x0a ; 10 + b54: 0f b6 in r0, 0x3f ; 63 + b56: f8 94 cli + b58: de bf out 0x3e, r29 ; 62 + b5a: 0f be out 0x3f, r0 ; 63 + b5c: cd bf out 0x3d, r28 ; 61 + b5e: df 91 pop r29 + b60: cf 91 pop r28 + b62: 1f 91 pop r17 + b64: 0f 91 pop r16 + b66: ff 90 pop r15 + b68: ef 90 pop r14 + b6a: df 90 pop r13 + b6c: cf 90 pop r12 + b6e: bf 90 pop r11 + b70: af 90 pop r10 + b72: 9f 90 pop r9 + b74: 8f 90 pop r8 + b76: 08 95 ret + +00000b78 <_ZN10Nokia_51105writeEh>: + extendedInstruction(); + execute(rate); +} + +size_t Nokia_5110::write(uint8_t character) { + _print(character); + b78: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6> + return 1; +} + b7c: 81 e0 ldi r24, 0x01 ; 1 + b7e: 90 e0 ldi r25, 0x00 ; 0 + b80: 08 95 ret + +00000b82 <__cxa_pure_virtual>: +extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); + +void __cxa_pure_virtual(void) { + // We might want to write some diagnostics to uart in this case + //std::terminate(); + abort(); + b82: 0e 94 8d 0a call 0x151a ; 0x151a + +00000b86 <__vector_16>: +#if defined(TIM0_OVF_vect) +ISR(TIM0_OVF_vect) +#else +ISR(TIMER0_OVF_vect) +#endif +{ + b86: 1f 92 push r1 + b88: 0f 92 push r0 + b8a: 0f b6 in r0, 0x3f ; 63 + b8c: 0f 92 push r0 + b8e: 11 24 eor r1, r1 + b90: 2f 93 push r18 + b92: 3f 93 push r19 + b94: 8f 93 push r24 + b96: 9f 93 push r25 + b98: af 93 push r26 + b9a: 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; + b9c: 80 91 4b 01 lds r24, 0x014B ; 0x80014b + ba0: 90 91 4c 01 lds r25, 0x014C ; 0x80014c + ba4: a0 91 4d 01 lds r26, 0x014D ; 0x80014d + ba8: b0 91 4e 01 lds r27, 0x014E ; 0x80014e + unsigned char f = timer0_fract; + bac: 30 91 4a 01 lds r19, 0x014A ; 0x80014a + + m += MILLIS_INC; + f += FRACT_INC; + bb0: 23 e0 ldi r18, 0x03 ; 3 + bb2: 23 0f add r18, r19 + if (f >= FRACT_MAX) { + bb4: 2d 37 cpi r18, 0x7D ; 125 + bb6: 20 f4 brcc .+8 ; 0xbc0 <__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; + bb8: 01 96 adiw r24, 0x01 ; 1 + bba: a1 1d adc r26, r1 + bbc: b1 1d adc r27, r1 + bbe: 05 c0 rjmp .+10 ; 0xbca <__vector_16+0x44> + f += FRACT_INC; + if (f >= FRACT_MAX) { + f -= FRACT_MAX; + bc0: 26 e8 ldi r18, 0x86 ; 134 + bc2: 23 0f add r18, r19 + m += 1; + bc4: 02 96 adiw r24, 0x02 ; 2 + bc6: a1 1d adc r26, r1 + bc8: b1 1d adc r27, r1 + } + + timer0_fract = f; + bca: 20 93 4a 01 sts 0x014A, r18 ; 0x80014a + timer0_millis = m; + bce: 80 93 4b 01 sts 0x014B, r24 ; 0x80014b + bd2: 90 93 4c 01 sts 0x014C, r25 ; 0x80014c + bd6: a0 93 4d 01 sts 0x014D, r26 ; 0x80014d + bda: b0 93 4e 01 sts 0x014E, r27 ; 0x80014e + timer0_overflow_count++; + bde: 80 91 4f 01 lds r24, 0x014F ; 0x80014f + be2: 90 91 50 01 lds r25, 0x0150 ; 0x800150 + be6: a0 91 51 01 lds r26, 0x0151 ; 0x800151 + bea: b0 91 52 01 lds r27, 0x0152 ; 0x800152 + bee: 01 96 adiw r24, 0x01 ; 1 + bf0: a1 1d adc r26, r1 + bf2: b1 1d adc r27, r1 + bf4: 80 93 4f 01 sts 0x014F, r24 ; 0x80014f + bf8: 90 93 50 01 sts 0x0150, r25 ; 0x800150 + bfc: a0 93 51 01 sts 0x0151, r26 ; 0x800151 + c00: b0 93 52 01 sts 0x0152, r27 ; 0x800152 +} + c04: bf 91 pop r27 + c06: af 91 pop r26 + c08: 9f 91 pop r25 + c0a: 8f 91 pop r24 + c0c: 3f 91 pop r19 + c0e: 2f 91 pop r18 + c10: 0f 90 pop r0 + c12: 0f be out 0x3f, r0 ; 63 + c14: 0f 90 pop r0 + c16: 1f 90 pop r1 + c18: 18 95 reti + +00000c1a <__vector_19>: +#elif defined(USART_UDRE_vect) +ISR(USART_UDRE_vect) +#else + #error "Don't know what the Data Register Empty vector is called for Serial" +#endif +{ + c1a: 1f 92 push r1 + c1c: 0f 92 push r0 + c1e: 0f b6 in r0, 0x3f ; 63 + c20: 0f 92 push r0 + c22: 11 24 eor r1, r1 + c24: 2f 93 push r18 + c26: 3f 93 push r19 + c28: 4f 93 push r20 + c2a: 5f 93 push r21 + c2c: 6f 93 push r22 + c2e: 7f 93 push r23 + c30: 8f 93 push r24 + c32: 9f 93 push r25 + c34: af 93 push r26 + c36: bf 93 push r27 + c38: ef 93 push r30 + c3a: ff 93 push r31 + Serial._tx_udr_empty_irq(); + c3c: 83 e5 ldi r24, 0x53 ; 83 + c3e: 91 e0 ldi r25, 0x01 ; 1 + c40: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv> +} + c44: ff 91 pop r31 + c46: ef 91 pop r30 + c48: bf 91 pop r27 + c4a: af 91 pop r26 + c4c: 9f 91 pop r25 + c4e: 8f 91 pop r24 + c50: 7f 91 pop r23 + c52: 6f 91 pop r22 + c54: 5f 91 pop r21 + c56: 4f 91 pop r20 + c58: 3f 91 pop r19 + c5a: 2f 91 pop r18 + c5c: 0f 90 pop r0 + c5e: 0f be out 0x3f, r0 ; 63 + c60: 0f 90 pop r0 + c62: 1f 90 pop r1 + c64: 18 95 reti + +00000c66 <__vector_18>: +#elif defined(USART_RXC_vect) + ISR(USART_RXC_vect) // ATmega8 +#else + #error "Don't know what the Data Received vector is called for Serial" +#endif + { + c66: 1f 92 push r1 + c68: 0f 92 push r0 + c6a: 0f b6 in r0, 0x3f ; 63 + c6c: 0f 92 push r0 + c6e: 11 24 eor r1, r1 + c70: 2f 93 push r18 + c72: 8f 93 push r24 + c74: 9f 93 push r25 + c76: ef 93 push r30 + c78: ff 93 push r31 + +// Actual interrupt handlers ////////////////////////////////////////////////////////////// + +void HardwareSerial::_rx_complete_irq(void) +{ + if (bit_is_clear(*_ucsra, UPE0)) { + c7a: e0 91 63 01 lds r30, 0x0163 ; 0x800163 + c7e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 + c82: 80 81 ld r24, Z + c84: e0 91 69 01 lds r30, 0x0169 ; 0x800169 + c88: f0 91 6a 01 lds r31, 0x016A ; 0x80016a + c8c: 82 fd sbrc r24, 2 + c8e: 12 c0 rjmp .+36 ; 0xcb4 <__vector_18+0x4e> + // No Parity error, read byte and store it in the buffer if there is + // room + unsigned char c = *_udr; + c90: 90 81 ld r25, Z + rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE; + c92: 80 91 6c 01 lds r24, 0x016C ; 0x80016c + c96: 8f 5f subi r24, 0xFF ; 255 + c98: 8f 73 andi r24, 0x3F ; 63 + + // if we should be storing the received character into the location + // just before the tail (meaning that the head would advance to the + // current location of the tail), we're about to overflow the buffer + // and so we don't write the character or advance the head. + if (i != _rx_buffer_tail) { + c9a: 20 91 6d 01 lds r18, 0x016D ; 0x80016d + c9e: 82 17 cp r24, r18 + ca0: 51 f0 breq .+20 ; 0xcb6 <__vector_18+0x50> + _rx_buffer[_rx_buffer_head] = c; + ca2: e0 91 6c 01 lds r30, 0x016C ; 0x80016c + ca6: f0 e0 ldi r31, 0x00 ; 0 + ca8: ed 5a subi r30, 0xAD ; 173 + caa: fe 4f sbci r31, 0xFE ; 254 + cac: 95 8f std Z+29, r25 ; 0x1d + _rx_buffer_head = i; + cae: 80 93 6c 01 sts 0x016C, r24 ; 0x80016c + cb2: 01 c0 rjmp .+2 ; 0xcb6 <__vector_18+0x50> + } + } else { + // Parity error, read byte but discard it + *_udr; + cb4: 80 81 ld r24, Z + Serial._rx_complete_irq(); + } + cb6: ff 91 pop r31 + cb8: ef 91 pop r30 + cba: 9f 91 pop r25 + cbc: 8f 91 pop r24 + cbe: 2f 91 pop r18 + cc0: 0f 90 pop r0 + cc2: 0f be out 0x3f, r0 ; 63 + cc4: 0f 90 pop r0 + cc6: 1f 90 pop r1 + cc8: 18 95 reti + +00000cca <_GLOBAL__I_65535_0_BasicPHSensor.ino.cpp.o.2007>: + cca: cf 93 push r28 + ccc: df 93 push r29 + size_t printNumber(unsigned long, uint8_t); + size_t printFloat(double, uint8_t); + protected: + void setWriteError(int err = 1) { write_error = err; } + public: + Print() : write_error(0) {} + cce: e3 e5 ldi r30, 0x53 ; 83 + cd0: f1 e0 ldi r31, 0x01 ; 1 + cd2: 13 82 std Z+3, r1 ; 0x03 + cd4: 12 82 std Z+2, r1 ; 0x02 + public: + virtual int available() = 0; + virtual int read() = 0; + virtual int peek() = 0; + + Stream() {_timeout=1000;} + cd6: 88 ee ldi r24, 0xE8 ; 232 + cd8: 93 e0 ldi r25, 0x03 ; 3 + cda: a0 e0 ldi r26, 0x00 ; 0 + cdc: b0 e0 ldi r27, 0x00 ; 0 + cde: 84 83 std Z+4, r24 ; 0x04 + ce0: 95 83 std Z+5, r25 ; 0x05 + ce2: a6 83 std Z+6, r26 ; 0x06 + ce4: b7 83 std Z+7, r27 ; 0x07 + volatile uint8_t *ucsrc, volatile uint8_t *udr) : + _ubrrh(ubrrh), _ubrrl(ubrrl), + _ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc), + _udr(udr), + _rx_buffer_head(0), _rx_buffer_tail(0), + _tx_buffer_head(0), _tx_buffer_tail(0) + ce6: 84 e0 ldi r24, 0x04 ; 4 + ce8: 91 e0 ldi r25, 0x01 ; 1 + cea: 91 83 std Z+1, r25 ; 0x01 + cec: 80 83 st Z, r24 + cee: 85 ec ldi r24, 0xC5 ; 197 + cf0: 90 e0 ldi r25, 0x00 ; 0 + cf2: 95 87 std Z+13, r25 ; 0x0d + cf4: 84 87 std Z+12, r24 ; 0x0c + cf6: 84 ec ldi r24, 0xC4 ; 196 + cf8: 90 e0 ldi r25, 0x00 ; 0 + cfa: 97 87 std Z+15, r25 ; 0x0f + cfc: 86 87 std Z+14, r24 ; 0x0e + cfe: 80 ec ldi r24, 0xC0 ; 192 + d00: 90 e0 ldi r25, 0x00 ; 0 + d02: 91 8b std Z+17, r25 ; 0x11 + d04: 80 8b std Z+16, r24 ; 0x10 + d06: 81 ec ldi r24, 0xC1 ; 193 + d08: 90 e0 ldi r25, 0x00 ; 0 + d0a: 93 8b std Z+19, r25 ; 0x13 + d0c: 82 8b std Z+18, r24 ; 0x12 + d0e: 82 ec ldi r24, 0xC2 ; 194 + d10: 90 e0 ldi r25, 0x00 ; 0 + d12: 95 8b std Z+21, r25 ; 0x15 + d14: 84 8b std Z+20, r24 ; 0x14 + d16: 86 ec ldi r24, 0xC6 ; 198 + d18: 90 e0 ldi r25, 0x00 ; 0 + d1a: 97 8b std Z+23, r25 ; 0x17 + d1c: 86 8b std Z+22, r24 ; 0x16 + d1e: 11 8e std Z+25, r1 ; 0x19 + d20: 12 8e std Z+26, r1 ; 0x1a + d22: 13 8e std Z+27, r1 ; 0x1b + d24: 14 8e std Z+28, r1 ; 0x1c + d26: c0 ef ldi r28, 0xF0 ; 240 + d28: d1 e0 ldi r29, 0x01 ; 1 + d2a: 1b 82 std Y+3, r1 ; 0x03 + d2c: 1a 82 std Y+2, r1 ; 0x02 +#include "Nokia_5110.h" +#include "Font.h" + +Nokia_5110::Nokia_5110(){} + +Nokia_5110::Nokia_5110(unsigned short RST, unsigned short CE, unsigned short DC, unsigned short DIN, unsigned short CLK){ + d2e: 86 e1 ldi r24, 0x16 ; 22 + d30: 91 e0 ldi r25, 0x01 ; 1 + d32: 99 83 std Y+1, r25 ; 0x01 + d34: 88 83 st Y, r24 +struct Position { + position y; + position x; +}; + +class Cursor { + d36: 1f 86 std Y+15, r1 ; 0x0f + d38: 1e 86 std Y+14, r1 ; 0x0e + d3a: 19 8a std Y+17, r1 ; 0x11 + d3c: 18 8a std Y+16, r1 ; 0x10 + _RST = RST; + d3e: 83 e0 ldi r24, 0x03 ; 3 + d40: 90 e0 ldi r25, 0x00 ; 0 + d42: 9d 83 std Y+5, r25 ; 0x05 + d44: 8c 83 std Y+4, r24 ; 0x04 + _CE = CE; + d46: 84 e0 ldi r24, 0x04 ; 4 + d48: 90 e0 ldi r25, 0x00 ; 0 + d4a: 9f 83 std Y+7, r25 ; 0x07 + d4c: 8e 83 std Y+6, r24 ; 0x06 + _DC = DC; + d4e: 85 e0 ldi r24, 0x05 ; 5 + d50: 90 e0 ldi r25, 0x00 ; 0 + d52: 99 87 std Y+9, r25 ; 0x09 + d54: 88 87 std Y+8, r24 ; 0x08 + _DIN = DIN; + d56: 86 e0 ldi r24, 0x06 ; 6 + d58: 90 e0 ldi r25, 0x00 ; 0 + d5a: 9b 87 std Y+11, r25 ; 0x0b + d5c: 8a 87 std Y+10, r24 ; 0x0a + _CLK = CLK; + d5e: 87 e0 ldi r24, 0x07 ; 7 + d60: 90 e0 ldi r25, 0x00 ; 0 + d62: 9d 87 std Y+13, r25 ; 0x0d + d64: 8c 87 std Y+12, r24 ; 0x0c + + pinMode(RST, OUTPUT); + d66: 83 e0 ldi r24, 0x03 ; 3 + d68: 0e 94 62 02 call 0x4c4 ; 0x4c4 + pinMode(CE, OUTPUT); + d6c: 84 e0 ldi r24, 0x04 ; 4 + d6e: 0e 94 62 02 call 0x4c4 ; 0x4c4 + pinMode(DC, OUTPUT); + d72: 85 e0 ldi r24, 0x05 ; 5 + d74: 0e 94 62 02 call 0x4c4 ; 0x4c4 + pinMode(DIN, OUTPUT); + d78: 86 e0 ldi r24, 0x06 ; 6 + d7a: 0e 94 62 02 call 0x4c4 ; 0x4c4 + pinMode(CLK, OUTPUT); + d7e: 87 e0 ldi r24, 0x07 ; 7 + d80: 0e 94 62 02 call 0x4c4 ; 0x4c4 + + _cursor = Cursor(); + d84: 1f 86 std Y+15, r1 ; 0x0f + d86: 1e 86 std Y+14, r1 ; 0x0e + d88: 19 8a std Y+17, r1 ; 0x11 + d8a: 18 8a std Y+16, r1 ; 0x10 + const unsigned short leastValue = 4; + execute(byte(leastValue + value)); +} + +void Nokia_5110::reset(){ + digitalWrite(_RST, LOW); + d8c: 60 e0 ldi r22, 0x00 ; 0 + d8e: 8c 81 ldd r24, Y+4 ; 0x04 + d90: 0e 94 8e 02 call 0x51c ; 0x51c + digitalWrite(_RST, HIGH); + d94: 61 e0 ldi r22, 0x01 ; 1 + d96: 8c 81 ldd r24, Y+4 ; 0x04 + d98: 0e 94 8e 02 call 0x51c ; 0x51c + + _cursor = Cursor(); + + reset(); + + clear(); + d9c: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31> +void Nokia_5110::extendedInstruction(){ + execute(0x21); +} + +void Nokia_5110::basicInstruction(){ + execute(0x20); + da0: 60 e2 ldi r22, 0x20 ; 32 + da2: ce 01 movw r24, r28 + da4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> +} + + +void Nokia_5110::setDisplayMode(display_mode value){ + basicInstruction(); + execute(value); + da8: 6c e0 ldi r22, 0x0C ; 12 + daa: ce 01 movw r24, r28 + dac: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + const unsigned short leastValue = 128; + execute(byte(leastValue + value)); +} + +void Nokia_5110::extendedInstruction(){ + execute(0x21); + db0: 61 e2 ldi r22, 0x21 ; 33 + db2: ce 01 movw r24, r28 + db4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> +} + + +void Nokia_5110::setBiasSystem(mux_rate rate){ + extendedInstruction(); + execute(rate); + db8: 64 e1 ldi r22, 0x14 ; 20 + dba: ce 01 movw r24, r28 + dbc: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + const unsigned short leastValue = 128; + execute(byte(leastValue + value)); +} + +void Nokia_5110::extendedInstruction(){ + execute(0x21); + dc0: 61 e2 ldi r22, 0x21 ; 33 + dc2: ce 01 movw r24, r28 + dc4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + return; + + extendedInstruction(); + + const unsigned short leastValue = 128; + execute(byte(leastValue + value)); + dc8: 6c eb ldi r22, 0xBC ; 188 + dca: ce 01 movw r24, r28 + dcc: df 91 pop r29 + dce: cf 91 pop r28 + dd0: 0c 94 d2 04 jmp 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + +00000dd4
: + +void init() +{ + // this needs to be called before setup() or some functions won't + // work there + sei(); + dd4: 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); + dd6: 84 b5 in r24, 0x24 ; 36 + dd8: 82 60 ori r24, 0x02 ; 2 + dda: 84 bd out 0x24, r24 ; 36 + sbi(TCCR0A, WGM00); + ddc: 84 b5 in r24, 0x24 ; 36 + dde: 81 60 ori r24, 0x01 ; 1 + de0: 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); + de2: 85 b5 in r24, 0x25 ; 37 + de4: 82 60 ori r24, 0x02 ; 2 + de6: 85 bd out 0x25, r24 ; 37 + sbi(TCCR0B, CS00); + de8: 85 b5 in r24, 0x25 ; 37 + dea: 81 60 ori r24, 0x01 ; 1 + dec: 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); + dee: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + df2: 81 60 ori r24, 0x01 ; 1 + df4: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e> + // 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; + df8: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + + // set timer 1 prescale factor to 64 + sbi(TCCR1B, CS11); + dfc: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + e00: 82 60 ori r24, 0x02 ; 2 + e02: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> +#if F_CPU >= 8000000L + sbi(TCCR1B, CS10); + e06: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + e0a: 81 60 ori r24, 0x01 ; 1 + e0c: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081> + sbi(TCCR1, CS10); +#endif +#endif + // put timer 1 in 8-bit phase correct pwm mode +#if defined(TCCR1A) && defined(WGM10) + sbi(TCCR1A, WGM10); + e10: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + e14: 81 60 ori r24, 0x01 ; 1 + e16: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080> + + // set timer 2 prescale factor to 64 +#if defined(TCCR2) && defined(CS22) + sbi(TCCR2, CS22); +#elif defined(TCCR2B) && defined(CS22) + sbi(TCCR2B, CS22); + e1a: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + e1e: 84 60 ori r24, 0x04 ; 4 + e20: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1> + + // 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); + e24: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> + e28: 81 60 ori r24, 0x01 ; 1 + e2a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0> +#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); + e2e: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + e32: 84 60 ori r24, 0x04 ; 4 + e34: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + sbi(ADCSRA, ADPS1); + e38: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + e3c: 82 60 ori r24, 0x02 ; 2 + e3e: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + sbi(ADCSRA, ADPS0); + e42: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + e46: 81 60 ori r24, 0x01 ; 1 + e48: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + cbi(ADCSRA, ADPS2); + cbi(ADCSRA, ADPS1); + sbi(ADCSRA, ADPS0); + #endif + // enable a2d conversions + sbi(ADCSRA, ADEN); + e4c: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + e50: 80 68 ori r24, 0x80 ; 128 + e52: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + // 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; + e56: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> + +void HardwareSerial::begin(unsigned long baud, byte config) +{ + // Try u2x mode first + uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2; + *_ucsra = 1 << U2X0; + e5a: e0 91 63 01 lds r30, 0x0163 ; 0x800163 + e5e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 + e62: 82 e0 ldi r24, 0x02 ; 2 + e64: 80 83 st Z, r24 + *_ucsra = 0; + baud_setting = (F_CPU / 8 / baud - 1) / 2; + } + + // assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register) + *_ubrrh = baud_setting >> 8; + e66: e0 91 5f 01 lds r30, 0x015F ; 0x80015f + e6a: f0 91 60 01 lds r31, 0x0160 ; 0x800160 + e6e: 10 82 st Z, r1 + *_ubrrl = baud_setting; + e70: e0 91 61 01 lds r30, 0x0161 ; 0x800161 + e74: f0 91 62 01 lds r31, 0x0162 ; 0x800162 + e78: 8f ec ldi r24, 0xCF ; 207 + e7a: 80 83 st Z, r24 + + _written = false; + e7c: 10 92 6b 01 sts 0x016B, r1 ; 0x80016b + + //set the data bits, parity, and stop bits +#if defined(__AVR_ATmega8__) + config |= 0x80; // select UCSRC register (shared with UBRRH) +#endif + *_ucsrc = config; + e80: e0 91 67 01 lds r30, 0x0167 ; 0x800167 + e84: f0 91 68 01 lds r31, 0x0168 ; 0x800168 + e88: 86 e0 ldi r24, 0x06 ; 6 + e8a: 80 83 st Z, r24 + + sbi(*_ucsrb, RXEN0); + e8c: e0 91 65 01 lds r30, 0x0165 ; 0x800165 + e90: f0 91 66 01 lds r31, 0x0166 ; 0x800166 + e94: 80 81 ld r24, Z + e96: 80 61 ori r24, 0x10 ; 16 + e98: 80 83 st Z, r24 + sbi(*_ucsrb, TXEN0); + e9a: e0 91 65 01 lds r30, 0x0165 ; 0x800165 + e9e: f0 91 66 01 lds r31, 0x0166 ; 0x800166 + ea2: 80 81 ld r24, Z + ea4: 88 60 ori r24, 0x08 ; 8 + ea6: 80 83 st Z, r24 + sbi(*_ucsrb, RXCIE0); + ea8: e0 91 65 01 lds r30, 0x0165 ; 0x800165 + eac: f0 91 66 01 lds r31, 0x0166 ; 0x800166 + eb0: 80 81 ld r24, Z + eb2: 80 68 ori r24, 0x80 ; 128 + eb4: 80 83 st Z, r24 + cbi(*_ucsrb, UDRIE0); + eb6: e0 91 65 01 lds r30, 0x0165 ; 0x800165 + eba: f0 91 66 01 lds r31, 0x0166 ; 0x800166 + ebe: 80 81 ld r24, Z + ec0: 8f 7d andi r24, 0xDF ; 223 + ec2: 80 83 st Z, r24 +} + +void Nokia_5110::extendedInstruction(){ + execute(0x21); + ec4: 61 e2 ldi r22, 0x21 ; 33 + ec6: 80 ef ldi r24, 0xF0 ; 240 + ec8: 91 e0 ldi r25, 0x01 ; 1 + eca: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + return; + + extendedInstruction(); + + const unsigned short leastValue = 128; + execute(byte(leastValue + value)); + ece: 6c e9 ldi r22, 0x9C ; 156 + ed0: 80 ef ldi r24, 0xF0 ; 240 + ed2: 91 e0 ldi r25, 0x01 ; 1 + ed4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh> + * Note: if instead of text being shown on the display, all the segments are on, you may need to decrease contrast value. + */ + lcd.setContrast(28); // 60 is the default value set by the driver + + //lcd.print("Please Wait ..."); + lcd.setCursor(15,1); + ed8: 41 e0 ldi r20, 0x01 ; 1 + eda: 50 e0 ldi r21, 0x00 ; 0 + edc: 6f e0 ldi r22, 0x0F ; 15 + ede: 70 e0 ldi r23, 0x00 ; 0 + ee0: 80 ef ldi r24, 0xF0 ; 240 + ee2: 91 e0 ldi r25, 0x01 ; 1 + ee4: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + ee8: 8e e1 ldi r24, 0x1E ; 30 + eea: 91 e0 ldi r25, 0x01 ; 1 + eec: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + lcd.print("Starting..."); + delay(800); + ef0: 60 e2 ldi r22, 0x20 ; 32 + ef2: 73 e0 ldi r23, 0x03 ; 3 + ef4: 80 e0 ldi r24, 0x00 ; 0 + ef6: 90 e0 ldi r25, 0x00 ; 0 + ef8: 0e 94 00 03 call 0x600 ; 0x600 + lcd.clear(); + efc: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31> + // to 0 (the default). +#if defined(ADMUX) +#if defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) + ADMUX = (analog_reference << 4) | (pin & 0x07); +#else + ADMUX = (analog_reference << 6) | (pin & 0x07); + f00: c3 e4 ldi r28, 0x43 ; 67 + //lcd.setCursor(0, 5); + //lcd.println("1 2 3 ..."); +} + +void loop() { + lcd.clear(); + f02: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31> + f06: c0 93 7c 00 sts 0x007C, r28 ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c> + // without a delay, we seem to read from the wrong channel + //delay(1); + +#if defined(ADCSRA) && defined(ADCL) + // start the conversion + sbi(ADCSRA, ADSC); + f0a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + f0e: 80 64 ori r24, 0x40 ; 64 + f10: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + + // ADSC is cleared when the conversion finishes + while (bit_is_set(ADCSRA, ADSC)); + f14: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a> + f18: 86 fd sbrc r24, 6 + f1a: fc cf rjmp .-8 ; 0xf14 + + // we have to read ADCL first; doing so locks both ADCL + // and ADCH until ADCH is read. reading ADCL second would + // cause the results of each conversion to be discarded, + // as ADCL and ADCH would be locked when it completed. + low = ADCL; + f1c: 60 91 78 00 lds r22, 0x0078 ; 0x800078 <__TEXT_REGION_LENGTH__+0x7e0078> + high = ADCH; + f20: 80 91 79 00 lds r24, 0x0079 ; 0x800079 <__TEXT_REGION_LENGTH__+0x7e0079> + phVal_u16 = analogRead(PHSENSOR); + f24: 70 e0 ldi r23, 0x00 ; 0 + f26: 78 2b or r23, r24 + f28: 70 93 49 01 sts 0x0149, r23 ; 0x800149 + f2c: 60 93 48 01 sts 0x0148, r22 ; 0x800148 + phFloat = phVal_u16 * 0.013672; + f30: 80 e0 ldi r24, 0x00 ; 0 + f32: 90 e0 ldi r25, 0x00 ; 0 + f34: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf> + f38: 26 e8 ldi r18, 0x86 ; 134 + f3a: 30 e0 ldi r19, 0x00 ; 0 + f3c: 40 e6 ldi r20, 0x60 ; 96 + f3e: 5c e3 ldi r21, 0x3C ; 60 + f40: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3> + f44: 60 93 44 01 sts 0x0144, r22 ; 0x800144 <__data_end> + f48: 70 93 45 01 sts 0x0145, r23 ; 0x800145 <__data_end+0x1> + f4c: 80 93 46 01 sts 0x0146, r24 ; 0x800146 <__data_end+0x2> + f50: 90 93 47 01 sts 0x0147, r25 ; 0x800147 <__data_end+0x3> + lcd.setCursor(15,1); + f54: 41 e0 ldi r20, 0x01 ; 1 + f56: 50 e0 ldi r21, 0x00 ; 0 + f58: 6f e0 ldi r22, 0x0F ; 15 + f5a: 70 e0 ldi r23, 0x00 ; 0 + f5c: 80 ef ldi r24, 0xF0 ; 240 + f5e: 91 e0 ldi r25, 0x01 ; 1 + f60: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + f64: 8a e2 ldi r24, 0x2A ; 42 + f66: 91 e0 ldi r25, 0x01 ; 1 + f68: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + return x.printTo(*this); +} + +size_t Print::println(void) +{ + return write("\r\n"); + f6c: 8f e2 ldi r24, 0x2F ; 47 + f6e: 91 e0 ldi r25, 0x01 ; 1 + f70: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + lcd.println("Raw:"); + lcd.setCursor(45,2); + f74: 42 e0 ldi r20, 0x02 ; 2 + f76: 50 e0 ldi r21, 0x00 ; 0 + f78: 6d e2 ldi r22, 0x2D ; 45 + f7a: 70 e0 ldi r23, 0x00 ; 0 + f7c: 80 ef ldi r24, 0xF0 ; 240 + f7e: 91 e0 ldi r25, 0x01 ; 1 + f80: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> +} + +size_t Print::print(unsigned long n, int base) +{ + if (base == 0) return write(n); + else return printNumber(n, base); + f84: 60 91 48 01 lds r22, 0x0148 ; 0x800148 + f88: 70 91 49 01 lds r23, 0x0149 ; 0x800149 + f8c: 80 e0 ldi r24, 0x00 ; 0 + f8e: 90 e0 ldi r25, 0x00 ; 0 + f90: 4a e0 ldi r20, 0x0A ; 10 + f92: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20> + lcd.print(phVal_u16); + lcd.setCursor(15,3); + f96: 43 e0 ldi r20, 0x03 ; 3 + f98: 50 e0 ldi r21, 0x00 ; 0 + f9a: 6f e0 ldi r22, 0x0F ; 15 + f9c: 70 e0 ldi r23, 0x00 ; 0 + f9e: 80 ef ldi r24, 0xF0 ; 240 + fa0: 91 e0 ldi r25, 0x01 ; 1 + fa2: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + fa6: 82 e3 ldi r24, 0x32 ; 50 + fa8: 91 e0 ldi r25, 0x01 ; 1 + faa: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + return x.printTo(*this); +} + +size_t Print::println(void) +{ + return write("\r\n"); + fae: 8f e2 ldi r24, 0x2F ; 47 + fb0: 91 e0 ldi r25, 0x01 ; 1 + fb2: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + lcd.println("PH #:"); + lcd.setCursor(45,4); + fb6: 44 e0 ldi r20, 0x04 ; 4 + fb8: 50 e0 ldi r21, 0x00 ; 0 + fba: 6d e2 ldi r22, 0x2D ; 45 + fbc: 70 e0 ldi r23, 0x00 ; 0 + fbe: 80 ef ldi r24, 0xF0 ; 240 + fc0: 91 e0 ldi r25, 0x01 ; 1 + fc2: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt> + lcd.print(phFloat); + fc6: c0 90 44 01 lds r12, 0x0144 ; 0x800144 <__data_end> + fca: d0 90 45 01 lds r13, 0x0145 ; 0x800145 <__data_end+0x1> + fce: e0 90 46 01 lds r14, 0x0146 ; 0x800146 <__data_end+0x2> + fd2: f0 90 47 01 lds r15, 0x0147 ; 0x800147 <__data_end+0x3> + +size_t Print::printFloat(double number, uint8_t digits) +{ + size_t n = 0; + + if (isnan(number)) return print("nan"); + fd6: a7 01 movw r20, r14 + fd8: 96 01 movw r18, r12 + fda: c7 01 movw r24, r14 + fdc: b6 01 movw r22, r12 + fde: 0e 94 60 0a call 0x14c0 ; 0x14c0 <__unordsf2> + fe2: 88 23 and r24, r24 + fe4: 19 f0 breq .+6 ; 0xfec + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + fe6: 88 e3 ldi r24, 0x38 ; 56 + fe8: 91 e0 ldi r25, 0x01 ; 1 + fea: 1a c0 rjmp .+52 ; 0x1020 +size_t Print::printFloat(double number, uint8_t digits) +{ + size_t n = 0; + + if (isnan(number)) return print("nan"); + if (isinf(number)) return print("inf"); + fec: 46 01 movw r8, r12 + fee: 57 01 movw r10, r14 + ff0: e8 94 clt + ff2: b7 f8 bld r11, 7 + ff4: 2f ef ldi r18, 0xFF ; 255 + ff6: 3f ef ldi r19, 0xFF ; 255 + ff8: 4f e7 ldi r20, 0x7F ; 127 + ffa: 5f e7 ldi r21, 0x7F ; 127 + ffc: c5 01 movw r24, r10 + ffe: b4 01 movw r22, r8 + 1000: 0e 94 60 0a call 0x14c0 ; 0x14c0 <__unordsf2> + 1004: 81 11 cpse r24, r1 + 1006: 0f c0 rjmp .+30 ; 0x1026 + 1008: 2f ef ldi r18, 0xFF ; 255 + 100a: 3f ef ldi r19, 0xFF ; 255 + 100c: 4f e7 ldi r20, 0x7F ; 127 + 100e: 5f e7 ldi r21, 0x7F ; 127 + 1010: c5 01 movw r24, r10 + 1012: b4 01 movw r22, r8 + 1014: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2> + 1018: 18 16 cp r1, r24 + 101a: 2c f4 brge .+10 ; 0x1026 + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + 101c: 8c e3 ldi r24, 0x3C ; 60 + 101e: 91 e0 ldi r25, 0x01 ; 1 + 1020: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24> + 1024: 76 c0 rjmp .+236 ; 0x1112 +{ + size_t n = 0; + + if (isnan(number)) return print("nan"); + if (isinf(number)) return print("inf"); + if (number > 4294967040.0) return print ("ovf"); // constant determined empirically + 1026: 2f ef ldi r18, 0xFF ; 255 + 1028: 3f ef ldi r19, 0xFF ; 255 + 102a: 4f e7 ldi r20, 0x7F ; 127 + 102c: 5f e4 ldi r21, 0x4F ; 79 + 102e: c7 01 movw r24, r14 + 1030: b6 01 movw r22, r12 + 1032: 0e 94 ee 09 call 0x13dc ; 0x13dc <__gesf2> + 1036: 18 16 cp r1, r24 + 1038: 1c f4 brge .+6 ; 0x1040 + return write(s.c_str(), s.length()); +} + +size_t Print::print(const char str[]) +{ + return write(str); + 103a: 80 e4 ldi r24, 0x40 ; 64 + 103c: 91 e0 ldi r25, 0x01 ; 1 + 103e: f0 cf rjmp .-32 ; 0x1020 + size_t n = 0; + + if (isnan(number)) return print("nan"); + if (isinf(number)) return print("inf"); + if (number > 4294967040.0) return print ("ovf"); // constant determined empirically + if (number <-4294967040.0) return print ("ovf"); // constant determined empirically + 1040: 2f ef ldi r18, 0xFF ; 255 + 1042: 3f ef ldi r19, 0xFF ; 255 + 1044: 4f e7 ldi r20, 0x7F ; 127 + 1046: 5f ec ldi r21, 0xCF ; 207 + 1048: c7 01 movw r24, r14 + 104a: b6 01 movw r22, r12 + 104c: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2> + 1050: 87 fd sbrc r24, 7 + 1052: f3 cf rjmp .-26 ; 0x103a + + // Handle negative numbers + if (number < 0.0) + 1054: 20 e0 ldi r18, 0x00 ; 0 + 1056: 30 e0 ldi r19, 0x00 ; 0 + 1058: a9 01 movw r20, r18 + 105a: c7 01 movw r24, r14 + 105c: b6 01 movw r22, r12 + 105e: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2> + 1062: 87 ff sbrs r24, 7 + 1064: 09 c0 rjmp .+18 ; 0x1078 + extendedInstruction(); + execute(rate); +} + +size_t Nokia_5110::write(uint8_t character) { + _print(character); + 1066: 6d e2 ldi r22, 0x2D ; 45 + 1068: 80 ef ldi r24, 0xF0 ; 240 + 106a: 91 e0 ldi r25, 0x01 ; 1 + 106c: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6> + { + n += print('-'); + number = -number; + 1070: f7 fa bst r15, 7 + 1072: f0 94 com r15 + 1074: f7 f8 bld r15, 7 + 1076: f0 94 com r15 + // Round correctly so that print(1.999, 2) prints as "2.00" + double rounding = 0.5; + for (uint8_t i=0; i + 1088: 4b 01 movw r8, r22 + 108a: 5c 01 movw r10, r24 + + // Extract the integer part of the number and print it + unsigned long int_part = (unsigned long)number; + 108c: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi> + 1090: 6b 01 movw r12, r22 + 1092: 7c 01 movw r14, r24 + double remainder = number - (double)int_part; + 1094: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf> + 1098: 9b 01 movw r18, r22 + 109a: ac 01 movw r20, r24 + 109c: c5 01 movw r24, r10 + 109e: b4 01 movw r22, r8 + 10a0: 0e 94 9b 08 call 0x1136 ; 0x1136 <__subsf3> + 10a4: 4b 01 movw r8, r22 + 10a6: 5c 01 movw r10, r24 +} + +size_t Print::print(unsigned long n, int base) +{ + if (base == 0) return write(n); + else return printNumber(n, base); + 10a8: 4a e0 ldi r20, 0x0A ; 10 + 10aa: c7 01 movw r24, r14 + 10ac: b6 01 movw r22, r12 + 10ae: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20> + 10b2: 6e e2 ldi r22, 0x2E ; 46 + 10b4: 80 ef ldi r24, 0xF0 ; 240 + 10b6: 91 e0 ldi r25, 0x01 ; 1 + 10b8: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6> + } + + // Extract digits from the remainder one at a time + while (digits-- > 0) + { + remainder *= 10.0; + 10bc: 20 e0 ldi r18, 0x00 ; 0 + 10be: 30 e0 ldi r19, 0x00 ; 0 + 10c0: 40 e2 ldi r20, 0x20 ; 32 + 10c2: 51 e4 ldi r21, 0x41 ; 65 + 10c4: c5 01 movw r24, r10 + 10c6: b4 01 movw r22, r8 + 10c8: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3> + 10cc: 4b 01 movw r8, r22 + 10ce: 5c 01 movw r10, r24 + unsigned int toPrint = (unsigned int)(remainder); + 10d0: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi> +} + +size_t Print::print(unsigned long n, int base) +{ + if (base == 0) return write(n); + else return printNumber(n, base); + 10d4: 6b 01 movw r12, r22 + 10d6: e1 2c mov r14, r1 + 10d8: f1 2c mov r15, r1 + 10da: 4a e0 ldi r20, 0x0A ; 10 + 10dc: c7 01 movw r24, r14 + 10de: b6 01 movw r22, r12 + 10e0: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20> + while (digits-- > 0) + { + remainder *= 10.0; + unsigned int toPrint = (unsigned int)(remainder); + n += print(toPrint); + remainder -= toPrint; + 10e4: c7 01 movw r24, r14 + 10e6: b6 01 movw r22, r12 + 10e8: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf> + 10ec: 9b 01 movw r18, r22 + 10ee: ac 01 movw r20, r24 + 10f0: c5 01 movw r24, r10 + 10f2: b4 01 movw r22, r8 + 10f4: 0e 94 9b 08 call 0x1136 ; 0x1136 <__subsf3> +} + +size_t Print::print(unsigned long n, int base) +{ + if (base == 0) return write(n); + else return printNumber(n, base); + 10f8: 20 e0 ldi r18, 0x00 ; 0 + 10fa: 30 e0 ldi r19, 0x00 ; 0 + 10fc: 40 e2 ldi r20, 0x20 ; 32 + 10fe: 51 e4 ldi r21, 0x41 ; 65 + 1100: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3> + 1104: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi> + 1108: 80 e0 ldi r24, 0x00 ; 0 + 110a: 90 e0 ldi r25, 0x00 ; 0 + 110c: 4a e0 ldi r20, 0x0A ; 10 + 110e: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20> + //Serial.println(phVal_u16); + delay(1000); + 1112: 68 ee ldi r22, 0xE8 ; 232 + 1114: 73 e0 ldi r23, 0x03 ; 3 + 1116: 80 e0 ldi r24, 0x00 ; 0 + 1118: 90 e0 ldi r25, 0x00 ; 0 + 111a: 0e 94 00 03 call 0x600 ; 0x600 + + setup(); + + for (;;) { + loop(); + if (serialEventRun) serialEventRun(); + 111e: 0e 94 3c 04 call 0x878 ; 0x878 <_Z14serialEventRunv> + 1122: ef ce rjmp .-546 ; 0xf02 + +00001124 : + 1124: fb 01 movw r30, r22 + 1126: dc 01 movw r26, r24 + 1128: 02 c0 rjmp .+4 ; 0x112e + 112a: 05 90 lpm r0, Z+ + 112c: 0d 92 st X+, r0 + 112e: 41 50 subi r20, 0x01 ; 1 + 1130: 50 40 sbci r21, 0x00 ; 0 + 1132: d8 f7 brcc .-10 ; 0x112a + 1134: 08 95 ret + +00001136 <__subsf3>: + 1136: 50 58 subi r21, 0x80 ; 128 + +00001138 <__addsf3>: + 1138: bb 27 eor r27, r27 + 113a: aa 27 eor r26, r26 + 113c: 0e 94 b3 08 call 0x1166 ; 0x1166 <__addsf3x> + 1140: 0c 94 b4 09 jmp 0x1368 ; 0x1368 <__fp_round> + 1144: 0e 94 a6 09 call 0x134c ; 0x134c <__fp_pscA> + 1148: 38 f0 brcs .+14 ; 0x1158 <__addsf3+0x20> + 114a: 0e 94 ad 09 call 0x135a ; 0x135a <__fp_pscB> + 114e: 20 f0 brcs .+8 ; 0x1158 <__addsf3+0x20> + 1150: 39 f4 brne .+14 ; 0x1160 <__addsf3+0x28> + 1152: 9f 3f cpi r25, 0xFF ; 255 + 1154: 19 f4 brne .+6 ; 0x115c <__addsf3+0x24> + 1156: 26 f4 brtc .+8 ; 0x1160 <__addsf3+0x28> + 1158: 0c 94 a3 09 jmp 0x1346 ; 0x1346 <__fp_nan> + 115c: 0e f4 brtc .+2 ; 0x1160 <__addsf3+0x28> + 115e: e0 95 com r30 + 1160: e7 fb bst r30, 7 + 1162: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf> + +00001166 <__addsf3x>: + 1166: e9 2f mov r30, r25 + 1168: 0e 94 c5 09 call 0x138a ; 0x138a <__fp_split3> + 116c: 58 f3 brcs .-42 ; 0x1144 <__addsf3+0xc> + 116e: ba 17 cp r27, r26 + 1170: 62 07 cpc r22, r18 + 1172: 73 07 cpc r23, r19 + 1174: 84 07 cpc r24, r20 + 1176: 95 07 cpc r25, r21 + 1178: 20 f0 brcs .+8 ; 0x1182 <__addsf3x+0x1c> + 117a: 79 f4 brne .+30 ; 0x119a <__addsf3x+0x34> + 117c: a6 f5 brtc .+104 ; 0x11e6 <__addsf3x+0x80> + 117e: 0c 94 e7 09 jmp 0x13ce ; 0x13ce <__fp_zero> + 1182: 0e f4 brtc .+2 ; 0x1186 <__addsf3x+0x20> + 1184: e0 95 com r30 + 1186: 0b 2e mov r0, r27 + 1188: ba 2f mov r27, r26 + 118a: a0 2d mov r26, r0 + 118c: 0b 01 movw r0, r22 + 118e: b9 01 movw r22, r18 + 1190: 90 01 movw r18, r0 + 1192: 0c 01 movw r0, r24 + 1194: ca 01 movw r24, r20 + 1196: a0 01 movw r20, r0 + 1198: 11 24 eor r1, r1 + 119a: ff 27 eor r31, r31 + 119c: 59 1b sub r21, r25 + 119e: 99 f0 breq .+38 ; 0x11c6 <__addsf3x+0x60> + 11a0: 59 3f cpi r21, 0xF9 ; 249 + 11a2: 50 f4 brcc .+20 ; 0x11b8 <__addsf3x+0x52> + 11a4: 50 3e cpi r21, 0xE0 ; 224 + 11a6: 68 f1 brcs .+90 ; 0x1202 <__addsf3x+0x9c> + 11a8: 1a 16 cp r1, r26 + 11aa: f0 40 sbci r31, 0x00 ; 0 + 11ac: a2 2f mov r26, r18 + 11ae: 23 2f mov r18, r19 + 11b0: 34 2f mov r19, r20 + 11b2: 44 27 eor r20, r20 + 11b4: 58 5f subi r21, 0xF8 ; 248 + 11b6: f3 cf rjmp .-26 ; 0x119e <__addsf3x+0x38> + 11b8: 46 95 lsr r20 + 11ba: 37 95 ror r19 + 11bc: 27 95 ror r18 + 11be: a7 95 ror r26 + 11c0: f0 40 sbci r31, 0x00 ; 0 + 11c2: 53 95 inc r21 + 11c4: c9 f7 brne .-14 ; 0x11b8 <__addsf3x+0x52> + 11c6: 7e f4 brtc .+30 ; 0x11e6 <__addsf3x+0x80> + 11c8: 1f 16 cp r1, r31 + 11ca: ba 0b sbc r27, r26 + 11cc: 62 0b sbc r22, r18 + 11ce: 73 0b sbc r23, r19 + 11d0: 84 0b sbc r24, r20 + 11d2: ba f0 brmi .+46 ; 0x1202 <__addsf3x+0x9c> + 11d4: 91 50 subi r25, 0x01 ; 1 + 11d6: a1 f0 breq .+40 ; 0x1200 <__addsf3x+0x9a> + 11d8: ff 0f add r31, r31 + 11da: bb 1f adc r27, r27 + 11dc: 66 1f adc r22, r22 + 11de: 77 1f adc r23, r23 + 11e0: 88 1f adc r24, r24 + 11e2: c2 f7 brpl .-16 ; 0x11d4 <__addsf3x+0x6e> + 11e4: 0e c0 rjmp .+28 ; 0x1202 <__addsf3x+0x9c> + 11e6: ba 0f add r27, r26 + 11e8: 62 1f adc r22, r18 + 11ea: 73 1f adc r23, r19 + 11ec: 84 1f adc r24, r20 + 11ee: 48 f4 brcc .+18 ; 0x1202 <__addsf3x+0x9c> + 11f0: 87 95 ror r24 + 11f2: 77 95 ror r23 + 11f4: 67 95 ror r22 + 11f6: b7 95 ror r27 + 11f8: f7 95 ror r31 + 11fa: 9e 3f cpi r25, 0xFE ; 254 + 11fc: 08 f0 brcs .+2 ; 0x1200 <__addsf3x+0x9a> + 11fe: b0 cf rjmp .-160 ; 0x1160 <__addsf3+0x28> + 1200: 93 95 inc r25 + 1202: 88 0f add r24, r24 + 1204: 08 f0 brcs .+2 ; 0x1208 <__addsf3x+0xa2> + 1206: 99 27 eor r25, r25 + 1208: ee 0f add r30, r30 + 120a: 97 95 ror r25 + 120c: 87 95 ror r24 + 120e: 08 95 ret + +00001210 <__cmpsf2>: + 1210: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp> + 1214: 08 f4 brcc .+2 ; 0x1218 <__cmpsf2+0x8> + 1216: 81 e0 ldi r24, 0x01 ; 1 + 1218: 08 95 ret + +0000121a <__fixunssfsi>: + 121a: 0e 94 cd 09 call 0x139a ; 0x139a <__fp_splitA> + 121e: 88 f0 brcs .+34 ; 0x1242 <__fixunssfsi+0x28> + 1220: 9f 57 subi r25, 0x7F ; 127 + 1222: 98 f0 brcs .+38 ; 0x124a <__fixunssfsi+0x30> + 1224: b9 2f mov r27, r25 + 1226: 99 27 eor r25, r25 + 1228: b7 51 subi r27, 0x17 ; 23 + 122a: b0 f0 brcs .+44 ; 0x1258 <__fixunssfsi+0x3e> + 122c: e1 f0 breq .+56 ; 0x1266 <__fixunssfsi+0x4c> + 122e: 66 0f add r22, r22 + 1230: 77 1f adc r23, r23 + 1232: 88 1f adc r24, r24 + 1234: 99 1f adc r25, r25 + 1236: 1a f0 brmi .+6 ; 0x123e <__fixunssfsi+0x24> + 1238: ba 95 dec r27 + 123a: c9 f7 brne .-14 ; 0x122e <__fixunssfsi+0x14> + 123c: 14 c0 rjmp .+40 ; 0x1266 <__fixunssfsi+0x4c> + 123e: b1 30 cpi r27, 0x01 ; 1 + 1240: 91 f0 breq .+36 ; 0x1266 <__fixunssfsi+0x4c> + 1242: 0e 94 e7 09 call 0x13ce ; 0x13ce <__fp_zero> + 1246: b1 e0 ldi r27, 0x01 ; 1 + 1248: 08 95 ret + 124a: 0c 94 e7 09 jmp 0x13ce ; 0x13ce <__fp_zero> + 124e: 67 2f mov r22, r23 + 1250: 78 2f mov r23, r24 + 1252: 88 27 eor r24, r24 + 1254: b8 5f subi r27, 0xF8 ; 248 + 1256: 39 f0 breq .+14 ; 0x1266 <__fixunssfsi+0x4c> + 1258: b9 3f cpi r27, 0xF9 ; 249 + 125a: cc f3 brlt .-14 ; 0x124e <__fixunssfsi+0x34> + 125c: 86 95 lsr r24 + 125e: 77 95 ror r23 + 1260: 67 95 ror r22 + 1262: b3 95 inc r27 + 1264: d9 f7 brne .-10 ; 0x125c <__fixunssfsi+0x42> + 1266: 3e f4 brtc .+14 ; 0x1276 <__fixunssfsi+0x5c> + 1268: 90 95 com r25 + 126a: 80 95 com r24 + 126c: 70 95 com r23 + 126e: 61 95 neg r22 + 1270: 7f 4f sbci r23, 0xFF ; 255 + 1272: 8f 4f sbci r24, 0xFF ; 255 + 1274: 9f 4f sbci r25, 0xFF ; 255 + 1276: 08 95 ret + +00001278 <__floatunsisf>: + 1278: e8 94 clt + 127a: 09 c0 rjmp .+18 ; 0x128e <__floatsisf+0x12> + +0000127c <__floatsisf>: + 127c: 97 fb bst r25, 7 + 127e: 3e f4 brtc .+14 ; 0x128e <__floatsisf+0x12> + 1280: 90 95 com r25 + 1282: 80 95 com r24 + 1284: 70 95 com r23 + 1286: 61 95 neg r22 + 1288: 7f 4f sbci r23, 0xFF ; 255 + 128a: 8f 4f sbci r24, 0xFF ; 255 + 128c: 9f 4f sbci r25, 0xFF ; 255 + 128e: 99 23 and r25, r25 + 1290: a9 f0 breq .+42 ; 0x12bc <__floatsisf+0x40> + 1292: f9 2f mov r31, r25 + 1294: 96 e9 ldi r25, 0x96 ; 150 + 1296: bb 27 eor r27, r27 + 1298: 93 95 inc r25 + 129a: f6 95 lsr r31 + 129c: 87 95 ror r24 + 129e: 77 95 ror r23 + 12a0: 67 95 ror r22 + 12a2: b7 95 ror r27 + 12a4: f1 11 cpse r31, r1 + 12a6: f8 cf rjmp .-16 ; 0x1298 <__floatsisf+0x1c> + 12a8: fa f4 brpl .+62 ; 0x12e8 <__floatsisf+0x6c> + 12aa: bb 0f add r27, r27 + 12ac: 11 f4 brne .+4 ; 0x12b2 <__floatsisf+0x36> + 12ae: 60 ff sbrs r22, 0 + 12b0: 1b c0 rjmp .+54 ; 0x12e8 <__floatsisf+0x6c> + 12b2: 6f 5f subi r22, 0xFF ; 255 + 12b4: 7f 4f sbci r23, 0xFF ; 255 + 12b6: 8f 4f sbci r24, 0xFF ; 255 + 12b8: 9f 4f sbci r25, 0xFF ; 255 + 12ba: 16 c0 rjmp .+44 ; 0x12e8 <__floatsisf+0x6c> + 12bc: 88 23 and r24, r24 + 12be: 11 f0 breq .+4 ; 0x12c4 <__floatsisf+0x48> + 12c0: 96 e9 ldi r25, 0x96 ; 150 + 12c2: 11 c0 rjmp .+34 ; 0x12e6 <__floatsisf+0x6a> + 12c4: 77 23 and r23, r23 + 12c6: 21 f0 breq .+8 ; 0x12d0 <__floatsisf+0x54> + 12c8: 9e e8 ldi r25, 0x8E ; 142 + 12ca: 87 2f mov r24, r23 + 12cc: 76 2f mov r23, r22 + 12ce: 05 c0 rjmp .+10 ; 0x12da <__floatsisf+0x5e> + 12d0: 66 23 and r22, r22 + 12d2: 71 f0 breq .+28 ; 0x12f0 <__floatsisf+0x74> + 12d4: 96 e8 ldi r25, 0x86 ; 134 + 12d6: 86 2f mov r24, r22 + 12d8: 70 e0 ldi r23, 0x00 ; 0 + 12da: 60 e0 ldi r22, 0x00 ; 0 + 12dc: 2a f0 brmi .+10 ; 0x12e8 <__floatsisf+0x6c> + 12de: 9a 95 dec r25 + 12e0: 66 0f add r22, r22 + 12e2: 77 1f adc r23, r23 + 12e4: 88 1f adc r24, r24 + 12e6: da f7 brpl .-10 ; 0x12de <__floatsisf+0x62> + 12e8: 88 0f add r24, r24 + 12ea: 96 95 lsr r25 + 12ec: 87 95 ror r24 + 12ee: 97 f9 bld r25, 7 + 12f0: 08 95 ret + +000012f2 <__fp_cmp>: + 12f2: 99 0f add r25, r25 + 12f4: 00 08 sbc r0, r0 + 12f6: 55 0f add r21, r21 + 12f8: aa 0b sbc r26, r26 + 12fa: e0 e8 ldi r30, 0x80 ; 128 + 12fc: fe ef ldi r31, 0xFE ; 254 + 12fe: 16 16 cp r1, r22 + 1300: 17 06 cpc r1, r23 + 1302: e8 07 cpc r30, r24 + 1304: f9 07 cpc r31, r25 + 1306: c0 f0 brcs .+48 ; 0x1338 <__fp_cmp+0x46> + 1308: 12 16 cp r1, r18 + 130a: 13 06 cpc r1, r19 + 130c: e4 07 cpc r30, r20 + 130e: f5 07 cpc r31, r21 + 1310: 98 f0 brcs .+38 ; 0x1338 <__fp_cmp+0x46> + 1312: 62 1b sub r22, r18 + 1314: 73 0b sbc r23, r19 + 1316: 84 0b sbc r24, r20 + 1318: 95 0b sbc r25, r21 + 131a: 39 f4 brne .+14 ; 0x132a <__fp_cmp+0x38> + 131c: 0a 26 eor r0, r26 + 131e: 61 f0 breq .+24 ; 0x1338 <__fp_cmp+0x46> + 1320: 23 2b or r18, r19 + 1322: 24 2b or r18, r20 + 1324: 25 2b or r18, r21 + 1326: 21 f4 brne .+8 ; 0x1330 <__fp_cmp+0x3e> + 1328: 08 95 ret + 132a: 0a 26 eor r0, r26 + 132c: 09 f4 brne .+2 ; 0x1330 <__fp_cmp+0x3e> + 132e: a1 40 sbci r26, 0x01 ; 1 + 1330: a6 95 lsr r26 + 1332: 8f ef ldi r24, 0xFF ; 255 + 1334: 81 1d adc r24, r1 + 1336: 81 1d adc r24, r1 + 1338: 08 95 ret + +0000133a <__fp_inf>: + 133a: 97 f9 bld r25, 7 + 133c: 9f 67 ori r25, 0x7F ; 127 + 133e: 80 e8 ldi r24, 0x80 ; 128 + 1340: 70 e0 ldi r23, 0x00 ; 0 + 1342: 60 e0 ldi r22, 0x00 ; 0 + 1344: 08 95 ret + +00001346 <__fp_nan>: + 1346: 9f ef ldi r25, 0xFF ; 255 + 1348: 80 ec ldi r24, 0xC0 ; 192 + 134a: 08 95 ret + +0000134c <__fp_pscA>: + 134c: 00 24 eor r0, r0 + 134e: 0a 94 dec r0 + 1350: 16 16 cp r1, r22 + 1352: 17 06 cpc r1, r23 + 1354: 18 06 cpc r1, r24 + 1356: 09 06 cpc r0, r25 + 1358: 08 95 ret + +0000135a <__fp_pscB>: + 135a: 00 24 eor r0, r0 + 135c: 0a 94 dec r0 + 135e: 12 16 cp r1, r18 + 1360: 13 06 cpc r1, r19 + 1362: 14 06 cpc r1, r20 + 1364: 05 06 cpc r0, r21 + 1366: 08 95 ret + +00001368 <__fp_round>: + 1368: 09 2e mov r0, r25 + 136a: 03 94 inc r0 + 136c: 00 0c add r0, r0 + 136e: 11 f4 brne .+4 ; 0x1374 <__fp_round+0xc> + 1370: 88 23 and r24, r24 + 1372: 52 f0 brmi .+20 ; 0x1388 <__fp_round+0x20> + 1374: bb 0f add r27, r27 + 1376: 40 f4 brcc .+16 ; 0x1388 <__fp_round+0x20> + 1378: bf 2b or r27, r31 + 137a: 11 f4 brne .+4 ; 0x1380 <__fp_round+0x18> + 137c: 60 ff sbrs r22, 0 + 137e: 04 c0 rjmp .+8 ; 0x1388 <__fp_round+0x20> + 1380: 6f 5f subi r22, 0xFF ; 255 + 1382: 7f 4f sbci r23, 0xFF ; 255 + 1384: 8f 4f sbci r24, 0xFF ; 255 + 1386: 9f 4f sbci r25, 0xFF ; 255 + 1388: 08 95 ret + +0000138a <__fp_split3>: + 138a: 57 fd sbrc r21, 7 + 138c: 90 58 subi r25, 0x80 ; 128 + 138e: 44 0f add r20, r20 + 1390: 55 1f adc r21, r21 + 1392: 59 f0 breq .+22 ; 0x13aa <__fp_splitA+0x10> + 1394: 5f 3f cpi r21, 0xFF ; 255 + 1396: 71 f0 breq .+28 ; 0x13b4 <__fp_splitA+0x1a> + 1398: 47 95 ror r20 + +0000139a <__fp_splitA>: + 139a: 88 0f add r24, r24 + 139c: 97 fb bst r25, 7 + 139e: 99 1f adc r25, r25 + 13a0: 61 f0 breq .+24 ; 0x13ba <__fp_splitA+0x20> + 13a2: 9f 3f cpi r25, 0xFF ; 255 + 13a4: 79 f0 breq .+30 ; 0x13c4 <__fp_splitA+0x2a> + 13a6: 87 95 ror r24 + 13a8: 08 95 ret + 13aa: 12 16 cp r1, r18 + 13ac: 13 06 cpc r1, r19 + 13ae: 14 06 cpc r1, r20 + 13b0: 55 1f adc r21, r21 + 13b2: f2 cf rjmp .-28 ; 0x1398 <__fp_split3+0xe> + 13b4: 46 95 lsr r20 + 13b6: f1 df rcall .-30 ; 0x139a <__fp_splitA> + 13b8: 08 c0 rjmp .+16 ; 0x13ca <__fp_splitA+0x30> + 13ba: 16 16 cp r1, r22 + 13bc: 17 06 cpc r1, r23 + 13be: 18 06 cpc r1, r24 + 13c0: 99 1f adc r25, r25 + 13c2: f1 cf rjmp .-30 ; 0x13a6 <__fp_splitA+0xc> + 13c4: 86 95 lsr r24 + 13c6: 71 05 cpc r23, r1 + 13c8: 61 05 cpc r22, r1 + 13ca: 08 94 sec + 13cc: 08 95 ret + +000013ce <__fp_zero>: + 13ce: e8 94 clt + +000013d0 <__fp_szero>: + 13d0: bb 27 eor r27, r27 + 13d2: 66 27 eor r22, r22 + 13d4: 77 27 eor r23, r23 + 13d6: cb 01 movw r24, r22 + 13d8: 97 f9 bld r25, 7 + 13da: 08 95 ret + +000013dc <__gesf2>: + 13dc: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp> + 13e0: 08 f4 brcc .+2 ; 0x13e4 <__gesf2+0x8> + 13e2: 8f ef ldi r24, 0xFF ; 255 + 13e4: 08 95 ret + +000013e6 <__mulsf3>: + 13e6: 0e 94 06 0a call 0x140c ; 0x140c <__mulsf3x> + 13ea: 0c 94 b4 09 jmp 0x1368 ; 0x1368 <__fp_round> + 13ee: 0e 94 a6 09 call 0x134c ; 0x134c <__fp_pscA> + 13f2: 38 f0 brcs .+14 ; 0x1402 <__mulsf3+0x1c> + 13f4: 0e 94 ad 09 call 0x135a ; 0x135a <__fp_pscB> + 13f8: 20 f0 brcs .+8 ; 0x1402 <__mulsf3+0x1c> + 13fa: 95 23 and r25, r21 + 13fc: 11 f0 breq .+4 ; 0x1402 <__mulsf3+0x1c> + 13fe: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf> + 1402: 0c 94 a3 09 jmp 0x1346 ; 0x1346 <__fp_nan> + 1406: 11 24 eor r1, r1 + 1408: 0c 94 e8 09 jmp 0x13d0 ; 0x13d0 <__fp_szero> + +0000140c <__mulsf3x>: + 140c: 0e 94 c5 09 call 0x138a ; 0x138a <__fp_split3> + 1410: 70 f3 brcs .-36 ; 0x13ee <__mulsf3+0x8> + +00001412 <__mulsf3_pse>: + 1412: 95 9f mul r25, r21 + 1414: c1 f3 breq .-16 ; 0x1406 <__mulsf3+0x20> + 1416: 95 0f add r25, r21 + 1418: 50 e0 ldi r21, 0x00 ; 0 + 141a: 55 1f adc r21, r21 + 141c: 62 9f mul r22, r18 + 141e: f0 01 movw r30, r0 + 1420: 72 9f mul r23, r18 + 1422: bb 27 eor r27, r27 + 1424: f0 0d add r31, r0 + 1426: b1 1d adc r27, r1 + 1428: 63 9f mul r22, r19 + 142a: aa 27 eor r26, r26 + 142c: f0 0d add r31, r0 + 142e: b1 1d adc r27, r1 + 1430: aa 1f adc r26, r26 + 1432: 64 9f mul r22, r20 + 1434: 66 27 eor r22, r22 + 1436: b0 0d add r27, r0 + 1438: a1 1d adc r26, r1 + 143a: 66 1f adc r22, r22 + 143c: 82 9f mul r24, r18 + 143e: 22 27 eor r18, r18 + 1440: b0 0d add r27, r0 + 1442: a1 1d adc r26, r1 + 1444: 62 1f adc r22, r18 + 1446: 73 9f mul r23, r19 + 1448: b0 0d add r27, r0 + 144a: a1 1d adc r26, r1 + 144c: 62 1f adc r22, r18 + 144e: 83 9f mul r24, r19 + 1450: a0 0d add r26, r0 + 1452: 61 1d adc r22, r1 + 1454: 22 1f adc r18, r18 + 1456: 74 9f mul r23, r20 + 1458: 33 27 eor r19, r19 + 145a: a0 0d add r26, r0 + 145c: 61 1d adc r22, r1 + 145e: 23 1f adc r18, r19 + 1460: 84 9f mul r24, r20 + 1462: 60 0d add r22, r0 + 1464: 21 1d adc r18, r1 + 1466: 82 2f mov r24, r18 + 1468: 76 2f mov r23, r22 + 146a: 6a 2f mov r22, r26 + 146c: 11 24 eor r1, r1 + 146e: 9f 57 subi r25, 0x7F ; 127 + 1470: 50 40 sbci r21, 0x00 ; 0 + 1472: 9a f0 brmi .+38 ; 0x149a <__mulsf3_pse+0x88> + 1474: f1 f0 breq .+60 ; 0x14b2 <__mulsf3_pse+0xa0> + 1476: 88 23 and r24, r24 + 1478: 4a f0 brmi .+18 ; 0x148c <__mulsf3_pse+0x7a> + 147a: ee 0f add r30, r30 + 147c: ff 1f adc r31, r31 + 147e: bb 1f adc r27, r27 + 1480: 66 1f adc r22, r22 + 1482: 77 1f adc r23, r23 + 1484: 88 1f adc r24, r24 + 1486: 91 50 subi r25, 0x01 ; 1 + 1488: 50 40 sbci r21, 0x00 ; 0 + 148a: a9 f7 brne .-22 ; 0x1476 <__mulsf3_pse+0x64> + 148c: 9e 3f cpi r25, 0xFE ; 254 + 148e: 51 05 cpc r21, r1 + 1490: 80 f0 brcs .+32 ; 0x14b2 <__mulsf3_pse+0xa0> + 1492: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf> + 1496: 0c 94 e8 09 jmp 0x13d0 ; 0x13d0 <__fp_szero> + 149a: 5f 3f cpi r21, 0xFF ; 255 + 149c: e4 f3 brlt .-8 ; 0x1496 <__mulsf3_pse+0x84> + 149e: 98 3e cpi r25, 0xE8 ; 232 + 14a0: d4 f3 brlt .-12 ; 0x1496 <__mulsf3_pse+0x84> + 14a2: 86 95 lsr r24 + 14a4: 77 95 ror r23 + 14a6: 67 95 ror r22 + 14a8: b7 95 ror r27 + 14aa: f7 95 ror r31 + 14ac: e7 95 ror r30 + 14ae: 9f 5f subi r25, 0xFF ; 255 + 14b0: c1 f7 brne .-16 ; 0x14a2 <__mulsf3_pse+0x90> + 14b2: fe 2b or r31, r30 + 14b4: 88 0f add r24, r24 + 14b6: 91 1d adc r25, r1 + 14b8: 96 95 lsr r25 + 14ba: 87 95 ror r24 + 14bc: 97 f9 bld r25, 7 + 14be: 08 95 ret + +000014c0 <__unordsf2>: + 14c0: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp> + 14c4: 88 0b sbc r24, r24 + 14c6: 99 0b sbc r25, r25 + 14c8: 08 95 ret + +000014ca <__udivmodsi4>: + 14ca: a1 e2 ldi r26, 0x21 ; 33 + 14cc: 1a 2e mov r1, r26 + 14ce: aa 1b sub r26, r26 + 14d0: bb 1b sub r27, r27 + 14d2: fd 01 movw r30, r26 + 14d4: 0d c0 rjmp .+26 ; 0x14f0 <__udivmodsi4_ep> + +000014d6 <__udivmodsi4_loop>: + 14d6: aa 1f adc r26, r26 + 14d8: bb 1f adc r27, r27 + 14da: ee 1f adc r30, r30 + 14dc: ff 1f adc r31, r31 + 14de: a2 17 cp r26, r18 + 14e0: b3 07 cpc r27, r19 + 14e2: e4 07 cpc r30, r20 + 14e4: f5 07 cpc r31, r21 + 14e6: 20 f0 brcs .+8 ; 0x14f0 <__udivmodsi4_ep> + 14e8: a2 1b sub r26, r18 + 14ea: b3 0b sbc r27, r19 + 14ec: e4 0b sbc r30, r20 + 14ee: f5 0b sbc r31, r21 + +000014f0 <__udivmodsi4_ep>: + 14f0: 66 1f adc r22, r22 + 14f2: 77 1f adc r23, r23 + 14f4: 88 1f adc r24, r24 + 14f6: 99 1f adc r25, r25 + 14f8: 1a 94 dec r1 + 14fa: 69 f7 brne .-38 ; 0x14d6 <__udivmodsi4_loop> + 14fc: 60 95 com r22 + 14fe: 70 95 com r23 + 1500: 80 95 com r24 + 1502: 90 95 com r25 + 1504: 9b 01 movw r18, r22 + 1506: ac 01 movw r20, r24 + 1508: bd 01 movw r22, r26 + 150a: cf 01 movw r24, r30 + 150c: 08 95 ret + +0000150e <__tablejump2__>: + 150e: ee 0f add r30, r30 + 1510: ff 1f adc r31, r31 + 1512: 05 90 lpm r0, Z+ + 1514: f4 91 lpm r31, Z + 1516: e0 2d mov r30, r0 + 1518: 09 94 ijmp + +0000151a : + 151a: 81 e0 ldi r24, 0x01 ; 1 + 151c: 90 e0 ldi r25, 0x00 ; 0 + 151e: f8 94 cli + 1520: 0c 94 92 0a jmp 0x1524 ; 0x1524 <_exit> + +00001524 <_exit>: + 1524: f8 94 cli + +00001526 <__stop_program>: + 1526: ff cf rjmp .-2 ; 0x1526 <__stop_program> diff --git a/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.elf b/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.elf new file mode 100755 index 0000000..56d11fa Binary files /dev/null and b/PHSensor/code/BasicPHSensor/BasicPHSensor.ino.elf differ diff --git a/Steno_ProCAT_Flash/docs/10.log b/Steno_ProCAT_Flash/docs/10.log index 8f9447a..bfe5d4b 100644 --- a/Steno_ProCAT_Flash/docs/10.log +++ b/Steno_ProCAT_Flash/docs/10.log @@ -1,4 +1,4 @@ -This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016/Debian) (preloaded format=pdflatex 2019.8.17) 1 JAN 2020 18:36 +This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016/Debian) (preloaded format=pdflatex 2019.8.17) 5 JUN 2020 00:43 entering extended mode restricted \write18 enabled. %&-line parsing enabled. @@ -243,7 +243,7 @@ x12.pfb> -Output written on 10.pdf (7 pages, 120177 bytes). +Output written on 10.pdf (7 pages, 120176 bytes). PDF statistics: 56 PDF objects out of 1000 (max. 8388607) 39 compressed objects within 1 object stream diff --git a/Steno_ProCAT_Flash/docs/10.pdf b/Steno_ProCAT_Flash/docs/10.pdf index 3001011..819da65 100644 Binary files a/Steno_ProCAT_Flash/docs/10.pdf and b/Steno_ProCAT_Flash/docs/10.pdf differ diff --git a/Steno_ProCAT_Flash/docs/10.tex b/Steno_ProCAT_Flash/docs/10.tex index fa9696b..99f5c0b 100644 --- a/Steno_ProCAT_Flash/docs/10.tex +++ b/Steno_ProCAT_Flash/docs/10.tex @@ -174,3 +174,4 @@ The ProCAT Flash is similar to the Stentura 200 but not identical. Due to that, I feel using a genuine Steno machine was the right choice to starting down this road, as I don't want to deal with the toys or half baked solutions made by some hackers who are selling home built keyboards.\footnote{There is also the issue that the switches on these keyboard all require 10-30 something of force for each key, whereas the ProCAT only requires 10-20 of force for the first key, whereas all subsequent keys, are free of strain. A small difference, but the devil is in the details. You can't beat the real thing.} However, I will say, that once I'm comfortable with this, I might get one of those keyboards, add a few extra keys on\footnote{By keys, I mean I plan to make a custom keyboard solution. Rotaries, Slide pots, etc... All the fun interfacing things.}, and make my own custom keyboard for interfacing with GNU Linux. There is a reason to have both a genuine steno machine, and a custom hacker diy keyboard solution. Why not both? \end{document} +\grid diff --git a/ZMHW_Modector/pcb/layout.pdf b/ZMHW_Modector/pcb/layout.pdf new file mode 100644 index 0000000..b3e5243 Binary files /dev/null and b/ZMHW_Modector/pcb/layout.pdf differ diff --git a/ZMHW_Modector/pcb/schematic.pdf b/ZMHW_Modector/pcb/schematic.pdf new file mode 100644 index 0000000..e88ab19 Binary files /dev/null and b/ZMHW_Modector/pcb/schematic.pdf differ diff --git a/ZMHW_Modector/pcb/uno.pro b/ZMHW_Modector/pcb/uno.pro index 473c355..fd6bbd2 100644 --- a/ZMHW_Modector/pcb/uno.pro +++ b/ZMHW_Modector/pcb/uno.pro @@ -1,4 +1,4 @@ -update=Mon 12 Nov 2018 10:50:35 PM EST +update=Tue 25 Aug 2020 12:24:53 AM EDT version=1 last_client=kicad [cvpcb] @@ -23,6 +23,11 @@ SolderMaskMinWidth=0.004000000000 DrawSegmentWidth=0.152400000000 BoardOutlineThickness=0.152400000000 ModuleOutlineThickness=0.152400000000 +[general] +version=1 +[eeschema] +version=1 +LibDir= [schematic_editor] version=1 PageLayoutDescrFile= @@ -30,11 +35,6 @@ PlotDirectoryName= SubpartIdSeparator=0 SubpartFirstId=65 NetFmtName= -SpiceForceRefPrefix=0 -SpiceUseNetNumbers=0 +SpiceAjustPassiveValues=0 LabSize=50 -[general] -version=1 -[eeschema] -version=1 -LibDir= +ERC_TestSimilarLabels=1 diff --git a/ZMHW_Modector/pcb_switcher/layout.pdf b/ZMHW_Modector/pcb_switcher/layout.pdf new file mode 100644 index 0000000..4696895 Binary files /dev/null and b/ZMHW_Modector/pcb_switcher/layout.pdf differ diff --git a/ZMHW_Modector/pcb_switcher/schematic.pdf b/ZMHW_Modector/pcb_switcher/schematic.pdf new file mode 100644 index 0000000..78712ed Binary files /dev/null and b/ZMHW_Modector/pcb_switcher/schematic.pdf differ diff --git a/ZMHW_Modector/pcb_switcher/uno.pro b/ZMHW_Modector/pcb_switcher/uno.pro index 473c355..fb3a276 100644 --- a/ZMHW_Modector/pcb_switcher/uno.pro +++ b/ZMHW_Modector/pcb_switcher/uno.pro @@ -1,4 +1,4 @@ -update=Mon 12 Nov 2018 10:50:35 PM EST +update=Tue 25 Aug 2020 12:26:24 AM EDT version=1 last_client=kicad [cvpcb] @@ -23,6 +23,11 @@ SolderMaskMinWidth=0.004000000000 DrawSegmentWidth=0.152400000000 BoardOutlineThickness=0.152400000000 ModuleOutlineThickness=0.152400000000 +[general] +version=1 +[eeschema] +version=1 +LibDir= [schematic_editor] version=1 PageLayoutDescrFile= @@ -30,11 +35,6 @@ PlotDirectoryName= SubpartIdSeparator=0 SubpartFirstId=65 NetFmtName= -SpiceForceRefPrefix=0 -SpiceUseNetNumbers=0 +SpiceAjustPassiveValues=0 LabSize=50 -[general] -version=1 -[eeschema] -version=1 -LibDir= +ERC_TestSimilarLabels=1 diff --git a/batterycharge_stationdata/pcb/rev2/batterystation.pro b/batterycharge_stationdata/pcb/rev2/batterystation.pro index ff5741b..65d2cb7 100644 --- a/batterycharge_stationdata/pcb/rev2/batterystation.pro +++ b/batterycharge_stationdata/pcb/rev2/batterystation.pro @@ -1,4 +1,4 @@ -update=Tue 11 Oct 2016 05:25:07 PM PDT +update=Tue 25 Aug 2020 12:30:59 AM EDT version=1 last_client=kicad [cvpcb] @@ -27,6 +27,8 @@ ModuleOutlineThickness=0.152400000000 version=1 LibDir= [eeschema/libraries] +[general] +version=1 [schematic_editor] version=1 PageLayoutDescrFile= @@ -34,8 +36,6 @@ PlotDirectoryName= SubpartIdSeparator=0 SubpartFirstId=65 NetFmtName= -SpiceForceRefPrefix=0 -SpiceUseNetNumbers=0 +SpiceAjustPassiveValues=0 LabSize=50 -[general] -version=1 +ERC_TestSimilarLabels=1 diff --git a/batterycharge_stationdata/pcb/rev2/layout.pdf b/batterycharge_stationdata/pcb/rev2/layout.pdf new file mode 100644 index 0000000..dc4248d Binary files /dev/null and b/batterycharge_stationdata/pcb/rev2/layout.pdf differ diff --git a/batterycharge_stationdata/pcb/rev2/schematic.pdf b/batterycharge_stationdata/pcb/rev2/schematic.pdf new file mode 100644 index 0000000..adb5f13 Binary files /dev/null and b/batterycharge_stationdata/pcb/rev2/schematic.pdf differ diff --git a/cctv_camera_fuse/pcb/rev1.1/layout.pdf b/cctv_camera_fuse/pcb/rev1.1/layout.pdf new file mode 100644 index 0000000..e192ce1 Binary files /dev/null and b/cctv_camera_fuse/pcb/rev1.1/layout.pdf differ