You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3294 lines
119 KiB
3294 lines
119 KiB
|
|
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 <port_to_output_PGM>:
|
|
432: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+.
|
|
|
|
0000043c <port_to_mode_PGM>:
|
|
43c: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*.
|
|
|
|
00000446 <digital_pin_to_port_PGM>:
|
|
446: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................
|
|
456: 03 03 03 03 ....
|
|
|
|
0000045a <digital_pin_to_bit_mask_PGM>:
|
|
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 <main>
|
|
4bc: 0c 94 92 0a jmp 0x1524 ; 0x1524 <_exit>
|
|
|
|
000004c0 <__bad_interrupt>:
|
|
4c0: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
|
|
|
|
000004c4 <pinMode.constprop.29>:
|
|
#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 <pinMode.constprop.29+0x3c>
|
|
|
|
// 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 <digitalWrite>:
|
|
}
|
|
}
|
|
|
|
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 <digitalWrite+0x20>
|
|
53a: 3c c0 rjmp .+120 ; 0x5b4 <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);
|
|
53c: 22 23 and r18, r18
|
|
53e: 39 f1 breq .+78 ; 0x58e <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)
|
|
540: 23 30 cpi r18, 0x03 ; 3
|
|
542: 91 f0 breq .+36 ; 0x568 <digitalWrite+0x4c>
|
|
544: 38 f4 brcc .+14 ; 0x554 <digitalWrite+0x38>
|
|
546: 21 30 cpi r18, 0x01 ; 1
|
|
548: a9 f0 breq .+42 ; 0x574 <digitalWrite+0x58>
|
|
54a: 22 30 cpi r18, 0x02 ; 2
|
|
54c: 01 f5 brne .+64 ; 0x58e <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;
|
|
54e: 84 b5 in r24, 0x24 ; 36
|
|
550: 8f 7d andi r24, 0xDF ; 223
|
|
552: 12 c0 rjmp .+36 ; 0x578 <digitalWrite+0x5c>
|
|
//
|
|
//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 <digitalWrite+0x60>
|
|
558: 28 30 cpi r18, 0x08 ; 8
|
|
55a: a1 f0 breq .+40 ; 0x584 <digitalWrite+0x68>
|
|
55c: 24 30 cpi r18, 0x04 ; 4
|
|
55e: b9 f4 brne .+46 ; 0x58e <digitalWrite+0x72>
|
|
{
|
|
#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 <digitalWrite+0x52>
|
|
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 <digitalWrite+0x72>
|
|
#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 <digitalWrite+0x72>
|
|
#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 <digitalWrite+0x6e>
|
|
#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 <digitalWrite+0x90>
|
|
*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 <digitalWrite+0x94>
|
|
} 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 <micros>:
|
|
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 <timer0_overflow_count>
|
|
5be: 90 91 50 01 lds r25, 0x0150 ; 0x800150 <timer0_overflow_count+0x1>
|
|
5c2: a0 91 51 01 lds r26, 0x0151 ; 0x800151 <timer0_overflow_count+0x2>
|
|
5c6: b0 91 52 01 lds r27, 0x0152 ; 0x800152 <timer0_overflow_count+0x3>
|
|
#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 <micros+0x24>
|
|
5d0: 2f 3f cpi r18, 0xFF ; 255
|
|
5d2: 19 f0 breq .+6 ; 0x5da <micros+0x24>
|
|
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 <micros+0x3c>
|
|
}
|
|
5fe: 08 95 ret
|
|
|
|
00000600 <delay>:
|
|
|
|
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 <micros>
|
|
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 <delay+0x62>
|
|
yield();
|
|
while ( ms > 0 && (micros() - start) >= 1000) {
|
|
626: 0e 94 db 02 call 0x5b6 ; 0x5b6 <micros>
|
|
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 <delay+0x1c>
|
|
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 <delay+0x26>
|
|
660: dd cf rjmp .-70 ; 0x61c <delay+0x1c>
|
|
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>
|
|
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>
|
|
|
|
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>
|
|
digitalWrite(clockPin, LOW);
|
|
97e: 60 e0 ldi r22, 0x00 ; 0
|
|
980: 8d 2d mov r24, r13
|
|
982: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
|
|
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 <digitalWrite>
|
|
|
|
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 <digitalWrite>
|
|
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 <lcd+0x8>
|
|
a06: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
|
|
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 <digitalWrite>
|
|
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 <memcpy_P>
|
|
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 <memcpy_P>
|
|
|
|
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 <digitalWrite>
|
|
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 <abort>
|
|
|
|
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 <timer0_millis>
|
|
ba0: 90 91 4c 01 lds r25, 0x014C ; 0x80014c <timer0_millis+0x1>
|
|
ba4: a0 91 4d 01 lds r26, 0x014D ; 0x80014d <timer0_millis+0x2>
|
|
ba8: b0 91 4e 01 lds r27, 0x014E ; 0x80014e <timer0_millis+0x3>
|
|
unsigned char f = timer0_fract;
|
|
bac: 30 91 4a 01 lds r19, 0x014A ; 0x80014a <timer0_fract>
|
|
|
|
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_fract>
|
|
timer0_millis = m;
|
|
bce: 80 93 4b 01 sts 0x014B, r24 ; 0x80014b <timer0_millis>
|
|
bd2: 90 93 4c 01 sts 0x014C, r25 ; 0x80014c <timer0_millis+0x1>
|
|
bd6: a0 93 4d 01 sts 0x014D, r26 ; 0x80014d <timer0_millis+0x2>
|
|
bda: b0 93 4e 01 sts 0x014E, r27 ; 0x80014e <timer0_millis+0x3>
|
|
timer0_overflow_count++;
|
|
bde: 80 91 4f 01 lds r24, 0x014F ; 0x80014f <timer0_overflow_count>
|
|
be2: 90 91 50 01 lds r25, 0x0150 ; 0x800150 <timer0_overflow_count+0x1>
|
|
be6: a0 91 51 01 lds r26, 0x0151 ; 0x800151 <timer0_overflow_count+0x2>
|
|
bea: b0 91 52 01 lds r27, 0x0152 ; 0x800152 <timer0_overflow_count+0x3>
|
|
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 <timer0_overflow_count>
|
|
bf8: 90 93 50 01 sts 0x0150, r25 ; 0x800150 <timer0_overflow_count+0x1>
|
|
bfc: a0 93 51 01 sts 0x0151, r26 ; 0x800151 <timer0_overflow_count+0x2>
|
|
c00: b0 93 52 01 sts 0x0152, r27 ; 0x800152 <timer0_overflow_count+0x3>
|
|
}
|
|
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 <Serial+0x10>
|
|
c7e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 <Serial+0x11>
|
|
c82: 80 81 ld r24, Z
|
|
c84: e0 91 69 01 lds r30, 0x0169 ; 0x800169 <Serial+0x16>
|
|
c88: f0 91 6a 01 lds r31, 0x016A ; 0x80016a <Serial+0x17>
|
|
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 <Serial+0x19>
|
|
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 <Serial+0x1a>
|
|
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 <Serial+0x19>
|
|
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 <Serial+0x19>
|
|
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.constprop.29>
|
|
pinMode(CE, OUTPUT);
|
|
d6c: 84 e0 ldi r24, 0x04 ; 4
|
|
d6e: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
|
|
pinMode(DC, OUTPUT);
|
|
d72: 85 e0 ldi r24, 0x05 ; 5
|
|
d74: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
|
|
pinMode(DIN, OUTPUT);
|
|
d78: 86 e0 ldi r24, 0x06 ; 6
|
|
d7a: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
|
|
pinMode(CLK, OUTPUT);
|
|
d7e: 87 e0 ldi r24, 0x07 ; 7
|
|
d80: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
|
|
|
|
_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>
|
|
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 <digitalWrite>
|
|
|
|
_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 <main>:
|
|
|
|
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 <Serial+0x10>
|
|
e5e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 <Serial+0x11>
|
|
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 <Serial+0xc>
|
|
e6a: f0 91 60 01 lds r31, 0x0160 ; 0x800160 <Serial+0xd>
|
|
e6e: 10 82 st Z, r1
|
|
*_ubrrl = baud_setting;
|
|
e70: e0 91 61 01 lds r30, 0x0161 ; 0x800161 <Serial+0xe>
|
|
e74: f0 91 62 01 lds r31, 0x0162 ; 0x800162 <Serial+0xf>
|
|
e78: 8f ec ldi r24, 0xCF ; 207
|
|
e7a: 80 83 st Z, r24
|
|
|
|
_written = false;
|
|
e7c: 10 92 6b 01 sts 0x016B, r1 ; 0x80016b <Serial+0x18>
|
|
|
|
//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 <Serial+0x14>
|
|
e84: f0 91 68 01 lds r31, 0x0168 ; 0x800168 <Serial+0x15>
|
|
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 <Serial+0x12>
|
|
e90: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
|
|
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 <Serial+0x12>
|
|
e9e: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
|
|
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 <Serial+0x12>
|
|
eac: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
|
|
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 <Serial+0x12>
|
|
eba: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
|
|
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 <delay>
|
|
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 <main+0x140>
|
|
|
|
// 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 <phVal_u16+0x1>
|
|
f2c: 60 93 48 01 sts 0x0148, r22 ; 0x800148 <phVal_u16>
|
|
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 <phVal_u16>
|
|
f88: 70 91 49 01 lds r23, 0x0149 ; 0x800149 <phVal_u16+0x1>
|
|
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 <main+0x218>
|
|
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 <main+0x24c>
|
|
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 <main+0x252>
|
|
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 <main+0x252>
|
|
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 <main+0x33e>
|
|
{
|
|
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 <main+0x26c>
|
|
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 <main+0x24c>
|
|
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 <main+0x266>
|
|
|
|
// 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 <main+0x2a4>
|
|
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<digits; ++i)
|
|
rounding /= 10.0;
|
|
|
|
number += rounding;
|
|
1078: 2a e0 ldi r18, 0x0A ; 10
|
|
107a: 37 ed ldi r19, 0xD7 ; 215
|
|
107c: 43 ea ldi r20, 0xA3 ; 163
|
|
107e: 5b e3 ldi r21, 0x3B ; 59
|
|
1080: c7 01 movw r24, r14
|
|
1082: b6 01 movw r22, r12
|
|
1084: 0e 94 9c 08 call 0x1138 ; 0x1138 <__addsf3>
|
|
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 <delay>
|
|
|
|
setup();
|
|
|
|
for (;;) {
|
|
loop();
|
|
if (serialEventRun) serialEventRun();
|
|
111e: 0e 94 3c 04 call 0x878 ; 0x878 <_Z14serialEventRunv>
|
|
1122: ef ce rjmp .-546 ; 0xf02 <main+0x12e>
|
|
|
|
00001124 <memcpy_P>:
|
|
1124: fb 01 movw r30, r22
|
|
1126: dc 01 movw r26, r24
|
|
1128: 02 c0 rjmp .+4 ; 0x112e <memcpy_P+0xa>
|
|
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 <memcpy_P+0x6>
|
|
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 <abort>:
|
|
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>
|