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

3 years ago
  1. BasicPHSensor.ino.elf: file format elf32-avr
  2. Disassembly of section .text:
  3. 00000000 <__vectors>:
  4. 0: 0c 94 38 02 jmp 0x470 ; 0x470 <__ctors_end>
  5. 4: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  6. 8: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  7. c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  8. 10: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  9. 14: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  10. 18: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  11. 1c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  12. 20: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  13. 24: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  14. 28: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  15. 2c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  16. 30: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  17. 34: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  18. 38: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  19. 3c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  20. 40: 0c 94 c3 05 jmp 0xb86 ; 0xb86 <__vector_16>
  21. 44: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  22. 48: 0c 94 33 06 jmp 0xc66 ; 0xc66 <__vector_18>
  23. 4c: 0c 94 0d 06 jmp 0xc1a ; 0xc1a <__vector_19>
  24. 50: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  25. 54: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  26. 58: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  27. 5c: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  28. 60: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  29. 64: 0c 94 60 02 jmp 0x4c0 ; 0x4c0 <__bad_interrupt>
  30. 00000068 <__trampolines_end>:
  31. 68: 00 00 nop
  32. 6a: 00 08 sbc r0, r0
  33. 6c: 00 02 muls r16, r16
  34. 6e: 01 00 .word 0x0001 ; ????
  35. 70: 00 03 mulsu r16, r16
  36. 72: 04 07 cpc r16, r20
  37. ...
  38. 0000007c <_ZL10characters>:
  39. 7c: 3f 3f 02 01 51 09 06 00 05 00 41 41 7c 12 11 12 ??..Q.....AA|...
  40. 8c: 7c 00 05 00 42 42 7f 49 49 49 36 00 05 00 43 43 |...BB.III6...CC
  41. 9c: 3e 41 41 41 22 00 05 00 44 44 7f 41 41 41 3e 00 >AAA"...DD.AAA>.
  42. ac: 05 00 45 45 7f 49 49 49 41 00 05 00 46 46 7f 09 ..EE.IIIA...FF..
  43. bc: 09 09 01 00 05 00 47 47 3e 41 49 49 3a 00 05 00 ......GG>AII:...
  44. cc: 48 48 7f 08 08 08 7f 00 05 00 49 49 00 41 7f 41 HH........II.A.A
  45. dc: 00 00 05 00 4a 4a 30 40 40 40 3f 00 05 00 4b 4b ....JJ0@@@?...KK
  46. ec: 7f 08 08 14 63 00 05 00 4c 4c 7f 40 40 40 40 00 ....c...LL.@@@@.
  47. fc: 05 00 4d 4d 7f 06 0c 06 7f 00 05 00 4e 4e 7f 04 ..MM........NN..
  48. 10c: 08 10 7f 00 05 00 4f 4f 3e 41 41 41 3e 00 05 00 ......OO>AAA>...
  49. 11c: 50 50 7f 09 09 09 06 00 05 00 51 51 3e 41 51 61 PP........QQ>AQa
  50. 12c: 7e 00 05 00 52 52 7f 09 19 29 46 00 05 00 53 53 ~...RR...)F...SS
  51. 13c: 26 49 49 49 32 00 05 00 54 54 01 01 7f 01 01 00 &III2...TT......
  52. 14c: 05 00 55 55 3f 40 40 40 3f 00 05 00 56 56 1f 20 ..UU?@@@?...VV.
  53. 15c: 40 20 1f 00 05 00 57 57 3f 40 38 40 3f 00 05 00 @ ....WW?@8@?...
  54. 16c: 58 58 63 14 08 14 63 00 05 00 59 59 07 08 70 08 XXc...c...YY..p.
  55. 17c: 07 00 05 00 5a 5a 61 51 49 45 43 00 05 00 2d 2d ....ZZaQIEC...--
  56. 18c: 08 08 08 08 08 00 05 00 21 21 00 00 5f 00 00 00 ........!!.._...
  57. 19c: 05 00 2e 2e 00 40 00 00 00 00 03 00 31 31 42 42 .....@......11BB
  58. 1ac: 7f 40 40 00 05 00 32 32 62 51 49 45 42 00 05 00 .@@...22bQIEB...
  59. 1bc: 33 33 22 41 49 49 3e 00 05 00 34 34 1f 10 7c 10 33"AII>...44..|.
  60. 1cc: 10 00 05 00 35 35 4f 49 49 49 31 00 05 00 36 36 ....55OIII1...66
  61. 1dc: 3e 49 49 49 32 00 05 00 37 37 01 01 79 05 03 00 >III2...77..y...
  62. 1ec: 05 00 38 38 36 49 49 49 36 00 05 00 39 39 26 49 ..886III6...99&I
  63. 1fc: 49 49 3e 00 05 00 30 30 3e 41 41 41 3e 00 05 00 II>...00>AAA>...
  64. 20c: 2b 2b 08 08 3e 08 08 00 05 00 3a 3a 00 28 00 00 ++..>.....::.(..
  65. 21c: 00 00 03 00 3d 3d 14 14 14 14 14 00 05 00 20 20 ....==........
  66. 22c: 00 00 00 00 00 00 02 00 61 61 20 54 54 54 78 00 ........aa TTTx.
  67. 23c: 05 00 62 62 7f 48 48 48 30 00 05 00 63 63 38 44 ..bb.HHH0...cc8D
  68. 24c: 44 44 28 00 05 00 64 64 20 50 50 50 7f 00 05 00 DD(...dd PPP....
  69. 25c: 65 65 38 54 54 54 48 00 05 00 66 66 08 7e 09 01 ee8TTTH...ff.~..
  70. 26c: 02 00 05 00 67 67 48 54 54 54 38 00 05 00 68 68 ....ggHTTT8...hh
  71. 27c: 7f 08 08 08 70 00 05 00 69 69 40 44 7d 40 40 00 ....p...ii@D}@@.
  72. 28c: 05 00 6a 6a 20 40 44 3d 00 00 05 00 6b 6b 7f 10 ..jj @D=....kk..
  73. 29c: 10 28 44 00 05 00 6c 6c 01 01 7f 40 40 00 05 00 .(D...ll...@@...
  74. 2ac: 6d 6d 7c 04 7c 04 78 00 05 00 6e 6e 7c 04 04 04 mm|.|.x...nn|...
  75. 2bc: 78 00 05 00 6f 6f 38 44 44 44 38 00 05 00 70 70 x...oo8DDD8...pp
  76. 2cc: 7c 14 14 14 08 00 05 00 71 71 08 14 14 14 7c 00 |.......qq....|.
  77. 2dc: 05 00 72 72 7c 08 04 04 04 00 05 00 73 73 48 54 ..rr|.......ssHT
  78. 2ec: 54 54 24 00 05 00 74 74 02 02 3f 42 42 00 05 00 TT$...tt..?BB...
  79. 2fc: 75 75 3c 40 40 20 7c 00 05 00 76 76 1c 20 40 20 uu<@@ |...vv. @
  80. 30c: 1c 00 05 00 77 77 7c 20 70 20 7c 00 05 00 78 78 ....ww| p |...xx
  81. 31c: 44 28 10 28 44 00 05 00 79 79 4c 50 50 50 3c 00 D(.(D...yyLPPP<.
  82. 32c: 05 00 7a 7a 44 64 54 4c 44 00 05 00 5b 5b 00 7f ..zzDdTLD...[[..
  83. 33c: 41 41 00 00 05 00 5d 5d 00 41 41 7f 00 00 05 00 AA....]].AA.....
  84. 34c: 7b 7b 08 08 36 41 41 00 05 00 7d 7d 41 41 36 08 {{..6AA...}}AA6.
  85. 35c: 08 00 05 00 28 28 00 1c 22 41 00 00 05 00 29 29 ....((.."A....))
  86. 36c: 00 41 22 1c 00 00 05 00 40 40 3e 41 5d 55 1e 00 .A".....@@>A]U..
  87. 37c: 05 00 23 23 14 3e 14 3e 14 00 05 00 24 24 2c 2a ..##.>.>....$$,*
  88. 38c: 7f 2a 12 00 05 00 25 25 26 16 08 34 32 00 05 00 .*....%%&..42...
  89. 39c: 5e 5e 04 02 01 02 04 00 05 00 5f 5f 40 40 40 40 ^^........__@@@@
  90. 3ac: 40 00 05 00 27 27 07 00 00 00 00 00 01 00 22 22 @...''........""
  91. 3bc: 00 07 00 07 00 00 05 00 3b 3b 00 40 76 36 00 00 ........;;.@v6..
  92. 3cc: 05 00 2f 2f 20 10 08 04 02 00 05 00 5c 5c 02 04 ..// .......\\..
  93. 3dc: 08 10 20 00 05 00 3c 3c 00 10 28 44 00 00 05 00 .. ...<<..(D....
  94. 3ec: 3e 3e 00 44 28 10 00 00 05 00 2a 2a 12 0c 3f 0c >>.D(.....**..?.
  95. 3fc: 12 00 05 00 60 60 01 02 00 00 00 00 02 00 7e 7e ....``........~~
  96. 40c: 02 01 03 02 01 00 05 00 26 26 30 4a 45 2a 10 28 ........&&0JE*.(
  97. 41c: 06 00 0a 0a 00 00 00 00 00 00 00 00 0d 0d 00 00 ................
  98. 42c: 00 00 00 00 00 00 ......
  99. 00000432 <port_to_output_PGM>:
  100. 432: 00 00 00 00 25 00 28 00 2b 00 ....%.(.+.
  101. 0000043c <port_to_mode_PGM>:
  102. 43c: 00 00 00 00 24 00 27 00 2a 00 ....$.'.*.
  103. 00000446 <digital_pin_to_port_PGM>:
  104. 446: 04 04 04 04 04 04 04 04 02 02 02 02 02 02 03 03 ................
  105. 456: 03 03 03 03 ....
  106. 0000045a <digital_pin_to_bit_mask_PGM>:
  107. 45a: 01 02 04 08 10 20 40 80 01 02 04 08 10 20 01 02 ..... @...... ..
  108. 46a: 04 08 10 20 ...
  109. 0000046e <__ctors_start>:
  110. 46e: 65 06 cpc r6, r21
  111. 00000470 <__ctors_end>:
  112. 470: 11 24 eor r1, r1
  113. 472: 1f be out 0x3f, r1 ; 63
  114. 474: cf ef ldi r28, 0xFF ; 255
  115. 476: d8 e0 ldi r29, 0x08 ; 8
  116. 478: de bf out 0x3e, r29 ; 62
  117. 47a: cd bf out 0x3d, r28 ; 61
  118. 0000047c <__do_copy_data>:
  119. 47c: 11 e0 ldi r17, 0x01 ; 1
  120. 47e: a0 e0 ldi r26, 0x00 ; 0
  121. 480: b1 e0 ldi r27, 0x01 ; 1
  122. 482: e8 e2 ldi r30, 0x28 ; 40
  123. 484: f5 e1 ldi r31, 0x15 ; 21
  124. 486: 02 c0 rjmp .+4 ; 0x48c <__do_copy_data+0x10>
  125. 488: 05 90 lpm r0, Z+
  126. 48a: 0d 92 st X+, r0
  127. 48c: a4 34 cpi r26, 0x44 ; 68
  128. 48e: b1 07 cpc r27, r17
  129. 490: d9 f7 brne .-10 ; 0x488 <__do_copy_data+0xc>
  130. 00000492 <__do_clear_bss>:
  131. 492: 22 e0 ldi r18, 0x02 ; 2
  132. 494: a4 e4 ldi r26, 0x44 ; 68
  133. 496: b1 e0 ldi r27, 0x01 ; 1
  134. 498: 01 c0 rjmp .+2 ; 0x49c <.do_clear_bss_start>
  135. 0000049a <.do_clear_bss_loop>:
  136. 49a: 1d 92 st X+, r1
  137. 0000049c <.do_clear_bss_start>:
  138. 49c: a2 30 cpi r26, 0x02 ; 2
  139. 49e: b2 07 cpc r27, r18
  140. 4a0: e1 f7 brne .-8 ; 0x49a <.do_clear_bss_loop>
  141. 000004a2 <__do_global_ctors>:
  142. 4a2: 12 e0 ldi r17, 0x02 ; 2
  143. 4a4: c8 e3 ldi r28, 0x38 ; 56
  144. 4a6: d2 e0 ldi r29, 0x02 ; 2
  145. 4a8: 04 c0 rjmp .+8 ; 0x4b2 <__do_global_ctors+0x10>
  146. 4aa: 21 97 sbiw r28, 0x01 ; 1
  147. 4ac: fe 01 movw r30, r28
  148. 4ae: 0e 94 87 0a call 0x150e ; 0x150e <__tablejump2__>
  149. 4b2: c7 33 cpi r28, 0x37 ; 55
  150. 4b4: d1 07 cpc r29, r17
  151. 4b6: c9 f7 brne .-14 ; 0x4aa <__do_global_ctors+0x8>
  152. 4b8: 0e 94 ea 06 call 0xdd4 ; 0xdd4 <main>
  153. 4bc: 0c 94 92 0a jmp 0x1524 ; 0x1524 <_exit>
  154. 000004c0 <__bad_interrupt>:
  155. 4c0: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
  156. 000004c4 <pinMode.constprop.29>:
  157. #include "wiring_private.h"
  158. #include "pins_arduino.h"
  159. void pinMode(uint8_t pin, uint8_t mode)
  160. {
  161. uint8_t bit = digitalPinToBitMask(pin);
  162. 4c4: 90 e0 ldi r25, 0x00 ; 0
  163. 4c6: fc 01 movw r30, r24
  164. 4c8: e6 5a subi r30, 0xA6 ; 166
  165. 4ca: fb 4f sbci r31, 0xFB ; 251
  166. 4cc: 24 91 lpm r18, Z
  167. uint8_t port = digitalPinToPort(pin);
  168. 4ce: fc 01 movw r30, r24
  169. 4d0: ea 5b subi r30, 0xBA ; 186
  170. 4d2: fb 4f sbci r31, 0xFB ; 251
  171. 4d4: 84 91 lpm r24, Z
  172. volatile uint8_t *reg, *out;
  173. if (port == NOT_A_PIN) return;
  174. 4d6: 88 23 and r24, r24
  175. 4d8: 99 f0 breq .+38 ; 0x500 <pinMode.constprop.29+0x3c>
  176. // JWS: can I let the optimizer do this?
  177. reg = portModeRegister(port);
  178. 4da: 90 e0 ldi r25, 0x00 ; 0
  179. 4dc: 88 0f add r24, r24
  180. 4de: 99 1f adc r25, r25
  181. 4e0: fc 01 movw r30, r24
  182. 4e2: e4 5c subi r30, 0xC4 ; 196
  183. 4e4: fb 4f sbci r31, 0xFB ; 251
  184. 4e6: a5 91 lpm r26, Z+
  185. 4e8: b4 91 lpm r27, Z
  186. out = portOutputRegister(port);
  187. 4ea: fc 01 movw r30, r24
  188. 4ec: ee 5c subi r30, 0xCE ; 206
  189. 4ee: fb 4f sbci r31, 0xFB ; 251
  190. 4f0: 85 91 lpm r24, Z+
  191. 4f2: 94 91 lpm r25, Z
  192. cli();
  193. *reg &= ~bit;
  194. *out |= bit;
  195. SREG = oldSREG;
  196. } else {
  197. uint8_t oldSREG = SREG;
  198. 4f4: 8f b7 in r24, 0x3f ; 63
  199. cli();
  200. 4f6: f8 94 cli
  201. *reg |= bit;
  202. 4f8: ec 91 ld r30, X
  203. 4fa: e2 2b or r30, r18
  204. 4fc: ec 93 st X, r30
  205. SREG = oldSREG;
  206. 4fe: 8f bf out 0x3f, r24 ; 63
  207. 500: 08 95 ret
  208. 00000502 <_ZN6Cursor9moveYAxisEt.constprop.10>:
  209. }
  210. /**
  211. * Moves cursor in y axis by a number sepcified in method's parameter
  212. */
  213. void Cursor::moveYAxis(position by){
  214. 502: fc 01 movw r30, r24
  215. if(by == 0)
  216. return;
  217. _y++;
  218. 504: 80 81 ld r24, Z
  219. 506: 91 81 ldd r25, Z+1 ; 0x01
  220. 508: 01 96 adiw r24, 0x01 ; 1
  221. 50a: 91 83 std Z+1, r25 ; 0x01
  222. 50c: 80 83 st Z, r24
  223. _x = 0; // for each y incrementation, reset the x axis :D
  224. 50e: 13 82 std Z+3, r1 ; 0x03
  225. 510: 12 82 std Z+2, r1 ; 0x02
  226. if(_y > 5){
  227. 512: 06 97 sbiw r24, 0x06 ; 6
  228. 514: 10 f0 brcs .+4 ; 0x51a <_ZN6Cursor9moveYAxisEt.constprop.10+0x18>
  229. _y = 0;
  230. 516: 11 82 std Z+1, r1 ; 0x01
  231. 518: 10 82 st Z, r1
  232. 51a: 08 95 ret
  233. 0000051c <digitalWrite>:
  234. }
  235. }
  236. void digitalWrite(uint8_t pin, uint8_t val)
  237. {
  238. uint8_t timer = digitalPinToTimer(pin);
  239. 51c: 90 e0 ldi r25, 0x00 ; 0
  240. 51e: fc 01 movw r30, r24
  241. 520: e8 59 subi r30, 0x98 ; 152
  242. 522: ff 4f sbci r31, 0xFF ; 255
  243. 524: 24 91 lpm r18, Z
  244. uint8_t bit = digitalPinToBitMask(pin);
  245. 526: fc 01 movw r30, r24
  246. 528: e6 5a subi r30, 0xA6 ; 166
  247. 52a: fb 4f sbci r31, 0xFB ; 251
  248. 52c: 34 91 lpm r19, Z
  249. uint8_t port = digitalPinToPort(pin);
  250. 52e: fc 01 movw r30, r24
  251. 530: ea 5b subi r30, 0xBA ; 186
  252. 532: fb 4f sbci r31, 0xFB ; 251
  253. 534: e4 91 lpm r30, Z
  254. volatile uint8_t *out;
  255. if (port == NOT_A_PIN) return;
  256. 536: ee 23 and r30, r30
  257. 538: 09 f4 brne .+2 ; 0x53c <digitalWrite+0x20>
  258. 53a: 3c c0 rjmp .+120 ; 0x5b4 <digitalWrite+0x98>
  259. // If the pin that support PWM output, we need to turn it off
  260. // before doing a digital write.
  261. if (timer != NOT_ON_TIMER) turnOffPWM(timer);
  262. 53c: 22 23 and r18, r18
  263. 53e: 39 f1 breq .+78 ; 0x58e <digitalWrite+0x72>
  264. //
  265. //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
  266. //static inline void turnOffPWM(uint8_t timer)
  267. static void turnOffPWM(uint8_t timer)
  268. {
  269. switch (timer)
  270. 540: 23 30 cpi r18, 0x03 ; 3
  271. 542: 91 f0 breq .+36 ; 0x568 <digitalWrite+0x4c>
  272. 544: 38 f4 brcc .+14 ; 0x554 <digitalWrite+0x38>
  273. 546: 21 30 cpi r18, 0x01 ; 1
  274. 548: a9 f0 breq .+42 ; 0x574 <digitalWrite+0x58>
  275. 54a: 22 30 cpi r18, 0x02 ; 2
  276. 54c: 01 f5 brne .+64 ; 0x58e <digitalWrite+0x72>
  277. #if defined(TCCR0A) && defined(COM0A1)
  278. case TIMER0A: cbi(TCCR0A, COM0A1); break;
  279. #endif
  280. #if defined(TCCR0A) && defined(COM0B1)
  281. case TIMER0B: cbi(TCCR0A, COM0B1); break;
  282. 54e: 84 b5 in r24, 0x24 ; 36
  283. 550: 8f 7d andi r24, 0xDF ; 223
  284. 552: 12 c0 rjmp .+36 ; 0x578 <digitalWrite+0x5c>
  285. //
  286. //static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
  287. //static inline void turnOffPWM(uint8_t timer)
  288. static void turnOffPWM(uint8_t timer)
  289. {
  290. switch (timer)
  291. 554: 27 30 cpi r18, 0x07 ; 7
  292. 556: 91 f0 breq .+36 ; 0x57c <digitalWrite+0x60>
  293. 558: 28 30 cpi r18, 0x08 ; 8
  294. 55a: a1 f0 breq .+40 ; 0x584 <digitalWrite+0x68>
  295. 55c: 24 30 cpi r18, 0x04 ; 4
  296. 55e: b9 f4 brne .+46 ; 0x58e <digitalWrite+0x72>
  297. {
  298. #if defined(TCCR1A) && defined(COM1A1)
  299. case TIMER1A: cbi(TCCR1A, COM1A1); break;
  300. #endif
  301. #if defined(TCCR1A) && defined(COM1B1)
  302. case TIMER1B: cbi(TCCR1A, COM1B1); break;
  303. 560: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
  304. 564: 8f 7d andi r24, 0xDF ; 223
  305. 566: 03 c0 rjmp .+6 ; 0x56e <digitalWrite+0x52>
  306. static void turnOffPWM(uint8_t timer)
  307. {
  308. switch (timer)
  309. {
  310. #if defined(TCCR1A) && defined(COM1A1)
  311. case TIMER1A: cbi(TCCR1A, COM1A1); break;
  312. 568: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
  313. 56c: 8f 77 andi r24, 0x7F ; 127
  314. #endif
  315. #if defined(TCCR1A) && defined(COM1B1)
  316. case TIMER1B: cbi(TCCR1A, COM1B1); break;
  317. 56e: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
  318. 572: 0d c0 rjmp .+26 ; 0x58e <digitalWrite+0x72>
  319. #if defined(TCCR2) && defined(COM21)
  320. case TIMER2: cbi(TCCR2, COM21); break;
  321. #endif
  322. #if defined(TCCR0A) && defined(COM0A1)
  323. case TIMER0A: cbi(TCCR0A, COM0A1); break;
  324. 574: 84 b5 in r24, 0x24 ; 36
  325. 576: 8f 77 andi r24, 0x7F ; 127
  326. #endif
  327. #if defined(TCCR0A) && defined(COM0B1)
  328. case TIMER0B: cbi(TCCR0A, COM0B1); break;
  329. 578: 84 bd out 0x24, r24 ; 36
  330. 57a: 09 c0 rjmp .+18 ; 0x58e <digitalWrite+0x72>
  331. #endif
  332. #if defined(TCCR2A) && defined(COM2A1)
  333. case TIMER2A: cbi(TCCR2A, COM2A1); break;
  334. 57c: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
  335. 580: 8f 77 andi r24, 0x7F ; 127
  336. 582: 03 c0 rjmp .+6 ; 0x58a <digitalWrite+0x6e>
  337. #endif
  338. #if defined(TCCR2A) && defined(COM2B1)
  339. case TIMER2B: cbi(TCCR2A, COM2B1); break;
  340. 584: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
  341. 588: 8f 7d andi r24, 0xDF ; 223
  342. 58a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
  343. // If the pin that support PWM output, we need to turn it off
  344. // before doing a digital write.
  345. if (timer != NOT_ON_TIMER) turnOffPWM(timer);
  346. out = portOutputRegister(port);
  347. 58e: f0 e0 ldi r31, 0x00 ; 0
  348. 590: ee 0f add r30, r30
  349. 592: ff 1f adc r31, r31
  350. 594: ee 5c subi r30, 0xCE ; 206
  351. 596: fb 4f sbci r31, 0xFB ; 251
  352. 598: a5 91 lpm r26, Z+
  353. 59a: b4 91 lpm r27, Z
  354. uint8_t oldSREG = SREG;
  355. 59c: 9f b7 in r25, 0x3f ; 63
  356. cli();
  357. 59e: f8 94 cli
  358. if (val == LOW) {
  359. 5a0: 61 11 cpse r22, r1
  360. 5a2: 04 c0 rjmp .+8 ; 0x5ac <digitalWrite+0x90>
  361. *out &= ~bit;
  362. 5a4: 8c 91 ld r24, X
  363. 5a6: 30 95 com r19
  364. 5a8: 38 23 and r19, r24
  365. 5aa: 02 c0 rjmp .+4 ; 0x5b0 <digitalWrite+0x94>
  366. } else {
  367. *out |= bit;
  368. 5ac: ec 91 ld r30, X
  369. 5ae: 3e 2b or r19, r30
  370. 5b0: 3c 93 st X, r19
  371. }
  372. SREG = oldSREG;
  373. 5b2: 9f bf out 0x3f, r25 ; 63
  374. 5b4: 08 95 ret
  375. 000005b6 <micros>:
  376. return m;
  377. }
  378. unsigned long micros() {
  379. unsigned long m;
  380. uint8_t oldSREG = SREG, t;
  381. 5b6: 3f b7 in r19, 0x3f ; 63
  382. cli();
  383. 5b8: f8 94 cli
  384. m = timer0_overflow_count;
  385. 5ba: 80 91 4f 01 lds r24, 0x014F ; 0x80014f <timer0_overflow_count>
  386. 5be: 90 91 50 01 lds r25, 0x0150 ; 0x800150 <timer0_overflow_count+0x1>
  387. 5c2: a0 91 51 01 lds r26, 0x0151 ; 0x800151 <timer0_overflow_count+0x2>
  388. 5c6: b0 91 52 01 lds r27, 0x0152 ; 0x800152 <timer0_overflow_count+0x3>
  389. #if defined(TCNT0)
  390. t = TCNT0;
  391. 5ca: 26 b5 in r18, 0x26 ; 38
  392. #else
  393. #error TIMER 0 not defined
  394. #endif
  395. #ifdef TIFR0
  396. if ((TIFR0 & _BV(TOV0)) && (t < 255))
  397. 5cc: a8 9b sbis 0x15, 0 ; 21
  398. 5ce: 05 c0 rjmp .+10 ; 0x5da <micros+0x24>
  399. 5d0: 2f 3f cpi r18, 0xFF ; 255
  400. 5d2: 19 f0 breq .+6 ; 0x5da <micros+0x24>
  401. m++;
  402. 5d4: 01 96 adiw r24, 0x01 ; 1
  403. 5d6: a1 1d adc r26, r1
  404. 5d8: b1 1d adc r27, r1
  405. #else
  406. if ((TIFR & _BV(TOV0)) && (t < 255))
  407. m++;
  408. #endif
  409. SREG = oldSREG;
  410. 5da: 3f bf out 0x3f, r19 ; 63
  411. return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
  412. 5dc: ba 2f mov r27, r26
  413. 5de: a9 2f mov r26, r25
  414. 5e0: 98 2f mov r25, r24
  415. 5e2: 88 27 eor r24, r24
  416. 5e4: 82 0f add r24, r18
  417. 5e6: 91 1d adc r25, r1
  418. 5e8: a1 1d adc r26, r1
  419. 5ea: b1 1d adc r27, r1
  420. 5ec: bc 01 movw r22, r24
  421. 5ee: cd 01 movw r24, r26
  422. 5f0: 42 e0 ldi r20, 0x02 ; 2
  423. 5f2: 66 0f add r22, r22
  424. 5f4: 77 1f adc r23, r23
  425. 5f6: 88 1f adc r24, r24
  426. 5f8: 99 1f adc r25, r25
  427. 5fa: 4a 95 dec r20
  428. 5fc: d1 f7 brne .-12 ; 0x5f2 <micros+0x3c>
  429. }
  430. 5fe: 08 95 ret
  431. 00000600 <delay>:
  432. void delay(unsigned long ms)
  433. {
  434. 600: 8f 92 push r8
  435. 602: 9f 92 push r9
  436. 604: af 92 push r10
  437. 606: bf 92 push r11
  438. 608: cf 92 push r12
  439. 60a: df 92 push r13
  440. 60c: ef 92 push r14
  441. 60e: ff 92 push r15
  442. 610: 6b 01 movw r12, r22
  443. 612: 7c 01 movw r14, r24
  444. uint32_t start = micros();
  445. 614: 0e 94 db 02 call 0x5b6 ; 0x5b6 <micros>
  446. 618: 4b 01 movw r8, r22
  447. 61a: 5c 01 movw r10, r24
  448. while (ms > 0) {
  449. 61c: c1 14 cp r12, r1
  450. 61e: d1 04 cpc r13, r1
  451. 620: e1 04 cpc r14, r1
  452. 622: f1 04 cpc r15, r1
  453. 624: f1 f0 breq .+60 ; 0x662 <delay+0x62>
  454. yield();
  455. while ( ms > 0 && (micros() - start) >= 1000) {
  456. 626: 0e 94 db 02 call 0x5b6 ; 0x5b6 <micros>
  457. 62a: dc 01 movw r26, r24
  458. 62c: cb 01 movw r24, r22
  459. 62e: 88 19 sub r24, r8
  460. 630: 99 09 sbc r25, r9
  461. 632: aa 09 sbc r26, r10
  462. 634: bb 09 sbc r27, r11
  463. 636: 88 3e cpi r24, 0xE8 ; 232
  464. 638: 93 40 sbci r25, 0x03 ; 3
  465. 63a: a1 05 cpc r26, r1
  466. 63c: b1 05 cpc r27, r1
  467. 63e: 70 f3 brcs .-36 ; 0x61c <delay+0x1c>
  468. ms--;
  469. 640: 21 e0 ldi r18, 0x01 ; 1
  470. 642: c2 1a sub r12, r18
  471. 644: d1 08 sbc r13, r1
  472. 646: e1 08 sbc r14, r1
  473. 648: f1 08 sbc r15, r1
  474. start += 1000;
  475. 64a: 88 ee ldi r24, 0xE8 ; 232
  476. 64c: 88 0e add r8, r24
  477. 64e: 83 e0 ldi r24, 0x03 ; 3
  478. 650: 98 1e adc r9, r24
  479. 652: a1 1c adc r10, r1
  480. 654: b1 1c adc r11, r1
  481. {
  482. uint32_t start = micros();
  483. while (ms > 0) {
  484. yield();
  485. while ( ms > 0 && (micros() - start) >= 1000) {
  486. 656: c1 14 cp r12, r1
  487. 658: d1 04 cpc r13, r1
  488. 65a: e1 04 cpc r14, r1
  489. 65c: f1 04 cpc r15, r1
  490. 65e: 19 f7 brne .-58 ; 0x626 <delay+0x26>
  491. 660: dd cf rjmp .-70 ; 0x61c <delay+0x1c>
  492. ms--;
  493. start += 1000;
  494. }
  495. }
  496. }
  497. 662: ff 90 pop r15
  498. 664: ef 90 pop r14
  499. 666: df 90 pop r13
  500. 668: cf 90 pop r12
  501. 66a: bf 90 pop r11
  502. 66c: af 90 pop r10
  503. 66e: 9f 90 pop r9
  504. 670: 8f 90 pop r8
  505. 672: 08 95 ret
  506. 00000674 <_ZN5Print5writeEPKhj>:
  507. // Public Methods //////////////////////////////////////////////////////////////
  508. /* default implementation: may be overridden */
  509. size_t Print::write(const uint8_t *buffer, size_t size)
  510. {
  511. 674: cf 92 push r12
  512. 676: df 92 push r13
  513. 678: ef 92 push r14
  514. 67a: ff 92 push r15
  515. 67c: 0f 93 push r16
  516. 67e: 1f 93 push r17
  517. 680: cf 93 push r28
  518. 682: df 93 push r29
  519. 684: 6c 01 movw r12, r24
  520. 686: 7a 01 movw r14, r20
  521. 688: 8b 01 movw r16, r22
  522. size_t n = 0;
  523. 68a: c0 e0 ldi r28, 0x00 ; 0
  524. 68c: d0 e0 ldi r29, 0x00 ; 0
  525. while (size--) {
  526. 68e: ce 15 cp r28, r14
  527. 690: df 05 cpc r29, r15
  528. 692: 81 f0 breq .+32 ; 0x6b4 <_ZN5Print5writeEPKhj+0x40>
  529. if (write(*buffer++)) n++;
  530. 694: d8 01 movw r26, r16
  531. 696: 6d 91 ld r22, X+
  532. 698: 8d 01 movw r16, r26
  533. 69a: d6 01 movw r26, r12
  534. 69c: ed 91 ld r30, X+
  535. 69e: fc 91 ld r31, X
  536. 6a0: 01 90 ld r0, Z+
  537. 6a2: f0 81 ld r31, Z
  538. 6a4: e0 2d mov r30, r0
  539. 6a6: c6 01 movw r24, r12
  540. 6a8: 09 95 icall
  541. 6aa: 89 2b or r24, r25
  542. 6ac: 11 f0 breq .+4 ; 0x6b2 <_ZN5Print5writeEPKhj+0x3e>
  543. 6ae: 21 96 adiw r28, 0x01 ; 1
  544. 6b0: ee cf rjmp .-36 ; 0x68e <_ZN5Print5writeEPKhj+0x1a>
  545. 6b2: 7e 01 movw r14, r28
  546. else break;
  547. }
  548. return n;
  549. }
  550. 6b4: c7 01 movw r24, r14
  551. 6b6: df 91 pop r29
  552. 6b8: cf 91 pop r28
  553. 6ba: 1f 91 pop r17
  554. 6bc: 0f 91 pop r16
  555. 6be: ff 90 pop r15
  556. 6c0: ef 90 pop r14
  557. 6c2: df 90 pop r13
  558. 6c4: cf 90 pop r12
  559. 6c6: 08 95 ret
  560. 000006c8 <_ZN14HardwareSerial17availableForWriteEv>:
  561. {
  562. tx_buffer_index_t head;
  563. tx_buffer_index_t tail;
  564. TX_BUFFER_ATOMIC {
  565. head = _tx_buffer_head;
  566. 6c8: fc 01 movw r30, r24
  567. 6ca: 53 8d ldd r21, Z+27 ; 0x1b
  568. tail = _tx_buffer_tail;
  569. 6cc: 44 8d ldd r20, Z+28 ; 0x1c
  570. 6ce: 25 2f mov r18, r21
  571. 6d0: 30 e0 ldi r19, 0x00 ; 0
  572. 6d2: 84 2f mov r24, r20
  573. 6d4: 90 e0 ldi r25, 0x00 ; 0
  574. }
  575. if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
  576. 6d6: 82 1b sub r24, r18
  577. 6d8: 93 0b sbc r25, r19
  578. 6da: 54 17 cp r21, r20
  579. 6dc: 10 f0 brcs .+4 ; 0x6e2 <_ZN14HardwareSerial17availableForWriteEv+0x1a>
  580. 6de: cf 96 adiw r24, 0x3f ; 63
  581. 6e0: 08 95 ret
  582. return tail - head - 1;
  583. 6e2: 01 97 sbiw r24, 0x01 ; 1
  584. }
  585. 6e4: 08 95 ret
  586. 000006e6 <_ZN14HardwareSerial4readEv>:
  587. return _rx_buffer[_rx_buffer_tail];
  588. }
  589. }
  590. int HardwareSerial::read(void)
  591. {
  592. 6e6: fc 01 movw r30, r24
  593. // if the head isn't ahead of the tail, we don't have any characters
  594. if (_rx_buffer_head == _rx_buffer_tail) {
  595. 6e8: 91 8d ldd r25, Z+25 ; 0x19
  596. 6ea: 82 8d ldd r24, Z+26 ; 0x1a
  597. 6ec: 98 17 cp r25, r24
  598. 6ee: 61 f0 breq .+24 ; 0x708 <_ZN14HardwareSerial4readEv+0x22>
  599. return -1;
  600. } else {
  601. unsigned char c = _rx_buffer[_rx_buffer_tail];
  602. 6f0: 82 8d ldd r24, Z+26 ; 0x1a
  603. 6f2: df 01 movw r26, r30
  604. 6f4: a8 0f add r26, r24
  605. 6f6: b1 1d adc r27, r1
  606. 6f8: 5d 96 adiw r26, 0x1d ; 29
  607. 6fa: 8c 91 ld r24, X
  608. _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
  609. 6fc: 92 8d ldd r25, Z+26 ; 0x1a
  610. 6fe: 9f 5f subi r25, 0xFF ; 255
  611. 700: 9f 73 andi r25, 0x3F ; 63
  612. 702: 92 8f std Z+26, r25 ; 0x1a
  613. return c;
  614. 704: 90 e0 ldi r25, 0x00 ; 0
  615. 706: 08 95 ret
  616. int HardwareSerial::read(void)
  617. {
  618. // if the head isn't ahead of the tail, we don't have any characters
  619. if (_rx_buffer_head == _rx_buffer_tail) {
  620. return -1;
  621. 708: 8f ef ldi r24, 0xFF ; 255
  622. 70a: 9f ef ldi r25, 0xFF ; 255
  623. } else {
  624. unsigned char c = _rx_buffer[_rx_buffer_tail];
  625. _rx_buffer_tail = (rx_buffer_index_t)(_rx_buffer_tail + 1) % SERIAL_RX_BUFFER_SIZE;
  626. return c;
  627. }
  628. }
  629. 70c: 08 95 ret
  630. 0000070e <_ZN14HardwareSerial4peekEv>:
  631. {
  632. return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
  633. }
  634. int HardwareSerial::peek(void)
  635. {
  636. 70e: fc 01 movw r30, r24
  637. if (_rx_buffer_head == _rx_buffer_tail) {
  638. 710: 91 8d ldd r25, Z+25 ; 0x19
  639. 712: 82 8d ldd r24, Z+26 ; 0x1a
  640. 714: 98 17 cp r25, r24
  641. 716: 31 f0 breq .+12 ; 0x724 <_ZN14HardwareSerial4peekEv+0x16>
  642. return -1;
  643. } else {
  644. return _rx_buffer[_rx_buffer_tail];
  645. 718: 82 8d ldd r24, Z+26 ; 0x1a
  646. 71a: e8 0f add r30, r24
  647. 71c: f1 1d adc r31, r1
  648. 71e: 85 8d ldd r24, Z+29 ; 0x1d
  649. 720: 90 e0 ldi r25, 0x00 ; 0
  650. 722: 08 95 ret
  651. }
  652. int HardwareSerial::peek(void)
  653. {
  654. if (_rx_buffer_head == _rx_buffer_tail) {
  655. return -1;
  656. 724: 8f ef ldi r24, 0xFF ; 255
  657. 726: 9f ef ldi r25, 0xFF ; 255
  658. } else {
  659. return _rx_buffer[_rx_buffer_tail];
  660. }
  661. }
  662. 728: 08 95 ret
  663. 0000072a <_ZN14HardwareSerial9availableEv>:
  664. // clear any received data
  665. _rx_buffer_head = _rx_buffer_tail;
  666. }
  667. int HardwareSerial::available(void)
  668. {
  669. 72a: fc 01 movw r30, r24
  670. return ((unsigned int)(SERIAL_RX_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail)) % SERIAL_RX_BUFFER_SIZE;
  671. 72c: 91 8d ldd r25, Z+25 ; 0x19
  672. 72e: 22 8d ldd r18, Z+26 ; 0x1a
  673. 730: 89 2f mov r24, r25
  674. 732: 90 e0 ldi r25, 0x00 ; 0
  675. 734: 80 5c subi r24, 0xC0 ; 192
  676. 736: 9f 4f sbci r25, 0xFF ; 255
  677. 738: 82 1b sub r24, r18
  678. 73a: 91 09 sbc r25, r1
  679. }
  680. 73c: 8f 73 andi r24, 0x3F ; 63
  681. 73e: 99 27 eor r25, r25
  682. 740: 08 95 ret
  683. 00000742 <_Z17Serial0_availablev>:
  684. #endif
  685. // Function that can be weakly referenced by serialEventRun to prevent
  686. // pulling in this file if it's not otherwise used.
  687. bool Serial0_available() {
  688. return Serial.available();
  689. 742: 83 e5 ldi r24, 0x53 ; 83
  690. 744: 91 e0 ldi r25, 0x01 ; 1
  691. 746: 0e 94 95 03 call 0x72a ; 0x72a <_ZN14HardwareSerial9availableEv>
  692. 74a: 21 e0 ldi r18, 0x01 ; 1
  693. 74c: 89 2b or r24, r25
  694. 74e: 09 f4 brne .+2 ; 0x752 <_Z17Serial0_availablev+0x10>
  695. 750: 20 e0 ldi r18, 0x00 ; 0
  696. }
  697. 752: 82 2f mov r24, r18
  698. 754: 08 95 ret
  699. 00000756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv>:
  700. #endif
  701. // Actual interrupt handlers //////////////////////////////////////////////////////////////
  702. void HardwareSerial::_tx_udr_empty_irq(void)
  703. {
  704. 756: fc 01 movw r30, r24
  705. // If interrupts are enabled, there must be more data in the output
  706. // buffer. Send the next byte
  707. unsigned char c = _tx_buffer[_tx_buffer_tail];
  708. 758: 84 8d ldd r24, Z+28 ; 0x1c
  709. 75a: df 01 movw r26, r30
  710. 75c: a8 0f add r26, r24
  711. 75e: b1 1d adc r27, r1
  712. 760: a3 5a subi r26, 0xA3 ; 163
  713. 762: bf 4f sbci r27, 0xFF ; 255
  714. 764: 2c 91 ld r18, X
  715. _tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_TX_BUFFER_SIZE;
  716. 766: 84 8d ldd r24, Z+28 ; 0x1c
  717. 768: 90 e0 ldi r25, 0x00 ; 0
  718. 76a: 01 96 adiw r24, 0x01 ; 1
  719. 76c: 8f 73 andi r24, 0x3F ; 63
  720. 76e: 99 27 eor r25, r25
  721. 770: 84 8f std Z+28, r24 ; 0x1c
  722. *_udr = c;
  723. 772: a6 89 ldd r26, Z+22 ; 0x16
  724. 774: b7 89 ldd r27, Z+23 ; 0x17
  725. 776: 2c 93 st X, r18
  726. // location". This makes sure flush() won't return until the bytes
  727. // actually got written. Other r/w bits are preserved, and zeroes
  728. // written to the rest.
  729. #ifdef MPCM0
  730. *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
  731. 778: a0 89 ldd r26, Z+16 ; 0x10
  732. 77a: b1 89 ldd r27, Z+17 ; 0x11
  733. 77c: 8c 91 ld r24, X
  734. 77e: 83 70 andi r24, 0x03 ; 3
  735. 780: 80 64 ori r24, 0x40 ; 64
  736. 782: 8c 93 st X, r24
  737. #else
  738. *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
  739. #endif
  740. if (_tx_buffer_head == _tx_buffer_tail) {
  741. 784: 93 8d ldd r25, Z+27 ; 0x1b
  742. 786: 84 8d ldd r24, Z+28 ; 0x1c
  743. 788: 98 13 cpse r25, r24
  744. 78a: 06 c0 rjmp .+12 ; 0x798 <_ZN14HardwareSerial17_tx_udr_empty_irqEv+0x42>
  745. // Buffer empty, so disable interrupts
  746. cbi(*_ucsrb, UDRIE0);
  747. 78c: 02 88 ldd r0, Z+18 ; 0x12
  748. 78e: f3 89 ldd r31, Z+19 ; 0x13
  749. 790: e0 2d mov r30, r0
  750. 792: 80 81 ld r24, Z
  751. 794: 8f 7d andi r24, 0xDF ; 223
  752. 796: 80 83 st Z, r24
  753. 798: 08 95 ret
  754. 0000079a <_ZN14HardwareSerial5writeEh>:
  755. // If we get here, nothing is queued anymore (DRIE is disabled) and
  756. // the hardware finished tranmission (TXC is set).
  757. }
  758. size_t HardwareSerial::write(uint8_t c)
  759. {
  760. 79a: ef 92 push r14
  761. 79c: ff 92 push r15
  762. 79e: 0f 93 push r16
  763. 7a0: 1f 93 push r17
  764. 7a2: cf 93 push r28
  765. 7a4: df 93 push r29
  766. 7a6: ec 01 movw r28, r24
  767. _written = true;
  768. 7a8: 81 e0 ldi r24, 0x01 ; 1
  769. 7aa: 88 8f std Y+24, r24 ; 0x18
  770. // If the buffer and the data register is empty, just write the byte
  771. // to the data register and be done. This shortcut helps
  772. // significantly improve the effective datarate at high (>
  773. // 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
  774. if (_tx_buffer_head == _tx_buffer_tail && bit_is_set(*_ucsra, UDRE0)) {
  775. 7ac: 9b 8d ldd r25, Y+27 ; 0x1b
  776. 7ae: 8c 8d ldd r24, Y+28 ; 0x1c
  777. 7b0: 98 13 cpse r25, r24
  778. 7b2: 05 c0 rjmp .+10 ; 0x7be <_ZN14HardwareSerial5writeEh+0x24>
  779. 7b4: e8 89 ldd r30, Y+16 ; 0x10
  780. 7b6: f9 89 ldd r31, Y+17 ; 0x11
  781. 7b8: 80 81 ld r24, Z
  782. 7ba: 85 fd sbrc r24, 5
  783. 7bc: 26 c0 rjmp .+76 ; 0x80a <_ZN14HardwareSerial5writeEh+0x70>
  784. 7be: f6 2e mov r15, r22
  785. *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << TXC0)));
  786. #endif
  787. }
  788. return 1;
  789. }
  790. tx_buffer_index_t i = (_tx_buffer_head + 1) % SERIAL_TX_BUFFER_SIZE;
  791. 7c0: 0b 8d ldd r16, Y+27 ; 0x1b
  792. 7c2: 10 e0 ldi r17, 0x00 ; 0
  793. 7c4: 0f 5f subi r16, 0xFF ; 255
  794. 7c6: 1f 4f sbci r17, 0xFF ; 255
  795. 7c8: 0f 73 andi r16, 0x3F ; 63
  796. 7ca: 11 27 eor r17, r17
  797. 7cc: e0 2e mov r14, r16
  798. // If the output buffer is full, there's nothing for it other than to
  799. // wait for the interrupt handler to empty it a bit
  800. while (i == _tx_buffer_tail) {
  801. 7ce: 8c 8d ldd r24, Y+28 ; 0x1c
  802. 7d0: e8 12 cpse r14, r24
  803. 7d2: 0c c0 rjmp .+24 ; 0x7ec <_ZN14HardwareSerial5writeEh+0x52>
  804. if (bit_is_clear(SREG, SREG_I)) {
  805. 7d4: 0f b6 in r0, 0x3f ; 63
  806. 7d6: 07 fc sbrc r0, 7
  807. 7d8: fa cf rjmp .-12 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34>
  808. // Interrupts are disabled, so we'll have to poll the data
  809. // register empty flag ourselves. If it is set, pretend an
  810. // interrupt has happened and call the handler to free up
  811. // space for us.
  812. if(bit_is_set(*_ucsra, UDRE0))
  813. 7da: e8 89 ldd r30, Y+16 ; 0x10
  814. 7dc: f9 89 ldd r31, Y+17 ; 0x11
  815. 7de: 80 81 ld r24, Z
  816. 7e0: 85 ff sbrs r24, 5
  817. 7e2: f5 cf rjmp .-22 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34>
  818. _tx_udr_empty_irq();
  819. 7e4: ce 01 movw r24, r28
  820. 7e6: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
  821. 7ea: f1 cf rjmp .-30 ; 0x7ce <_ZN14HardwareSerial5writeEh+0x34>
  822. } else {
  823. // nop, the interrupt handler will free up space for us
  824. }
  825. }
  826. _tx_buffer[_tx_buffer_head] = c;
  827. 7ec: 8b 8d ldd r24, Y+27 ; 0x1b
  828. 7ee: fe 01 movw r30, r28
  829. 7f0: e8 0f add r30, r24
  830. 7f2: f1 1d adc r31, r1
  831. 7f4: e3 5a subi r30, 0xA3 ; 163
  832. 7f6: ff 4f sbci r31, 0xFF ; 255
  833. 7f8: f0 82 st Z, r15
  834. // make atomic to prevent execution of ISR between setting the
  835. // head pointer and setting the interrupt flag resulting in buffer
  836. // retransmission
  837. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  838. 7fa: 9f b7 in r25, 0x3f ; 63
  839. return 1;
  840. }
  841. static __inline__ uint8_t __iCliRetVal(void)
  842. {
  843. cli();
  844. 7fc: f8 94 cli
  845. _tx_buffer_head = i;
  846. 7fe: 0b 8f std Y+27, r16 ; 0x1b
  847. sbi(*_ucsrb, UDRIE0);
  848. 800: ea 89 ldd r30, Y+18 ; 0x12
  849. 802: fb 89 ldd r31, Y+19 ; 0x13
  850. 804: 80 81 ld r24, Z
  851. 806: 80 62 ori r24, 0x20 ; 32
  852. 808: 0a c0 rjmp .+20 ; 0x81e <_ZN14HardwareSerial5writeEh+0x84>
  853. // So writing UDR must happen first.
  854. // Writing UDR and clearing TC must be done atomically, otherwise
  855. // interrupts might delay the TXC clear so the byte written to UDR
  856. // is transmitted (setting TXC) before clearing TXC. Then TXC will
  857. // be cleared when no bytes are left, causing flush() to hang
  858. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  859. 80a: 9f b7 in r25, 0x3f ; 63
  860. 80c: f8 94 cli
  861. *_udr = c;
  862. 80e: ee 89 ldd r30, Y+22 ; 0x16
  863. 810: ff 89 ldd r31, Y+23 ; 0x17
  864. 812: 60 83 st Z, r22
  865. #ifdef MPCM0
  866. *_ucsra = ((*_ucsra) & ((1 << U2X0) | (1 << MPCM0))) | (1 << TXC0);
  867. 814: e8 89 ldd r30, Y+16 ; 0x10
  868. 816: f9 89 ldd r31, Y+17 ; 0x11
  869. 818: 80 81 ld r24, Z
  870. 81a: 83 70 andi r24, 0x03 ; 3
  871. 81c: 80 64 ori r24, 0x40 ; 64
  872. 81e: 80 83 st Z, r24
  873. (void)__s;
  874. }
  875. static __inline__ void __iRestore(const uint8_t *__s)
  876. {
  877. SREG = *__s;
  878. 820: 9f bf out 0x3f, r25 ; 63
  879. _tx_buffer_head = i;
  880. sbi(*_ucsrb, UDRIE0);
  881. }
  882. return 1;
  883. }
  884. 822: 81 e0 ldi r24, 0x01 ; 1
  885. 824: 90 e0 ldi r25, 0x00 ; 0
  886. 826: df 91 pop r29
  887. 828: cf 91 pop r28
  888. 82a: 1f 91 pop r17
  889. 82c: 0f 91 pop r16
  890. 82e: ff 90 pop r15
  891. 830: ef 90 pop r14
  892. 832: 08 95 ret
  893. 00000834 <_ZN14HardwareSerial5flushEv>:
  894. if (head >= tail) return SERIAL_TX_BUFFER_SIZE - 1 - head + tail;
  895. return tail - head - 1;
  896. }
  897. void HardwareSerial::flush()
  898. {
  899. 834: cf 93 push r28
  900. 836: df 93 push r29
  901. 838: ec 01 movw r28, r24
  902. // If we have never written a byte, no need to flush. This special
  903. // case is needed since there is no way to force the TXC (transmit
  904. // complete) bit to 1 during initialization
  905. if (!_written)
  906. 83a: 88 8d ldd r24, Y+24 ; 0x18
  907. 83c: 88 23 and r24, r24
  908. 83e: c9 f0 breq .+50 ; 0x872 <_ZN14HardwareSerial5flushEv+0x3e>
  909. return;
  910. while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
  911. 840: ea 89 ldd r30, Y+18 ; 0x12
  912. 842: fb 89 ldd r31, Y+19 ; 0x13
  913. 844: 80 81 ld r24, Z
  914. 846: 85 fd sbrc r24, 5
  915. 848: 05 c0 rjmp .+10 ; 0x854 <_ZN14HardwareSerial5flushEv+0x20>
  916. 84a: a8 89 ldd r26, Y+16 ; 0x10
  917. 84c: b9 89 ldd r27, Y+17 ; 0x11
  918. 84e: 8c 91 ld r24, X
  919. 850: 86 fd sbrc r24, 6
  920. 852: 0f c0 rjmp .+30 ; 0x872 <_ZN14HardwareSerial5flushEv+0x3e>
  921. if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
  922. 854: 0f b6 in r0, 0x3f ; 63
  923. 856: 07 fc sbrc r0, 7
  924. 858: f5 cf rjmp .-22 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10>
  925. 85a: 80 81 ld r24, Z
  926. 85c: 85 ff sbrs r24, 5
  927. 85e: f2 cf rjmp .-28 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10>
  928. // Interrupts are globally disabled, but the DR empty
  929. // interrupt should be enabled, so poll the DR empty flag to
  930. // prevent deadlock
  931. if (bit_is_set(*_ucsra, UDRE0))
  932. 860: a8 89 ldd r26, Y+16 ; 0x10
  933. 862: b9 89 ldd r27, Y+17 ; 0x11
  934. 864: 8c 91 ld r24, X
  935. 866: 85 ff sbrs r24, 5
  936. 868: ed cf rjmp .-38 ; 0x844 <_ZN14HardwareSerial5flushEv+0x10>
  937. _tx_udr_empty_irq();
  938. 86a: ce 01 movw r24, r28
  939. 86c: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
  940. 870: e7 cf rjmp .-50 ; 0x840 <_ZN14HardwareSerial5flushEv+0xc>
  941. }
  942. // If we get here, nothing is queued anymore (DRIE is disabled) and
  943. // the hardware finished tranmission (TXC is set).
  944. }
  945. 872: df 91 pop r29
  946. 874: cf 91 pop r28
  947. 876: 08 95 ret
  948. 00000878 <_Z14serialEventRunv>:
  949. #endif
  950. void serialEventRun(void)
  951. {
  952. #if defined(HAVE_HWSERIAL0)
  953. if (Serial0_available && serialEvent && Serial0_available()) serialEvent();
  954. 878: 80 e0 ldi r24, 0x00 ; 0
  955. 87a: 90 e0 ldi r25, 0x00 ; 0
  956. 87c: 89 2b or r24, r25
  957. 87e: 29 f0 breq .+10 ; 0x88a <_Z14serialEventRunv+0x12>
  958. 880: 0e 94 a1 03 call 0x742 ; 0x742 <_Z17Serial0_availablev>
  959. 884: 81 11 cpse r24, r1
  960. 886: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
  961. 88a: 08 95 ret
  962. 0000088c <_ZN5Print5flushEv>:
  963. size_t println(unsigned long, int = DEC);
  964. size_t println(double, int = 2);
  965. size_t println(const Printable&);
  966. size_t println(void);
  967. virtual void flush() { /* Empty implementation for backward compatibility */ }
  968. 88c: 08 95 ret
  969. 0000088e <_ZN5Print17availableForWriteEv>:
  970. return write((const uint8_t *)buffer, size);
  971. }
  972. // default to zero, meaning "a single write may block"
  973. // should be overriden by subclasses with buffering
  974. virtual int availableForWrite() { return 0; }
  975. 88e: 80 e0 ldi r24, 0x00 ; 0
  976. 890: 90 e0 ldi r25, 0x00 ; 0
  977. 892: 08 95 ret
  978. 00000894 <_ZN5Print5writeEPKc.constprop.24>:
  979. int getWriteError() { return write_error; }
  980. void clearWriteError() { setWriteError(0); }
  981. virtual size_t write(uint8_t) = 0;
  982. size_t write(const char *str) {
  983. if (str == NULL) return 0;
  984. 894: 00 97 sbiw r24, 0x00 ; 0
  985. 896: 69 f0 breq .+26 ; 0x8b2 <_ZN5Print5writeEPKc.constprop.24+0x1e>
  986. return write((const uint8_t *)str, strlen(str));
  987. 898: fc 01 movw r30, r24
  988. 89a: 01 90 ld r0, Z+
  989. 89c: 00 20 and r0, r0
  990. 89e: e9 f7 brne .-6 ; 0x89a <_ZN5Print5writeEPKc.constprop.24+0x6>
  991. 8a0: 31 97 sbiw r30, 0x01 ; 1
  992. 8a2: af 01 movw r20, r30
  993. 8a4: 48 1b sub r20, r24
  994. 8a6: 59 0b sbc r21, r25
  995. 8a8: bc 01 movw r22, r24
  996. 8aa: 80 ef ldi r24, 0xF0 ; 240
  997. 8ac: 91 e0 ldi r25, 0x01 ; 1
  998. 8ae: 0c 94 3a 03 jmp 0x674 ; 0x674 <_ZN5Print5writeEPKhj>
  999. }
  1000. 8b2: 80 e0 ldi r24, 0x00 ; 0
  1001. 8b4: 90 e0 ldi r25, 0x00 ; 0
  1002. 8b6: 08 95 ret
  1003. 000008b8 <_ZN5Print11printNumberEmh.constprop.20>:
  1004. return n;
  1005. }
  1006. // Private Methods /////////////////////////////////////////////////////////////
  1007. size_t Print::printNumber(unsigned long n, uint8_t base)
  1008. 8b8: 8f 92 push r8
  1009. 8ba: 9f 92 push r9
  1010. 8bc: af 92 push r10
  1011. 8be: bf 92 push r11
  1012. 8c0: 0f 93 push r16
  1013. 8c2: 1f 93 push r17
  1014. 8c4: cf 93 push r28
  1015. 8c6: df 93 push r29
  1016. 8c8: cd b7 in r28, 0x3d ; 61
  1017. 8ca: de b7 in r29, 0x3e ; 62
  1018. 8cc: a1 97 sbiw r28, 0x21 ; 33
  1019. 8ce: 0f b6 in r0, 0x3f ; 63
  1020. 8d0: f8 94 cli
  1021. 8d2: de bf out 0x3e, r29 ; 62
  1022. 8d4: 0f be out 0x3f, r0 ; 63
  1023. 8d6: cd bf out 0x3d, r28 ; 61
  1024. {
  1025. char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
  1026. char *str = &buf[sizeof(buf) - 1];
  1027. *str = '\0';
  1028. 8d8: 19 a2 std Y+33, r1 ; 0x21
  1029. // prevent crash if called with base == 1
  1030. if (base < 2) base = 10;
  1031. 8da: 42 30 cpi r20, 0x02 ; 2
  1032. 8dc: 08 f4 brcc .+2 ; 0x8e0 <_ZN5Print11printNumberEmh.constprop.20+0x28>
  1033. 8de: 4a e0 ldi r20, 0x0A ; 10
  1034. 8e0: 8e 01 movw r16, r28
  1035. 8e2: 0f 5d subi r16, 0xDF ; 223
  1036. 8e4: 1f 4f sbci r17, 0xFF ; 255
  1037. do {
  1038. char c = n % base;
  1039. 8e6: 84 2e mov r8, r20
  1040. 8e8: 91 2c mov r9, r1
  1041. 8ea: a1 2c mov r10, r1
  1042. 8ec: b1 2c mov r11, r1
  1043. 8ee: a5 01 movw r20, r10
  1044. 8f0: 94 01 movw r18, r8
  1045. 8f2: 0e 94 65 0a call 0x14ca ; 0x14ca <__udivmodsi4>
  1046. 8f6: e6 2f mov r30, r22
  1047. n /= base;
  1048. 8f8: b9 01 movw r22, r18
  1049. 8fa: ca 01 movw r24, r20
  1050. *--str = c < 10 ? c + '0' : c + 'A' - 10;
  1051. 8fc: 01 50 subi r16, 0x01 ; 1
  1052. 8fe: 11 09 sbc r17, r1
  1053. 900: ea 30 cpi r30, 0x0A ; 10
  1054. 902: 14 f4 brge .+4 ; 0x908 <__stack+0x9>
  1055. 904: e0 5d subi r30, 0xD0 ; 208
  1056. 906: 01 c0 rjmp .+2 ; 0x90a <__stack+0xb>
  1057. 908: e9 5c subi r30, 0xC9 ; 201
  1058. 90a: d8 01 movw r26, r16
  1059. 90c: ec 93 st X, r30
  1060. *str = '\0';
  1061. // prevent crash if called with base == 1
  1062. if (base < 2) base = 10;
  1063. do {
  1064. 90e: 23 2b or r18, r19
  1065. 910: 24 2b or r18, r20
  1066. 912: 25 2b or r18, r21
  1067. 914: 61 f7 brne .-40 ; 0x8ee <_ZN5Print11printNumberEmh.constprop.20+0x36>
  1068. n /= base;
  1069. *--str = c < 10 ? c + '0' : c + 'A' - 10;
  1070. } while(n);
  1071. return write(str);
  1072. 916: c8 01 movw r24, r16
  1073. 918: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  1074. }
  1075. 91c: a1 96 adiw r28, 0x21 ; 33
  1076. 91e: 0f b6 in r0, 0x3f ; 63
  1077. 920: f8 94 cli
  1078. 922: de bf out 0x3e, r29 ; 62
  1079. 924: 0f be out 0x3f, r0 ; 63
  1080. 926: cd bf out 0x3d, r28 ; 61
  1081. 928: df 91 pop r29
  1082. 92a: cf 91 pop r28
  1083. 92c: 1f 91 pop r17
  1084. 92e: 0f 91 pop r16
  1085. 930: bf 90 pop r11
  1086. 932: af 90 pop r10
  1087. 934: 9f 90 pop r9
  1088. 936: 8f 90 pop r8
  1089. 938: 08 95 ret
  1090. 0000093a <_ZN10Nokia_511019transmitInformationEh>:
  1091. void Nokia_5110::endTransmission(){
  1092. digitalWrite(_CE, HIGH);
  1093. }
  1094. void Nokia_5110::transmitInformation(byte information){
  1095. 93a: cf 92 push r12
  1096. 93c: df 92 push r13
  1097. 93e: ef 92 push r14
  1098. 940: ff 92 push r15
  1099. 942: 0f 93 push r16
  1100. 944: 1f 93 push r17
  1101. 946: cf 93 push r28
  1102. 948: df 93 push r29
  1103. 94a: ec 01 movw r28, r24
  1104. 94c: e6 2e mov r14, r22
  1105. setBiasSystem(Mux_Rate::FORTY);
  1106. setContrast(60);
  1107. }
  1108. void Nokia_5110::startTransmission(){
  1109. digitalWrite(_CE, LOW);
  1110. 94e: 60 e0 ldi r22, 0x00 ; 0
  1111. 950: 8e 81 ldd r24, Y+6 ; 0x06
  1112. 952: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1113. digitalWrite(_CE, HIGH);
  1114. }
  1115. void Nokia_5110::transmitInformation(byte information){
  1116. startTransmission();
  1117. shiftOut(_DIN, _CLK, MSBFIRST, information);
  1118. 956: dc 84 ldd r13, Y+12 ; 0x0c
  1119. 958: ca 84 ldd r12, Y+10 ; 0x0a
  1120. 95a: 07 e0 ldi r16, 0x07 ; 7
  1121. 95c: 10 e0 ldi r17, 0x00 ; 0
  1122. for (i = 0; i < 8; i++) {
  1123. if (bitOrder == LSBFIRST)
  1124. digitalWrite(dataPin, !!(val & (1 << i)));
  1125. else
  1126. digitalWrite(dataPin, !!(val & (1 << (7 - i))));
  1127. 95e: f1 2c mov r15, r1
  1128. 960: b7 01 movw r22, r14
  1129. 962: 00 2e mov r0, r16
  1130. 964: 02 c0 rjmp .+4 ; 0x96a <_ZN10Nokia_511019transmitInformationEh+0x30>
  1131. 966: 75 95 asr r23
  1132. 968: 67 95 ror r22
  1133. 96a: 0a 94 dec r0
  1134. 96c: e2 f7 brpl .-8 ; 0x966 <_ZN10Nokia_511019transmitInformationEh+0x2c>
  1135. 96e: 61 70 andi r22, 0x01 ; 1
  1136. 970: 8c 2d mov r24, r12
  1137. 972: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1138. digitalWrite(clockPin, HIGH);
  1139. 976: 61 e0 ldi r22, 0x01 ; 1
  1140. 978: 8d 2d mov r24, r13
  1141. 97a: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1142. digitalWrite(clockPin, LOW);
  1143. 97e: 60 e0 ldi r22, 0x00 ; 0
  1144. 980: 8d 2d mov r24, r13
  1145. 982: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1146. 986: 01 50 subi r16, 0x01 ; 1
  1147. 988: 11 09 sbc r17, r1
  1148. 98a: 50 f7 brcc .-44 ; 0x960 <_ZN10Nokia_511019transmitInformationEh+0x26>
  1149. void Nokia_5110::startTransmission(){
  1150. digitalWrite(_CE, LOW);
  1151. }
  1152. void Nokia_5110::endTransmission(){
  1153. digitalWrite(_CE, HIGH);
  1154. 98c: 61 e0 ldi r22, 0x01 ; 1
  1155. 98e: 8e 81 ldd r24, Y+6 ; 0x06
  1156. void Nokia_5110::transmitInformation(byte information){
  1157. startTransmission();
  1158. shiftOut(_DIN, _CLK, MSBFIRST, information);
  1159. endTransmission();
  1160. }
  1161. 990: df 91 pop r29
  1162. 992: cf 91 pop r28
  1163. 994: 1f 91 pop r17
  1164. 996: 0f 91 pop r16
  1165. 998: ff 90 pop r15
  1166. 99a: ef 90 pop r14
  1167. 99c: df 90 pop r13
  1168. 99e: cf 90 pop r12
  1169. void Nokia_5110::startTransmission(){
  1170. digitalWrite(_CE, LOW);
  1171. }
  1172. void Nokia_5110::endTransmission(){
  1173. digitalWrite(_CE, HIGH);
  1174. 9a0: 0c 94 8e 02 jmp 0x51c ; 0x51c <digitalWrite>
  1175. 000009a4 <_ZN10Nokia_51107executeEh>:
  1176. startTransmission();
  1177. shiftOut(_DIN, _CLK, MSBFIRST, information);
  1178. endTransmission();
  1179. }
  1180. void Nokia_5110::execute(byte command){
  1181. 9a4: 1f 93 push r17
  1182. 9a6: cf 93 push r28
  1183. 9a8: df 93 push r29
  1184. 9aa: ec 01 movw r28, r24
  1185. 9ac: 16 2f mov r17, r22
  1186. initializeForSendingCommand();
  1187. transmitInformation(command);
  1188. }
  1189. void Nokia_5110::initializeForSendingCommand(){
  1190. digitalWrite(_DC, LOW);
  1191. 9ae: 60 e0 ldi r22, 0x00 ; 0
  1192. 9b0: 88 85 ldd r24, Y+8 ; 0x08
  1193. 9b2: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1194. endTransmission();
  1195. }
  1196. void Nokia_5110::execute(byte command){
  1197. initializeForSendingCommand();
  1198. transmitInformation(command);
  1199. 9b6: 61 2f mov r22, r17
  1200. 9b8: ce 01 movw r24, r28
  1201. }
  1202. 9ba: df 91 pop r29
  1203. 9bc: cf 91 pop r28
  1204. 9be: 1f 91 pop r17
  1205. endTransmission();
  1206. }
  1207. void Nokia_5110::execute(byte command){
  1208. initializeForSendingCommand();
  1209. transmitInformation(command);
  1210. 9c0: 0c 94 9d 04 jmp 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh>
  1211. 000009c4 <_ZN10Nokia_51109setCursorEtt>:
  1212. transmitInformation(0x0); // add an empty line after each chars
  1213. _cursor.moveXAxis(fontData.definition_total_bytes + 1);
  1214. }
  1215. void Nokia_5110::setCursor(position x, position y){
  1216. 9c4: 0f 93 push r16
  1217. 9c6: 1f 93 push r17
  1218. 9c8: cf 93 push r28
  1219. 9ca: df 93 push r29
  1220. 9cc: ec 01 movw r28, r24
  1221. 9ce: 06 2f mov r16, r22
  1222. 9d0: 14 2f mov r17, r20
  1223. #include "Cursor.h"
  1224. void Cursor::setCursor(position x, position y){
  1225. _x = x;
  1226. 9d2: 68 8b std Y+16, r22 ; 0x10
  1227. 9d4: 79 8b std Y+17, r23 ; 0x11
  1228. _y = y;
  1229. 9d6: 4e 87 std Y+14, r20 ; 0x0e
  1230. 9d8: 5f 87 std Y+15, r21 ; 0x0f
  1231. void Nokia_5110::extendedInstruction(){
  1232. execute(0x21);
  1233. }
  1234. void Nokia_5110::basicInstruction(){
  1235. execute(0x20);
  1236. 9da: 60 e2 ldi r22, 0x20 ; 32
  1237. 9dc: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1238. basicInstruction();
  1239. //set x position
  1240. unsigned short int leastXPositionValue = 128;
  1241. execute(byte(leastXPositionValue + x));
  1242. 9e0: 60 e8 ldi r22, 0x80 ; 128
  1243. 9e2: 60 0f add r22, r16
  1244. 9e4: ce 01 movw r24, r28
  1245. 9e6: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1246. //set y position
  1247. unsigned short int leastYPositionValue = 64;
  1248. execute(byte(leastYPositionValue + y));
  1249. 9ea: 60 e4 ldi r22, 0x40 ; 64
  1250. 9ec: 61 0f add r22, r17
  1251. 9ee: ce 01 movw r24, r28
  1252. }
  1253. 9f0: df 91 pop r29
  1254. 9f2: cf 91 pop r28
  1255. 9f4: 1f 91 pop r17
  1256. 9f6: 0f 91 pop r16
  1257. execute(byte(leastXPositionValue + x));
  1258. //set y position
  1259. unsigned short int leastYPositionValue = 64;
  1260. execute(byte(leastYPositionValue + y));
  1261. 9f8: 0c 94 d2 04 jmp 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1262. 000009fc <_ZN10Nokia_51105clearEv.constprop.31>:
  1263. }
  1264. void Nokia_5110::clear(){
  1265. 9fc: cf 93 push r28
  1266. 9fe: df 93 push r29
  1267. digitalWrite(_RST, LOW);
  1268. digitalWrite(_RST, HIGH);
  1269. }
  1270. void Nokia_5110::initializeForSendingData(){
  1271. digitalWrite(_DC, HIGH);
  1272. a00: 61 e0 ldi r22, 0x01 ; 1
  1273. a02: 80 91 f8 01 lds r24, 0x01F8 ; 0x8001f8 <lcd+0x8>
  1274. a06: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1275. a0a: c9 ef ldi r28, 0xF9 ; 249
  1276. a0c: d1 e0 ldi r29, 0x01 ; 1
  1277. void Nokia_5110::clear(){
  1278. initializeForSendingData();
  1279. int i = 504;
  1280. while(i >= 0){
  1281. transmitInformation(0x0);
  1282. a0e: 60 e0 ldi r22, 0x00 ; 0
  1283. a10: 80 ef ldi r24, 0xF0 ; 240
  1284. a12: 91 e0 ldi r25, 0x01 ; 1
  1285. a14: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh>
  1286. a18: 21 97 sbiw r28, 0x01 ; 1
  1287. void Nokia_5110::clear(){
  1288. initializeForSendingData();
  1289. int i = 504;
  1290. while(i >= 0){
  1291. a1a: c9 f7 brne .-14 ; 0xa0e <_ZN10Nokia_51105clearEv.constprop.31+0x12>
  1292. transmitInformation(0x0);
  1293. i--;
  1294. }
  1295. setCursor(0, 0);
  1296. a1c: 40 e0 ldi r20, 0x00 ; 0
  1297. a1e: 50 e0 ldi r21, 0x00 ; 0
  1298. a20: 60 e0 ldi r22, 0x00 ; 0
  1299. a22: 70 e0 ldi r23, 0x00 ; 0
  1300. a24: 80 ef ldi r24, 0xF0 ; 240
  1301. a26: 91 e0 ldi r25, 0x01 ; 1
  1302. }
  1303. a28: df 91 pop r29
  1304. a2a: cf 91 pop r28
  1305. while(i >= 0){
  1306. transmitInformation(0x0);
  1307. i--;
  1308. }
  1309. setCursor(0, 0);
  1310. a2c: 0c 94 e2 04 jmp 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  1311. 00000a30 <_ZN10Nokia_51106_printEh.constprop.6>:
  1312. _cursor.moveYAxis(1);
  1313. setCursor(_cursor.getPosition().x, _cursor.getPosition().y);
  1314. initializeForSendingData();
  1315. }
  1316. void Nokia_5110::_print(uint8_t charAsciiCode){
  1317. a30: 8f 92 push r8
  1318. a32: 9f 92 push r9
  1319. a34: af 92 push r10
  1320. a36: bf 92 push r11
  1321. a38: cf 92 push r12
  1322. a3a: df 92 push r13
  1323. a3c: ef 92 push r14
  1324. a3e: ff 92 push r15
  1325. a40: 0f 93 push r16
  1326. a42: 1f 93 push r17
  1327. a44: cf 93 push r28
  1328. a46: df 93 push r29
  1329. a48: cd b7 in r28, 0x3d ; 61
  1330. a4a: de b7 in r29, 0x3e ; 62
  1331. a4c: 2a 97 sbiw r28, 0x0a ; 10
  1332. a4e: 0f b6 in r0, 0x3f ; 63
  1333. a50: f8 94 cli
  1334. a52: de bf out 0x3e, r29 ; 62
  1335. a54: 0f be out 0x3f, r0 ; 63
  1336. a56: cd bf out 0x3d, r28 ; 61
  1337. a58: 8c 01 movw r16, r24
  1338. a5a: d6 2e mov r13, r22
  1339. a5c: 0e 96 adiw r24, 0x0e ; 14
  1340. a5e: 5c 01 movw r10, r24
  1341. if (charAsciiCode == 0x0a){ // \n for jumping to the beginning of a new line.
  1342. a60: 9a e0 ldi r25, 0x0A ; 10
  1343. a62: 69 13 cpse r22, r25
  1344. a64: 04 c0 rjmp .+8 ; 0xa6e <_ZN10Nokia_51106_printEh.constprop.6+0x3e>
  1345. _cursor.moveYAxis(1);
  1346. a66: c5 01 movw r24, r10
  1347. a68: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10>
  1348. a6c: 72 c0 rjmp .+228 ; 0xb52 <_ZN10Nokia_51106_printEh.constprop.6+0x122>
  1349. return;
  1350. }
  1351. setCursor(_cursor.getPosition().x, _cursor.getPosition().y);
  1352. a6e: f8 01 movw r30, r16
  1353. a70: 46 85 ldd r20, Z+14 ; 0x0e
  1354. a72: 57 85 ldd r21, Z+15 ; 0x0f
  1355. a74: 60 89 ldd r22, Z+16 ; 0x10
  1356. a76: 71 89 ldd r23, Z+17 ; 0x11
  1357. a78: c8 01 movw r24, r16
  1358. a7a: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  1359. digitalWrite(_RST, LOW);
  1360. digitalWrite(_RST, HIGH);
  1361. }
  1362. void Nokia_5110::initializeForSendingData(){
  1363. digitalWrite(_DC, HIGH);
  1364. a7e: 61 e0 ldi r22, 0x01 ; 1
  1365. a80: f8 01 movw r30, r16
  1366. a82: 80 85 ldd r24, Z+8 ; 0x08
  1367. a84: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1368. a88: 8c e7 ldi r24, 0x7C ; 124
  1369. a8a: e8 2e mov r14, r24
  1370. a8c: 80 e0 ldi r24, 0x00 ; 0
  1371. a8e: f8 2e mov r15, r24
  1372. unsigned short int total_characters = sizeof(characters) / sizeof(*characters);
  1373. character temp;
  1374. for (unsigned short int i = 0; i < total_characters; i++) {
  1375. //Retrieve character from FLASH MEMORY
  1376. memcpy_P(&temp, &characters[i], sizeof(character));
  1377. a90: 4a e0 ldi r20, 0x0A ; 10
  1378. a92: 50 e0 ldi r21, 0x00 ; 0
  1379. a94: b7 01 movw r22, r14
  1380. a96: ce 01 movw r24, r28
  1381. a98: 01 96 adiw r24, 0x01 ; 1
  1382. a9a: 0e 94 92 08 call 0x1124 ; 0x1124 <memcpy_P>
  1383. if (temp.ascii_code == ascii_code) return temp;
  1384. a9e: 8a 81 ldd r24, Y+2 ; 0x02
  1385. aa0: d8 16 cp r13, r24
  1386. aa2: 81 f0 breq .+32 ; 0xac4 <_ZN10Nokia_51106_printEh.constprop.6+0x94>
  1387. aa4: fa e0 ldi r31, 0x0A ; 10
  1388. aa6: ef 0e add r14, r31
  1389. aa8: f1 1c adc r15, r1
  1390. character findCorrespondingByte(uint8_t ascii_code){
  1391. unsigned short int total_characters = sizeof(characters) / sizeof(*characters);
  1392. character temp;
  1393. for (unsigned short int i = 0; i < total_characters; i++) {
  1394. aaa: 82 e3 ldi r24, 0x32 ; 50
  1395. aac: e8 16 cp r14, r24
  1396. aae: 84 e0 ldi r24, 0x04 ; 4
  1397. ab0: f8 06 cpc r15, r24
  1398. ab2: 71 f7 brne .-36 ; 0xa90 <_ZN10Nokia_51106_printEh.constprop.6+0x60>
  1399. //Retrieve character from FLASH MEMORY
  1400. memcpy_P(&temp, &characters[i], sizeof(character));
  1401. if (temp.ascii_code == ascii_code) return temp;
  1402. }
  1403. memcpy_P(&temp, &characters[0], sizeof(character));
  1404. ab4: 4a e0 ldi r20, 0x0A ; 10
  1405. ab6: 50 e0 ldi r21, 0x00 ; 0
  1406. ab8: 6c e7 ldi r22, 0x7C ; 124
  1407. aba: 70 e0 ldi r23, 0x00 ; 0
  1408. abc: ce 01 movw r24, r28
  1409. abe: 01 96 adiw r24, 0x01 ; 1
  1410. ac0: 0e 94 92 08 call 0x1124 ; 0x1124 <memcpy_P>
  1411. setCursor(_cursor.getPosition().x, _cursor.getPosition().y);
  1412. initializeForSendingData();
  1413. character fontData = findCorrespondingByte(charAsciiCode);
  1414. ac4: c9 84 ldd r12, Y+9 ; 0x09
  1415. ac6: da 84 ldd r13, Y+10 ; 0x0a
  1416. void Nokia_5110::initializeForSendingData(){
  1417. digitalWrite(_DC, HIGH);
  1418. }
  1419. void Nokia_5110::makeEnoughSpaceForPrinting(unsigned short int newCharacterLength){
  1420. if((newCharacterLength + _cursor.getPosition().x) < 85)
  1421. ac8: f8 01 movw r30, r16
  1422. aca: 80 89 ldd r24, Z+16 ; 0x10
  1423. acc: 91 89 ldd r25, Z+17 ; 0x11
  1424. ace: 8c 0d add r24, r12
  1425. ad0: 9d 1d adc r25, r13
  1426. ad2: 85 35 cpi r24, 0x55 ; 85
  1427. ad4: 91 05 cpc r25, r1
  1428. ad6: 80 f0 brcs .+32 ; 0xaf8 <_ZN10Nokia_51106_printEh.constprop.6+0xc8>
  1429. return;
  1430. _cursor.moveYAxis(1);
  1431. ad8: c5 01 movw r24, r10
  1432. ada: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10>
  1433. setCursor(_cursor.getPosition().x, _cursor.getPosition().y);
  1434. ade: f8 01 movw r30, r16
  1435. ae0: 46 85 ldd r20, Z+14 ; 0x0e
  1436. ae2: 57 85 ldd r21, Z+15 ; 0x0f
  1437. ae4: 60 89 ldd r22, Z+16 ; 0x10
  1438. ae6: 71 89 ldd r23, Z+17 ; 0x11
  1439. ae8: c8 01 movw r24, r16
  1440. aea: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  1441. digitalWrite(_RST, LOW);
  1442. digitalWrite(_RST, HIGH);
  1443. }
  1444. void Nokia_5110::initializeForSendingData(){
  1445. digitalWrite(_DC, HIGH);
  1446. aee: 61 e0 ldi r22, 0x01 ; 1
  1447. af0: f8 01 movw r30, r16
  1448. af2: 80 85 ldd r24, Z+8 ; 0x08
  1449. af4: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1450. af8: ce 01 movw r24, r28
  1451. afa: 01 96 adiw r24, 0x01 ; 1
  1452. afc: 7c 01 movw r14, r24
  1453. afe: 4c 01 movw r8, r24
  1454. b00: 8c 0c add r8, r12
  1455. b02: 9d 1c adc r9, r13
  1456. initializeForSendingData();
  1457. character fontData = findCorrespondingByte(charAsciiCode);
  1458. makeEnoughSpaceForPrinting(fontData.definition_total_bytes);
  1459. for(unsigned int i = 0; i < fontData.definition_total_bytes; i++){
  1460. b04: e8 14 cp r14, r8
  1461. b06: f9 04 cpc r15, r9
  1462. b08: 49 f0 breq .+18 ; 0xb1c <_ZN10Nokia_51106_printEh.constprop.6+0xec>
  1463. transmitInformation(fontData.definition[i]);
  1464. b0a: f7 01 movw r30, r14
  1465. b0c: 62 81 ldd r22, Z+2 ; 0x02
  1466. b0e: c8 01 movw r24, r16
  1467. b10: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh>
  1468. b14: ff ef ldi r31, 0xFF ; 255
  1469. b16: ef 1a sub r14, r31
  1470. b18: ff 0a sbc r15, r31
  1471. b1a: f4 cf rjmp .-24 ; 0xb04 <_ZN10Nokia_51106_printEh.constprop.6+0xd4>
  1472. }
  1473. transmitInformation(0x0); // add an empty line after each chars
  1474. b1c: 60 e0 ldi r22, 0x00 ; 0
  1475. b1e: c8 01 movw r24, r16
  1476. b20: 0e 94 9d 04 call 0x93a ; 0x93a <_ZN10Nokia_511019transmitInformationEh>
  1477. /**
  1478. * Moves cursor in x axis by a number sepcified in method's parameter
  1479. */
  1480. void Cursor::moveXAxis(position by){
  1481. if(by == 0)
  1482. b24: 8f ef ldi r24, 0xFF ; 255
  1483. b26: c8 16 cp r12, r24
  1484. b28: d8 06 cpc r13, r24
  1485. b2a: 99 f0 breq .+38 ; 0xb52 <_ZN10Nokia_51106_printEh.constprop.6+0x122>
  1486. return;
  1487. _x++;
  1488. b2c: f8 01 movw r30, r16
  1489. b2e: 80 89 ldd r24, Z+16 ; 0x10
  1490. b30: 91 89 ldd r25, Z+17 ; 0x11
  1491. b32: 01 96 adiw r24, 0x01 ; 1
  1492. b34: 91 8b std Z+17, r25 ; 0x11
  1493. b36: 80 8b std Z+16, r24 ; 0x10
  1494. if(_x > 83){
  1495. b38: 84 35 cpi r24, 0x54 ; 84
  1496. b3a: 91 05 cpc r25, r1
  1497. b3c: 30 f0 brcs .+12 ; 0xb4a <_ZN10Nokia_51106_printEh.constprop.6+0x11a>
  1498. moveYAxis(1);
  1499. b3e: c5 01 movw r24, r10
  1500. b40: 0e 94 81 02 call 0x502 ; 0x502 <_ZN6Cursor9moveYAxisEt.constprop.10>
  1501. _x = 0;
  1502. b44: f8 01 movw r30, r16
  1503. b46: 11 8a std Z+17, r1 ; 0x11
  1504. b48: 10 8a std Z+16, r1 ; 0x10
  1505. b4a: f1 e0 ldi r31, 0x01 ; 1
  1506. b4c: cf 1a sub r12, r31
  1507. b4e: d1 08 sbc r13, r1
  1508. b50: e9 cf rjmp .-46 ; 0xb24 <_ZN10Nokia_51106_printEh.constprop.6+0xf4>
  1509. _cursor.moveXAxis(fontData.definition_total_bytes + 1);
  1510. }
  1511. b52: 2a 96 adiw r28, 0x0a ; 10
  1512. b54: 0f b6 in r0, 0x3f ; 63
  1513. b56: f8 94 cli
  1514. b58: de bf out 0x3e, r29 ; 62
  1515. b5a: 0f be out 0x3f, r0 ; 63
  1516. b5c: cd bf out 0x3d, r28 ; 61
  1517. b5e: df 91 pop r29
  1518. b60: cf 91 pop r28
  1519. b62: 1f 91 pop r17
  1520. b64: 0f 91 pop r16
  1521. b66: ff 90 pop r15
  1522. b68: ef 90 pop r14
  1523. b6a: df 90 pop r13
  1524. b6c: cf 90 pop r12
  1525. b6e: bf 90 pop r11
  1526. b70: af 90 pop r10
  1527. b72: 9f 90 pop r9
  1528. b74: 8f 90 pop r8
  1529. b76: 08 95 ret
  1530. 00000b78 <_ZN10Nokia_51105writeEh>:
  1531. extendedInstruction();
  1532. execute(rate);
  1533. }
  1534. size_t Nokia_5110::write(uint8_t character) {
  1535. _print(character);
  1536. b78: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6>
  1537. return 1;
  1538. }
  1539. b7c: 81 e0 ldi r24, 0x01 ; 1
  1540. b7e: 90 e0 ldi r25, 0x00 ; 0
  1541. b80: 08 95 ret
  1542. 00000b82 <__cxa_pure_virtual>:
  1543. extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
  1544. void __cxa_pure_virtual(void) {
  1545. // We might want to write some diagnostics to uart in this case
  1546. //std::terminate();
  1547. abort();
  1548. b82: 0e 94 8d 0a call 0x151a ; 0x151a <abort>
  1549. 00000b86 <__vector_16>:
  1550. #if defined(TIM0_OVF_vect)
  1551. ISR(TIM0_OVF_vect)
  1552. #else
  1553. ISR(TIMER0_OVF_vect)
  1554. #endif
  1555. {
  1556. b86: 1f 92 push r1
  1557. b88: 0f 92 push r0
  1558. b8a: 0f b6 in r0, 0x3f ; 63
  1559. b8c: 0f 92 push r0
  1560. b8e: 11 24 eor r1, r1
  1561. b90: 2f 93 push r18
  1562. b92: 3f 93 push r19
  1563. b94: 8f 93 push r24
  1564. b96: 9f 93 push r25
  1565. b98: af 93 push r26
  1566. b9a: bf 93 push r27
  1567. // copy these to local variables so they can be stored in registers
  1568. // (volatile variables must be read from memory on every access)
  1569. unsigned long m = timer0_millis;
  1570. b9c: 80 91 4b 01 lds r24, 0x014B ; 0x80014b <timer0_millis>
  1571. ba0: 90 91 4c 01 lds r25, 0x014C ; 0x80014c <timer0_millis+0x1>
  1572. ba4: a0 91 4d 01 lds r26, 0x014D ; 0x80014d <timer0_millis+0x2>
  1573. ba8: b0 91 4e 01 lds r27, 0x014E ; 0x80014e <timer0_millis+0x3>
  1574. unsigned char f = timer0_fract;
  1575. bac: 30 91 4a 01 lds r19, 0x014A ; 0x80014a <timer0_fract>
  1576. m += MILLIS_INC;
  1577. f += FRACT_INC;
  1578. bb0: 23 e0 ldi r18, 0x03 ; 3
  1579. bb2: 23 0f add r18, r19
  1580. if (f >= FRACT_MAX) {
  1581. bb4: 2d 37 cpi r18, 0x7D ; 125
  1582. bb6: 20 f4 brcc .+8 ; 0xbc0 <__vector_16+0x3a>
  1583. // copy these to local variables so they can be stored in registers
  1584. // (volatile variables must be read from memory on every access)
  1585. unsigned long m = timer0_millis;
  1586. unsigned char f = timer0_fract;
  1587. m += MILLIS_INC;
  1588. bb8: 01 96 adiw r24, 0x01 ; 1
  1589. bba: a1 1d adc r26, r1
  1590. bbc: b1 1d adc r27, r1
  1591. bbe: 05 c0 rjmp .+10 ; 0xbca <__vector_16+0x44>
  1592. f += FRACT_INC;
  1593. if (f >= FRACT_MAX) {
  1594. f -= FRACT_MAX;
  1595. bc0: 26 e8 ldi r18, 0x86 ; 134
  1596. bc2: 23 0f add r18, r19
  1597. m += 1;
  1598. bc4: 02 96 adiw r24, 0x02 ; 2
  1599. bc6: a1 1d adc r26, r1
  1600. bc8: b1 1d adc r27, r1
  1601. }
  1602. timer0_fract = f;
  1603. bca: 20 93 4a 01 sts 0x014A, r18 ; 0x80014a <timer0_fract>
  1604. timer0_millis = m;
  1605. bce: 80 93 4b 01 sts 0x014B, r24 ; 0x80014b <timer0_millis>
  1606. bd2: 90 93 4c 01 sts 0x014C, r25 ; 0x80014c <timer0_millis+0x1>
  1607. bd6: a0 93 4d 01 sts 0x014D, r26 ; 0x80014d <timer0_millis+0x2>
  1608. bda: b0 93 4e 01 sts 0x014E, r27 ; 0x80014e <timer0_millis+0x3>
  1609. timer0_overflow_count++;
  1610. bde: 80 91 4f 01 lds r24, 0x014F ; 0x80014f <timer0_overflow_count>
  1611. be2: 90 91 50 01 lds r25, 0x0150 ; 0x800150 <timer0_overflow_count+0x1>
  1612. be6: a0 91 51 01 lds r26, 0x0151 ; 0x800151 <timer0_overflow_count+0x2>
  1613. bea: b0 91 52 01 lds r27, 0x0152 ; 0x800152 <timer0_overflow_count+0x3>
  1614. bee: 01 96 adiw r24, 0x01 ; 1
  1615. bf0: a1 1d adc r26, r1
  1616. bf2: b1 1d adc r27, r1
  1617. bf4: 80 93 4f 01 sts 0x014F, r24 ; 0x80014f <timer0_overflow_count>
  1618. bf8: 90 93 50 01 sts 0x0150, r25 ; 0x800150 <timer0_overflow_count+0x1>
  1619. bfc: a0 93 51 01 sts 0x0151, r26 ; 0x800151 <timer0_overflow_count+0x2>
  1620. c00: b0 93 52 01 sts 0x0152, r27 ; 0x800152 <timer0_overflow_count+0x3>
  1621. }
  1622. c04: bf 91 pop r27
  1623. c06: af 91 pop r26
  1624. c08: 9f 91 pop r25
  1625. c0a: 8f 91 pop r24
  1626. c0c: 3f 91 pop r19
  1627. c0e: 2f 91 pop r18
  1628. c10: 0f 90 pop r0
  1629. c12: 0f be out 0x3f, r0 ; 63
  1630. c14: 0f 90 pop r0
  1631. c16: 1f 90 pop r1
  1632. c18: 18 95 reti
  1633. 00000c1a <__vector_19>:
  1634. #elif defined(USART_UDRE_vect)
  1635. ISR(USART_UDRE_vect)
  1636. #else
  1637. #error "Don't know what the Data Register Empty vector is called for Serial"
  1638. #endif
  1639. {
  1640. c1a: 1f 92 push r1
  1641. c1c: 0f 92 push r0
  1642. c1e: 0f b6 in r0, 0x3f ; 63
  1643. c20: 0f 92 push r0
  1644. c22: 11 24 eor r1, r1
  1645. c24: 2f 93 push r18
  1646. c26: 3f 93 push r19
  1647. c28: 4f 93 push r20
  1648. c2a: 5f 93 push r21
  1649. c2c: 6f 93 push r22
  1650. c2e: 7f 93 push r23
  1651. c30: 8f 93 push r24
  1652. c32: 9f 93 push r25
  1653. c34: af 93 push r26
  1654. c36: bf 93 push r27
  1655. c38: ef 93 push r30
  1656. c3a: ff 93 push r31
  1657. Serial._tx_udr_empty_irq();
  1658. c3c: 83 e5 ldi r24, 0x53 ; 83
  1659. c3e: 91 e0 ldi r25, 0x01 ; 1
  1660. c40: 0e 94 ab 03 call 0x756 ; 0x756 <_ZN14HardwareSerial17_tx_udr_empty_irqEv>
  1661. }
  1662. c44: ff 91 pop r31
  1663. c46: ef 91 pop r30
  1664. c48: bf 91 pop r27
  1665. c4a: af 91 pop r26
  1666. c4c: 9f 91 pop r25
  1667. c4e: 8f 91 pop r24
  1668. c50: 7f 91 pop r23
  1669. c52: 6f 91 pop r22
  1670. c54: 5f 91 pop r21
  1671. c56: 4f 91 pop r20
  1672. c58: 3f 91 pop r19
  1673. c5a: 2f 91 pop r18
  1674. c5c: 0f 90 pop r0
  1675. c5e: 0f be out 0x3f, r0 ; 63
  1676. c60: 0f 90 pop r0
  1677. c62: 1f 90 pop r1
  1678. c64: 18 95 reti
  1679. 00000c66 <__vector_18>:
  1680. #elif defined(USART_RXC_vect)
  1681. ISR(USART_RXC_vect) // ATmega8
  1682. #else
  1683. #error "Don't know what the Data Received vector is called for Serial"
  1684. #endif
  1685. {
  1686. c66: 1f 92 push r1
  1687. c68: 0f 92 push r0
  1688. c6a: 0f b6 in r0, 0x3f ; 63
  1689. c6c: 0f 92 push r0
  1690. c6e: 11 24 eor r1, r1
  1691. c70: 2f 93 push r18
  1692. c72: 8f 93 push r24
  1693. c74: 9f 93 push r25
  1694. c76: ef 93 push r30
  1695. c78: ff 93 push r31
  1696. // Actual interrupt handlers //////////////////////////////////////////////////////////////
  1697. void HardwareSerial::_rx_complete_irq(void)
  1698. {
  1699. if (bit_is_clear(*_ucsra, UPE0)) {
  1700. c7a: e0 91 63 01 lds r30, 0x0163 ; 0x800163 <Serial+0x10>
  1701. c7e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 <Serial+0x11>
  1702. c82: 80 81 ld r24, Z
  1703. c84: e0 91 69 01 lds r30, 0x0169 ; 0x800169 <Serial+0x16>
  1704. c88: f0 91 6a 01 lds r31, 0x016A ; 0x80016a <Serial+0x17>
  1705. c8c: 82 fd sbrc r24, 2
  1706. c8e: 12 c0 rjmp .+36 ; 0xcb4 <__vector_18+0x4e>
  1707. // No Parity error, read byte and store it in the buffer if there is
  1708. // room
  1709. unsigned char c = *_udr;
  1710. c90: 90 81 ld r25, Z
  1711. rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE;
  1712. c92: 80 91 6c 01 lds r24, 0x016C ; 0x80016c <Serial+0x19>
  1713. c96: 8f 5f subi r24, 0xFF ; 255
  1714. c98: 8f 73 andi r24, 0x3F ; 63
  1715. // if we should be storing the received character into the location
  1716. // just before the tail (meaning that the head would advance to the
  1717. // current location of the tail), we're about to overflow the buffer
  1718. // and so we don't write the character or advance the head.
  1719. if (i != _rx_buffer_tail) {
  1720. c9a: 20 91 6d 01 lds r18, 0x016D ; 0x80016d <Serial+0x1a>
  1721. c9e: 82 17 cp r24, r18
  1722. ca0: 51 f0 breq .+20 ; 0xcb6 <__vector_18+0x50>
  1723. _rx_buffer[_rx_buffer_head] = c;
  1724. ca2: e0 91 6c 01 lds r30, 0x016C ; 0x80016c <Serial+0x19>
  1725. ca6: f0 e0 ldi r31, 0x00 ; 0
  1726. ca8: ed 5a subi r30, 0xAD ; 173
  1727. caa: fe 4f sbci r31, 0xFE ; 254
  1728. cac: 95 8f std Z+29, r25 ; 0x1d
  1729. _rx_buffer_head = i;
  1730. cae: 80 93 6c 01 sts 0x016C, r24 ; 0x80016c <Serial+0x19>
  1731. cb2: 01 c0 rjmp .+2 ; 0xcb6 <__vector_18+0x50>
  1732. }
  1733. } else {
  1734. // Parity error, read byte but discard it
  1735. *_udr;
  1736. cb4: 80 81 ld r24, Z
  1737. Serial._rx_complete_irq();
  1738. }
  1739. cb6: ff 91 pop r31
  1740. cb8: ef 91 pop r30
  1741. cba: 9f 91 pop r25
  1742. cbc: 8f 91 pop r24
  1743. cbe: 2f 91 pop r18
  1744. cc0: 0f 90 pop r0
  1745. cc2: 0f be out 0x3f, r0 ; 63
  1746. cc4: 0f 90 pop r0
  1747. cc6: 1f 90 pop r1
  1748. cc8: 18 95 reti
  1749. 00000cca <_GLOBAL__I_65535_0_BasicPHSensor.ino.cpp.o.2007>:
  1750. cca: cf 93 push r28
  1751. ccc: df 93 push r29
  1752. size_t printNumber(unsigned long, uint8_t);
  1753. size_t printFloat(double, uint8_t);
  1754. protected:
  1755. void setWriteError(int err = 1) { write_error = err; }
  1756. public:
  1757. Print() : write_error(0) {}
  1758. cce: e3 e5 ldi r30, 0x53 ; 83
  1759. cd0: f1 e0 ldi r31, 0x01 ; 1
  1760. cd2: 13 82 std Z+3, r1 ; 0x03
  1761. cd4: 12 82 std Z+2, r1 ; 0x02
  1762. public:
  1763. virtual int available() = 0;
  1764. virtual int read() = 0;
  1765. virtual int peek() = 0;
  1766. Stream() {_timeout=1000;}
  1767. cd6: 88 ee ldi r24, 0xE8 ; 232
  1768. cd8: 93 e0 ldi r25, 0x03 ; 3
  1769. cda: a0 e0 ldi r26, 0x00 ; 0
  1770. cdc: b0 e0 ldi r27, 0x00 ; 0
  1771. cde: 84 83 std Z+4, r24 ; 0x04
  1772. ce0: 95 83 std Z+5, r25 ; 0x05
  1773. ce2: a6 83 std Z+6, r26 ; 0x06
  1774. ce4: b7 83 std Z+7, r27 ; 0x07
  1775. volatile uint8_t *ucsrc, volatile uint8_t *udr) :
  1776. _ubrrh(ubrrh), _ubrrl(ubrrl),
  1777. _ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc),
  1778. _udr(udr),
  1779. _rx_buffer_head(0), _rx_buffer_tail(0),
  1780. _tx_buffer_head(0), _tx_buffer_tail(0)
  1781. ce6: 84 e0 ldi r24, 0x04 ; 4
  1782. ce8: 91 e0 ldi r25, 0x01 ; 1
  1783. cea: 91 83 std Z+1, r25 ; 0x01
  1784. cec: 80 83 st Z, r24
  1785. cee: 85 ec ldi r24, 0xC5 ; 197
  1786. cf0: 90 e0 ldi r25, 0x00 ; 0
  1787. cf2: 95 87 std Z+13, r25 ; 0x0d
  1788. cf4: 84 87 std Z+12, r24 ; 0x0c
  1789. cf6: 84 ec ldi r24, 0xC4 ; 196
  1790. cf8: 90 e0 ldi r25, 0x00 ; 0
  1791. cfa: 97 87 std Z+15, r25 ; 0x0f
  1792. cfc: 86 87 std Z+14, r24 ; 0x0e
  1793. cfe: 80 ec ldi r24, 0xC0 ; 192
  1794. d00: 90 e0 ldi r25, 0x00 ; 0
  1795. d02: 91 8b std Z+17, r25 ; 0x11
  1796. d04: 80 8b std Z+16, r24 ; 0x10
  1797. d06: 81 ec ldi r24, 0xC1 ; 193
  1798. d08: 90 e0 ldi r25, 0x00 ; 0
  1799. d0a: 93 8b std Z+19, r25 ; 0x13
  1800. d0c: 82 8b std Z+18, r24 ; 0x12
  1801. d0e: 82 ec ldi r24, 0xC2 ; 194
  1802. d10: 90 e0 ldi r25, 0x00 ; 0
  1803. d12: 95 8b std Z+21, r25 ; 0x15
  1804. d14: 84 8b std Z+20, r24 ; 0x14
  1805. d16: 86 ec ldi r24, 0xC6 ; 198
  1806. d18: 90 e0 ldi r25, 0x00 ; 0
  1807. d1a: 97 8b std Z+23, r25 ; 0x17
  1808. d1c: 86 8b std Z+22, r24 ; 0x16
  1809. d1e: 11 8e std Z+25, r1 ; 0x19
  1810. d20: 12 8e std Z+26, r1 ; 0x1a
  1811. d22: 13 8e std Z+27, r1 ; 0x1b
  1812. d24: 14 8e std Z+28, r1 ; 0x1c
  1813. d26: c0 ef ldi r28, 0xF0 ; 240
  1814. d28: d1 e0 ldi r29, 0x01 ; 1
  1815. d2a: 1b 82 std Y+3, r1 ; 0x03
  1816. d2c: 1a 82 std Y+2, r1 ; 0x02
  1817. #include "Nokia_5110.h"
  1818. #include "Font.h"
  1819. Nokia_5110::Nokia_5110(){}
  1820. Nokia_5110::Nokia_5110(unsigned short RST, unsigned short CE, unsigned short DC, unsigned short DIN, unsigned short CLK){
  1821. d2e: 86 e1 ldi r24, 0x16 ; 22
  1822. d30: 91 e0 ldi r25, 0x01 ; 1
  1823. d32: 99 83 std Y+1, r25 ; 0x01
  1824. d34: 88 83 st Y, r24
  1825. struct Position {
  1826. position y;
  1827. position x;
  1828. };
  1829. class Cursor {
  1830. d36: 1f 86 std Y+15, r1 ; 0x0f
  1831. d38: 1e 86 std Y+14, r1 ; 0x0e
  1832. d3a: 19 8a std Y+17, r1 ; 0x11
  1833. d3c: 18 8a std Y+16, r1 ; 0x10
  1834. _RST = RST;
  1835. d3e: 83 e0 ldi r24, 0x03 ; 3
  1836. d40: 90 e0 ldi r25, 0x00 ; 0
  1837. d42: 9d 83 std Y+5, r25 ; 0x05
  1838. d44: 8c 83 std Y+4, r24 ; 0x04
  1839. _CE = CE;
  1840. d46: 84 e0 ldi r24, 0x04 ; 4
  1841. d48: 90 e0 ldi r25, 0x00 ; 0
  1842. d4a: 9f 83 std Y+7, r25 ; 0x07
  1843. d4c: 8e 83 std Y+6, r24 ; 0x06
  1844. _DC = DC;
  1845. d4e: 85 e0 ldi r24, 0x05 ; 5
  1846. d50: 90 e0 ldi r25, 0x00 ; 0
  1847. d52: 99 87 std Y+9, r25 ; 0x09
  1848. d54: 88 87 std Y+8, r24 ; 0x08
  1849. _DIN = DIN;
  1850. d56: 86 e0 ldi r24, 0x06 ; 6
  1851. d58: 90 e0 ldi r25, 0x00 ; 0
  1852. d5a: 9b 87 std Y+11, r25 ; 0x0b
  1853. d5c: 8a 87 std Y+10, r24 ; 0x0a
  1854. _CLK = CLK;
  1855. d5e: 87 e0 ldi r24, 0x07 ; 7
  1856. d60: 90 e0 ldi r25, 0x00 ; 0
  1857. d62: 9d 87 std Y+13, r25 ; 0x0d
  1858. d64: 8c 87 std Y+12, r24 ; 0x0c
  1859. pinMode(RST, OUTPUT);
  1860. d66: 83 e0 ldi r24, 0x03 ; 3
  1861. d68: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
  1862. pinMode(CE, OUTPUT);
  1863. d6c: 84 e0 ldi r24, 0x04 ; 4
  1864. d6e: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
  1865. pinMode(DC, OUTPUT);
  1866. d72: 85 e0 ldi r24, 0x05 ; 5
  1867. d74: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
  1868. pinMode(DIN, OUTPUT);
  1869. d78: 86 e0 ldi r24, 0x06 ; 6
  1870. d7a: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
  1871. pinMode(CLK, OUTPUT);
  1872. d7e: 87 e0 ldi r24, 0x07 ; 7
  1873. d80: 0e 94 62 02 call 0x4c4 ; 0x4c4 <pinMode.constprop.29>
  1874. _cursor = Cursor();
  1875. d84: 1f 86 std Y+15, r1 ; 0x0f
  1876. d86: 1e 86 std Y+14, r1 ; 0x0e
  1877. d88: 19 8a std Y+17, r1 ; 0x11
  1878. d8a: 18 8a std Y+16, r1 ; 0x10
  1879. const unsigned short leastValue = 4;
  1880. execute(byte(leastValue + value));
  1881. }
  1882. void Nokia_5110::reset(){
  1883. digitalWrite(_RST, LOW);
  1884. d8c: 60 e0 ldi r22, 0x00 ; 0
  1885. d8e: 8c 81 ldd r24, Y+4 ; 0x04
  1886. d90: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1887. digitalWrite(_RST, HIGH);
  1888. d94: 61 e0 ldi r22, 0x01 ; 1
  1889. d96: 8c 81 ldd r24, Y+4 ; 0x04
  1890. d98: 0e 94 8e 02 call 0x51c ; 0x51c <digitalWrite>
  1891. _cursor = Cursor();
  1892. reset();
  1893. clear();
  1894. d9c: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31>
  1895. void Nokia_5110::extendedInstruction(){
  1896. execute(0x21);
  1897. }
  1898. void Nokia_5110::basicInstruction(){
  1899. execute(0x20);
  1900. da0: 60 e2 ldi r22, 0x20 ; 32
  1901. da2: ce 01 movw r24, r28
  1902. da4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1903. }
  1904. void Nokia_5110::setDisplayMode(display_mode value){
  1905. basicInstruction();
  1906. execute(value);
  1907. da8: 6c e0 ldi r22, 0x0C ; 12
  1908. daa: ce 01 movw r24, r28
  1909. dac: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1910. const unsigned short leastValue = 128;
  1911. execute(byte(leastValue + value));
  1912. }
  1913. void Nokia_5110::extendedInstruction(){
  1914. execute(0x21);
  1915. db0: 61 e2 ldi r22, 0x21 ; 33
  1916. db2: ce 01 movw r24, r28
  1917. db4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1918. }
  1919. void Nokia_5110::setBiasSystem(mux_rate rate){
  1920. extendedInstruction();
  1921. execute(rate);
  1922. db8: 64 e1 ldi r22, 0x14 ; 20
  1923. dba: ce 01 movw r24, r28
  1924. dbc: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1925. const unsigned short leastValue = 128;
  1926. execute(byte(leastValue + value));
  1927. }
  1928. void Nokia_5110::extendedInstruction(){
  1929. execute(0x21);
  1930. dc0: 61 e2 ldi r22, 0x21 ; 33
  1931. dc2: ce 01 movw r24, r28
  1932. dc4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1933. return;
  1934. extendedInstruction();
  1935. const unsigned short leastValue = 128;
  1936. execute(byte(leastValue + value));
  1937. dc8: 6c eb ldi r22, 0xBC ; 188
  1938. dca: ce 01 movw r24, r28
  1939. dcc: df 91 pop r29
  1940. dce: cf 91 pop r28
  1941. dd0: 0c 94 d2 04 jmp 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  1942. 00000dd4 <main>:
  1943. void init()
  1944. {
  1945. // this needs to be called before setup() or some functions won't
  1946. // work there
  1947. sei();
  1948. dd4: 78 94 sei
  1949. // on the ATmega168, timer 0 is also used for fast hardware pwm
  1950. // (using phase-correct PWM would mean that timer 0 overflowed half as often
  1951. // resulting in different millis() behavior on the ATmega8 and ATmega168)
  1952. #if defined(TCCR0A) && defined(WGM01)
  1953. sbi(TCCR0A, WGM01);
  1954. dd6: 84 b5 in r24, 0x24 ; 36
  1955. dd8: 82 60 ori r24, 0x02 ; 2
  1956. dda: 84 bd out 0x24, r24 ; 36
  1957. sbi(TCCR0A, WGM00);
  1958. ddc: 84 b5 in r24, 0x24 ; 36
  1959. dde: 81 60 ori r24, 0x01 ; 1
  1960. de0: 84 bd out 0x24, r24 ; 36
  1961. // this combination is for the standard atmega8
  1962. sbi(TCCR0, CS01);
  1963. sbi(TCCR0, CS00);
  1964. #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
  1965. // this combination is for the standard 168/328/1280/2560
  1966. sbi(TCCR0B, CS01);
  1967. de2: 85 b5 in r24, 0x25 ; 37
  1968. de4: 82 60 ori r24, 0x02 ; 2
  1969. de6: 85 bd out 0x25, r24 ; 37
  1970. sbi(TCCR0B, CS00);
  1971. de8: 85 b5 in r24, 0x25 ; 37
  1972. dea: 81 60 ori r24, 0x01 ; 1
  1973. dec: 85 bd out 0x25, r24 ; 37
  1974. // enable timer 0 overflow interrupt
  1975. #if defined(TIMSK) && defined(TOIE0)
  1976. sbi(TIMSK, TOIE0);
  1977. #elif defined(TIMSK0) && defined(TOIE0)
  1978. sbi(TIMSK0, TOIE0);
  1979. dee: 80 91 6e 00 lds r24, 0x006E ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
  1980. df2: 81 60 ori r24, 0x01 ; 1
  1981. df4: 80 93 6e 00 sts 0x006E, r24 ; 0x80006e <__TEXT_REGION_LENGTH__+0x7e006e>
  1982. // this is better for motors as it ensures an even waveform
  1983. // note, however, that fast pwm mode can achieve a frequency of up
  1984. // 8 MHz (with a 16 MHz clock) at 50% duty cycle
  1985. #if defined(TCCR1B) && defined(CS11) && defined(CS10)
  1986. TCCR1B = 0;
  1987. df8: 10 92 81 00 sts 0x0081, r1 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
  1988. // set timer 1 prescale factor to 64
  1989. sbi(TCCR1B, CS11);
  1990. dfc: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
  1991. e00: 82 60 ori r24, 0x02 ; 2
  1992. e02: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
  1993. #if F_CPU >= 8000000L
  1994. sbi(TCCR1B, CS10);
  1995. e06: 80 91 81 00 lds r24, 0x0081 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
  1996. e0a: 81 60 ori r24, 0x01 ; 1
  1997. e0c: 80 93 81 00 sts 0x0081, r24 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
  1998. sbi(TCCR1, CS10);
  1999. #endif
  2000. #endif
  2001. // put timer 1 in 8-bit phase correct pwm mode
  2002. #if defined(TCCR1A) && defined(WGM10)
  2003. sbi(TCCR1A, WGM10);
  2004. e10: 80 91 80 00 lds r24, 0x0080 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
  2005. e14: 81 60 ori r24, 0x01 ; 1
  2006. e16: 80 93 80 00 sts 0x0080, r24 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
  2007. // set timer 2 prescale factor to 64
  2008. #if defined(TCCR2) && defined(CS22)
  2009. sbi(TCCR2, CS22);
  2010. #elif defined(TCCR2B) && defined(CS22)
  2011. sbi(TCCR2B, CS22);
  2012. e1a: 80 91 b1 00 lds r24, 0x00B1 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
  2013. e1e: 84 60 ori r24, 0x04 ; 4
  2014. e20: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
  2015. // configure timer 2 for phase correct pwm (8-bit)
  2016. #if defined(TCCR2) && defined(WGM20)
  2017. sbi(TCCR2, WGM20);
  2018. #elif defined(TCCR2A) && defined(WGM20)
  2019. sbi(TCCR2A, WGM20);
  2020. e24: 80 91 b0 00 lds r24, 0x00B0 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
  2021. e28: 81 60 ori r24, 0x01 ; 1
  2022. e2a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
  2023. #endif
  2024. #if defined(ADCSRA)
  2025. // set a2d prescaler so we are inside the desired 50-200 KHz range.
  2026. #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
  2027. sbi(ADCSRA, ADPS2);
  2028. e2e: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2029. e32: 84 60 ori r24, 0x04 ; 4
  2030. e34: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2031. sbi(ADCSRA, ADPS1);
  2032. e38: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2033. e3c: 82 60 ori r24, 0x02 ; 2
  2034. e3e: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2035. sbi(ADCSRA, ADPS0);
  2036. e42: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2037. e46: 81 60 ori r24, 0x01 ; 1
  2038. e48: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2039. cbi(ADCSRA, ADPS2);
  2040. cbi(ADCSRA, ADPS1);
  2041. sbi(ADCSRA, ADPS0);
  2042. #endif
  2043. // enable a2d conversions
  2044. sbi(ADCSRA, ADEN);
  2045. e4c: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2046. e50: 80 68 ori r24, 0x80 ; 128
  2047. e52: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2048. // here so they can be used as normal digital i/o; they will be
  2049. // reconnected in Serial.begin()
  2050. #if defined(UCSRB)
  2051. UCSRB = 0;
  2052. #elif defined(UCSR0B)
  2053. UCSR0B = 0;
  2054. e56: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1>
  2055. void HardwareSerial::begin(unsigned long baud, byte config)
  2056. {
  2057. // Try u2x mode first
  2058. uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
  2059. *_ucsra = 1 << U2X0;
  2060. e5a: e0 91 63 01 lds r30, 0x0163 ; 0x800163 <Serial+0x10>
  2061. e5e: f0 91 64 01 lds r31, 0x0164 ; 0x800164 <Serial+0x11>
  2062. e62: 82 e0 ldi r24, 0x02 ; 2
  2063. e64: 80 83 st Z, r24
  2064. *_ucsra = 0;
  2065. baud_setting = (F_CPU / 8 / baud - 1) / 2;
  2066. }
  2067. // assign the baud_setting, a.k.a. ubrr (USART Baud Rate Register)
  2068. *_ubrrh = baud_setting >> 8;
  2069. e66: e0 91 5f 01 lds r30, 0x015F ; 0x80015f <Serial+0xc>
  2070. e6a: f0 91 60 01 lds r31, 0x0160 ; 0x800160 <Serial+0xd>
  2071. e6e: 10 82 st Z, r1
  2072. *_ubrrl = baud_setting;
  2073. e70: e0 91 61 01 lds r30, 0x0161 ; 0x800161 <Serial+0xe>
  2074. e74: f0 91 62 01 lds r31, 0x0162 ; 0x800162 <Serial+0xf>
  2075. e78: 8f ec ldi r24, 0xCF ; 207
  2076. e7a: 80 83 st Z, r24
  2077. _written = false;
  2078. e7c: 10 92 6b 01 sts 0x016B, r1 ; 0x80016b <Serial+0x18>
  2079. //set the data bits, parity, and stop bits
  2080. #if defined(__AVR_ATmega8__)
  2081. config |= 0x80; // select UCSRC register (shared with UBRRH)
  2082. #endif
  2083. *_ucsrc = config;
  2084. e80: e0 91 67 01 lds r30, 0x0167 ; 0x800167 <Serial+0x14>
  2085. e84: f0 91 68 01 lds r31, 0x0168 ; 0x800168 <Serial+0x15>
  2086. e88: 86 e0 ldi r24, 0x06 ; 6
  2087. e8a: 80 83 st Z, r24
  2088. sbi(*_ucsrb, RXEN0);
  2089. e8c: e0 91 65 01 lds r30, 0x0165 ; 0x800165 <Serial+0x12>
  2090. e90: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
  2091. e94: 80 81 ld r24, Z
  2092. e96: 80 61 ori r24, 0x10 ; 16
  2093. e98: 80 83 st Z, r24
  2094. sbi(*_ucsrb, TXEN0);
  2095. e9a: e0 91 65 01 lds r30, 0x0165 ; 0x800165 <Serial+0x12>
  2096. e9e: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
  2097. ea2: 80 81 ld r24, Z
  2098. ea4: 88 60 ori r24, 0x08 ; 8
  2099. ea6: 80 83 st Z, r24
  2100. sbi(*_ucsrb, RXCIE0);
  2101. ea8: e0 91 65 01 lds r30, 0x0165 ; 0x800165 <Serial+0x12>
  2102. eac: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
  2103. eb0: 80 81 ld r24, Z
  2104. eb2: 80 68 ori r24, 0x80 ; 128
  2105. eb4: 80 83 st Z, r24
  2106. cbi(*_ucsrb, UDRIE0);
  2107. eb6: e0 91 65 01 lds r30, 0x0165 ; 0x800165 <Serial+0x12>
  2108. eba: f0 91 66 01 lds r31, 0x0166 ; 0x800166 <Serial+0x13>
  2109. ebe: 80 81 ld r24, Z
  2110. ec0: 8f 7d andi r24, 0xDF ; 223
  2111. ec2: 80 83 st Z, r24
  2112. }
  2113. void Nokia_5110::extendedInstruction(){
  2114. execute(0x21);
  2115. ec4: 61 e2 ldi r22, 0x21 ; 33
  2116. ec6: 80 ef ldi r24, 0xF0 ; 240
  2117. ec8: 91 e0 ldi r25, 0x01 ; 1
  2118. eca: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  2119. return;
  2120. extendedInstruction();
  2121. const unsigned short leastValue = 128;
  2122. execute(byte(leastValue + value));
  2123. ece: 6c e9 ldi r22, 0x9C ; 156
  2124. ed0: 80 ef ldi r24, 0xF0 ; 240
  2125. ed2: 91 e0 ldi r25, 0x01 ; 1
  2126. ed4: 0e 94 d2 04 call 0x9a4 ; 0x9a4 <_ZN10Nokia_51107executeEh>
  2127. * Note: if instead of text being shown on the display, all the segments are on, you may need to decrease contrast value.
  2128. */
  2129. lcd.setContrast(28); // 60 is the default value set by the driver
  2130. //lcd.print("Please Wait ...");
  2131. lcd.setCursor(15,1);
  2132. ed8: 41 e0 ldi r20, 0x01 ; 1
  2133. eda: 50 e0 ldi r21, 0x00 ; 0
  2134. edc: 6f e0 ldi r22, 0x0F ; 15
  2135. ede: 70 e0 ldi r23, 0x00 ; 0
  2136. ee0: 80 ef ldi r24, 0xF0 ; 240
  2137. ee2: 91 e0 ldi r25, 0x01 ; 1
  2138. ee4: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  2139. return write(s.c_str(), s.length());
  2140. }
  2141. size_t Print::print(const char str[])
  2142. {
  2143. return write(str);
  2144. ee8: 8e e1 ldi r24, 0x1E ; 30
  2145. eea: 91 e0 ldi r25, 0x01 ; 1
  2146. eec: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2147. lcd.print("Starting...");
  2148. delay(800);
  2149. ef0: 60 e2 ldi r22, 0x20 ; 32
  2150. ef2: 73 e0 ldi r23, 0x03 ; 3
  2151. ef4: 80 e0 ldi r24, 0x00 ; 0
  2152. ef6: 90 e0 ldi r25, 0x00 ; 0
  2153. ef8: 0e 94 00 03 call 0x600 ; 0x600 <delay>
  2154. lcd.clear();
  2155. efc: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31>
  2156. // to 0 (the default).
  2157. #if defined(ADMUX)
  2158. #if defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
  2159. ADMUX = (analog_reference << 4) | (pin & 0x07);
  2160. #else
  2161. ADMUX = (analog_reference << 6) | (pin & 0x07);
  2162. f00: c3 e4 ldi r28, 0x43 ; 67
  2163. //lcd.setCursor(0, 5);
  2164. //lcd.println("1 2 3 ...");
  2165. }
  2166. void loop() {
  2167. lcd.clear();
  2168. f02: 0e 94 fe 04 call 0x9fc ; 0x9fc <_ZN10Nokia_51105clearEv.constprop.31>
  2169. f06: c0 93 7c 00 sts 0x007C, r28 ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c>
  2170. // without a delay, we seem to read from the wrong channel
  2171. //delay(1);
  2172. #if defined(ADCSRA) && defined(ADCL)
  2173. // start the conversion
  2174. sbi(ADCSRA, ADSC);
  2175. f0a: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2176. f0e: 80 64 ori r24, 0x40 ; 64
  2177. f10: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2178. // ADSC is cleared when the conversion finishes
  2179. while (bit_is_set(ADCSRA, ADSC));
  2180. f14: 80 91 7a 00 lds r24, 0x007A ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
  2181. f18: 86 fd sbrc r24, 6
  2182. f1a: fc cf rjmp .-8 ; 0xf14 <main+0x140>
  2183. // we have to read ADCL first; doing so locks both ADCL
  2184. // and ADCH until ADCH is read. reading ADCL second would
  2185. // cause the results of each conversion to be discarded,
  2186. // as ADCL and ADCH would be locked when it completed.
  2187. low = ADCL;
  2188. f1c: 60 91 78 00 lds r22, 0x0078 ; 0x800078 <__TEXT_REGION_LENGTH__+0x7e0078>
  2189. high = ADCH;
  2190. f20: 80 91 79 00 lds r24, 0x0079 ; 0x800079 <__TEXT_REGION_LENGTH__+0x7e0079>
  2191. phVal_u16 = analogRead(PHSENSOR);
  2192. f24: 70 e0 ldi r23, 0x00 ; 0
  2193. f26: 78 2b or r23, r24
  2194. f28: 70 93 49 01 sts 0x0149, r23 ; 0x800149 <phVal_u16+0x1>
  2195. f2c: 60 93 48 01 sts 0x0148, r22 ; 0x800148 <phVal_u16>
  2196. phFloat = phVal_u16 * 0.013672;
  2197. f30: 80 e0 ldi r24, 0x00 ; 0
  2198. f32: 90 e0 ldi r25, 0x00 ; 0
  2199. f34: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf>
  2200. f38: 26 e8 ldi r18, 0x86 ; 134
  2201. f3a: 30 e0 ldi r19, 0x00 ; 0
  2202. f3c: 40 e6 ldi r20, 0x60 ; 96
  2203. f3e: 5c e3 ldi r21, 0x3C ; 60
  2204. f40: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3>
  2205. f44: 60 93 44 01 sts 0x0144, r22 ; 0x800144 <__data_end>
  2206. f48: 70 93 45 01 sts 0x0145, r23 ; 0x800145 <__data_end+0x1>
  2207. f4c: 80 93 46 01 sts 0x0146, r24 ; 0x800146 <__data_end+0x2>
  2208. f50: 90 93 47 01 sts 0x0147, r25 ; 0x800147 <__data_end+0x3>
  2209. lcd.setCursor(15,1);
  2210. f54: 41 e0 ldi r20, 0x01 ; 1
  2211. f56: 50 e0 ldi r21, 0x00 ; 0
  2212. f58: 6f e0 ldi r22, 0x0F ; 15
  2213. f5a: 70 e0 ldi r23, 0x00 ; 0
  2214. f5c: 80 ef ldi r24, 0xF0 ; 240
  2215. f5e: 91 e0 ldi r25, 0x01 ; 1
  2216. f60: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  2217. f64: 8a e2 ldi r24, 0x2A ; 42
  2218. f66: 91 e0 ldi r25, 0x01 ; 1
  2219. f68: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2220. return x.printTo(*this);
  2221. }
  2222. size_t Print::println(void)
  2223. {
  2224. return write("\r\n");
  2225. f6c: 8f e2 ldi r24, 0x2F ; 47
  2226. f6e: 91 e0 ldi r25, 0x01 ; 1
  2227. f70: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2228. lcd.println("Raw:");
  2229. lcd.setCursor(45,2);
  2230. f74: 42 e0 ldi r20, 0x02 ; 2
  2231. f76: 50 e0 ldi r21, 0x00 ; 0
  2232. f78: 6d e2 ldi r22, 0x2D ; 45
  2233. f7a: 70 e0 ldi r23, 0x00 ; 0
  2234. f7c: 80 ef ldi r24, 0xF0 ; 240
  2235. f7e: 91 e0 ldi r25, 0x01 ; 1
  2236. f80: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  2237. }
  2238. size_t Print::print(unsigned long n, int base)
  2239. {
  2240. if (base == 0) return write(n);
  2241. else return printNumber(n, base);
  2242. f84: 60 91 48 01 lds r22, 0x0148 ; 0x800148 <phVal_u16>
  2243. f88: 70 91 49 01 lds r23, 0x0149 ; 0x800149 <phVal_u16+0x1>
  2244. f8c: 80 e0 ldi r24, 0x00 ; 0
  2245. f8e: 90 e0 ldi r25, 0x00 ; 0
  2246. f90: 4a e0 ldi r20, 0x0A ; 10
  2247. f92: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20>
  2248. lcd.print(phVal_u16);
  2249. lcd.setCursor(15,3);
  2250. f96: 43 e0 ldi r20, 0x03 ; 3
  2251. f98: 50 e0 ldi r21, 0x00 ; 0
  2252. f9a: 6f e0 ldi r22, 0x0F ; 15
  2253. f9c: 70 e0 ldi r23, 0x00 ; 0
  2254. f9e: 80 ef ldi r24, 0xF0 ; 240
  2255. fa0: 91 e0 ldi r25, 0x01 ; 1
  2256. fa2: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  2257. return write(s.c_str(), s.length());
  2258. }
  2259. size_t Print::print(const char str[])
  2260. {
  2261. return write(str);
  2262. fa6: 82 e3 ldi r24, 0x32 ; 50
  2263. fa8: 91 e0 ldi r25, 0x01 ; 1
  2264. faa: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2265. return x.printTo(*this);
  2266. }
  2267. size_t Print::println(void)
  2268. {
  2269. return write("\r\n");
  2270. fae: 8f e2 ldi r24, 0x2F ; 47
  2271. fb0: 91 e0 ldi r25, 0x01 ; 1
  2272. fb2: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2273. lcd.println("PH #:");
  2274. lcd.setCursor(45,4);
  2275. fb6: 44 e0 ldi r20, 0x04 ; 4
  2276. fb8: 50 e0 ldi r21, 0x00 ; 0
  2277. fba: 6d e2 ldi r22, 0x2D ; 45
  2278. fbc: 70 e0 ldi r23, 0x00 ; 0
  2279. fbe: 80 ef ldi r24, 0xF0 ; 240
  2280. fc0: 91 e0 ldi r25, 0x01 ; 1
  2281. fc2: 0e 94 e2 04 call 0x9c4 ; 0x9c4 <_ZN10Nokia_51109setCursorEtt>
  2282. lcd.print(phFloat);
  2283. fc6: c0 90 44 01 lds r12, 0x0144 ; 0x800144 <__data_end>
  2284. fca: d0 90 45 01 lds r13, 0x0145 ; 0x800145 <__data_end+0x1>
  2285. fce: e0 90 46 01 lds r14, 0x0146 ; 0x800146 <__data_end+0x2>
  2286. fd2: f0 90 47 01 lds r15, 0x0147 ; 0x800147 <__data_end+0x3>
  2287. size_t Print::printFloat(double number, uint8_t digits)
  2288. {
  2289. size_t n = 0;
  2290. if (isnan(number)) return print("nan");
  2291. fd6: a7 01 movw r20, r14
  2292. fd8: 96 01 movw r18, r12
  2293. fda: c7 01 movw r24, r14
  2294. fdc: b6 01 movw r22, r12
  2295. fde: 0e 94 60 0a call 0x14c0 ; 0x14c0 <__unordsf2>
  2296. fe2: 88 23 and r24, r24
  2297. fe4: 19 f0 breq .+6 ; 0xfec <main+0x218>
  2298. return write(s.c_str(), s.length());
  2299. }
  2300. size_t Print::print(const char str[])
  2301. {
  2302. return write(str);
  2303. fe6: 88 e3 ldi r24, 0x38 ; 56
  2304. fe8: 91 e0 ldi r25, 0x01 ; 1
  2305. fea: 1a c0 rjmp .+52 ; 0x1020 <main+0x24c>
  2306. size_t Print::printFloat(double number, uint8_t digits)
  2307. {
  2308. size_t n = 0;
  2309. if (isnan(number)) return print("nan");
  2310. if (isinf(number)) return print("inf");
  2311. fec: 46 01 movw r8, r12
  2312. fee: 57 01 movw r10, r14
  2313. ff0: e8 94 clt
  2314. ff2: b7 f8 bld r11, 7
  2315. ff4: 2f ef ldi r18, 0xFF ; 255
  2316. ff6: 3f ef ldi r19, 0xFF ; 255
  2317. ff8: 4f e7 ldi r20, 0x7F ; 127
  2318. ffa: 5f e7 ldi r21, 0x7F ; 127
  2319. ffc: c5 01 movw r24, r10
  2320. ffe: b4 01 movw r22, r8
  2321. 1000: 0e 94 60 0a call 0x14c0 ; 0x14c0 <__unordsf2>
  2322. 1004: 81 11 cpse r24, r1
  2323. 1006: 0f c0 rjmp .+30 ; 0x1026 <main+0x252>
  2324. 1008: 2f ef ldi r18, 0xFF ; 255
  2325. 100a: 3f ef ldi r19, 0xFF ; 255
  2326. 100c: 4f e7 ldi r20, 0x7F ; 127
  2327. 100e: 5f e7 ldi r21, 0x7F ; 127
  2328. 1010: c5 01 movw r24, r10
  2329. 1012: b4 01 movw r22, r8
  2330. 1014: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2>
  2331. 1018: 18 16 cp r1, r24
  2332. 101a: 2c f4 brge .+10 ; 0x1026 <main+0x252>
  2333. return write(s.c_str(), s.length());
  2334. }
  2335. size_t Print::print(const char str[])
  2336. {
  2337. return write(str);
  2338. 101c: 8c e3 ldi r24, 0x3C ; 60
  2339. 101e: 91 e0 ldi r25, 0x01 ; 1
  2340. 1020: 0e 94 4a 04 call 0x894 ; 0x894 <_ZN5Print5writeEPKc.constprop.24>
  2341. 1024: 76 c0 rjmp .+236 ; 0x1112 <main+0x33e>
  2342. {
  2343. size_t n = 0;
  2344. if (isnan(number)) return print("nan");
  2345. if (isinf(number)) return print("inf");
  2346. if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
  2347. 1026: 2f ef ldi r18, 0xFF ; 255
  2348. 1028: 3f ef ldi r19, 0xFF ; 255
  2349. 102a: 4f e7 ldi r20, 0x7F ; 127
  2350. 102c: 5f e4 ldi r21, 0x4F ; 79
  2351. 102e: c7 01 movw r24, r14
  2352. 1030: b6 01 movw r22, r12
  2353. 1032: 0e 94 ee 09 call 0x13dc ; 0x13dc <__gesf2>
  2354. 1036: 18 16 cp r1, r24
  2355. 1038: 1c f4 brge .+6 ; 0x1040 <main+0x26c>
  2356. return write(s.c_str(), s.length());
  2357. }
  2358. size_t Print::print(const char str[])
  2359. {
  2360. return write(str);
  2361. 103a: 80 e4 ldi r24, 0x40 ; 64
  2362. 103c: 91 e0 ldi r25, 0x01 ; 1
  2363. 103e: f0 cf rjmp .-32 ; 0x1020 <main+0x24c>
  2364. size_t n = 0;
  2365. if (isnan(number)) return print("nan");
  2366. if (isinf(number)) return print("inf");
  2367. if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
  2368. if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
  2369. 1040: 2f ef ldi r18, 0xFF ; 255
  2370. 1042: 3f ef ldi r19, 0xFF ; 255
  2371. 1044: 4f e7 ldi r20, 0x7F ; 127
  2372. 1046: 5f ec ldi r21, 0xCF ; 207
  2373. 1048: c7 01 movw r24, r14
  2374. 104a: b6 01 movw r22, r12
  2375. 104c: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2>
  2376. 1050: 87 fd sbrc r24, 7
  2377. 1052: f3 cf rjmp .-26 ; 0x103a <main+0x266>
  2378. // Handle negative numbers
  2379. if (number < 0.0)
  2380. 1054: 20 e0 ldi r18, 0x00 ; 0
  2381. 1056: 30 e0 ldi r19, 0x00 ; 0
  2382. 1058: a9 01 movw r20, r18
  2383. 105a: c7 01 movw r24, r14
  2384. 105c: b6 01 movw r22, r12
  2385. 105e: 0e 94 08 09 call 0x1210 ; 0x1210 <__cmpsf2>
  2386. 1062: 87 ff sbrs r24, 7
  2387. 1064: 09 c0 rjmp .+18 ; 0x1078 <main+0x2a4>
  2388. extendedInstruction();
  2389. execute(rate);
  2390. }
  2391. size_t Nokia_5110::write(uint8_t character) {
  2392. _print(character);
  2393. 1066: 6d e2 ldi r22, 0x2D ; 45
  2394. 1068: 80 ef ldi r24, 0xF0 ; 240
  2395. 106a: 91 e0 ldi r25, 0x01 ; 1
  2396. 106c: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6>
  2397. {
  2398. n += print('-');
  2399. number = -number;
  2400. 1070: f7 fa bst r15, 7
  2401. 1072: f0 94 com r15
  2402. 1074: f7 f8 bld r15, 7
  2403. 1076: f0 94 com r15
  2404. // Round correctly so that print(1.999, 2) prints as "2.00"
  2405. double rounding = 0.5;
  2406. for (uint8_t i=0; i<digits; ++i)
  2407. rounding /= 10.0;
  2408. number += rounding;
  2409. 1078: 2a e0 ldi r18, 0x0A ; 10
  2410. 107a: 37 ed ldi r19, 0xD7 ; 215
  2411. 107c: 43 ea ldi r20, 0xA3 ; 163
  2412. 107e: 5b e3 ldi r21, 0x3B ; 59
  2413. 1080: c7 01 movw r24, r14
  2414. 1082: b6 01 movw r22, r12
  2415. 1084: 0e 94 9c 08 call 0x1138 ; 0x1138 <__addsf3>
  2416. 1088: 4b 01 movw r8, r22
  2417. 108a: 5c 01 movw r10, r24
  2418. // Extract the integer part of the number and print it
  2419. unsigned long int_part = (unsigned long)number;
  2420. 108c: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi>
  2421. 1090: 6b 01 movw r12, r22
  2422. 1092: 7c 01 movw r14, r24
  2423. double remainder = number - (double)int_part;
  2424. 1094: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf>
  2425. 1098: 9b 01 movw r18, r22
  2426. 109a: ac 01 movw r20, r24
  2427. 109c: c5 01 movw r24, r10
  2428. 109e: b4 01 movw r22, r8
  2429. 10a0: 0e 94 9b 08 call 0x1136 ; 0x1136 <__subsf3>
  2430. 10a4: 4b 01 movw r8, r22
  2431. 10a6: 5c 01 movw r10, r24
  2432. }
  2433. size_t Print::print(unsigned long n, int base)
  2434. {
  2435. if (base == 0) return write(n);
  2436. else return printNumber(n, base);
  2437. 10a8: 4a e0 ldi r20, 0x0A ; 10
  2438. 10aa: c7 01 movw r24, r14
  2439. 10ac: b6 01 movw r22, r12
  2440. 10ae: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20>
  2441. 10b2: 6e e2 ldi r22, 0x2E ; 46
  2442. 10b4: 80 ef ldi r24, 0xF0 ; 240
  2443. 10b6: 91 e0 ldi r25, 0x01 ; 1
  2444. 10b8: 0e 94 18 05 call 0xa30 ; 0xa30 <_ZN10Nokia_51106_printEh.constprop.6>
  2445. }
  2446. // Extract digits from the remainder one at a time
  2447. while (digits-- > 0)
  2448. {
  2449. remainder *= 10.0;
  2450. 10bc: 20 e0 ldi r18, 0x00 ; 0
  2451. 10be: 30 e0 ldi r19, 0x00 ; 0
  2452. 10c0: 40 e2 ldi r20, 0x20 ; 32
  2453. 10c2: 51 e4 ldi r21, 0x41 ; 65
  2454. 10c4: c5 01 movw r24, r10
  2455. 10c6: b4 01 movw r22, r8
  2456. 10c8: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3>
  2457. 10cc: 4b 01 movw r8, r22
  2458. 10ce: 5c 01 movw r10, r24
  2459. unsigned int toPrint = (unsigned int)(remainder);
  2460. 10d0: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi>
  2461. }
  2462. size_t Print::print(unsigned long n, int base)
  2463. {
  2464. if (base == 0) return write(n);
  2465. else return printNumber(n, base);
  2466. 10d4: 6b 01 movw r12, r22
  2467. 10d6: e1 2c mov r14, r1
  2468. 10d8: f1 2c mov r15, r1
  2469. 10da: 4a e0 ldi r20, 0x0A ; 10
  2470. 10dc: c7 01 movw r24, r14
  2471. 10de: b6 01 movw r22, r12
  2472. 10e0: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20>
  2473. while (digits-- > 0)
  2474. {
  2475. remainder *= 10.0;
  2476. unsigned int toPrint = (unsigned int)(remainder);
  2477. n += print(toPrint);
  2478. remainder -= toPrint;
  2479. 10e4: c7 01 movw r24, r14
  2480. 10e6: b6 01 movw r22, r12
  2481. 10e8: 0e 94 3c 09 call 0x1278 ; 0x1278 <__floatunsisf>
  2482. 10ec: 9b 01 movw r18, r22
  2483. 10ee: ac 01 movw r20, r24
  2484. 10f0: c5 01 movw r24, r10
  2485. 10f2: b4 01 movw r22, r8
  2486. 10f4: 0e 94 9b 08 call 0x1136 ; 0x1136 <__subsf3>
  2487. }
  2488. size_t Print::print(unsigned long n, int base)
  2489. {
  2490. if (base == 0) return write(n);
  2491. else return printNumber(n, base);
  2492. 10f8: 20 e0 ldi r18, 0x00 ; 0
  2493. 10fa: 30 e0 ldi r19, 0x00 ; 0
  2494. 10fc: 40 e2 ldi r20, 0x20 ; 32
  2495. 10fe: 51 e4 ldi r21, 0x41 ; 65
  2496. 1100: 0e 94 f3 09 call 0x13e6 ; 0x13e6 <__mulsf3>
  2497. 1104: 0e 94 0d 09 call 0x121a ; 0x121a <__fixunssfsi>
  2498. 1108: 80 e0 ldi r24, 0x00 ; 0
  2499. 110a: 90 e0 ldi r25, 0x00 ; 0
  2500. 110c: 4a e0 ldi r20, 0x0A ; 10
  2501. 110e: 0e 94 5c 04 call 0x8b8 ; 0x8b8 <_ZN5Print11printNumberEmh.constprop.20>
  2502. //Serial.println(phVal_u16);
  2503. delay(1000);
  2504. 1112: 68 ee ldi r22, 0xE8 ; 232
  2505. 1114: 73 e0 ldi r23, 0x03 ; 3
  2506. 1116: 80 e0 ldi r24, 0x00 ; 0
  2507. 1118: 90 e0 ldi r25, 0x00 ; 0
  2508. 111a: 0e 94 00 03 call 0x600 ; 0x600 <delay>
  2509. setup();
  2510. for (;;) {
  2511. loop();
  2512. if (serialEventRun) serialEventRun();
  2513. 111e: 0e 94 3c 04 call 0x878 ; 0x878 <_Z14serialEventRunv>
  2514. 1122: ef ce rjmp .-546 ; 0xf02 <main+0x12e>
  2515. 00001124 <memcpy_P>:
  2516. 1124: fb 01 movw r30, r22
  2517. 1126: dc 01 movw r26, r24
  2518. 1128: 02 c0 rjmp .+4 ; 0x112e <memcpy_P+0xa>
  2519. 112a: 05 90 lpm r0, Z+
  2520. 112c: 0d 92 st X+, r0
  2521. 112e: 41 50 subi r20, 0x01 ; 1
  2522. 1130: 50 40 sbci r21, 0x00 ; 0
  2523. 1132: d8 f7 brcc .-10 ; 0x112a <memcpy_P+0x6>
  2524. 1134: 08 95 ret
  2525. 00001136 <__subsf3>:
  2526. 1136: 50 58 subi r21, 0x80 ; 128
  2527. 00001138 <__addsf3>:
  2528. 1138: bb 27 eor r27, r27
  2529. 113a: aa 27 eor r26, r26
  2530. 113c: 0e 94 b3 08 call 0x1166 ; 0x1166 <__addsf3x>
  2531. 1140: 0c 94 b4 09 jmp 0x1368 ; 0x1368 <__fp_round>
  2532. 1144: 0e 94 a6 09 call 0x134c ; 0x134c <__fp_pscA>
  2533. 1148: 38 f0 brcs .+14 ; 0x1158 <__addsf3+0x20>
  2534. 114a: 0e 94 ad 09 call 0x135a ; 0x135a <__fp_pscB>
  2535. 114e: 20 f0 brcs .+8 ; 0x1158 <__addsf3+0x20>
  2536. 1150: 39 f4 brne .+14 ; 0x1160 <__addsf3+0x28>
  2537. 1152: 9f 3f cpi r25, 0xFF ; 255
  2538. 1154: 19 f4 brne .+6 ; 0x115c <__addsf3+0x24>
  2539. 1156: 26 f4 brtc .+8 ; 0x1160 <__addsf3+0x28>
  2540. 1158: 0c 94 a3 09 jmp 0x1346 ; 0x1346 <__fp_nan>
  2541. 115c: 0e f4 brtc .+2 ; 0x1160 <__addsf3+0x28>
  2542. 115e: e0 95 com r30
  2543. 1160: e7 fb bst r30, 7
  2544. 1162: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf>
  2545. 00001166 <__addsf3x>:
  2546. 1166: e9 2f mov r30, r25
  2547. 1168: 0e 94 c5 09 call 0x138a ; 0x138a <__fp_split3>
  2548. 116c: 58 f3 brcs .-42 ; 0x1144 <__addsf3+0xc>
  2549. 116e: ba 17 cp r27, r26
  2550. 1170: 62 07 cpc r22, r18
  2551. 1172: 73 07 cpc r23, r19
  2552. 1174: 84 07 cpc r24, r20
  2553. 1176: 95 07 cpc r25, r21
  2554. 1178: 20 f0 brcs .+8 ; 0x1182 <__addsf3x+0x1c>
  2555. 117a: 79 f4 brne .+30 ; 0x119a <__addsf3x+0x34>
  2556. 117c: a6 f5 brtc .+104 ; 0x11e6 <__addsf3x+0x80>
  2557. 117e: 0c 94 e7 09 jmp 0x13ce ; 0x13ce <__fp_zero>
  2558. 1182: 0e f4 brtc .+2 ; 0x1186 <__addsf3x+0x20>
  2559. 1184: e0 95 com r30
  2560. 1186: 0b 2e mov r0, r27
  2561. 1188: ba 2f mov r27, r26
  2562. 118a: a0 2d mov r26, r0
  2563. 118c: 0b 01 movw r0, r22
  2564. 118e: b9 01 movw r22, r18
  2565. 1190: 90 01 movw r18, r0
  2566. 1192: 0c 01 movw r0, r24
  2567. 1194: ca 01 movw r24, r20
  2568. 1196: a0 01 movw r20, r0
  2569. 1198: 11 24 eor r1, r1
  2570. 119a: ff 27 eor r31, r31
  2571. 119c: 59 1b sub r21, r25
  2572. 119e: 99 f0 breq .+38 ; 0x11c6 <__addsf3x+0x60>
  2573. 11a0: 59 3f cpi r21, 0xF9 ; 249
  2574. 11a2: 50 f4 brcc .+20 ; 0x11b8 <__addsf3x+0x52>
  2575. 11a4: 50 3e cpi r21, 0xE0 ; 224
  2576. 11a6: 68 f1 brcs .+90 ; 0x1202 <__addsf3x+0x9c>
  2577. 11a8: 1a 16 cp r1, r26
  2578. 11aa: f0 40 sbci r31, 0x00 ; 0
  2579. 11ac: a2 2f mov r26, r18
  2580. 11ae: 23 2f mov r18, r19
  2581. 11b0: 34 2f mov r19, r20
  2582. 11b2: 44 27 eor r20, r20
  2583. 11b4: 58 5f subi r21, 0xF8 ; 248
  2584. 11b6: f3 cf rjmp .-26 ; 0x119e <__addsf3x+0x38>
  2585. 11b8: 46 95 lsr r20
  2586. 11ba: 37 95 ror r19
  2587. 11bc: 27 95 ror r18
  2588. 11be: a7 95 ror r26
  2589. 11c0: f0 40 sbci r31, 0x00 ; 0
  2590. 11c2: 53 95 inc r21
  2591. 11c4: c9 f7 brne .-14 ; 0x11b8 <__addsf3x+0x52>
  2592. 11c6: 7e f4 brtc .+30 ; 0x11e6 <__addsf3x+0x80>
  2593. 11c8: 1f 16 cp r1, r31
  2594. 11ca: ba 0b sbc r27, r26
  2595. 11cc: 62 0b sbc r22, r18
  2596. 11ce: 73 0b sbc r23, r19
  2597. 11d0: 84 0b sbc r24, r20
  2598. 11d2: ba f0 brmi .+46 ; 0x1202 <__addsf3x+0x9c>
  2599. 11d4: 91 50 subi r25, 0x01 ; 1
  2600. 11d6: a1 f0 breq .+40 ; 0x1200 <__addsf3x+0x9a>
  2601. 11d8: ff 0f add r31, r31
  2602. 11da: bb 1f adc r27, r27
  2603. 11dc: 66 1f adc r22, r22
  2604. 11de: 77 1f adc r23, r23
  2605. 11e0: 88 1f adc r24, r24
  2606. 11e2: c2 f7 brpl .-16 ; 0x11d4 <__addsf3x+0x6e>
  2607. 11e4: 0e c0 rjmp .+28 ; 0x1202 <__addsf3x+0x9c>
  2608. 11e6: ba 0f add r27, r26
  2609. 11e8: 62 1f adc r22, r18
  2610. 11ea: 73 1f adc r23, r19
  2611. 11ec: 84 1f adc r24, r20
  2612. 11ee: 48 f4 brcc .+18 ; 0x1202 <__addsf3x+0x9c>
  2613. 11f0: 87 95 ror r24
  2614. 11f2: 77 95 ror r23
  2615. 11f4: 67 95 ror r22
  2616. 11f6: b7 95 ror r27
  2617. 11f8: f7 95 ror r31
  2618. 11fa: 9e 3f cpi r25, 0xFE ; 254
  2619. 11fc: 08 f0 brcs .+2 ; 0x1200 <__addsf3x+0x9a>
  2620. 11fe: b0 cf rjmp .-160 ; 0x1160 <__addsf3+0x28>
  2621. 1200: 93 95 inc r25
  2622. 1202: 88 0f add r24, r24
  2623. 1204: 08 f0 brcs .+2 ; 0x1208 <__addsf3x+0xa2>
  2624. 1206: 99 27 eor r25, r25
  2625. 1208: ee 0f add r30, r30
  2626. 120a: 97 95 ror r25
  2627. 120c: 87 95 ror r24
  2628. 120e: 08 95 ret
  2629. 00001210 <__cmpsf2>:
  2630. 1210: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp>
  2631. 1214: 08 f4 brcc .+2 ; 0x1218 <__cmpsf2+0x8>
  2632. 1216: 81 e0 ldi r24, 0x01 ; 1
  2633. 1218: 08 95 ret
  2634. 0000121a <__fixunssfsi>:
  2635. 121a: 0e 94 cd 09 call 0x139a ; 0x139a <__fp_splitA>
  2636. 121e: 88 f0 brcs .+34 ; 0x1242 <__fixunssfsi+0x28>
  2637. 1220: 9f 57 subi r25, 0x7F ; 127
  2638. 1222: 98 f0 brcs .+38 ; 0x124a <__fixunssfsi+0x30>
  2639. 1224: b9 2f mov r27, r25
  2640. 1226: 99 27 eor r25, r25
  2641. 1228: b7 51 subi r27, 0x17 ; 23
  2642. 122a: b0 f0 brcs .+44 ; 0x1258 <__fixunssfsi+0x3e>
  2643. 122c: e1 f0 breq .+56 ; 0x1266 <__fixunssfsi+0x4c>
  2644. 122e: 66 0f add r22, r22
  2645. 1230: 77 1f adc r23, r23
  2646. 1232: 88 1f adc r24, r24
  2647. 1234: 99 1f adc r25, r25
  2648. 1236: 1a f0 brmi .+6 ; 0x123e <__fixunssfsi+0x24>
  2649. 1238: ba 95 dec r27
  2650. 123a: c9 f7 brne .-14 ; 0x122e <__fixunssfsi+0x14>
  2651. 123c: 14 c0 rjmp .+40 ; 0x1266 <__fixunssfsi+0x4c>
  2652. 123e: b1 30 cpi r27, 0x01 ; 1
  2653. 1240: 91 f0 breq .+36 ; 0x1266 <__fixunssfsi+0x4c>
  2654. 1242: 0e 94 e7 09 call 0x13ce ; 0x13ce <__fp_zero>
  2655. 1246: b1 e0 ldi r27, 0x01 ; 1
  2656. 1248: 08 95 ret
  2657. 124a: 0c 94 e7 09 jmp 0x13ce ; 0x13ce <__fp_zero>
  2658. 124e: 67 2f mov r22, r23
  2659. 1250: 78 2f mov r23, r24
  2660. 1252: 88 27 eor r24, r24
  2661. 1254: b8 5f subi r27, 0xF8 ; 248
  2662. 1256: 39 f0 breq .+14 ; 0x1266 <__fixunssfsi+0x4c>
  2663. 1258: b9 3f cpi r27, 0xF9 ; 249
  2664. 125a: cc f3 brlt .-14 ; 0x124e <__fixunssfsi+0x34>
  2665. 125c: 86 95 lsr r24
  2666. 125e: 77 95 ror r23
  2667. 1260: 67 95 ror r22
  2668. 1262: b3 95 inc r27
  2669. 1264: d9 f7 brne .-10 ; 0x125c <__fixunssfsi+0x42>
  2670. 1266: 3e f4 brtc .+14 ; 0x1276 <__fixunssfsi+0x5c>
  2671. 1268: 90 95 com r25
  2672. 126a: 80 95 com r24
  2673. 126c: 70 95 com r23
  2674. 126e: 61 95 neg r22
  2675. 1270: 7f 4f sbci r23, 0xFF ; 255
  2676. 1272: 8f 4f sbci r24, 0xFF ; 255
  2677. 1274: 9f 4f sbci r25, 0xFF ; 255
  2678. 1276: 08 95 ret
  2679. 00001278 <__floatunsisf>:
  2680. 1278: e8 94 clt
  2681. 127a: 09 c0 rjmp .+18 ; 0x128e <__floatsisf+0x12>
  2682. 0000127c <__floatsisf>:
  2683. 127c: 97 fb bst r25, 7
  2684. 127e: 3e f4 brtc .+14 ; 0x128e <__floatsisf+0x12>
  2685. 1280: 90 95 com r25
  2686. 1282: 80 95 com r24
  2687. 1284: 70 95 com r23
  2688. 1286: 61 95 neg r22
  2689. 1288: 7f 4f sbci r23, 0xFF ; 255
  2690. 128a: 8f 4f sbci r24, 0xFF ; 255
  2691. 128c: 9f 4f sbci r25, 0xFF ; 255
  2692. 128e: 99 23 and r25, r25
  2693. 1290: a9 f0 breq .+42 ; 0x12bc <__floatsisf+0x40>
  2694. 1292: f9 2f mov r31, r25
  2695. 1294: 96 e9 ldi r25, 0x96 ; 150
  2696. 1296: bb 27 eor r27, r27
  2697. 1298: 93 95 inc r25
  2698. 129a: f6 95 lsr r31
  2699. 129c: 87 95 ror r24
  2700. 129e: 77 95 ror r23
  2701. 12a0: 67 95 ror r22
  2702. 12a2: b7 95 ror r27
  2703. 12a4: f1 11 cpse r31, r1
  2704. 12a6: f8 cf rjmp .-16 ; 0x1298 <__floatsisf+0x1c>
  2705. 12a8: fa f4 brpl .+62 ; 0x12e8 <__floatsisf+0x6c>
  2706. 12aa: bb 0f add r27, r27
  2707. 12ac: 11 f4 brne .+4 ; 0x12b2 <__floatsisf+0x36>
  2708. 12ae: 60 ff sbrs r22, 0
  2709. 12b0: 1b c0 rjmp .+54 ; 0x12e8 <__floatsisf+0x6c>
  2710. 12b2: 6f 5f subi r22, 0xFF ; 255
  2711. 12b4: 7f 4f sbci r23, 0xFF ; 255
  2712. 12b6: 8f 4f sbci r24, 0xFF ; 255
  2713. 12b8: 9f 4f sbci r25, 0xFF ; 255
  2714. 12ba: 16 c0 rjmp .+44 ; 0x12e8 <__floatsisf+0x6c>
  2715. 12bc: 88 23 and r24, r24
  2716. 12be: 11 f0 breq .+4 ; 0x12c4 <__floatsisf+0x48>
  2717. 12c0: 96 e9 ldi r25, 0x96 ; 150
  2718. 12c2: 11 c0 rjmp .+34 ; 0x12e6 <__floatsisf+0x6a>
  2719. 12c4: 77 23 and r23, r23
  2720. 12c6: 21 f0 breq .+8 ; 0x12d0 <__floatsisf+0x54>
  2721. 12c8: 9e e8 ldi r25, 0x8E ; 142
  2722. 12ca: 87 2f mov r24, r23
  2723. 12cc: 76 2f mov r23, r22
  2724. 12ce: 05 c0 rjmp .+10 ; 0x12da <__floatsisf+0x5e>
  2725. 12d0: 66 23 and r22, r22
  2726. 12d2: 71 f0 breq .+28 ; 0x12f0 <__floatsisf+0x74>
  2727. 12d4: 96 e8 ldi r25, 0x86 ; 134
  2728. 12d6: 86 2f mov r24, r22
  2729. 12d8: 70 e0 ldi r23, 0x00 ; 0
  2730. 12da: 60 e0 ldi r22, 0x00 ; 0
  2731. 12dc: 2a f0 brmi .+10 ; 0x12e8 <__floatsisf+0x6c>
  2732. 12de: 9a 95 dec r25
  2733. 12e0: 66 0f add r22, r22
  2734. 12e2: 77 1f adc r23, r23
  2735. 12e4: 88 1f adc r24, r24
  2736. 12e6: da f7 brpl .-10 ; 0x12de <__floatsisf+0x62>
  2737. 12e8: 88 0f add r24, r24
  2738. 12ea: 96 95 lsr r25
  2739. 12ec: 87 95 ror r24
  2740. 12ee: 97 f9 bld r25, 7
  2741. 12f0: 08 95 ret
  2742. 000012f2 <__fp_cmp>:
  2743. 12f2: 99 0f add r25, r25
  2744. 12f4: 00 08 sbc r0, r0
  2745. 12f6: 55 0f add r21, r21
  2746. 12f8: aa 0b sbc r26, r26
  2747. 12fa: e0 e8 ldi r30, 0x80 ; 128
  2748. 12fc: fe ef ldi r31, 0xFE ; 254
  2749. 12fe: 16 16 cp r1, r22
  2750. 1300: 17 06 cpc r1, r23
  2751. 1302: e8 07 cpc r30, r24
  2752. 1304: f9 07 cpc r31, r25
  2753. 1306: c0 f0 brcs .+48 ; 0x1338 <__fp_cmp+0x46>
  2754. 1308: 12 16 cp r1, r18
  2755. 130a: 13 06 cpc r1, r19
  2756. 130c: e4 07 cpc r30, r20
  2757. 130e: f5 07 cpc r31, r21
  2758. 1310: 98 f0 brcs .+38 ; 0x1338 <__fp_cmp+0x46>
  2759. 1312: 62 1b sub r22, r18
  2760. 1314: 73 0b sbc r23, r19
  2761. 1316: 84 0b sbc r24, r20
  2762. 1318: 95 0b sbc r25, r21
  2763. 131a: 39 f4 brne .+14 ; 0x132a <__fp_cmp+0x38>
  2764. 131c: 0a 26 eor r0, r26
  2765. 131e: 61 f0 breq .+24 ; 0x1338 <__fp_cmp+0x46>
  2766. 1320: 23 2b or r18, r19
  2767. 1322: 24 2b or r18, r20
  2768. 1324: 25 2b or r18, r21
  2769. 1326: 21 f4 brne .+8 ; 0x1330 <__fp_cmp+0x3e>
  2770. 1328: 08 95 ret
  2771. 132a: 0a 26 eor r0, r26
  2772. 132c: 09 f4 brne .+2 ; 0x1330 <__fp_cmp+0x3e>
  2773. 132e: a1 40 sbci r26, 0x01 ; 1
  2774. 1330: a6 95 lsr r26
  2775. 1332: 8f ef ldi r24, 0xFF ; 255
  2776. 1334: 81 1d adc r24, r1
  2777. 1336: 81 1d adc r24, r1
  2778. 1338: 08 95 ret
  2779. 0000133a <__fp_inf>:
  2780. 133a: 97 f9 bld r25, 7
  2781. 133c: 9f 67 ori r25, 0x7F ; 127
  2782. 133e: 80 e8 ldi r24, 0x80 ; 128
  2783. 1340: 70 e0 ldi r23, 0x00 ; 0
  2784. 1342: 60 e0 ldi r22, 0x00 ; 0
  2785. 1344: 08 95 ret
  2786. 00001346 <__fp_nan>:
  2787. 1346: 9f ef ldi r25, 0xFF ; 255
  2788. 1348: 80 ec ldi r24, 0xC0 ; 192
  2789. 134a: 08 95 ret
  2790. 0000134c <__fp_pscA>:
  2791. 134c: 00 24 eor r0, r0
  2792. 134e: 0a 94 dec r0
  2793. 1350: 16 16 cp r1, r22
  2794. 1352: 17 06 cpc r1, r23
  2795. 1354: 18 06 cpc r1, r24
  2796. 1356: 09 06 cpc r0, r25
  2797. 1358: 08 95 ret
  2798. 0000135a <__fp_pscB>:
  2799. 135a: 00 24 eor r0, r0
  2800. 135c: 0a 94 dec r0
  2801. 135e: 12 16 cp r1, r18
  2802. 1360: 13 06 cpc r1, r19
  2803. 1362: 14 06 cpc r1, r20
  2804. 1364: 05 06 cpc r0, r21
  2805. 1366: 08 95 ret
  2806. 00001368 <__fp_round>:
  2807. 1368: 09 2e mov r0, r25
  2808. 136a: 03 94 inc r0
  2809. 136c: 00 0c add r0, r0
  2810. 136e: 11 f4 brne .+4 ; 0x1374 <__fp_round+0xc>
  2811. 1370: 88 23 and r24, r24
  2812. 1372: 52 f0 brmi .+20 ; 0x1388 <__fp_round+0x20>
  2813. 1374: bb 0f add r27, r27
  2814. 1376: 40 f4 brcc .+16 ; 0x1388 <__fp_round+0x20>
  2815. 1378: bf 2b or r27, r31
  2816. 137a: 11 f4 brne .+4 ; 0x1380 <__fp_round+0x18>
  2817. 137c: 60 ff sbrs r22, 0
  2818. 137e: 04 c0 rjmp .+8 ; 0x1388 <__fp_round+0x20>
  2819. 1380: 6f 5f subi r22, 0xFF ; 255
  2820. 1382: 7f 4f sbci r23, 0xFF ; 255
  2821. 1384: 8f 4f sbci r24, 0xFF ; 255
  2822. 1386: 9f 4f sbci r25, 0xFF ; 255
  2823. 1388: 08 95 ret
  2824. 0000138a <__fp_split3>:
  2825. 138a: 57 fd sbrc r21, 7
  2826. 138c: 90 58 subi r25, 0x80 ; 128
  2827. 138e: 44 0f add r20, r20
  2828. 1390: 55 1f adc r21, r21
  2829. 1392: 59 f0 breq .+22 ; 0x13aa <__fp_splitA+0x10>
  2830. 1394: 5f 3f cpi r21, 0xFF ; 255
  2831. 1396: 71 f0 breq .+28 ; 0x13b4 <__fp_splitA+0x1a>
  2832. 1398: 47 95 ror r20
  2833. 0000139a <__fp_splitA>:
  2834. 139a: 88 0f add r24, r24
  2835. 139c: 97 fb bst r25, 7
  2836. 139e: 99 1f adc r25, r25
  2837. 13a0: 61 f0 breq .+24 ; 0x13ba <__fp_splitA+0x20>
  2838. 13a2: 9f 3f cpi r25, 0xFF ; 255
  2839. 13a4: 79 f0 breq .+30 ; 0x13c4 <__fp_splitA+0x2a>
  2840. 13a6: 87 95 ror r24
  2841. 13a8: 08 95 ret
  2842. 13aa: 12 16 cp r1, r18
  2843. 13ac: 13 06 cpc r1, r19
  2844. 13ae: 14 06 cpc r1, r20
  2845. 13b0: 55 1f adc r21, r21
  2846. 13b2: f2 cf rjmp .-28 ; 0x1398 <__fp_split3+0xe>
  2847. 13b4: 46 95 lsr r20
  2848. 13b6: f1 df rcall .-30 ; 0x139a <__fp_splitA>
  2849. 13b8: 08 c0 rjmp .+16 ; 0x13ca <__fp_splitA+0x30>
  2850. 13ba: 16 16 cp r1, r22
  2851. 13bc: 17 06 cpc r1, r23
  2852. 13be: 18 06 cpc r1, r24
  2853. 13c0: 99 1f adc r25, r25
  2854. 13c2: f1 cf rjmp .-30 ; 0x13a6 <__fp_splitA+0xc>
  2855. 13c4: 86 95 lsr r24
  2856. 13c6: 71 05 cpc r23, r1
  2857. 13c8: 61 05 cpc r22, r1
  2858. 13ca: 08 94 sec
  2859. 13cc: 08 95 ret
  2860. 000013ce <__fp_zero>:
  2861. 13ce: e8 94 clt
  2862. 000013d0 <__fp_szero>:
  2863. 13d0: bb 27 eor r27, r27
  2864. 13d2: 66 27 eor r22, r22
  2865. 13d4: 77 27 eor r23, r23
  2866. 13d6: cb 01 movw r24, r22
  2867. 13d8: 97 f9 bld r25, 7
  2868. 13da: 08 95 ret
  2869. 000013dc <__gesf2>:
  2870. 13dc: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp>
  2871. 13e0: 08 f4 brcc .+2 ; 0x13e4 <__gesf2+0x8>
  2872. 13e2: 8f ef ldi r24, 0xFF ; 255
  2873. 13e4: 08 95 ret
  2874. 000013e6 <__mulsf3>:
  2875. 13e6: 0e 94 06 0a call 0x140c ; 0x140c <__mulsf3x>
  2876. 13ea: 0c 94 b4 09 jmp 0x1368 ; 0x1368 <__fp_round>
  2877. 13ee: 0e 94 a6 09 call 0x134c ; 0x134c <__fp_pscA>
  2878. 13f2: 38 f0 brcs .+14 ; 0x1402 <__mulsf3+0x1c>
  2879. 13f4: 0e 94 ad 09 call 0x135a ; 0x135a <__fp_pscB>
  2880. 13f8: 20 f0 brcs .+8 ; 0x1402 <__mulsf3+0x1c>
  2881. 13fa: 95 23 and r25, r21
  2882. 13fc: 11 f0 breq .+4 ; 0x1402 <__mulsf3+0x1c>
  2883. 13fe: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf>
  2884. 1402: 0c 94 a3 09 jmp 0x1346 ; 0x1346 <__fp_nan>
  2885. 1406: 11 24 eor r1, r1
  2886. 1408: 0c 94 e8 09 jmp 0x13d0 ; 0x13d0 <__fp_szero>
  2887. 0000140c <__mulsf3x>:
  2888. 140c: 0e 94 c5 09 call 0x138a ; 0x138a <__fp_split3>
  2889. 1410: 70 f3 brcs .-36 ; 0x13ee <__mulsf3+0x8>
  2890. 00001412 <__mulsf3_pse>:
  2891. 1412: 95 9f mul r25, r21
  2892. 1414: c1 f3 breq .-16 ; 0x1406 <__mulsf3+0x20>
  2893. 1416: 95 0f add r25, r21
  2894. 1418: 50 e0 ldi r21, 0x00 ; 0
  2895. 141a: 55 1f adc r21, r21
  2896. 141c: 62 9f mul r22, r18
  2897. 141e: f0 01 movw r30, r0
  2898. 1420: 72 9f mul r23, r18
  2899. 1422: bb 27 eor r27, r27
  2900. 1424: f0 0d add r31, r0
  2901. 1426: b1 1d adc r27, r1
  2902. 1428: 63 9f mul r22, r19
  2903. 142a: aa 27 eor r26, r26
  2904. 142c: f0 0d add r31, r0
  2905. 142e: b1 1d adc r27, r1
  2906. 1430: aa 1f adc r26, r26
  2907. 1432: 64 9f mul r22, r20
  2908. 1434: 66 27 eor r22, r22
  2909. 1436: b0 0d add r27, r0
  2910. 1438: a1 1d adc r26, r1
  2911. 143a: 66 1f adc r22, r22
  2912. 143c: 82 9f mul r24, r18
  2913. 143e: 22 27 eor r18, r18
  2914. 1440: b0 0d add r27, r0
  2915. 1442: a1 1d adc r26, r1
  2916. 1444: 62 1f adc r22, r18
  2917. 1446: 73 9f mul r23, r19
  2918. 1448: b0 0d add r27, r0
  2919. 144a: a1 1d adc r26, r1
  2920. 144c: 62 1f adc r22, r18
  2921. 144e: 83 9f mul r24, r19
  2922. 1450: a0 0d add r26, r0
  2923. 1452: 61 1d adc r22, r1
  2924. 1454: 22 1f adc r18, r18
  2925. 1456: 74 9f mul r23, r20
  2926. 1458: 33 27 eor r19, r19
  2927. 145a: a0 0d add r26, r0
  2928. 145c: 61 1d adc r22, r1
  2929. 145e: 23 1f adc r18, r19
  2930. 1460: 84 9f mul r24, r20
  2931. 1462: 60 0d add r22, r0
  2932. 1464: 21 1d adc r18, r1
  2933. 1466: 82 2f mov r24, r18
  2934. 1468: 76 2f mov r23, r22
  2935. 146a: 6a 2f mov r22, r26
  2936. 146c: 11 24 eor r1, r1
  2937. 146e: 9f 57 subi r25, 0x7F ; 127
  2938. 1470: 50 40 sbci r21, 0x00 ; 0
  2939. 1472: 9a f0 brmi .+38 ; 0x149a <__mulsf3_pse+0x88>
  2940. 1474: f1 f0 breq .+60 ; 0x14b2 <__mulsf3_pse+0xa0>
  2941. 1476: 88 23 and r24, r24
  2942. 1478: 4a f0 brmi .+18 ; 0x148c <__mulsf3_pse+0x7a>
  2943. 147a: ee 0f add r30, r30
  2944. 147c: ff 1f adc r31, r31
  2945. 147e: bb 1f adc r27, r27
  2946. 1480: 66 1f adc r22, r22
  2947. 1482: 77 1f adc r23, r23
  2948. 1484: 88 1f adc r24, r24
  2949. 1486: 91 50 subi r25, 0x01 ; 1
  2950. 1488: 50 40 sbci r21, 0x00 ; 0
  2951. 148a: a9 f7 brne .-22 ; 0x1476 <__mulsf3_pse+0x64>
  2952. 148c: 9e 3f cpi r25, 0xFE ; 254
  2953. 148e: 51 05 cpc r21, r1
  2954. 1490: 80 f0 brcs .+32 ; 0x14b2 <__mulsf3_pse+0xa0>
  2955. 1492: 0c 94 9d 09 jmp 0x133a ; 0x133a <__fp_inf>
  2956. 1496: 0c 94 e8 09 jmp 0x13d0 ; 0x13d0 <__fp_szero>
  2957. 149a: 5f 3f cpi r21, 0xFF ; 255
  2958. 149c: e4 f3 brlt .-8 ; 0x1496 <__mulsf3_pse+0x84>
  2959. 149e: 98 3e cpi r25, 0xE8 ; 232
  2960. 14a0: d4 f3 brlt .-12 ; 0x1496 <__mulsf3_pse+0x84>
  2961. 14a2: 86 95 lsr r24
  2962. 14a4: 77 95 ror r23
  2963. 14a6: 67 95 ror r22
  2964. 14a8: b7 95 ror r27
  2965. 14aa: f7 95 ror r31
  2966. 14ac: e7 95 ror r30
  2967. 14ae: 9f 5f subi r25, 0xFF ; 255
  2968. 14b0: c1 f7 brne .-16 ; 0x14a2 <__mulsf3_pse+0x90>
  2969. 14b2: fe 2b or r31, r30
  2970. 14b4: 88 0f add r24, r24
  2971. 14b6: 91 1d adc r25, r1
  2972. 14b8: 96 95 lsr r25
  2973. 14ba: 87 95 ror r24
  2974. 14bc: 97 f9 bld r25, 7
  2975. 14be: 08 95 ret
  2976. 000014c0 <__unordsf2>:
  2977. 14c0: 0e 94 79 09 call 0x12f2 ; 0x12f2 <__fp_cmp>
  2978. 14c4: 88 0b sbc r24, r24
  2979. 14c6: 99 0b sbc r25, r25
  2980. 14c8: 08 95 ret
  2981. 000014ca <__udivmodsi4>:
  2982. 14ca: a1 e2 ldi r26, 0x21 ; 33
  2983. 14cc: 1a 2e mov r1, r26
  2984. 14ce: aa 1b sub r26, r26
  2985. 14d0: bb 1b sub r27, r27
  2986. 14d2: fd 01 movw r30, r26
  2987. 14d4: 0d c0 rjmp .+26 ; 0x14f0 <__udivmodsi4_ep>
  2988. 000014d6 <__udivmodsi4_loop>:
  2989. 14d6: aa 1f adc r26, r26
  2990. 14d8: bb 1f adc r27, r27
  2991. 14da: ee 1f adc r30, r30
  2992. 14dc: ff 1f adc r31, r31
  2993. 14de: a2 17 cp r26, r18
  2994. 14e0: b3 07 cpc r27, r19
  2995. 14e2: e4 07 cpc r30, r20
  2996. 14e4: f5 07 cpc r31, r21
  2997. 14e6: 20 f0 brcs .+8 ; 0x14f0 <__udivmodsi4_ep>
  2998. 14e8: a2 1b sub r26, r18
  2999. 14ea: b3 0b sbc r27, r19
  3000. 14ec: e4 0b sbc r30, r20
  3001. 14ee: f5 0b sbc r31, r21
  3002. 000014f0 <__udivmodsi4_ep>:
  3003. 14f0: 66 1f adc r22, r22
  3004. 14f2: 77 1f adc r23, r23
  3005. 14f4: 88 1f adc r24, r24
  3006. 14f6: 99 1f adc r25, r25
  3007. 14f8: 1a 94 dec r1
  3008. 14fa: 69 f7 brne .-38 ; 0x14d6 <__udivmodsi4_loop>
  3009. 14fc: 60 95 com r22
  3010. 14fe: 70 95 com r23
  3011. 1500: 80 95 com r24
  3012. 1502: 90 95 com r25
  3013. 1504: 9b 01 movw r18, r22
  3014. 1506: ac 01 movw r20, r24
  3015. 1508: bd 01 movw r22, r26
  3016. 150a: cf 01 movw r24, r30
  3017. 150c: 08 95 ret
  3018. 0000150e <__tablejump2__>:
  3019. 150e: ee 0f add r30, r30
  3020. 1510: ff 1f adc r31, r31
  3021. 1512: 05 90 lpm r0, Z+
  3022. 1514: f4 91 lpm r31, Z
  3023. 1516: e0 2d mov r30, r0
  3024. 1518: 09 94 ijmp
  3025. 0000151a <abort>:
  3026. 151a: 81 e0 ldi r24, 0x01 ; 1
  3027. 151c: 90 e0 ldi r25, 0x00 ; 0
  3028. 151e: f8 94 cli
  3029. 1520: 0c 94 92 0a jmp 0x1524 ; 0x1524 <_exit>
  3030. 00001524 <_exit>:
  3031. 1524: f8 94 cli
  3032. 00001526 <__stop_program>:
  3033. 1526: ff cf rjmp .-2 ; 0x1526 <__stop_program>