Auto Launch

ex.ino.
elf: file format elf32-avr
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 8a 00 jmp 0x114 ; 0x114 <__ctors_end>
4: 0c 94 b2 00 jmp 0x164 ; 0x164 <__bad_interrupt>
c: 0c 94 b2 00 jmp 0x164 ; 0x164 <__bad_interrupt>
1c: 0c 94 b2 00 jmp 0x164 ; 0x164 <__bad_interrupt>
40: 0c 94 cb 02 jmp 0x596 ; 0x596 <__vector_16>
68: 08 00 .word 0x0008 ; ????
6a: 00 00 nop
6c: be 92 st -X, r11
6e: 24 49 sbci r18, 0x94 ; 148
70: 12 3e cpi r17, 0xE2 ; 226
72: ab aa std Y+51, r10 ; 0x33
74: aa 2a or r10, r26
76: be cd rjmp .-1156 ; 0xfffffbf4 <__eeprom_end+0xff7efbf4>
78: cc cc rjmp .-1640 ; 0xfffffa12 <__eeprom_end+0xff7efa12>
7a: 4c 3e cpi r20, 0xEC ; 236
7c: 00 00 nop
7e: 00 80 ld r0, Z
80: be ab std Y+54, r27 ; 0x36
82: aa aa std Y+50, r10 ; 0x32
84: aa 3e cpi r26, 0xEA ; 234
86: 00 00 nop
88: 00 00 nop
8a: bf 00 .word 0x00bf ; ????
8c: 00 00 nop
8e: 80 3f cpi r24, 0xF0 ; 240
90: 00 00 nop
92: 00 00 nop
94: 00 08 sbc r0, r0
96: 41 78 andi r20, 0x81 ; 129
98: d3 bb out 0x13, r29 ; 19
9a: 43 87 std Z+11, r20 ; 0x0b
9c: d1 13 cpse r29, r17
9e: 3d 19 sub r19, r13
a0: 0e 3c cpi r16, 0xCE ; 206
a2: c3 bd out 0x23, r28 ; 35
a4: 42 82 std Z+2, r4 ; 0x02
a6: ad 2b or r26, r29
a8: 3e 68 ori r19, 0x8E ; 142
aa: ec 82 std Y+4, r14 ; 0x04
ac: 76 be out 0x36, r7 ; 54
ae: d9 8f std Y+25, r29 ; 0x19
b0: e1 a9 ldd r30, Z+49 ; 0x31
b2: 3e 4c sbci r19, 0xCE ; 206
b4: 80 ef ldi r24, 0xF0 ; 240
b6: ff be out 0x3f, r15 ; 63
b8: 01 c4 rjmp .+2050 ; 0x8bc <main+0x292>
ba: ff 7f andi r31, 0xFF ; 255
bc: 3f 00 .word 0x003f ; ????
be: 00 00 nop
...
000000c2 <__trampolines_end>:
c2: 00 00 nop
c4: 00 08 sbc r0, r0
c6: 00 02 muls r16, r16
c8: 01 00 .word 0x0001 ; ????
ca: 00 03 mulsu r16, r16
cc: 04 07 cpc r16, r20
...
000000d6 <port_to_output_PGM>:
d6: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+.
000000e0 <port_to_mode_PGM>:
e0: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*.
000000ea <digital_pin_to_port_PGM>:
ea: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................
fa: 03 03 03 03 ....
000000fe <digital_pin_to_bit_mask_PGM>:
fe: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... ..
10e: 04 08 10 20 ...
00000112 <__ctors_start>:
112: d0 04 cpc r13, r0
00000114 <__ctors_end>:
114: 11 24 eor r1, r1
116: 1f be out 0x3f, r1 ; 63
118: cf ef ldi r28, 0xFF ; 255
11a: d8 e0 ldi r29, 0x08 ; 8
11c: de bf out 0x3e, r29 ; 62
11e: cd bf out 0x3d, r28 ; 61
00000120 <__do_copy_data>:
120: 11 e0 ldi r17, 0x01 ; 1
122: a0 e0 ldi r26, 0x00 ; 0
124: b1 e0 ldi r27, 0x01 ; 1
126: ec eb ldi r30, 0xBC ; 188
128: ff e0 ldi r31, 0x0F ; 15
12a: 02 c0 rjmp .+4 ; 0x130 <__do_copy_data+0x10>
12c: 05 90 lpm r0, Z+
12e: 0d 92 st X+, r0
130: a8 33 cpi r26, 0x38 ; 56
132: b1 07 cpc r27, r17
134: d9 f7 brne .-10 ; 0x12c <__do_copy_data+0xc>
00000136 <__do_clear_bss>:
136: 21 e0 ldi r18, 0x01 ; 1
138: a8 e3 ldi r26, 0x38 ; 56
13a: b1 e0 ldi r27, 0x01 ; 1
13c: 01 c0 rjmp .+2 ; 0x140 <.do_clear_bss_start>
0000013e <.do_clear_bss_loop>:
13e: 1d 92 st X+, r1
00000140 <.do_clear_bss_start>:
140: a9 35 cpi r26, 0x59 ; 89
142: b2 07 cpc r27, r18
144: e1 f7 brne .-8 ; 0x13e <.do_clear_bss_loop>
00000146 <__do_global_ctors>:
146: 10 e0 ldi r17, 0x00 ; 0
148: ca e8 ldi r28, 0x8A ; 138
14a: d0 e0 ldi r29, 0x00 ; 0
14c: 04 c0 rjmp .+8 ; 0x156 <__do_global_ctors+0x10>
14e: 21 97 sbiw r28, 0x01 ; 1
150: fe 01 movw r30, r28
152: 0e 94 d1 07 call 0xfa2 ; 0xfa2 <__tablejump2__>
156: c9 38 cpi r28, 0x89 ; 137
158: d1 07 cpc r29, r17
15a: c9 f7 brne .-14 ; 0x14e <__do_global_ctors+0x8>
15c: 0e 94 15 03 call 0x62a ; 0x62a <main>
160: 0c 94 dc 07 jmp 0xfb8 ; 0xfb8 <_exit>
00000164 <__bad_interrupt>:
164: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
00000168 <pinMode.constprop.15>:
#include "wiring_private.h"
#include "pins_arduino.h"
void pinMode(uint8_t pin, uint8_t mode)

{
uint8_t bit = digitalPinToBitMask(pin);
168: 90 e0 ldi r25, 0x00 ; 0
16a: fc 01 movw r30, r24
16c: e2 50 subi r30, 0x02 ; 2
16e: ff 4f sbci r31, 0xFF ; 255
170: 24 91 lpm r18, Z
uint8_t port = digitalPinToPort(pin);
172: fc 01 movw r30, r24
174: e6 51 subi r30, 0x16 ; 22
176: ff 4f sbci r31, 0xFF ; 255
178: 84 91 lpm r24, Z
volatile uint8_t *reg, *out;
if (port == NOT_A_PIN) return;

17a: 88 23 and r24, r24
17c: 99 f0 breq .+38 ; 0x1a4 <pinMode.constprop.15+0x3c>
// JWS: can I let the optimizer do this?

reg = portModeRegister(port);
17e: 90 e0 ldi r25, 0x00 ; 0
180: 88 0f add r24, r24
182: 99 1f adc r25, r25
184: fc 01 movw r30, r24
186: e0 52 subi r30, 0x20 ; 32
188: ff 4f sbci r31, 0xFF ; 255
18a: a5 91 lpm r26, Z+
18c: b4 91 lpm r27, Z
out = portOutputRegister(port);
18e: fc 01 movw r30, r24
190: ea 52 subi r30, 0x2A ; 42
192: ff 4f sbci r31, 0xFF ; 255
194: 85 91 lpm r24, Z+
196: 94 91 lpm r25, Z
cli();
*reg &= ~bit;
*out |= bit;
SREG = oldSREG;
} else {
uint8_t oldSREG = SREG;
198: 8f b7 in r24, 0x3f ; 63
cli();
19a: f8 94 cli
*reg |= bit;
19c: ec 91 ld r30, X
19e: e2 2b or r30, r18
1a0: ec 93 st X, r30
SREG = oldSREG;
1a2: 8f bf out 0x3f, r24 ; 63
1a4: 08 95 ret
000001a6 <digitalWrite>:
}
}
void digitalWrite(uint8_t pin, uint8_t val)

