API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 24th, 2019
205
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 164.46 KB | None | 0 0
raw download clone embed print report
  1.  
  2. Li-ionTester.elf: file format elf32-avr
  3.  
  4. Sections:
  5. Idx Name Size VMA LMA File off Algn
  6. 0 .text 00001976 00000000 00000000 000000b4 2**1
  7. CONTENTS, ALLOC, LOAD, READONLY, CODE
  8. 1 .data 000002ca 00800060 00001976 00001a2a 2**0
  9. CONTENTS, ALLOC, LOAD, DATA
  10. 2 .bss 00000086 0080032a 0080032a 00001cf4 2**0
  11. ALLOC
  12. 3 .eeprom 00000019 00810000 00810000 00001cf4 2**0
  13. CONTENTS, ALLOC, LOAD, DATA
  14. 4 .stab 00000e88 00000000 00000000 00001d10 2**2
  15. CONTENTS, READONLY, DEBUGGING
  16. 5 .stabstr 00000406 00000000 00000000 00002b98 2**0
  17. CONTENTS, READONLY, DEBUGGING
  18. 6 .debug_aranges 00000240 00000000 00000000 00002f9e 2**0
  19. CONTENTS, READONLY, DEBUGGING
  20. 7 .debug_pubnames 000005ff 00000000 00000000 000031de 2**0
  21. CONTENTS, READONLY, DEBUGGING
  22. 8 .debug_info 00001d84 00000000 00000000 000037dd 2**0
  23. CONTENTS, READONLY, DEBUGGING
  24. 9 .debug_abbrev 0000093c 00000000 00000000 00005561 2**0
  25. CONTENTS, READONLY, DEBUGGING
  26. 10 .debug_line 0000202e 00000000 00000000 00005e9d 2**0
  27. CONTENTS, READONLY, DEBUGGING
  28. 11 .debug_frame 000003c0 00000000 00000000 00007ecc 2**2
  29. CONTENTS, READONLY, DEBUGGING
  30. 12 .debug_str 000006d0 00000000 00000000 0000828c 2**0
  31. CONTENTS, READONLY, DEBUGGING
  32. 13 .debug_loc 000010e7 00000000 00000000 0000895c 2**0
  33. CONTENTS, READONLY, DEBUGGING
  34. 14 .debug_pubtypes 0000010f 00000000 00000000 00009a43 2**0
  35. CONTENTS, READONLY, DEBUGGING
  36. 15 .debug_ranges 000001f8 00000000 00000000 00009b52 2**0
  37. CONTENTS, READONLY, DEBUGGING
  38.  
  39. Disassembly of section .text:
  40.  
  41. 00000000 <__vectors>:
  42. 0: 1a c0 rjmp .+52 ; 0x36 <__ctors_end>
  43. 2: 34 c0 rjmp .+104 ; 0x6c <__bad_interrupt>
  44. 4: 33 c0 rjmp .+102 ; 0x6c <__bad_interrupt>
  45. 6: 32 c0 rjmp .+100 ; 0x6c <__bad_interrupt>
  46. 8: 6d c5 rjmp .+2778 ; 0xae4 <__vector_4>
  47. a: 30 c0 rjmp .+96 ; 0x6c <__bad_interrupt>
  48. c: 2f c0 rjmp .+94 ; 0x6c <__bad_interrupt>
  49. e: 2e c0 rjmp .+92 ; 0x6c <__bad_interrupt>
  50. 10: 2d c0 rjmp .+90 ; 0x6c <__bad_interrupt>
  51. 12: 2c c0 rjmp .+88 ; 0x6c <__bad_interrupt>
  52. 14: 2b c0 rjmp .+86 ; 0x6c <__bad_interrupt>
  53. 16: 93 cb rjmp .-2266 ; 0xfffff73e <__eeprom_end+0xff7ef725>
  54. 18: 45 cb rjmp .-2422 ; 0xfffff6a4 <__eeprom_end+0xff7ef68b>
  55. 1a: 28 c0 rjmp .+80 ; 0x6c <__bad_interrupt>
  56. 1c: 27 c0 rjmp .+78 ; 0x6c <__bad_interrupt>
  57. 1e: 26 c0 rjmp .+76 ; 0x6c <__bad_interrupt>
  58. 20: 25 c0 rjmp .+74 ; 0x6c <__bad_interrupt>
  59. 22: 24 c0 rjmp .+72 ; 0x6c <__bad_interrupt>
  60. 24: 23 c0 rjmp .+70 ; 0x6c <__bad_interrupt>
  61.  
  62. 00000026 <leftArrow>:
  63. 26: 02 04 08 10 08 04 02 00 ........
  64.  
  65. 0000002e <rightArrow>:
  66. 2e: 08 04 02 01 02 04 08 00 ........
  67.  
  68. 00000036 <__ctors_end>:
  69. 36: 11 24 eor r1, r1
  70. 38: 1f be out 0x3f, r1 ; 63
  71. 3a: cf e5 ldi r28, 0x5F ; 95
  72. 3c: d4 e0 ldi r29, 0x04 ; 4
  73. 3e: de bf out 0x3e, r29 ; 62
  74. 40: cd bf out 0x3d, r28 ; 61
  75.  
  76. 00000042 <__do_copy_data>:
  77. 42: 13 e0 ldi r17, 0x03 ; 3
  78. 44: a0 e6 ldi r26, 0x60 ; 96
  79. 46: b0 e0 ldi r27, 0x00 ; 0
  80. 48: e6 e7 ldi r30, 0x76 ; 118
  81. 4a: f9 e1 ldi r31, 0x19 ; 25
  82. 4c: 02 c0 rjmp .+4 ; 0x52 <__do_copy_data+0x10>
  83. 4e: 05 90 lpm r0, Z+
  84. 50: 0d 92 st X+, r0
  85. 52: aa 32 cpi r26, 0x2A ; 42
  86. 54: b1 07 cpc r27, r17
  87. 56: d9 f7 brne .-10 ; 0x4e <__do_copy_data+0xc>
  88.  
  89. 00000058 <__do_clear_bss>:
  90. 58: 13 e0 ldi r17, 0x03 ; 3
  91. 5a: aa e2 ldi r26, 0x2A ; 42
  92. 5c: b3 e0 ldi r27, 0x03 ; 3
  93. 5e: 01 c0 rjmp .+2 ; 0x62 <.do_clear_bss_start>
  94.  
  95. 00000060 <.do_clear_bss_loop>:
  96. 60: 1d 92 st X+, r1
  97.  
  98. 00000062 <.do_clear_bss_start>:
  99. 62: a0 3b cpi r26, 0xB0 ; 176
  100. 64: b1 07 cpc r27, r17
  101. 66: e1 f7 brne .-8 ; 0x60 <.do_clear_bss_loop>
  102. 68: 65 d5 rcall .+2762 ; 0xb34 <main>
  103. 6a: 83 cc rjmp .-1786 ; 0xfffff972 <__eeprom_end+0xff7ef959>
  104.  
  105. 0000006c <__bad_interrupt>:
  106. 6c: c9 cf rjmp .-110 ; 0x0 <__vectors>
  107.  
  108. 0000006e <ShiftRegisterInit>:
  109.  
  110. /*
  111. Init SPI and I/O pins
  112. */
  113. void ShiftRegisterInit(){
  114. DATA_DDR |= (1<<DATA);
  115. 6e: b8 9a sbi 0x17, 0 ; 23
  116. SCK_DDR |= (1<<SCK);
  117. 70: bb 9a sbi 0x17, 3 ; 23
  118. LATCH_DDR |= (1<<LATCH);
  119. 72: bc 9a sbi 0x17, 4 ; 23
  120.  
  121. DATA_PORT &=~ (1 << DATA);
  122. 74: c0 98 cbi 0x18, 0 ; 24
  123. SCK_PORT &=~ (1 << SCK);
  124. 76: c3 98 cbi 0x18, 3 ; 24
  125. LATCH_PORT &=~ (1 << LATCH);
  126. 78: c4 98 cbi 0x18, 4 ; 24
  127. #if (USE_HARDWARE_SPI == 1)
  128. SPCR = ((1<<SPE)|(1<<MSTR)); //SPI config for Atmega8 if you have problems with hardware SPI change this or use soft SPI
  129. #endif
  130. }
  131. 7a: 08 95 ret
  132.  
  133. 0000007c <ShiftRegisterSend>:
  134. for(unsigned int byte = sizeof(ShiftPORT); byte > 0; byte--){
  135. #else
  136. for(unsigned int byte = 1; byte <= sizeof(ShiftPORT); byte++){
  137. #endif
  138.  
  139. unsigned char data = ShiftPORT[byte-1];
  140. 7c: 20 91 2a 03 lds r18, 0x032A
  141. 80: 88 e0 ldi r24, 0x08 ; 8
  142. 82: 90 e0 ldi r25, 0x00 ; 0
  143. for(unsigned int bit = 0; bit < 8; bit++){
  144. if(data & 0x80){
  145. 84: 27 ff sbrs r18, 7
  146. 86: 02 c0 rjmp .+4 ; 0x8c <ShiftRegisterSend+0x10>
  147. DATA_PORT |= (1 << DATA);
  148. 88: c0 9a sbi 0x18, 0 ; 24
  149. 8a: 01 c0 rjmp .+2 ; 0x8e <ShiftRegisterSend+0x12>
  150. }else{
  151. DATA_PORT &=~ (1 << DATA);
  152. 8c: c0 98 cbi 0x18, 0 ; 24
  153. }
  154. SCK_PORT |= (1 << SCK);
  155. 8e: c3 9a sbi 0x18, 3 ; 24
  156. SCK_PORT &=~ (1 << SCK);
  157. 90: c3 98 cbi 0x18, 3 ; 24
  158. 92: 01 97 sbiw r24, 0x01 ; 1
  159. #else
  160. for(unsigned int byte = 1; byte <= sizeof(ShiftPORT); byte++){
  161. #endif
  162.  
  163. unsigned char data = ShiftPORT[byte-1];
  164. for(unsigned int bit = 0; bit < 8; bit++){
  165. 94: 11 f0 breq .+4 ; 0x9a <ShiftRegisterSend+0x1e>
  166. }else{
  167. DATA_PORT &=~ (1 << DATA);
  168. }
  169. SCK_PORT |= (1 << SCK);
  170. SCK_PORT &=~ (1 << SCK);
  171. data <<= 1;
  172. 96: 22 0f add r18, r18
  173. 98: f5 cf rjmp .-22 ; 0x84 <ShiftRegisterSend+0x8>
  174. }
  175. }
  176. #endif
  177. LATCH_PORT |= (1 << LATCH);
  178. 9a: c4 9a sbi 0x18, 4 ; 24
  179. LATCH_PORT &=~ (1 << LATCH);
  180. 9c: c4 98 cbi 0x18, 4 ; 24
  181. }
  182. 9e: 08 95 ret
  183.  
  184. 000000a0 <ShiftDigitalWrite>:
  185. Set one pin of the shift register
  186. Use example:
  187. ShiftDigitalWrite(4, HIGH, 2);
  188. This example set pin 4 of в„–2 shift regisner to HIGH level
  189. */
  190. void ShiftDigitalWrite(int pin, int lvl, int number){
  191. a0: fa 01 movw r30, r20
  192. a2: e6 5d subi r30, 0xD6 ; 214
  193. a4: fc 4f sbci r31, 0xFC ; 252
  194. if(lvl){
  195. a6: 61 15 cp r22, r1
  196. a8: 71 05 cpc r23, r1
  197. aa: 51 f0 breq .+20 ; 0xc0 <ShiftDigitalWrite+0x20>
  198. ShiftPORT[number] |= (1 << pin);
  199. ac: 21 e0 ldi r18, 0x01 ; 1
  200. ae: 30 e0 ldi r19, 0x00 ; 0
  201. b0: 02 c0 rjmp .+4 ; 0xb6 <ShiftDigitalWrite+0x16>
  202. b2: 22 0f add r18, r18
  203. b4: 33 1f adc r19, r19
  204. b6: 8a 95 dec r24
  205. b8: e2 f7 brpl .-8 ; 0xb2 <ShiftDigitalWrite+0x12>
  206. ba: 80 81 ld r24, Z
  207. bc: 82 2b or r24, r18
  208. be: 0a c0 rjmp .+20 ; 0xd4 <ShiftDigitalWrite+0x34>
  209. }else{
  210. ShiftPORT[number] &= ~(1 << pin);
  211. c0: 21 e0 ldi r18, 0x01 ; 1
  212. c2: 30 e0 ldi r19, 0x00 ; 0
  213. c4: 02 c0 rjmp .+4 ; 0xca <ShiftDigitalWrite+0x2a>
  214. c6: 22 0f add r18, r18
  215. c8: 33 1f adc r19, r19
  216. ca: 8a 95 dec r24
  217. cc: e2 f7 brpl .-8 ; 0xc6 <ShiftDigitalWrite+0x26>
  218. ce: 20 95 com r18
  219. d0: 80 81 ld r24, Z
  220. d2: 82 23 and r24, r18
  221. d4: 80 83 st Z, r24
  222. }
  223. ShiftRegisterSend();
  224. d6: d2 df rcall .-92 ; 0x7c <ShiftRegisterSend>
  225. }
  226. d8: 08 95 ret
  227.  
  228. 000000da <ShiftDigitalWritePort>:
  229. Use example:
  230. ShiftDigitalWritePort(0xFF, 1);
  231. This example set all pins of в„–1 shuft register to HIGH level
  232. */
  233. void ShiftDigitalWritePort(int port, int number){
  234. ShiftPORT[number] = port;
  235. da: 66 5d subi r22, 0xD6 ; 214
  236. dc: 7c 4f sbci r23, 0xFC ; 252
  237. de: fb 01 movw r30, r22
  238. e0: 80 83 st Z, r24
  239. ShiftRegisterSend();
  240. e2: cc df rcall .-104 ; 0x7c <ShiftRegisterSend>
  241. }
  242. e4: 08 95 ret
  243.  
  244. 000000e6 <ShiftDigitalGetPort>:
  245. Use example:
  246. ShiftDigitalGetPort(1);
  247. This example return actual byte from shift register в„–1
  248. */
  249. char ShiftDigitalGetPort(int number){
  250. return ShiftPORT[number];
  251. e6: fc 01 movw r30, r24
  252. e8: e6 5d subi r30, 0xD6 ; 214
  253. ea: fc 4f sbci r31, 0xFC ; 252
  254. ec: 80 81 ld r24, Z
  255. ee: 08 95 ret
  256.  
  257. 000000f0 <PARS_Init>:
  258. uint8_t inc = 0;
  259. uint8_t flag = 0;
  260.  
  261. void PARS_Init(void)
  262. {
  263. argc = 0;
  264. f0: 10 92 9f 03 sts 0x039F, r1
  265. argv[0] = buf;
  266. f4: 80 ea ldi r24, 0xA0 ; 160
  267. f6: 93 e0 ldi r25, 0x03 ; 3
  268. f8: 90 93 9c 03 sts 0x039C, r25
  269. fc: 80 93 9b 03 sts 0x039B, r24
  270. flag = FALSE;
  271. 100: 10 92 2c 03 sts 0x032C, r1
  272. inc = 0;
  273. 104: 10 92 2b 03 sts 0x032B, r1
  274. }
  275. 108: 08 95 ret
  276.  
  277. 0000010a <PARS_Parser>:
  278.  
  279. void PARS_Parser(char sym)
  280. {
  281. 10a: 90 91 2b 03 lds r25, 0x032B
  282. if (sym != '\r'){
  283. 10e: 8d 30 cpi r24, 0x0D ; 13
  284. 110: 09 f4 brne .+2 ; 0x114 <PARS_Parser+0xa>
  285. 112: 4a c0 rjmp .+148 ; 0x1a8 <PARS_Parser+0x9e>
  286. if (inc < SIZE_RECEIVE_BUF - 1){
  287. 114: 9f 30 cpi r25, 0x0F ; 15
  288. 116: 08 f0 brcs .+2 ; 0x11a <PARS_Parser+0x10>
  289. 118: 40 c0 rjmp .+128 ; 0x19a <PARS_Parser+0x90>
  290. if (sym != ' '){
  291. 11a: 80 32 cpi r24, 0x20 ; 32
  292. 11c: 79 f1 breq .+94 ; 0x17c <PARS_Parser+0x72>
  293. if (!argc){
  294. 11e: 20 91 9f 03 lds r18, 0x039F
  295. 122: 22 23 and r18, r18
  296. 124: 49 f4 brne .+18 ; 0x138 <PARS_Parser+0x2e>
  297. argv[0] = buf;
  298. 126: 20 ea ldi r18, 0xA0 ; 160
  299. 128: 33 e0 ldi r19, 0x03 ; 3
  300. 12a: 30 93 9c 03 sts 0x039C, r19
  301. 12e: 20 93 9b 03 sts 0x039B, r18
  302. argc++;
  303. 132: 21 e0 ldi r18, 0x01 ; 1
  304. 134: 20 93 9f 03 sts 0x039F, r18
  305. }
  306.  
  307. if (flag){
  308. 138: 20 91 2c 03 lds r18, 0x032C
  309. 13c: 22 23 and r18, r18
  310. 13e: a9 f0 breq .+42 ; 0x16a <PARS_Parser+0x60>
  311. if (argc < AMOUNT_PAR){
  312. 140: 40 91 9f 03 lds r20, 0x039F
  313. 144: 42 30 cpi r20, 0x02 ; 2
  314. 146: 78 f4 brcc .+30 ; 0x166 <PARS_Parser+0x5c>
  315. argv[argc] = &buf[inc];
  316. 148: e4 2f mov r30, r20
  317. 14a: f0 e0 ldi r31, 0x00 ; 0
  318. 14c: ee 0f add r30, r30
  319. 14e: ff 1f adc r31, r31
  320. 150: e5 56 subi r30, 0x65 ; 101
  321. 152: fc 4f sbci r31, 0xFC ; 252
  322. 154: 29 2f mov r18, r25
  323. 156: 30 e0 ldi r19, 0x00 ; 0
  324. 158: 20 56 subi r18, 0x60 ; 96
  325. 15a: 3c 4f sbci r19, 0xFC ; 252
  326. 15c: 31 83 std Z+1, r19 ; 0x01
  327. 15e: 20 83 st Z, r18
  328. argc++;
  329. 160: 4f 5f subi r20, 0xFF ; 255
  330. 162: 40 93 9f 03 sts 0x039F, r20
  331. }
  332. flag = FALSE;
  333. 166: 10 92 2c 03 sts 0x032C, r1
  334. }
  335.  
  336. buf[inc] = sym;
  337. 16a: a9 2f mov r26, r25
  338. 16c: b0 e0 ldi r27, 0x00 ; 0
  339. 16e: a0 56 subi r26, 0x60 ; 96
  340. 170: bc 4f sbci r27, 0xFC ; 252
  341. 172: 8c 93 st X, r24
  342. inc++;
  343. 174: 9f 5f subi r25, 0xFF ; 255
  344. 176: 90 93 2b 03 sts 0x032B, r25
  345. 17a: 0f c0 rjmp .+30 ; 0x19a <PARS_Parser+0x90>
  346. }
  347. else{
  348. if (!flag){
  349. 17c: 80 91 2c 03 lds r24, 0x032C
  350. 180: 88 23 and r24, r24
  351. 182: 59 f4 brne .+22 ; 0x19a <PARS_Parser+0x90>
  352. buf[inc] = 0;
  353. 184: a9 2f mov r26, r25
  354. 186: b0 e0 ldi r27, 0x00 ; 0
  355. 188: a0 56 subi r26, 0x60 ; 96
  356. 18a: bc 4f sbci r27, 0xFC ; 252
  357. 18c: 1c 92 st X, r1
  358. inc++;
  359. 18e: 9f 5f subi r25, 0xFF ; 255
  360. 190: 90 93 2b 03 sts 0x032B, r25
  361. flag = TRUE;
  362. 194: 81 e0 ldi r24, 0x01 ; 1
  363. 196: 80 93 2c 03 sts 0x032C, r24
  364. }
  365. }
  366. }
  367. buf[inc] = 0;
  368. 19a: e0 91 2b 03 lds r30, 0x032B
  369. 19e: f0 e0 ldi r31, 0x00 ; 0
  370. 1a0: e0 56 subi r30, 0x60 ; 96
  371. 1a2: fc 4f sbci r31, 0xFC ; 252
  372. 1a4: 10 82 st Z, r1
  373. return;
  374. 1a6: 08 95 ret
  375. }
  376. else{
  377. buf[inc] = 0;
  378. 1a8: e9 2f mov r30, r25
  379. 1aa: f0 e0 ldi r31, 0x00 ; 0
  380. 1ac: e0 56 subi r30, 0x60 ; 96
  381. 1ae: fc 4f sbci r31, 0xFC ; 252
  382. 1b0: 10 82 st Z, r1
  383.  
  384. if (argc){
  385. 1b2: 80 91 9f 03 lds r24, 0x039F
  386. 1b6: 88 23 and r24, r24
  387. 1b8: 19 f0 breq .+6 ; 0x1c0 <PARS_Parser+0xb6>
  388. PARS_Handler(argc, argv);
  389. 1ba: 6b e9 ldi r22, 0x9B ; 155
  390. 1bc: 73 e0 ldi r23, 0x03 ; 3
  391. 1be: 37 d0 rcall .+110 ; 0x22e <PARS_Handler>
  392. }
  393. else{
  394. //сюда можно что-то добавить
  395. }
  396.  
  397. argc = 0;
  398. 1c0: 10 92 9f 03 sts 0x039F, r1
  399. flag = FALSE;
  400. 1c4: 10 92 2c 03 sts 0x032C, r1
  401. inc = 0;
  402. 1c8: 10 92 2b 03 sts 0x032B, r1
  403. 1cc: 08 95 ret
  404.  
  405. 000001ce <PARS_StrToUint>:
  406.  
  407. uint16_t PARS_StrToUint(char *s)
  408. {
  409. uint16_t value = 0;
  410.  
  411. while(*s == '0'){
  412. 1ce: e8 2f mov r30, r24
  413. 1d0: f9 2f mov r31, r25
  414. 1d2: 3e 2f mov r19, r30
  415. 1d4: 2f 2f mov r18, r31
  416. 1d6: 81 91 ld r24, Z+
  417. 1d8: 80 33 cpi r24, 0x30 ; 48
  418. 1da: d9 f3 breq .-10 ; 0x1d2 <PARS_StrToUint+0x4>
  419. 1dc: c9 01 movw r24, r18
  420. 1de: e9 2f mov r30, r25
  421. 1e0: f8 2f mov r31, r24
  422. 1e2: 20 e0 ldi r18, 0x00 ; 0
  423. 1e4: 30 e0 ldi r19, 0x00 ; 0
  424. 1e6: 11 c0 rjmp .+34 ; 0x20a <PARS_StrToUint+0x3c>
  425. s++;
  426. }
  427.  
  428. while(*s){
  429. value += (*s - 0x30);
  430. 1e8: 90 e0 ldi r25, 0x00 ; 0
  431. 1ea: c0 97 sbiw r24, 0x30 ; 48
  432. 1ec: 28 0f add r18, r24
  433. 1ee: 39 1f adc r19, r25
  434. s++;
  435. if (*s){
  436. 1f0: 80 81 ld r24, Z
  437. 1f2: 88 23 and r24, r24
  438. 1f4: 51 f0 breq .+20 ; 0x20a <PARS_StrToUint+0x3c>
  439. value *= 10;
  440. 1f6: c9 01 movw r24, r18
  441. 1f8: 88 0f add r24, r24
  442. 1fa: 99 1f adc r25, r25
  443. 1fc: 43 e0 ldi r20, 0x03 ; 3
  444. 1fe: 22 0f add r18, r18
  445. 200: 33 1f adc r19, r19
  446. 202: 4a 95 dec r20
  447. 204: e1 f7 brne .-8 ; 0x1fe <PARS_StrToUint+0x30>
  448. 206: 28 0f add r18, r24
  449. 208: 39 1f adc r19, r25
  450.  
  451. while(*s == '0'){
  452. s++;
  453. }
  454.  
  455. while(*s){
  456. 20a: 81 91 ld r24, Z+
  457. 20c: 88 23 and r24, r24
  458. 20e: 61 f7 brne .-40 ; 0x1e8 <PARS_StrToUint+0x1a>
  459. value *= 10;
  460. }
  461. };
  462.  
  463. return value;
  464. 210: c9 01 movw r24, r18
  465. 212: 08 95 ret
  466.  
  467. 00000214 <seconds>:
  468. 0b00000
  469. };
  470.  
  471. uint32_t seconds() {
  472. uint32_t m;
  473. cli();
  474. 214: f8 94 cli
  475. m = seconds_timer2;
  476. 216: 20 91 2d 03 lds r18, 0x032D
  477. 21a: 30 91 2e 03 lds r19, 0x032E
  478. 21e: 40 91 2f 03 lds r20, 0x032F
  479. 222: 50 91 30 03 lds r21, 0x0330
  480. sei();
  481. 226: 78 94 sei
  482. return m;
  483. }
  484. 228: b9 01 movw r22, r18
  485. 22a: ca 01 movw r24, r20
  486. 22c: 08 95 ret
  487.  
  488. 0000022e <PARS_Handler>:
  489.  
  490.  
  491. void PARS_Handler(uint8_t argc, char *argv[])
  492. {
  493. 22e: 1f 93 push r17
  494. int_buffer = PARS_StrToUint(argv[0]);
  495. 230: fb 01 movw r30, r22
  496. 232: 80 81 ld r24, Z
  497. 234: 91 81 ldd r25, Z+1 ; 0x01
  498. 236: cb df rcall .-106 ; 0x1ce <PARS_StrToUint>
  499. 238: 90 93 4c 03 sts 0x034C, r25
  500. 23c: 80 93 4b 03 sts 0x034B, r24
  501. if(dialog_id == VOLTAGE_DIALOG){
  502. 240: 10 91 4a 03 lds r17, 0x034A
  503. 244: 11 30 cpi r17, 0x01 ; 1
  504. 246: a9 f4 brne .+42 ; 0x272 <PARS_Handler+0x44>
  505.  
  506. if (int_buffer <= VOLTAGE_MAX && int_buffer >= VOLTAGE_MIN && int_buffer%VOLTAGE_STEP == 0)
  507. 248: 9c 01 movw r18, r24
  508. 24a: 24 5c subi r18, 0xC4 ; 196
  509. 24c: 39 40 sbci r19, 0x09 ; 9
  510. 24e: f3 e0 ldi r31, 0x03 ; 3
  511. 250: 29 3e cpi r18, 0xE9 ; 233
  512. 252: 3f 07 cpc r19, r31
  513. 254: 58 f4 brcc .+22 ; 0x26c <PARS_Handler+0x3e>
  514. 256: 64 e6 ldi r22, 0x64 ; 100
  515. 258: 70 e0 ldi r23, 0x00 ; 0
  516. 25a: bd da rcall .-2694 ; 0xfffff7d6 <__eeprom_end+0xff7ef7bd>
  517. 25c: 00 97 sbiw r24, 0x00 ; 0
  518. 25e: 31 f4 brne .+12 ; 0x26c <PARS_Handler+0x3e>
  519. {
  520. USART_SendStr("OK\r\n");
  521. 260: 80 e6 ldi r24, 0x60 ; 96
  522. 262: 90 e0 ldi r25, 0x00 ; 0
  523. 264: 0c da rcall .-3048 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  524. value_parsed_success = true;
  525. 266: 10 93 4e 03 sts 0x034E, r17
  526. 26a: 03 c0 rjmp .+6 ; 0x272 <PARS_Handler+0x44>
  527. }else{
  528. USART_SendStr("Invalid value\r\n");
  529. 26c: 85 e6 ldi r24, 0x65 ; 101
  530. 26e: 90 e0 ldi r25, 0x00 ; 0
  531. 270: 06 da rcall .-3060 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  532. }
  533. }
  534. if(dialog_id == AMPERAGE_DIALOG){
  535. 272: 80 91 4a 03 lds r24, 0x034A
  536. 276: 82 30 cpi r24, 0x02 ; 2
  537. 278: d1 f4 brne .+52 ; 0x2ae <PARS_Handler+0x80>
  538. if (int_buffer <= AMPERAGE_MAX && int_buffer >= AMPERAGE_MIN && int_buffer%AMPERAGE_STEP == 0)
  539. 27a: 80 91 4b 03 lds r24, 0x034B
  540. 27e: 90 91 4c 03 lds r25, 0x034C
  541. 282: 9c 01 movw r18, r24
  542. 284: 24 56 subi r18, 0x64 ; 100
  543. 286: 30 40 sbci r19, 0x00 ; 0
  544. 288: 47 e0 ldi r20, 0x07 ; 7
  545. 28a: 2d 36 cpi r18, 0x6D ; 109
  546. 28c: 34 07 cpc r19, r20
  547. 28e: 60 f4 brcc .+24 ; 0x2a8 <PARS_Handler+0x7a>
  548. 290: 64 e6 ldi r22, 0x64 ; 100
  549. 292: 70 e0 ldi r23, 0x00 ; 0
  550. 294: a0 da rcall .-2752 ; 0xfffff7d6 <__eeprom_end+0xff7ef7bd>
  551. 296: 00 97 sbiw r24, 0x00 ; 0
  552. 298: 39 f4 brne .+14 ; 0x2a8 <PARS_Handler+0x7a>
  553. {
  554. USART_SendStr("OK\r\n");
  555. 29a: 80 e6 ldi r24, 0x60 ; 96
  556. 29c: 90 e0 ldi r25, 0x00 ; 0
  557. 29e: ef d9 rcall .-3106 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  558. value_parsed_success = true;
  559. 2a0: 81 e0 ldi r24, 0x01 ; 1
  560. 2a2: 80 93 4e 03 sts 0x034E, r24
  561. 2a6: 03 c0 rjmp .+6 ; 0x2ae <PARS_Handler+0x80>
  562. }else{
  563. USART_SendStr("Invalid value\r\n");
  564. 2a8: 85 e6 ldi r24, 0x65 ; 101
  565. 2aa: 90 e0 ldi r25, 0x00 ; 0
  566. 2ac: e8 d9 rcall .-3120 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  567. }
  568. }
  569. }
  570. 2ae: 1f 91 pop r17
  571. 2b0: 08 95 ret
  572.  
  573. 000002b2 <t2_init>:
  574.  
  575. void t2_init(){
  576. TIMSK &= ~(1 << OCIE2)|(1 << TOIE2);
  577. 2b2: 89 b7 in r24, 0x39 ; 57
  578. 2b4: 8f 77 andi r24, 0x7F ; 127
  579. 2b6: 89 bf out 0x39, r24 ; 57
  580. ASSR |= (1 << AS2);
  581. 2b8: 82 b5 in r24, 0x22 ; 34
  582. 2ba: 88 60 ori r24, 0x08 ; 8
  583. 2bc: 82 bd out 0x22, r24 ; 34
  584. TCNT2 = 0;
  585. 2be: 14 bc out 0x24, r1 ; 36
  586. TCCR2 |= (1 << CS22)|(1 << CS20);
  587. 2c0: 85 b5 in r24, 0x25 ; 37
  588. 2c2: 85 60 ori r24, 0x05 ; 5
  589. 2c4: 85 bd out 0x25, r24 ; 37
  590. }
  591. 2c6: 08 95 ret
  592.  
  593. 000002c8 <read_adc>:
  594.  
  595.  
  596. unsigned int read_adc(unsigned char adc_input)
  597. {
  598. uint32_t adc_ = 0;
  599. ADMUX= adc_input | ADC_VREF_TYPE;
  600. 2c8: 87 b9 out 0x07, r24 ; 7
  601. #else
  602. //round up by default
  603. __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
  604. #endif
  605.  
  606. __builtin_avr_delay_cycles(__ticks_dc);
  607. 2ca: 8a e1 ldi r24, 0x1A ; 26
  608. 2cc: 8a 95 dec r24
  609. 2ce: f1 f7 brne .-4 ; 0x2cc <read_adc+0x4>
  610. 2d0: 00 c0 rjmp .+0 ; 0x2d2 <read_adc+0xa>
  611. 2d2: e4 e6 ldi r30, 0x64 ; 100
  612. }
  613.  
  614.  
  615. unsigned int read_adc(unsigned char adc_input)
  616. {
  617. uint32_t adc_ = 0;
  618. 2d4: 60 e0 ldi r22, 0x00 ; 0
  619. 2d6: 70 e0 ldi r23, 0x00 ; 0
  620. 2d8: cb 01 movw r24, r22
  621. ADMUX= adc_input | ADC_VREF_TYPE;
  622. _delay_us(10);
  623. for (char i = 0; i < ADC_READ_NUM; i++)
  624. {
  625. ADCSRA|=(1<<ADSC);
  626. 2da: 36 9a sbi 0x06, 6 ; 6
  627. while ((ADCSRA & (1<<ADIF))==0);
  628. 2dc: 34 9b sbis 0x06, 4 ; 6
  629. 2de: fe cf rjmp .-4 ; 0x2dc <read_adc+0x14>
  630. ADCSRA|=(1<<ADIF);
  631. 2e0: 34 9a sbi 0x06, 4 ; 6
  632. adc_ += ADCW;
  633. 2e2: 24 b1 in r18, 0x04 ; 4
  634. 2e4: 35 b1 in r19, 0x05 ; 5
  635. 2e6: 40 e0 ldi r20, 0x00 ; 0
  636. 2e8: 50 e0 ldi r21, 0x00 ; 0
  637. 2ea: 62 0f add r22, r18
  638. 2ec: 73 1f adc r23, r19
  639. 2ee: 84 1f adc r24, r20
  640. 2f0: 95 1f adc r25, r21
  641. 2f2: e1 50 subi r30, 0x01 ; 1
  642. unsigned int read_adc(unsigned char adc_input)
  643. {
  644. uint32_t adc_ = 0;
  645. ADMUX= adc_input | ADC_VREF_TYPE;
  646. _delay_us(10);
  647. for (char i = 0; i < ADC_READ_NUM; i++)
  648. 2f4: 91 f7 brne .-28 ; 0x2da <read_adc+0x12>
  649. ADCSRA|=(1<<ADSC);
  650. while ((ADCSRA & (1<<ADIF))==0);
  651. ADCSRA|=(1<<ADIF);
  652. adc_ += ADCW;
  653. }
  654. return adc_/ADC_READ_NUM;
  655. 2f6: 24 e6 ldi r18, 0x64 ; 100
  656. 2f8: 30 e0 ldi r19, 0x00 ; 0
  657. 2fa: 40 e0 ldi r20, 0x00 ; 0
  658. 2fc: 50 e0 ldi r21, 0x00 ; 0
  659. 2fe: 7f da rcall .-2818 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  660. }
  661. 300: c9 01 movw r24, r18
  662. 302: 08 95 ret
  663.  
  664. 00000304 <printUL>:
  665.  
  666. /*
  667. Функции для экономии памяти
  668. */
  669. void printUL(char i)
  670. {
  671. 304: 1f 93 push r17
  672. LCD_WriteData(0x30+i);
  673. 306: 18 2f mov r17, r24
  674. 308: 10 5d subi r17, 0xD0 ; 208
  675. 30a: 81 2f mov r24, r17
  676. 30c: fe d7 rcall .+4092 ; 0x130a <LCD_WriteData>
  677. USART_PutChar(0x30+i);
  678. 30e: 81 2f mov r24, r17
  679. 310: 90 d9 rcall .-3296 ; 0xfffff632 <__eeprom_end+0xff7ef619>
  680. }
  681. 312: 1f 91 pop r17
  682. 314: 08 95 ret
  683.  
  684. 00000316 <printUARTLCD>:
  685. void printUARTLCD(char i, bool uart)
  686. {
  687. 316: 1f 93 push r17
  688. 318: df 93 push r29
  689. 31a: cf 93 push r28
  690. 31c: 0f 92 push r0
  691. 31e: cd b7 in r28, 0x3d ; 61
  692. 320: de b7 in r29, 0x3e ; 62
  693. LCD_WriteData(0x30+i);
  694. 322: 18 2f mov r17, r24
  695. 324: 10 5d subi r17, 0xD0 ; 208
  696. 326: 81 2f mov r24, r17
  697. 328: 69 83 std Y+1, r22 ; 0x01
  698. 32a: ef d7 rcall .+4062 ; 0x130a <LCD_WriteData>
  699. if(uart){
  700. 32c: 69 81 ldd r22, Y+1 ; 0x01
  701. 32e: 66 23 and r22, r22
  702. 330: 11 f0 breq .+4 ; 0x336 <printUARTLCD+0x20>
  703. USART_PutChar(0x30+i);
  704. 332: 81 2f mov r24, r17
  705. 334: 7e d9 rcall .-3332 ; 0xfffff632 <__eeprom_end+0xff7ef619>
  706. }
  707. }
  708. 336: 0f 90 pop r0
  709. 338: cf 91 pop r28
  710. 33a: df 91 pop r29
  711. 33c: 1f 91 pop r17
  712. 33e: 08 95 ret
  713.  
  714. 00000340 <printITime>:
  715. void printITime(char a, char b)
  716. {
  717. 340: 0f 93 push r16
  718. 342: 1f 93 push r17
  719. 344: 16 2f mov r17, r22
  720. LCD_WriteData(0x30+a);
  721. 346: 08 2f mov r16, r24
  722. 348: 00 5d subi r16, 0xD0 ; 208
  723. 34a: 80 2f mov r24, r16
  724. 34c: de d7 rcall .+4028 ; 0x130a <LCD_WriteData>
  725. LCD_WriteData(0x30+b);
  726. 34e: 10 5d subi r17, 0xD0 ; 208
  727. 350: 81 2f mov r24, r17
  728. 352: db d7 rcall .+4022 ; 0x130a <LCD_WriteData>
  729. USART_PutChar(0x30+a);
  730. 354: 80 2f mov r24, r16
  731. 356: 6d d9 rcall .-3366 ; 0xfffff632 <__eeprom_end+0xff7ef619>
  732. USART_PutChar(0x30+b);
  733. 358: 81 2f mov r24, r17
  734. 35a: 6b d9 rcall .-3370 ; 0xfffff632 <__eeprom_end+0xff7ef619>
  735. }
  736. 35c: 1f 91 pop r17
  737. 35e: 0f 91 pop r16
  738. 360: 08 95 ret
  739.  
  740. 00000362 <printVoltage>:
  741. USART_PutChar('.');
  742. printUL((val%1000)/100);
  743. printUL((val%100)/10);
  744. }*/
  745. void printVoltage(unsigned long val)
  746. {
  747. 362: af 92 push r10
  748. 364: bf 92 push r11
  749. 366: cf 92 push r12
  750. 368: df 92 push r13
  751. 36a: ef 92 push r14
  752. 36c: ff 92 push r15
  753. 36e: 0f 93 push r16
  754. 370: 1f 93 push r17
  755. 372: 7b 01 movw r14, r22
  756. 374: 8c 01 movw r16, r24
  757. V_ = (val%100000)/10000;
  758. 376: 20 ea ldi r18, 0xA0 ; 160
  759. 378: 36 e8 ldi r19, 0x86 ; 134
  760. 37a: 41 e0 ldi r20, 0x01 ; 1
  761. 37c: 50 e0 ldi r21, 0x00 ; 0
  762. 37e: 3f da rcall .-2946 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  763. 380: 20 e1 ldi r18, 0x10 ; 16
  764. 382: 37 e2 ldi r19, 0x27 ; 39
  765. 384: 40 e0 ldi r20, 0x00 ; 0
  766. 386: 50 e0 ldi r21, 0x00 ; 0
  767. 388: 3a da rcall .-2956 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  768. 38a: 20 93 4d 03 sts 0x034D, r18
  769. if(V_){printUL(V_);}
  770. 38e: 22 23 and r18, r18
  771. 390: 11 f0 breq .+4 ; 0x396 <printVoltage+0x34>
  772. 392: 82 2f mov r24, r18
  773. 394: b7 df rcall .-146 ; 0x304 <printUL>
  774. printUL((val%10000)/1000);
  775. 396: c8 01 movw r24, r16
  776. 398: b7 01 movw r22, r14
  777. 39a: 20 e1 ldi r18, 0x10 ; 16
  778. 39c: 37 e2 ldi r19, 0x27 ; 39
  779. 39e: 40 e0 ldi r20, 0x00 ; 0
  780. 3a0: 50 e0 ldi r21, 0x00 ; 0
  781. 3a2: 2d da rcall .-2982 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  782. 3a4: 38 ee ldi r19, 0xE8 ; 232
  783. 3a6: a3 2e mov r10, r19
  784. 3a8: 33 e0 ldi r19, 0x03 ; 3
  785. 3aa: b3 2e mov r11, r19
  786. 3ac: c1 2c mov r12, r1
  787. 3ae: d1 2c mov r13, r1
  788. 3b0: a6 01 movw r20, r12
  789. 3b2: 95 01 movw r18, r10
  790. 3b4: 24 da rcall .-3000 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  791. 3b6: 82 2f mov r24, r18
  792. 3b8: a5 df rcall .-182 ; 0x304 <printUL>
  793. LCD_WriteData('.');
  794. 3ba: 8e e2 ldi r24, 0x2E ; 46
  795. 3bc: a6 d7 rcall .+3916 ; 0x130a <LCD_WriteData>
  796. USART_PutChar('.');
  797. 3be: 8e e2 ldi r24, 0x2E ; 46
  798. 3c0: 38 d9 rcall .-3472 ; 0xfffff632 <__eeprom_end+0xff7ef619>
  799. printUL((val%1000)/100);
  800. 3c2: c8 01 movw r24, r16
  801. 3c4: b7 01 movw r22, r14
  802. 3c6: a6 01 movw r20, r12
  803. 3c8: 95 01 movw r18, r10
  804. 3ca: 19 da rcall .-3022 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  805. 3cc: 24 e6 ldi r18, 0x64 ; 100
  806. 3ce: a2 2e mov r10, r18
  807. 3d0: b1 2c mov r11, r1
  808. 3d2: c1 2c mov r12, r1
  809. 3d4: d1 2c mov r13, r1
  810. 3d6: a6 01 movw r20, r12
  811. 3d8: 95 01 movw r18, r10
  812. 3da: 11 da rcall .-3038 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  813. 3dc: 82 2f mov r24, r18
  814. 3de: 92 df rcall .-220 ; 0x304 <printUL>
  815. if(!V_){
  816. 3e0: 80 91 4d 03 lds r24, 0x034D
  817. 3e4: 88 23 and r24, r24
  818. 3e6: 61 f4 brne .+24 ; 0x400 <printVoltage+0x9e>
  819. printUL((val%100)/10);
  820. 3e8: c8 01 movw r24, r16
  821. 3ea: b7 01 movw r22, r14
  822. 3ec: a6 01 movw r20, r12
  823. 3ee: 95 01 movw r18, r10
  824. 3f0: 06 da rcall .-3060 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  825. 3f2: 2a e0 ldi r18, 0x0A ; 10
  826. 3f4: 30 e0 ldi r19, 0x00 ; 0
  827. 3f6: 40 e0 ldi r20, 0x00 ; 0
  828. 3f8: 50 e0 ldi r21, 0x00 ; 0
  829. 3fa: 01 da rcall .-3070 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  830. 3fc: 82 2f mov r24, r18
  831. 3fe: 82 df rcall .-252 ; 0x304 <printUL>
  832. }
  833. }
  834. 400: 1f 91 pop r17
  835. 402: 0f 91 pop r16
  836. 404: ff 90 pop r15
  837. 406: ef 90 pop r14
  838. 408: df 90 pop r13
  839. 40a: cf 90 pop r12
  840. 40c: bf 90 pop r11
  841. 40e: af 90 pop r10
  842. 410: 08 95 ret
  843.  
  844. 00000412 <coolerCalc>:
  845. long map(long x, long in_min, long in_max, long out_min, long out_max)
  846. {
  847. return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
  848. }
  849. void coolerCalc(){
  850. cooler = read_adc(COOLER_TEMP_MUX_CHANNEL);
  851. 412: 82 e0 ldi r24, 0x02 ; 2
  852. 414: 59 df rcall .-334 ; 0x2c8 <read_adc>
  853. 416: 90 93 59 03 sts 0x0359, r25
  854. 41a: 80 93 58 03 sts 0x0358, r24
  855. if(cooler >= COOLER_ON_TEMP_VALUE && !start_cool){
  856. 41e: 21 e0 ldi r18, 0x01 ; 1
  857. 420: 8b 3d cpi r24, 0xDB ; 219
  858. 422: 92 07 cpc r25, r18
  859. 424: 40 f0 brcs .+16 ; 0x436 <coolerCalc+0x24>
  860. 426: 80 91 5a 03 lds r24, 0x035A
  861. 42a: 88 23 and r24, r24
  862. 42c: 81 f4 brne .+32 ; 0x44e <coolerCalc+0x3c>
  863. start_cool = true;
  864. 42e: 81 e0 ldi r24, 0x01 ; 1
  865. 430: 80 93 5a 03 sts 0x035A, r24
  866. 434: 0c c0 rjmp .+24 ; 0x44e <coolerCalc+0x3c>
  867. }
  868. if(cooler <= COOLER_OFF_TEMP_VALUE && start_cool){
  869. 436: 21 e0 ldi r18, 0x01 ; 1
  870. 438: 8a 35 cpi r24, 0x5A ; 90
  871. 43a: 92 07 cpc r25, r18
  872. 43c: 40 f4 brcc .+16 ; 0x44e <coolerCalc+0x3c>
  873. 43e: 80 91 5a 03 lds r24, 0x035A
  874. 442: 88 23 and r24, r24
  875. 444: 21 f0 breq .+8 ; 0x44e <coolerCalc+0x3c>
  876. start_cool = false;
  877. 446: 10 92 5a 03 sts 0x035A, r1
  878. OCR1B = 0;
  879. 44a: 19 bc out 0x29, r1 ; 41
  880. 44c: 18 bc out 0x28, r1 ; 40
  881. }
  882. if(start_cool){
  883. 44e: 80 91 5a 03 lds r24, 0x035A
  884. 452: 88 23 and r24, r24
  885. 454: b1 f0 breq .+44 ; 0x482 <__stack+0x23>
  886. OCR1B = map(cooler, 0, 1023, COOLER_MIN_PWM, 1023);
  887. 456: 60 91 58 03 lds r22, 0x0358
  888. 45a: 70 91 59 03 lds r23, 0x0359
  889. 45e: 80 e0 ldi r24, 0x00 ; 0
  890. 460: 90 e0 ldi r25, 0x00 ; 0
  891. }
  892. }
  893. /* Конец долбоебизма */
  894. long map(long x, long in_min, long in_max, long out_min, long out_max)
  895. {
  896. return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
  897. 462: 2f ef ldi r18, 0xFF ; 255
  898. 464: 31 e0 ldi r19, 0x01 ; 1
  899. 466: 40 e0 ldi r20, 0x00 ; 0
  900. 468: 50 e0 ldi r21, 0x00 ; 0
  901. 46a: 96 d9 rcall .-3284 ; 0xfffff798 <__eeprom_end+0xff7ef77f>
  902. 46c: 2f ef ldi r18, 0xFF ; 255
  903. 46e: 33 e0 ldi r19, 0x03 ; 3
  904. 470: 40 e0 ldi r20, 0x00 ; 0
  905. 472: 50 e0 ldi r21, 0x00 ; 0
  906. 474: e6 d9 rcall .-3124 ; 0xfffff842 <__eeprom_end+0xff7ef829>
  907. 476: 20 50 subi r18, 0x00 ; 0
  908. 478: 3e 4f sbci r19, 0xFE ; 254
  909. 47a: 4f 4f sbci r20, 0xFF ; 255
  910. 47c: 5f 4f sbci r21, 0xFF ; 255
  911. if(cooler <= COOLER_OFF_TEMP_VALUE && start_cool){
  912. start_cool = false;
  913. OCR1B = 0;
  914. }
  915. if(start_cool){
  916. OCR1B = map(cooler, 0, 1023, COOLER_MIN_PWM, 1023);
  917. 47e: 39 bd out 0x29, r19 ; 41
  918. 480: 28 bd out 0x28, r18 ; 40
  919. 482: 08 95 ret
  920.  
  921. 00000484 <checkBattery>:
  922. }
  923. }
  924. void checkBattery(bool clear, bool test)
  925. {
  926. 484: 0f 93 push r16
  927. 486: 1f 93 push r17
  928. 488: 18 2f mov r17, r24
  929. 48a: 06 2f mov r16, r22
  930. if(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(NO_BATTERY_VALUE)){
  931. 48c: 80 e0 ldi r24, 0x00 ; 0
  932. 48e: 1c df rcall .-456 ; 0x2c8 <read_adc>
  933. 490: 87 32 cpi r24, 0x27 ; 39
  934. 492: 91 05 cpc r25, r1
  935. 494: 08 f0 brcs .+2 ; 0x498 <checkBattery+0x14>
  936. 496: 4f c0 rjmp .+158 ; 0x536 <checkBattery+0xb2>
  937. LCD_Clear();
  938. 498: 81 e0 ldi r24, 0x01 ; 1
  939. 49a: 26 d7 rcall .+3660 ; 0x12e8 <LCD_WriteCom>
  940. #else
  941. //round up by default
  942. __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
  943. #endif
  944.  
  945. __builtin_avr_delay_cycles(__ticks_dc);
  946. 49c: 8f e9 ldi r24, 0x9F ; 159
  947. 49e: 9f e0 ldi r25, 0x0F ; 15
  948. 4a0: 01 97 sbiw r24, 0x01 ; 1
  949. 4a2: f1 f7 brne .-4 ; 0x4a0 <checkBattery+0x1c>
  950. 4a4: 00 c0 rjmp .+0 ; 0x4a6 <checkBattery+0x22>
  951. 4a6: 00 00 nop
  952. LCD_Goto(0,0);
  953. 4a8: 80 e8 ldi r24, 0x80 ; 128
  954. 4aa: 1e d7 rcall .+3644 ; 0x12e8 <LCD_WriteCom>
  955. LCD_SendStr("Please connect");
  956. 4ac: 85 e7 ldi r24, 0x75 ; 117
  957. 4ae: 90 e0 ldi r25, 0x00 ; 0
  958. 4b0: 60 d7 rcall .+3776 ; 0x1372 <LCD_SendStr>
  959. LCD_Goto(0,1);
  960. 4b2: 80 ec ldi r24, 0xC0 ; 192
  961. 4b4: 19 d7 rcall .+3634 ; 0x12e8 <LCD_WriteCom>
  962. LCD_SendStr("the battery ");
  963. 4b6: 84 e8 ldi r24, 0x84 ; 132
  964. 4b8: 90 e0 ldi r25, 0x00 ; 0
  965. 4ba: 5b d7 rcall .+3766 ; 0x1372 <LCD_SendStr>
  966. OCR1A = 0;
  967. 4bc: 1b bc out 0x2b, r1 ; 43
  968. 4be: 1a bc out 0x2a, r1 ; 42
  969. if(test){
  970. 4c0: 00 23 and r16, r16
  971. 4c2: 61 f0 breq .+24 ; 0x4dc <checkBattery+0x58>
  972. //Подключение АКБ
  973. BATTERY_OFF;
  974. 4c4: 86 e0 ldi r24, 0x06 ; 6
  975. 4c6: 90 e0 ldi r25, 0x00 ; 0
  976. 4c8: 60 e0 ldi r22, 0x00 ; 0
  977. 4ca: 70 e0 ldi r23, 0x00 ; 0
  978. 4cc: 40 e0 ldi r20, 0x00 ; 0
  979. 4ce: 50 e0 ldi r21, 0x00 ; 0
  980. 4d0: e7 dd rcall .-1074 ; 0xa0 <ShiftDigitalWrite>
  981. //Включение таймера времени
  982. TIMSK &= ~(1 << TOIE2);
  983. 4d2: 89 b7 in r24, 0x39 ; 57
  984. 4d4: 8f 7b andi r24, 0xBF ; 191
  985. 4d6: 89 bf out 0x39, r24 ; 57
  986. 4d8: 01 c0 rjmp .+2 ; 0x4dc <checkBattery+0x58>
  987. }
  988. while(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(NO_BATTERY_VALUE)){coolerCalc();}
  989. 4da: 9b df rcall .-202 ; 0x412 <coolerCalc>
  990. 4dc: 80 e0 ldi r24, 0x00 ; 0
  991. 4de: f4 de rcall .-536 ; 0x2c8 <read_adc>
  992. 4e0: 87 32 cpi r24, 0x27 ; 39
  993. 4e2: 91 05 cpc r25, r1
  994. 4e4: d0 f3 brcs .-12 ; 0x4da <checkBattery+0x56>
  995. if(test){
  996. 4e6: 00 23 and r16, r16
  997. 4e8: e1 f0 breq .+56 ; 0x522 <checkBattery+0x9e>
  998. //Подключение АКБ
  999. BATTERY_ON;
  1000. 4ea: 86 e0 ldi r24, 0x06 ; 6
  1001. 4ec: 90 e0 ldi r25, 0x00 ; 0
  1002. 4ee: 61 e0 ldi r22, 0x01 ; 1
  1003. 4f0: 70 e0 ldi r23, 0x00 ; 0
  1004. 4f2: 40 e0 ldi r20, 0x00 ; 0
  1005. 4f4: 50 e0 ldi r21, 0x00 ; 0
  1006. 4f6: d4 dd rcall .-1112 ; 0xa0 <ShiftDigitalWrite>
  1007. //Включение таймера времени
  1008. TIMSK |= (1 << TOIE2);
  1009. 4f8: 89 b7 in r24, 0x39 ; 57
  1010. 4fa: 80 64 ori r24, 0x40 ; 64
  1011. 4fc: 89 bf out 0x39, r24 ; 57
  1012. //PWM Calc
  1013. OCR1A = AMPERAGE_PWM_COEFFICIENT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP)+AMPERAGE_PWM_COEFFICIENT_CORRECT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP);
  1014. 4fe: 80 91 27 03 lds r24, 0x0327
  1015. 502: 90 91 28 03 lds r25, 0x0328
  1016. 506: 64 e6 ldi r22, 0x64 ; 100
  1017. 508: 70 e0 ldi r23, 0x00 ; 0
  1018. 50a: 65 d9 rcall .-3382 ; 0xfffff7d6 <__eeprom_end+0xff7ef7bd>
  1019. 50c: 4c e2 ldi r20, 0x2C ; 44
  1020. 50e: 50 e0 ldi r21, 0x00 ; 0
  1021. 510: 64 9f mul r22, r20
  1022. 512: 90 01 movw r18, r0
  1023. 514: 65 9f mul r22, r21
  1024. 516: 30 0d add r19, r0
  1025. 518: 74 9f mul r23, r20
  1026. 51a: 30 0d add r19, r0
  1027. 51c: 11 24 eor r1, r1
  1028. 51e: 3b bd out 0x2b, r19 ; 43
  1029. 520: 2a bd out 0x2a, r18 ; 42
  1030. }
  1031. if(clear) LCD_Clear();
  1032. 522: 11 23 and r17, r17
  1033. 524: 41 f0 breq .+16 ; 0x536 <checkBattery+0xb2>
  1034. 526: 81 e0 ldi r24, 0x01 ; 1
  1035. 528: df d6 rcall .+3518 ; 0x12e8 <LCD_WriteCom>
  1036. 52a: 8f e9 ldi r24, 0x9F ; 159
  1037. 52c: 9f e0 ldi r25, 0x0F ; 15
  1038. 52e: 01 97 sbiw r24, 0x01 ; 1
  1039. 530: f1 f7 brne .-4 ; 0x52e <checkBattery+0xaa>
  1040. 532: 00 c0 rjmp .+0 ; 0x534 <checkBattery+0xb0>
  1041. 534: 00 00 nop
  1042. }
  1043. }
  1044. 536: 1f 91 pop r17
  1045. 538: 0f 91 pop r16
  1046. 53a: 08 95 ret
  1047.  
  1048. 0000053c <Reset_Button>:
  1049.  
  1050. void Reset_Button(){
  1051. i = 0;
  1052. 53c: 10 92 47 03 sts 0x0347, r1
  1053. button_event = 0;
  1054. 540: 10 92 48 03 sts 0x0348, r1
  1055. while(i != ENTER_BUTTON_ID || button_event != BUT_PRESSED_CODE){
  1056. 544: 08 c0 rjmp .+16 ; 0x556 <Reset_Button+0x1a>
  1057. BUT_Poll();
  1058. 546: 2b d8 rcall .-4010 ; 0xfffff59e <__eeprom_end+0xff7ef585>
  1059. i = BUT_GetBut();
  1060. 548: e0 d7 rcall .+4032 ; 0x150a <BUT_GetBut>
  1061. 54a: 80 93 47 03 sts 0x0347, r24
  1062. button_event = BUT_GetBut();
  1063. 54e: dd d7 rcall .+4026 ; 0x150a <BUT_GetBut>
  1064. 550: 80 93 48 03 sts 0x0348, r24
  1065. coolerCalc();
  1066. 554: 5e df rcall .-324 ; 0x412 <coolerCalc>
  1067. }
  1068.  
  1069. void Reset_Button(){
  1070. i = 0;
  1071. button_event = 0;
  1072. while(i != ENTER_BUTTON_ID || button_event != BUT_PRESSED_CODE){
  1073. 556: 80 91 47 03 lds r24, 0x0347
  1074. 55a: 81 30 cpi r24, 0x01 ; 1
  1075. 55c: a1 f7 brne .-24 ; 0x546 <Reset_Button+0xa>
  1076. 55e: 80 91 48 03 lds r24, 0x0348
  1077. 562: 81 30 cpi r24, 0x01 ; 1
  1078. 564: 81 f7 brne .-32 ; 0x546 <Reset_Button+0xa>
  1079. BUT_Poll();
  1080. i = BUT_GetBut();
  1081. button_event = BUT_GetBut();
  1082. coolerCalc();
  1083. }
  1084. }
  1085. 566: 08 95 ret
  1086.  
  1087. 00000568 <checkTempPotection>:
  1088. void checkTempPotection(){
  1089. if(read_adc(BATTERY_TEMP_MUX_CHANNEL) >= BATTERY_CRITICAL_TEMP_VALUE){
  1090. 568: 85 e0 ldi r24, 0x05 ; 5
  1091. 56a: ae de rcall .-676 ; 0x2c8 <read_adc>
  1092. 56c: 24 e0 ldi r18, 0x04 ; 4
  1093. 56e: 80 30 cpi r24, 0x00 ; 0
  1094. 570: 92 07 cpc r25, r18
  1095. 572: 78 f1 brcs .+94 ; 0x5d2 <checkTempPotection+0x6a>
  1096. LCD_Clear();
  1097. 574: 81 e0 ldi r24, 0x01 ; 1
  1098. 576: b8 d6 rcall .+3440 ; 0x12e8 <LCD_WriteCom>
  1099. 578: 8f e9 ldi r24, 0x9F ; 159
  1100. 57a: 9f e0 ldi r25, 0x0F ; 15
  1101. 57c: 01 97 sbiw r24, 0x01 ; 1
  1102. 57e: f1 f7 brne .-4 ; 0x57c <checkTempPotection+0x14>
  1103. 580: 00 c0 rjmp .+0 ; 0x582 <checkTempPotection+0x1a>
  1104. 582: 00 00 nop
  1105. LCD_Goto(0,0);
  1106. 584: 80 e8 ldi r24, 0x80 ; 128
  1107. 586: b0 d6 rcall .+3424 ; 0x12e8 <LCD_WriteCom>
  1108. LCD_SendStr("High temperature");
  1109. 588: 81 e9 ldi r24, 0x91 ; 145
  1110. 58a: 90 e0 ldi r25, 0x00 ; 0
  1111. 58c: f2 d6 rcall .+3556 ; 0x1372 <LCD_SendStr>
  1112. LCD_Goto(1,1);
  1113. 58e: 81 ec ldi r24, 0xC1 ; 193
  1114. 590: ab d6 rcall .+3414 ; 0x12e8 <LCD_WriteCom>
  1115. LCD_SendStr("Enter - reboot");
  1116. 592: 82 ea ldi r24, 0xA2 ; 162
  1117. 594: 90 e0 ldi r25, 0x00 ; 0
  1118. 596: ed d6 rcall .+3546 ; 0x1372 <LCD_SendStr>
  1119. USART_SendStr("Critical temperarure!!! Test Stopped\r\n");
  1120. 598: 81 eb ldi r24, 0xB1 ; 177
  1121. 59a: 90 e0 ldi r25, 0x00 ; 0
  1122. 59c: 70 d8 rcall .-3872 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  1123. OCR1A = 0;
  1124. 59e: 1b bc out 0x2b, r1 ; 43
  1125. 5a0: 1a bc out 0x2a, r1 ; 42
  1126. TIMSK &= ~(1 << TOIE2);
  1127. 5a2: 89 b7 in r24, 0x39 ; 57
  1128. 5a4: 8f 7b andi r24, 0xBF ; 191
  1129. 5a6: 89 bf out 0x39, r24 ; 57
  1130. BATTERY_OFF;
  1131. 5a8: 86 e0 ldi r24, 0x06 ; 6
  1132. 5aa: 90 e0 ldi r25, 0x00 ; 0
  1133. 5ac: 60 e0 ldi r22, 0x00 ; 0
  1134. 5ae: 70 e0 ldi r23, 0x00 ; 0
  1135. 5b0: 40 e0 ldi r20, 0x00 ; 0
  1136. 5b2: 50 e0 ldi r21, 0x00 ; 0
  1137. 5b4: 75 dd rcall .-1302 ; 0xa0 <ShiftDigitalWrite>
  1138. Reset_Button();
  1139. 5b6: c2 df rcall .-124 ; 0x53c <Reset_Button>
  1140. USART_SendStr("Rebooting\r\n");
  1141. 5b8: 88 ed ldi r24, 0xD8 ; 216
  1142. 5ba: 90 e0 ldi r25, 0x00 ; 0
  1143. 5bc: 60 d8 rcall .-3904 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  1144. soft_reset();
  1145. 5be: 28 e0 ldi r18, 0x08 ; 8
  1146. 5c0: 88 e1 ldi r24, 0x18 ; 24
  1147. 5c2: 90 e0 ldi r25, 0x00 ; 0
  1148. 5c4: 0f b6 in r0, 0x3f ; 63
  1149. 5c6: f8 94 cli
  1150. 5c8: a8 95 wdr
  1151. 5ca: 81 bd out 0x21, r24 ; 33
  1152. 5cc: 0f be out 0x3f, r0 ; 63
  1153. 5ce: 21 bd out 0x21, r18 ; 33
  1154. 5d0: ff cf rjmp .-2 ; 0x5d0 <checkTempPotection+0x68>
  1155. 5d2: 08 95 ret
  1156.  
  1157. 000005d4 <printCapacity>:
  1158. }
  1159. }
  1160.  
  1161. void printCapacity(unsigned long Capacity, bool mode, bool uart){
  1162. 5d4: 4f 92 push r4
  1163. 5d6: 5f 92 push r5
  1164. 5d8: 6f 92 push r6
  1165. 5da: 7f 92 push r7
  1166. 5dc: 8f 92 push r8
  1167. 5de: 9f 92 push r9
  1168. 5e0: af 92 push r10
  1169. 5e2: bf 92 push r11
  1170. 5e4: cf 92 push r12
  1171. 5e6: df 92 push r13
  1172. 5e8: ef 92 push r14
  1173. 5ea: ff 92 push r15
  1174. 5ec: 0f 93 push r16
  1175. 5ee: 1f 93 push r17
  1176. 5f0: 6b 01 movw r12, r22
  1177. 5f2: 7c 01 movw r14, r24
  1178. 5f4: 04 2f mov r16, r20
  1179. 5f6: 12 2f mov r17, r18
  1180. if(mode){
  1181. 5f8: 44 23 and r20, r20
  1182. 5fa: 39 f0 breq .+14 ; 0x60a <printCapacity+0x36>
  1183. LCD_Goto(4,1);
  1184. 5fc: 84 ec ldi r24, 0xC4 ; 196
  1185. 5fe: 74 d6 rcall .+3304 ; 0x12e8 <LCD_WriteCom>
  1186. if(uart){
  1187. 600: 11 23 and r17, r17
  1188. 602: 19 f0 breq .+6 ; 0x60a <printCapacity+0x36>
  1189. USART_SendStr("Capacity: ");
  1190. 604: 84 ee ldi r24, 0xE4 ; 228
  1191. 606: 90 e0 ldi r25, 0x00 ; 0
  1192. 608: 3a d8 rcall .-3980 ; 0xfffff67e <__eeprom_end+0xff7ef665>
  1193. }
  1194. }
  1195.  
  1196. //Десятки тыс
  1197. printUARTLCD(Capacity/10000, uart);
  1198. 60a: c7 01 movw r24, r14
  1199. 60c: b6 01 movw r22, r12
  1200. 60e: 20 e1 ldi r18, 0x10 ; 16
  1201. 610: 37 e2 ldi r19, 0x27 ; 39
  1202. 612: 40 e0 ldi r20, 0x00 ; 0
  1203. 614: 50 e0 ldi r21, 0x00 ; 0
  1204. 616: f3 d8 rcall .-3610 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1205. 618: 2b 01 movw r4, r22
  1206. 61a: 3c 01 movw r6, r24
  1207. 61c: 82 2f mov r24, r18
  1208. 61e: 61 2f mov r22, r17
  1209. 620: 7a de rcall .-780 ; 0x316 <printUARTLCD>
  1210. //Тысячи
  1211. printUARTLCD((Capacity%10000)/1000, uart);
  1212. 622: 68 ee ldi r22, 0xE8 ; 232
  1213. 624: 86 2e mov r8, r22
  1214. 626: 63 e0 ldi r22, 0x03 ; 3
  1215. 628: 96 2e mov r9, r22
  1216. 62a: a1 2c mov r10, r1
  1217. 62c: b1 2c mov r11, r1
  1218. 62e: c3 01 movw r24, r6
  1219. 630: b2 01 movw r22, r4
  1220. 632: a5 01 movw r20, r10
  1221. 634: 94 01 movw r18, r8
  1222. 636: e3 d8 rcall .-3642 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1223. 638: 82 2f mov r24, r18
  1224. 63a: 61 2f mov r22, r17
  1225. 63c: 6c de rcall .-808 ; 0x316 <printUARTLCD>
  1226. //Сотни
  1227. printUARTLCD((Capacity%1000)/100, uart);
  1228. 63e: c7 01 movw r24, r14
  1229. 640: b6 01 movw r22, r12
  1230. 642: a5 01 movw r20, r10
  1231. 644: 94 01 movw r18, r8
  1232. 646: db d8 rcall .-3658 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1233. 648: 54 e6 ldi r21, 0x64 ; 100
  1234. 64a: 85 2e mov r8, r21
  1235. 64c: 91 2c mov r9, r1
  1236. 64e: a1 2c mov r10, r1
  1237. 650: b1 2c mov r11, r1
  1238. 652: a5 01 movw r20, r10
  1239. 654: 94 01 movw r18, r8
  1240. 656: d3 d8 rcall .-3674 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1241. 658: 82 2f mov r24, r18
  1242. 65a: 61 2f mov r22, r17
  1243. 65c: 5c de rcall .-840 ; 0x316 <printUARTLCD>
  1244. //Десятки
  1245. printUARTLCD((Capacity%100)/10, uart);
  1246. 65e: c7 01 movw r24, r14
  1247. 660: b6 01 movw r22, r12
  1248. 662: a5 01 movw r20, r10
  1249. 664: 94 01 movw r18, r8
  1250. 666: cb d8 rcall .-3690 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1251. 668: 4a e0 ldi r20, 0x0A ; 10
  1252. 66a: 84 2e mov r8, r20
  1253. 66c: 91 2c mov r9, r1
  1254. 66e: a1 2c mov r10, r1
  1255. 670: b1 2c mov r11, r1
  1256. 672: a5 01 movw r20, r10
  1257. 674: 94 01 movw r18, r8
  1258. 676: c3 d8 rcall .-3706 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1259. 678: 82 2f mov r24, r18
  1260. 67a: 61 2f mov r22, r17
  1261. 67c: 4c de rcall .-872 ; 0x316 <printUARTLCD>
  1262. printUARTLCD((Capacity%10), uart);
  1263. 67e: c7 01 movw r24, r14
  1264. 680: b6 01 movw r22, r12
  1265. 682: a5 01 movw r20, r10
  1266. 684: 94 01 movw r18, r8
  1267. 686: bb d8 rcall .-3722 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1268. 688: 86 2f mov r24, r22
  1269. 68a: 61 2f mov r22, r17
  1270. 68c: 44 de rcall .-888 ; 0x316 <printUARTLCD>
  1271.  
  1272. if(mode){
  1273. 68e: 00 23 and r16, r16
  1274. 690: 41 f0 breq .+16 ; 0x6a2 <printCapacity+0xce>
  1275. if(uart){
  1276. 692: 11 23 and r17, r17
  1277. 694: 19 f0 breq .+6 ; 0x69c <printCapacity+0xc8>
  1278. USART_SendStr(" mAh\r\n");
  1279. 696: 8f ee ldi r24, 0xEF ; 239
  1280. 698: 90 e0 ldi r25, 0x00 ; 0
  1281. 69a: f1 d7 rcall .+4066 ; 0x167e <USART_SendStr>
  1282. }
  1283. LCD_SendStr("mAh");
  1284. 69c: 86 ef ldi r24, 0xF6 ; 246
  1285. 69e: 90 e0 ldi r25, 0x00 ; 0
  1286. 6a0: 68 d6 rcall .+3280 ; 0x1372 <LCD_SendStr>
  1287. }
  1288.  
  1289. }
  1290. 6a2: 1f 91 pop r17
  1291. 6a4: 0f 91 pop r16
  1292. 6a6: ff 90 pop r15
  1293. 6a8: ef 90 pop r14
  1294. 6aa: df 90 pop r13
  1295. 6ac: cf 90 pop r12
  1296. 6ae: bf 90 pop r11
  1297. 6b0: af 90 pop r10
  1298. 6b2: 9f 90 pop r9
  1299. 6b4: 8f 90 pop r8
  1300. 6b6: 7f 90 pop r7
  1301. 6b8: 6f 90 pop r6
  1302. 6ba: 5f 90 pop r5
  1303. 6bc: 4f 90 pop r4
  1304. 6be: 08 95 ret
  1305.  
  1306. 000006c0 <Charge_battery>:
  1307.  
  1308. void Charge_battery(bool end)
  1309. {
  1310. 6c0: cf 92 push r12
  1311. 6c2: df 92 push r13
  1312. 6c4: ef 92 push r14
  1313. 6c6: ff 92 push r15
  1314. 6c8: 1f 93 push r17
  1315. 6ca: 18 2f mov r17, r24
  1316.  
  1317. TP4056_ON;
  1318. 6cc: 87 e0 ldi r24, 0x07 ; 7
  1319. 6ce: 90 e0 ldi r25, 0x00 ; 0
  1320. 6d0: 61 e0 ldi r22, 0x01 ; 1
  1321. 6d2: 70 e0 ldi r23, 0x00 ; 0
  1322. 6d4: 40 e0 ldi r20, 0x00 ; 0
  1323. 6d6: 50 e0 ldi r21, 0x00 ; 0
  1324. 6d8: e3 dc rcall .-1594 ; 0xa0 <ShiftDigitalWrite>
  1325. LCD_Goto(4,0);
  1326. 6da: 84 e8 ldi r24, 0x84 ; 132
  1327. 6dc: 05 d6 rcall .+3082 ; 0x12e8 <LCD_WriteCom>
  1328. USART_SendStr("Charging\r\n");
  1329. 6de: 8a ef ldi r24, 0xFA ; 250
  1330. 6e0: 90 e0 ldi r25, 0x00 ; 0
  1331. 6e2: cd d7 rcall .+3994 ; 0x167e <USART_SendStr>
  1332. while(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(CHARGE_TRIGGER_VALUE) && !(PINC & (1 << PC3))){
  1333. LCD_Goto(4,0);
  1334. LCD_SendStr("Charging");
  1335. if(end){
  1336. coolerCalc();
  1337. printCapacity(Capacity/3600, true, false);
  1338. 6e4: 70 e1 ldi r23, 0x10 ; 16
  1339. 6e6: c7 2e mov r12, r23
  1340. 6e8: 7e e0 ldi r23, 0x0E ; 14
  1341. 6ea: d7 2e mov r13, r23
  1342. 6ec: e1 2c mov r14, r1
  1343. 6ee: f1 2c mov r15, r1
  1344. {
  1345.  
  1346. TP4056_ON;
  1347. LCD_Goto(4,0);
  1348. USART_SendStr("Charging\r\n");
  1349. while(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(CHARGE_TRIGGER_VALUE) && !(PINC & (1 << PC3))){
  1350. 6f0: 1c c0 rjmp .+56 ; 0x72a <Charge_battery+0x6a>
  1351. LCD_Goto(4,0);
  1352. 6f2: 84 e8 ldi r24, 0x84 ; 132
  1353. 6f4: f9 d5 rcall .+3058 ; 0x12e8 <LCD_WriteCom>
  1354. LCD_SendStr("Charging");
  1355. 6f6: 85 e0 ldi r24, 0x05 ; 5
  1356. 6f8: 91 e0 ldi r25, 0x01 ; 1
  1357. 6fa: 3b d6 rcall .+3190 ; 0x1372 <LCD_SendStr>
  1358. if(end){
  1359. 6fc: 11 23 and r17, r17
  1360. 6fe: 89 f0 breq .+34 ; 0x722 <Charge_battery+0x62>
  1361. coolerCalc();
  1362. 700: 88 de rcall .-752 ; 0x412 <coolerCalc>
  1363. printCapacity(Capacity/3600, true, false);
  1364. 702: 60 91 3b 03 lds r22, 0x033B
  1365. 706: 70 91 3c 03 lds r23, 0x033C
  1366. 70a: 80 91 3d 03 lds r24, 0x033D
  1367. 70e: 90 91 3e 03 lds r25, 0x033E
  1368. 712: a7 01 movw r20, r14
  1369. 714: 96 01 movw r18, r12
  1370. 716: 73 d8 rcall .-3866 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1371. 718: ca 01 movw r24, r20
  1372. 71a: b9 01 movw r22, r18
  1373. 71c: 41 e0 ldi r20, 0x01 ; 1
  1374. 71e: 20 e0 ldi r18, 0x00 ; 0
  1375. 720: 59 df rcall .-334 ; 0x5d4 <printCapacity>
  1376. }
  1377. checkBattery(true, false);
  1378. 722: 81 e0 ldi r24, 0x01 ; 1
  1379. 724: 60 e0 ldi r22, 0x00 ; 0
  1380. 726: ae de rcall .-676 ; 0x484 <checkBattery>
  1381. checkTempPotection();
  1382. 728: 1f df rcall .-450 ; 0x568 <checkTempPotection>
  1383. {
  1384.  
  1385. TP4056_ON;
  1386. LCD_Goto(4,0);
  1387. USART_SendStr("Charging\r\n");
  1388. while(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(CHARGE_TRIGGER_VALUE) && !(PINC & (1 << PC3))){
  1389. 72a: 80 e0 ldi r24, 0x00 ; 0
  1390. 72c: cd dd rcall .-1126 ; 0x2c8 <read_adc>
  1391. 72e: 26 e0 ldi r18, 0x06 ; 6
  1392. 730: 8e 33 cpi r24, 0x3E ; 62
  1393. 732: 92 07 cpc r25, r18
  1394. 734: 10 f4 brcc .+4 ; 0x73a <Charge_battery+0x7a>
  1395. 736: 9b 9b sbis 0x13, 3 ; 19
  1396. 738: dc cf rjmp .-72 ; 0x6f2 <Charge_battery+0x32>
  1397. printCapacity(Capacity/3600, true, false);
  1398. }
  1399. checkBattery(true, false);
  1400. checkTempPotection();
  1401. }
  1402. TP4056_OFF;
  1403. 73a: 87 e0 ldi r24, 0x07 ; 7
  1404. 73c: 90 e0 ldi r25, 0x00 ; 0
  1405. 73e: 60 e0 ldi r22, 0x00 ; 0
  1406. 740: 70 e0 ldi r23, 0x00 ; 0
  1407. 742: 40 e0 ldi r20, 0x00 ; 0
  1408. 744: 50 e0 ldi r21, 0x00 ; 0
  1409. 746: ac dc rcall .-1704 ; 0xa0 <ShiftDigitalWrite>
  1410. if(end){
  1411. 748: 11 23 and r17, r17
  1412. 74a: 41 f1 breq .+80 ; 0x79c <Charge_battery+0xdc>
  1413. LCD_Goto(0,0);
  1414. 74c: 80 e8 ldi r24, 0x80 ; 128
  1415. 74e: cc d5 rcall .+2968 ; 0x12e8 <LCD_WriteCom>
  1416. LCD_SendStr("Full charged! :)");
  1417. 750: 8e e0 ldi r24, 0x0E ; 14
  1418. 752: 91 e0 ldi r25, 0x01 ; 1
  1419. 754: 0e d6 rcall .+3100 ; 0x1372 <LCD_SendStr>
  1420. USART_SendStr("Full charged! :)\r\n");
  1421. 756: 8f e1 ldi r24, 0x1F ; 31
  1422. 758: 91 e0 ldi r25, 0x01 ; 1
  1423. 75a: 91 d7 rcall .+3874 ; 0x167e <USART_SendStr>
  1424. printCapacity(Capacity/3600, true, false);
  1425. 75c: 60 91 3b 03 lds r22, 0x033B
  1426. 760: 70 91 3c 03 lds r23, 0x033C
  1427. 764: 80 91 3d 03 lds r24, 0x033D
  1428. 768: 90 91 3e 03 lds r25, 0x033E
  1429. 76c: 20 e1 ldi r18, 0x10 ; 16
  1430. 76e: 3e e0 ldi r19, 0x0E ; 14
  1431. 770: 40 e0 ldi r20, 0x00 ; 0
  1432. 772: 50 e0 ldi r21, 0x00 ; 0
  1433. 774: 44 d8 rcall .-3960 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1434. 776: ca 01 movw r24, r20
  1435. 778: b9 01 movw r22, r18
  1436. 77a: 41 e0 ldi r20, 0x01 ; 1
  1437. 77c: 20 e0 ldi r18, 0x00 ; 0
  1438. 77e: 2a df rcall .-428 ; 0x5d4 <printCapacity>
  1439. Reset_Button();
  1440. 780: dd de rcall .-582 ; 0x53c <Reset_Button>
  1441. USART_SendStr("Rebooting\r\n");
  1442. 782: 88 ed ldi r24, 0xD8 ; 216
  1443. 784: 90 e0 ldi r25, 0x00 ; 0
  1444. 786: 7b d7 rcall .+3830 ; 0x167e <USART_SendStr>
  1445. soft_reset();
  1446. 788: 28 e0 ldi r18, 0x08 ; 8
  1447. 78a: 88 e1 ldi r24, 0x18 ; 24
  1448. 78c: 90 e0 ldi r25, 0x00 ; 0
  1449. 78e: 0f b6 in r0, 0x3f ; 63
  1450. 790: f8 94 cli
  1451. 792: a8 95 wdr
  1452. 794: 81 bd out 0x21, r24 ; 33
  1453. 796: 0f be out 0x3f, r0 ; 63
  1454. 798: 21 bd out 0x21, r18 ; 33
  1455. 79a: ff cf rjmp .-2 ; 0x79a <Charge_battery+0xda>
  1456. }
  1457. }
  1458. 79c: 1f 91 pop r17
  1459. 79e: ff 90 pop r15
  1460. 7a0: ef 90 pop r14
  1461. 7a2: df 90 pop r13
  1462. 7a4: cf 90 pop r12
  1463. 7a6: 08 95 ret
  1464.  
  1465. 000007a8 <checkEndVoltage>:
  1466.  
  1467. void checkEndVoltage(){
  1468. 7a8: ef 92 push r14
  1469. 7aa: ff 92 push r15
  1470. 7ac: 0f 93 push r16
  1471. 7ae: 1f 93 push r17
  1472. if (END_Voltage > Voltage) { //выключение нагрузки при достижении минимального напряжения
  1473. 7b0: 20 91 25 03 lds r18, 0x0325
  1474. 7b4: 30 91 26 03 lds r19, 0x0326
  1475. 7b8: 40 e0 ldi r20, 0x00 ; 0
  1476. 7ba: 50 e0 ldi r21, 0x00 ; 0
  1477. 7bc: 80 91 43 03 lds r24, 0x0343
  1478. 7c0: 90 91 44 03 lds r25, 0x0344
  1479. 7c4: a0 91 45 03 lds r26, 0x0345
  1480. 7c8: b0 91 46 03 lds r27, 0x0346
  1481. 7cc: 82 17 cp r24, r18
  1482. 7ce: 93 07 cpc r25, r19
  1483. 7d0: a4 07 cpc r26, r20
  1484. 7d2: b5 07 cpc r27, r21
  1485. 7d4: 08 f0 brcs .+2 ; 0x7d8 <checkEndVoltage+0x30>
  1486. 7d6: aa c0 rjmp .+340 ; 0x92c <checkEndVoltage+0x184>
  1487. USART_SendStr("Low voltage: ");
  1488. 7d8: 82 e3 ldi r24, 0x32 ; 50
  1489. 7da: 91 e0 ldi r25, 0x01 ; 1
  1490. 7dc: 50 d7 rcall .+3744 ; 0x167e <USART_SendStr>
  1491. USART_PutChar((Voltage%10000)/1000);
  1492. 7de: 60 91 43 03 lds r22, 0x0343
  1493. 7e2: 70 91 44 03 lds r23, 0x0344
  1494. 7e6: 80 91 45 03 lds r24, 0x0345
  1495. 7ea: 90 91 46 03 lds r25, 0x0346
  1496. 7ee: 20 e1 ldi r18, 0x10 ; 16
  1497. 7f0: 37 e2 ldi r19, 0x27 ; 39
  1498. 7f2: 40 e0 ldi r20, 0x00 ; 0
  1499. 7f4: 50 e0 ldi r21, 0x00 ; 0
  1500. 7f6: 03 d8 rcall .-4090 ; 0xfffff7fe <__eeprom_end+0xff7ef7e5>
  1501. 7f8: a8 ee ldi r26, 0xE8 ; 232
  1502. 7fa: ea 2e mov r14, r26
  1503. 7fc: a3 e0 ldi r26, 0x03 ; 3
  1504. 7fe: fa 2e mov r15, r26
  1505. 800: 01 2d mov r16, r1
  1506. 802: 11 2d mov r17, r1
  1507. 804: a8 01 movw r20, r16
  1508. 806: 97 01 movw r18, r14
  1509. 808: fa d7 rcall .+4084 ; 0x17fe <__udivmodsi4>
  1510. 80a: 82 2f mov r24, r18
  1511. 80c: 12 d7 rcall .+3620 ; 0x1632 <USART_PutChar>
  1512. USART_PutChar('.');
  1513. 80e: 8e e2 ldi r24, 0x2E ; 46
  1514. 810: 10 d7 rcall .+3616 ; 0x1632 <USART_PutChar>
  1515. USART_PutChar((Voltage%1000)/100);
  1516. 812: 60 91 43 03 lds r22, 0x0343
  1517. 816: 70 91 44 03 lds r23, 0x0344
  1518. 81a: 80 91 45 03 lds r24, 0x0345
  1519. 81e: 90 91 46 03 lds r25, 0x0346
  1520. 822: a8 01 movw r20, r16
  1521. 824: 97 01 movw r18, r14
  1522. 826: eb d7 rcall .+4054 ; 0x17fe <__udivmodsi4>
  1523. 828: f4 e6 ldi r31, 0x64 ; 100
  1524. 82a: ef 2e mov r14, r31
  1525. 82c: f1 2c mov r15, r1
  1526. 82e: 01 2d mov r16, r1
  1527. 830: 11 2d mov r17, r1
  1528. 832: a8 01 movw r20, r16
  1529. 834: 97 01 movw r18, r14
  1530. 836: e3 d7 rcall .+4038 ; 0x17fe <__udivmodsi4>
  1531. 838: 82 2f mov r24, r18
  1532. 83a: fb d6 rcall .+3574 ; 0x1632 <USART_PutChar>
  1533. USART_PutChar((Voltage%100)/10);
  1534. 83c: 60 91 43 03 lds r22, 0x0343
  1535. 840: 70 91 44 03 lds r23, 0x0344
  1536. 844: 80 91 45 03 lds r24, 0x0345
  1537. 848: 90 91 46 03 lds r25, 0x0346
  1538. 84c: a8 01 movw r20, r16
  1539. 84e: 97 01 movw r18, r14
  1540. 850: d6 d7 rcall .+4012 ; 0x17fe <__udivmodsi4>
  1541. 852: 2a e0 ldi r18, 0x0A ; 10
  1542. 854: 30 e0 ldi r19, 0x00 ; 0
  1543. 856: 40 e0 ldi r20, 0x00 ; 0
  1544. 858: 50 e0 ldi r21, 0x00 ; 0
  1545. 85a: d1 d7 rcall .+4002 ; 0x17fe <__udivmodsi4>
  1546. 85c: 82 2f mov r24, r18
  1547. 85e: e9 d6 rcall .+3538 ; 0x1632 <USART_PutChar>
  1548. USART_SendStr("V\r\n");
  1549. 860: 80 e4 ldi r24, 0x40 ; 64
  1550. 862: 91 e0 ldi r25, 0x01 ; 1
  1551. 864: 0c d7 rcall .+3608 ; 0x167e <USART_SendStr>
  1552. OCR1A = 0;
  1553. 866: 1b bc out 0x2b, r1 ; 43
  1554. 868: 1a bc out 0x2a, r1 ; 42
  1555. BATTERY_OFF;
  1556. 86a: 86 e0 ldi r24, 0x06 ; 6
  1557. 86c: 90 e0 ldi r25, 0x00 ; 0
  1558. 86e: 60 e0 ldi r22, 0x00 ; 0
  1559. 870: 70 e0 ldi r23, 0x00 ; 0
  1560. 872: 40 e0 ldi r20, 0x00 ; 0
  1561. 874: 50 e0 ldi r21, 0x00 ; 0
  1562. 876: 14 dc rcall .-2008 ; 0xa0 <ShiftDigitalWrite>
  1563. TIMSK &= ~(1 << OCIE2)|(1 << TOIE2);
  1564. 878: 89 b7 in r24, 0x39 ; 57
  1565. 87a: 8f 77 andi r24, 0x7F ; 127
  1566. 87c: 89 bf out 0x39, r24 ; 57
  1567.  
  1568. LCD_Clear();
  1569. 87e: 81 e0 ldi r24, 0x01 ; 1
  1570. 880: 33 d5 rcall .+2662 ; 0x12e8 <LCD_WriteCom>
  1571. 882: 8f e9 ldi r24, 0x9F ; 159
  1572. 884: 9f e0 ldi r25, 0x0F ; 15
  1573. 886: 01 97 sbiw r24, 0x01 ; 1
  1574. 888: f1 f7 brne .-4 ; 0x886 <checkEndVoltage+0xde>
  1575. 88a: 00 c0 rjmp .+0 ; 0x88c <checkEndVoltage+0xe4>
  1576. 88c: 00 00 nop
  1577. LCD_Goto(1,0);
  1578. 88e: 81 e8 ldi r24, 0x81 ; 129
  1579. 890: 2b d5 rcall .+2646 ; 0x12e8 <LCD_WriteCom>
  1580. eeprom_write_dword(&CountTestsComplete, eeprom_read_dword(&CountTestsComplete)+1);
  1581. 892: 81 e1 ldi r24, 0x11 ; 17
  1582. 894: 90 e0 ldi r25, 0x00 ; 0
  1583. 896: 3a d8 rcall .-3980 ; 0xfffff90c <__eeprom_end+0xff7ef8f3>
  1584. 898: ab 01 movw r20, r22
  1585. 89a: bc 01 movw r22, r24
  1586. 89c: 4f 5f subi r20, 0xFF ; 255
  1587. 89e: 5f 4f sbci r21, 0xFF ; 255
  1588. 8a0: 6f 4f sbci r22, 0xFF ; 255
  1589. 8a2: 7f 4f sbci r23, 0xFF ; 255
  1590. 8a4: 81 e1 ldi r24, 0x11 ; 17
  1591. 8a6: 90 e0 ldi r25, 0x00 ; 0
  1592. 8a8: 4c d8 rcall .-3944 ; 0xfffff942 <__eeprom_end+0xff7ef929>
  1593. LCD_SendStr("Test completed");
  1594. 8aa: 84 e4 ldi r24, 0x44 ; 68
  1595. 8ac: 91 e0 ldi r25, 0x01 ; 1
  1596. 8ae: 61 d5 rcall .+2754 ; 0x1372 <LCD_SendStr>
  1597. USART_SendStr("Test completed\r\n");
  1598. 8b0: 83 e5 ldi r24, 0x53 ; 83
  1599. 8b2: 91 e0 ldi r25, 0x01 ; 1
  1600. 8b4: e4 d6 rcall .+3528 ; 0x167e <USART_SendStr>
  1601.  
  1602. //Вывод емкости
  1603. printCapacity(Capacity/3600, true, true);
  1604. 8b6: 60 91 3b 03 lds r22, 0x033B
  1605. 8ba: 70 91 3c 03 lds r23, 0x033C
  1606. 8be: 80 91 3d 03 lds r24, 0x033D
  1607. 8c2: 90 91 3e 03 lds r25, 0x033E
  1608. 8c6: e0 e1 ldi r30, 0x10 ; 16
  1609. 8c8: ee 2e mov r14, r30
  1610. 8ca: ee e0 ldi r30, 0x0E ; 14
  1611. 8cc: fe 2e mov r15, r30
  1612. 8ce: 01 2d mov r16, r1
  1613. 8d0: 11 2d mov r17, r1
  1614. 8d2: a8 01 movw r20, r16
  1615. 8d4: 97 01 movw r18, r14
  1616. 8d6: 93 d7 rcall .+3878 ; 0x17fe <__udivmodsi4>
  1617. 8d8: ca 01 movw r24, r20
  1618. 8da: b9 01 movw r22, r18
  1619. 8dc: 41 e0 ldi r20, 0x01 ; 1
  1620. 8de: 21 e0 ldi r18, 0x01 ; 1
  1621. 8e0: 79 de rcall .-782 ; 0x5d4 <printCapacity>
  1622.  
  1623. eeprom_write_dword(&eeLastCapacity, Capacity/3600);
  1624. 8e2: 60 91 3b 03 lds r22, 0x033B
  1625. 8e6: 70 91 3c 03 lds r23, 0x033C
  1626. 8ea: 80 91 3d 03 lds r24, 0x033D
  1627. 8ee: 90 91 3e 03 lds r25, 0x033E
  1628. 8f2: a8 01 movw r20, r16
  1629. 8f4: 97 01 movw r18, r14
  1630. 8f6: 83 d7 rcall .+3846 ; 0x17fe <__udivmodsi4>
  1631. 8f8: 89 e0 ldi r24, 0x09 ; 9
  1632. 8fa: 90 e0 ldi r25, 0x00 ; 0
  1633. 8fc: ba 01 movw r22, r20
  1634. 8fe: a9 01 movw r20, r18
  1635. 900: 20 d8 rcall .-4032 ; 0xfffff942 <__eeprom_end+0xff7ef929>
  1636. 902: 8f ef ldi r24, 0xFF ; 255
  1637. 904: 99 e6 ldi r25, 0x69 ; 105
  1638. 906: a8 e1 ldi r26, 0x18 ; 24
  1639. 908: 81 50 subi r24, 0x01 ; 1
  1640. 90a: 90 40 sbci r25, 0x00 ; 0
  1641. 90c: a0 40 sbci r26, 0x00 ; 0
  1642. 90e: e1 f7 brne .-8 ; 0x908 <checkEndVoltage+0x160>
  1643. 910: 00 c0 rjmp .+0 ; 0x912 <checkEndVoltage+0x16a>
  1644. 912: 00 00 nop
  1645.  
  1646. _delay_ms(1000);
  1647.  
  1648. LCD_Goto(0,0);
  1649. 914: 80 e8 ldi r24, 0x80 ; 128
  1650. 916: e8 d4 rcall .+2512 ; 0x12e8 <LCD_WriteCom>
  1651. LCD_SendStr(" ");
  1652. 918: 84 e6 ldi r24, 0x64 ; 100
  1653. 91a: 91 e0 ldi r25, 0x01 ; 1
  1654. 91c: 2a d5 rcall .+2644 ; 0x1372 <LCD_SendStr>
  1655. LCD_Goto(12,0);
  1656. 91e: 8c e8 ldi r24, 0x8C ; 140
  1657. 920: e3 d4 rcall .+2502 ; 0x12e8 <LCD_WriteCom>
  1658. LCD_SendStr(" ");
  1659. 922: 84 e6 ldi r24, 0x64 ; 100
  1660. 924: 91 e0 ldi r25, 0x01 ; 1
  1661. 926: 25 d5 rcall .+2634 ; 0x1372 <LCD_SendStr>
  1662. Charge_battery(true);
  1663. 928: 81 e0 ldi r24, 0x01 ; 1
  1664. 92a: ca de rcall .-620 ; 0x6c0 <Charge_battery>
  1665. }
  1666. }
  1667. 92c: 1f 91 pop r17
  1668. 92e: 0f 91 pop r16
  1669. 930: ff 90 pop r15
  1670. 932: ef 90 pop r14
  1671. 934: 08 95 ret
  1672.  
  1673. 00000936 <printVADialig>:
  1674.  
  1675. void printVADialig(unsigned long *eeprom, unsigned int step, char *start_text, unsigned int *var, unsigned int position, unsigned int min, unsigned int max, char *uart_text, char *start_value_text, char id){
  1676. 936: 2f 92 push r2
  1677. 938: 3f 92 push r3
  1678. 93a: 4f 92 push r4
  1679. 93c: 5f 92 push r5
  1680. 93e: 6f 92 push r6
  1681. 940: 7f 92 push r7
  1682. 942: 8f 92 push r8
  1683. 944: 9f 92 push r9
  1684. 946: af 92 push r10
  1685. 948: bf 92 push r11
  1686. 94a: cf 92 push r12
  1687. 94c: df 92 push r13
  1688. 94e: ef 92 push r14
  1689. 950: ff 92 push r15
  1690. 952: 0f 93 push r16
  1691. 954: 1f 93 push r17
  1692. 956: df 93 push r29
  1693. 958: cf 93 push r28
  1694. 95a: 00 d0 rcall .+0 ; 0x95c <printVADialig+0x26>
  1695. 95c: cd b7 in r28, 0x3d ; 61
  1696. 95e: de b7 in r29, 0x3e ; 62
  1697. 960: 9a 83 std Y+2, r25 ; 0x02
  1698. 962: 89 83 std Y+1, r24 ; 0x01
  1699. 964: 1b 01 movw r2, r22
  1700. 966: 2a 01 movw r4, r20
  1701. 968: 39 01 movw r6, r18
  1702. LCD_Goto(position, 0);
  1703. 96a: 0f 70 andi r16, 0x0F ; 15
  1704. 96c: 80 2f mov r24, r16
  1705. 96e: 80 68 ori r24, 0x80 ; 128
  1706. 970: bb d4 rcall .+2422 ; 0x12e8 <LCD_WriteCom>
  1707. LCD_SendStr(start_text);
  1708. 972: c2 01 movw r24, r4
  1709. 974: fe d4 rcall .+2556 ; 0x1372 <LCD_SendStr>
  1710. *var = eeprom_read_dword(eeprom);
  1711. 976: 89 81 ldd r24, Y+1 ; 0x01
  1712. 978: 9a 81 ldd r25, Y+2 ; 0x02
  1713. 97a: c8 d7 rcall .+3984 ; 0x190c <__eerd_dword_m8>
  1714. 97c: f3 01 movw r30, r6
  1715. 97e: 71 83 std Z+1, r23 ; 0x01
  1716. 980: 60 83 st Z, r22
  1717. dialog_id = id;
  1718. 982: 8f 89 ldd r24, Y+23 ; 0x17
  1719. 984: 80 93 4a 03 sts 0x034A, r24
  1720. USART_SendStr(start_text);
  1721. 988: c2 01 movw r24, r4
  1722. 98a: 79 d6 rcall .+3314 ; 0x167e <USART_SendStr>
  1723. USART_SendStr("\r\n");
  1724. 98c: 89 e6 ldi r24, 0x69 ; 105
  1725. 98e: 91 e0 ldi r25, 0x01 ; 1
  1726. 990: 76 d6 rcall .+3308 ; 0x167e <USART_SendStr>
  1727. USART_SendStr(start_value_text);
  1728. 992: c4 01 movw r24, r8
  1729. 994: 74 d6 rcall .+3304 ; 0x167e <USART_SendStr>
  1730. USART_PutChar(0x30+(*var/1000));
  1731. 996: f3 01 movw r30, r6
  1732. 998: 80 81 ld r24, Z
  1733. 99a: 91 81 ldd r25, Z+1 ; 0x01
  1734. 99c: 08 ee ldi r16, 0xE8 ; 232
  1735. 99e: 13 e0 ldi r17, 0x03 ; 3
  1736. 9a0: b8 01 movw r22, r16
  1737. 9a2: 19 d7 rcall .+3634 ; 0x17d6 <__udivmodhi4>
  1738. 9a4: 86 2f mov r24, r22
  1739. 9a6: 80 5d subi r24, 0xD0 ; 208
  1740. 9a8: 44 d6 rcall .+3208 ; 0x1632 <USART_PutChar>
  1741. USART_PutChar(',');
  1742. 9aa: 8c e2 ldi r24, 0x2C ; 44
  1743. 9ac: 42 d6 rcall .+3204 ; 0x1632 <USART_PutChar>
  1744. USART_PutChar(0x30+((*var%1000)/100));
  1745. 9ae: f3 01 movw r30, r6
  1746. 9b0: 80 81 ld r24, Z
  1747. 9b2: 91 81 ldd r25, Z+1 ; 0x01
  1748. 9b4: b8 01 movw r22, r16
  1749. 9b6: 0f d7 rcall .+3614 ; 0x17d6 <__udivmodhi4>
  1750. 9b8: 64 e6 ldi r22, 0x64 ; 100
  1751. 9ba: 70 e0 ldi r23, 0x00 ; 0
  1752. 9bc: 0c d7 rcall .+3608 ; 0x17d6 <__udivmodhi4>
  1753. 9be: 86 2f mov r24, r22
  1754. 9c0: 80 5d subi r24, 0xD0 ; 208
  1755. 9c2: 37 d6 rcall .+3182 ; 0x1632 <USART_PutChar>
  1756. USART_SendStr(uart_text);
  1757. 9c4: c5 01 movw r24, r10
  1758. 9c6: 5b d6 rcall .+3254 ; 0x167e <USART_SendStr>
  1759.  
  1760. LCD_Goto(5, 1);
  1761. LCD_WriteData(1);
  1762. LCD_WriteData(0x30+(*var/1000));
  1763. LCD_WriteData(',');
  1764. LCD_WriteData(0x30+((*var%1000)/100));
  1765. 9c8: b4 e6 ldi r27, 0x64 ; 100
  1766. 9ca: 8b 2e mov r8, r27
  1767. 9cc: 91 2c mov r9, r1
  1768. USART_PutChar(0x30+(*var/1000));
  1769. USART_PutChar(',');
  1770. USART_PutChar(0x30+((*var%1000)/100));
  1771. USART_SendStr(uart_text);
  1772. while(1){
  1773. i = BUT_GetBut();
  1774. 9ce: 9d d5 rcall .+2874 ; 0x150a <BUT_GetBut>
  1775. 9d0: 80 93 47 03 sts 0x0347, r24
  1776. button_event = BUT_GetBut();
  1777. 9d4: 9a d5 rcall .+2868 ; 0x150a <BUT_GetBut>
  1778. 9d6: 80 93 48 03 sts 0x0348, r24
  1779.  
  1780. if (USART_GetRxCount()){
  1781. 9da: 91 d6 rcall .+3362 ; 0x16fe <USART_GetRxCount>
  1782. 9dc: 88 23 and r24, r24
  1783. 9de: 21 f0 breq .+8 ; 0x9e8 <printVADialig+0xb2>
  1784. one_char_buffer = USART_GetChar();
  1785. 9e0: 91 d6 rcall .+3362 ; 0x1704 <USART_GetChar>
  1786. 9e2: 80 93 49 03 sts 0x0349, r24
  1787. PARS_Parser(one_char_buffer);
  1788. 9e6: 91 db rcall .-2270 ; 0x10a <PARS_Parser>
  1789. }
  1790.  
  1791. if(i == PLUS_UP_ID && button_event == BUT_PRESSED_CODE && *var < max){
  1792. 9e8: 80 91 47 03 lds r24, 0x0347
  1793. 9ec: 82 30 cpi r24, 0x02 ; 2
  1794. 9ee: 71 f4 brne .+28 ; 0xa0c <printVADialig+0xd6>
  1795. 9f0: 80 91 48 03 lds r24, 0x0348
  1796. 9f4: 81 30 cpi r24, 0x01 ; 1
  1797. 9f6: 51 f4 brne .+20 ; 0xa0c <printVADialig+0xd6>
  1798. 9f8: f3 01 movw r30, r6
  1799. 9fa: 80 81 ld r24, Z
  1800. 9fc: 91 81 ldd r25, Z+1 ; 0x01
  1801. 9fe: 8c 15 cp r24, r12
  1802. a00: 9d 05 cpc r25, r13
  1803. a02: 20 f4 brcc .+8 ; 0xa0c <printVADialig+0xd6>
  1804. *var += step;
  1805. a04: 82 0d add r24, r2
  1806. a06: 93 1d adc r25, r3
  1807. a08: 91 83 std Z+1, r25 ; 0x01
  1808. a0a: 80 83 st Z, r24
  1809. }
  1810.  
  1811. if(i == MINUS_DOWN_ID && button_event == BUT_PRESSED_CODE && *var > min){
  1812. a0c: 80 91 47 03 lds r24, 0x0347
  1813. a10: 83 30 cpi r24, 0x03 ; 3
  1814. a12: 71 f4 brne .+28 ; 0xa30 <printVADialig+0xfa>
  1815. a14: 80 91 48 03 lds r24, 0x0348
  1816. a18: 81 30 cpi r24, 0x01 ; 1
  1817. a1a: 51 f4 brne .+20 ; 0xa30 <printVADialig+0xfa>
  1818. a1c: f3 01 movw r30, r6
  1819. a1e: 80 81 ld r24, Z
  1820. a20: 91 81 ldd r25, Z+1 ; 0x01
  1821. a22: e8 16 cp r14, r24
  1822. a24: f9 06 cpc r15, r25
  1823. a26: 20 f4 brcc .+8 ; 0xa30 <printVADialig+0xfa>
  1824. *var -= step;
  1825. a28: 82 19 sub r24, r2
  1826. a2a: 93 09 sbc r25, r3
  1827. a2c: 91 83 std Z+1, r25 ; 0x01
  1828. a2e: 80 83 st Z, r24
  1829. }
  1830.  
  1831. if((i == ENTER_BUTTON_ID && button_event == BUT_PRESSED_CODE) || value_parsed_success){
  1832. a30: 80 91 47 03 lds r24, 0x0347
  1833. a34: 81 30 cpi r24, 0x01 ; 1
  1834. a36: 21 f4 brne .+8 ; 0xa40 <printVADialig+0x10a>
  1835. a38: 80 91 48 03 lds r24, 0x0348
  1836. a3c: 81 30 cpi r24, 0x01 ; 1
  1837. a3e: 21 f0 breq .+8 ; 0xa48 <printVADialig+0x112>
  1838. a40: 80 91 4e 03 lds r24, 0x034E
  1839. a44: 88 23 and r24, r24
  1840. a46: 91 f1 breq .+100 ; 0xaac <printVADialig+0x176>
  1841. if(value_parsed_success){
  1842. a48: 80 91 4e 03 lds r24, 0x034E
  1843. a4c: 88 23 and r24, r24
  1844. a4e: 49 f0 breq .+18 ; 0xa62 <printVADialig+0x12c>
  1845. *var = int_buffer;
  1846. a50: 80 91 4b 03 lds r24, 0x034B
  1847. a54: 90 91 4c 03 lds r25, 0x034C
  1848. a58: f3 01 movw r30, r6
  1849. a5a: 91 83 std Z+1, r25 ; 0x01
  1850. a5c: 80 83 st Z, r24
  1851. value_parsed_success = false;
  1852. a5e: 10 92 4e 03 sts 0x034E, r1
  1853. }
  1854. eeprom_write_dword(eeprom, *var);
  1855. a62: f3 01 movw r30, r6
  1856. a64: 40 81 ld r20, Z
  1857. a66: 51 81 ldd r21, Z+1 ; 0x01
  1858. a68: 60 e0 ldi r22, 0x00 ; 0
  1859. a6a: 70 e0 ldi r23, 0x00 ; 0
  1860. a6c: 89 81 ldd r24, Y+1 ; 0x01
  1861. a6e: 9a 81 ldd r25, Y+2 ; 0x02
  1862. a70: 68 d7 rcall .+3792 ; 0x1942 <__eewr_dword_m8>
  1863. LCD_Clear();
  1864. a72: 81 e0 ldi r24, 0x01 ; 1
  1865. a74: 39 d4 rcall .+2162 ; 0x12e8 <LCD_WriteCom>
  1866. a76: 8f e9 ldi r24, 0x9F ; 159
  1867. a78: 9f e0 ldi r25, 0x0F ; 15
  1868. a7a: 01 97 sbiw r24, 0x01 ; 1
  1869. a7c: f1 f7 brne .-4 ; 0xa7a <printVADialig+0x144>
  1870. a7e: 00 c0 rjmp .+0 ; 0xa80 <printVADialig+0x14a>
  1871. a80: 00 00 nop
  1872. LCD_WriteData(0x30+((*var%1000)/100));
  1873. LCD_WriteData(0);
  1874. BUT_Poll();
  1875. }
  1876.  
  1877. }
  1878. a82: 0f 90 pop r0
  1879. a84: 0f 90 pop r0
  1880. a86: cf 91 pop r28
  1881. a88: df 91 pop r29
  1882. a8a: 1f 91 pop r17
  1883. a8c: 0f 91 pop r16
  1884. a8e: ff 90 pop r15
  1885. a90: ef 90 pop r14
  1886. a92: df 90 pop r13
  1887. a94: cf 90 pop r12
  1888. a96: bf 90 pop r11
  1889. a98: af 90 pop r10
  1890. a9a: 9f 90 pop r9
  1891. a9c: 8f 90 pop r8
  1892. a9e: 7f 90 pop r7
  1893. aa0: 6f 90 pop r6
  1894. aa2: 5f 90 pop r5
  1895. aa4: 4f 90 pop r4
  1896. aa6: 3f 90 pop r3
  1897. aa8: 2f 90 pop r2
  1898. aaa: 08 95 ret
  1899. eeprom_write_dword(eeprom, *var);
  1900. LCD_Clear();
  1901. break;
  1902. }
  1903.  
  1904. LCD_Goto(5, 1);
  1905. aac: 85 ec ldi r24, 0xC5 ; 197
  1906. aae: 1c d4 rcall .+2104 ; 0x12e8 <LCD_WriteCom>
  1907. LCD_WriteData(1);
  1908. ab0: 81 e0 ldi r24, 0x01 ; 1
  1909. ab2: 2b d4 rcall .+2134 ; 0x130a <LCD_WriteData>
  1910. LCD_WriteData(0x30+(*var/1000));
  1911. ab4: f3 01 movw r30, r6
  1912. ab6: 80 81 ld r24, Z
  1913. ab8: 91 81 ldd r25, Z+1 ; 0x01
  1914. aba: b8 01 movw r22, r16
  1915. abc: 8c d6 rcall .+3352 ; 0x17d6 <__udivmodhi4>
  1916. abe: 86 2f mov r24, r22
  1917. ac0: 80 5d subi r24, 0xD0 ; 208
  1918. ac2: 23 d4 rcall .+2118 ; 0x130a <LCD_WriteData>
  1919. LCD_WriteData(',');
  1920. ac4: 8c e2 ldi r24, 0x2C ; 44
  1921. ac6: 21 d4 rcall .+2114 ; 0x130a <LCD_WriteData>
  1922. LCD_WriteData(0x30+((*var%1000)/100));
  1923. ac8: f3 01 movw r30, r6
  1924. aca: 80 81 ld r24, Z
  1925. acc: 91 81 ldd r25, Z+1 ; 0x01
  1926. ace: b8 01 movw r22, r16
  1927. ad0: 82 d6 rcall .+3332 ; 0x17d6 <__udivmodhi4>
  1928. ad2: b4 01 movw r22, r8
  1929. ad4: 80 d6 rcall .+3328 ; 0x17d6 <__udivmodhi4>
  1930. ad6: 86 2f mov r24, r22
  1931. ad8: 80 5d subi r24, 0xD0 ; 208
  1932. ada: 17 d4 rcall .+2094 ; 0x130a <LCD_WriteData>
  1933. LCD_WriteData(0);
  1934. adc: 80 e0 ldi r24, 0x00 ; 0
  1935. ade: 15 d4 rcall .+2090 ; 0x130a <LCD_WriteData>
  1936. BUT_Poll();
  1937. ae0: 5e d5 rcall .+2748 ; 0x159e <BUT_Poll>
  1938. }
  1939. ae2: 75 cf rjmp .-278 ; 0x9ce <printVADialig+0x98>
  1940.  
  1941. 00000ae4 <__vector_4>:
  1942.  
  1943. }
  1944.  
  1945. ISR(TIMER2_OVF_vect)
  1946. {
  1947. ae4: 1f 92 push r1
  1948. ae6: 0f 92 push r0
  1949. ae8: 0f b6 in r0, 0x3f ; 63
  1950. aea: 0f 92 push r0
  1951. aec: 11 24 eor r1, r1
  1952. aee: 8f 93 push r24
  1953. af0: 9f 93 push r25
  1954. af2: af 93 push r26
  1955. af4: bf 93 push r27
  1956. seconds_timer2++;
  1957. af6: 80 91 2d 03 lds r24, 0x032D
  1958. afa: 90 91 2e 03 lds r25, 0x032E
  1959. afe: a0 91 2f 03 lds r26, 0x032F
  1960. b02: b0 91 30 03 lds r27, 0x0330
  1961. b06: 01 96 adiw r24, 0x01 ; 1
  1962. b08: a1 1d adc r26, r1
  1963. b0a: b1 1d adc r27, r1
  1964. b0c: 80 93 2d 03 sts 0x032D, r24
  1965. b10: 90 93 2e 03 sts 0x032E, r25
  1966. b14: a0 93 2f 03 sts 0x032F, r26
  1967. b18: b0 93 30 03 sts 0x0330, r27
  1968. interrupt_data = true;
  1969. b1c: 81 e0 ldi r24, 0x01 ; 1
  1970. b1e: 80 93 31 03 sts 0x0331, r24
  1971. }
  1972. b22: bf 91 pop r27
  1973. b24: af 91 pop r26
  1974. b26: 9f 91 pop r25
  1975. b28: 8f 91 pop r24
  1976. b2a: 0f 90 pop r0
  1977. b2c: 0f be out 0x3f, r0 ; 63
  1978. b2e: 0f 90 pop r0
  1979. b30: 1f 90 pop r1
  1980. b32: 18 95 reti
  1981.  
  1982. 00000b34 <main>:
  1983.  
  1984. int main()
  1985. {
  1986. b34: 2f 92 push r2
  1987. b36: 3f 92 push r3
  1988. b38: 4f 92 push r4
  1989. b3a: 5f 92 push r5
  1990. b3c: 6f 92 push r6
  1991. b3e: 7f 92 push r7
  1992. b40: 8f 92 push r8
  1993. b42: 9f 92 push r9
  1994. b44: af 92 push r10
  1995. b46: bf 92 push r11
  1996. b48: cf 92 push r12
  1997. b4a: df 92 push r13
  1998. b4c: ef 92 push r14
  1999. b4e: ff 92 push r15
  2000. b50: 0f 93 push r16
  2001. b52: 1f 93 push r17
  2002. b54: df 93 push r29
  2003. b56: cf 93 push r28
  2004. b58: 00 d0 rcall .+0 ; 0xb5a <main+0x26>
  2005. b5a: 00 d0 rcall .+0 ; 0xb5c <main+0x28>
  2006. b5c: 00 d0 rcall .+0 ; 0xb5e <main+0x2a>
  2007. b5e: cd b7 in r28, 0x3d ; 61
  2008. b60: de b7 in r29, 0x3e ; 62
  2009. BUT_Init();
  2010. b62: e8 d4 rcall .+2512 ; 0x1534 <BUT_Init>
  2011. USART_Init(USART_DOUBLED, 9600);
  2012. b64: 81 e0 ldi r24, 0x01 ; 1
  2013. b66: 60 e8 ldi r22, 0x80 ; 128
  2014. b68: 75 e2 ldi r23, 0x25 ; 37
  2015. b6a: 2c d5 rcall .+2648 ; 0x15c4 <USART_Init>
  2016. PARS_Init();
  2017. b6c: c1 da rcall .-2686 ; 0xf0 <PARS_Init>
  2018. ShiftRegisterInit(1);
  2019. b6e: 81 e0 ldi r24, 0x01 ; 1
  2020. b70: 90 e0 ldi r25, 0x00 ; 0
  2021. b72: 7d da rcall .-2822 ; 0x6e <ShiftRegisterInit>
  2022. LCD_Init();
  2023. b74: db d3 rcall .+1974 ; 0x132c <LCD_Init>
  2024. t2_init();
  2025. b76: 9d db rcall .-2246 ; 0x2b2 <t2_init>
  2026. //ADC Init
  2027. ADCSRA = (1<<ADEN) | (0<<ADSC) | (0<<ADFR) | (0<<ADIF) | (0<<ADIE) | (1<<ADPS2) | (0<<ADPS1) | (1<<ADPS0);
  2028. b78: 85 e8 ldi r24, 0x85 ; 133
  2029. b7a: 86 b9 out 0x06, r24 ; 6
  2030.  
  2031. USART_SendStr("Initializing...\r\n");
  2032. b7c: 8c e6 ldi r24, 0x6C ; 108
  2033. b7e: 91 e0 ldi r25, 0x01 ; 1
  2034. b80: 7e d5 rcall .+2812 ; 0x167e <USART_SendStr>
  2035.  
  2036. //Конфиг ножек
  2037. DDRB |= (1 << PB1) | (1 << PB2);
  2038. b82: 87 b3 in r24, 0x17 ; 23
  2039. b84: 86 60 ori r24, 0x06 ; 6
  2040. b86: 87 bb out 0x17, r24 ; 23
  2041. DDRC &= ~((1 << PC0) | (1 << PC1) | (1 << PC3) | (1 << PC5));
  2042. b88: 84 b3 in r24, 0x14 ; 20
  2043. b8a: 84 7d andi r24, 0xD4 ; 212
  2044. b8c: 84 bb out 0x14, r24 ; 20
  2045.  
  2046. LCD_SetUserChar(leftArrow, 0);
  2047. b8e: 86 e2 ldi r24, 0x26 ; 38
  2048. b90: 90 e0 ldi r25, 0x00 ; 0
  2049. b92: 60 e0 ldi r22, 0x00 ; 0
  2050. b94: 01 d4 rcall .+2050 ; 0x1398 <LCD_SetUserChar>
  2051. LCD_SetUserChar(rightArrow, 1);
  2052. b96: 8e e2 ldi r24, 0x2E ; 46
  2053. b98: 90 e0 ldi r25, 0x00 ; 0
  2054. b9a: 61 e0 ldi r22, 0x01 ; 1
  2055. b9c: fd d3 rcall .+2042 ; 0x1398 <LCD_SetUserChar>
  2056.  
  2057.  
  2058. USART_SendStr("Last capacity:");
  2059. b9e: 8e e7 ldi r24, 0x7E ; 126
  2060. ba0: 91 e0 ldi r25, 0x01 ; 1
  2061. ba2: 6d d5 rcall .+2778 ; 0x167e <USART_SendStr>
  2062. LastCapacity = eeprom_read_dword(&eeLastCapacity);
  2063. ba4: 89 e0 ldi r24, 0x09 ; 9
  2064. ba6: 90 e0 ldi r25, 0x00 ; 0
  2065. ba8: b1 d6 rcall .+3426 ; 0x190c <__eerd_dword_m8>
  2066. baa: 60 93 33 03 sts 0x0333, r22
  2067. bae: 70 93 34 03 sts 0x0334, r23
  2068. bb2: 80 93 35 03 sts 0x0335, r24
  2069. bb6: 90 93 36 03 sts 0x0336, r25
  2070. LCD_Goto(1,0);
  2071. bba: 81 e8 ldi r24, 0x81 ; 129
  2072. bbc: 95 d3 rcall .+1834 ; 0x12e8 <LCD_WriteCom>
  2073. LCD_SendStr("Last capacity:");
  2074. bbe: 8e e7 ldi r24, 0x7E ; 126
  2075. bc0: 91 e0 ldi r25, 0x01 ; 1
  2076. bc2: d7 d3 rcall .+1966 ; 0x1372 <LCD_SendStr>
  2077. LCD_Goto(4, 1);
  2078. bc4: 84 ec ldi r24, 0xC4 ; 196
  2079. bc6: 90 d3 rcall .+1824 ; 0x12e8 <LCD_WriteCom>
  2080. printCapacity(LastCapacity, false, true);
  2081. bc8: 60 91 33 03 lds r22, 0x0333
  2082. bcc: 70 91 34 03 lds r23, 0x0334
  2083. bd0: 80 91 35 03 lds r24, 0x0335
  2084. bd4: 90 91 36 03 lds r25, 0x0336
  2085. bd8: 40 e0 ldi r20, 0x00 ; 0
  2086. bda: 21 e0 ldi r18, 0x01 ; 1
  2087. bdc: fb dc rcall .-1546 ; 0x5d4 <printCapacity>
  2088. LCD_SendStr("mAh");
  2089. bde: 86 ef ldi r24, 0xF6 ; 246
  2090. be0: 90 e0 ldi r25, 0x00 ; 0
  2091. be2: c7 d3 rcall .+1934 ; 0x1372 <LCD_SendStr>
  2092. USART_SendStr(" mAh\r\n");
  2093. be4: 8f ee ldi r24, 0xEF ; 239
  2094. be6: 90 e0 ldi r25, 0x00 ; 0
  2095. be8: 4a d5 rcall .+2708 ; 0x167e <USART_SendStr>
  2096. bea: 8f ef ldi r24, 0xFF ; 255
  2097. bec: 98 e0 ldi r25, 0x08 ; 8
  2098. bee: ad e3 ldi r26, 0x3D ; 61
  2099. bf0: 81 50 subi r24, 0x01 ; 1
  2100. bf2: 90 40 sbci r25, 0x00 ; 0
  2101. bf4: a0 40 sbci r26, 0x00 ; 0
  2102. bf6: e1 f7 brne .-8 ; 0xbf0 <main+0xbc>
  2103. bf8: 00 c0 rjmp .+0 ; 0xbfa <main+0xc6>
  2104. bfa: 00 00 nop
  2105. _delay_ms(2500);
  2106.  
  2107. checkBattery(false, false);
  2108. bfc: 80 e0 ldi r24, 0x00 ; 0
  2109. bfe: 60 e0 ldi r22, 0x00 ; 0
  2110. c00: 41 dc rcall .-1918 ; 0x484 <checkBattery>
  2111.  
  2112. if(eeprom_read_byte(&eepause_continue) == 1){
  2113. c02: 88 e0 ldi r24, 0x08 ; 8
  2114. c04: 90 e0 ldi r25, 0x00 ; 0
  2115. c06: 7a d6 rcall .+3316 ; 0x18fc <__eerd_byte_m8>
  2116. c08: 81 30 cpi r24, 0x01 ; 1
  2117. c0a: 09 f0 breq .+2 ; 0xc0e <main+0xda>
  2118. c0c: 45 c0 rjmp .+138 ; 0xc98 <main+0x164>
  2119. LCD_Clear();
  2120. c0e: 6c d3 rcall .+1752 ; 0x12e8 <LCD_WriteCom>
  2121. c10: af e9 ldi r26, 0x9F ; 159
  2122. c12: bf e0 ldi r27, 0x0F ; 15
  2123. c14: 11 97 sbiw r26, 0x01 ; 1
  2124. c16: f1 f7 brne .-4 ; 0xc14 <main+0xe0>
  2125. c18: 00 c0 rjmp .+0 ; 0xc1a <main+0xe6>
  2126. c1a: 00 00 nop
  2127. LCD_Goto(0,0);
  2128. c1c: 80 e8 ldi r24, 0x80 ; 128
  2129. c1e: 64 d3 rcall .+1736 ; 0x12e8 <LCD_WriteCom>
  2130. LCD_SendStr("Continue test?");
  2131. c20: 8d e8 ldi r24, 0x8D ; 141
  2132. c22: 91 e0 ldi r25, 0x01 ; 1
  2133. c24: a6 d3 rcall .+1868 ; 0x1372 <LCD_SendStr>
  2134. USART_SendStr("Continue test? (Y/N)\r\n");
  2135. c26: 8c e9 ldi r24, 0x9C ; 156
  2136. c28: 91 e0 ldi r25, 0x01 ; 1
  2137. c2a: 29 d5 rcall .+2642 ; 0x167e <USART_SendStr>
  2138. while(1){
  2139. i = BUT_GetBut();
  2140. c2c: 6e d4 rcall .+2268 ; 0x150a <BUT_GetBut>
  2141. c2e: 80 93 47 03 sts 0x0347, r24
  2142. button_event = BUT_GetBut();
  2143. c32: 6b d4 rcall .+2262 ; 0x150a <BUT_GetBut>
  2144. c34: 80 93 48 03 sts 0x0348, r24
  2145. one_char_buffer = USART_GetChar();
  2146. c38: 65 d5 rcall .+2762 ; 0x1704 <USART_GetChar>
  2147. c3a: 80 93 49 03 sts 0x0349, r24
  2148.  
  2149. if((i == PLUS_UP_ID && button_event == BUT_PRESSED_CODE) || one_char_buffer == 'Y' || one_char_buffer == 'y'){
  2150. c3e: 90 91 47 03 lds r25, 0x0347
  2151. c42: 92 30 cpi r25, 0x02 ; 2
  2152. c44: 21 f4 brne .+8 ; 0xc4e <main+0x11a>
  2153. c46: 20 91 48 03 lds r18, 0x0348
  2154. c4a: 21 30 cpi r18, 0x01 ; 1
  2155. c4c: 21 f0 breq .+8 ; 0xc56 <main+0x122>
  2156. c4e: 89 35 cpi r24, 0x59 ; 89
  2157. c50: 11 f0 breq .+4 ; 0xc56 <main+0x122>
  2158. c52: 89 37 cpi r24, 0x79 ; 121
  2159. c54: 21 f4 brne .+8 ; 0xc5e <main+0x12a>
  2160. pause_continue = 1;
  2161. c56: 81 e0 ldi r24, 0x01 ; 1
  2162. c58: 80 93 57 03 sts 0x0357, r24
  2163. break;
  2164. c5c: 15 c0 rjmp .+42 ; 0xc88 <main+0x154>
  2165. }
  2166.  
  2167. if(((i == MINUS_DOWN_ID && button_event == BUT_PRESSED_CODE) || (i == ENTER_BUTTON_ID && button_event == BUT_PRESSED_CODE)) || one_char_buffer == 'N' || one_char_buffer == 'n'){
  2168. c5e: 93 30 cpi r25, 0x03 ; 3
  2169. c60: 11 f0 breq .+4 ; 0xc66 <main+0x132>
  2170. c62: 91 30 cpi r25, 0x01 ; 1
  2171. c64: 21 f4 brne .+8 ; 0xc6e <main+0x13a>
  2172. c66: 90 91 48 03 lds r25, 0x0348
  2173. c6a: 91 30 cpi r25, 0x01 ; 1
  2174. c6c: 21 f0 breq .+8 ; 0xc76 <main+0x142>
  2175. c6e: 8e 34 cpi r24, 0x4E ; 78
  2176. c70: 11 f0 breq .+4 ; 0xc76 <main+0x142>
  2177. c72: 8e 36 cpi r24, 0x6E ; 110
  2178. c74: 39 f4 brne .+14 ; 0xc84 <main+0x150>
  2179. eeprom_write_byte(&eepause_continue, 0);
  2180. c76: 88 e0 ldi r24, 0x08 ; 8
  2181. c78: 90 e0 ldi r25, 0x00 ; 0
  2182. c7a: 60 e0 ldi r22, 0x00 ; 0
  2183. c7c: 55 d6 rcall .+3242 ; 0x1928 <__eewr_byte_m8>
  2184. pause_continue = 0;
  2185. c7e: 10 92 57 03 sts 0x0357, r1
  2186. break;
  2187. c82: 02 c0 rjmp .+4 ; 0xc88 <main+0x154>
  2188. }
  2189. BUT_Poll();
  2190. c84: 8c d4 rcall .+2328 ; 0x159e <BUT_Poll>
  2191. }
  2192. c86: d2 cf rjmp .-92 ; 0xc2c <main+0xf8>
  2193. LCD_Clear();
  2194. c88: 81 e0 ldi r24, 0x01 ; 1
  2195. c8a: 2e d3 rcall .+1628 ; 0x12e8 <LCD_WriteCom>
  2196. c8c: ef e9 ldi r30, 0x9F ; 159
  2197. c8e: ff e0 ldi r31, 0x0F ; 15
  2198. c90: 31 97 sbiw r30, 0x01 ; 1
  2199. c92: f1 f7 brne .-4 ; 0xc90 <main+0x15c>
  2200. c94: 00 c0 rjmp .+0 ; 0xc96 <main+0x162>
  2201. c96: 00 00 nop
  2202. }
  2203. if(pause_continue == 0){
  2204. c98: 80 91 57 03 lds r24, 0x0357
  2205. c9c: 88 23 and r24, r24
  2206. c9e: 09 f0 breq .+2 ; 0xca2 <main+0x16e>
  2207. ca0: a6 c0 rjmp .+332 ; 0xdee <main+0x2ba>
  2208. //Диалог зарядки
  2209. if(read_adc(VOLTAGE_MUX_CHANNEL) < CALC_ADC_VOLTAGE(CHARGE_DIALOG_VALUE)){
  2210. ca2: 12 db rcall .-2524 ; 0x2c8 <read_adc>
  2211. ca4: f6 e0 ldi r31, 0x06 ; 6
  2212. ca6: 82 35 cpi r24, 0x52 ; 82
  2213. ca8: 9f 07 cpc r25, r31
  2214. caa: 08 f0 brcs .+2 ; 0xcae <main+0x17a>
  2215. cac: 47 c0 rjmp .+142 ; 0xd3c <main+0x208>
  2216. LCD_Clear();
  2217. cae: 81 e0 ldi r24, 0x01 ; 1
  2218. cb0: 1b d3 rcall .+1590 ; 0x12e8 <LCD_WriteCom>
  2219. cb2: 8f e9 ldi r24, 0x9F ; 159
  2220. cb4: 9f e0 ldi r25, 0x0F ; 15
  2221. cb6: 01 97 sbiw r24, 0x01 ; 1
  2222. cb8: f1 f7 brne .-4 ; 0xcb6 <main+0x182>
  2223. cba: 00 c0 rjmp .+0 ; 0xcbc <main+0x188>
  2224. cbc: 00 00 nop
  2225. LCD_Goto(0,0);
  2226. cbe: 80 e8 ldi r24, 0x80 ; 128
  2227. cc0: 13 d3 rcall .+1574 ; 0x12e8 <LCD_WriteCom>
  2228. LCD_SendStr("Charge");
  2229. cc2: 83 eb ldi r24, 0xB3 ; 179
  2230. cc4: 91 e0 ldi r25, 0x01 ; 1
  2231. cc6: 55 d3 rcall .+1706 ; 0x1372 <LCD_SendStr>
  2232. LCD_Goto(0,1);
  2233. cc8: 80 ec ldi r24, 0xC0 ; 192
  2234. cca: 0e d3 rcall .+1564 ; 0x12e8 <LCD_WriteCom>
  2235. LCD_SendStr("the battery?");
  2236. ccc: 8a eb ldi r24, 0xBA ; 186
  2237. cce: 91 e0 ldi r25, 0x01 ; 1
  2238. cd0: 50 d3 rcall .+1696 ; 0x1372 <LCD_SendStr>
  2239. USART_SendStr("Charge the battery? (Y/N)\r\n");
  2240. cd2: 87 ec ldi r24, 0xC7 ; 199
  2241. cd4: 91 e0 ldi r25, 0x01 ; 1
  2242. cd6: d3 d4 rcall .+2470 ; 0x167e <USART_SendStr>
  2243. while(1){
  2244. i = BUT_GetBut();
  2245. cd8: 18 d4 rcall .+2096 ; 0x150a <BUT_GetBut>
  2246. cda: 80 93 47 03 sts 0x0347, r24
  2247. button_event = BUT_GetBut();
  2248. cde: 15 d4 rcall .+2090 ; 0x150a <BUT_GetBut>
  2249. ce0: 80 93 48 03 sts 0x0348, r24
  2250. one_char_buffer = USART_GetChar();
  2251. ce4: 0f d5 rcall .+2590 ; 0x1704 <USART_GetChar>
  2252. ce6: 80 93 49 03 sts 0x0349, r24
  2253.  
  2254. if((i == PLUS_UP_ID && button_event == BUT_PRESSED_CODE) || one_char_buffer == 'Y' || one_char_buffer == 'y'){
  2255. cea: 90 91 47 03 lds r25, 0x0347
  2256. cee: 92 30 cpi r25, 0x02 ; 2
  2257. cf0: 21 f4 brne .+8 ; 0xcfa <main+0x1c6>
  2258. cf2: 20 91 48 03 lds r18, 0x0348
  2259. cf6: 21 30 cpi r18, 0x01 ; 1
  2260. cf8: 21 f0 breq .+8 ; 0xd02 <main+0x1ce>
  2261. cfa: 89 35 cpi r24, 0x59 ; 89
  2262. cfc: 11 f0 breq .+4 ; 0xd02 <main+0x1ce>
  2263. cfe: 89 37 cpi r24, 0x79 ; 121
  2264. d00: 21 f4 brne .+8 ; 0xd0a <main+0x1d6>
  2265. charge_before = true;
  2266. d02: 81 e0 ldi r24, 0x01 ; 1
  2267. d04: 80 93 32 03 sts 0x0332, r24
  2268. break;
  2269. d08: 11 c0 rjmp .+34 ; 0xd2c <main+0x1f8>
  2270. }
  2271.  
  2272. if(((i == MINUS_DOWN_ID && button_event == BUT_PRESSED_CODE) || (i == ENTER_BUTTON_ID && button_event == BUT_PRESSED_CODE)) || one_char_buffer == 'N' || one_char_buffer == 'n'){
  2273. d0a: 93 30 cpi r25, 0x03 ; 3
  2274. d0c: 11 f0 breq .+4 ; 0xd12 <main+0x1de>
  2275. d0e: 91 30 cpi r25, 0x01 ; 1
  2276. d10: 21 f4 brne .+8 ; 0xd1a <main+0x1e6>
  2277. d12: 90 91 48 03 lds r25, 0x0348
  2278. d16: 91 30 cpi r25, 0x01 ; 1
  2279. d18: 21 f0 breq .+8 ; 0xd22 <main+0x1ee>
  2280. d1a: 8e 34 cpi r24, 0x4E ; 78
  2281. d1c: 11 f0 breq .+4 ; 0xd22 <main+0x1ee>
  2282. d1e: 8e 36 cpi r24, 0x6E ; 110
  2283. d20: 19 f4 brne .+6 ; 0xd28 <main+0x1f4>
  2284. charge_before = false;
  2285. d22: 10 92 32 03 sts 0x0332, r1
  2286. break;
  2287. d26: 02 c0 rjmp .+4 ; 0xd2c <main+0x1f8>
  2288. }
  2289. BUT_Poll();
  2290. d28: 3a d4 rcall .+2164 ; 0x159e <BUT_Poll>
  2291. }
  2292. d2a: d6 cf rjmp .-84 ; 0xcd8 <main+0x1a4>
  2293. LCD_Clear();
  2294. d2c: 81 e0 ldi r24, 0x01 ; 1
  2295. d2e: dc d2 rcall .+1464 ; 0x12e8 <LCD_WriteCom>
  2296. d30: af e9 ldi r26, 0x9F ; 159
  2297. d32: bf e0 ldi r27, 0x0F ; 15
  2298. d34: 11 97 sbiw r26, 0x01 ; 1
  2299. d36: f1 f7 brne .-4 ; 0xd34 <main+0x200>
  2300. d38: 00 c0 rjmp .+0 ; 0xd3a <main+0x206>
  2301. d3a: 00 00 nop
  2302. }
  2303.  
  2304. //Установка параметров
  2305. printVADialig(&eeI, AMPERAGE_STEP, "Current:", &I_set, 4, AMPERAGE_MIN, AMPERAGE_MAX, "\r\nSend value 100-2000 with step 100 (or send ok):\r\n", "Default value:", AMPERAGE_DIALOG);
  2306. d3c: 0f 92 push r0
  2307. d3e: 82 e0 ldi r24, 0x02 ; 2
  2308. d40: ed b7 in r30, 0x3d ; 61
  2309. d42: fe b7 in r31, 0x3e ; 62
  2310. d44: 81 83 std Z+1, r24 ; 0x01
  2311. d46: 8d e0 ldi r24, 0x0D ; 13
  2312. d48: 90 e0 ldi r25, 0x00 ; 0
  2313. d4a: 64 e6 ldi r22, 0x64 ; 100
  2314. d4c: 70 e0 ldi r23, 0x00 ; 0
  2315. d4e: 43 ee ldi r20, 0xE3 ; 227
  2316. d50: 51 e0 ldi r21, 0x01 ; 1
  2317. d52: 27 e2 ldi r18, 0x27 ; 39
  2318. d54: 33 e0 ldi r19, 0x03 ; 3
  2319. d56: 04 e0 ldi r16, 0x04 ; 4
  2320. d58: 10 e0 ldi r17, 0x00 ; 0
  2321. d5a: b4 e6 ldi r27, 0x64 ; 100
  2322. d5c: eb 2e mov r14, r27
  2323. d5e: f1 2c mov r15, r1
  2324. d60: a0 ed ldi r26, 0xD0 ; 208
  2325. d62: ca 2e mov r12, r26
  2326. d64: a7 e0 ldi r26, 0x07 ; 7
  2327. d66: da 2e mov r13, r26
  2328. d68: fc ee ldi r31, 0xEC ; 236
  2329. d6a: af 2e mov r10, r31
  2330. d6c: f1 e0 ldi r31, 0x01 ; 1
  2331. d6e: bf 2e mov r11, r31
  2332. d70: e0 e2 ldi r30, 0x20 ; 32
  2333. d72: 8e 2e mov r8, r30
  2334. d74: e2 e0 ldi r30, 0x02 ; 2
  2335. d76: 9e 2e mov r9, r30
  2336. d78: de dd rcall .-1092 ; 0x936 <printVADialig>
  2337. printVADialig(&eeEND_Voltage, VOLTAGE_STEP, "End voltage:", &END_Voltage, 2, VOLTAGE_MIN, VOLTAGE_MAX, "\r\nSend value 2500-3500 with step 100 (or send ok):\r\n", "Default value:", VOLTAGE_DIALOG);
  2338. d7a: 81 e0 ldi r24, 0x01 ; 1
  2339. d7c: ad b7 in r26, 0x3d ; 61
  2340. d7e: be b7 in r27, 0x3e ; 62
  2341. d80: 11 96 adiw r26, 0x01 ; 1
  2342. d82: 8c 93 st X, r24
  2343. d84: 85 e1 ldi r24, 0x15 ; 21
  2344. d86: 90 e0 ldi r25, 0x00 ; 0
  2345. d88: 64 e6 ldi r22, 0x64 ; 100
  2346. d8a: 70 e0 ldi r23, 0x00 ; 0
  2347. d8c: 4f e2 ldi r20, 0x2F ; 47
  2348. d8e: 52 e0 ldi r21, 0x02 ; 2
  2349. d90: 25 e2 ldi r18, 0x25 ; 37
  2350. d92: 33 e0 ldi r19, 0x03 ; 3
  2351. d94: 02 e0 ldi r16, 0x02 ; 2
  2352. d96: 10 e0 ldi r17, 0x00 ; 0
  2353. d98: b4 ec ldi r27, 0xC4 ; 196
  2354. d9a: eb 2e mov r14, r27
  2355. d9c: b9 e0 ldi r27, 0x09 ; 9
  2356. d9e: fb 2e mov r15, r27
  2357. da0: ac ea ldi r26, 0xAC ; 172
  2358. da2: ca 2e mov r12, r26
  2359. da4: ad e0 ldi r26, 0x0D ; 13
  2360. da6: da 2e mov r13, r26
  2361. da8: fc e3 ldi r31, 0x3C ; 60
  2362. daa: af 2e mov r10, r31
  2363. dac: f2 e0 ldi r31, 0x02 ; 2
  2364. dae: bf 2e mov r11, r31
  2365. db0: c2 dd rcall .-1148 ; 0x936 <printVADialig>
  2366.  
  2367. //Зарядка перед тестом
  2368. if(charge_before){
  2369. db2: 0f 90 pop r0
  2370. db4: 80 91 32 03 lds r24, 0x0332
  2371. db8: 88 23 and r24, r24
  2372. dba: 51 f0 breq .+20 ; 0xdd0 <main+0x29c>
  2373. LCD_Clear();
  2374. dbc: 81 e0 ldi r24, 0x01 ; 1
  2375. dbe: 94 d2 rcall .+1320 ; 0x12e8 <LCD_WriteCom>
  2376. dc0: ef e9 ldi r30, 0x9F ; 159
  2377. dc2: ff e0 ldi r31, 0x0F ; 15
  2378. dc4: 31 97 sbiw r30, 0x01 ; 1
  2379. dc6: f1 f7 brne .-4 ; 0xdc4 <main+0x290>
  2380. dc8: 00 c0 rjmp .+0 ; 0xdca <main+0x296>
  2381. dca: 00 00 nop
  2382. Charge_battery(false);
  2383. dcc: 80 e0 ldi r24, 0x00 ; 0
  2384. dce: 78 dc rcall .-1808 ; 0x6c0 <Charge_battery>
  2385. }
  2386.  
  2387. USART_SendStr("Press any key to start the test...\r\n");
  2388. dd0: 81 e7 ldi r24, 0x71 ; 113
  2389. dd2: 92 e0 ldi r25, 0x02 ; 2
  2390. dd4: 54 d4 rcall .+2216 ; 0x167e <USART_SendStr>
  2391.  
  2392. LCD_Goto(0,0);
  2393. dd6: 80 e8 ldi r24, 0x80 ; 128
  2394. dd8: 87 d2 rcall .+1294 ; 0x12e8 <LCD_WriteCom>
  2395. LCD_SendStr("Press start to");
  2396. dda: 86 e9 ldi r24, 0x96 ; 150
  2397. ddc: 92 e0 ldi r25, 0x02 ; 2
  2398. dde: c9 d2 rcall .+1426 ; 0x1372 <LCD_SendStr>
  2399. LCD_Goto(0,1);
  2400. de0: 80 ec ldi r24, 0xC0 ; 192
  2401. de2: 82 d2 rcall .+1284 ; 0x12e8 <LCD_WriteCom>
  2402. LCD_SendStr("begin the test");
  2403. de4: 85 ea ldi r24, 0xA5 ; 165
  2404. de6: 92 e0 ldi r25, 0x02 ; 2
  2405. de8: c4 d2 rcall .+1416 ; 0x1372 <LCD_SendStr>
  2406.  
  2407.  
  2408. Reset_Button();
  2409. dea: a8 db rcall .-2224 ; 0x53c <Reset_Button>
  2410. dec: 2b c0 rjmp .+86 ; 0xe44 <main+0x310>
  2411. }else{
  2412. eeprom_read_block ((void *)&PauseSave, (const void *)&eePauseSave, 8);
  2413. dee: 8f e4 ldi r24, 0x4F ; 79
  2414. df0: 93 e0 ldi r25, 0x03 ; 3
  2415. df2: 60 e0 ldi r22, 0x00 ; 0
  2416. df4: 70 e0 ldi r23, 0x00 ; 0
  2417. df6: 48 e0 ldi r20, 0x08 ; 8
  2418. df8: 50 e0 ldi r21, 0x00 ; 0
  2419. dfa: 70 d5 rcall .+2784 ; 0x18dc <__eerd_block_m8>
  2420. eeprom_write_byte(&eepause_continue, 0);
  2421. dfc: 88 e0 ldi r24, 0x08 ; 8
  2422. dfe: 90 e0 ldi r25, 0x00 ; 0
  2423. e00: 60 e0 ldi r22, 0x00 ; 0
  2424. e02: 92 d5 rcall .+2852 ; 0x1928 <__eewr_byte_m8>
  2425. Capacity = PauseSave[0];
  2426. e04: 80 91 4f 03 lds r24, 0x034F
  2427. e08: 90 91 50 03 lds r25, 0x0350
  2428. e0c: a0 91 51 03 lds r26, 0x0351
  2429. e10: b0 91 52 03 lds r27, 0x0352
  2430. e14: 80 93 3b 03 sts 0x033B, r24
  2431. e18: 90 93 3c 03 sts 0x033C, r25
  2432. e1c: a0 93 3d 03 sts 0x033D, r26
  2433. e20: b0 93 3e 03 sts 0x033E, r27
  2434. seconds_timer2 = PauseSave[1];
  2435. e24: 80 91 53 03 lds r24, 0x0353
  2436. e28: 90 91 54 03 lds r25, 0x0354
  2437. e2c: a0 91 55 03 lds r26, 0x0355
  2438. e30: b0 91 56 03 lds r27, 0x0356
  2439. e34: 80 93 2d 03 sts 0x032D, r24
  2440. e38: 90 93 2e 03 sts 0x032E, r25
  2441. e3c: a0 93 2f 03 sts 0x032F, r26
  2442. e40: b0 93 30 03 sts 0x0330, r27
  2443. }
  2444.  
  2445. USART_SendStr("Starting...\r\n");
  2446. e44: 84 eb ldi r24, 0xB4 ; 180
  2447. e46: 92 e0 ldi r25, 0x02 ; 2
  2448. e48: 1a d4 rcall .+2100 ; 0x167e <USART_SendStr>
  2449. LCD_Clear();
  2450. e4a: 81 e0 ldi r24, 0x01 ; 1
  2451. e4c: 4d d2 rcall .+1178 ; 0x12e8 <LCD_WriteCom>
  2452. e4e: 8f e9 ldi r24, 0x9F ; 159
  2453. e50: 9f e0 ldi r25, 0x0F ; 15
  2454. e52: 01 97 sbiw r24, 0x01 ; 1
  2455. e54: f1 f7 brne .-4 ; 0xe52 <main+0x31e>
  2456. e56: 00 c0 rjmp .+0 ; 0xe58 <main+0x324>
  2457. e58: 00 00 nop
  2458.  
  2459. USART_SendStr("Seconds | Voltage | Amperage | Time | mAh\r\n");
  2460. e5a: 82 ec ldi r24, 0xC2 ; 194
  2461. e5c: 92 e0 ldi r25, 0x02 ; 2
  2462. e5e: 0f d4 rcall .+2078 ; 0x167e <USART_SendStr>
  2463.  
  2464. //ШИМ электронной нагрузки
  2465. TCCR1A |= (1 << COM1A1) | (1 << COM1B1);
  2466. e60: 8f b5 in r24, 0x2f ; 47
  2467. e62: 80 6a ori r24, 0xA0 ; 160
  2468. e64: 8f bd out 0x2f, r24 ; 47
  2469. TCCR1A |= (1 << WGM11) | (1 << WGM10);
  2470. e66: 8f b5 in r24, 0x2f ; 47
  2471. e68: 83 60 ori r24, 0x03 ; 3
  2472. e6a: 8f bd out 0x2f, r24 ; 47
  2473. TCCR1B |= (1 << CS11);
  2474. e6c: 8e b5 in r24, 0x2e ; 46
  2475. e6e: 82 60 ori r24, 0x02 ; 2
  2476. e70: 8e bd out 0x2e, r24 ; 46
  2477. OCR1A = AMPERAGE_PWM_COEFFICIENT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP)+AMPERAGE_PWM_COEFFICIENT_CORRECT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP);
  2478. e72: 80 91 27 03 lds r24, 0x0327
  2479. e76: 90 91 28 03 lds r25, 0x0328
  2480. e7a: 64 e6 ldi r22, 0x64 ; 100
  2481. e7c: 70 e0 ldi r23, 0x00 ; 0
  2482. e7e: ab d4 rcall .+2390 ; 0x17d6 <__udivmodhi4>
  2483. e80: 2c e2 ldi r18, 0x2C ; 44
  2484. e82: 30 e0 ldi r19, 0x00 ; 0
  2485. e84: 62 9f mul r22, r18
  2486. e86: c0 01 movw r24, r0
  2487. e88: 63 9f mul r22, r19
  2488. e8a: 90 0d add r25, r0
  2489. e8c: 72 9f mul r23, r18
  2490. e8e: 90 0d add r25, r0
  2491. e90: 11 24 eor r1, r1
  2492. e92: 9b bd out 0x2b, r25 ; 43
  2493. e94: 8a bd out 0x2a, r24 ; 42
  2494. OCR1B = 0;
  2495. e96: 19 bc out 0x29, r1 ; 41
  2496. e98: 18 bc out 0x28, r1 ; 40
  2497. //Подключение АКБ
  2498. BATTERY_ON;
  2499. e9a: 86 e0 ldi r24, 0x06 ; 6
  2500. e9c: 90 e0 ldi r25, 0x00 ; 0
  2501. e9e: 61 e0 ldi r22, 0x01 ; 1
  2502. ea0: 70 e0 ldi r23, 0x00 ; 0
  2503. ea2: 40 e0 ldi r20, 0x00 ; 0
  2504. ea4: 50 e0 ldi r21, 0x00 ; 0
  2505. ea6: fc d8 rcall .-3592 ; 0xa0 <ShiftDigitalWrite>
  2506.  
  2507. //Включение таймера времени
  2508. TIMSK |= (1 << TOIE2);
  2509. ea8: 89 b7 in r24, 0x39 ; 57
  2510. eaa: 80 64 ori r24, 0x40 ; 64
  2511. eac: 89 bf out 0x39, r24 ; 57
  2512.  
  2513. //Разрешение прерываний
  2514. sei();
  2515. eae: 78 94 sei
  2516. //Измерение емкости
  2517. Capacity += I;
  2518.  
  2519. //Вывод секунд
  2520. char buffer[6];
  2521. ltoa((long)seconds(), buffer, 10);
  2522. eb0: 1e 01 movw r2, r28
  2523. eb2: 08 94 sec
  2524. eb4: 21 1c adc r2, r1
  2525. eb6: 31 1c adc r3, r1
  2526.  
  2527. USART_PutChar(' ');
  2528.  
  2529. //Вывод Тока
  2530. LCD_Goto(6,0);
  2531. printUL(I/1000);
  2532. eb8: e8 ee ldi r30, 0xE8 ; 232
  2533. eba: 8e 2e mov r8, r30
  2534. ebc: e3 e0 ldi r30, 0x03 ; 3
  2535. ebe: 9e 2e mov r9, r30
  2536. ec0: a1 2c mov r10, r1
  2537. ec2: b1 2c mov r11, r1
  2538. LCD_WriteData('.');
  2539. USART_PutChar('.');
  2540. printUL(I%1000/100);
  2541. USART_PutChar(0x30+(I%1000)%100/10);
  2542. ec4: 7a e0 ldi r23, 0x0A ; 10
  2543. ec6: 47 2e mov r4, r23
  2544. ec8: 51 2c mov r5, r1
  2545. eca: 61 2c mov r6, r1
  2546. ecc: 71 2c mov r7, r1
  2547. //Разрешение прерываний
  2548. sei();
  2549.  
  2550. while(1)
  2551. {
  2552. coolerCalc();
  2553. ece: a1 da rcall .-2750 ; 0x412 <coolerCalc>
  2554. checkBattery(true, true);
  2555. ed0: 81 e0 ldi r24, 0x01 ; 1
  2556. ed2: 61 e0 ldi r22, 0x01 ; 1
  2557. ed4: d7 da rcall .-2642 ; 0x484 <checkBattery>
  2558. //Темапературная защита
  2559. checkTempPotection();
  2560. ed6: 48 db rcall .-2416 ; 0x568 <checkTempPotection>
  2561.  
  2562. if(interrupt_data) {
  2563. ed8: 80 91 31 03 lds r24, 0x0331
  2564. edc: 88 23 and r24, r24
  2565. ede: 09 f4 brne .+2 ; 0xee2 <main+0x3ae>
  2566. ee0: fc c0 rjmp .+504 ; 0x10da <main+0x5a6>
  2567. Voltage = ((read_adc(VOLTAGE_MUX_CHANNEL)*12)/4)*10;
  2568. ee2: 80 e0 ldi r24, 0x00 ; 0
  2569. ee4: f1 d9 rcall .-3102 ; 0x2c8 <read_adc>
  2570. ee6: 9c 01 movw r18, r24
  2571. ee8: 22 0f add r18, r18
  2572. eea: 33 1f adc r19, r19
  2573. eec: 28 0f add r18, r24
  2574. eee: 39 1f adc r19, r25
  2575. ef0: 3f 73 andi r19, 0x3F ; 63
  2576. ef2: c9 01 movw r24, r18
  2577. ef4: 88 0f add r24, r24
  2578. ef6: 99 1f adc r25, r25
  2579. ef8: 43 e0 ldi r20, 0x03 ; 3
  2580. efa: 22 0f add r18, r18
  2581. efc: 33 1f adc r19, r19
  2582. efe: 4a 95 dec r20
  2583. f00: e1 f7 brne .-8 ; 0xefa <main+0x3c6>
  2584. f02: 82 0f add r24, r18
  2585. f04: 93 1f adc r25, r19
  2586. f06: a0 e0 ldi r26, 0x00 ; 0
  2587. f08: b0 e0 ldi r27, 0x00 ; 0
  2588. f0a: 80 93 43 03 sts 0x0343, r24
  2589. f0e: 90 93 44 03 sts 0x0344, r25
  2590. f12: a0 93 45 03 sts 0x0345, r26
  2591. f16: b0 93 46 03 sts 0x0346, r27
  2592. I = read_adc(CURRENT_MUX_CHANNEL)*10;
  2593. f1a: 81 e0 ldi r24, 0x01 ; 1
  2594. f1c: d5 d9 rcall .-3158 ; 0x2c8 <read_adc>
  2595. f1e: 9c 01 movw r18, r24
  2596. f20: 88 0f add r24, r24
  2597. f22: 99 1f adc r25, r25
  2598. f24: 13 e0 ldi r17, 0x03 ; 3
  2599. f26: 22 0f add r18, r18
  2600. f28: 33 1f adc r19, r19
  2601. f2a: 1a 95 dec r17
  2602. f2c: e1 f7 brne .-8 ; 0xf26 <main+0x3f2>
  2603. f2e: 82 0f add r24, r18
  2604. f30: 93 1f adc r25, r19
  2605. f32: 9c 01 movw r18, r24
  2606. f34: 40 e0 ldi r20, 0x00 ; 0
  2607. f36: 50 e0 ldi r21, 0x00 ; 0
  2608. f38: 20 93 3f 03 sts 0x033F, r18
  2609. f3c: 30 93 40 03 sts 0x0340, r19
  2610. f40: 40 93 41 03 sts 0x0341, r20
  2611. f44: 50 93 42 03 sts 0x0342, r21
  2612.  
  2613. //Измерение емкости
  2614. Capacity += I;
  2615. f48: 80 91 3b 03 lds r24, 0x033B
  2616. f4c: 90 91 3c 03 lds r25, 0x033C
  2617. f50: a0 91 3d 03 lds r26, 0x033D
  2618. f54: b0 91 3e 03 lds r27, 0x033E
  2619. f58: 82 0f add r24, r18
  2620. f5a: 93 1f adc r25, r19
  2621. f5c: a4 1f adc r26, r20
  2622. f5e: b5 1f adc r27, r21
  2623. f60: 80 93 3b 03 sts 0x033B, r24
  2624. f64: 90 93 3c 03 sts 0x033C, r25
  2625. f68: a0 93 3d 03 sts 0x033D, r26
  2626. f6c: b0 93 3e 03 sts 0x033E, r27
  2627.  
  2628. //Вывод секунд
  2629. char buffer[6];
  2630. ltoa((long)seconds(), buffer, 10);
  2631. f70: 51 d9 rcall .-3422 ; 0x214 <seconds>
  2632. f72: a1 01 movw r20, r2
  2633. f74: 2a e0 ldi r18, 0x0A ; 10
  2634. f76: 30 e0 ldi r19, 0x00 ; 0
  2635. f78: 7f d4 rcall .+2302 ; 0x1878 <ltoa>
  2636. USART_SendStr(buffer);
  2637. f7a: c1 01 movw r24, r2
  2638. f7c: 80 d3 rcall .+1792 ; 0x167e <USART_SendStr>
  2639. USART_PutChar(' ');
  2640. f7e: 80 e2 ldi r24, 0x20 ; 32
  2641. f80: 58 d3 rcall .+1712 ; 0x1632 <USART_PutChar>
  2642.  
  2643.  
  2644. //Вывод напряжения
  2645. LCD_Goto(0,0);
  2646. f82: 80 e8 ldi r24, 0x80 ; 128
  2647. f84: b1 d1 rcall .+866 ; 0x12e8 <LCD_WriteCom>
  2648. printVoltage(Voltage);
  2649. f86: 60 91 43 03 lds r22, 0x0343
  2650. f8a: 70 91 44 03 lds r23, 0x0344
  2651. f8e: 80 91 45 03 lds r24, 0x0345
  2652. f92: 90 91 46 03 lds r25, 0x0346
  2653. f96: e5 d9 rcall .-3126 ; 0x362 <printVoltage>
  2654. LCD_SendStr("V");
  2655. f98: 8e ee ldi r24, 0xEE ; 238
  2656. f9a: 92 e0 ldi r25, 0x02 ; 2
  2657. f9c: ea d1 rcall .+980 ; 0x1372 <LCD_SendStr>
  2658.  
  2659. USART_PutChar(' ');
  2660. f9e: 80 e2 ldi r24, 0x20 ; 32
  2661. fa0: 48 d3 rcall .+1680 ; 0x1632 <USART_PutChar>
  2662.  
  2663. //Вывод Тока
  2664. LCD_Goto(6,0);
  2665. fa2: 86 e8 ldi r24, 0x86 ; 134
  2666. fa4: a1 d1 rcall .+834 ; 0x12e8 <LCD_WriteCom>
  2667. printUL(I/1000);
  2668. fa6: 60 91 3f 03 lds r22, 0x033F
  2669. faa: 70 91 40 03 lds r23, 0x0340
  2670. fae: 80 91 41 03 lds r24, 0x0341
  2671. fb2: 90 91 42 03 lds r25, 0x0342
  2672. fb6: a5 01 movw r20, r10
  2673. fb8: 94 01 movw r18, r8
  2674. fba: 21 d4 rcall .+2114 ; 0x17fe <__udivmodsi4>
  2675. fbc: 82 2f mov r24, r18
  2676. fbe: a2 d9 rcall .-3260 ; 0x304 <printUL>
  2677. LCD_WriteData('.');
  2678. fc0: 8e e2 ldi r24, 0x2E ; 46
  2679. fc2: a3 d1 rcall .+838 ; 0x130a <LCD_WriteData>
  2680. USART_PutChar('.');
  2681. fc4: 8e e2 ldi r24, 0x2E ; 46
  2682. fc6: 35 d3 rcall .+1642 ; 0x1632 <USART_PutChar>
  2683. printUL(I%1000/100);
  2684. fc8: 60 91 3f 03 lds r22, 0x033F
  2685. fcc: 70 91 40 03 lds r23, 0x0340
  2686. fd0: 80 91 41 03 lds r24, 0x0341
  2687. fd4: 90 91 42 03 lds r25, 0x0342
  2688. fd8: a5 01 movw r20, r10
  2689. fda: 94 01 movw r18, r8
  2690. fdc: 10 d4 rcall .+2080 ; 0x17fe <__udivmodsi4>
  2691. fde: 24 e6 ldi r18, 0x64 ; 100
  2692. fe0: 30 e0 ldi r19, 0x00 ; 0
  2693. fe2: 40 e0 ldi r20, 0x00 ; 0
  2694. fe4: 50 e0 ldi r21, 0x00 ; 0
  2695. fe6: 0b d4 rcall .+2070 ; 0x17fe <__udivmodsi4>
  2696. fe8: 82 2f mov r24, r18
  2697. fea: 8c d9 rcall .-3304 ; 0x304 <printUL>
  2698. USART_PutChar(0x30+(I%1000)%100/10);
  2699. fec: 60 91 3f 03 lds r22, 0x033F
  2700. ff0: 70 91 40 03 lds r23, 0x0340
  2701. ff4: 80 91 41 03 lds r24, 0x0341
  2702. ff8: 90 91 42 03 lds r25, 0x0342
  2703. ffc: a5 01 movw r20, r10
  2704. ffe: 94 01 movw r18, r8
  2705. 1000: fe d3 rcall .+2044 ; 0x17fe <__udivmodsi4>
  2706. 1002: 24 e6 ldi r18, 0x64 ; 100
  2707. 1004: 30 e0 ldi r19, 0x00 ; 0
  2708. 1006: 40 e0 ldi r20, 0x00 ; 0
  2709. 1008: 50 e0 ldi r21, 0x00 ; 0
  2710. 100a: f9 d3 rcall .+2034 ; 0x17fe <__udivmodsi4>
  2711. 100c: a3 01 movw r20, r6
  2712. 100e: 92 01 movw r18, r4
  2713. 1010: f6 d3 rcall .+2028 ; 0x17fe <__udivmodsi4>
  2714. 1012: 82 2f mov r24, r18
  2715. 1014: 80 5d subi r24, 0xD0 ; 208
  2716. 1016: 0d d3 rcall .+1562 ; 0x1632 <USART_PutChar>
  2717. LCD_SendStr("A");
  2718. 1018: 80 ef ldi r24, 0xF0 ; 240
  2719. 101a: 92 e0 ldi r25, 0x02 ; 2
  2720. 101c: aa d1 rcall .+852 ; 0x1372 <LCD_SendStr>
  2721.  
  2722. USART_PutChar(' ');
  2723. 101e: 80 e2 ldi r24, 0x20 ; 32
  2724. 1020: 08 d3 rcall .+1552 ; 0x1632 <USART_PutChar>
  2725.  
  2726. //Вывод времени
  2727. LCD_Goto(11,0);
  2728. 1022: 8b e8 ldi r24, 0x8B ; 139
  2729. 1024: 61 d1 rcall .+706 ; 0x12e8 <LCD_WriteCom>
  2730. minutes = seconds()/60;
  2731. 1026: f6 d8 rcall .-3604 ; 0x214 <seconds>
  2732. 1028: 2c e3 ldi r18, 0x3C ; 60
  2733. 102a: 30 e0 ldi r19, 0x00 ; 0
  2734. 102c: 40 e0 ldi r20, 0x00 ; 0
  2735. 102e: 50 e0 ldi r21, 0x00 ; 0
  2736. 1030: e6 d3 rcall .+1996 ; 0x17fe <__udivmodsi4>
  2737. 1032: 79 01 movw r14, r18
  2738. 1034: 8a 01 movw r16, r20
  2739. 1036: 20 93 37 03 sts 0x0337, r18
  2740. 103a: 30 93 38 03 sts 0x0338, r19
  2741. 103e: 40 93 39 03 sts 0x0339, r20
  2742. 1042: 50 93 3a 03 sts 0x033A, r21
  2743. printITime((minutes/60)/10, (minutes/60)%10);
  2744. 1046: ca 01 movw r24, r20
  2745. 1048: b9 01 movw r22, r18
  2746. 104a: 28 e5 ldi r18, 0x58 ; 88
  2747. 104c: 32 e0 ldi r19, 0x02 ; 2
  2748. 104e: 40 e0 ldi r20, 0x00 ; 0
  2749. 1050: 50 e0 ldi r21, 0x00 ; 0
  2750. 1052: d5 d3 rcall .+1962 ; 0x17fe <__udivmodsi4>
  2751. 1054: d2 2e mov r13, r18
  2752. 1056: c8 01 movw r24, r16
  2753. 1058: b7 01 movw r22, r14
  2754. 105a: 2c e3 ldi r18, 0x3C ; 60
  2755. 105c: 30 e0 ldi r19, 0x00 ; 0
  2756. 105e: 40 e0 ldi r20, 0x00 ; 0
  2757. 1060: 50 e0 ldi r21, 0x00 ; 0
  2758. 1062: cd d3 rcall .+1946 ; 0x17fe <__udivmodsi4>
  2759. 1064: ca 01 movw r24, r20
  2760. 1066: b9 01 movw r22, r18
  2761. 1068: a3 01 movw r20, r6
  2762. 106a: 92 01 movw r18, r4
  2763. 106c: c8 d3 rcall .+1936 ; 0x17fe <__udivmodsi4>
  2764. 106e: 8d 2d mov r24, r13
  2765. 1070: 67 d9 rcall .-3378 ; 0x340 <printITime>
  2766. USART_PutChar(':');
  2767. 1072: 8a e3 ldi r24, 0x3A ; 58
  2768. 1074: de d2 rcall .+1468 ; 0x1632 <USART_PutChar>
  2769. LCD_WriteData(':');
  2770. 1076: 8a e3 ldi r24, 0x3A ; 58
  2771. 1078: 48 d1 rcall .+656 ; 0x130a <LCD_WriteData>
  2772. printITime((minutes%60)/10, (minutes%60%10));
  2773. 107a: 60 91 37 03 lds r22, 0x0337
  2774. 107e: 70 91 38 03 lds r23, 0x0338
  2775. 1082: 80 91 39 03 lds r24, 0x0339
  2776. 1086: 90 91 3a 03 lds r25, 0x033A
  2777. 108a: 2c e3 ldi r18, 0x3C ; 60
  2778. 108c: 30 e0 ldi r19, 0x00 ; 0
  2779. 108e: 40 e0 ldi r20, 0x00 ; 0
  2780. 1090: 50 e0 ldi r21, 0x00 ; 0
  2781. 1092: b5 d3 rcall .+1898 ; 0x17fe <__udivmodsi4>
  2782. 1094: a3 01 movw r20, r6
  2783. 1096: 92 01 movw r18, r4
  2784. 1098: b2 d3 rcall .+1892 ; 0x17fe <__udivmodsi4>
  2785. 109a: 82 2f mov r24, r18
  2786. 109c: 51 d9 rcall .-3422 ; 0x340 <printITime>
  2787.  
  2788. USART_PutChar(' ');
  2789. 109e: 80 e2 ldi r24, 0x20 ; 32
  2790. 10a0: c8 d2 rcall .+1424 ; 0x1632 <USART_PutChar>
  2791.  
  2792. //Вывод емкости
  2793. LCD_Goto(0,1);
  2794. 10a2: 80 ec ldi r24, 0xC0 ; 192
  2795. 10a4: 21 d1 rcall .+578 ; 0x12e8 <LCD_WriteCom>
  2796. printCapacity(Capacity/3600, false, true);
  2797. 10a6: 60 91 3b 03 lds r22, 0x033B
  2798. 10aa: 70 91 3c 03 lds r23, 0x033C
  2799. 10ae: 80 91 3d 03 lds r24, 0x033D
  2800. 10b2: 90 91 3e 03 lds r25, 0x033E
  2801. 10b6: 20 e1 ldi r18, 0x10 ; 16
  2802. 10b8: 3e e0 ldi r19, 0x0E ; 14
  2803. 10ba: 40 e0 ldi r20, 0x00 ; 0
  2804. 10bc: 50 e0 ldi r21, 0x00 ; 0
  2805. 10be: 9f d3 rcall .+1854 ; 0x17fe <__udivmodsi4>
  2806. 10c0: ca 01 movw r24, r20
  2807. 10c2: b9 01 movw r22, r18
  2808. 10c4: 40 e0 ldi r20, 0x00 ; 0
  2809. 10c6: 21 e0 ldi r18, 0x01 ; 1
  2810. 10c8: 85 da rcall .-2806 ; 0x5d4 <printCapacity>
  2811. LCD_SendStr("mAh");
  2812. 10ca: 86 ef ldi r24, 0xF6 ; 246
  2813. 10cc: 90 e0 ldi r25, 0x00 ; 0
  2814. 10ce: 51 d1 rcall .+674 ; 0x1372 <LCD_SendStr>
  2815. LCD_Goto(9,1);
  2816. printWhVoltage((long)(Wh*1000), true);
  2817. LCD_SendStr("Wh");
  2818. */
  2819.  
  2820. USART_SendStr("\r\n");
  2821. 10d0: 89 e6 ldi r24, 0x69 ; 105
  2822. 10d2: 91 e0 ldi r25, 0x01 ; 1
  2823. 10d4: d4 d2 rcall .+1448 ; 0x167e <USART_SendStr>
  2824. interrupt_data = false;
  2825. 10d6: 10 92 31 03 sts 0x0331, r1
  2826. }
  2827. BUT_Poll();
  2828. 10da: 61 d2 rcall .+1218 ; 0x159e <BUT_Poll>
  2829. i = BUT_GetBut();
  2830. 10dc: 16 d2 rcall .+1068 ; 0x150a <BUT_GetBut>
  2831. 10de: 80 93 47 03 sts 0x0347, r24
  2832. button_event = BUT_GetBut();
  2833. 10e2: 13 d2 rcall .+1062 ; 0x150a <BUT_GetBut>
  2834. 10e4: 80 93 48 03 sts 0x0348, r24
  2835.  
  2836. //PAUSE
  2837. if(i == ENTER_BUTTON_ID && button_event == BUT_PRESSED_CODE){
  2838. 10e8: 90 91 47 03 lds r25, 0x0347
  2839. 10ec: 91 30 cpi r25, 0x01 ; 1
  2840. 10ee: 09 f0 breq .+2 ; 0x10f2 <main+0x5be>
  2841. 10f0: 7b c0 rjmp .+246 ; 0x11e8 <main+0x6b4>
  2842. 10f2: 81 30 cpi r24, 0x01 ; 1
  2843. 10f4: 09 f0 breq .+2 ; 0x10f8 <main+0x5c4>
  2844. 10f6: 78 c0 rjmp .+240 ; 0x11e8 <main+0x6b4>
  2845. OCR1A = 0;
  2846. 10f8: 1b bc out 0x2b, r1 ; 43
  2847. 10fa: 1a bc out 0x2a, r1 ; 42
  2848. //Отключение АКБ
  2849. BATTERY_OFF;
  2850. 10fc: 86 e0 ldi r24, 0x06 ; 6
  2851. 10fe: 90 e0 ldi r25, 0x00 ; 0
  2852. 1100: 60 e0 ldi r22, 0x00 ; 0
  2853. 1102: 70 e0 ldi r23, 0x00 ; 0
  2854. 1104: 40 e0 ldi r20, 0x00 ; 0
  2855. 1106: 50 e0 ldi r21, 0x00 ; 0
  2856. 1108: cb d7 rcall .+3990 ; 0x20a0 <__data_load_end+0x460>
  2857. //Выключение таймера времени
  2858. TIMSK &= ~(1 << TOIE2);
  2859. 110a: 89 b7 in r24, 0x39 ; 57
  2860. 110c: 8f 7b andi r24, 0xBF ; 191
  2861. 110e: 89 bf out 0x39, r24 ; 57
  2862. PauseSave[0] = Capacity;
  2863. 1110: 80 91 3b 03 lds r24, 0x033B
  2864. 1114: 90 91 3c 03 lds r25, 0x033C
  2865. 1118: a0 91 3d 03 lds r26, 0x033D
  2866. 111c: b0 91 3e 03 lds r27, 0x033E
  2867. 1120: 80 93 4f 03 sts 0x034F, r24
  2868. 1124: 90 93 50 03 sts 0x0350, r25
  2869. 1128: a0 93 51 03 sts 0x0351, r26
  2870. 112c: b0 93 52 03 sts 0x0352, r27
  2871. PauseSave[1] = seconds();
  2872. 1130: 71 d8 rcall .-3870 ; 0x214 <seconds>
  2873. 1132: 60 93 53 03 sts 0x0353, r22
  2874. 1136: 70 93 54 03 sts 0x0354, r23
  2875. 113a: 80 93 55 03 sts 0x0355, r24
  2876. 113e: 90 93 56 03 sts 0x0356, r25
  2877. eeprom_write_byte(&eepause_continue, 1);
  2878. 1142: 88 e0 ldi r24, 0x08 ; 8
  2879. 1144: 90 e0 ldi r25, 0x00 ; 0
  2880. 1146: 61 e0 ldi r22, 0x01 ; 1
  2881. 1148: ef d3 rcall .+2014 ; 0x1928 <__eewr_byte_m8>
  2882. eeprom_write_block ((const void *)&PauseSave, (void *)&eePauseSave, 8);
  2883. 114a: 8f e4 ldi r24, 0x4F ; 79
  2884. 114c: 93 e0 ldi r25, 0x03 ; 3
  2885. 114e: 60 e0 ldi r22, 0x00 ; 0
  2886. 1150: 70 e0 ldi r23, 0x00 ; 0
  2887. 1152: 48 e0 ldi r20, 0x08 ; 8
  2888. 1154: 50 e0 ldi r21, 0x00 ; 0
  2889. 1156: df d3 rcall .+1982 ; 0x1916 <__eewr_block_m8>
  2890. USART_SendStr("Test suspended\r\n");
  2891. 1158: 82 ef ldi r24, 0xF2 ; 242
  2892. 115a: 92 e0 ldi r25, 0x02 ; 2
  2893. 115c: 90 d2 rcall .+1312 ; 0x167e <USART_SendStr>
  2894.  
  2895. LCD_Goto(9, 1);
  2896. 115e: 89 ec ldi r24, 0xC9 ; 201
  2897. 1160: c3 d0 rcall .+390 ; 0x12e8 <LCD_WriteCom>
  2898. LCD_SendStr("PAUSED");
  2899. 1162: 83 e0 ldi r24, 0x03 ; 3
  2900. 1164: 93 e0 ldi r25, 0x03 ; 3
  2901. 1166: 05 d1 rcall .+522 ; 0x1372 <LCD_SendStr>
  2902. i = 0;
  2903. 1168: 10 92 47 03 sts 0x0347, r1
  2904. button_event = 0;
  2905. 116c: 10 92 48 03 sts 0x0348, r1
  2906. while(i != ENTER_BUTTON_ID || button_event != BUT_PRESSED_CODE){
  2907. 1170: 08 c0 rjmp .+16 ; 0x1182 <main+0x64e>
  2908. BUT_Poll();
  2909. 1172: 15 d2 rcall .+1066 ; 0x159e <BUT_Poll>
  2910. i = BUT_GetBut();
  2911. 1174: ca d1 rcall .+916 ; 0x150a <BUT_GetBut>
  2912. 1176: 80 93 47 03 sts 0x0347, r24
  2913. button_event = BUT_GetBut();
  2914. 117a: c7 d1 rcall .+910 ; 0x150a <BUT_GetBut>
  2915. 117c: 80 93 48 03 sts 0x0348, r24
  2916. coolerCalc();
  2917. 1180: 48 d9 rcall .-3440 ; 0x412 <coolerCalc>
  2918.  
  2919. LCD_Goto(9, 1);
  2920. LCD_SendStr("PAUSED");
  2921. i = 0;
  2922. button_event = 0;
  2923. while(i != ENTER_BUTTON_ID || button_event != BUT_PRESSED_CODE){
  2924. 1182: 80 91 47 03 lds r24, 0x0347
  2925. 1186: 81 30 cpi r24, 0x01 ; 1
  2926. 1188: a1 f7 brne .-24 ; 0x1172 <main+0x63e>
  2927. 118a: 80 91 48 03 lds r24, 0x0348
  2928. 118e: 81 30 cpi r24, 0x01 ; 1
  2929. 1190: 81 f7 brne .-32 ; 0x1172 <main+0x63e>
  2930. BUT_Poll();
  2931. i = BUT_GetBut();
  2932. button_event = BUT_GetBut();
  2933. coolerCalc();
  2934. }
  2935. eeprom_write_byte(&eepause_continue, 0);
  2936. 1192: 88 e0 ldi r24, 0x08 ; 8
  2937. 1194: 90 e0 ldi r25, 0x00 ; 0
  2938. 1196: 60 e0 ldi r22, 0x00 ; 0
  2939. 1198: c7 d3 rcall .+1934 ; 0x1928 <__eewr_byte_m8>
  2940. USART_SendStr("Initializing...\r\n");
  2941. 119a: 8c e6 ldi r24, 0x6C ; 108
  2942. 119c: 91 e0 ldi r25, 0x01 ; 1
  2943. 119e: 6f d2 rcall .+1246 ; 0x167e <USART_SendStr>
  2944. //PWM Calc
  2945. OCR1A = AMPERAGE_PWM_COEFFICIENT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP)+AMPERAGE_PWM_COEFFICIENT_CORRECT*(I_set/AMPERAGE_PWM_COEFFICIENT_STEP);
  2946. 11a0: 80 91 27 03 lds r24, 0x0327
  2947. 11a4: 90 91 28 03 lds r25, 0x0328
  2948. 11a8: 64 e6 ldi r22, 0x64 ; 100
  2949. 11aa: 70 e0 ldi r23, 0x00 ; 0
  2950. 11ac: 14 d3 rcall .+1576 ; 0x17d6 <__udivmodhi4>
  2951. 11ae: ac e2 ldi r26, 0x2C ; 44
  2952. 11b0: b0 e0 ldi r27, 0x00 ; 0
  2953. 11b2: 6a 9f mul r22, r26
  2954. 11b4: c0 01 movw r24, r0
  2955. 11b6: 6b 9f mul r22, r27
  2956. 11b8: 90 0d add r25, r0
  2957. 11ba: 7a 9f mul r23, r26
  2958. 11bc: 90 0d add r25, r0
  2959. 11be: 11 24 eor r1, r1
  2960. 11c0: 9b bd out 0x2b, r25 ; 43
  2961. 11c2: 8a bd out 0x2a, r24 ; 42
  2962.  
  2963. //Подключение АКБ
  2964. BATTERY_ON;
  2965. 11c4: 86 e0 ldi r24, 0x06 ; 6
  2966. 11c6: 90 e0 ldi r25, 0x00 ; 0
  2967. 11c8: 61 e0 ldi r22, 0x01 ; 1
  2968. 11ca: 70 e0 ldi r23, 0x00 ; 0
  2969. 11cc: 40 e0 ldi r20, 0x00 ; 0
  2970. 11ce: 50 e0 ldi r21, 0x00 ; 0
  2971. 11d0: 67 d7 rcall .+3790 ; 0x20a0 <__data_load_end+0x460>
  2972.  
  2973. //Включение таймера времени
  2974. TIMSK |= (1 << TOIE2);
  2975. 11d2: 89 b7 in r24, 0x39 ; 57
  2976. 11d4: 80 64 ori r24, 0x40 ; 64
  2977. 11d6: 89 bf out 0x39, r24 ; 57
  2978. LCD_Goto(9, 1);
  2979. 11d8: 89 ec ldi r24, 0xC9 ; 201
  2980. 11da: 86 d0 rcall .+268 ; 0x12e8 <LCD_WriteCom>
  2981. LCD_SendStr(" ");
  2982. 11dc: 8a e0 ldi r24, 0x0A ; 10
  2983. 11de: 93 e0 ldi r25, 0x03 ; 3
  2984. 11e0: c8 d0 rcall .+400 ; 0x1372 <LCD_SendStr>
  2985. USART_SendStr("Test continued...\r\n");
  2986. 11e2: 81 e1 ldi r24, 0x11 ; 17
  2987. 11e4: 93 e0 ldi r25, 0x03 ; 3
  2988. 11e6: 4b d2 rcall .+1174 ; 0x167e <USART_SendStr>
  2989. }
  2990.  
  2991. //Защита от переразряда и конец теста
  2992. checkEndVoltage();
  2993. 11e8: df da rcall .-2626 ; 0x7a8 <checkEndVoltage>
  2994. }
  2995. 11ea: 71 ce rjmp .-798 ; 0xece <main+0x39a>
  2996.  
  2997. 000011ec <LCD_CommonFunc>:
  2998. }
  2999.  
  3000.  
  3001. /*общая функция*/
  3002. inline static void LCD_CommonFunc(uint8_t data)
  3003. {
  3004. 11ec: 1f 93 push r17
  3005. 11ee: 18 2f mov r17, r24
  3006. #if (LCD_BUS_4_8_BIT == 0)
  3007.  
  3008. uint8_t tmp;
  3009. tmp = (data & 0xf0);
  3010. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (tmp >> 2)), 0);
  3011. 11f0: 80 e0 ldi r24, 0x00 ; 0
  3012. 11f2: 90 e0 ldi r25, 0x00 ; 0
  3013. 11f4: 78 d7 rcall .+3824 ; 0x20e6 <__data_load_end+0x4a6>
  3014. 11f6: 28 2f mov r18, r24
  3015. 11f8: 30 e0 ldi r19, 0x00 ; 0
  3016. 11fa: 23 7c andi r18, 0xC3 ; 195
  3017. 11fc: 30 70 andi r19, 0x00 ; 0
  3018. inline static void LCD_CommonFunc(uint8_t data)
  3019. {
  3020. #if (LCD_BUS_4_8_BIT == 0)
  3021.  
  3022. uint8_t tmp;
  3023. tmp = (data & 0xf0);
  3024. 11fe: 41 2f mov r20, r17
  3025. 1200: 40 7f andi r20, 0xF0 ; 240
  3026. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (tmp >> 2)), 0);
  3027. 1202: 46 95 lsr r20
  3028. 1204: 46 95 lsr r20
  3029. 1206: 50 e0 ldi r21, 0x00 ; 0
  3030. 1208: c9 01 movw r24, r18
  3031. 120a: 84 2b or r24, r20
  3032. 120c: 95 2b or r25, r21
  3033. 120e: 60 e0 ldi r22, 0x00 ; 0
  3034. 1210: 70 e0 ldi r23, 0x00 ; 0
  3035. 1212: 63 d7 rcall .+3782 ; 0x20da <__data_load_end+0x49a>
  3036. ShiftDigitalWrite(0, HIGH, 0);
  3037. 1214: 80 e0 ldi r24, 0x00 ; 0
  3038. 1216: 90 e0 ldi r25, 0x00 ; 0
  3039. 1218: 61 e0 ldi r22, 0x01 ; 1
  3040. 121a: 70 e0 ldi r23, 0x00 ; 0
  3041. 121c: 40 e0 ldi r20, 0x00 ; 0
  3042. 121e: 50 e0 ldi r21, 0x00 ; 0
  3043. 1220: 3f d7 rcall .+3710 ; 0x20a0 <__data_load_end+0x460>
  3044. #else
  3045. //round up by default
  3046. __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
  3047. #endif
  3048.  
  3049. __builtin_avr_delay_cycles(__ticks_dc);
  3050. 1222: 85 e0 ldi r24, 0x05 ; 5
  3051. 1224: 8a 95 dec r24
  3052. 1226: f1 f7 brne .-4 ; 0x1224 <LCD_CommonFunc+0x38>
  3053. 1228: 00 00 nop
  3054. delay_us(LCD_DELAY_STROB);
  3055. ShiftDigitalWrite(0, LOW, 0);
  3056. 122a: 80 e0 ldi r24, 0x00 ; 0
  3057. 122c: 90 e0 ldi r25, 0x00 ; 0
  3058. 122e: 60 e0 ldi r22, 0x00 ; 0
  3059. 1230: 70 e0 ldi r23, 0x00 ; 0
  3060. 1232: 40 e0 ldi r20, 0x00 ; 0
  3061. 1234: 50 e0 ldi r21, 0x00 ; 0
  3062. 1236: 34 d7 rcall .+3688 ; 0x20a0 <__data_load_end+0x460>
  3063.  
  3064. data = __swap_nibbles(data);
  3065. 1238: 12 95 swap r17
  3066. tmp = (data & 0xf0);
  3067.  
  3068. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (tmp >> 2)), 0);
  3069. 123a: 80 e0 ldi r24, 0x00 ; 0
  3070. 123c: 90 e0 ldi r25, 0x00 ; 0
  3071. 123e: 53 d7 rcall .+3750 ; 0x20e6 <__data_load_end+0x4a6>
  3072. 1240: 28 2f mov r18, r24
  3073. 1242: 30 e0 ldi r19, 0x00 ; 0
  3074. 1244: 23 7c andi r18, 0xC3 ; 195
  3075. 1246: 30 70 andi r19, 0x00 ; 0
  3076. ShiftDigitalWrite(0, HIGH, 0);
  3077. delay_us(LCD_DELAY_STROB);
  3078. ShiftDigitalWrite(0, LOW, 0);
  3079.  
  3080. data = __swap_nibbles(data);
  3081. tmp = (data & 0xf0);
  3082. 1248: 10 7f andi r17, 0xF0 ; 240
  3083.  
  3084. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (tmp >> 2)), 0);
  3085. 124a: 16 95 lsr r17
  3086. 124c: 16 95 lsr r17
  3087. 124e: 81 2f mov r24, r17
  3088. 1250: 90 e0 ldi r25, 0x00 ; 0
  3089. 1252: 82 2b or r24, r18
  3090. 1254: 93 2b or r25, r19
  3091. 1256: 60 e0 ldi r22, 0x00 ; 0
  3092. 1258: 70 e0 ldi r23, 0x00 ; 0
  3093. 125a: 3f d7 rcall .+3710 ; 0x20da <__data_load_end+0x49a>
  3094. ShiftDigitalWrite(0, HIGH, 0);
  3095. 125c: 80 e0 ldi r24, 0x00 ; 0
  3096. 125e: 90 e0 ldi r25, 0x00 ; 0
  3097. 1260: 61 e0 ldi r22, 0x01 ; 1
  3098. 1262: 70 e0 ldi r23, 0x00 ; 0
  3099. 1264: 40 e0 ldi r20, 0x00 ; 0
  3100. 1266: 50 e0 ldi r21, 0x00 ; 0
  3101. 1268: 1b d7 rcall .+3638 ; 0x20a0 <__data_load_end+0x460>
  3102. 126a: 85 e0 ldi r24, 0x05 ; 5
  3103. 126c: 8a 95 dec r24
  3104. 126e: f1 f7 brne .-4 ; 0x126c <LCD_CommonFunc+0x80>
  3105. 1270: 00 00 nop
  3106. delay_us(LCD_DELAY_STROB);
  3107. ShiftDigitalWrite(0, LOW, 0);
  3108. 1272: 80 e0 ldi r24, 0x00 ; 0
  3109. 1274: 90 e0 ldi r25, 0x00 ; 0
  3110. 1276: 60 e0 ldi r22, 0x00 ; 0
  3111. 1278: 70 e0 ldi r23, 0x00 ; 0
  3112. 127a: 40 e0 ldi r20, 0x00 ; 0
  3113. 127c: 50 e0 ldi r21, 0x00 ; 0
  3114. 127e: 10 d7 rcall .+3616 ; 0x20a0 <__data_load_end+0x460>
  3115. ShiftDigitalWrite(0, HIGH, 0);
  3116. delay_us(LCD_DELAY_STROB);
  3117. ShiftDigitalWrite(0, LOW, 0);
  3118.  
  3119. #endif
  3120. }
  3121. 1280: 1f 91 pop r17
  3122. 1282: 08 95 ret
  3123.  
  3124. 00001284 <LCD_WriteComInit>:
  3125. #define LCD_FL_BF 7
  3126.  
  3127. /*_________________________________________________________________*/
  3128.  
  3129. void LCD_WriteComInit(uint8_t data)
  3130. {
  3131. 1284: 1f 93 push r17
  3132. 1286: 18 2f mov r17, r24
  3133. 1288: 8a e6 ldi r24, 0x6A ; 106
  3134. 128a: 8a 95 dec r24
  3135. 128c: f1 f7 brne .-4 ; 0x128a <LCD_WriteComInit+0x6>
  3136. 128e: 00 c0 rjmp .+0 ; 0x1290 <LCD_WriteComInit+0xc>
  3137. delay_us(LCD_DELAY_WAIT);
  3138. ShiftDigitalWrite(1, LOW, 0);
  3139. 1290: 81 e0 ldi r24, 0x01 ; 1
  3140. 1292: 90 e0 ldi r25, 0x00 ; 0
  3141. 1294: 60 e0 ldi r22, 0x00 ; 0
  3142. 1296: 70 e0 ldi r23, 0x00 ; 0
  3143. 1298: 40 e0 ldi r20, 0x00 ; 0
  3144. 129a: 50 e0 ldi r21, 0x00 ; 0
  3145. 129c: 01 d7 rcall .+3586 ; 0x20a0 <__data_load_end+0x460>
  3146.  
  3147. #if (LCD_BUS_4_8_BIT == 0)
  3148. data &= 0xf0;
  3149. #endif
  3150.  
  3151. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (data >> 2)), 0);
  3152. 129e: 80 e0 ldi r24, 0x00 ; 0
  3153. 12a0: 90 e0 ldi r25, 0x00 ; 0
  3154. 12a2: 21 d7 rcall .+3650 ; 0x20e6 <__data_load_end+0x4a6>
  3155. 12a4: 28 2f mov r18, r24
  3156. 12a6: 30 e0 ldi r19, 0x00 ; 0
  3157. 12a8: 23 7c andi r18, 0xC3 ; 195
  3158. 12aa: 30 70 andi r19, 0x00 ; 0
  3159. {
  3160. delay_us(LCD_DELAY_WAIT);
  3161. ShiftDigitalWrite(1, LOW, 0);
  3162.  
  3163. #if (LCD_BUS_4_8_BIT == 0)
  3164. data &= 0xf0;
  3165. 12ac: 10 7f andi r17, 0xF0 ; 240
  3166. #endif
  3167.  
  3168. ShiftDigitalWritePort(((ShiftDigitalGetPort(0) & 0b11000011) | (data >> 2)), 0);
  3169. 12ae: 16 95 lsr r17
  3170. 12b0: 16 95 lsr r17
  3171. 12b2: 81 2f mov r24, r17
  3172. 12b4: 90 e0 ldi r25, 0x00 ; 0
  3173. 12b6: 82 2b or r24, r18
  3174. 12b8: 93 2b or r25, r19
  3175. 12ba: 60 e0 ldi r22, 0x00 ; 0
  3176. 12bc: 70 e0 ldi r23, 0x00 ; 0
  3177. 12be: 0d d7 rcall .+3610 ; 0x20da <__data_load_end+0x49a>
  3178. ShiftDigitalWrite(0, HIGH, 0);
  3179. 12c0: 80 e0 ldi r24, 0x00 ; 0
  3180. 12c2: 90 e0 ldi r25, 0x00 ; 0
  3181. 12c4: 61 e0 ldi r22, 0x01 ; 1
  3182. 12c6: 70 e0 ldi r23, 0x00 ; 0
  3183. 12c8: 40 e0 ldi r20, 0x00 ; 0
  3184. 12ca: 50 e0 ldi r21, 0x00 ; 0
  3185. 12cc: e9 d6 rcall .+3538 ; 0x20a0 <__data_load_end+0x460>
  3186. 12ce: 85 e0 ldi r24, 0x05 ; 5
  3187. 12d0: 8a 95 dec r24
  3188. 12d2: f1 f7 brne .-4 ; 0x12d0 <LCD_WriteComInit+0x4c>
  3189. 12d4: 00 00 nop
  3190. delay_us(LCD_DELAY_STROB);
  3191. ShiftDigitalWrite(0, LOW, 0);
  3192. 12d6: 80 e0 ldi r24, 0x00 ; 0
  3193. 12d8: 90 e0 ldi r25, 0x00 ; 0
  3194. 12da: 60 e0 ldi r22, 0x00 ; 0
  3195. 12dc: 70 e0 ldi r23, 0x00 ; 0
  3196. 12de: 40 e0 ldi r20, 0x00 ; 0
  3197. 12e0: 50 e0 ldi r21, 0x00 ; 0
  3198. 12e2: de d6 rcall .+3516 ; 0x20a0 <__data_load_end+0x460>
  3199. }
  3200. 12e4: 1f 91 pop r17
  3201. 12e6: 08 95 ret
  3202.  
  3203. 000012e8 <LCD_WriteCom>:
  3204. #endif
  3205. }
  3206.  
  3207. /*функция записи команды*/
  3208. void LCD_WriteCom(uint8_t data)
  3209. {
  3210. 12e8: 1f 93 push r17
  3211. 12ea: 18 2f mov r17, r24
  3212. 12ec: 8a e6 ldi r24, 0x6A ; 106
  3213. 12ee: 8a 95 dec r24
  3214. 12f0: f1 f7 brne .-4 ; 0x12ee <LCD_WriteCom+0x6>
  3215. 12f2: 00 c0 rjmp .+0 ; 0x12f4 <LCD_WriteCom+0xc>
  3216. LCD_Wait();
  3217. ShiftDigitalWrite(1, LOW, 0);
  3218. 12f4: 81 e0 ldi r24, 0x01 ; 1
  3219. 12f6: 90 e0 ldi r25, 0x00 ; 0
  3220. 12f8: 60 e0 ldi r22, 0x00 ; 0
  3221. 12fa: 70 e0 ldi r23, 0x00 ; 0
  3222. 12fc: 40 e0 ldi r20, 0x00 ; 0
  3223. 12fe: 50 e0 ldi r21, 0x00 ; 0
  3224. 1300: cf d6 rcall .+3486 ; 0x20a0 <__data_load_end+0x460>
  3225. LCD_CommonFunc(data);
  3226. 1302: 81 2f mov r24, r17
  3227. 1304: 73 df rcall .-282 ; 0x11ec <LCD_CommonFunc>
  3228. }
  3229. 1306: 1f 91 pop r17
  3230. 1308: 08 95 ret
  3231.  
  3232. 0000130a <LCD_WriteData>:
  3233.  
  3234. /*функция записи данных*/
  3235. void LCD_WriteData(char data)
  3236. {
  3237. 130a: 1f 93 push r17
  3238. 130c: 18 2f mov r17, r24
  3239. 130e: 8a e6 ldi r24, 0x6A ; 106
  3240. 1310: 8a 95 dec r24
  3241. 1312: f1 f7 brne .-4 ; 0x1310 <LCD_WriteData+0x6>
  3242. 1314: 00 c0 rjmp .+0 ; 0x1316 <LCD_WriteData+0xc>
  3243. LCD_Wait();
  3244. ShiftDigitalWrite(1, HIGH, 0);
  3245. 1316: 81 e0 ldi r24, 0x01 ; 1
  3246. 1318: 90 e0 ldi r25, 0x00 ; 0
  3247. 131a: 61 e0 ldi r22, 0x01 ; 1
  3248. 131c: 70 e0 ldi r23, 0x00 ; 0
  3249. 131e: 40 e0 ldi r20, 0x00 ; 0
  3250. 1320: 50 e0 ldi r21, 0x00 ; 0
  3251. 1322: be d6 rcall .+3452 ; 0x20a0 <__data_load_end+0x460>
  3252. LCD_CommonFunc(data);
  3253. 1324: 81 2f mov r24, r17
  3254. 1326: 62 df rcall .-316 ; 0x11ec <LCD_CommonFunc>
  3255. }
  3256. 1328: 1f 91 pop r17
  3257. 132a: 08 95 ret
  3258.  
  3259. 0000132c <LCD_Init>:
  3260.  
  3261. /*функция инициализации*/
  3262. void LCD_Init(void)
  3263. {
  3264. LCD_WriteComInit(LCD_COM_INIT_1);
  3265. 132c: 80 e3 ldi r24, 0x30 ; 48
  3266. 132e: aa df rcall .-172 ; 0x1284 <LCD_WriteComInit>
  3267. #else
  3268. //round up by default
  3269. __ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
  3270. #endif
  3271.  
  3272. __builtin_avr_delay_cycles(__ticks_dc);
  3273. 1330: 8f e1 ldi r24, 0x1F ; 31
  3274. 1332: 9e e4 ldi r25, 0x4E ; 78
  3275. 1334: 01 97 sbiw r24, 0x01 ; 1
  3276. 1336: f1 f7 brne .-4 ; 0x1334 <LCD_Init+0x8>
  3277. 1338: 00 c0 rjmp .+0 ; 0x133a <LCD_Init+0xe>
  3278. 133a: 00 00 nop
  3279. delay_ms(10);
  3280. LCD_WriteComInit(LCD_COM_INIT_1);
  3281. 133c: 80 e3 ldi r24, 0x30 ; 48
  3282. 133e: a2 df rcall .-188 ; 0x1284 <LCD_WriteComInit>
  3283. 1340: 8f e9 ldi r24, 0x9F ; 159
  3284. 1342: 9f e0 ldi r25, 0x0F ; 15
  3285. 1344: 01 97 sbiw r24, 0x01 ; 1
  3286. 1346: f1 f7 brne .-4 ; 0x1344 <LCD_Init+0x18>
  3287. 1348: 00 c0 rjmp .+0 ; 0x134a <LCD_Init+0x1e>
  3288. 134a: 00 00 nop
  3289. delay_ms(2);
  3290. LCD_WriteComInit(LCD_COM_INIT_1);
  3291. 134c: 80 e3 ldi r24, 0x30 ; 48
  3292. 134e: 9a df rcall .-204 ; 0x1284 <LCD_WriteComInit>
  3293.  
  3294. #if (LCD_BUS_4_8_BIT == 0)
  3295. LCD_WriteComInit(LCD_COM_FUNCTION_SET);
  3296. 1350: 88 e2 ldi r24, 0x28 ; 40
  3297. 1352: 98 df rcall .-208 ; 0x1284 <LCD_WriteComInit>
  3298. #endif
  3299.  
  3300. LCD_WriteCom(LCD_COM_FUNCTION_SET);
  3301. 1354: 88 e2 ldi r24, 0x28 ; 40
  3302. 1356: c8 df rcall .-112 ; 0x12e8 <LCD_WriteCom>
  3303. LCD_WriteCom(LCD_COM_DISPLAY_CONTR);
  3304. 1358: 8c e0 ldi r24, 0x0C ; 12
  3305. 135a: c6 df rcall .-116 ; 0x12e8 <LCD_WriteCom>
  3306. LCD_WriteCom(LCD_CLEAR_DISPLAY);
  3307. 135c: 81 e0 ldi r24, 0x01 ; 1
  3308. 135e: c4 df rcall .-120 ; 0x12e8 <LCD_WriteCom>
  3309. 1360: 8f e9 ldi r24, 0x9F ; 159
  3310. 1362: 9f e0 ldi r25, 0x0F ; 15
  3311. 1364: 01 97 sbiw r24, 0x01 ; 1
  3312. 1366: f1 f7 brne .-4 ; 0x1364 <LCD_Init+0x38>
  3313. 1368: 00 c0 rjmp .+0 ; 0x136a <LCD_Init+0x3e>
  3314. 136a: 00 00 nop
  3315. delay_ms(2);
  3316. LCD_WriteCom(LCD_COM_ENTRY_MODE_SET);
  3317. 136c: 86 e0 ldi r24, 0x06 ; 6
  3318. 136e: bc df rcall .-136 ; 0x12e8 <LCD_WriteCom>
  3319.  
  3320. }
  3321. 1370: 08 95 ret
  3322.  
  3323. 00001372 <LCD_SendStr>:
  3324.  
  3325. /*функция вывда строки из ОЗУ*/
  3326. void LCD_SendStr(char *str)
  3327. {
  3328. 1372: ef 92 push r14
  3329. 1374: ff 92 push r15
  3330. 1376: cf 93 push r28
  3331. 1378: df 93 push r29
  3332. 137a: e8 2e mov r14, r24
  3333. 137c: e7 01 movw r28, r14
  3334. 137e: 7e 01 movw r14, r28
  3335. 1380: f9 2e mov r15, r25
  3336. 1382: e7 01 movw r28, r14
  3337. uint8_t data;
  3338. while (*str){
  3339. 1384: 01 c0 rjmp .+2 ; 0x1388 <LCD_SendStr+0x16>
  3340. data = *str++;
  3341. LCD_WriteData(data);
  3342. 1386: c1 df rcall .-126 ; 0x130a <LCD_WriteData>
  3343.  
  3344. /*функция вывда строки из ОЗУ*/
  3345. void LCD_SendStr(char *str)
  3346. {
  3347. uint8_t data;
  3348. while (*str){
  3349. 1388: 89 91 ld r24, Y+
  3350. 138a: 88 23 and r24, r24
  3351. 138c: e1 f7 brne .-8 ; 0x1386 <LCD_SendStr+0x14>
  3352. data = *str++;
  3353. LCD_WriteData(data);
  3354. }
  3355. }
  3356. 138e: df 91 pop r29
  3357. 1390: cf 91 pop r28
  3358. 1392: ff 90 pop r15
  3359. 1394: ef 90 pop r14
  3360. 1396: 08 95 ret
  3361.  
  3362. 00001398 <LCD_SetUserChar>:
  3363. LCD_WriteData(data);
  3364. }
  3365. }
  3366.  
  3367. void LCD_SetUserChar(uint8_t const *sym, uint8_t adr)
  3368. {
  3369. 1398: 0f 93 push r16
  3370. 139a: 1f 93 push r17
  3371. 139c: cf 93 push r28
  3372. 139e: df 93 push r29
  3373. 13a0: ec 01 movw r28, r24
  3374. uint8_t data;
  3375. uint8_t i;
  3376.  
  3377. LCD_WriteCom((1<<0x06)|((adr&0x07)<<0x03));
  3378. 13a2: 86 2f mov r24, r22
  3379. 13a4: 90 e0 ldi r25, 0x00 ; 0
  3380. 13a6: 87 70 andi r24, 0x07 ; 7
  3381. 13a8: 90 70 andi r25, 0x00 ; 0
  3382. 13aa: 23 e0 ldi r18, 0x03 ; 3
  3383. 13ac: 88 0f add r24, r24
  3384. 13ae: 99 1f adc r25, r25
  3385. 13b0: 2a 95 dec r18
  3386. 13b2: e1 f7 brne .-8 ; 0x13ac <LCD_SetUserChar+0x14>
  3387. 13b4: 80 64 ori r24, 0x40 ; 64
  3388. 13b6: 98 df rcall .-208 ; 0x12e8 <LCD_WriteCom>
  3389. 13b8: 00 e0 ldi r16, 0x00 ; 0
  3390. 13ba: 10 e0 ldi r17, 0x00 ; 0
  3391.  
  3392. i = 0;
  3393. while (i<8){
  3394. data = pgm_read_byte(sym);
  3395. 13bc: fe 01 movw r30, r28
  3396. 13be: e0 0f add r30, r16
  3397. 13c0: f1 1f adc r31, r17
  3398. 13c2: 84 91 lpm r24, Z+
  3399. sym++;
  3400. LCD_WriteData(data);
  3401. 13c4: a2 df rcall .-188 ; 0x130a <LCD_WriteData>
  3402. 13c6: 0f 5f subi r16, 0xFF ; 255
  3403. 13c8: 1f 4f sbci r17, 0xFF ; 255
  3404. uint8_t i;
  3405.  
  3406. LCD_WriteCom((1<<0x06)|((adr&0x07)<<0x03));
  3407.  
  3408. i = 0;
  3409. while (i<8){
  3410. 13ca: 08 30 cpi r16, 0x08 ; 8
  3411. 13cc: 11 05 cpc r17, r1
  3412. 13ce: b1 f7 brne .-20 ; 0x13bc <LCD_SetUserChar+0x24>
  3413. data = pgm_read_byte(sym);
  3414. sym++;
  3415. LCD_WriteData(data);
  3416. i++;
  3417. }
  3418. }
  3419. 13d0: df 91 pop r29
  3420. 13d2: cf 91 pop r28
  3421. 13d4: 1f 91 pop r17
  3422. 13d6: 0f 91 pop r16
  3423. 13d8: 08 95 ret
  3424.  
  3425. 000013da <PutBut>:
  3426. static uint8_t buf[BUT_SIZE_BUF];
  3427. static uint8_t head, tail, count;
  3428.  
  3429. static void PutBut(uint8_t but)
  3430. {
  3431. if (count < BUT_SIZE_BUF){
  3432. 13da: 20 91 6a 03 lds r18, 0x036A
  3433. 13de: 28 30 cpi r18, 0x08 ; 8
  3434. 13e0: 78 f4 brcc .+30 ; 0x1400 <PutBut+0x26>
  3435. buf[head] = but;
  3436. 13e2: 90 91 6b 03 lds r25, 0x036B
  3437. 13e6: e9 2f mov r30, r25
  3438. 13e8: f0 e0 ldi r31, 0x00 ; 0
  3439. 13ea: e4 59 subi r30, 0x94 ; 148
  3440. 13ec: fc 4f sbci r31, 0xFC ; 252
  3441. 13ee: 80 83 st Z, r24
  3442. count++;
  3443. 13f0: 2f 5f subi r18, 0xFF ; 255
  3444. 13f2: 20 93 6a 03 sts 0x036A, r18
  3445. head++;
  3446. 13f6: 89 2f mov r24, r25
  3447. 13f8: 8f 5f subi r24, 0xFF ; 255
  3448. head &= (BUT_SIZE_BUF - 1);
  3449. 13fa: 87 70 andi r24, 0x07 ; 7
  3450. 13fc: 80 93 6b 03 sts 0x036B, r24
  3451. 1400: 08 95 ret
  3452.  
  3453. 00001402 <BUT_Check>:
  3454. }
  3455.  
  3456. /************************************************/
  3457.  
  3458. static void BUT_Check(uint8_t state, uint8_t i, uint8_t settings)
  3459. {
  3460. 1402: 0f 93 push r16
  3461. 1404: 1f 93 push r17
  3462. 1406: cf 93 push r28
  3463. 1408: df 93 push r29
  3464. uint8_t stateTmp;
  3465. uint8_t event;
  3466.  
  3467. i--;
  3468. 140a: 96 2f mov r25, r22
  3469. 140c: 91 50 subi r25, 0x01 ; 1
  3470.  
  3471. stateTmp = stateBut[i];
  3472. 140e: c9 2f mov r28, r25
  3473. 1410: d0 e0 ldi r29, 0x00 ; 0
  3474. 1412: fe 01 movw r30, r28
  3475. 1414: e5 5a subi r30, 0xA5 ; 165
  3476. 1416: fc 4f sbci r31, 0xFC ; 252
  3477. 1418: 10 81 ld r17, Z
  3478. event = 0;
  3479.  
  3480. #if (BUT_DOUBLE_CLICK_EN == 1)
  3481. countHoldTmp = countHold[i];
  3482. 141a: fe 01 movw r30, r28
  3483. 141c: e2 5a subi r30, 0xA2 ; 162
  3484. 141e: fc 4f sbci r31, 0xFC ; 252
  3485. 1420: 90 81 ld r25, Z
  3486. 1422: 90 93 61 03 sts 0x0361, r25
  3487. #endif
  3488.  
  3489. countDebTmp = countDeb[i];
  3490. 1426: fe 01 movw r30, r28
  3491. 1428: ee 0f add r30, r30
  3492. 142a: ff 1f adc r31, r31
  3493. 142c: ee 59 subi r30, 0x9E ; 158
  3494. 142e: fc 4f sbci r31, 0xFC ; 252
  3495. 1430: 20 81 ld r18, Z
  3496. 1432: 31 81 ldd r19, Z+1 ; 0x01
  3497. 1434: 30 93 69 03 sts 0x0369, r19
  3498. 1438: 20 93 68 03 sts 0x0368, r18
  3499.  
  3500. if (state){
  3501. 143c: 88 23 and r24, r24
  3502. 143e: f1 f0 breq .+60 ; 0x147c <BUT_Check+0x7a>
  3503. if (countDebTmp < BUT_COUNT_MAX){
  3504. 1440: 81 e0 ldi r24, 0x01 ; 1
  3505. 1442: 25 3f cpi r18, 0xF5 ; 245
  3506. 1444: 38 07 cpc r19, r24
  3507. 1446: c0 f5 brcc .+112 ; 0x14b8 <BUT_Check+0xb6>
  3508. countDebTmp++;
  3509. 1448: 2f 5f subi r18, 0xFF ; 255
  3510. 144a: 3f 4f sbci r19, 0xFF ; 255
  3511. 144c: 30 93 69 03 sts 0x0369, r19
  3512. 1450: 20 93 68 03 sts 0x0368, r18
  3513.  
  3514. if (countDebTmp > BUT_COUNT_THR){
  3515. 1454: 2b 30 cpi r18, 0x0B ; 11
  3516. 1456: 31 05 cpc r19, r1
  3517. 1458: 78 f1 brcs .+94 ; 0x14b8 <BUT_Check+0xb6>
  3518. if (!(stateTmp & FLAG_BUT_PRESSED)){
  3519. 145a: 10 fd sbrc r17, 0
  3520. 145c: 05 c0 rjmp .+10 ; 0x1468 <BUT_Check+0x66>
  3521. stateTmp |= FLAG_BUT_PRESSED;
  3522. 145e: 11 60 ori r17, 0x01 ; 1
  3523.  
  3524. #if (BUT_PRESSED_EN == 1)
  3525. SaveEvent_m(settings, BUT_EV_PRESSED, BUT_PRESSED_CODE, event);
  3526. 1460: 40 ff sbrs r20, 0
  3527. 1462: 02 c0 rjmp .+4 ; 0x1468 <BUT_Check+0x66>
  3528. 1464: 01 e0 ldi r16, 0x01 ; 1
  3529. 1466: 01 c0 rjmp .+2 ; 0x146a <BUT_Check+0x68>
  3530. uint8_t event;
  3531.  
  3532. i--;
  3533.  
  3534. stateTmp = stateBut[i];
  3535. event = 0;
  3536. 1468: 00 e0 ldi r16, 0x00 ; 0
  3537. SaveEvent_m(settings, BUT_EV_PRESSED, BUT_PRESSED_CODE, event);
  3538. #endif
  3539. }
  3540. }
  3541.  
  3542. if (countDebTmp > BUT_COUNT_HELD){
  3543. 146a: 81 e0 ldi r24, 0x01 ; 1
  3544. 146c: 25 3f cpi r18, 0xF5 ; 245
  3545. 146e: 38 07 cpc r19, r24
  3546. 1470: 21 f5 brne .+72 ; 0x14ba <BUT_Check+0xb8>
  3547. if (!(stateTmp & FLAG_BUT_HOLD)){
  3548. 1472: 11 fd sbrc r17, 1
  3549. 1474: 22 c0 rjmp .+68 ; 0x14ba <BUT_Check+0xb8>
  3550. stateTmp &= ~(FLAG_BUT_RELEASED);
  3551. 1476: 1b 7f andi r17, 0xFB ; 251
  3552. stateTmp |= FLAG_BUT_HOLD;
  3553. 1478: 12 60 ori r17, 0x02 ; 2
  3554. 147a: 1f c0 rjmp .+62 ; 0x14ba <BUT_Check+0xb8>
  3555. }
  3556. }
  3557. else{
  3558.  
  3559. #if (BUT_DOUBLE_CLICK_EN == 1)
  3560. if ((stateTmp & FLAG_BUT_PRESSED)&&(!(stateTmp & FLAG_BUT_HOLD))){
  3561. 147c: 10 ff sbrs r17, 0
  3562. 147e: 0c c0 rjmp .+24 ; 0x1498 <BUT_Check+0x96>
  3563. 1480: 11 fd sbrc r17, 1
  3564. 1482: 0a c0 rjmp .+20 ; 0x1498 <BUT_Check+0x96>
  3565.  
  3566. if (stateTmp & FLAG_BUT_RELEASED){
  3567. 1484: 12 ff sbrs r17, 2
  3568. 1486: 05 c0 rjmp .+10 ; 0x1492 <BUT_Check+0x90>
  3569. stateTmp &= ~FLAG_BUT_RELEASED;
  3570. 1488: 1b 7f andi r17, 0xFB ; 251
  3571. SaveEvent_m(settings, BUT_EV_DOUBLE_CLICK, BUT_DOUBLE_CLICK_CODE, event);
  3572. 148a: 44 ff sbrs r20, 4
  3573. 148c: 05 c0 rjmp .+10 ; 0x1498 <BUT_Check+0x96>
  3574. 148e: 05 e0 ldi r16, 0x05 ; 5
  3575. 1490: 04 c0 rjmp .+8 ; 0x149a <BUT_Check+0x98>
  3576. }
  3577. else{
  3578. countHoldTmp = 0;
  3579. 1492: 10 92 61 03 sts 0x0361, r1
  3580. stateTmp |= FLAG_BUT_RELEASED;
  3581. 1496: 14 60 ori r17, 0x04 ; 4
  3582. uint8_t event;
  3583.  
  3584. i--;
  3585.  
  3586. stateTmp = stateBut[i];
  3587. event = 0;
  3588. 1498: 00 e0 ldi r16, 0x00 ; 0
  3589. countHoldTmp = 0;
  3590. stateTmp |= FLAG_BUT_RELEASED;
  3591. }
  3592. }
  3593.  
  3594. if (stateTmp & FLAG_BUT_RELEASED){
  3595. 149a: 12 ff sbrs r17, 2
  3596. 149c: 07 c0 rjmp .+14 ; 0x14ac <BUT_Check+0xaa>
  3597. if (countHoldTmp > BUT_COUNT_THR_2){
  3598. 149e: 80 91 61 03 lds r24, 0x0361
  3599. 14a2: 89 3c cpi r24, 0xC9 ; 201
  3600. 14a4: 18 f0 brcs .+6 ; 0x14ac <BUT_Check+0xaa>
  3601. countHoldTmp = 0;
  3602. 14a6: 10 92 61 03 sts 0x0361, r1
  3603. stateTmp &= ~FLAG_BUT_RELEASED;
  3604. 14aa: 1b 7f andi r17, 0xFB ; 251
  3605. if ((stateTmp & FLAG_BUT_PRESSED)&&(stateTmp & FLAG_BUT_HOLD)){
  3606. SaveEvent_m(settings, BUT_EV_RELEASED_LONG, BUT_RELEASED_LONG_CODE, event);
  3607. }
  3608. #endif
  3609.  
  3610. countDebTmp = 0;
  3611. 14ac: 10 92 69 03 sts 0x0369, r1
  3612. 14b0: 10 92 68 03 sts 0x0368, r1
  3613. stateTmp &= ~(FLAG_BUT_PRESSED|FLAG_BUT_HOLD);
  3614. 14b4: 1c 7f andi r17, 0xFC ; 252
  3615. 14b6: 01 c0 rjmp .+2 ; 0x14ba <BUT_Check+0xb8>
  3616. uint8_t event;
  3617.  
  3618. i--;
  3619.  
  3620. stateTmp = stateBut[i];
  3621. event = 0;
  3622. 14b8: 00 e0 ldi r16, 0x00 ; 0
  3623. }
  3624.  
  3625.  
  3626.  
  3627. #if (BUT_DOUBLE_CLICK_EN == 1)
  3628. if (stateTmp & FLAG_BUT_RELEASED){
  3629. 14ba: 12 ff sbrs r17, 2
  3630. 14bc: 07 c0 rjmp .+14 ; 0x14cc <BUT_Check+0xca>
  3631. if (countHoldTmp < BUT_COUNT_THR_2_MAX){
  3632. 14be: 80 91 61 03 lds r24, 0x0361
  3633. 14c2: 89 3c cpi r24, 0xC9 ; 201
  3634. 14c4: 18 f4 brcc .+6 ; 0x14cc <BUT_Check+0xca>
  3635. countHoldTmp++;
  3636. 14c6: 8f 5f subi r24, 0xFF ; 255
  3637. 14c8: 80 93 61 03 sts 0x0361, r24
  3638. }
  3639. }
  3640.  
  3641. countHold[i] = countHoldTmp;
  3642. 14cc: fe 01 movw r30, r28
  3643. 14ce: e2 5a subi r30, 0xA2 ; 162
  3644. 14d0: fc 4f sbci r31, 0xFC ; 252
  3645. 14d2: 80 91 61 03 lds r24, 0x0361
  3646. 14d6: 80 83 st Z, r24
  3647. #endif
  3648.  
  3649. if (event){
  3650. 14d8: 00 23 and r16, r16
  3651. 14da: 21 f0 breq .+8 ; 0x14e4 <BUT_Check+0xe2>
  3652. PutBut(i+1);
  3653. 14dc: 86 2f mov r24, r22
  3654. 14de: 7d df rcall .-262 ; 0x13da <PutBut>
  3655. PutBut(event);
  3656. 14e0: 80 2f mov r24, r16
  3657. 14e2: 7b df rcall .-266 ; 0x13da <PutBut>
  3658. }
  3659.  
  3660. countDeb[i] = countDebTmp;
  3661. 14e4: fe 01 movw r30, r28
  3662. 14e6: ee 0f add r30, r30
  3663. 14e8: ff 1f adc r31, r31
  3664. 14ea: ee 59 subi r30, 0x9E ; 158
  3665. 14ec: fc 4f sbci r31, 0xFC ; 252
  3666. 14ee: 80 91 68 03 lds r24, 0x0368
  3667. 14f2: 90 91 69 03 lds r25, 0x0369
  3668. 14f6: 91 83 std Z+1, r25 ; 0x01
  3669. 14f8: 80 83 st Z, r24
  3670. stateBut[i] = stateTmp;
  3671. 14fa: c5 5a subi r28, 0xA5 ; 165
  3672. 14fc: dc 4f sbci r29, 0xFC ; 252
  3673. 14fe: 18 83 st Y, r17
  3674. }
  3675. 1500: df 91 pop r29
  3676. 1502: cf 91 pop r28
  3677. 1504: 1f 91 pop r17
  3678. 1506: 0f 91 pop r16
  3679. 1508: 08 95 ret
  3680.  
  3681. 0000150a <BUT_GetBut>:
  3682.  
  3683. uint8_t BUT_GetBut(void)
  3684. {
  3685. uint8_t but = 0;
  3686.  
  3687. if (count){
  3688. 150a: 20 91 6a 03 lds r18, 0x036A
  3689. 150e: 22 23 and r18, r18
  3690. 1510: 79 f0 breq .+30 ; 0x1530 <BUT_GetBut+0x26>
  3691. but = buf[tail];
  3692. 1512: 90 91 74 03 lds r25, 0x0374
  3693. 1516: e9 2f mov r30, r25
  3694. 1518: f0 e0 ldi r31, 0x00 ; 0
  3695. 151a: e4 59 subi r30, 0x94 ; 148
  3696. 151c: fc 4f sbci r31, 0xFC ; 252
  3697. 151e: 80 81 ld r24, Z
  3698. count--;
  3699. 1520: 21 50 subi r18, 0x01 ; 1
  3700. 1522: 20 93 6a 03 sts 0x036A, r18
  3701. tail++;
  3702. 1526: 9f 5f subi r25, 0xFF ; 255
  3703. tail &= (BUT_SIZE_BUF - 1);
  3704. 1528: 97 70 andi r25, 0x07 ; 7
  3705. 152a: 90 93 74 03 sts 0x0374, r25
  3706. 152e: 08 95 ret
  3707. }
  3708. }
  3709.  
  3710. uint8_t BUT_GetBut(void)
  3711. {
  3712. uint8_t but = 0;
  3713. 1530: 80 e0 ldi r24, 0x00 ; 0
  3714. tail++;
  3715. tail &= (BUT_SIZE_BUF - 1);
  3716. }
  3717.  
  3718. return but;
  3719. }
  3720. 1532: 08 95 ret
  3721.  
  3722. 00001534 <BUT_Init>:
  3723. void BUT_Init(void)
  3724. {
  3725. uint8_t i;
  3726.  
  3727. for(i = 0; i < BUT_AMOUNT; i++){
  3728. countDeb[i] = 0;
  3729. 1534: 10 92 63 03 sts 0x0363, r1
  3730. 1538: 10 92 62 03 sts 0x0362, r1
  3731. stateBut[i] = 0;
  3732. 153c: 10 92 5b 03 sts 0x035B, r1
  3733.  
  3734. #if (BUT_DOUBLE_CLICK_EN == 1)
  3735. countHold[i] = 0;
  3736. 1540: 10 92 5e 03 sts 0x035E, r1
  3737. void BUT_Init(void)
  3738. {
  3739. uint8_t i;
  3740.  
  3741. for(i = 0; i < BUT_AMOUNT; i++){
  3742. countDeb[i] = 0;
  3743. 1544: 10 92 65 03 sts 0x0365, r1
  3744. 1548: 10 92 64 03 sts 0x0364, r1
  3745. stateBut[i] = 0;
  3746. 154c: 10 92 5c 03 sts 0x035C, r1
  3747.  
  3748. #if (BUT_DOUBLE_CLICK_EN == 1)
  3749. countHold[i] = 0;
  3750. 1550: 10 92 5f 03 sts 0x035F, r1
  3751. void BUT_Init(void)
  3752. {
  3753. uint8_t i;
  3754.  
  3755. for(i = 0; i < BUT_AMOUNT; i++){
  3756. countDeb[i] = 0;
  3757. 1554: 10 92 67 03 sts 0x0367, r1
  3758. 1558: 10 92 66 03 sts 0x0366, r1
  3759. stateBut[i] = 0;
  3760. 155c: 10 92 5d 03 sts 0x035D, r1
  3761.  
  3762. #if (BUT_DOUBLE_CLICK_EN == 1)
  3763. countHold[i] = 0;
  3764. 1560: 10 92 60 03 sts 0x0360, r1
  3765. #endif
  3766.  
  3767. }
  3768.  
  3769. for(i = 0; i < BUT_SIZE_BUF; i++){
  3770. buf[i] = 0;
  3771. 1564: 10 92 6c 03 sts 0x036C, r1
  3772. 1568: 10 92 6d 03 sts 0x036D, r1
  3773. 156c: 10 92 6e 03 sts 0x036E, r1
  3774. 1570: 10 92 6f 03 sts 0x036F, r1
  3775. 1574: 10 92 70 03 sts 0x0370, r1
  3776. 1578: 10 92 71 03 sts 0x0371, r1
  3777. 157c: 10 92 72 03 sts 0x0372, r1
  3778. 1580: 10 92 73 03 sts 0x0373, r1
  3779. }
  3780.  
  3781. head = 0;
  3782. 1584: 10 92 6b 03 sts 0x036B, r1
  3783. tail = 0;
  3784. 1588: 10 92 74 03 sts 0x0374, r1
  3785. count = 0;
  3786. 158c: 10 92 6a 03 sts 0x036A, r1
  3787.  
  3788. #ifdef BUT_1_ID
  3789. ButtonInit_m(BUT_1_DDRX, BUT_1_PORTX, BUT_1_PIN, BUT_1_PULL);
  3790. 1590: 8a 98 cbi 0x11, 2 ; 17
  3791. 1592: 92 98 cbi 0x12, 2 ; 18
  3792. #endif
  3793.  
  3794. #ifdef BUT_2_ID
  3795. ButtonInit_m(BUT_2_DDRX, BUT_2_PORTX, BUT_2_PIN, BUT_2_PULL);
  3796. 1594: 8b 98 cbi 0x11, 3 ; 17
  3797. 1596: 93 98 cbi 0x12, 3 ; 18
  3798. #endif
  3799.  
  3800. #ifdef BUT_3_ID
  3801. ButtonInit_m(BUT_3_DDRX, BUT_3_PORTX, BUT_3_PIN, BUT_3_PULL);
  3802. 1598: 8c 98 cbi 0x11, 4 ; 17
  3803. 159a: 94 98 cbi 0x12, 4 ; 18
  3804. #endif
  3805.  
  3806. #ifdef BUT_32_ID
  3807. ButtonInit_m(BUT_32_DDRX, BUT_32_PORTX, BUT_32_PIN, BUT_32_PULL);
  3808. #endif
  3809. }
  3810. 159c: 08 95 ret
  3811.  
  3812. 0000159e <BUT_Poll>:
  3813. uint8_t state = 0;
  3814.  
  3815. Switch_m(i);
  3816.  
  3817. #ifdef BUT_1_ID
  3818. CheckOneBut_m(BUT_1_ID, BUT_1_PINX, BUT_1_PIN, BUT_1_LEV, BUT_1_EVENT, state);
  3819. 159e: 81 e0 ldi r24, 0x01 ; 1
  3820. 15a0: 82 99 sbic 0x10, 2 ; 16
  3821. 15a2: 80 e0 ldi r24, 0x00 ; 0
  3822. 15a4: 61 e0 ldi r22, 0x01 ; 1
  3823. 15a6: 41 e1 ldi r20, 0x11 ; 17
  3824. 15a8: 2c df rcall .-424 ; 0x1402 <BUT_Check>
  3825. #endif
  3826.  
  3827. #ifdef BUT_2_ID
  3828. CheckOneBut_m(BUT_2_ID, BUT_2_PINX, BUT_2_PIN, BUT_2_LEV, BUT_2_EVENT, state);
  3829. 15aa: 81 e0 ldi r24, 0x01 ; 1
  3830. 15ac: 83 99 sbic 0x10, 3 ; 16
  3831. 15ae: 80 e0 ldi r24, 0x00 ; 0
  3832. 15b0: 62 e0 ldi r22, 0x02 ; 2
  3833. 15b2: 41 e0 ldi r20, 0x01 ; 1
  3834. 15b4: 26 df rcall .-436 ; 0x1402 <BUT_Check>
  3835. #endif
  3836.  
  3837. #ifdef BUT_3_ID
  3838. CheckOneBut_m(BUT_3_ID, BUT_3_PINX, BUT_3_PIN, BUT_3_LEV, BUT_3_EVENT, state);
  3839. 15b6: 81 e0 ldi r24, 0x01 ; 1
  3840. 15b8: 84 99 sbic 0x10, 4 ; 16
  3841. 15ba: 80 e0 ldi r24, 0x00 ; 0
  3842. 15bc: 63 e0 ldi r22, 0x03 ; 3
  3843. 15be: 41 e0 ldi r20, 0x01 ; 1
  3844. 15c0: 20 df rcall .-448 ; 0x1402 <BUT_Check>
  3845. if (i >= BUT_AMOUNT){
  3846. i = 0;
  3847. }
  3848. #endif
  3849.  
  3850. }
  3851. 15c2: 08 95 ret
  3852.  
  3853. 000015c4 <USART_Init>:
  3854. #endif
  3855.  
  3856.  
  3857. //инициализация usart`a
  3858. void USART_Init(uint8_t regime, uint16_t baudRate)
  3859. {
  3860. 15c4: 1f 93 push r17
  3861. uint16_t ubrrValue;
  3862.  
  3863. uint8_t save = SREG;
  3864. 15c6: 1f b7 in r17, 0x3f ; 63
  3865. cli();
  3866. 15c8: f8 94 cli
  3867.  
  3868. txBufTail = 0;
  3869. 15ca: 10 92 9a 03 sts 0x039A, r1
  3870. txBufHead = 0;
  3871. 15ce: 10 92 89 03 sts 0x0389, r1
  3872. txCount = 0;
  3873. 15d2: 10 92 88 03 sts 0x0388, r1
  3874.  
  3875. rxBufTail = 0;
  3876. 15d6: 10 92 76 03 sts 0x0376, r1
  3877. rxBufHead = 0;
  3878. 15da: 10 92 87 03 sts 0x0387, r1
  3879. rxCount = 0;
  3880. 15de: 10 92 75 03 sts 0x0375, r1
  3881.  
  3882. UCSRB = 0;
  3883. 15e2: 1a b8 out 0x0a, r1 ; 10
  3884. UCSRC = 0;
  3885. 15e4: 10 bc out 0x20, r1 ; 32
  3886. 15e6: 9b 01 movw r18, r22
  3887. 15e8: 40 e0 ldi r20, 0x00 ; 0
  3888. 15ea: 50 e0 ldi r21, 0x00 ; 0
  3889.  
  3890. if (regime == USART_NORMAL){
  3891. 15ec: 88 23 and r24, r24
  3892. 15ee: 41 f4 brne .+16 ; 0x1600 <USART_Init+0x3c>
  3893. ubrrValue = F_CPU/(16UL*baudRate) - 1;
  3894. 15f0: 94 e0 ldi r25, 0x04 ; 4
  3895. 15f2: 22 0f add r18, r18
  3896. 15f4: 33 1f adc r19, r19
  3897. 15f6: 44 1f adc r20, r20
  3898. 15f8: 55 1f adc r21, r21
  3899. 15fa: 9a 95 dec r25
  3900. 15fc: d1 f7 brne .-12 ; 0x15f2 <USART_Init+0x2e>
  3901. 15fe: 07 c0 rjmp .+14 ; 0x160e <USART_Init+0x4a>
  3902. }
  3903. else{
  3904. ubrrValue = F_CPU/(8UL*baudRate) - 1;
  3905. 1600: 83 e0 ldi r24, 0x03 ; 3
  3906. 1602: 22 0f add r18, r18
  3907. 1604: 33 1f adc r19, r19
  3908. 1606: 44 1f adc r20, r20
  3909. 1608: 55 1f adc r21, r21
  3910. 160a: 8a 95 dec r24
  3911. 160c: d1 f7 brne .-12 ; 0x1602 <USART_Init+0x3e>
  3912. 160e: 60 e0 ldi r22, 0x00 ; 0
  3913. 1610: 72 e1 ldi r23, 0x12 ; 18
  3914. 1612: 8a e7 ldi r24, 0x7A ; 122
  3915. 1614: 90 e0 ldi r25, 0x00 ; 0
  3916. 1616: f3 d0 rcall .+486 ; 0x17fe <__udivmodsi4>
  3917. 1618: 21 50 subi r18, 0x01 ; 1
  3918. 161a: 30 40 sbci r19, 0x00 ; 0
  3919. }
  3920.  
  3921. UBRRH = (uint8_t)(ubrrValue >> 8);
  3922. 161c: 30 bd out 0x20, r19 ; 32
  3923. UBRRL = (uint8_t)ubrrValue;
  3924. 161e: 29 b9 out 0x09, r18 ; 9
  3925.  
  3926. UCSRA = (1<< (1 & U2X));
  3927. 1620: 82 e0 ldi r24, 0x02 ; 2
  3928. 1622: 8b b9 out 0x0b, r24 ; 11
  3929. UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN); //разр. прерыв при приеме, разр приема, разр передачи.
  3930. 1624: 88 e9 ldi r24, 0x98 ; 152
  3931. 1626: 8a b9 out 0x0a, r24 ; 10
  3932. UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); //размер слова 8 разрядов
  3933. 1628: 86 e8 ldi r24, 0x86 ; 134
  3934. 162a: 80 bd out 0x20, r24 ; 32
  3935.  
  3936. SREG = save;
  3937. 162c: 1f bf out 0x3f, r17 ; 63
  3938. }
  3939. 162e: 1f 91 pop r17
  3940. 1630: 08 95 ret
  3941.  
  3942. 00001632 <USART_PutChar>:
  3943. }
  3944.  
  3945. //помещает символ в буфер, инициирует начало передачи
  3946. void USART_PutChar(char sym)
  3947. {
  3948. while(txCount == SIZE_BUF_TX);
  3949. 1632: 90 91 88 03 lds r25, 0x0388
  3950. 1636: 90 31 cpi r25, 0x10 ; 16
  3951. 1638: e1 f3 breq .-8 ; 0x1632 <USART_PutChar>
  3952.  
  3953. cli();
  3954. 163a: f8 94 cli
  3955. if (!txCount){
  3956. 163c: 90 91 88 03 lds r25, 0x0388
  3957. 1640: 99 23 and r25, r25
  3958. 1642: 09 f4 brne .+2 ; 0x1646 <USART_PutChar+0x14>
  3959. UCSRB |= (1<<UDRIE);
  3960. 1644: 55 9a sbi 0x0a, 5 ; 10
  3961. }
  3962. if (txCount < SIZE_BUF_TX){ //если в буфере еще есть место
  3963. 1646: 90 91 88 03 lds r25, 0x0388
  3964. 164a: 90 31 cpi r25, 0x10 ; 16
  3965. 164c: b0 f4 brcc .+44 ; 0x167a <USART_PutChar+0x48>
  3966. usartTxBuf[txBufTail] = sym; //помещаем в него символ
  3967. 164e: e0 91 9a 03 lds r30, 0x039A
  3968. 1652: f0 e0 ldi r31, 0x00 ; 0
  3969. 1654: e6 57 subi r30, 0x76 ; 118
  3970. 1656: fc 4f sbci r31, 0xFC ; 252
  3971. 1658: 80 83 st Z, r24
  3972. txCount++; //инкрементируем счетчик символов
  3973. 165a: 80 91 88 03 lds r24, 0x0388
  3974. 165e: 8f 5f subi r24, 0xFF ; 255
  3975. 1660: 80 93 88 03 sts 0x0388, r24
  3976. txBufTail++; //и индекс хвоста буфера
  3977. 1664: 80 91 9a 03 lds r24, 0x039A
  3978. 1668: 8f 5f subi r24, 0xFF ; 255
  3979. 166a: 80 93 9a 03 sts 0x039A, r24
  3980. if (txBufTail == SIZE_BUF_TX) txBufTail = 0;
  3981. 166e: 80 91 9a 03 lds r24, 0x039A
  3982. 1672: 80 31 cpi r24, 0x10 ; 16
  3983. 1674: 11 f4 brne .+4 ; 0x167a <USART_PutChar+0x48>
  3984. 1676: 10 92 9a 03 sts 0x039A, r1
  3985. }
  3986. sei();
  3987. 167a: 78 94 sei
  3988. }
  3989. 167c: 08 95 ret
  3990.  
  3991. 0000167e <USART_SendStr>:
  3992.  
  3993. //функция посылающая строку из озу по usart`у
  3994. void USART_SendStr(char * data)
  3995. {
  3996. 167e: ef 92 push r14
  3997. 1680: ff 92 push r15
  3998. 1682: cf 93 push r28
  3999. 1684: df 93 push r29
  4000. 1686: e8 2e mov r14, r24
  4001. 1688: e7 01 movw r28, r14
  4002. 168a: 7e 01 movw r14, r28
  4003. 168c: f9 2e mov r15, r25
  4004. 168e: e7 01 movw r28, r14
  4005. char sym;
  4006. while(*data){
  4007. 1690: 01 c0 rjmp .+2 ; 0x1694 <USART_SendStr+0x16>
  4008. sym = *data++;
  4009. USART_PutChar(sym);
  4010. 1692: cf df rcall .-98 ; 0x1632 <USART_PutChar>
  4011.  
  4012. //функция посылающая строку из озу по usart`у
  4013. void USART_SendStr(char * data)
  4014. {
  4015. char sym;
  4016. while(*data){
  4017. 1694: 89 91 ld r24, Y+
  4018. 1696: 88 23 and r24, r24
  4019. 1698: e1 f7 brne .-8 ; 0x1692 <USART_SendStr+0x14>
  4020. sym = *data++;
  4021. USART_PutChar(sym);
  4022. }
  4023. }
  4024. 169a: df 91 pop r29
  4025. 169c: cf 91 pop r28
  4026. 169e: ff 90 pop r15
  4027. 16a0: ef 90 pop r14
  4028. 16a2: 08 95 ret
  4029.  
  4030. 000016a4 <__vector_12>:
  4031. }
  4032. }
  4033.  
  4034. //обработчик прерывания
  4035. ISR(USART_UDRE_vect)
  4036. {
  4037. 16a4: 1f 92 push r1
  4038. 16a6: 0f 92 push r0
  4039. 16a8: 0f b6 in r0, 0x3f ; 63
  4040. 16aa: 0f 92 push r0
  4041. 16ac: 11 24 eor r1, r1
  4042. 16ae: 8f 93 push r24
  4043. 16b0: ef 93 push r30
  4044. 16b2: ff 93 push r31
  4045. if (txCount > 0){ //если буфер не пустой
  4046. 16b4: 80 91 88 03 lds r24, 0x0388
  4047. 16b8: 88 23 and r24, r24
  4048. 16ba: c1 f0 breq .+48 ; 0x16ec <__vector_12+0x48>
  4049. UDR = usartTxBuf[txBufHead]; //записываем в UDR символ из буфера
  4050. 16bc: e0 91 89 03 lds r30, 0x0389
  4051. 16c0: f0 e0 ldi r31, 0x00 ; 0
  4052. 16c2: e6 57 subi r30, 0x76 ; 118
  4053. 16c4: fc 4f sbci r31, 0xFC ; 252
  4054. 16c6: 80 81 ld r24, Z
  4055. 16c8: 8c b9 out 0x0c, r24 ; 12
  4056. txCount--; //уменьшаем счетчик символов
  4057. 16ca: 80 91 88 03 lds r24, 0x0388
  4058. 16ce: 81 50 subi r24, 0x01 ; 1
  4059. 16d0: 80 93 88 03 sts 0x0388, r24
  4060. txBufHead++; //инкрементируем индекс головы буфера
  4061. 16d4: 80 91 89 03 lds r24, 0x0389
  4062. 16d8: 8f 5f subi r24, 0xFF ; 255
  4063. 16da: 80 93 89 03 sts 0x0389, r24
  4064. if (txBufHead == SIZE_BUF_TX) txBufHead = 0;
  4065. 16de: 80 91 89 03 lds r24, 0x0389
  4066. 16e2: 80 31 cpi r24, 0x10 ; 16
  4067. 16e4: 21 f4 brne .+8 ; 0x16ee <__vector_12+0x4a>
  4068. 16e6: 10 92 89 03 sts 0x0389, r1
  4069. 16ea: 01 c0 rjmp .+2 ; 0x16ee <__vector_12+0x4a>
  4070. }
  4071. else{
  4072. UCSRB &= ~(1<<UDRIE);
  4073. 16ec: 55 98 cbi 0x0a, 5 ; 10
  4074. }
  4075. }
  4076. 16ee: ff 91 pop r31
  4077. 16f0: ef 91 pop r30
  4078. 16f2: 8f 91 pop r24
  4079. 16f4: 0f 90 pop r0
  4080. 16f6: 0f be out 0x3f, r0 ; 63
  4081. 16f8: 0f 90 pop r0
  4082. 16fa: 1f 90 pop r1
  4083. 16fc: 18 95 reti
  4084.  
  4085. 000016fe <USART_GetRxCount>:
  4086.  
  4087. //______________________________________________________________________________
  4088. //возвращает колличество символов находящихся в приемном буфере
  4089. uint8_t USART_GetRxCount(void)
  4090. {
  4091. return rxCount;
  4092. 16fe: 80 91 75 03 lds r24, 0x0375
  4093. }
  4094. 1702: 08 95 ret
  4095.  
  4096. 00001704 <USART_GetChar>:
  4097.  
  4098. //чтение буфера
  4099. char USART_GetChar(void)
  4100. {
  4101. char sym;
  4102. if (rxCount > 0){ //если приемный буфер не пустой
  4103. 1704: 80 91 75 03 lds r24, 0x0375
  4104. 1708: 88 23 and r24, r24
  4105. 170a: b9 f0 breq .+46 ; 0x173a <USART_GetChar+0x36>
  4106. sym = usartRxBuf[rxBufHead]; //прочитать из него символ
  4107. 170c: e0 91 87 03 lds r30, 0x0387
  4108. 1710: f0 e0 ldi r31, 0x00 ; 0
  4109. 1712: e9 58 subi r30, 0x89 ; 137
  4110. 1714: fc 4f sbci r31, 0xFC ; 252
  4111. 1716: 80 81 ld r24, Z
  4112. rxCount--; //уменьшить счетчик символов
  4113. 1718: 90 91 75 03 lds r25, 0x0375
  4114. 171c: 91 50 subi r25, 0x01 ; 1
  4115. 171e: 90 93 75 03 sts 0x0375, r25
  4116. rxBufHead++; //инкрементировать индекс головы буфера
  4117. 1722: 90 91 87 03 lds r25, 0x0387
  4118. 1726: 9f 5f subi r25, 0xFF ; 255
  4119. 1728: 90 93 87 03 sts 0x0387, r25
  4120. if (rxBufHead == SIZE_BUF_RX) rxBufHead = 0;
  4121. 172c: 90 91 87 03 lds r25, 0x0387
  4122. 1730: 90 31 cpi r25, 0x10 ; 16
  4123. 1732: 21 f4 brne .+8 ; 0x173c <USART_GetChar+0x38>
  4124. 1734: 10 92 87 03 sts 0x0387, r1
  4125. 1738: 08 95 ret
  4126. return sym; //вернуть прочитанный символ
  4127. }
  4128. return 0;
  4129. 173a: 80 e0 ldi r24, 0x00 ; 0
  4130. }
  4131. 173c: 08 95 ret
  4132.  
  4133. 0000173e <__vector_11>:
  4134.  
  4135. volatile uint8_t block = 0;
  4136.  
  4137. //прерывание по завершению приема
  4138. ISR(USART_RXC_vect)
  4139. {
  4140. 173e: 1f 92 push r1
  4141. 1740: 0f 92 push r0
  4142. 1742: 0f b6 in r0, 0x3f ; 63
  4143. 1744: 0f 92 push r0
  4144. 1746: 11 24 eor r1, r1
  4145. 1748: 8f 93 push r24
  4146. 174a: 9f 93 push r25
  4147. 174c: ef 93 push r30
  4148. 174e: ff 93 push r31
  4149. char data = UDR;
  4150. 1750: 8c b1 in r24, 0x0c ; 12
  4151. if (rxCount < SIZE_BUF_RX){ //если в буфере еще есть место
  4152. 1752: 90 91 75 03 lds r25, 0x0375
  4153. 1756: 90 31 cpi r25, 0x10 ; 16
  4154. 1758: b0 f4 brcc .+44 ; 0x1786 <__vector_11+0x48>
  4155. usartRxBuf[rxBufTail] = data; //считать символ из UDR в буфер
  4156. 175a: e0 91 76 03 lds r30, 0x0376
  4157. 175e: f0 e0 ldi r31, 0x00 ; 0
  4158. 1760: e9 58 subi r30, 0x89 ; 137
  4159. 1762: fc 4f sbci r31, 0xFC ; 252
  4160. 1764: 80 83 st Z, r24
  4161. rxBufTail++; //увеличить индекс хвоста приемного буфера
  4162. 1766: 80 91 76 03 lds r24, 0x0376
  4163. 176a: 8f 5f subi r24, 0xFF ; 255
  4164. 176c: 80 93 76 03 sts 0x0376, r24
  4165. if (rxBufTail == SIZE_BUF_RX) rxBufTail = 0;
  4166. 1770: 80 91 76 03 lds r24, 0x0376
  4167. 1774: 80 31 cpi r24, 0x10 ; 16
  4168. 1776: 11 f4 brne .+4 ; 0x177c <__vector_11+0x3e>
  4169. 1778: 10 92 76 03 sts 0x0376, r1
  4170. rxCount++; //увеличить счетчик принятых символов
  4171. 177c: 80 91 75 03 lds r24, 0x0375
  4172. 1780: 8f 5f subi r24, 0xFF ; 255
  4173. 1782: 80 93 75 03 sts 0x0375, r24
  4174. }
  4175. }
  4176. 1786: ff 91 pop r31
  4177. 1788: ef 91 pop r30
  4178. 178a: 9f 91 pop r25
  4179. 178c: 8f 91 pop r24
  4180. 178e: 0f 90 pop r0
  4181. 1790: 0f be out 0x3f, r0 ; 63
  4182. 1792: 0f 90 pop r0
  4183. 1794: 1f 90 pop r1
  4184. 1796: 18 95 reti
  4185.  
  4186. 00001798 <__mulsi3>:
  4187. 1798: 62 9f mul r22, r18
  4188. 179a: d0 01 movw r26, r0
  4189. 179c: 73 9f mul r23, r19
  4190. 179e: f0 01 movw r30, r0
  4191. 17a0: 82 9f mul r24, r18
  4192. 17a2: e0 0d add r30, r0
  4193. 17a4: f1 1d adc r31, r1
  4194. 17a6: 64 9f mul r22, r20
  4195. 17a8: e0 0d add r30, r0
  4196. 17aa: f1 1d adc r31, r1
  4197. 17ac: 92 9f mul r25, r18
  4198. 17ae: f0 0d add r31, r0
  4199. 17b0: 83 9f mul r24, r19
  4200. 17b2: f0 0d add r31, r0
  4201. 17b4: 74 9f mul r23, r20
  4202. 17b6: f0 0d add r31, r0
  4203. 17b8: 65 9f mul r22, r21
  4204. 17ba: f0 0d add r31, r0
  4205. 17bc: 99 27 eor r25, r25
  4206. 17be: 72 9f mul r23, r18
  4207. 17c0: b0 0d add r27, r0
  4208. 17c2: e1 1d adc r30, r1
  4209. 17c4: f9 1f adc r31, r25
  4210. 17c6: 63 9f mul r22, r19
  4211. 17c8: b0 0d add r27, r0
  4212. 17ca: e1 1d adc r30, r1
  4213. 17cc: f9 1f adc r31, r25
  4214. 17ce: bd 01 movw r22, r26
  4215. 17d0: cf 01 movw r24, r30
  4216. 17d2: 11 24 eor r1, r1
  4217. 17d4: 08 95 ret
  4218.  
  4219. 000017d6 <__udivmodhi4>:
  4220. 17d6: aa 1b sub r26, r26
  4221. 17d8: bb 1b sub r27, r27
  4222. 17da: 51 e1 ldi r21, 0x11 ; 17
  4223. 17dc: 07 c0 rjmp .+14 ; 0x17ec <__udivmodhi4_ep>
  4224.  
  4225. 000017de <__udivmodhi4_loop>:
  4226. 17de: aa 1f adc r26, r26
  4227. 17e0: bb 1f adc r27, r27
  4228. 17e2: a6 17 cp r26, r22
  4229. 17e4: b7 07 cpc r27, r23
  4230. 17e6: 10 f0 brcs .+4 ; 0x17ec <__udivmodhi4_ep>
  4231. 17e8: a6 1b sub r26, r22
  4232. 17ea: b7 0b sbc r27, r23
  4233.  
  4234. 000017ec <__udivmodhi4_ep>:
  4235. 17ec: 88 1f adc r24, r24
  4236. 17ee: 99 1f adc r25, r25
  4237. 17f0: 5a 95 dec r21
  4238. 17f2: a9 f7 brne .-22 ; 0x17de <__udivmodhi4_loop>
  4239. 17f4: 80 95 com r24
  4240. 17f6: 90 95 com r25
  4241. 17f8: bc 01 movw r22, r24
  4242. 17fa: cd 01 movw r24, r26
  4243. 17fc: 08 95 ret
  4244.  
  4245. 000017fe <__udivmodsi4>:
  4246. 17fe: a1 e2 ldi r26, 0x21 ; 33
  4247. 1800: 1a 2e mov r1, r26
  4248. 1802: aa 1b sub r26, r26
  4249. 1804: bb 1b sub r27, r27
  4250. 1806: fd 01 movw r30, r26
  4251. 1808: 0d c0 rjmp .+26 ; 0x1824 <__udivmodsi4_ep>
  4252.  
  4253. 0000180a <__udivmodsi4_loop>:
  4254. 180a: aa 1f adc r26, r26
  4255. 180c: bb 1f adc r27, r27
  4256. 180e: ee 1f adc r30, r30
  4257. 1810: ff 1f adc r31, r31
  4258. 1812: a2 17 cp r26, r18
  4259. 1814: b3 07 cpc r27, r19
  4260. 1816: e4 07 cpc r30, r20
  4261. 1818: f5 07 cpc r31, r21
  4262. 181a: 20 f0 brcs .+8 ; 0x1824 <__udivmodsi4_ep>
  4263. 181c: a2 1b sub r26, r18
  4264. 181e: b3 0b sbc r27, r19
  4265. 1820: e4 0b sbc r30, r20
  4266. 1822: f5 0b sbc r31, r21
  4267.  
  4268. 00001824 <__udivmodsi4_ep>:
  4269. 1824: 66 1f adc r22, r22
  4270. 1826: 77 1f adc r23, r23
  4271. 1828: 88 1f adc r24, r24
  4272. 182a: 99 1f adc r25, r25
  4273. 182c: 1a 94 dec r1
  4274. 182e: 69 f7 brne .-38 ; 0x180a <__udivmodsi4_loop>
  4275. 1830: 60 95 com r22
  4276. 1832: 70 95 com r23
  4277. 1834: 80 95 com r24
  4278. 1836: 90 95 com r25
  4279. 1838: 9b 01 movw r18, r22
  4280. 183a: ac 01 movw r20, r24
  4281. 183c: bd 01 movw r22, r26
  4282. 183e: cf 01 movw r24, r30
  4283. 1840: 08 95 ret
  4284.  
  4285. 00001842 <__divmodsi4>:
  4286. 1842: 97 fb bst r25, 7
  4287. 1844: 09 2e mov r0, r25
  4288. 1846: 05 26 eor r0, r21
  4289. 1848: 0e d0 rcall .+28 ; 0x1866 <__divmodsi4_neg1>
  4290. 184a: 57 fd sbrc r21, 7
  4291. 184c: 04 d0 rcall .+8 ; 0x1856 <__divmodsi4_neg2>
  4292. 184e: d7 df rcall .-82 ; 0x17fe <__udivmodsi4>
  4293. 1850: 0a d0 rcall .+20 ; 0x1866 <__divmodsi4_neg1>
  4294. 1852: 00 1c adc r0, r0
  4295. 1854: 38 f4 brcc .+14 ; 0x1864 <__divmodsi4_exit>
  4296.  
  4297. 00001856 <__divmodsi4_neg2>:
  4298. 1856: 50 95 com r21
  4299. 1858: 40 95 com r20
  4300. 185a: 30 95 com r19
  4301. 185c: 21 95 neg r18
  4302. 185e: 3f 4f sbci r19, 0xFF ; 255
  4303. 1860: 4f 4f sbci r20, 0xFF ; 255
  4304. 1862: 5f 4f sbci r21, 0xFF ; 255
  4305.  
  4306. 00001864 <__divmodsi4_exit>:
  4307. 1864: 08 95 ret
  4308.  
  4309. 00001866 <__divmodsi4_neg1>:
  4310. 1866: f6 f7 brtc .-4 ; 0x1864 <__divmodsi4_exit>
  4311. 1868: 90 95 com r25
  4312. 186a: 80 95 com r24
  4313. 186c: 70 95 com r23
  4314. 186e: 61 95 neg r22
  4315. 1870: 7f 4f sbci r23, 0xFF ; 255
  4316. 1872: 8f 4f sbci r24, 0xFF ; 255
  4317. 1874: 9f 4f sbci r25, 0xFF ; 255
  4318. 1876: 08 95 ret
  4319.  
  4320. 00001878 <ltoa>:
  4321. 1878: fa 01 movw r30, r20
  4322. 187a: cf 93 push r28
  4323. 187c: ff 93 push r31
  4324. 187e: ef 93 push r30
  4325. 1880: 22 30 cpi r18, 0x02 ; 2
  4326. 1882: 3c f1 brlt .+78 ; 0x18d2 <ltoa+0x5a>
  4327. 1884: 25 32 cpi r18, 0x25 ; 37
  4328. 1886: 2c f5 brge .+74 ; 0x18d2 <ltoa+0x5a>
  4329. 1888: c2 2f mov r28, r18
  4330. 188a: e8 94 clt
  4331. 188c: ca 30 cpi r28, 0x0A ; 10
  4332. 188e: 49 f4 brne .+18 ; 0x18a2 <ltoa+0x2a>
  4333. 1890: 97 fb bst r25, 7
  4334. 1892: 3e f4 brtc .+14 ; 0x18a2 <ltoa+0x2a>
  4335. 1894: 90 95 com r25
  4336. 1896: 80 95 com r24
  4337. 1898: 70 95 com r23
  4338. 189a: 61 95 neg r22
  4339. 189c: 7f 4f sbci r23, 0xFF ; 255
  4340. 189e: 8f 4f sbci r24, 0xFF ; 255
  4341. 18a0: 9f 4f sbci r25, 0xFF ; 255
  4342. 18a2: 2c 2f mov r18, r28
  4343. 18a4: 33 27 eor r19, r19
  4344. 18a6: 44 27 eor r20, r20
  4345. 18a8: 55 27 eor r21, r21
  4346. 18aa: ff 93 push r31
  4347. 18ac: ef 93 push r30
  4348. 18ae: a7 df rcall .-178 ; 0x17fe <__udivmodsi4>
  4349. 18b0: ef 91 pop r30
  4350. 18b2: ff 91 pop r31
  4351. 18b4: 60 5d subi r22, 0xD0 ; 208
  4352. 18b6: 6a 33 cpi r22, 0x3A ; 58
  4353. 18b8: 0c f0 brlt .+2 ; 0x18bc <ltoa+0x44>
  4354. 18ba: 69 5d subi r22, 0xD9 ; 217
  4355. 18bc: 61 93 st Z+, r22
  4356. 18be: b9 01 movw r22, r18
  4357. 18c0: ca 01 movw r24, r20
  4358. 18c2: 60 50 subi r22, 0x00 ; 0
  4359. 18c4: 70 40 sbci r23, 0x00 ; 0
  4360. 18c6: 80 40 sbci r24, 0x00 ; 0
  4361. 18c8: 90 40 sbci r25, 0x00 ; 0
  4362. 18ca: 59 f7 brne .-42 ; 0x18a2 <ltoa+0x2a>
  4363. 18cc: 16 f4 brtc .+4 ; 0x18d2 <ltoa+0x5a>
  4364. 18ce: cd e2 ldi r28, 0x2D ; 45
  4365. 18d0: c1 93 st Z+, r28
  4366. 18d2: 10 82 st Z, r1
  4367. 18d4: 8f 91 pop r24
  4368. 18d6: 9f 91 pop r25
  4369. 18d8: cf 91 pop r28
  4370. 18da: 3b c0 rjmp .+118 ; 0x1952 <strrev>
  4371.  
  4372. 000018dc <__eerd_block_m8>:
  4373. 18dc: dc 01 movw r26, r24
  4374. 18de: cb 01 movw r24, r22
  4375.  
  4376. 000018e0 <__eerd_blraw_m8>:
  4377. 18e0: fc 01 movw r30, r24
  4378. 18e2: e1 99 sbic 0x1c, 1 ; 28
  4379. 18e4: fe cf rjmp .-4 ; 0x18e2 <__eerd_blraw_m8+0x2>
  4380. 18e6: 06 c0 rjmp .+12 ; 0x18f4 <__eerd_blraw_m8+0x14>
  4381. 18e8: ff bb out 0x1f, r31 ; 31
  4382. 18ea: ee bb out 0x1e, r30 ; 30
  4383. 18ec: e0 9a sbi 0x1c, 0 ; 28
  4384. 18ee: 31 96 adiw r30, 0x01 ; 1
  4385. 18f0: 0d b2 in r0, 0x1d ; 29
  4386. 18f2: 0d 92 st X+, r0
  4387. 18f4: 41 50 subi r20, 0x01 ; 1
  4388. 18f6: 50 40 sbci r21, 0x00 ; 0
  4389. 18f8: b8 f7 brcc .-18 ; 0x18e8 <__eerd_blraw_m8+0x8>
  4390. 18fa: 08 95 ret
  4391.  
  4392. 000018fc <__eerd_byte_m8>:
  4393. 18fc: e1 99 sbic 0x1c, 1 ; 28
  4394. 18fe: fe cf rjmp .-4 ; 0x18fc <__eerd_byte_m8>
  4395. 1900: 9f bb out 0x1f, r25 ; 31
  4396. 1902: 8e bb out 0x1e, r24 ; 30
  4397. 1904: e0 9a sbi 0x1c, 0 ; 28
  4398. 1906: 99 27 eor r25, r25
  4399. 1908: 8d b3 in r24, 0x1d ; 29
  4400. 190a: 08 95 ret
  4401.  
  4402. 0000190c <__eerd_dword_m8>:
  4403. 190c: a6 e1 ldi r26, 0x16 ; 22
  4404. 190e: b0 e0 ldi r27, 0x00 ; 0
  4405. 1910: 44 e0 ldi r20, 0x04 ; 4
  4406. 1912: 50 e0 ldi r21, 0x00 ; 0
  4407. 1914: e5 cf rjmp .-54 ; 0x18e0 <__eerd_blraw_m8>
  4408.  
  4409. 00001916 <__eewr_block_m8>:
  4410. 1916: dc 01 movw r26, r24
  4411. 1918: cb 01 movw r24, r22
  4412. 191a: 02 c0 rjmp .+4 ; 0x1920 <__eewr_block_m8+0xa>
  4413. 191c: 2d 91 ld r18, X+
  4414. 191e: 05 d0 rcall .+10 ; 0x192a <__eewr_r18_m8>
  4415. 1920: 41 50 subi r20, 0x01 ; 1
  4416. 1922: 50 40 sbci r21, 0x00 ; 0
  4417. 1924: d8 f7 brcc .-10 ; 0x191c <__eewr_block_m8+0x6>
  4418. 1926: 08 95 ret
  4419.  
  4420. 00001928 <__eewr_byte_m8>:
  4421. 1928: 26 2f mov r18, r22
  4422.  
  4423. 0000192a <__eewr_r18_m8>:
  4424. 192a: e1 99 sbic 0x1c, 1 ; 28
  4425. 192c: fe cf rjmp .-4 ; 0x192a <__eewr_r18_m8>
  4426. 192e: 9f bb out 0x1f, r25 ; 31
  4427. 1930: 8e bb out 0x1e, r24 ; 30
  4428. 1932: 2d bb out 0x1d, r18 ; 29
  4429. 1934: 0f b6 in r0, 0x3f ; 63
  4430. 1936: f8 94 cli
  4431. 1938: e2 9a sbi 0x1c, 2 ; 28
  4432. 193a: e1 9a sbi 0x1c, 1 ; 28
  4433. 193c: 0f be out 0x3f, r0 ; 63
  4434. 193e: 01 96 adiw r24, 0x01 ; 1
  4435. 1940: 08 95 ret
  4436.  
  4437. 00001942 <__eewr_dword_m8>:
  4438. 1942: 24 2f mov r18, r20
  4439. 1944: f2 df rcall .-28 ; 0x192a <__eewr_r18_m8>
  4440. 1946: 25 2f mov r18, r21
  4441. 1948: f0 df rcall .-32 ; 0x192a <__eewr_r18_m8>
  4442. 194a: 00 c0 rjmp .+0 ; 0x194c <__eewr_word_m8>
  4443.  
  4444. 0000194c <__eewr_word_m8>:
  4445. 194c: ed df rcall .-38 ; 0x1928 <__eewr_byte_m8>
  4446. 194e: 27 2f mov r18, r23
  4447. 1950: ec cf rjmp .-40 ; 0x192a <__eewr_r18_m8>
  4448.  
  4449. 00001952 <strrev>:
  4450. 1952: dc 01 movw r26, r24
  4451. 1954: fc 01 movw r30, r24
  4452. 1956: 67 2f mov r22, r23
  4453. 1958: 71 91 ld r23, Z+
  4454. 195a: 77 23 and r23, r23
  4455. 195c: e1 f7 brne .-8 ; 0x1956 <strrev+0x4>
  4456. 195e: 32 97 sbiw r30, 0x02 ; 2
  4457. 1960: 04 c0 rjmp .+8 ; 0x196a <strrev+0x18>
  4458. 1962: 7c 91 ld r23, X
  4459. 1964: 6d 93 st X+, r22
  4460. 1966: 70 83 st Z, r23
  4461. 1968: 62 91 ld r22, -Z
  4462. 196a: ae 17 cp r26, r30
  4463. 196c: bf 07 cpc r27, r31
  4464. 196e: c8 f3 brcs .-14 ; 0x1962 <strrev+0x10>
  4465. 1970: 08 95 ret
  4466.  
  4467. 00001972 <_exit>:
  4468. 1972: f8 94 cli
  4469.  
  4470. 00001974 <__stop_program>:
  4471. 1974: ff cf rjmp .-2 ; 0x1974 <__stop_program>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!