{
uint8_t timer = digitalPinToTimer(pin);
1a6: 90 e0 ldi r25, 0x00 ; 0
1a8: fc 01 movw r30, r24
1aa: ee 53 subi r30, 0x3E ; 62
1ac: ff 4f sbci r31, 0xFF ; 255
1ae: 24 91 lpm r18, Z
uint8_t bit = digitalPinToBitMask(pin);
1b0: fc 01 movw r30, r24
1b2: e2 50 subi r30, 0x02 ; 2
1b4: ff 4f sbci r31, 0xFF ; 255
1b6: 34 91 lpm r19, Z
uint8_t port = digitalPinToPort(pin);
1b8: fc 01 movw r30, r24
1ba: e6 51 subi r30, 0x16 ; 22
1bc: ff 4f sbci r31, 0xFF ; 255
1be: e4 91 lpm r30, Z
volatile uint8_t *out;
if (port == NOT_A_PIN) return;
1c0: ee 23 and r30, r30
1c2: 09 f4 brne .+2 ; 0x1c6 <digitalWrite+0x20>
1c4: 3c c0 rjmp .+120 ; 0x23e <digitalWrite+0x98>
// 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);
1c6: 22 23 and r18, r18
1c8: 39 f1 breq .+78 ; 0x218 <digitalWrite+0x72>
//
//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)
1ca: 23 30 cpi r18, 0x03 ; 3
1cc: 91 f0 breq .+36 ; 0x1f2 <digitalWrite+0x4c>
1ce: 38 f4 brcc .+14 ; 0x1de <digitalWrite+0x38>
1d0: 21 30 cpi r18, 0x01 ; 1
1d2: a9 f0 breq .+42 ; 0x1fe <digitalWrite+0x58>
1d4: 22 30 cpi r18, 0x02 ; 2
1d6: 01 f5 brne .+64 ; 0x218 <digitalWrite+0x72>
#if defined(TCCR0A) && defined(COM0A1)
case TIMER0A: cbi(TCCR0A, COM0A1); break;
#endif
#if defined(TCCR0A) && defined(COM0B1)

case TIMER0B: cbi(TCCR0A, COM0B1); break;
1d8: 84 b5 in r24, 0x24 ; 36
1da: 8f 7d andi r24, 0xDF ; 223
1dc: 12 c0 rjmp .+36 ; 0x202 <digitalWrite+0x5c>
//
//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
//static inline void turnOffPWM(uint8_t timer)
{
switch (timer)
1de: 27 30 cpi r18, 0x07 ; 7
1e0: 91 f0 breq .+36 ; 0x206 <digitalWrite+0x60>
1e2: 28 30 cpi r18, 0x08 ; 8
1e4: a1 f0 breq .+40 ; 0x20e <digitalWrite+0x68>
1e6: 24 30 cpi r18, 0x04 ; 4
1e8: b9 f4 brne .+46 ; 0x218 <digitalWrite+0x72>
{
#endif
1ea: 80 91 80 00 lds r24, 0x0080 ; 0x800080
<__TEXT_REGION_LENGTH__+0x7e0080>
1ee: 8f 7d andi r24, 0xDF ; 223
1f0: 03 c0 rjmp .+6 ; 0x1f8 <digitalWrite+0x52>
{
switch (timer)
{
1f2: 80 91 80 00 lds r24, 0x0080 ; 0x800080
1f6: 8f 77 andi r24, 0x7F ; 127
#endif
1f8: 80 93 80 00 sts 0x0080, r24 ; 0x800080
1fc: 0d c0 rjmp .+26 ; 0x218 <digitalWrite+0x72>
#if defined(TCCR2) && defined(COM21)
case TIMER2: cbi(TCCR2, COM21); break;
#endif

1fe: 84 b5 in r24, 0x24 ; 36
200: 8f 77 andi r24, 0x7F ; 127
#endif

202: 84 bd out 0x24, r24 ; 36
204: 09 c0 rjmp .+18 ; 0x218 <digitalWrite+0x72>
#endif
206: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0
<__TEXT_REGION_LENGTH__+0x7e00b0>
20a: 8f 77 andi r24, 0x7F ; 127
20c: 03 c0 rjmp .+6 ; 0x214 <digitalWrite+0x6e>
#endif
20e: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0
212: 8f 7d andi r24, 0xDF ; 223
214: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0
// 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);
218: f0 e0 ldi r31, 0x00 ; 0
21a: ee 0f add r30, r30
21c: ff 1f adc r31, r31
21e: ea 52 subi r30, 0x2A ; 42
220: ff 4f sbci r31, 0xFF ; 255
222: a5 91 lpm r26, Z+
224: b4 91 lpm r27, Z
uint8_t oldSREG = SREG;

226: 9f b7 in r25, 0x3f ; 63
cli();
228: f8 94 cli
if (val == LOW) {
22a: 61 11 cpse r22, r1
22c: 04 c0 rjmp .+8 ; 0x236 <digitalWrite+0x90>
*out &= ~bit;
22e: 8c 91 ld r24, X
230: 30 95 com r19
232: 38 23 and r19, r24
234: 02 c0 rjmp .+4 ; 0x23a <digitalWrite+0x94>
} else {
*out |= bit;
236: ec 91 ld r30, X
238: 3e 2b or r19, r30
23a: 3c 93 st X, r19
}
SREG = oldSREG;
23c: 9f bf out 0x3f, r25 ; 63
23e: 08 95 ret
00000240 <micros>:
return m;
}
unsigned long micros() {

unsigned long m;
uint8_t oldSREG = SREG, t;
240: 3f b7 in r19, 0x3f ; 63
cli();
242: f8 94 cli
m = timer0_overflow_count;
244: 80 91 3d 01 lds r24, 0x013D ; 0x80013d <timer0_overflow_count>
248: 90 91 3e 01 lds r25, 0x013E ; 0x80013e <timer0_overflow_count+0x1>
24c: a0 91 3f 01 lds r26, 0x013F ; 0x80013f <timer0_overflow_count+0x2>
250: b0 91 40 01 lds r27, 0x0140 ; 0x800140 <timer0_overflow_count+0x3>
#if defined(TCNT0)
t = TCNT0;
254: 26 b5 in r18, 0x26 ; 38
#else
#error TIMER 0 not defined
#endif
#ifdef TIFR0
if ((TIFR0 & _BV(TOV0)) && (t < 255))
256: a8 9b sbis 0x15, 0 ; 21
258: 05 c0 rjmp .+10 ; 0x264 <micros+0x24>
25a: 2f 3f cpi r18, 0xFF ; 255
25c: 19 f0 breq .+6 ; 0x264 <micros+0x24>
m++;
25e: 01 96 adiw r24, 0x01 ; 1
260: a1 1d adc r26, r1
262: b1 1d adc r27, r1
#else
if ((TIFR & _BV(TOV0)) && (t < 255))
m++;
#endif
SREG = oldSREG;
264: 3f bf out 0x3f, r19 ; 63
return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
266: ba 2f mov r27, r26
268: a9 2f mov r26, r25
26a: 98 2f mov r25, r24
26c: 88 27 eor r24, r24
26e: 82 0f add r24, r18
270: 91 1d adc r25, r1
272: a1 1d adc r26, r1
274: b1 1d adc r27, r1
276: bc 01 movw r22, r24
278: cd 01 movw r24, r26
27a: 42 e0 ldi r20, 0x02 ; 2
27c: 66 0f add r22, r22
27e: 77 1f adc r23, r23
280: 88 1f adc r24, r24
282: 99 1f adc r25, r25
284: 4a 95 dec r20
286: d1 f7 brne .-12 ; 0x27c <micros+0x3c>
}
288: 08 95 ret
0000028a <_ZN5Print5writeEPKhj>:
// Public Methods //////////////////////////////////////////////////////////////
/* default implementation: may be overridden */

size_t Print::write(const uint8_t *buffer, size_t size)
{
28a: cf 92 push r12
28c: df 92 push r13
28e: ef 92 push r14
290: ff 92 push r15
292: 0f 93 push r16
294: 1f 93 push r17
296: cf 93 push r28
298: df 93 push r29
29a: 6c 01 movw r12, r24
29c: 7a 01 movw r14, r20
29e: 8b 01 movw r16, r22
size_t n = 0;
2a0: c0 e0 ldi r28, 0x00 ; 0
2a2: d0 e0 ldi r29, 0x00 ; 0
while (size--) {
2a4: ce 15 cp r28, r14
2a6: df 05 cpc r29, r15
2a8: 81 f0 breq .+32 ; 0x2ca <_ZN5Print5writeEPKhj+0x40>
if (write(*buffer++)) n++;
2aa: d8 01 movw r26, r16
2ac: 6d 91 ld r22, X+
2ae: 8d 01 movw r16, r26
2b0: d6 01 movw r26, r12
2b2: ed 91 ld r30, X+
2b4: fc 91 ld r31, X
2b6: 01 90 ld r0, Z+
2b8: f0 81 ld r31, Z
2ba: e0 2d mov r30, r0
2bc: c6 01 movw r24, r12
2be: 09 95 icall
2c0: 89 2b or r24, r25
2c2: 11 f0 breq .+4 ; 0x2c8 <_ZN5Print5writeEPKhj+0x3e>
2c4: 21 96 adiw r28, 0x01 ; 1
2c6: ee cf rjmp .-36 ; 0x2a4 <_ZN5Print5writeEPKhj+0x1a>
2c8: 7e 01 movw r14, r28
else break;
}
return n;
}
2ca: c7 01 movw r24, r14
2cc: df 91 pop r29
2ce: cf 91 pop r28
2d0: 1f 91 pop r17
2d2: 0f 91 pop r16
2d4: ff 90 pop r15
2d6: ef 90 pop r14
2d8: df 90 pop r13
2da: cf 90 pop r12
2dc: 08 95 ret
000002de <_ZN13LiquidCrystal11pulseEnableEv>:
write4bits(value>>4);
write4bits(value);
}
}
void LiquidCrystal::pulseEnable(void) {
2de: cf 93 push r28
2e0: df 93 push r29
2e2: ec 01 movw r28, r24
digitalWrite(_enable_pin, LOW);
2e4: 60 e0 ldi r22, 0x00 ; 0
2e6: 8e 81 ldd r24, Y+6 ; 0x06
2e8: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
delayMicroseconds(1);
digitalWrite(_enable_pin, HIGH);
2ec: 61 e0 ldi r22, 0x01 ; 1
2ee: 8e 81 ldd r24, Y+6 ; 0x06
2f0: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
delayMicroseconds(1); // enable pulse must be >450ns
2f4: 60 e0 ldi r22, 0x00 ; 0
2f6: 8e 81 ldd r24, Y+6 ; 0x06
2f8: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
#endif
// busy wait
__asm__ __volatile__ (
2fc: 8b e8 ldi r24, 0x8B ; 139
2fe: 91 e0 ldi r25, 0x01 ; 1
300: 01 97 sbiw r24, 0x01 ; 1
302: f1 f7 brne .-4 ; 0x300
<_ZN13LiquidCrystal11pulseEnableEv+0x22>
delayMicroseconds(100); // commands need > 37us to settle
}
304: df 91 pop r29
306: cf 91 pop r28
308: 08 95 ret
0000030a <_ZN13LiquidCrystal10write4bitsEh>:
void LiquidCrystal::write4bits(uint8_t value) {

30a: cf 92 push r12
30c: df 92 push r13
30e: ef 92 push r14
310: ff 92 push r15
312: 0f 93 push r16
314: 1f 93 push r17
316: cf 93 push r28
318: df 93 push r29
31a: 6c 01 movw r12, r24
31c: 7c 01 movw r14, r24
31e: 87 e0 ldi r24, 0x07 ; 7
320: e8 0e add r14, r24
322: f1 1c adc r15, r1
for (int i = 0; i < 4; i++) {
324: c0 e0 ldi r28, 0x00 ; 0
326: d0 e0 ldi r29, 0x00 ; 0
digitalWrite(_data_pins[i], (value >> i) & 0x01);
328: 06 2f mov r16, r22
32a: 10 e0 ldi r17, 0x00 ; 0
32c: b8 01 movw r22, r16
32e: 0c 2e mov r0, r28
330: 02 c0 rjmp .+4 ; 0x336
<_ZN13LiquidCrystal10write4bitsEh+0x2c>
332: 75 95 asr r23
334: 67 95 ror r22
336: 0a 94 dec r0
338: e2 f7 brpl .-8 ; 0x332
<_ZN13LiquidCrystal10write4bitsEh+0x28>
33a: 61 70 andi r22, 0x01 ; 1
33c: f7 01 movw r30, r14
33e: 81 91 ld r24, Z+
340: 7f 01 movw r14, r30
342: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
delayMicroseconds(100); // commands need > 37us to settle
}

for (int i = 0; i < 4; i++) {
346: 21 96 adiw r28, 0x01 ; 1
348: c4 30 cpi r28, 0x04 ; 4
34a: d1 05 cpc r29, r1
34c: 79 f7 brne .-34 ; 0x32c
<_ZN13LiquidCrystal10write4bitsEh+0x22>
}
pulseEnable();
34e: c6 01 movw r24, r12
}
350: df 91 pop r29
352: cf 91 pop r28
354: 1f 91 pop r17
356: 0f 91 pop r16
358: ff 90 pop r15
35a: ef 90 pop r14
35c: df 90 pop r13
35e: cf 90 pop r12
for (int i = 0; i < 4; i++) {
}
pulseEnable();
360: 0c 94 6f 01 jmp 0x2de ; 0x2de <_ZN13LiquidCrystal11pulseEnableEv>
00000364 <_ZN13LiquidCrystal4sendEhh>:
}
/************ low level data pushing commands **********/
// write either command or data, with automatic 4/8-bit selection

void LiquidCrystal::send(uint8_t value, uint8_t mode) {
364: cf 92 push r12
366: df 92 push r13
368: ef 92 push r14
36a: ff 92 push r15
36c: 0f 93 push r16
36e: 1f 93 push r17
370: cf 93 push r28
372: df 93 push r29
374: ec 01 movw r28, r24
376: f6 2e mov r15, r22
digitalWrite(_rs_pin, mode);
378: 64 2f mov r22, r20
37a: 8c 81 ldd r24, Y+4 ; 0x04
37c: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
// if there is a RW pin indicated, set it low to Write

if (_rw_pin != 255) {
380: 8d 81 ldd r24, Y+5 ; 0x05
382: 8f 3f cpi r24, 0xFF ; 255
384: 19 f0 breq .+6 ; 0x38c <_ZN13LiquidCrystal4sendEhh+0x28>
digitalWrite(_rw_pin, LOW);
386: 60 e0 ldi r22, 0x00 ; 0
}
if (_displayfunction & LCD_8BITMODE) {

38c: 8f 85 ldd r24, Y+15 ; 0x0f
38e: 0f 2d mov r16, r15
390: 10 e0 ldi r17, 0x00 ; 0
392: 84 ff sbrs r24, 4
394: 25 c0 rjmp .+74 ; 0x3e0 <_ZN13LiquidCrystal4sendEhh+0x7c>
396: 6e 01 movw r12, r28
398: 87 e0 ldi r24, 0x07 ; 7
39a: c8 0e add r12, r24
39c: d1 1c adc r13, r1
39e: e1 2c mov r14, r1
3a0: f1 2c mov r15, r1
pulseEnable();
}
for (int i = 0; i < 8; i++) {
3a2: b8 01 movw r22, r16
3a4: 0e 2c mov r0, r14
3a6: 02 c0 rjmp .+4 ; 0x3ac <_ZN13LiquidCrystal4sendEhh+0x48>
3a8: 75 95 asr r23
3aa: 67 95 ror r22
3ac: 0a 94 dec r0
3ae: e2 f7 brpl .-8 ; 0x3a8 <_ZN13LiquidCrystal4sendEhh+0x44>
3b0: 61 70 andi r22, 0x01 ; 1
3b2: f6 01 movw r30, r12
3b4: 81 91 ld r24, Z+
3b6: 6f 01 movw r12, r30
3b8: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
pulseEnable();
}

for (int i = 0; i < 8; i++) {
3bc: ff ef ldi r31, 0xFF ; 255
3be: ef 1a sub r14, r31
3c0: ff 0a sbc r15, r31
3c2: 88 e0 ldi r24, 0x08 ; 8
3c4: e8 16 cp r14, r24
3c6: f1 04 cpc r15, r1
3c8: 61 f7 brne .-40 ; 0x3a2 <_ZN13LiquidCrystal4sendEhh+0x3e>
}
pulseEnable();
3ca: ce 01 movw r24, r28
write8bits(value);
} else {
write4bits(value);
}
}
3cc: df 91 pop r29
3ce: cf 91 pop r28
3d0: 1f 91 pop r17
3d2: 0f 91 pop r16
3d4: ff 90 pop r15
3d6: ef 90 pop r14
3d8: df 90 pop r13
3da: cf 90 pop r12
for (int i = 0; i < 8; i++) {
}
pulseEnable();
3dc: 0c 94 6f 01 jmp 0x2de ; 0x2de <_ZN13LiquidCrystal11pulseEnableEv>
}

write8bits(value);
} else {
3e0: b8 01 movw r22, r16
3e2: 84 e0 ldi r24, 0x04 ; 4
3e4: 75 95 asr r23
3e6: 67 95 ror r22
3e8: 8a 95 dec r24
3ea: e1 f7 brne .-8 ; 0x3e4 <_ZN13LiquidCrystal4sendEhh+0x80>
3ec: ce 01 movw r24, r28
3ee: 0e 94 85 01 call 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
write4bits(value);
3f2: 6f 2d mov r22, r15
3f4: ce 01 movw r24, r28
}
}
3f6: df 91 pop r29
3f8: cf 91 pop r28
3fa: 1f 91 pop r17
3fc: 0f 91 pop r16
3fe: ff 90 pop r15
400: ef 90 pop r14
402: df 90 pop r13
404: cf 90 pop r12

write8bits(value);
} else {
write4bits(value);
406: 0c 94 85 01 jmp 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
0000040a <_ZN13LiquidCrystal7commandEh.constprop.18>:
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal::command(uint8_t value) {

send(value, LOW);
40a: 40 e0 ldi r20, 0x00 ; 0
40c: 68 2f mov r22, r24
40e: 81 e4 ldi r24, 0x41 ; 65
410: 91 e0 ldi r25, 0x01 ; 1
412: 0c 94 b2 01 jmp 0x364 ; 0x364 <_ZN13LiquidCrystal4sendEhh>
00000416 <_ZN13LiquidCrystal5beginEhhh.constprop.14>:
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(16, 1);
}
void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {

416: cf 93 push r28
418: df 93 push r29
if (lines > 1) {
41a: 82 30 cpi r24, 0x02 ; 2
41c: 28 f0 brcs .+10 ; 0x428
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0x12>
_displayfunction |= LCD_2LINE;
41e: 90 91 50 01 lds r25, 0x0150 ; 0x800150 <lcd+0xf>
422: 98 60 ori r25, 0x08 ; 8
424: 90 93 50 01 sts 0x0150, r25 ; 0x800150 <lcd+0xf>
}
_numlines = lines;
428: 80 93 54 01 sts 0x0154, r24 ; 0x800154 <lcd+0x13>
void LiquidCrystal::setRowOffsets(int row0, int row1, int row2, int row3)

{
_row_offsets[0] = row0;
42c: 10 92 55 01 sts 0x0155, r1 ; 0x800155 <lcd+0x14>
430: 80 e4 ldi r24, 0x40 ; 64
432: 80 93 56 01 sts 0x0156, r24 ; 0x800156 <lcd+0x15>
436: 80 e1 ldi r24, 0x10 ; 16
438: 80 93 57 01 sts 0x0157, r24 ; 0x800157 <lcd+0x16>
43c: 80 e5 ldi r24, 0x50 ; 80
43e: 80 93 58 01 sts 0x0158, r24 ; 0x800158 <lcd+0x17>
// for some 1 line displays you can select a 10 pixel high font
if ((dotsize != LCD_5x8DOTS) && (lines == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
pinMode(_rs_pin, OUTPUT);
442: 80 91 45 01 lds r24, 0x0145 ; 0x800145 <lcd+0x4>
446: 0e 94 b4 00 call 0x168 ; 0x168 <pinMode.constprop.15>
// we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#
if (_rw_pin != 255) {
44a: 80 91 46 01 lds r24, 0x0146 ; 0x800146 <lcd+0x5>
44e: 8f 3f cpi r24, 0xFF ; 255
450: 11 f0 breq .+4 ; 0x456
pinMode(_rw_pin, OUTPUT);
}
pinMode(_enable_pin, OUTPUT);
456: 80 91 47 01 lds r24, 0x0147 ; 0x800147 <lcd+0x6>
45a: 0e 94 b4 00 call 0x168 ; 0x168 <pinMode.constprop.15>
45e: c1 e4 ldi r28, 0x41 ; 65
460: d1 e0 ldi r29, 0x01 ; 1
462: 9e 01 movw r18, r28
464: 21 54 subi r18, 0x41 ; 65
466: 31 40 sbci r19, 0x01 ; 1
// Do these once, instead of every time a character is drawn for speed reasons.
for (int i=0; i<((_displayfunction & LCD_8BITMODE) ? 8 : 4); ++i)
468: 80 91 50 01 lds r24, 0x0150 ; 0x800150 <lcd+0xf>
46c: 84 fd sbrc r24, 4
46e: 03 c0 rjmp .+6 ; 0x476
470: 84 e0 ldi r24, 0x04 ; 4
472: 90 e0 ldi r25, 0x00 ; 0
474: 02 c0 rjmp .+4 ; 0x47a
476: 88 e0 ldi r24, 0x08 ; 8
478: 90 e0 ldi r25, 0x00 ; 0
47a: 21 96 adiw r28, 0x01 ; 1
47c: 28 17 cp r18, r24
47e: 39 07 cpc r19, r25
480: 24 f4 brge .+8 ; 0x48a
{
pinMode(_data_pins[i], OUTPUT);
482: 8e 81 ldd r24, Y+6 ; 0x06
488: ec cf rjmp .-40 ; 0x462
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0x4c>
48a: 8b e3 ldi r24, 0x3B ; 59
48c: 9d e0 ldi r25, 0x0D ; 13
48e: 01 97 sbiw r24, 0x01 ; 1
490: f1 f7 brne .-4 ; 0x48e
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
// Now we pull both RS and R/W low to begin commands
digitalWrite(_rs_pin, LOW);
492: 60 e0 ldi r22, 0x00 ; 0
494: 80 91 45 01 lds r24, 0x0145 ; 0x800145 <lcd+0x4>
49c: 60 e0 ldi r22, 0x00 ; 0
49e: 80 91 47 01 lds r24, 0x0147 ; 0x800147 <lcd+0x6>
4a2: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
if (_rw_pin != 255) {
4a6: 80 91 46 01 lds r24, 0x0146 ; 0x800146 <lcd+0x5>
4aa: 8f 3f cpi r24, 0xFF ; 255
4ac: 19 f0 breq .+6 ; 0x4b4
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0x9e>
digitalWrite(_rw_pin, LOW);
4ae: 60 e0 ldi r22, 0x00 ; 0
4b0: 0e 94 d3 00 call 0x1a6 ; 0x1a6 <digitalWrite>
}
//put the LCD into 4 bit or 8 bit mode

if (! (_displayfunction & LCD_8BITMODE)) {
4b4: 80 91 50 01 lds r24, 0x0150 ; 0x800150 <lcd+0xf>
4b8: 84 fd sbrc r24, 4
4ba: 20 c0 rjmp .+64 ; 0x4fc
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0xe6>
// this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode

write4bits(0x03);
4bc: 63 e0 ldi r22, 0x03 ; 3
4be: 81 e4 ldi r24, 0x41 ; 65
4c0: 91 e0 ldi r25, 0x01 ; 1
4c2: 0e 94 85 01 call 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
4c6: cb e4 ldi r28, 0x4B ; 75
4c8: d6 e4 ldi r29, 0x46 ; 70
4ca: ce 01 movw r24, r28
4cc: 01 97 sbiw r24, 0x01 ; 1
4ce: f1 f7 brne .-4 ; 0x4cc
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0xb6>
delayMicroseconds(4500); // wait min 4.1ms
// second try
write4bits(0x03);
4d0: 63 e0 ldi r22, 0x03 ; 3
4d2: 81 e4 ldi r24, 0x41 ; 65
4d4: 91 e0 ldi r25, 0x01 ; 1
4d6: 0e 94 85 01 call 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
4da: 21 97 sbiw r28, 0x01 ; 1
4dc: f1 f7 brne .-4 ; 0x4da
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0xc4>
delayMicroseconds(4500); // wait min 4.1ms
// third go!
write4bits(0x03);
4de: 63 e0 ldi r22, 0x03 ; 3
4e0: 81 e4 ldi r24, 0x41 ; 65
4e2: 91 e0 ldi r25, 0x01 ; 1
4e4: 0e 94 85 01 call 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
4e8: 83 e5 ldi r24, 0x53 ; 83
4ea: 92 e0 ldi r25, 0x02 ; 2
4ec: 01 97 sbiw r24, 0x01 ; 1
4ee: f1 f7 brne .-4 ; 0x4ec
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0xd6>
// finally, set to 4-bit interface

write4bits(0x02);
4f0: 62 e0 ldi r22, 0x02 ; 2
4f2: 81 e4 ldi r24, 0x41 ; 65
4f4: 91 e0 ldi r25, 0x01 ; 1
4f6: 0e 94 85 01 call 0x30a ; 0x30a <_ZN13LiquidCrystal10write4bitsEh>
4fa: 15 c0 rjmp .+42 ; 0x526
} else {
// this is according to the hitachi HD44780 datasheet
// page 45 figure 23
// Send function set command sequence

command(LCD_FUNCTIONSET | _displayfunction);
4fc: 80 62 ori r24, 0x20 ; 32
4fe: 0e 94 05 02 call 0x40a ; 0x40a
<_ZN13LiquidCrystal7commandEh.constprop.18>
502: 8b e4 ldi r24, 0x4B ; 75
504: 96 e4 ldi r25, 0x46 ; 70
506: 01 97 sbiw r24, 0x01 ; 1
508: f1 f7 brne .-4 ; 0x506
<_ZN13LiquidCrystal5beginEhhh.constprop.14+0xf0>
delayMicroseconds(4500); // wait more than 4.1ms
// second try
50a: 80 91 50 01 lds r24, 0x0150 ; 0x800150 <lcd+0xf>
50e: 80 62 ori r24, 0x20 ; 32
510: 0e 94 05 02 call 0x40a ; 0x40a
514: 83 e5 ldi r24, 0x53 ; 83
516: 92 e0 ldi r25, 0x02 ; 2
518: 01 97 sbiw r24, 0x01 ; 1
51a: f1 f7 brne .-4 ; 0x518
// third go
51c: 80 91 50 01 lds r24, 0x0150 ; 0x800150 <lcd+0xf>
520: 80 62 ori r24, 0x20 ; 32
522: 0e 94 05 02 call 0x40a ; 0x40a
}
// finally, set # lines, font size, etc.

526: 80 91 50 01 lds r24, 0x0150 ; 0x800150 <lcd+0xf>
52a: 80 62 ori r24, 0x20 ; 32
52c: 0e 94 05 02 call 0x40a ; 0x40a
// turn the display on with no cursor or blinking default

_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
530: 84 e0 ldi r24, 0x04 ; 4
532: 80 93 51 01 sts 0x0151, r24 ; 0x800151 <lcd+0x10>
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
536: 8c e0 ldi r24, 0x0C ; 12
538: 0e 94 05 02 call 0x40a ; 0x40a
}
/********** high level commands, for the user! */

void LiquidCrystal::clear()
{
command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
53c: 81 e0 ldi r24, 0x01 ; 1
53e: 0e 94 05 02 call 0x40a ; 0x40a
542: 8b e3 ldi r24, 0x3B ; 59
544: 9f e1 ldi r25, 0x1F ; 31
546: 01 97 sbiw r24, 0x01 ; 1
548: f1 f7 brne .-4 ; 0x546
// clear it off
clear();
// Initialize to default text direction (for romance languages)

_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
54a: 82 e0 ldi r24, 0x02 ; 2
54c: 80 93 52 01 sts 0x0152, r24 ; 0x800152 <lcd+0x11>
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
550: 86 e0 ldi r24, 0x06 ; 6
}
552: df 91 pop r29
554: cf 91 pop r28
clear();
// Initialize to default text direction (for romance languages)

_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
556: 0c 94 05 02 jmp 0x40a ; 0x40a
0000055a <_ZN13LiquidCrystal5writeEh>:
send(value, LOW);
}
inline size_t LiquidCrystal::write(uint8_t value) {

send(value, HIGH);
55a: 41 e0 ldi r20, 0x01 ; 1
55c: 0e 94 b2 01 call 0x364 ; 0x364 <_ZN13LiquidCrystal4sendEhh>
return 1; // assume sucess
}
560: 81 e0 ldi r24, 0x01 ; 1
562: 90 e0 ldi r25, 0x00 ; 0
564: 08 95 ret
00000566 <_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 */ }

566: 08 95 ret
00000568 <_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; }
568: 80 e0 ldi r24, 0x00 ; 0
56a: 90 e0 ldi r25, 0x00 ; 0
56c: 08 95 ret
0000056e <_ZN5Print5writeEPKc.constprop.10>:
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;
56e: 00 97 sbiw r24, 0x00 ; 0
570: 69 f0 breq .+26 ; 0x58c
<_ZN5Print5writeEPKc.constprop.10+0x1e>
return write((const uint8_t *)str, strlen(str));
572: fc 01 movw r30, r24
574: 01 90 ld r0, Z+
576: 00 20 and r0, r0
578: e9 f7 brne .-6 ; 0x574
<_ZN5Print5writeEPKc.constprop.10+0x6>
57a: 31 97 sbiw r30, 0x01 ; 1
57c: af 01 movw r20, r30
57e: 48 1b sub r20, r24
580: 59 0b sbc r21, r25
582: bc 01 movw r22, r24
584: 81 e4 ldi r24, 0x41 ; 65
586: 91 e0 ldi r25, 0x01 ; 1
588: 0c 94 45 01 jmp 0x28a ; 0x28a <_ZN5Print5writeEPKhj>
}
58c: 80 e0 ldi r24, 0x00 ; 0
58e: 90 e0 ldi r25, 0x00 ; 0
590: 08 95 ret
00000592 <__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();
592: 0e 94 d7 07 call 0xfae ; 0xfae <abort>
00000596 <__vector_16>:
#if defined(TIM0_OVF_vect)
ISR(TIM0_OVF_vect)
#else
ISR(TIMER0_OVF_vect)
#endif
{
596: 1f 92 push r1
598: 0f 92 push r0
59a: 0f b6 in r0, 0x3f ; 63
59c: 0f 92 push r0
59e: 11 24 eor r1, r1
5a0: 2f 93 push r18
5a2: 3f 93 push r19
5a4: 8f 93 push r24
5a6: 9f 93 push r25
5a8: af 93 push r26
5aa: 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;
5ac: 80 91 39 01 lds r24, 0x0139 ; 0x800139 <timer0_millis>
5b0: 90 91 3a 01 lds r25, 0x013A ; 0x80013a <timer0_millis+0x1>
5b4: a0 91 3b 01 lds r26, 0x013B ; 0x80013b <timer0_millis+0x2>
5b8: b0 91 3c 01 lds r27, 0x013C ; 0x80013c <timer0_millis+0x3>
unsigned char f = timer0_fract;
5bc: 30 91 38 01 lds r19, 0x0138 ; 0x800138 <__data_end>
m += MILLIS_INC;
f += FRACT_INC;
5c0: 23 e0 ldi r18, 0x03 ; 3
5c2: 23 0f add r18, r19
if (f >= FRACT_MAX) {
5c4: 2d 37 cpi r18, 0x7D ; 125
5c6: 20 f4 brcc .+8 ; 0x5d0 <__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;
5c8: 01 96 adiw r24, 0x01 ; 1
5ca: a1 1d adc r26, r1
5cc: b1 1d adc r27, r1
5ce: 05 c0 rjmp .+10 ; 0x5da <__vector_16+0x44>
f += FRACT_INC;
if (f >= FRACT_MAX) {
f -= FRACT_MAX;
5d0: 26 e8 ldi r18, 0x86 ; 134
5d2: 23 0f add r18, r19
m += 1;
5d4: 02 96 adiw r24, 0x02 ; 2
5d6: a1 1d adc r26, r1
5d8: b1 1d adc r27, r1
}
timer0_fract = f;
5da: 20 93 38 01 sts 0x0138, r18 ; 0x800138 <__data_end>
timer0_millis = m;
5de: 80 93 39 01 sts 0x0139, r24 ; 0x800139 <timer0_millis>
5e2: 90 93 3a 01 sts 0x013A, r25 ; 0x80013a <timer0_millis+0x1>
5e6: a0 93 3b 01 sts 0x013B, r26 ; 0x80013b <timer0_millis+0x2>
5ea: b0 93 3c 01 sts 0x013C, r27 ; 0x80013c <timer0_millis+0x3>
timer0_overflow_count++;
5ee: 80 91 3d 01 lds r24, 0x013D ; 0x80013d <timer0_overflow_count>
5f2: 90 91 3e 01 lds r25, 0x013E ; 0x80013e <timer0_overflow_count+0x1>
5f6: a0 91 3f 01 lds r26, 0x013F ; 0x80013f <timer0_overflow_count+0x2>
5fa: b0 91 40 01 lds r27, 0x0140 ; 0x800140 <timer0_overflow_count+0x3>
5fe: 01 96 adiw r24, 0x01 ; 1
600: a1 1d adc r26, r1
602: b1 1d adc r27, r1
604: 80 93 3d 01 sts 0x013D, r24 ; 0x80013d <timer0_overflow_count>
608: 90 93 3e 01 sts 0x013E, r25 ; 0x80013e <timer0_overflow_count+0x1>
60c: a0 93 3f 01 sts 0x013F, r26 ; 0x80013f <timer0_overflow_count+0x2>
610: b0 93 40 01 sts 0x0140, r27 ; 0x800140 <timer0_overflow_count+0x3>
}
614: bf 91 pop r27
616: af 91 pop r26
618: 9f 91 pop r25
61a: 8f 91 pop r24
61c: 3f 91 pop r19
61e: 2f 91 pop r18
620: 0f 90 pop r0
622: 0f be out 0x3f, r0 ; 63
624: 0f 90 pop r0
626: 1f 90 pop r1
628: 18 95 reti
0000062a <main>:
void setupUSB() __attribute__((weak));

void setupUSB() { }
int main(void)
{
62a: cf 93 push r28
62c: df 93 push r29
62e: cd b7 in r28, 0x3d ; 61
630: de b7 in r29, 0x3e ; 62
632: a2 97 sbiw r28, 0x22 ; 34
634: 0f b6 in r0, 0x3f ; 63
636: f8 94 cli
638: de bf out 0x3e, r29 ; 62
63a: 0f be out 0x3f, r0 ; 63
63c: cd bf out 0x3d, r28 ; 61
void init()
{
// this needs to be called before setup() or some functions won't
// work there
sei();
63e: 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);
640: 84 b5 in r24, 0x24 ; 36
642: 82 60 ori r24, 0x02 ; 2
644: 84 bd out 0x24, r24 ; 36
sbi(TCCR0A, WGM00);
646: 84 b5 in r24, 0x24 ; 36
648: 81 60 ori r24, 0x01 ; 1
64a: 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);
64c: 85 b5 in r24, 0x25 ; 37
64e: 82 60 ori r24, 0x02 ; 2
650: 85 bd out 0x25, r24 ; 37
sbi(TCCR0B, CS00);
652: 85 b5 in r24, 0x25 ; 37
654: 81 60 ori r24, 0x01 ; 1
656: 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);
658: 80 91 6e 00 lds r24, 0x006E ; 0x80006e
<__TEXT_REGION_LENGTH__+0x7e006e>
65c: 81 60 ori r24, 0x01 ; 1
65e: 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;
662: 10 92 81 00 sts 0x0081, r1 ; 0x800081
// set timer 1 prescale factor to 64

sbi(TCCR1B, CS11);
666: 80 91 81 00 lds r24, 0x0081 ; 0x800081
66a: 82 60 ori r24, 0x02 ; 2
66c: 80 93 81 00 sts 0x0081, r24 ; 0x800081
#if F_CPU >= 8000000L
sbi(TCCR1B, CS10);
670: 80 91 81 00 lds r24, 0x0081 ; 0x800081
674: 81 60 ori r24, 0x01 ; 1
676: 80 93 81 00 sts 0x0081, r24 ; 0x800081
sbi(TCCR1, CS10);
#endif
#endif
// put timer 1 in 8-bit phase correct pwm mode
#if defined(TCCR1A) && defined(WGM10)
sbi(TCCR1A, WGM10);
67a: 80 91 80 00 lds r24, 0x0080 ; 0x800080
67e: 81 60 ori r24, 0x01 ; 1
680: 80 93 80 00 sts 0x0080, r24 ; 0x800080
// set timer 2 prescale factor to 64

#if defined(TCCR2) && defined(CS22)
sbi(TCCR2, CS22);
#elif defined(TCCR2B) && defined(CS22)
sbi(TCCR2B, CS22);
684: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1
688: 84 60 ori r24, 0x04 ; 4
68a: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1
// 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);
68e: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0
692: 81 60 ori r24, 0x01 ; 1
694: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0
#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);
698: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
<__TEXT_REGION_LENGTH__+0x7e007a>
69c: 84 60 ori r24, 0x04 ; 4
69e: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a
sbi(ADCSRA, ADPS1);
6a2: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
6a6: 82 60 ori r24, 0x02 ; 2
6a8: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a
sbi(ADCSRA, ADPS0);
6ac: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
6b0: 81 60 ori r24, 0x01 ; 1
6b2: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a
cbi(ADCSRA, ADPS2);
cbi(ADCSRA, ADPS1);
sbi(ADCSRA, ADPS0);
#endif
// enable a2d conversions
sbi(ADCSRA, ADEN);
6b6: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
6ba: 80 68 ori r24, 0x80 ; 128
6bc: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a
// 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;
6c0: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1
<__TEXT_REGION_LENGTH__+0x7e00c1>
LiquidCrystal lcd(4, 6, 10, 11, 12, 13);
int thermistorPin = 0; // thermistor connected to analog pin 3
void setup()
{
lcd.begin(16, 2); // set up the LCD's number of columns and rows:
6c4: 82 e0 ldi r24, 0x02 ; 2
6c6: 0e 94 0b 02 call 0x416 ; 0x416
<_ZN13LiquidCrystal5beginEhhh.constprop.14>
}
/********** high level commands, for the user! */

void LiquidCrystal::clear()
{
command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
6ca: 81 e0 ldi r24, 0x01 ; 1
6cc: 0e 94 05 02 call 0x40a ; 0x40a
#endif
// busy wait
__asm__ __volatile__ (
6d0: 8b e3 ldi r24, 0x3B ; 59
6d2: 9f e1 ldi r25, 0x1F ; 31
6d4: 01 97 sbiw r24, 0x01 ; 1
6d6: f1 f7 brne .-4 ; 0x6d4 <main+0xaa>
// prevent crash if called with base == 1

if (base < 2) base = 10;
do {
char c = n % base;
6d8: 2a e0 ldi r18, 0x0A ; 10
6da: 82 2e mov r8, r18
6dc: 91 2c mov r9, r1
6de: a1 2c mov r10, r1
6e0: b1 2c mov r11, r1
// 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);
6e2: 20 e4 ldi r18, 0x40 ; 64
6e4: 20 93 7c 00 sts 0x007C, r18 ; 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);
6e8: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
6ec: 80 64 ori r24, 0x40 ; 64
6ee: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a
// ADSC is cleared when the conversion finishes

while (bit_is_set(ADCSRA, ADSC));
6f2: 80 91 7a 00 lds r24, 0x007A ; 0x80007a
6f6: 86 fd sbrc r24, 6
6f8: fc cf rjmp .-8 ; 0x6f2 <main+0xc8>
// 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;
6fa: 60 91 78 00 lds r22, 0x0078 ; 0x800078
high = ADCH;
6fe: 80 91 79 00 lds r24, 0x0079 ; 0x800079
void loop()
{
float a = analogRead(thermistorPin);
//the calculating formula of temperature
float resistor = (1023.0*10000)/a-10000;
float tempC = (3435.0/(log(resistor/10000)+(3435.0/(273.15+25)))) - 200.00;
702: 70 e0 ldi r23, 0x00 ; 0
704: 78 2b or r23, r24
706: 07 2e mov r0, r23
708: 00 0c add r0, r0
70a: 88 0b sbc r24, r24
70c: 99 0b sbc r25, r25
70e: 0e 94 03 06 call 0xc06 ; 0xc06 <__floatsisf>
712: 9b 01 movw r18, r22
714: ac 01 movw r20, r24
716: 60 ef ldi r22, 0xF0 ; 240
718: 78 e1 ldi r23, 0x18 ; 24
71a: 8c e1 ldi r24, 0x1C ; 28
71c: 9b e4 ldi r25, 0x4B ; 75
71e: 0e 94 60 05 call 0xac0 ; 0xac0 <__divsf3>
722: 20 e0 ldi r18, 0x00 ; 0
724: 30 e4 ldi r19, 0x40 ; 64
726: 4c e1 ldi r20, 0x1C ; 28
728: 56 e4 ldi r21, 0x46 ; 70
72a: 0e 94 ee 04 call 0x9dc ; 0x9dc <__subsf3>
72e: 20 e0 ldi r18, 0x00 ; 0
730: 30 e4 ldi r19, 0x40 ; 64
732: 4c e1 ldi r20, 0x1C ; 28
734: 56 e4 ldi r21, 0x46 ; 70
736: 0e 94 60 05 call 0xac0 ; 0xac0 <__divsf3>
73a: 0e 94 c0 06 call 0xd80 ; 0xd80 <log>
73e: 25 e3 ldi r18, 0x35 ; 53
740: 36 e5 ldi r19, 0x56 ; 86
742: 48 e3 ldi r20, 0x38 ; 56
744: 51 e4 ldi r21, 0x41 ; 65
746: 0e 94 ef 04 call 0x9de ; 0x9de <__addsf3>
74a: 9b 01 movw r18, r22
74c: ac 01 movw r20, r24
74e: 60 e0 ldi r22, 0x00 ; 0
750: 70 eb ldi r23, 0xB0 ; 176
752: 86 e5 ldi r24, 0x56 ; 86
754: 95 e4 ldi r25, 0x45 ; 69
756: 0e 94 60 05 call 0xac0 ; 0xac0 <__divsf3>
75a: 23 e3 ldi r18, 0x33 ; 51
75c: 33 e9 ldi r19, 0x93 ; 147
75e: 48 e8 ldi r20, 0x88 ; 136
760: 53 e4 ldi r21, 0x43 ; 67
762: 0e 94 ee 04 call 0x9dc ; 0x9dc <__subsf3>
766: 6b 01 movw r12, r22
768: 7c 01 movw r14, r24
}
if ( row >= _numlines ) {
row = _numlines - 1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));

76a: e1 e0 ldi r30, 0x01 ; 1
76c: 80 91 54 01 lds r24, 0x0154 ; 0x800154 <lcd+0x13>
770: 81 11 cpse r24, r1
772: e0 e0 ldi r30, 0x00 ; 0
774: e1 95 neg r30
776: f0 e0 ldi r31, 0x00 ; 0
778: ef 5b subi r30, 0xBF ; 191
77a: fe 4f sbci r31, 0xFE ; 254
77c: 84 89 ldd r24, Z+20 ; 0x14
77e: 80 68 ori r24, 0x80 ; 128
780: 0e 94 05 02 call 0x40a ; 0x40a
return write(s.c_str(), s.length());
}
size_t Print::print(const char str[])

{
return write(str);
784: 8c e0 ldi r24, 0x0C ; 12
786: 91 e0 ldi r25, 0x01 ; 1
788: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
{
const size_t max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
if ( row >= max_lines ) {
row = max_lines - 1; // we count rows starting w/0
}
78c: e0 91 54 01 lds r30, 0x0154 ; 0x800154 <lcd+0x13>
790: e2 30 cpi r30, 0x02 ; 2
792: 10 f4 brcc .+4 ; 0x798 <main+0x16e>
794: e1 50 subi r30, 0x01 ; 1
796: 01 c0 rjmp .+2 ; 0x79a <main+0x170>
{
const size_t max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
if ( row >= max_lines ) {
row = max_lines - 1; // we count rows starting w/0
}
798: e1 e0 ldi r30, 0x01 ; 1
}
command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));

79a: f0 e0 ldi r31, 0x00 ; 0
79c: ef 5b subi r30, 0xBF ; 191
79e: fe 4f sbci r31, 0xFE ; 254
7a0: 84 89 ldd r24, Z+20 ; 0x14
7a2: 80 68 ori r24, 0x80 ; 128
7a4: 0e 94 05 02 call 0x40a ; 0x40a
7a8: 8d e1 ldi r24, 0x1D ; 29
7aa: 91 e0 ldi r25, 0x01 ; 1
7ac: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
size_t Print::printFloat(double number, uint8_t digits)

{
size_t n = 0;
if (isnan(number)) return print("nan");

7b0: a7 01 movw r20, r14
7b2: 96 01 movw r18, r12
7b4: c7 01 movw r24, r14
7b6: b6 01 movw r22, r12
7b8: 0e 94 75 07 call 0xeea ; 0xeea <__unordsf2>
7bc: 88 23 and r24, r24
7be: 19 f0 breq .+6 ; 0x7c6 <main+0x19c>
}

{
return write(str);
7c0: 86 e2 ldi r24, 0x26 ; 38
7c2: 91 e0 ldi r25, 0x01 ; 1
7c4: 1a c0 rjmp .+52 ; 0x7fa <main+0x1d0>
size_t Print::printFloat(double number, uint8_t digits)
{
size_t n = 0;

if (isinf(number)) return print("inf");
7c6: 26 01 movw r4, r12
7c8: 37 01 movw r6, r14
7ca: e8 94 clt
7cc: 77 f8 bld r7, 7
7ce: 2f ef ldi r18, 0xFF ; 255
7d0: 3f ef ldi r19, 0xFF ; 255
7d2: 4f e7 ldi r20, 0x7F ; 127
7d4: 5f e7 ldi r21, 0x7F ; 127
7d6: c3 01 movw r24, r6
7d8: b2 01 movw r22, r4
7da: 0e 94 75 07 call 0xeea ; 0xeea <__unordsf2>
7de: 81 11 cpse r24, r1
7e0: 0f c0 rjmp .+30 ; 0x800 <main+0x1d6>
7e2: 2f ef ldi r18, 0xFF ; 255
7e4: 3f ef ldi r19, 0xFF ; 255
7e6: 4f e7 ldi r20, 0x7F ; 127
7e8: 5f e7 ldi r21, 0x7F ; 127
7ea: c3 01 movw r24, r6
7ec: b2 01 movw r22, r4
7ee: 0e 94 5b 05 call 0xab6 ; 0xab6 <__cmpsf2>
7f2: 18 16 cp r1, r24
7f4: 2c f4 brge .+10 ; 0x800 <main+0x1d6>
}

{
return write(str);
7f6: 8a e2 ldi r24, 0x2A ; 42
7f8: 91 e0 ldi r25, 0x01 ; 1
7fa: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
7fe: 9d c0 rjmp .+314 ; 0x93a <__stack+0x3b>
{
size_t n = 0;

if (number > 4294967040.0) return print ("ovf"); // constant determined
empirically
800: 2f ef ldi r18, 0xFF ; 255
802: 3f ef ldi r19, 0xFF ; 255
804: 4f e7 ldi r20, 0x7F ; 127
806: 5f e4 ldi r21, 0x4F ; 79
808: c7 01 movw r24, r14
80a: b6 01 movw r22, r12
80c: 0e 94 b3 06 call 0xd66 ; 0xd66 <__gesf2>
810: 18 16 cp r1, r24
812: 1c f4 brge .+6 ; 0x81a <main+0x1f0>
}

{
return write(str);
814: 8e e2 ldi r24, 0x2E ; 46
816: 91 e0 ldi r25, 0x01 ; 1
818: f0 cf rjmp .-32 ; 0x7fa <main+0x1d0>
size_t n = 0;

if (number > 4294967040.0) return print ("ovf"); // constant determined
empirically
if (number <-4294967040.0) return print ("ovf"); // constant determined
empirically
81a: 2f ef ldi r18, 0xFF ; 255
81c: 3f ef ldi r19, 0xFF ; 255
81e: 4f e7 ldi r20, 0x7F ; 127
820: 5f ec ldi r21, 0xCF ; 207
822: c7 01 movw r24, r14
824: b6 01 movw r22, r12
826: 0e 94 5b 05 call 0xab6 ; 0xab6 <__cmpsf2>
82a: 87 fd sbrc r24, 7
82c: f3 cf rjmp .-26 ; 0x814 <main+0x1ea>
// Handle negative numbers

if (number < 0.0)
82e: 20 e0 ldi r18, 0x00 ; 0
830: 30 e0 ldi r19, 0x00 ; 0
832: a9 01 movw r20, r18
834: c7 01 movw r24, r14
836: b6 01 movw r22, r12
838: 0e 94 5b 05 call 0xab6 ; 0xab6 <__cmpsf2>
83c: 87 ff sbrs r24, 7
83e: 0a c0 rjmp .+20 ; 0x854 <main+0x22a>
send(value, LOW);
}
inline size_t LiquidCrystal::write(uint8_t value) {

send(value, HIGH);
840: 41 e0 ldi r20, 0x01 ; 1
842: 6d e2 ldi r22, 0x2D ; 45
844: 81 e4 ldi r24, 0x41 ; 65
846: 91 e0 ldi r25, 0x01 ; 1
848: 0e 94 b2 01 call 0x364 ; 0x364 <_ZN13LiquidCrystal4sendEhh>
{
n += print('-');
number = -number;
84c: f7 fa bst r15, 7
84e: f0 94 com r15
850: f7 f8 bld r15, 7
852: 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<digits; ++i)
rounding /= 10.0;
number += rounding;
854: 2a e0 ldi r18, 0x0A ; 10
856: 37 ed ldi r19, 0xD7 ; 215
858: 43 ea ldi r20, 0xA3 ; 163
85a: 5b e3 ldi r21, 0x3B ; 59
85c: c7 01 movw r24, r14
85e: b6 01 movw r22, r12
860: 0e 94 ef 04 call 0x9de ; 0x9de <__addsf3>
864: 2b 01 movw r4, r22
866: 3c 01 movw r6, r24
// Extract the integer part of the number and print it

unsigned long int_part = (unsigned long)number;
868: 0e 94 d2 05 call 0xba4 ; 0xba4 <__fixunssfsi>
86c: 6b 01 movw r12, r22
86e: 7c 01 movw r14, r24
double remainder = number - (double)int_part;
870: 0e 94 01 06 call 0xc02 ; 0xc02 <__floatunsisf>
874: 9b 01 movw r18, r22
876: ac 01 movw r20, r24
878: c3 01 movw r24, r6
87a: b2 01 movw r22, r4
87c: 0e 94 ee 04 call 0x9dc ; 0x9dc <__subsf3>
880: 1b 01 movw r2, r22
882: 2c 01 movw r4, r24
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';
884: 19 a2 std Y+33, r1 ; 0x21
886: 8e 01 movw r16, r28
888: 0f 5d subi r16, 0xDF ; 223
88a: 1f 4f sbci r17, 0xFF ; 255
88c: 0a a3 std Y+34, r16 ; 0x22
88e: 71 2e mov r7, r17
do {
char c = n % base;
n /= base;
890: c7 01 movw r24, r14
892: b6 01 movw r22, r12
894: a5 01 movw r20, r10
896: 94 01 movw r18, r8
898: 0e 94 af 07 call 0xf5e ; 0xf5e <__udivmodsi4>
89c: 69 01 movw r12, r18
89e: 7a 01 movw r14, r20
*--str = c < 10 ? c + '0' : c + 'A' - 10;

8a0: 60 5d subi r22, 0xD0 ; 208
8a2: f8 01 movw r30, r16
8a4: 62 93 st -Z, r22
8a6: 8f 01 movw r16, r30
*str = '\0';

do {
8a8: 23 2b or r18, r19
8aa: 24 2b or r18, r20
8ac: 25 2b or r18, r21
8ae: 81 f7 brne .-32 ; 0x890 <main+0x266>
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;

} while(n);
return write(str);
8b0: cf 01 movw r24, r30
8b2: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
8b6: 41 e0 ldi r20, 0x01 ; 1
8b8: 6e e2 ldi r22, 0x2E ; 46
8ba: 81 e4 ldi r24, 0x41 ; 65
8bc: 91 e0 ldi r25, 0x01 ; 1
8be: 0e 94 b2 01 call 0x364 ; 0x364 <_ZN13LiquidCrystal4sendEhh>
8c2: 93 e0 ldi r25, 0x03 ; 3
8c4: f9 2e mov r15, r25
8c6: fa 94 dec r15
if (digits > 0) {
n += print('.');
}
// Extract digits from the remainder one at a time

while (digits-- > 0)
8c8: ff 20 and r15, r15
8ca: b9 f1 breq .+110 ; 0x93a <__stack+0x3b>
{
remainder *= 10.0;
8cc: 20 e0 ldi r18, 0x00 ; 0
8ce: 30 e0 ldi r19, 0x00 ; 0
8d0: 40 e2 ldi r20, 0x20 ; 32
8d2: 51 e4 ldi r21, 0x41 ; 65
8d4: c2 01 movw r24, r4
8d6: b1 01 movw r22, r2
8d8: 0e 94 08 07 call 0xe10 ; 0xe10 <__mulsf3>
8dc: 1b 01 movw r2, r22
8de: 2c 01 movw r4, r24
unsigned int toPrint = (unsigned int)(remainder);
8e0: 0e 94 d2 05 call 0xba4 ; 0xba4 <__fixunssfsi>
return print((long) n, base);
}
size_t Print::print(unsigned int n, int base)

{
return print((unsigned long) n, base);
8e4: 9b 01 movw r18, r22
8e6: 40 e0 ldi r20, 0x00 ; 0
8e8: 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';
8ea: 19 a2 std Y+33, r1 ; 0x21
8ec: 0a a1 ldd r16, Y+34 ; 0x22
8ee: 17 2d mov r17, r7
8f0: 66 2e mov r6, r22
8f2: c3 2e mov r12, r19
8f4: d4 2e mov r13, r20
8f6: e5 2e mov r14, r21
do {
char c = n % base;
n /= base;
8f8: ca 01 movw r24, r20
8fa: b9 01 movw r22, r18
8fc: a5 01 movw r20, r10
8fe: 94 01 movw r18, r8
900: 0e 94 af 07 call 0xf5e ; 0xf5e <__udivmodsi4>
*--str = c < 10 ? c + '0' : c + 'A' - 10;

904: 60 5d subi r22, 0xD0 ; 208
906: f8 01 movw r30, r16
908: 62 93 st -Z, r22
90a: 8f 01 movw r16, r30
*str = '\0';

do {
90c: 21 15 cp r18, r1
90e: 31 05 cpc r19, r1
910: 41 05 cpc r20, r1
912: 51 05 cpc r21, r1
914: 89 f7 brne .-30 ; 0x8f8 <main+0x2ce>
n /= base;
*--str = c < 10 ? c + '0' : c + 'A' - 10;

} while(n);
return write(str);
916: cf 01 movw r24, r30
918: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
while (digits-- > 0)
{
remainder *= 10.0;
unsigned int toPrint = (unsigned int)(remainder);
n += print(toPrint);
remainder -= toPrint;
91c: 66 2d mov r22, r6
91e: 7c 2d mov r23, r12
920: 8d 2d mov r24, r13
922: 9e 2d mov r25, r14
924: 0e 94 01 06 call 0xc02 ; 0xc02 <__floatunsisf>
928: 9b 01 movw r18, r22
92a: ac 01 movw r20, r24
92c: c2 01 movw r24, r4
92e: b1 01 movw r22, r2
930: 0e 94 ee 04 call 0x9dc ; 0x9dc <__subsf3>
934: 1b 01 movw r2, r22
936: 2c 01 movw r4, r24
938: c6 cf rjmp .-116 ; 0x8c6 <main+0x29c>
}

{
return write(str);
93a: 82 e3 ldi r24, 0x32 ; 50
93c: 91 e0 ldi r25, 0x01 ; 1
93e: 0e 94 b7 02 call 0x56e ; 0x56e <_ZN5Print5writeEPKc.constprop.10>
return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
}
void delay(unsigned long ms)

{
uint32_t start = micros();
942: 0e 94 20 01 call 0x240 ; 0x240 <micros>
946: 6b 01 movw r12, r22
948: 7c 01 movw r14, r24
94a: 84 ef ldi r24, 0xF4 ; 244
94c: 48 2e mov r4, r24
94e: 55 24 eor r5, r5
950: 53 94 inc r5
952: 61 2c mov r6, r1
954: 71 2c mov r7, r1
while (ms > 0) {

yield();
while ( ms > 0 && (micros() - start) >= 1000) {
956: 0e 94 20 01 call 0x240 ; 0x240 <micros>
95a: dc 01 movw r26, r24
95c: cb 01 movw r24, r22
95e: 8c 19 sub r24, r12
960: 9d 09 sbc r25, r13
962: ae 09 sbc r26, r14
964: bf 09 sbc r27, r15
966: 88 3e cpi r24, 0xE8 ; 232
968: 93 40 sbci r25, 0x03 ; 3
96a: a1 05 cpc r26, r1
96c: b1 05 cpc r27, r1
96e: 98 f3 brcs .-26 ; 0x956 <__stack+0x57>
ms--;
970: f1 e0 ldi r31, 0x01 ; 1
972: 4f 1a sub r4, r31
974: 51 08 sbc r5, r1
976: 61 08 sbc r6, r1
978: 71 08 sbc r7, r1
start += 1000;
97a: 28 ee ldi r18, 0xE8 ; 232
97c: c2 0e add r12, r18
97e: 23 e0 ldi r18, 0x03 ; 3
980: d2 1e adc r13, r18
982: e1 1c adc r14, r1
984: f1 1c adc r15, r1
{
uint32_t start = micros();
while (ms > 0) {

yield();
while ( ms > 0 && (micros() - start) >= 1000) {
986: 41 14 cp r4, r1
988: 51 04 cpc r5, r1
98a: 61 04 cpc r6, r1
98c: 71 04 cpc r7, r1
98e: 19 f7 brne .-58 ; 0x956 <__stack+0x57>
setup();
for (;;) {
loop();
if (serialEventRun) serialEventRun();
990: 80 e0 ldi r24, 0x00 ; 0
992: 90 e0 ldi r25, 0x00 ; 0
994: 89 2b or r24, r25
996: 09 f4 brne .+2 ; 0x99a <__stack+0x9b>
998: a4 ce rjmp .-696 ; 0x6e2 <main+0xb8>
99a: 0e 94 00 00 call 0 ; 0x0 <__vectors>
99e: a1 ce rjmp .-702 ; 0x6e2 <main+0xb8>
000009a0 <_GLOBAL__sub_I_tim>:
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) {}
9a0: e1 e4 ldi r30, 0x41 ; 65
9a2: f1 e0 ldi r31, 0x01 ; 1
9a4: 13 82 std Z+3, r1 ; 0x03
9a6: 12 82 std Z+2, r1 ; 0x02
{
init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}
LiquidCrystal::LiquidCrystal(uint8_t rs, uint8_t enable,

uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
9a8: 84 e0 ldi r24, 0x04 ; 4
9aa: 91 e0 ldi r25, 0x01 ; 1
9ac: 91 83 std Z+1, r25 ; 0x01
9ae: 80 83 st Z, r24
void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t

enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
_rs_pin = rs;
9b0: 84 e0 ldi r24, 0x04 ; 4
9b2: 84 83 std Z+4, r24 ; 0x04
_rw_pin = rw;
9b4: 8f ef ldi r24, 0xFF ; 255
9b6: 85 83 std Z+5, r24 ; 0x05
_enable_pin = enable;
9b8: 86 e0 ldi r24, 0x06 ; 6
9ba: 86 83 std Z+6, r24 ; 0x06
_data_pins[0] = d0;
9bc: 8a e0 ldi r24, 0x0A ; 10
9be: 87 83 std Z+7, r24 ; 0x07
_data_pins[1] = d1;
9c0: 8b e0 ldi r24, 0x0B ; 11
9c2: 80 87 std Z+8, r24 ; 0x08
_data_pins[2] = d2;
9c4: 8c e0 ldi r24, 0x0C ; 12
9c6: 81 87 std Z+9, r24 ; 0x09
_data_pins[3] = d3;
9c8: 8d e0 ldi r24, 0x0D ; 13
9ca: 82 87 std Z+10, r24 ; 0x0a
_data_pins[4] = d4;
9cc: 13 86 std Z+11, r1 ; 0x0b
_data_pins[5] = d5;
9ce: 14 86 std Z+12, r1 ; 0x0c
_data_pins[6] = d6;
9d0: 15 86 std Z+13, r1 ; 0x0d
_data_pins[7] = d7;
9d2: 16 86 std Z+14, r1 ; 0x0e
if (fourbitmode)
9d4: 17 86 std Z+15, r1 ; 0x0f
else
begin(16, 1);
9d6: 81 e0 ldi r24, 0x01 ; 1
9d8: 0c 94 0b 02 jmp 0x416 ; 0x416
<_ZN13LiquidCrystal5beginEhhh.constprop.14>
000009dc <__subsf3>:
9dc: 50 58 subi r21, 0x80 ; 128
000009de <__addsf3>:
9de: bb 27 eor r27, r27
9e0: aa 27 eor r26, r26
9e2: 0e 94 06 05 call 0xa0c ; 0xa0c <__addsf3x>
9e6: 0c 94 79 06 jmp 0xcf2 ; 0xcf2 <__fp_round>
9ea: 0e 94 6b 06 call 0xcd6 ; 0xcd6 <__fp_pscA>
9ee: 38 f0 brcs .+14 ; 0x9fe <__addsf3+0x20>
9f0: 0e 94 72 06 call 0xce4 ; 0xce4 <__fp_pscB>
9f4: 20 f0 brcs .+8 ; 0x9fe <__addsf3+0x20>
9f6: 39 f4 brne .+14 ; 0xa06 <__addsf3+0x28>
9f8: 9f 3f cpi r25, 0xFF ; 255
9fa: 19 f4 brne .+6 ; 0xa02 <__addsf3+0x24>
9fc: 26 f4 brtc .+8 ; 0xa06 <__addsf3+0x28>
9fe: 0c 94 68 06 jmp 0xcd0 ; 0xcd0 <__fp_nan>
a02: 0e f4 brtc .+2 ; 0xa06 <__addsf3+0x28>
a04: e0 95 com r30
a06: e7 fb bst r30, 7
a08: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
00000a0c <__addsf3x>:
a0c: e9 2f mov r30, r25
a0e: 0e 94 8a 06 call 0xd14 ; 0xd14 <__fp_split3>
a12: 58 f3 brcs .-42 ; 0x9ea <__addsf3+0xc>
a14: ba 17 cp r27, r26
a16: 62 07 cpc r22, r18
a18: 73 07 cpc r23, r19
a1a: 84 07 cpc r24, r20
a1c: 95 07 cpc r25, r21
a1e: 20 f0 brcs .+8 ; 0xa28 <__addsf3x+0x1c>
a20: 79 f4 brne .+30 ; 0xa40 <__addsf3x+0x34>
a22: a6 f5 brtc .+104 ; 0xa8c <__addsf3x+0x80>
a24: 0c 94 ac 06 jmp 0xd58 ; 0xd58 <__fp_zero>
a28: 0e f4 brtc .+2 ; 0xa2c <__addsf3x+0x20>
a2a: e0 95 com r30
a2c: 0b 2e mov r0, r27
a2e: ba 2f mov r27, r26
a30: a0 2d mov r26, r0
a32: 0b 01 movw r0, r22
a34: b9 01 movw r22, r18
a36: 90 01 movw r18, r0
a38: 0c 01 movw r0, r24
a3a: ca 01 movw r24, r20
a3c: a0 01 movw r20, r0
a3e: 11 24 eor r1, r1
a40: ff 27 eor r31, r31
a42: 59 1b sub r21, r25
a44: 99 f0 breq .+38 ; 0xa6c <__addsf3x+0x60>
a46: 59 3f cpi r21, 0xF9 ; 249
a48: 50 f4 brcc .+20 ; 0xa5e <__addsf3x+0x52>
a4a: 50 3e cpi r21, 0xE0 ; 224
a4c: 68 f1 brcs .+90 ; 0xaa8 <__addsf3x+0x9c>
a4e: 1a 16 cp r1, r26
a50: f0 40 sbci r31, 0x00 ; 0
a52: a2 2f mov r26, r18
a54: 23 2f mov r18, r19
a56: 34 2f mov r19, r20
a58: 44 27 eor r20, r20
a5a: 58 5f subi r21, 0xF8 ; 248
a5c: f3 cf rjmp .-26 ; 0xa44 <__addsf3x+0x38>
a5e: 46 95 lsr r20
a60: 37 95 ror r19
a62: 27 95 ror r18
a64: a7 95 ror r26
a66: f0 40 sbci r31, 0x00 ; 0
a68: 53 95 inc r21
a6a: c9 f7 brne .-14 ; 0xa5e <__addsf3x+0x52>
a6c: 7e f4 brtc .+30 ; 0xa8c <__addsf3x+0x80>
a6e: 1f 16 cp r1, r31
a70: ba 0b sbc r27, r26
a72: 62 0b sbc r22, r18
a74: 73 0b sbc r23, r19
a76: 84 0b sbc r24, r20
a78: ba f0 brmi .+46 ; 0xaa8 <__addsf3x+0x9c>
a7a: 91 50 subi r25, 0x01 ; 1
a7c: a1 f0 breq .+40 ; 0xaa6 <__addsf3x+0x9a>
a7e: ff 0f add r31, r31
a80: bb 1f adc r27, r27
a82: 66 1f adc r22, r22
a84: 77 1f adc r23, r23
a86: 88 1f adc r24, r24
a88: c2 f7 brpl .-16 ; 0xa7a <__addsf3x+0x6e>
a8a: 0e c0 rjmp .+28 ; 0xaa8 <__addsf3x+0x9c>
a8c: ba 0f add r27, r26
a8e: 62 1f adc r22, r18
a90: 73 1f adc r23, r19
a92: 84 1f adc r24, r20
a94: 48 f4 brcc .+18 ; 0xaa8 <__addsf3x+0x9c>
a96: 87 95 ror r24
a98: 77 95 ror r23
a9a: 67 95 ror r22
a9c: b7 95 ror r27
a9e: f7 95 ror r31
aa0: 9e 3f cpi r25, 0xFE ; 254
aa2: 08 f0 brcs .+2 ; 0xaa6 <__addsf3x+0x9a>
aa4: b0 cf rjmp .-160 ; 0xa06 <__addsf3+0x28>
aa6: 93 95 inc r25
aa8: 88 0f add r24, r24
aaa: 08 f0 brcs .+2 ; 0xaae <__addsf3x+0xa2>
aac: 99 27 eor r25, r25
aae: ee 0f add r30, r30
ab0: 97 95 ror r25
ab2: 87 95 ror r24
ab4: 08 95 ret
00000ab6 <__cmpsf2>:
ab6: 0e 94 3e 06 call 0xc7c ; 0xc7c <__fp_cmp>
aba: 08 f4 brcc .+2 ; 0xabe <__cmpsf2+0x8>
abc: 81 e0 ldi r24, 0x01 ; 1
abe: 08 95 ret
00000ac0 <__divsf3>:
ac0: 0e 94 74 05 call 0xae8 ; 0xae8 <__divsf3x>
ac4: 0c 94 79 06 jmp 0xcf2 ; 0xcf2 <__fp_round>
ac8: 0e 94 72 06 call 0xce4 ; 0xce4 <__fp_pscB>
acc: 58 f0 brcs .+22 ; 0xae4 <__divsf3+0x24>
ace: 0e 94 6b 06 call 0xcd6 ; 0xcd6 <__fp_pscA>
ad2: 40 f0 brcs .+16 ; 0xae4 <__divsf3+0x24>
ad4: 29 f4 brne .+10 ; 0xae0 <__divsf3+0x20>
ad6: 5f 3f cpi r21, 0xFF ; 255
ad8: 29 f0 breq .+10 ; 0xae4 <__divsf3+0x24>
ada: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
ade: 51 11 cpse r21, r1
ae0: 0c 94 ad 06 jmp 0xd5a ; 0xd5a <__fp_szero>
ae4: 0c 94 68 06 jmp 0xcd0 ; 0xcd0 <__fp_nan>
00000ae8 <__divsf3x>:
ae8: 0e 94 8a 06 call 0xd14 ; 0xd14 <__fp_split3>
aec: 68 f3 brcs .-38 ; 0xac8 <__divsf3+0x8>
00000aee <__divsf3_pse>:
aee: 99 23 and r25, r25
af0: b1 f3 breq .-20 ; 0xade <__divsf3+0x1e>
af2: 55 23 and r21, r21
af4: 91 f3 breq .-28 ; 0xada <__divsf3+0x1a>
af6: 95 1b sub r25, r21
af8: 55 0b sbc r21, r21
afa: bb 27 eor r27, r27
afc: aa 27 eor r26, r26
afe: 62 17 cp r22, r18
b00: 73 07 cpc r23, r19
b02: 84 07 cpc r24, r20
b04: 38 f0 brcs .+14 ; 0xb14 <__divsf3_pse+0x26>
b06: 9f 5f subi r25, 0xFF ; 255
b08: 5f 4f sbci r21, 0xFF ; 255
b0a: 22 0f add r18, r18
b0c: 33 1f adc r19, r19
b0e: 44 1f adc r20, r20
b10: aa 1f adc r26, r26
b12: a9 f3 breq .-22 ; 0xafe <__divsf3_pse+0x10>
b14: 35 d0 rcall .+106 ; 0xb80 <__divsf3_pse+0x92>
b16: 0e 2e mov r0, r30
b18: 3a f0 brmi .+14 ; 0xb28 <__divsf3_pse+0x3a>
b1a: e0 e8 ldi r30, 0x80 ; 128
b1c: 32 d0 rcall .+100 ; 0xb82 <__divsf3_pse+0x94>
b1e: 91 50 subi r25, 0x01 ; 1
b20: 50 40 sbci r21, 0x00 ; 0
b22: e6 95 lsr r30
b24: 00 1c adc r0, r0
b26: ca f7 brpl .-14 ; 0xb1a <__divsf3_pse+0x2c>
b28: 2b d0 rcall .+86 ; 0xb80 <__divsf3_pse+0x92>
b2a: fe 2f mov r31, r30
b2c: 29 d0 rcall .+82 ; 0xb80 <__divsf3_pse+0x92>
b2e: 66 0f add r22, r22
b30: 77 1f adc r23, r23
b32: 88 1f adc r24, r24
b34: bb 1f adc r27, r27
b36: 26 17 cp r18, r22
b38: 37 07 cpc r19, r23
b3a: 48 07 cpc r20, r24
b3c: ab 07 cpc r26, r27
b3e: b0 e8 ldi r27, 0x80 ; 128
b40: 09 f0 breq .+2 ; 0xb44 <__divsf3_pse+0x56>
b42: bb 0b sbc r27, r27
b44: 80 2d mov r24, r0
b46: bf 01 movw r22, r30
b48: ff 27 eor r31, r31
b4a: 93 58 subi r25, 0x83 ; 131
b4c: 5f 4f sbci r21, 0xFF ; 255
b4e: 3a f0 brmi .+14 ; 0xb5e <__divsf3_pse+0x70>
b50: 9e 3f cpi r25, 0xFE ; 254
b52: 51 05 cpc r21, r1
b54: 78 f0 brcs .+30 ; 0xb74 <__divsf3_pse+0x86>
b56: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
b5a: 0c 94 ad 06 jmp 0xd5a ; 0xd5a <__fp_szero>
b5e: 5f 3f cpi r21, 0xFF ; 255
b60: e4 f3 brlt .-8 ; 0xb5a <__divsf3_pse+0x6c>
b62: 98 3e cpi r25, 0xE8 ; 232
b64: d4 f3 brlt .-12 ; 0xb5a <__divsf3_pse+0x6c>
b66: 86 95 lsr r24
b68: 77 95 ror r23
b6a: 67 95 ror r22
b6c: b7 95 ror r27
b6e: f7 95 ror r31
b70: 9f 5f subi r25, 0xFF ; 255
b72: c9 f7 brne .-14 ; 0xb66 <__divsf3_pse+0x78>
b74: 88 0f add r24, r24
b76: 91 1d adc r25, r1
b78: 96 95 lsr r25
b7a: 87 95 ror r24
b7c: 97 f9 bld r25, 7
b7e: 08 95 ret
b80: e1 e0 ldi r30, 0x01 ; 1
b82: 66 0f add r22, r22
b84: 77 1f adc r23, r23
b86: 88 1f adc r24, r24
b88: bb 1f adc r27, r27
b8a: 62 17 cp r22, r18
b8c: 73 07 cpc r23, r19
b8e: 84 07 cpc r24, r20
b90: ba 07 cpc r27, r26
b92: 20 f0 brcs .+8 ; 0xb9c <__divsf3_pse+0xae>
b94: 62 1b sub r22, r18
b96: 73 0b sbc r23, r19
b98: 84 0b sbc r24, r20
b9a: ba 0b sbc r27, r26
b9c: ee 1f adc r30, r30
b9e: 88 f7 brcc .-30 ; 0xb82 <__divsf3_pse+0x94>
ba0: e0 95 com r30
ba2: 08 95 ret
00000ba4 <__fixunssfsi>:
ba4: 0e 94 92 06 call 0xd24 ; 0xd24 <__fp_splitA>
ba8: 88 f0 brcs .+34 ; 0xbcc <__fixunssfsi+0x28>
baa: 9f 57 subi r25, 0x7F ; 127
bac: 98 f0 brcs .+38 ; 0xbd4 <__fixunssfsi+0x30>
bae: b9 2f mov r27, r25
bb0: 99 27 eor r25, r25
bb2: b7 51 subi r27, 0x17 ; 23
bb4: b0 f0 brcs .+44 ; 0xbe2 <__fixunssfsi+0x3e>
bb6: e1 f0 breq .+56 ; 0xbf0 <__fixunssfsi+0x4c>
bb8: 66 0f add r22, r22
bba: 77 1f adc r23, r23
bbc: 88 1f adc r24, r24
bbe: 99 1f adc r25, r25
bc0: 1a f0 brmi .+6 ; 0xbc8 <__fixunssfsi+0x24>
bc2: ba 95 dec r27
bc4: c9 f7 brne .-14 ; 0xbb8 <__fixunssfsi+0x14>
bc6: 14 c0 rjmp .+40 ; 0xbf0 <__fixunssfsi+0x4c>
bc8: b1 30 cpi r27, 0x01 ; 1
bca: 91 f0 breq .+36 ; 0xbf0 <__fixunssfsi+0x4c>
bcc: 0e 94 ac 06 call 0xd58 ; 0xd58 <__fp_zero>
bd0: b1 e0 ldi r27, 0x01 ; 1
bd2: 08 95 ret
bd4: 0c 94 ac 06 jmp 0xd58 ; 0xd58 <__fp_zero>
bd8: 67 2f mov r22, r23
bda: 78 2f mov r23, r24
bdc: 88 27 eor r24, r24
bde: b8 5f subi r27, 0xF8 ; 248
be0: 39 f0 breq .+14 ; 0xbf0 <__fixunssfsi+0x4c>
be2: b9 3f cpi r27, 0xF9 ; 249
be4: cc f3 brlt .-14 ; 0xbd8 <__fixunssfsi+0x34>
be6: 86 95 lsr r24
be8: 77 95 ror r23
bea: 67 95 ror r22
bec: b3 95 inc r27
bee: d9 f7 brne .-10 ; 0xbe6 <__fixunssfsi+0x42>
bf0: 3e f4 brtc .+14 ; 0xc00 <__fixunssfsi+0x5c>
bf2: 90 95 com r25
bf4: 80 95 com r24
bf6: 70 95 com r23
bf8: 61 95 neg r22
bfa: 7f 4f sbci r23, 0xFF ; 255
bfc: 8f 4f sbci r24, 0xFF ; 255
bfe: 9f 4f sbci r25, 0xFF ; 255
c00: 08 95 ret
00000c02 <__floatunsisf>:
c02: e8 94 clt
c04: 09 c0 rjmp .+18 ; 0xc18 <__floatsisf+0x12>
00000c06 <__floatsisf>:
c06: 97 fb bst r25, 7
c08: 3e f4 brtc .+14 ; 0xc18 <__floatsisf+0x12>
c0a: 90 95 com r25
c0c: 80 95 com r24
c0e: 70 95 com r23
c10: 61 95 neg r22
c12: 7f 4f sbci r23, 0xFF ; 255
c14: 8f 4f sbci r24, 0xFF ; 255
c16: 9f 4f sbci r25, 0xFF ; 255
c18: 99 23 and r25, r25
c1a: a9 f0 breq .+42 ; 0xc46 <__floatsisf+0x40>
c1c: f9 2f mov r31, r25
c1e: 96 e9 ldi r25, 0x96 ; 150
c20: bb 27 eor r27, r27
c22: 93 95 inc r25
c24: f6 95 lsr r31
c26: 87 95 ror r24
c28: 77 95 ror r23
c2a: 67 95 ror r22
c2c: b7 95 ror r27
c2e: f1 11 cpse r31, r1
c30: f8 cf rjmp .-16 ; 0xc22 <__floatsisf+0x1c>
c32: fa f4 brpl .+62 ; 0xc72 <__floatsisf+0x6c>
c34: bb 0f add r27, r27
c36: 11 f4 brne .+4 ; 0xc3c <__floatsisf+0x36>
c38: 60 ff sbrs r22, 0
c3a: 1b c0 rjmp .+54 ; 0xc72 <__floatsisf+0x6c>
c3c: 6f 5f subi r22, 0xFF ; 255
c3e: 7f 4f sbci r23, 0xFF ; 255
c40: 8f 4f sbci r24, 0xFF ; 255
c42: 9f 4f sbci r25, 0xFF ; 255
c44: 16 c0 rjmp .+44 ; 0xc72 <__floatsisf+0x6c>
c46: 88 23 and r24, r24
c48: 11 f0 breq .+4 ; 0xc4e <__floatsisf+0x48>
c4a: 96 e9 ldi r25, 0x96 ; 150
c4c: 11 c0 rjmp .+34 ; 0xc70 <__floatsisf+0x6a>
c4e: 77 23 and r23, r23
c50: 21 f0 breq .+8 ; 0xc5a <__floatsisf+0x54>
c52: 9e e8 ldi r25, 0x8E ; 142
c54: 87 2f mov r24, r23
c56: 76 2f mov r23, r22
c58: 05 c0 rjmp .+10 ; 0xc64 <__floatsisf+0x5e>
c5a: 66 23 and r22, r22
c5c: 71 f0 breq .+28 ; 0xc7a <__floatsisf+0x74>
c5e: 96 e8 ldi r25, 0x86 ; 134
c60: 86 2f mov r24, r22
c62: 70 e0 ldi r23, 0x00 ; 0
c64: 60 e0 ldi r22, 0x00 ; 0
c66: 2a f0 brmi .+10 ; 0xc72 <__floatsisf+0x6c>
c68: 9a 95 dec r25
c6a: 66 0f add r22, r22
c6c: 77 1f adc r23, r23
c6e: 88 1f adc r24, r24
c70: da f7 brpl .-10 ; 0xc68 <__floatsisf+0x62>
c72: 88 0f add r24, r24
c74: 96 95 lsr r25
c76: 87 95 ror r24
c78: 97 f9 bld r25, 7
c7a: 08 95 ret
00000c7c <__fp_cmp>:
c7c: 99 0f add r25, r25
c7e: 00 08 sbc r0, r0
c80: 55 0f add r21, r21
c82: aa 0b sbc r26, r26
c84: e0 e8 ldi r30, 0x80 ; 128
c86: fe ef ldi r31, 0xFE ; 254
c88: 16 16 cp r1, r22
c8a: 17 06 cpc r1, r23
c8c: e8 07 cpc r30, r24
c8e: f9 07 cpc r31, r25
c90: c0 f0 brcs .+48 ; 0xcc2 <__fp_cmp+0x46>
c92: 12 16 cp r1, r18
c94: 13 06 cpc r1, r19
c96: e4 07 cpc r30, r20
c98: f5 07 cpc r31, r21
c9a: 98 f0 brcs .+38 ; 0xcc2 <__fp_cmp+0x46>
c9c: 62 1b sub r22, r18
c9e: 73 0b sbc r23, r19
ca0: 84 0b sbc r24, r20
ca2: 95 0b sbc r25, r21
ca4: 39 f4 brne .+14 ; 0xcb4 <__fp_cmp+0x38>
ca6: 0a 26 eor r0, r26
ca8: 61 f0 breq .+24 ; 0xcc2 <__fp_cmp+0x46>
caa: 23 2b or r18, r19
cac: 24 2b or r18, r20
cae: 25 2b or r18, r21
cb0: 21 f4 brne .+8 ; 0xcba <__fp_cmp+0x3e>
cb2: 08 95 ret
cb4: 0a 26 eor r0, r26
cb6: 09 f4 brne .+2 ; 0xcba <__fp_cmp+0x3e>
cb8: a1 40 sbci r26, 0x01 ; 1
cba: a6 95 lsr r26
cbc: 8f ef ldi r24, 0xFF ; 255
cbe: 81 1d adc r24, r1
cc0: 81 1d adc r24, r1
cc2: 08 95 ret
00000cc4 <__fp_inf>:
cc4: 97 f9 bld r25, 7
cc6: 9f 67 ori r25, 0x7F ; 127
cc8: 80 e8 ldi r24, 0x80 ; 128
cca: 70 e0 ldi r23, 0x00 ; 0
ccc: 60 e0 ldi r22, 0x00 ; 0
cce: 08 95 ret
00000cd0 <__fp_nan>:
cd0: 9f ef ldi r25, 0xFF ; 255
cd2: 80 ec ldi r24, 0xC0 ; 192
cd4: 08 95 ret
00000cd6 <__fp_pscA>:
cd6: 00 24 eor r0, r0
cd8: 0a 94 dec r0
cda: 16 16 cp r1, r22
cdc: 17 06 cpc r1, r23
cde: 18 06 cpc r1, r24
ce0: 09 06 cpc r0, r25
ce2: 08 95 ret
00000ce4 <__fp_pscB>:
ce4: 00 24 eor r0, r0
ce6: 0a 94 dec r0
ce8: 12 16 cp r1, r18
cea: 13 06 cpc r1, r19
cec: 14 06 cpc r1, r20
cee: 05 06 cpc r0, r21
cf0: 08 95 ret
00000cf2 <__fp_round>:
cf2: 09 2e mov r0, r25
cf4: 03 94 inc r0
cf6: 00 0c add r0, r0
cf8: 11 f4 brne .+4 ; 0xcfe <__fp_round+0xc>
cfa: 88 23 and r24, r24
cfc: 52 f0 brmi .+20 ; 0xd12 <__fp_round+0x20>
cfe: bb 0f add r27, r27
d00: 40 f4 brcc .+16 ; 0xd12 <__fp_round+0x20>
d02: bf 2b or r27, r31
d04: 11 f4 brne .+4 ; 0xd0a <__fp_round+0x18>
d06: 60 ff sbrs r22, 0
d08: 04 c0 rjmp .+8 ; 0xd12 <__fp_round+0x20>
d0a: 6f 5f subi r22, 0xFF ; 255
d0c: 7f 4f sbci r23, 0xFF ; 255
d0e: 8f 4f sbci r24, 0xFF ; 255
d10: 9f 4f sbci r25, 0xFF ; 255
d12: 08 95 ret
00000d14 <__fp_split3>:
d14: 57 fd sbrc r21, 7
d16: 90 58 subi r25, 0x80 ; 128
d18: 44 0f add r20, r20
d1a: 55 1f adc r21, r21
d1c: 59 f0 breq .+22 ; 0xd34 <__fp_splitA+0x10>
d1e: 5f 3f cpi r21, 0xFF ; 255
d20: 71 f0 breq .+28 ; 0xd3e <__fp_splitA+0x1a>
d22: 47 95 ror r20
00000d24 <__fp_splitA>:
d24: 88 0f add r24, r24
d26: 97 fb bst r25, 7
d28: 99 1f adc r25, r25
d2a: 61 f0 breq .+24 ; 0xd44 <__fp_splitA+0x20>
d2c: 9f 3f cpi r25, 0xFF ; 255
d2e: 79 f0 breq .+30 ; 0xd4e <__fp_splitA+0x2a>
d30: 87 95 ror r24
d32: 08 95 ret
d34: 12 16 cp r1, r18
d36: 13 06 cpc r1, r19
d38: 14 06 cpc r1, r20
d3a: 55 1f adc r21, r21
d3c: f2 cf rjmp .-28 ; 0xd22 <__fp_split3+0xe>
d3e: 46 95 lsr r20
d40: f1 df rcall .-30 ; 0xd24 <__fp_splitA>
d42: 08 c0 rjmp .+16 ; 0xd54 <__fp_splitA+0x30>
d44: 16 16 cp r1, r22
d46: 17 06 cpc r1, r23
d48: 18 06 cpc r1, r24
d4a: 99 1f adc r25, r25
d4c: f1 cf rjmp .-30 ; 0xd30 <__fp_splitA+0xc>
d4e: 86 95 lsr r24
d50: 71 05 cpc r23, r1
d52: 61 05 cpc r22, r1
d54: 08 94 sec
d56: 08 95 ret
00000d58 <__fp_zero>:
d58: e8 94 clt
00000d5a <__fp_szero>:
d5a: bb 27 eor r27, r27
d5c: 66 27 eor r22, r22
d5e: 77 27 eor r23, r23
d60: cb 01 movw r24, r22
d62: 97 f9 bld r25, 7
d64: 08 95 ret
00000d66 <__gesf2>:
d66: 0e 94 3e 06 call 0xc7c ; 0xc7c <__fp_cmp>
d6a: 08 f4 brcc .+2 ; 0xd6e <__gesf2+0x8>
d6c: 8f ef ldi r24, 0xFF ; 255
d6e: 08 95 ret
d70: 16 f0 brts .+4 ; 0xd76 <__gesf2+0x10>
d72: 0c 94 7a 07 jmp 0xef4 ; 0xef4 <__fp_mpack>
d76: 0c 94 68 06 jmp 0xcd0 ; 0xcd0 <__fp_nan>
d7a: 68 94 set
d7c: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
00000d80 <log>:
d80: 0e 94 92 06 call 0xd24 ; 0xd24 <__fp_splitA>
d84: a8 f3 brcs .-22 ; 0xd70 <__gesf2+0xa>
d86: 99 23 and r25, r25
d88: c1 f3 breq .-16 ; 0xd7a <__gesf2+0x14>
d8a: ae f3 brts .-22 ; 0xd76 <__gesf2+0x10>
d8c: df 93 push r29
d8e: cf 93 push r28
d90: 1f 93 push r17
d92: 0f 93 push r16
d94: ff 92 push r15
d96: c9 2f mov r28, r25
d98: dd 27 eor r29, r29
d9a: 88 23 and r24, r24
d9c: 2a f0 brmi .+10 ; 0xda8 <log+0x28>
d9e: 21 97 sbiw r28, 0x01 ; 1
da0: 66 0f add r22, r22
da2: 77 1f adc r23, r23
da4: 88 1f adc r24, r24
da6: da f7 brpl .-10 ; 0xd9e <log+0x1e>
da8: 20 e0 ldi r18, 0x00 ; 0
daa: 30 e0 ldi r19, 0x00 ; 0
dac: 40 e8 ldi r20, 0x80 ; 128
dae: 5f eb ldi r21, 0xBF ; 191
db0: 9f e3 ldi r25, 0x3F ; 63
db2: 88 39 cpi r24, 0x98 ; 152
db4: 20 f0 brcs .+8 ; 0xdbe <log+0x3e>
db6: 80 3e cpi r24, 0xE0 ; 224
db8: 38 f0 brcs .+14 ; 0xdc8 <log+0x48>
dba: 21 96 adiw r28, 0x01 ; 1
dbc: 8f 77 andi r24, 0x7F ; 127
dbe: 0e 94 ef 04 call 0x9de ; 0x9de <__addsf3>
dc2: e8 e6 ldi r30, 0x68 ; 104
dc4: f0 e0 ldi r31, 0x00 ; 0
dc6: 04 c0 rjmp .+8 ; 0xdd0 <log+0x50>
dc8: 0e 94 ef 04 call 0x9de ; 0x9de <__addsf3>
dcc: e5 e9 ldi r30, 0x95 ; 149
dce: f0 e0 ldi r31, 0x00 ; 0
dd0: 0e 94 88 07 call 0xf10 ; 0xf10 <__fp_powser>
dd4: 8b 01 movw r16, r22
dd6: be 01 movw r22, r28
dd8: ec 01 movw r28, r24
dda: fb 2e mov r15, r27
ddc: 6f 57 subi r22, 0x7F ; 127
dde: 71 09 sbc r23, r1
de0: 75 95 asr r23
de2: 77 1f adc r23, r23
de4: 88 0b sbc r24, r24
de6: 99 0b sbc r25, r25
de8: 0e 94 03 06 call 0xc06 ; 0xc06 <__floatsisf>
dec: 28 e1 ldi r18, 0x18 ; 24
dee: 32 e7 ldi r19, 0x72 ; 114
df0: 41 e3 ldi r20, 0x31 ; 49
df2: 5f e3 ldi r21, 0x3F ; 63
df4: 0e 94 1b 07 call 0xe36 ; 0xe36 <__mulsf3x>
df8: af 2d mov r26, r15
dfa: 98 01 movw r18, r16
dfc: ae 01 movw r20, r28
dfe: ff 90 pop r15
e00: 0f 91 pop r16
e02: 1f 91 pop r17
e04: cf 91 pop r28
e06: df 91 pop r29
e08: 0e 94 06 05 call 0xa0c ; 0xa0c <__addsf3x>
e0c: 0c 94 79 06 jmp 0xcf2 ; 0xcf2 <__fp_round>
00000e10 <__mulsf3>:
e10: 0e 94 1b 07 call 0xe36 ; 0xe36 <__mulsf3x>
e14: 0c 94 79 06 jmp 0xcf2 ; 0xcf2 <__fp_round>
e18: 0e 94 6b 06 call 0xcd6 ; 0xcd6 <__fp_pscA>
e1c: 38 f0 brcs .+14 ; 0xe2c <__mulsf3+0x1c>
e1e: 0e 94 72 06 call 0xce4 ; 0xce4 <__fp_pscB>
e22: 20 f0 brcs .+8 ; 0xe2c <__mulsf3+0x1c>
e24: 95 23 and r25, r21
e26: 11 f0 breq .+4 ; 0xe2c <__mulsf3+0x1c>
e28: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
e2c: 0c 94 68 06 jmp 0xcd0 ; 0xcd0 <__fp_nan>
e30: 11 24 eor r1, r1
e32: 0c 94 ad 06 jmp 0xd5a ; 0xd5a <__fp_szero>
00000e36 <__mulsf3x>:
e36: 0e 94 8a 06 call 0xd14 ; 0xd14 <__fp_split3>
e3a: 70 f3 brcs .-36 ; 0xe18 <__mulsf3+0x8>
00000e3c <__mulsf3_pse>:
e3c: 95 9f mul r25, r21
e3e: c1 f3 breq .-16 ; 0xe30 <__mulsf3+0x20>
e40: 95 0f add r25, r21
e42: 50 e0 ldi r21, 0x00 ; 0
e44: 55 1f adc r21, r21
e46: 62 9f mul r22, r18
e48: f0 01 movw r30, r0
e4a: 72 9f mul r23, r18
e4c: bb 27 eor r27, r27
e4e: f0 0d add r31, r0
e50: b1 1d adc r27, r1
e52: 63 9f mul r22, r19
e54: aa 27 eor r26, r26
e56: f0 0d add r31, r0
e58: b1 1d adc r27, r1
e5a: aa 1f adc r26, r26
e5c: 64 9f mul r22, r20
e5e: 66 27 eor r22, r22
e60: b0 0d add r27, r0
e62: a1 1d adc r26, r1
e64: 66 1f adc r22, r22
e66: 82 9f mul r24, r18
e68: 22 27 eor r18, r18
e6a: b0 0d add r27, r0
e6c: a1 1d adc r26, r1
e6e: 62 1f adc r22, r18
e70: 73 9f mul r23, r19
e72: b0 0d add r27, r0
e74: a1 1d adc r26, r1
e76: 62 1f adc r22, r18
e78: 83 9f mul r24, r19
e7a: a0 0d add r26, r0
e7c: 61 1d adc r22, r1
e7e: 22 1f adc r18, r18
e80: 74 9f mul r23, r20
e82: 33 27 eor r19, r19
e84: a0 0d add r26, r0
e86: 61 1d adc r22, r1
e88: 23 1f adc r18, r19
e8a: 84 9f mul r24, r20
e8c: 60 0d add r22, r0
e8e: 21 1d adc r18, r1
e90: 82 2f mov r24, r18
e92: 76 2f mov r23, r22
e94: 6a 2f mov r22, r26
e96: 11 24 eor r1, r1
e98: 9f 57 subi r25, 0x7F ; 127
e9a: 50 40 sbci r21, 0x00 ; 0
e9c: 9a f0 brmi .+38 ; 0xec4 <__mulsf3_pse+0x88>
e9e: f1 f0 breq .+60 ; 0xedc <__mulsf3_pse+0xa0>
ea0: 88 23 and r24, r24
ea2: 4a f0 brmi .+18 ; 0xeb6 <__mulsf3_pse+0x7a>
ea4: ee 0f add r30, r30
ea6: ff 1f adc r31, r31
ea8: bb 1f adc r27, r27
eaa: 66 1f adc r22, r22
eac: 77 1f adc r23, r23
eae: 88 1f adc r24, r24
eb0: 91 50 subi r25, 0x01 ; 1
eb2: 50 40 sbci r21, 0x00 ; 0
eb4: a9 f7 brne .-22 ; 0xea0 <__mulsf3_pse+0x64>
eb6: 9e 3f cpi r25, 0xFE ; 254
eb8: 51 05 cpc r21, r1
eba: 80 f0 brcs .+32 ; 0xedc <__mulsf3_pse+0xa0>
ebc: 0c 94 62 06 jmp 0xcc4 ; 0xcc4 <__fp_inf>
ec0: 0c 94 ad 06 jmp 0xd5a ; 0xd5a <__fp_szero>
ec4: 5f 3f cpi r21, 0xFF ; 255
ec6: e4 f3 brlt .-8 ; 0xec0 <__mulsf3_pse+0x84>
ec8: 98 3e cpi r25, 0xE8 ; 232
eca: d4 f3 brlt .-12 ; 0xec0 <__mulsf3_pse+0x84>
ecc: 86 95 lsr r24
ece: 77 95 ror r23
ed0: 67 95 ror r22
ed2: b7 95 ror r27
ed4: f7 95 ror r31
ed6: e7 95 ror r30
ed8: 9f 5f subi r25, 0xFF ; 255
eda: c1 f7 brne .-16 ; 0xecc <__mulsf3_pse+0x90>
edc: fe 2b or r31, r30
ede: 88 0f add r24, r24
ee0: 91 1d adc r25, r1
ee2: 96 95 lsr r25
ee4: 87 95 ror r24
ee6: 97 f9 bld r25, 7
ee8: 08 95 ret
00000eea <__unordsf2>:
eea: 0e 94 3e 06 call 0xc7c ; 0xc7c <__fp_cmp>
eee: 88 0b sbc r24, r24
ef0: 99 0b sbc r25, r25
ef2: 08 95 ret
00000ef4 <__fp_mpack>:
ef4: 9f 3f cpi r25, 0xFF ; 255
ef6: 31 f0 breq .+12 ; 0xf04 <__fp_mpack_finite+0xc>
00000ef8 <__fp_mpack_finite>:
ef8: 91 50 subi r25, 0x01 ; 1
efa: 20 f4 brcc .+8 ; 0xf04 <__fp_mpack_finite+0xc>
efc: 87 95 ror r24
efe: 77 95 ror r23
f00: 67 95 ror r22
f02: b7 95 ror r27
f04: 88 0f add r24, r24
f06: 91 1d adc r25, r1
f08: 96 95 lsr r25
f0a: 87 95 ror r24
f0c: 97 f9 bld r25, 7
f0e: 08 95 ret
00000f10 <__fp_powser>:
f10: df 93 push r29
f12: cf 93 push r28
f14: 1f 93 push r17
f16: 0f 93 push r16
f18: ff 92 push r15
f1a: ef 92 push r14
f1c: df 92 push r13
f1e: 7b 01 movw r14, r22
f20: 8c 01 movw r16, r24
f22: 68 94 set
f24: 06 c0 rjmp .+12 ; 0xf32 <__fp_powser+0x22>
f26: da 2e mov r13, r26
f28: ef 01 movw r28, r30
f2a: 0e 94 1b 07 call 0xe36 ; 0xe36 <__mulsf3x>
f2e: fe 01 movw r30, r28
f30: e8 94 clt
f32: a5 91 lpm r26, Z+
f34: 25 91 lpm r18, Z+
f36: 35 91 lpm r19, Z+
f38: 45 91 lpm r20, Z+
f3a: 55 91 lpm r21, Z+
f3c: a6 f3 brts .-24 ; 0xf26 <__fp_powser+0x16>
f3e: ef 01 movw r28, r30
f40: 0e 94 06 05 call 0xa0c ; 0xa0c <__addsf3x>
f44: fe 01 movw r30, r28
f46: 97 01 movw r18, r14
f48: a8 01 movw r20, r16
f4a: da 94 dec r13
f4c: 69 f7 brne .-38 ; 0xf28 <__fp_powser+0x18>
f4e: df 90 pop r13
f50: ef 90 pop r14
f52: ff 90 pop r15
f54: 0f 91 pop r16
f56: 1f 91 pop r17
f58: cf 91 pop r28
f5a: df 91 pop r29
f5c: 08 95 ret
00000f5e <__udivmodsi4>:
f5e: a1 e2 ldi r26, 0x21 ; 33
f60: 1a 2e mov r1, r26
f62: aa 1b sub r26, r26
f64: bb 1b sub r27, r27
f66: fd 01 movw r30, r26
f68: 0d c0 rjmp .+26 ; 0xf84 <__udivmodsi4_ep>
00000f6a <__udivmodsi4_loop>:
f6a: aa 1f adc r26, r26
f6c: bb 1f adc r27, r27
f6e: ee 1f adc r30, r30
f70: ff 1f adc r31, r31
f72: a2 17 cp r26, r18
f74: b3 07 cpc r27, r19
f76: e4 07 cpc r30, r20
f78: f5 07 cpc r31, r21
f7a: 20 f0 brcs .+8 ; 0xf84 <__udivmodsi4_ep>
f7c: a2 1b sub r26, r18
f7e: b3 0b sbc r27, r19
f80: e4 0b sbc r30, r20
f82: f5 0b sbc r31, r21
00000f84 <__udivmodsi4_ep>:
f84: 66 1f adc r22, r22
f86: 77 1f adc r23, r23
f88: 88 1f adc r24, r24
f8a: 99 1f adc r25, r25
f8c: 1a 94 dec r1
f8e: 69 f7 brne .-38 ; 0xf6a <__udivmodsi4_loop>
f90: 60 95 com r22
f92: 70 95 com r23
f94: 80 95 com r24
f96: 90 95 com r25
f98: 9b 01 movw r18, r22
f9a: ac 01 movw r20, r24
f9c: bd 01 movw r22, r26
f9e: cf 01 movw r24, r30
fa0: 08 95 ret
00000fa2 <__tablejump2__>:
fa2: ee 0f add r30, r30
fa4: ff 1f adc r31, r31
fa6: 05 90 lpm r0, Z+
fa8: f4 91 lpm r31, Z
faa: e0 2d mov r30, r0
fac: 09 94 ijmp
00000fae <abort>:
fae: 81 e0 ldi r24, 0x01 ; 1
fb0: 90 e0 ldi r25, 0x00 ; 0
fb2: f8 94 cli
fb4: 0c 94 dc 07 jmp 0xfb8 ; 0xfb8 <_exit>
00000fb8 <_exit>:
fb8: f8 94 cli
00000fba <__stop_program>:
fba: ff cf rjmp .-2 ; 0xfba <__stop_program>

Auto Launch

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Auto Launch

Загружено:

Авторское право:

Доступные форматы

ex.ino.

elf: file format elf32-avr

Disassembly of section .text:

void pinMode(uint8_t pin, uint8_t mode)

if (port == NOT_A_PIN) return;

// JWS: can I let the optimizer do this?

void digitalWrite(uint8_t pin, uint8_t val)

// If the pin that support PWM output, we need to turn it off

#if defined(TCCR0A) && defined(COM0B1)

#if defined(TCCR0A) && defined(COM0A1)

#if defined(TCCR0A) && defined(COM0B1)

// If the pin that support PWM output, we need to turn it off

uint8_t oldSREG = SREG;

unsigned long micros() {

// Public Methods //////////////////////////////////////////////////////////////

/* default implementation: may be overridden */

void LiquidCrystal::write4bits(uint8_t value) {

void LiquidCrystal::write4bits(uint8_t value) {

/************ low level data pushing commands **********/

// write either command or data, with automatic 4/8-bit selection

// if there is a RW pin indicated, set it low to Write

if (_displayfunction & LCD_8BITMODE) {

void LiquidCrystal::write8bits(uint8_t value) {

if (_displayfunction & LCD_8BITMODE) {

if (_displayfunction & LCD_8BITMODE) {

/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal::command(uint8_t value) {

void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {

void LiquidCrystal::setRowOffsets(int row0, int row1, int row2, int row3)

//put the LCD into 4 bit or 8 bit mode

// we start in 8bit mode, try to set 4 bit mode

// finally, set to 4-bit interface

// Send function set command sequence

// finally, set # lines, font size, etc.

// turn the display on with no cursor or blinking default

/********** high level commands, for the user! */

// Initialize to default text direction (for romance languages)

// Initialize to default text direction (for romance languages)

inline size_t LiquidCrystal::write(uint8_t value) {

virtual void flush() { /* Empty implementation for backward compatibility */ }

// default to zero, meaning "a single write may block"

virtual size_t write(uint8_t) = 0;

void setupUSB() __attribute__((weak));

// on the ATmega168, timer 0 is also used for fast hardware pwm

// enable timer 0 overflow interrupt

// set timer 1 prescale factor to 64

// set timer 2 prescale factor to 64

// configure timer 2 for phase correct pwm (8-bit)

/********** high level commands, for the user! */

// prevent crash if called with base == 1

#if defined(ADCSRA) && defined(ADCL)

// ADSC is cleared when the conversion finishes

// we have to read ADCL first; doing so locks both ADCL

command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));

size_t Print::print(const char str[])

command(LCD_SETDDRAMADDR | (col + _row_offsets[row]));

size_t Print::printFloat(double number, uint8_t digits)

if (isnan(number)) return print("nan");

size_t Print::print(const char str[])

if (isnan(number)) return print("nan");

size_t Print::print(const char str[])

if (isnan(number)) return print("nan");

size_t Print::print(const char str[])

if (isnan(number)) return print("nan");

/** low level data pushing commands /

void setupUSB() attribute((weak));