VFD_Sinus_AT168.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 00000020 00800100 000013c0 00001474 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 000013c0 00000000 00000000 000000b4 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .bss 0000001c 00800120 00800120 00001494 2**0
ALLOC
3 .eeprom 00000009 00810000 00810000 00001494 2**0
CONTENTS, ALLOC, LOAD, DATA
4 .comment 00000011 00000000 00000000 0000149d 2**0
CONTENTS, READONLY
5 .note.gnu.avr.deviceinfo 0000003c 00000000 00000000 000014b0 2**2
CONTENTS, READONLY
6 .debug_aranges 00000068 00000000 00000000 000014ec 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_info 00001f5b 00000000 00000000 00001554 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_abbrev 000007bf 00000000 00000000 000034af 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_line 00000c8c 00000000 00000000 00003c6e 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_frame 000003ec 00000000 00000000 000048fc 2**2
CONTENTS, READONLY, DEBUGGING
11 .debug_str 00000773 00000000 00000000 00004ce8 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_loc 0000128f 00000000 00000000 0000545b 2**0
CONTENTS, READONLY, DEBUGGING
13 .debug_ranges 00000060 00000000 00000000 000066ea 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 b8 01 jmp 0x370 ; 0x370 <__ctors_end>
4: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
8: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
c: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
10: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
14: 0c 94 cc 04 jmp 0x998 ; 0x998 <__vector_5>
18: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
1c: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
20: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
24: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
28: 0c 94 fc 04 jmp 0x9f8 ; 0x9f8 <__vector_10>
2c: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
30: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
34: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
38: 0c 94 fb 04 jmp 0x9f6 ; 0x9f6 <__vector_14>
3c: 0c 94 fb 04 jmp 0x9f6 ; 0x9f6 <__vector_14>
40: 0c 94 fa 04 jmp 0x9f4 ; 0x9f4 <__vector_16>
44: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
48: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
4c: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
50: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
54: 0c 94 23 06 jmp 0xc46 ; 0xc46 <__vector_21>
58: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
5c: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
60: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
64: 0c 94 d5 01 jmp 0x3aa ; 0x3aa <__bad_interrupt>
00000068 <__trampolines_end>:
68: 46 72 andi r20, 0x26 ; 38
6a: 65 71 andi r22, 0x15 ; 21
6c: 20 20 and r2, r0
6e: 56 2f mov r21, r22
70: 48 7a andi r20, 0xA8 ; 168
72: 20 20 and r2, r0
74: 41 6d ori r20, 0xD1 ; 209
76: 70 20 and r7, r0
...
00000079 <__c.2352>:
79: 50 20 20 20 49 20 20 20 44 20 20 20 20 44 54 20 P I D DT
...
0000008a <__c.2284>:
8a: 52 65 61 64 20 44 6f 6e 65 20 20 20 20 20 20 20 Read Done
...
0000009b <__c.2282>:
9b: 52 65 61 64 69 6e 67 20 45 45 50 52 4f 4d 20 20 Reading EEPROM
...
000000ac <__c.2425>:
ac: 46 72 65 71 20 20 56 2f 48 7a 20 20 41 6d 70 20 Freq V/Hz Amp
...
000000bd <__c.2423>:
bd: 56 46 20 4d 6f 74 6f 72 20 44 72 69 76 65 0a 00 VF Motor Drive..
000000cd <__c.2337>:
cd: 53 74 6f 72 65 64 20 20 20 20 20 20 20 20 20 20 Stored
...
000000de <__c.2321>:
de: 53 74 6f 72 69 6e 67 20 45 45 50 52 4f 4d 20 20 Storing EEPROM
...
000000ef <EndofFile>:
ef: 45 6e 64 65 20 64 65 72 20 46 61 68 6e 65 6e 73 Ende der Fahnens
ff: 74 61 6e 67 65 00 tange.
00000105 <VersionandCopyright>:
105: 31 2e 31 20 28 63 29 32 30 30 39 2d 32 30 31 37 1.1 (c)2009-2017
115: 20 6d 61 74 7a 65 74 72 6f 6e 69 63 73 00 00 00 matzetronics...
125: 00 00 00 00 ....
00000129 <cursorpos>:
129: 00 06 ..
0000012b <cursorextpos>:
12b: 00 04 08 0d ....
0000012f <sineTable>:
12f: 00 00 dd 08 00 e1 11 00 e5 19 00 e8 21 00 ec 2a ............!..*
13f: 00 ef 32 00 f1 3a 00 f4 42 00 f6 4a 00 f8 52 00 ..2..:..B..J..R.
14f: fa 5a 00 fc 62 00 fd 69 00 fe 71 00 fe 78 00 ff .Z..b..i..q..x..
15f: 80 00 ff 87 00 ff 8e 00 fe 95 00 fe 9b 00 fd a2 ................
16f: 00 fc a8 00 fa ae 00 f8 b4 00 f6 ba 00 f4 c0 00 ................
17f: f1 c5 00 ef ca 00 ec cf 00 e8 d4 00 e5 d9 00 e1 ................
18f: dd 00 dd e1 00 d9 e5 00 d4 e8 00 cf ec 00 ca ef ................
19f: 00 c5 f1 00 c0 f4 00 ba f6 00 b4 f8 00 ae fa 00 ................
1af: a8 fc 00 a2 fd 00 9b fe 00 95 fe 00 8e ff 00 87 ................
1bf: ff 00 7f ff 00 78 fe 00 71 fe 00 69 fd 00 62 fc .....x..q..i..b.
1cf: 00 5a fa 00 52 f8 00 4a f6 00 42 f4 00 3a f1 00 .Z..R..J..B..:..
1df: 32 ef 00 2a ec 00 21 e8 00 19 e5 00 11 e1 00 08 2..*..!.........
1ef: dd 00 00 e1 08 00 e5 11 00 e8 19 00 ec 21 00 ef .............!..
1ff: 2a 00 f1 32 00 f4 3a 00 f6 42 00 f8 4a 00 fa 52 *..2..:..B..J..R
20f: 00 fc 5a 00 fd 62 00 fe 69 00 fe 71 00 ff 78 00 ..Z..b..i..q..x.
21f: ff 7f 00 ff 87 00 fe 8e 00 fe 95 00 fd 9b 00 fc ................
22f: a2 00 fa a8 00 f8 ae 00 f6 b4 00 f4 ba 00 f1 c0 ................
23f: 00 ef c5 00 ec ca 00 e8 cf 00 e5 d4 00 e1 d9 00 ................
24f: dd dd 00 d9 e1 00 d4 e5 00 cf e8 00 ca ec 00 c5 ................
25f: ef 00 c0 f1 00 ba f4 00 b4 f6 00 ae f8 00 a8 fa ................
26f: 00 a2 fc 00 9b fd 00 95 fe 00 8e fe 00 87 ff 00 ................
27f: 80 ff 00 78 ff 00 71 fe 00 69 fe 00 62 fd 00 5a ...x..q..i..b..Z
28f: fc 00 52 fa 00 4a f8 00 42 f6 00 3a f4 00 32 f1 ..R..J..B..:..2.
29f: 00 2a ef 00 21 ec 00 19 e8 00 11 e5 00 08 e1 00 .*..!...........
2af: 00 dd 00 00 e1 08 00 e5 11 00 e8 19 00 ec 21 00 ..............!.
2bf: ef 2a 00 f1 32 00 f4 3a 00 f6 42 00 f8 4a 00 fa .*..2..:..B..J..
2cf: 52 00 fc 5a 00 fd 62 00 fe 69 00 fe 71 00 ff 78 R..Z..b..i..q..x
2df: 00 ff 80 00 ff 87 00 fe 8e 00 fe 95 00 fd 9b 00 ................
2ef: fc a2 00 fa a8 00 f8 ae 00 f6 b4 00 f4 ba 00 f1 ................
2ff: c0 00 ef c5 00 ec ca 00 e8 cf 00 e5 d4 00 e1 d9 ................
30f: 00 dd dd 00 d9 e1 00 d4 e5 00 cf e8 00 ca ec 00 ................
31f: c5 ef 00 c0 f1 00 ba f4 00 b4 f6 00 ae f8 00 a8 ................
32f: fa 00 a2 fc 00 9b fd 00 95 fe 00 8e fe 00 87 ff ................
33f: 00 80 ff 00 78 ff 00 71 fe 00 69 fe 00 62 fd 00 ....x..q..i..b..
34f: 5a fc 00 52 fa 00 4a f8 00 42 f6 00 3a f4 00 32 Z..R..J..B..:..2
35f: f1 00 2a ef 00 21 ec 00 19 e8 00 11 e5 00 08 e1 ..*..!..........
...
00000370 <__ctors_end>:
370: 11 24 eor r1, r1
372: 1f be out 0x3f, r1 ; 63
374: cf ef ldi r28, 0xFF ; 255
376: d8 e0 ldi r29, 0x08 ; 8
378: de bf out 0x3e, r29 ; 62
37a: cd bf out 0x3d, r28 ; 61
0000037c <__do_copy_data>:
37c: 11 e0 ldi r17, 0x01 ; 1
37e: a0 e0 ldi r26, 0x00 ; 0
380: b1 e0 ldi r27, 0x01 ; 1
382: e0 ec ldi r30, 0xC0 ; 192
384: f3 e1 ldi r31, 0x13 ; 19
386: 02 c0 rjmp .+4 ; 0x38c <__do_copy_data+0x10>
388: 05 90 lpm r0, Z+
38a: 0d 92 st X+, r0
38c: a0 32 cpi r26, 0x20 ; 32
38e: b1 07 cpc r27, r17
390: d9 f7 brne .-10 ; 0x388 <__do_copy_data+0xc>
00000392 <__do_clear_bss>:
392: 21 e0 ldi r18, 0x01 ; 1
394: a0 e2 ldi r26, 0x20 ; 32
396: b1 e0 ldi r27, 0x01 ; 1
398: 01 c0 rjmp .+2 ; 0x39c <.do_clear_bss_start>
0000039a <.do_clear_bss_loop>:
39a: 1d 92 st X+, r1
0000039c <.do_clear_bss_start>:
39c: ac 33 cpi r26, 0x3C ; 60
39e: b2 07 cpc r27, r18
3a0: e1 f7 brne .-8 ; 0x39a <.do_clear_bss_loop>
3a2: 0e 94 2b 07 call 0xe56 ; 0xe56 <main>
3a6: 0c 94 de 09 jmp 0x13bc ; 0x13bc <_exit>
000003aa <__bad_interrupt>:
3aa: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
000003ae <PID_Init>:
* \param d_factor Derivate term.
* \param pid Struct with PID status.
*/
void PID_Init(int16_t p_factor, int16_t i_factor, int16_t d_factor, pidData_t *pid)
// Set up PID controller parameters
{
3ae: cf 93 push r28
3b0: df 93 push r29
3b2: dc 01 movw r26, r24
3b4: fb 01 movw r30, r22
3b6: e9 01 movw r28, r18
// Start values for PID controller
pid->sumError = 0;
3b8: 1a 82 std Y+2, r1 ; 0x02
3ba: 1b 82 std Y+3, r1 ; 0x03
3bc: 1c 82 std Y+4, r1 ; 0x04
3be: 1d 82 std Y+5, r1 ; 0x05
pid->lastProcessValue = 0;
3c0: 19 82 std Y+1, r1 ; 0x01
3c2: 18 82 st Y, r1
// Tuning constants for PID loop
pid->P_Factor = p_factor;
3c4: 9f 83 std Y+7, r25 ; 0x07
3c6: 8e 83 std Y+6, r24 ; 0x06
pid->I_Factor = i_factor;
3c8: 79 87 std Y+9, r23 ; 0x09
3ca: 68 87 std Y+8, r22 ; 0x08
pid->D_Factor = d_factor;
3cc: 5b 87 std Y+11, r21 ; 0x0b
3ce: 4a 87 std Y+10, r20 ; 0x0a
// Limits to avoid overflow
pid->maxError = MAX_INT / pid->P_Factor;
3d0: 8f ef ldi r24, 0xFF ; 255
3d2: 9f e7 ldi r25, 0x7F ; 127
3d4: bd 01 movw r22, r26
3d6: 0e 94 01 09 call 0x1202 ; 0x1202 <__divmodhi4>
3da: 7d 87 std Y+13, r23 ; 0x0d
3dc: 6c 87 std Y+12, r22 ; 0x0c
pid->maxSumError = MAX_I_TERM / pid->I_Factor;
3de: 9f 01 movw r18, r30
3e0: ff 0f add r31, r31
3e2: 44 0b sbc r20, r20
3e4: 55 0b sbc r21, r21
3e6: 61 e0 ldi r22, 0x01 ; 1
3e8: 70 e0 ldi r23, 0x00 ; 0
3ea: 8f ef ldi r24, 0xFF ; 255
3ec: 9f e7 ldi r25, 0x7F ; 127
3ee: 0e 94 37 09 call 0x126e ; 0x126e <__divmodsi4>
3f2: 2e 87 std Y+14, r18 ; 0x0e
3f4: 3f 87 std Y+15, r19 ; 0x0f
3f6: 48 8b std Y+16, r20 ; 0x10
3f8: 59 8b std Y+17, r21 ; 0x11
}
3fa: df 91 pop r29
3fc: cf 91 pop r28
3fe: 08 95 ret
00000400 <PID_Controller>:
* \param setPoint Desired value.
* \param processValue Measured value.
* \param pid_st PID status struct.
*/
int16_t PID_Controller(int16_t setPoint, int16_t processValue, pidData_t *pid_st)
{
400: ef 92 push r14
402: ff 92 push r15
404: 0f 93 push r16
406: 1f 93 push r17
408: cf 93 push r28
40a: df 93 push r29
40c: 8b 01 movw r16, r22
40e: fa 01 movw r30, r20
int16_t error, p_term, d_term;
int32_t i_term;
int32_t ret;
int32_t temp;
error = setPoint - processValue;
410: 9c 01 movw r18, r24
412: 26 1b sub r18, r22
414: 37 0b sbc r19, r23
// Calculate Pterm and limit error overflow
if (error > pid_st->maxError)
416: 84 85 ldd r24, Z+12 ; 0x0c
418: 95 85 ldd r25, Z+13 ; 0x0d
41a: 82 17 cp r24, r18
41c: 93 07 cpc r25, r19
41e: 84 f0 brlt .+32 ; 0x440 <PID_Controller+0x40>
{
p_term = MAX_INT;
}
else if (error < -pid_st->maxError)
420: 91 95 neg r25
422: 81 95 neg r24
424: 91 09 sbc r25, r1
426: 28 17 cp r18, r24
428: 39 07 cpc r19, r25
42a: 6c f0 brlt .+26 ; 0x446 <PID_Controller+0x46>
{
p_term = -MAX_INT;
}
else
{
p_term = pid_st->P_Factor * error;
42c: 86 81 ldd r24, Z+6 ; 0x06
42e: 97 81 ldd r25, Z+7 ; 0x07
430: 28 9f mul r18, r24
432: e0 01 movw r28, r0
434: 29 9f mul r18, r25
436: d0 0d add r29, r0
438: 38 9f mul r19, r24
43a: d0 0d add r29, r0
43c: 11 24 eor r1, r1
43e: 05 c0 rjmp .+10 ; 0x44a <PID_Controller+0x4a>
error = setPoint - processValue;
// Calculate Pterm and limit error overflow
if (error > pid_st->maxError)
{
p_term = MAX_INT;
440: cf ef ldi r28, 0xFF ; 255
442: df e7 ldi r29, 0x7F ; 127
444: 02 c0 rjmp .+4 ; 0x44a <PID_Controller+0x4a>
}
else if (error < -pid_st->maxError)
{
p_term = -MAX_INT;
446: c1 e0 ldi r28, 0x01 ; 1
448: d0 e8 ldi r29, 0x80 ; 128
{
p_term = pid_st->P_Factor * error;
}
// Calculate Iterm and limit integral runaway
temp = pid_st->sumError + error;
44a: c9 01 movw r24, r18
44c: 33 0f add r19, r19
44e: aa 0b sbc r26, r26
450: bb 0b sbc r27, r27
452: 42 81 ldd r20, Z+2 ; 0x02
454: 53 81 ldd r21, Z+3 ; 0x03
456: 64 81 ldd r22, Z+4 ; 0x04
458: 75 81 ldd r23, Z+5 ; 0x05
45a: 9a 01 movw r18, r20
45c: ab 01 movw r20, r22
45e: 28 0f add r18, r24
460: 39 1f adc r19, r25
462: 4a 1f adc r20, r26
464: 5b 1f adc r21, r27
if(temp > pid_st->maxSumError)
466: 86 85 ldd r24, Z+14 ; 0x0e
468: 97 85 ldd r25, Z+15 ; 0x0f
46a: a0 89 ldd r26, Z+16 ; 0x10
46c: b1 89 ldd r27, Z+17 ; 0x11
46e: 82 17 cp r24, r18
470: 93 07 cpc r25, r19
472: a4 07 cpc r26, r20
474: b5 07 cpc r27, r21
476: 4c f4 brge .+18 ; 0x48a <PID_Controller+0x8a>
{
i_term = MAX_I_TERM;
pid_st->sumError = pid_st->maxSumError;
478: 82 83 std Z+2, r24 ; 0x02
47a: 93 83 std Z+3, r25 ; 0x03
47c: a4 83 std Z+4, r26 ; 0x04
47e: b5 83 std Z+5, r27 ; 0x05
// Calculate Iterm and limit integral runaway
temp = pid_st->sumError + error;
if(temp > pid_st->maxSumError)
{
i_term = MAX_I_TERM;
480: 61 e0 ldi r22, 0x01 ; 1
482: 70 e0 ldi r23, 0x00 ; 0
484: 8f ef ldi r24, 0xFF ; 255
486: 9f e7 ldi r25, 0x7F ; 127
488: 1d c0 rjmp .+58 ; 0x4c4 <PID_Controller+0xc4>
pid_st->sumError = pid_st->maxSumError;
}
else if(temp < -pid_st->maxSumError)
48a: b0 95 com r27
48c: a0 95 com r26
48e: 90 95 com r25
490: 81 95 neg r24
492: 9f 4f sbci r25, 0xFF ; 255
494: af 4f sbci r26, 0xFF ; 255
496: bf 4f sbci r27, 0xFF ; 255
498: 28 17 cp r18, r24
49a: 39 07 cpc r19, r25
49c: 4a 07 cpc r20, r26
49e: 5b 07 cpc r21, r27
4a0: 4c f4 brge .+18 ; 0x4b4 <PID_Controller+0xb4>
{
i_term = -MAX_I_TERM;
pid_st->sumError = -pid_st->maxSumError;
4a2: 82 83 std Z+2, r24 ; 0x02
4a4: 93 83 std Z+3, r25 ; 0x03
4a6: a4 83 std Z+4, r26 ; 0x04
4a8: b5 83 std Z+5, r27 ; 0x05
i_term = MAX_I_TERM;
pid_st->sumError = pid_st->maxSumError;
}
else if(temp < -pid_st->maxSumError)
{
i_term = -MAX_I_TERM;
4aa: 6f ef ldi r22, 0xFF ; 255
4ac: 7f ef ldi r23, 0xFF ; 255
4ae: 80 e0 ldi r24, 0x00 ; 0
4b0: 90 e8 ldi r25, 0x80 ; 128
4b2: 08 c0 rjmp .+16 ; 0x4c4 <PID_Controller+0xc4>
pid_st->sumError = -pid_st->maxSumError;
}
else
{
pid_st->sumError = temp;
4b4: 22 83 std Z+2, r18 ; 0x02
4b6: 33 83 std Z+3, r19 ; 0x03
4b8: 44 83 std Z+4, r20 ; 0x04
4ba: 55 83 std Z+5, r21 ; 0x05
i_term = pid_st->I_Factor * pid_st->sumError;
4bc: a0 85 ldd r26, Z+8 ; 0x08
4be: b1 85 ldd r27, Z+9 ; 0x09
4c0: 0e 94 65 09 call 0x12ca ; 0x12ca <__mulshisi3>
}
// Calculate Dterm
d_term = pid_st->D_Factor * (pid_st->lastProcessValue - processValue);
4c4: 20 81 ld r18, Z
4c6: 31 81 ldd r19, Z+1 ; 0x01
4c8: 20 1b sub r18, r16
4ca: 31 0b sbc r19, r17
4cc: a2 85 ldd r26, Z+10 ; 0x0a
4ce: b3 85 ldd r27, Z+11 ; 0x0b
4d0: 2a 9f mul r18, r26
4d2: 70 01 movw r14, r0
4d4: 2b 9f mul r18, r27
4d6: f0 0c add r15, r0
4d8: 3a 9f mul r19, r26
4da: f0 0c add r15, r0
4dc: 11 24 eor r1, r1
pid_st->lastProcessValue = processValue;
4de: 11 83 std Z+1, r17 ; 0x01
4e0: 00 83 st Z, r16
ret = (p_term + i_term + d_term) / SCALING_FACTOR;
4e2: 8e 01 movw r16, r28
4e4: dd 0f add r29, r29
4e6: 22 0b sbc r18, r18
4e8: 33 0b sbc r19, r19
4ea: ab 01 movw r20, r22
4ec: bc 01 movw r22, r24
4ee: 40 0f add r20, r16
4f0: 51 1f adc r21, r17
4f2: 62 1f adc r22, r18
4f4: 73 1f adc r23, r19
4f6: c7 01 movw r24, r14
4f8: ff 0c add r15, r15
4fa: aa 0b sbc r26, r26
4fc: bb 0b sbc r27, r27
4fe: 8a 01 movw r16, r20
500: 9b 01 movw r18, r22
502: 08 0f add r16, r24
504: 19 1f adc r17, r25
506: 2a 1f adc r18, r26
508: 3b 1f adc r19, r27
50a: c9 01 movw r24, r18
50c: b8 01 movw r22, r16
50e: 20 e0 ldi r18, 0x00 ; 0
510: 31 e0 ldi r19, 0x01 ; 1
512: 40 e0 ldi r20, 0x00 ; 0
514: 50 e0 ldi r21, 0x00 ; 0
516: 0e 94 37 09 call 0x126e ; 0x126e <__divmodsi4>
51a: 21 30 cpi r18, 0x01 ; 1
51c: 10 e8 ldi r17, 0x80 ; 128
51e: 31 07 cpc r19, r17
520: 1f ef ldi r17, 0xFF ; 255
522: 41 07 cpc r20, r17
524: 51 07 cpc r21, r17
526: 24 f4 brge .+8 ; 0x530 <PID_Controller+0x130>
528: 21 e0 ldi r18, 0x01 ; 1
52a: 30 e8 ldi r19, 0x80 ; 128
52c: 4f ef ldi r20, 0xFF ; 255
52e: 5f ef ldi r21, 0xFF ; 255
530: da 01 movw r26, r20
532: c9 01 movw r24, r18
534: 81 15 cp r24, r1
536: 20 e8 ldi r18, 0x80 ; 128
538: 92 07 cpc r25, r18
53a: a1 05 cpc r26, r1
53c: b1 05 cpc r27, r1
53e: 24 f0 brlt .+8 ; 0x548 <PID_Controller+0x148>
540: 8f ef ldi r24, 0xFF ; 255
542: 9f e7 ldi r25, 0x7F ; 127
544: a0 e0 ldi r26, 0x00 ; 0
546: b0 e0 ldi r27, 0x00 ; 0
{
ret = -MAX_INT;
}
return((int16_t)ret);
}
548: df 91 pop r29
54a: cf 91 pop r28
54c: 1f 91 pop r17
54e: 0f 91 pop r16
550: ff 90 pop r15
552: ef 90 pop r14
554: 08 95 ret
00000556 <PID_Reset_Integrator>:
*
* Calling this function will reset the integrator in the PID regulator.
*/
void PID_Reset_Integrator(pidData_t *pid_st)
{
pid_st->sumError = 0;
556: fc 01 movw r30, r24
558: 12 82 std Z+2, r1 ; 0x02
55a: 13 82 std Z+3, r1 ; 0x03
55c: 14 82 std Z+4, r1 ; 0x04
55e: 15 82 std Z+5, r1 ; 0x05
560: 08 95 ret
00000562 <DisablePWMOutputs>:
* all PWM pins as inputs, thus overriding the PWM. The PWM configuration
* itself is not altered in any way by running this function.
*/
static void DisablePWMOutputs(void)
{
DDRB &= ~PWM_PATTERN_PORTB;
562: 84 b1 in r24, 0x04 ; 4
564: 81 7f andi r24, 0xF1 ; 241
566: 84 b9 out 0x04, r24 ; 4
DDRD &= ~PWM_PATTERN_PORTD;
568: 8a b1 in r24, 0x0a ; 10
56a: 87 79 andi r24, 0x97 ; 151
56c: 8a b9 out 0x0a, r24 ; 10
56e: 08 95 ret
00000570 <printbyte>:
* but hey, no money back for saved memory
*/
char hextable[18] = "0123456789ABCDEF";
/* very simple output to hex */
static void printbyte(const unsigned char data)
{
570: cf 93 push r28
572: c8 2f mov r28, r24
lcd_putc(hextable[data >> 4]);
574: e8 2f mov r30, r24
576: e2 95 swap r30
578: ef 70 andi r30, 0x0F ; 15
57a: f0 e0 ldi r31, 0x00 ; 0
57c: e4 5f subi r30, 0xF4 ; 244
57e: fe 4f sbci r31, 0xFE ; 254
580: 80 81 ld r24, Z
582: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
lcd_putc(hextable[data & 0x0f]);
586: cf 70 andi r28, 0x0F ; 15
588: ec 2f mov r30, r28
58a: f0 e0 ldi r31, 0x00 ; 0
58c: e4 5f subi r30, 0xF4 ; 244
58e: fe 4f sbci r31, 0xFE ; 254
590: 80 81 ld r24, Z
}
592: cf 91 pop r28
char hextable[18] = "0123456789ABCDEF";
/* very simple output to hex */
static void printbyte(const unsigned char data)
{
lcd_putc(hextable[data >> 4]);
lcd_putc(hextable[data & 0x0f]);
594: 0c 94 c4 06 jmp 0xd88 ; 0xd88 <lcd_putc>
00000598 <printword>:
}
static void printword(const unsigned int data)
{
598: cf 93 push r28
59a: c8 2f mov r28, r24
printbyte(data >> 8);
59c: 89 2f mov r24, r25
59e: 0e 94 b8 02 call 0x570 ; 0x570 <printbyte>
printbyte(data);
5a2: 8c 2f mov r24, r28
}
5a4: cf 91 pop r28
lcd_putc(hextable[data & 0x0f]);
}
static void printword(const unsigned int data)
{
printbyte(data >> 8);
printbyte(data);
5a6: 0c 94 b8 02 jmp 0x570 ; 0x570 <printbyte>
000005aa <printspc>:
return i;
}
// Console//LCD utilities
static void printspc(void)
{
lcd_putc(' ');
5aa: 80 e2 ldi r24, 0x20 ; 32
5ac: 0c 94 c4 06 jmp 0xd88 ; 0xd88 <lcd_putc>
000005b0 <printdec>:
printbyte(data);
}
/* output a number in decimal style */
char dectable[12] = "000000000000";
char a;
static void printdec(int16_t number) {
5b0: df 92 push r13
5b2: ef 92 push r14
5b4: ff 92 push r15
5b6: 0f 93 push r16
5b8: 1f 93 push r17
5ba: cf 93 push r28
5bc: df 93 push r29
} else if (__radix < 2 || __radix > 36) {
*__s = 0;
return __s;
} else {
extern char *__itoa_ncheck (int, char *, unsigned char);
return __itoa_ncheck (__val, __s, __radix);
5be: 4a e0 ldi r20, 0x0A ; 10
5c0: 60 e0 ldi r22, 0x00 ; 0
5c2: 71 e0 ldi r23, 0x01 ; 1
5c4: 0e 94 78 09 call 0x12f0 ; 0x12f0 <__itoa_ncheck>
uint8_t n,i;
/* yeah, yeah warning "pointer to integer without a cast"
* Am i tired of this or what
*/
a = itoa(number,dectable,10);
5c8: 80 93 3b 01 sts 0x013B, r24 ; 0x80013b <a>
i = strlen(dectable);
5cc: e0 e0 ldi r30, 0x00 ; 0
5ce: f1 e0 ldi r31, 0x01 ; 1
5d0: 01 90 ld r0, Z+
5d2: 00 20 and r0, r0
5d4: e9 f7 brne .-6 ; 0x5d0 <printdec+0x20>
5d6: 31 97 sbiw r30, 0x01 ; 1
5d8: e0 50 subi r30, 0x00 ; 0
5da: f1 40 sbci r31, 0x01 ; 1
5dc: de 2e mov r13, r30
5de: 80 e0 ldi r24, 0x00 ; 0
5e0: e8 2e mov r14, r24
5e2: 81 e0 ldi r24, 0x01 ; 1
5e4: f8 2e mov r15, r24
for (n=0;n < i;n++) {
5e6: 87 01 movw r16, r14
5e8: ff 27 eor r31, r31
if (n == i-1) lcd_putc('.');
5ea: ef 01 movw r28, r30
5ec: 21 97 sbiw r28, 0x01 ; 1
5ee: 80 2f mov r24, r16
5f0: 8e 19 sub r24, r14
/* yeah, yeah warning "pointer to integer without a cast"
* Am i tired of this or what
*/
a = itoa(number,dectable,10);
i = strlen(dectable);
for (n=0;n < i;n++) {
5f2: 8d 15 cp r24, r13
5f4: 78 f4 brcc .+30 ; 0x614 <printdec+0x64>
5f6: c8 01 movw r24, r16
5f8: 80 50 subi r24, 0x00 ; 0
5fa: 91 40 sbci r25, 0x01 ; 1
if (n == i-1) lcd_putc('.');
5fc: 8c 17 cp r24, r28
5fe: 9d 07 cpc r25, r29
600: 19 f4 brne .+6 ; 0x608 <printdec+0x58>
602: 8e e2 ldi r24, 0x2E ; 46
604: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
lcd_putc(dectable[n]);
608: f8 01 movw r30, r16
60a: 81 91 ld r24, Z+
60c: 8f 01 movw r16, r30
60e: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
612: ed cf rjmp .-38 ; 0x5ee <printdec+0x3e>
}
}
614: df 91 pop r29
616: cf 91 pop r28
618: 1f 91 pop r17
61a: 0f 91 pop r16
61c: ff 90 pop r15
61e: ef 90 pop r14
620: df 90 pop r13
622: 08 95 ret
00000624 <InsertDeadband>:
* \param compareValue desired compare value
* \param compareHighPtr Pointer used to return high side compare value with dead band.
* \param compareLowPtr Pointer used to return low side compare value with dead band.
*/
static void InsertDeadband(const uint8_t compareValue, uint8_t * compareHighPtr, uint8_t * compareLowPtr)
{
624: db 01 movw r26, r22
626: fa 01 movw r30, r20
if (compareValue <= DEAD_TIME_HALF)
628: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <DEAD_TIME_HALF>
62c: 98 17 cp r25, r24
62e: 10 f0 brcs .+4 ; 0x634 <InsertDeadband+0x10>
{
*compareHighPtr = 0x00;
630: 1c 92 st X, r1
632: 1a c0 rjmp .+52 ; 0x668 <InsertDeadband+0x44>
*compareLowPtr = compareValue;
}
else if (compareValue >= (0xff - DEAD_TIME_HALF))
634: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <DEAD_TIME_HALF>
638: 48 2f mov r20, r24
63a: 50 e0 ldi r21, 0x00 ; 0
63c: 2f ef ldi r18, 0xFF ; 255
63e: 30 e0 ldi r19, 0x00 ; 0
640: 29 1b sub r18, r25
642: 31 09 sbc r19, r1
644: 42 17 cp r20, r18
646: 53 07 cpc r21, r19
648: 3c f0 brlt .+14 ; 0x658 <InsertDeadband+0x34>
{
*compareHighPtr = 0xff - (2 * DEAD_TIME_HALF);
64a: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
64e: 88 0f add r24, r24
650: 80 95 com r24
652: 8c 93 st X, r24
*compareLowPtr = 0xff;
654: 8f ef ldi r24, 0xFF ; 255
656: 08 c0 rjmp .+16 ; 0x668 <InsertDeadband+0x44>
}
else
{
*compareHighPtr = compareValue - DEAD_TIME_HALF;
658: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <DEAD_TIME_HALF>
65c: 28 2f mov r18, r24
65e: 29 1b sub r18, r25
660: 2c 93 st X, r18
*compareLowPtr = compareValue + DEAD_TIME_HALF;
662: 90 91 1e 01 lds r25, 0x011E ; 0x80011e <DEAD_TIME_HALF>
666: 89 0f add r24, r25
668: 80 83 st Z, r24
66a: 08 95 ret
0000066c <keyin>:
* note that debouncing is not really necessary here as the polling routine
* just happens to pass by.
*/
char keyin(void){
uint8_t i = 0;
i = ~BUTTON_PORT;
66c: 89 b1 in r24, 0x09 ; 9
66e: 80 95 com r24
i &= BUTTON_MASK;
return i;
}
670: 87 70 andi r24, 0x07 ; 7
672: 08 95 ret
00000674 <wrEEPROM>:
* IRQs must be disabled before writing and are re-enabled afterwards
* therefore disabling the PWM is safest. Reestablishing sine driving is done
* by resetting the waveform to undefined. The timer IRQ will handle the remains.
*/
void wrEEPROM(void) {
lcd_gotoxy(0,1);
674: 61 e0 ldi r22, 0x01 ; 1
676: 80 e0 ldi r24, 0x00 ; 0
678: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
lcd_puts_P( "Storing EEPROM " );
67c: 8e ed ldi r24, 0xDE ; 222
67e: 90 e0 ldi r25, 0x00 ; 0
680: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
cli();
684: f8 94 cli
DisablePWMOutputs();
686: 0e 94 b1 02 call 0x562 ; 0x562 <DisablePWMOutputs>
// real writing is here
eeprom_busy_wait();
68a: f9 99 sbic 0x1f, 1 ; 31
68c: fe cf rjmp .-4 ; 0x68a <wrEEPROM+0x16>
eeprom_write_byte(&ee_DEAD_TIME_HALF,DEAD_TIME_HALF);
68e: 60 91 1e 01 lds r22, 0x011E ; 0x80011e <DEAD_TIME_HALF>
692: 88 e0 ldi r24, 0x08 ; 8
694: 90 e0 ldi r25, 0x00 ; 0
696: 0e 94 bb 09 call 0x1376 ; 0x1376 <eeprom_write_byte>
eeprom_busy_wait();
69a: f9 99 sbic 0x1f, 1 ; 31
69c: fe cf rjmp .-4 ; 0x69a <wrEEPROM+0x26>
eeprom_write_byte(&ee_Inco,Inco);
69e: 68 2d mov r22, r8
6a0: 87 e0 ldi r24, 0x07 ; 7
6a2: 90 e0 ldi r25, 0x00 ; 0
6a4: 0e 94 bb 09 call 0x1376 ; 0x1376 <eeprom_write_byte>
eeprom_busy_wait();
6a8: f9 99 sbic 0x1f, 1 ; 31
6aa: fe cf rjmp .-4 ; 0x6a8 <wrEEPROM+0x34>
eeprom_write_byte(&ee_VperHz,VperHz);
6ac: 67 2d mov r22, r7
6ae: 86 e0 ldi r24, 0x06 ; 6
6b0: 90 e0 ldi r25, 0x00 ; 0
6b2: 0e 94 bb 09 call 0x1376 ; 0x1376 <eeprom_write_byte>
eeprom_busy_wait();
6b6: f9 99 sbic 0x1f, 1 ; 31
6b8: fe cf rjmp .-4 ; 0x6b6 <wrEEPROM+0x42>
// write PID values
eeprom_write_word(&ee_pid_P,pidParameters.P_Factor);
6ba: 60 91 2c 01 lds r22, 0x012C ; 0x80012c <pidParameters+0x6>
6be: 70 91 2d 01 lds r23, 0x012D ; 0x80012d <pidParameters+0x7>
6c2: 84 e0 ldi r24, 0x04 ; 4
6c4: 90 e0 ldi r25, 0x00 ; 0
6c6: 0e 94 c9 09 call 0x1392 ; 0x1392 <eeprom_write_word>
eeprom_busy_wait();
6ca: f9 99 sbic 0x1f, 1 ; 31
6cc: fe cf rjmp .-4 ; 0x6ca <wrEEPROM+0x56>
eeprom_write_word(&ee_pid_I,pidParameters.I_Factor);
6ce: 60 91 2e 01 lds r22, 0x012E ; 0x80012e <pidParameters+0x8>
6d2: 70 91 2f 01 lds r23, 0x012F ; 0x80012f <pidParameters+0x9>
6d6: 82 e0 ldi r24, 0x02 ; 2
6d8: 90 e0 ldi r25, 0x00 ; 0
6da: 0e 94 c9 09 call 0x1392 ; 0x1392 <eeprom_write_word>
eeprom_busy_wait();
6de: f9 99 sbic 0x1f, 1 ; 31
6e0: fe cf rjmp .-4 ; 0x6de <wrEEPROM+0x6a>
eeprom_write_word(&ee_pid_D,pidParameters.D_Factor);
6e2: 60 91 30 01 lds r22, 0x0130 ; 0x800130 <pidParameters+0xa>
6e6: 70 91 31 01 lds r23, 0x0131 ; 0x800131 <pidParameters+0xb>
6ea: 80 e0 ldi r24, 0x00 ; 0
6ec: 90 e0 ldi r25, 0x00 ; 0
6ee: 0e 94 c9 09 call 0x1392 ; 0x1392 <eeprom_write_word>
eeprom_busy_wait();
6f2: f9 99 sbic 0x1f, 1 ; 31
6f4: fe cf rjmp .-4 ; 0x6f2 <wrEEPROM+0x7e>
// tell the interrupt to reestablish Sine Driving
fastFlags.driveWaveform = WAVEFORM_UNDEFINED;
6f6: 29 2d mov r18, r9
6f8: 2c 60 ori r18, 0x0C ; 12
6fa: 92 2e mov r9, r18
sei();
6fc: 78 94 sei
#else
//round up by default
__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
#endif
__builtin_avr_delay_cycles(__ticks_dc);
6fe: 8f ef ldi r24, 0xFF ; 255
700: 99 e6 ldi r25, 0x69 ; 105
702: 28 e1 ldi r18, 0x18 ; 24
704: 81 50 subi r24, 0x01 ; 1
706: 90 40 sbci r25, 0x00 ; 0
708: 20 40 sbci r18, 0x00 ; 0
70a: e1 f7 brne .-8 ; 0x704 <wrEEPROM+0x90>
70c: 00 c0 rjmp .+0 ; 0x70e <wrEEPROM+0x9a>
70e: 00 00 nop
// tell the user
_delay_ms(500);
lcd_gotoxy(0,1);
710: 61 e0 ldi r22, 0x01 ; 1
712: 80 e0 ldi r24, 0x00 ; 0
714: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
lcd_puts_P( "Stored " );
718: 8d ec ldi r24, 0xCD ; 205
71a: 90 e0 ldi r25, 0x00 ; 0
71c: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
720: 8f ef ldi r24, 0xFF ; 255
722: 99 e6 ldi r25, 0x69 ; 105
724: 28 e1 ldi r18, 0x18 ; 24
726: 81 50 subi r24, 0x01 ; 1
728: 90 40 sbci r25, 0x00 ; 0
72a: 20 40 sbci r18, 0x00 ; 0
72c: e1 f7 brne .-8 ; 0x726 <wrEEPROM+0xb2>
72e: 00 c0 rjmp .+0 ; 0x730 <wrEEPROM+0xbc>
730: 00 00 nop
_delay_ms(500);
// wait for button release
if (keyin() > 0){};
732: 0c 94 36 03 jmp 0x66c ; 0x66c <keyin>
00000736 <execExtendedCommand>:
* Adjust in a safe environment with current monitoring.
* Place on the LCD is limited, thus PID and DT is displayed as Hex.
* Wrap around on these values should be avoided, thus the range check
*/
static void execExtendedCommand(void)
{
736: ef 92 push r14
738: ff 92 push r15
73a: 0f 93 push r16
73c: 1f 93 push r17
73e: cf 93 push r28
740: df 93 push r29
char n=0;
uint8_t j=0;
lcd_home();
742: 0e 94 c1 06 call 0xd82 ; 0xd82 <lcd_home>
// this line is only written once, actual values are always displayed in line 2
lcd_puts_P( "P I D DT " );
746: 89 e7 ldi r24, 0x79 ; 121
748: 90 e0 ldi r25, 0x00 ; 0
74a: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
parameter = 0;
74e: 10 92 21 01 sts 0x0121, r1 ; 0x800121 <parameter>
// wait for button release
while (keyin()!=0){};
752: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
756: 81 11 cpse r24, r1
758: fc cf rjmp .-8 ; 0x752 <execExtendedCommand+0x1c>
75a: d0 e0 ldi r29, 0x00 ; 0
break;
case 2 : if (pidParameters.D_Factor > 65534) pidParameters.D_Factor = 65534;
pidParameters.D_Factor++;
break;
case 3 : DEAD_TIME_HALF++;
if (DEAD_TIME_HALF > 200) DEAD_TIME_HALF = 200;
75c: 88 ec ldi r24, 0xC8 ; 200
75e: f8 2e mov r15, r24
case 2 :
switch (parameter) {
case 0 : if (pidParameters.P_Factor < 1) pidParameters.P_Factor = 1;
pidParameters.P_Factor--;
break;
case 1 : if (pidParameters.I_Factor < 1) pidParameters.I_Factor = 1;
760: 01 e0 ldi r16, 0x01 ; 1
762: 10 e0 ldi r17, 0x00 ; 0
break;
case 2 : if (pidParameters.D_Factor < 1) pidParameters.D_Factor = 1;
pidParameters.D_Factor--;
break;
case 3 : DEAD_TIME_HALF--;
if (DEAD_TIME_HALF < MIN_DEAD_TIME) DEAD_TIME_HALF = MIN_DEAD_TIME;
764: 98 e0 ldi r25, 0x08 ; 8
766: e9 2e mov r14, r25
parameter = 0;
// wait for button release
while (keyin()!=0){};
// pressing black and green button simultaneously exits this menu
while (n != 5) {
n = keyin();
768: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
76c: c8 2f mov r28, r24
switch (n)
76e: 83 30 cpi r24, 0x03 ; 3
770: 09 f4 brne .+2 ; 0x774 <execExtendedCommand+0x3e>
772: a5 c0 rjmp .+330 ; 0x8be <execExtendedCommand+0x188>
774: 28 f4 brcc .+10 ; 0x780 <execExtendedCommand+0x4a>
776: 81 30 cpi r24, 0x01 ; 1
778: 59 f0 breq .+22 ; 0x790 <execExtendedCommand+0x5a>
77a: 82 30 cpi r24, 0x02 ; 2
77c: b1 f0 breq .+44 ; 0x7aa <execExtendedCommand+0x74>
77e: 06 c0 rjmp .+12 ; 0x78c <execExtendedCommand+0x56>
780: 84 30 cpi r24, 0x04 ; 4
782: 09 f4 brne .+2 ; 0x786 <execExtendedCommand+0x50>
784: 5c c0 rjmp .+184 ; 0x83e <execExtendedCommand+0x108>
786: 85 30 cpi r24, 0x05 ; 5
788: 09 f4 brne .+2 ; 0x78c <execExtendedCommand+0x56>
78a: 9b c0 rjmp .+310 ; 0x8c2 <execExtendedCommand+0x18c>
// pressing black (1) and red (2) button simultaneously writes EEPROM
case 3 : wrEEPROM(); break;
// pressing black and green(4) button simultaneously exits this menu
case 5 : break;
default: j = 0; break;
78c: d0 e0 ldi r29, 0x00 ; 0
78e: 99 c0 rjmp .+306 ; 0x8c2 <execExtendedCommand+0x18c>
while (n != 5) {
n = keyin();
switch (n)
{
// cycle through parameters
case 1 : parameter++; if (parameter > EXTNUMPARAMS) parameter = 0;
790: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
794: 8f 5f subi r24, 0xFF ; 255
796: 80 93 21 01 sts 0x0121, r24 ; 0x800121 <parameter>
79a: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
79e: 84 30 cpi r24, 0x04 ; 4
7a0: 08 f4 brcc .+2 ; 0x7a4 <execExtendedCommand+0x6e>
7a2: 8f c0 rjmp .+286 ; 0x8c2 <execExtendedCommand+0x18c>
7a4: 10 92 21 01 sts 0x0121, r1 ; 0x800121 <parameter>
7a8: 8c c0 rjmp .+280 ; 0x8c2 <execExtendedCommand+0x18c>
break;
// red button decrements parameter
case 2 :
switch (parameter) {
7aa: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
7ae: 81 30 cpi r24, 0x01 ; 1
7b0: b9 f0 breq .+46 ; 0x7e0 <execExtendedCommand+0xaa>
7b2: 28 f0 brcs .+10 ; 0x7be <execExtendedCommand+0x88>
7b4: 82 30 cpi r24, 0x02 ; 2
7b6: 29 f1 breq .+74 ; 0x802 <execExtendedCommand+0xcc>
7b8: 83 30 cpi r24, 0x03 ; 3
7ba: a1 f1 breq .+104 ; 0x824 <execExtendedCommand+0xee>
7bc: 82 c0 rjmp .+260 ; 0x8c2 <execExtendedCommand+0x18c>
case 0 : if (pidParameters.P_Factor < 1) pidParameters.P_Factor = 1;
7be: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
7c2: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
7c6: 18 16 cp r1, r24
7c8: 19 06 cpc r1, r25
7ca: 24 f0 brlt .+8 ; 0x7d4 <execExtendedCommand+0x9e>
7cc: 10 93 2d 01 sts 0x012D, r17 ; 0x80012d <pidParameters+0x7>
7d0: 00 93 2c 01 sts 0x012C, r16 ; 0x80012c <pidParameters+0x6>
pidParameters.P_Factor--;
7d4: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
7d8: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
7dc: 01 97 sbiw r24, 0x01 ; 1
7de: 42 c0 rjmp .+132 ; 0x864 <execExtendedCommand+0x12e>
break;
case 1 : if (pidParameters.I_Factor < 1) pidParameters.I_Factor = 1;
7e0: 80 91 2e 01 lds r24, 0x012E ; 0x80012e <pidParameters+0x8>
7e4: 90 91 2f 01 lds r25, 0x012F ; 0x80012f <pidParameters+0x9>
7e8: 18 16 cp r1, r24
7ea: 19 06 cpc r1, r25
7ec: 24 f0 brlt .+8 ; 0x7f6 <execExtendedCommand+0xc0>
7ee: 10 93 2f 01 sts 0x012F, r17 ; 0x80012f <pidParameters+0x9>
7f2: 00 93 2e 01 sts 0x012E, r16 ; 0x80012e <pidParameters+0x8>
pidParameters.I_Factor--;
7f6: 80 91 2e 01 lds r24, 0x012E ; 0x80012e <pidParameters+0x8>
7fa: 90 91 2f 01 lds r25, 0x012F ; 0x80012f <pidParameters+0x9>
7fe: 01 97 sbiw r24, 0x01 ; 1
800: 3f c0 rjmp .+126 ; 0x880 <execExtendedCommand+0x14a>
break;
case 2 : if (pidParameters.D_Factor < 1) pidParameters.D_Factor = 1;
802: 80 91 30 01 lds r24, 0x0130 ; 0x800130 <pidParameters+0xa>
806: 90 91 31 01 lds r25, 0x0131 ; 0x800131 <pidParameters+0xb>
80a: 18 16 cp r1, r24
80c: 19 06 cpc r1, r25
80e: 24 f0 brlt .+8 ; 0x818 <execExtendedCommand+0xe2>
810: 10 93 31 01 sts 0x0131, r17 ; 0x800131 <pidParameters+0xb>
814: 00 93 30 01 sts 0x0130, r16 ; 0x800130 <pidParameters+0xa>
pidParameters.D_Factor--;
818: 80 91 30 01 lds r24, 0x0130 ; 0x800130 <pidParameters+0xa>
81c: 90 91 31 01 lds r25, 0x0131 ; 0x800131 <pidParameters+0xb>
820: 01 97 sbiw r24, 0x01 ; 1
822: 3c c0 rjmp .+120 ; 0x89c <execExtendedCommand+0x166>
break;
case 3 : DEAD_TIME_HALF--;
824: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
828: 81 50 subi r24, 0x01 ; 1
82a: 80 93 1e 01 sts 0x011E, r24 ; 0x80011e <DEAD_TIME_HALF>
if (DEAD_TIME_HALF < MIN_DEAD_TIME) DEAD_TIME_HALF = MIN_DEAD_TIME;
82e: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
832: 88 30 cpi r24, 0x08 ; 8
834: 08 f0 brcs .+2 ; 0x838 <execExtendedCommand+0x102>
836: 45 c0 rjmp .+138 ; 0x8c2 <execExtendedCommand+0x18c>
838: e0 92 1e 01 sts 0x011E, r14 ; 0x80011e <DEAD_TIME_HALF>
83c: 42 c0 rjmp .+132 ; 0x8c2 <execExtendedCommand+0x18c>
default : break;
}
break;
// green button increments parameter
case 4 :
switch (parameter) {
83e: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
842: 81 30 cpi r24, 0x01 ; 1
844: a1 f0 breq .+40 ; 0x86e <execExtendedCommand+0x138>
846: 28 f0 brcs .+10 ; 0x852 <execExtendedCommand+0x11c>
848: 82 30 cpi r24, 0x02 ; 2
84a: f9 f0 breq .+62 ; 0x88a <execExtendedCommand+0x154>
84c: 83 30 cpi r24, 0x03 ; 3
84e: 59 f1 breq .+86 ; 0x8a6 <execExtendedCommand+0x170>
850: 38 c0 rjmp .+112 ; 0x8c2 <execExtendedCommand+0x18c>
case 0 : if (pidParameters.P_Factor > 65534) pidParameters.P_Factor = 65534;
852: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
856: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
pidParameters.P_Factor++;
85a: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
85e: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
862: 01 96 adiw r24, 0x01 ; 1
864: 90 93 2d 01 sts 0x012D, r25 ; 0x80012d <pidParameters+0x7>
868: 80 93 2c 01 sts 0x012C, r24 ; 0x80012c <pidParameters+0x6>
break;
86c: 2a c0 rjmp .+84 ; 0x8c2 <execExtendedCommand+0x18c>
case 1 : if (pidParameters.I_Factor > 65534) pidParameters.I_Factor = 65534;
86e: 80 91 2e 01 lds r24, 0x012E ; 0x80012e <pidParameters+0x8>
872: 90 91 2f 01 lds r25, 0x012F ; 0x80012f <pidParameters+0x9>
pidParameters.I_Factor++;
876: 80 91 2e 01 lds r24, 0x012E ; 0x80012e <pidParameters+0x8>
87a: 90 91 2f 01 lds r25, 0x012F ; 0x80012f <pidParameters+0x9>
87e: 01 96 adiw r24, 0x01 ; 1
880: 90 93 2f 01 sts 0x012F, r25 ; 0x80012f <pidParameters+0x9>
884: 80 93 2e 01 sts 0x012E, r24 ; 0x80012e <pidParameters+0x8>
break;
888: 1c c0 rjmp .+56 ; 0x8c2 <execExtendedCommand+0x18c>
case 2 : if (pidParameters.D_Factor > 65534) pidParameters.D_Factor = 65534;
88a: 80 91 30 01 lds r24, 0x0130 ; 0x800130 <pidParameters+0xa>
88e: 90 91 31 01 lds r25, 0x0131 ; 0x800131 <pidParameters+0xb>
pidParameters.D_Factor++;
892: 80 91 30 01 lds r24, 0x0130 ; 0x800130 <pidParameters+0xa>
896: 90 91 31 01 lds r25, 0x0131 ; 0x800131 <pidParameters+0xb>
89a: 01 96 adiw r24, 0x01 ; 1
89c: 90 93 31 01 sts 0x0131, r25 ; 0x800131 <pidParameters+0xb>
8a0: 80 93 30 01 sts 0x0130, r24 ; 0x800130 <pidParameters+0xa>
break;
8a4: 0e c0 rjmp .+28 ; 0x8c2 <execExtendedCommand+0x18c>
case 3 : DEAD_TIME_HALF++;
8a6: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
8aa: 8f 5f subi r24, 0xFF ; 255
8ac: 80 93 1e 01 sts 0x011E, r24 ; 0x80011e <DEAD_TIME_HALF>
if (DEAD_TIME_HALF > 200) DEAD_TIME_HALF = 200;
8b0: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
8b4: 89 3c cpi r24, 0xC9 ; 201
8b6: 28 f0 brcs .+10 ; 0x8c2 <execExtendedCommand+0x18c>
8b8: f0 92 1e 01 sts 0x011E, r15 ; 0x80011e <DEAD_TIME_HALF>
8bc: 02 c0 rjmp .+4 ; 0x8c2 <execExtendedCommand+0x18c>
break;
default : break;
}
break;
// pressing black (1) and red (2) button simultaneously writes EEPROM
case 3 : wrEEPROM(); break;
8be: 0e 94 3a 03 call 0x674 ; 0x674 <wrEEPROM>
// pressing black and green(4) button simultaneously exits this menu
case 5 : break;
default: j = 0; break;
} // switch
PID_Init(pidParameters.P_Factor, pidParameters.I_Factor, pidParameters.D_Factor,(pidData_t *) &pidParameters);
8c2: 40 91 30 01 lds r20, 0x0130 ; 0x800130 <pidParameters+0xa>
8c6: 50 91 31 01 lds r21, 0x0131 ; 0x800131 <pidParameters+0xb>
8ca: 60 91 2e 01 lds r22, 0x012E ; 0x80012e <pidParameters+0x8>
8ce: 70 91 2f 01 lds r23, 0x012F ; 0x80012f <pidParameters+0x9>
8d2: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
8d6: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
8da: 26 e2 ldi r18, 0x26 ; 38
8dc: 31 e0 ldi r19, 0x01 ; 1
8de: 0e 94 d7 01 call 0x3ae ; 0x3ae <PID_Init>
// includes a little autorepeat accelerator
if (keyin() > 0) {
8e2: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
8e6: 88 23 and r24, r24
8e8: a1 f0 breq .+40 ; 0x912 <__stack+0x13>
j++;
8ea: df 5f subi r29, 0xFF ; 255
if (j<10) _delay_ms(60);
8ec: da 30 cpi r29, 0x0A ; 10
8ee: 50 f4 brcc .+20 ; 0x904 <__stack+0x5>
8f0: 2f ef ldi r18, 0xFF ; 255
8f2: 8d ee ldi r24, 0xED ; 237
8f4: 92 e0 ldi r25, 0x02 ; 2
8f6: 21 50 subi r18, 0x01 ; 1
8f8: 80 40 sbci r24, 0x00 ; 0
8fa: 90 40 sbci r25, 0x00 ; 0
8fc: e1 f7 brne .-8 ; 0x8f6 <execExtendedCommand+0x1c0>
8fe: 00 c0 rjmp .+0 ; 0x900 <__stack+0x1>
900: 00 00 nop
902: 07 c0 rjmp .+14 ; 0x912 <__stack+0x13>
904: 8f e3 ldi r24, 0x3F ; 63
906: 9c e9 ldi r25, 0x9C ; 156
908: 01 97 sbiw r24, 0x01 ; 1
90a: f1 f7 brne .-4 ; 0x908 <__stack+0x9>
90c: 00 c0 rjmp .+0 ; 0x90e <__stack+0xf>
90e: 00 00 nop
else {
_delay_ms(10);
j = 11;
910: db e0 ldi r29, 0x0B ; 11
static void showExtendedPars(void)
{
const uint8_t *p = cursorextpos;
lcd_gotoxy(0,1);
912: 61 e0 ldi r22, 0x01 ; 1
914: 80 e0 ldi r24, 0x00 ; 0
916: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
printword(pidParameters.P_Factor);
91a: 80 91 2c 01 lds r24, 0x012C ; 0x80012c <pidParameters+0x6>
91e: 90 91 2d 01 lds r25, 0x012D ; 0x80012d <pidParameters+0x7>
922: 0e 94 cc 02 call 0x598 ; 0x598 <printword>
printword(pidParameters.I_Factor);
926: 80 91 2e 01 lds r24, 0x012E ; 0x80012e <pidParameters+0x8>
92a: 90 91 2f 01 lds r25, 0x012F ; 0x80012f <pidParameters+0x9>
92e: 0e 94 cc 02 call 0x598 ; 0x598 <printword>
printword(pidParameters.D_Factor);printspc();
932: 80 91 30 01 lds r24, 0x0130 ; 0x800130 <pidParameters+0xa>
936: 90 91 31 01 lds r25, 0x0131 ; 0x800131 <pidParameters+0xb>
93a: 0e 94 cc 02 call 0x598 ; 0x598 <printword>
93e: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
printbyte(DEAD_TIME_HALF);printspc();
942: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
946: 0e 94 b8 02 call 0x570 ; 0x570 <printbyte>
94a: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
lcd_gotoxy(pgm_read_byte(p+parameter),1); // set cursor below active parameter
94e: e0 91 21 01 lds r30, 0x0121 ; 0x800121 <parameter>
952: f0 e0 ldi r31, 0x00 ; 0
954: e5 5d subi r30, 0xD5 ; 213
956: fe 4f sbci r31, 0xFE ; 254
958: 84 91 lpm r24, Z
95a: 61 e0 ldi r22, 0x01 ; 1
95c: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
960: 8f e1 ldi r24, 0x1F ; 31
962: 9e e4 ldi r25, 0x4E ; 78
964: 01 97 sbiw r24, 0x01 ; 1
966: f1 f7 brne .-4 ; 0x964 <__stack+0x65>
968: 00 c0 rjmp .+0 ; 0x96a <__stack+0x6b>
96a: 00 00 nop
lcd_puts_P( "P I D DT " );
parameter = 0;
// wait for button release
while (keyin()!=0){};
// pressing black and green button simultaneously exits this menu
while (n != 5) {
96c: c5 30 cpi r28, 0x05 ; 5
96e: 09 f0 breq .+2 ; 0x972 <__stack+0x73>
970: fb ce rjmp .-522 ; 0x768 <execExtendedCommand+0x32>
j = 11;
}
}
showExtendedPars();
} // while
parameter = 0;
972: 10 92 21 01 sts 0x0121, r1 ; 0x800121 <parameter>
lcd_clrscr();
976: 0e 94 be 06 call 0xd7c ; 0xd7c <lcd_clrscr>
// restore original diplay
lcd_puts_P( "Freq V/Hz Amp " );
97a: 88 e6 ldi r24, 0x68 ; 104
97c: 90 e0 ldi r25, 0x00 ; 0
97e: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
// wait for button release
while (keyin()!=0){};
982: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
986: 81 11 cpse r24, r1
988: fc cf rjmp .-8 ; 0x982 <__stack+0x83>
}
98a: df 91 pop r29
98c: cf 91 pop r28
98e: 1f 91 pop r17
990: 0f 91 pop r16
992: ff 90 pop r15
994: ef 90 pop r14
996: 08 95 ret
00000998 <__vector_5>:
*
* This ISR is called every time the direction input pin changes
* state. The desired direction flag is updated accordingly.
*/
ISR(PCINT2_vect)
{
998: 1f 92 push r1
99a: 0f 92 push r0
99c: 0f b6 in r0, 0x3f ; 63
99e: 0f 92 push r0
9a0: 11 24 eor r1, r1
9a2: 2f 93 push r18
9a4: 3f 93 push r19
9a6: 4f 93 push r20
9a8: 5f 93 push r21
9aa: 6f 93 push r22
9ac: 7f 93 push r23
9ae: 8f 93 push r24
9b0: 9f 93 push r25
9b2: af 93 push r26
9b4: bf 93 push r27
9b6: ef 93 push r30
9b8: ff 93 push r31
* Running this function triggers a reading of the direction
* input pin. The desiredDirection flag is set accordingly.
*/
static void DesiredDirectionUpdate(void)
{
if ( bit_is_clear(PIND,DIRECTION_COMMAND_PIN) )
9ba: 89 b1 in r24, 0x09 ; 9
{
fastFlags.desiredDirection = DIRECTION_REVERSE;
9bc: 80 95 com r24
9be: 88 1f adc r24, r24
9c0: 88 27 eor r24, r24
9c2: 88 1f adc r24, r24
9c4: 80 fb bst r24, 0
9c6: 91 f8 bld r9, 1
}
void ChangeDirection(void)
{
DesiredDirectionUpdate();
//Disable driver signals
DisablePWMOutputs();
9c8: 0e 94 b1 02 call 0x562 ; 0x562 <DisablePWMOutputs>
fastFlags.driveWaveform = WAVEFORM_UNDEFINED;
9cc: 89 2d mov r24, r9
9ce: 8c 60 ori r24, 0x0C ; 12
9d0: 98 2e mov r9, r24
*/
ISR(PCINT2_vect)
{
//Call the routine to actually stop the motor and reverse
ChangeDirection();
}
9d2: ff 91 pop r31
9d4: ef 91 pop r30
9d6: bf 91 pop r27
9d8: af 91 pop r26
9da: 9f 91 pop r25
9dc: 8f 91 pop r24
9de: 7f 91 pop r23
9e0: 6f 91 pop r22
9e2: 5f 91 pop r21
9e4: 4f 91 pop r20
9e6: 3f 91 pop r19
9e8: 2f 91 pop r18
9ea: 0f 90 pop r0
9ec: 0f be out 0x3f, r0 ; 63
9ee: 0f 90 pop r0
9f0: 1f 90 pop r1
9f2: 18 95 reti
000009f4 <__vector_16>:
//
EMPTY_INTERRUPT(TIMER0_OVF_vect);
9f4: 18 95 reti
000009f6 <__vector_14>:
// ISR stub for unused irqs. The AVRs sometimes need to fire an interupt and
// execute it before OC registers are updated
EMPTY_INTERRUPT(TIMER0_COMPB_vect);
9f6: 18 95 reti
000009f8 <__vector_10>:
* reaches TOP (0xff). New sinusoidal output values are calculated and the
* timers are updated to reflect the new values.
* The core routine of the VF Drive
*/
ISR(TIMER1_CAPT_vect)
{
9f8: 1f 92 push r1
9fa: 0f 92 push r0
9fc: 0f b6 in r0, 0x3f ; 63
9fe: 0f 92 push r0
a00: 11 24 eor r1, r1
a02: cf 92 push r12
a04: df 92 push r13
a06: ef 92 push r14
a08: ff 92 push r15
a0a: 0f 93 push r16
a0c: 1f 93 push r17
a0e: 2f 93 push r18
a10: 3f 93 push r19
a12: 4f 93 push r20
a14: 5f 93 push r21
a16: 6f 93 push r22
a18: 7f 93 push r23
a1a: 8f 93 push r24
a1c: 9f 93 push r25
a1e: af 93 push r26
a20: bf 93 push r27
a22: ef 93 push r30
a24: ff 93 push r31
a26: cf 93 push r28
a28: df 93 push r29
a2a: 00 d0 rcall .+0 ; 0xa2c <__vector_10+0x34>
a2c: cd b7 in r28, 0x3d ; 61
a2e: de b7 in r29, 0x3e ; 62
static uint8_t speedRegTicks = 0;
uint8_t tempU, tempV, tempW;
{
if (fastFlags.driveWaveform != WAVEFORM_SINUSOIDAL) TimersSetModeSinusoidal();
a30: 89 2d mov r24, r9
a32: 86 95 lsr r24
a34: 86 95 lsr r24
a36: 83 70 andi r24, 0x03 ; 3
a38: 81 30 cpi r24, 0x01 ; 1
a3a: 11 f1 breq .+68 ; 0xa80 <__vector_10+0x88>
* through.
*/
static void TimersSetModeSinusoidal(void)
{
//Set PWM pins to input (Hi-Z) while changing modes.
DisablePWMOutputs();
a3c: 0e 94 b1 02 call 0x562 ; 0x562 <DisablePWMOutputs>
//Sets all 3 timers in inverted pair mode.
TCCR0A = (1 << COM0A1) | (0 << COM0A0) | (1 << COM0B1) | (1 << COM0B0) | (1 << WGM00);
a40: 81 eb ldi r24, 0xB1 ; 177
a42: 84 bd out 0x24, r24 ; 36
TCCR1A = (1 << COM1A1) | (0 << COM1A0) | (1 << COM1B1) | (1 << COM1B0) | (1 << WGM11);
a44: 92 eb ldi r25, 0xB2 ; 178
a46: 90 93 80 00 sts 0x0080, r25 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
TCCR2A = (1 << COM2A1) | (0 << COM2A0) | (1 << COM2B1) | (1 << COM2B0) | (1 << WGM20);
a4a: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
//Make sure all outputs are turned off before PWM outputs are enabled.
OCR0A = OCR1AL = OCR2A = 0;
a4e: 10 92 b3 00 sts 0x00B3, r1 ; 0x8000b3 <__TEXT_REGION_LENGTH__+0x7e00b3>
a52: 10 92 88 00 sts 0x0088, r1 ; 0x800088 <__TEXT_REGION_LENGTH__+0x7e0088>
a56: 17 bc out 0x27, r1 ; 39
OCR0B = OCR1BL = OCR2B = 0xff;
a58: 8f ef ldi r24, 0xFF ; 255
a5a: 80 93 b4 00 sts 0x00B4, r24 ; 0x8000b4 <__TEXT_REGION_LENGTH__+0x7e00b4>
a5e: 80 93 8a 00 sts 0x008A, r24 ; 0x80008a <__TEXT_REGION_LENGTH__+0x7e008a>
a62: 88 bd out 0x28, r24 ; 40
* does not occur in the transition between two output waveform generation modes.
*/
static void TimersWaitForNextPWMCycle(void)
{
//Clear Timer1 Capture event flag.
TIFR1 = (1 << ICF1);
a64: 80 e2 ldi r24, 0x20 ; 32
a66: 86 bb out 0x16, r24 ; 22
//Wait for new Timer1 Capture event flag.
while ( !(TIFR1 & (1 << ICF1)) )
a68: b5 9b sbis 0x16, 5 ; 22
a6a: fe cf rjmp .-4 ; 0xa68 <__vector_10+0x70>
OCR0B = OCR1BL = OCR2B = 0xff;
//Wait for next PWM cycle to ensure that all outputs are updated.
TimersWaitForNextPWMCycle();
fastFlags.driveWaveform = WAVEFORM_SINUSOIDAL;
a6c: 89 2d mov r24, r9
a6e: 83 7f andi r24, 0xF3 ; 243
a70: 84 60 ori r24, 0x04 ; 4
a72: 98 2e mov r9, r24
* all PWM pins as output. The PWM configuration itself is not altered
* in any way by running this function.
*/
static void EnablePWMOutputs(void)
{
DDRB |= PWM_PATTERN_PORTB;
a74: 84 b1 in r24, 0x04 ; 4
a76: 8e 60 ori r24, 0x0E ; 14
a78: 84 b9 out 0x04, r24 ; 4
DDRD |= PWM_PATTERN_PORTD;
a7a: 8a b1 in r24, 0x0a ; 10
a7c: 88 66 ori r24, 0x68 ; 104
a7e: 8a b9 out 0x0a, r24 ; 10
static uint8_t speedRegTicks = 0;
uint8_t tempU, tempV, tempW;
{
if (fastFlags.driveWaveform != WAVEFORM_SINUSOIDAL) TimersSetModeSinusoidal();
const uint8_t *sineTablePtr = sineTable ; // set to start of sine table
sineTableIncrement = Inco; // stepwidth = frequency selection
a80: 88 2d mov r24, r8
a82: 90 e0 ldi r25, 0x00 ; 0
a84: 1c 01 movw r2, r24
*
* \param increment The increment (in 8.8 format) added to the sine table index.
*/
static void AdjustSineTableIndex(const uint16_t increment)
{
sineTableIndex += increment ;
a86: 20 91 38 01 lds r18, 0x0138 ; 0x800138 <sineTableIndex>
a8a: 30 91 39 01 lds r19, 0x0139 ; 0x800139 <sineTableIndex+0x1>
a8e: 82 0f add r24, r18
a90: 93 1f adc r25, r19
a92: 90 93 39 01 sts 0x0139, r25 ; 0x800139 <sineTableIndex+0x1>
a96: 80 93 38 01 sts 0x0138, r24 ; 0x800138 <sineTableIndex>
// If the table index is out of bounds, wrap the index around the table end
// to continue from the beginning. Also wrap the next sector start index.
if ((sineTableIndex >> 8) >= SINE_TABLE_LENGTH)
a9a: 80 91 38 01 lds r24, 0x0138 ; 0x800138 <sineTableIndex>
a9e: 90 91 39 01 lds r25, 0x0139 ; 0x800139 <sineTableIndex+0x1>
aa2: 81 15 cp r24, r1
aa4: 90 4c sbci r25, 0xC0 ; 192
aa6: 48 f0 brcs .+18 ; 0xaba <__vector_10+0xc2>
{
sineTableIndex -= (SINE_TABLE_LENGTH << 8);
aa8: 80 91 38 01 lds r24, 0x0138 ; 0x800138 <sineTableIndex>
aac: 90 91 39 01 lds r25, 0x0139 ; 0x800139 <sineTableIndex+0x1>
ab0: 90 5c subi r25, 0xC0 ; 192
ab2: 90 93 39 01 sts 0x0139, r25 ; 0x800139 <sineTableIndex+0x1>
ab6: 80 93 38 01 sts 0x0138, r24 ; 0x800138 <sineTableIndex>
sineTableIncrement = Inco; // stepwidth = frequency selection
AdjustSineTableIndex(sineTableIncrement); // call the routine to update the pointer
//Add sine table offset to pointer. Must be multiplied by 3, since one
//value for each phase is stored in the table.
sineTablePtr += (sineTableIndex >> 8) * 3;
aba: 80 91 38 01 lds r24, 0x0138 ; 0x800138 <sineTableIndex>
abe: 90 91 39 01 lds r25, 0x0139 ; 0x800139 <sineTableIndex+0x1>
ac2: 89 2f mov r24, r25
ac4: 99 27 eor r25, r25
ac6: fc 01 movw r30, r24
ac8: ee 0f add r30, r30
aca: ff 1f adc r31, r31
acc: 8e 0f add r24, r30
ace: 9f 1f adc r25, r31
ad0: fc 01 movw r30, r24
ad2: e1 5d subi r30, 0xD1 ; 209
ad4: fe 4f sbci r31, 0xFE ; 254
tempU = pgm_read_byte(sineTablePtr++);
ad6: 8f 01 movw r16, r30
ad8: 0f 5f subi r16, 0xFF ; 255
ada: 1f 4f sbci r17, 0xFF ; 255
adc: 24 91 lpm r18, Z
ade: cf 01 movw r24, r30
ae0: 02 96 adiw r24, 0x02 ; 2
if (fastFlags.desiredDirection == DIRECTION_FORWARD)
{
tempW = pgm_read_byte(sineTablePtr++);
ae2: f8 01 movw r30, r16
//Add sine table offset to pointer. Must be multiplied by 3, since one
//value for each phase is stored in the table.
sineTablePtr += (sineTableIndex >> 8) * 3;
tempU = pgm_read_byte(sineTablePtr++);
if (fastFlags.desiredDirection == DIRECTION_FORWARD)
ae4: 91 fc sbrc r9, 1
ae6: 04 c0 rjmp .+8 ; 0xaf0 <__vector_10+0xf8>
{
tempW = pgm_read_byte(sineTablePtr++);
ae8: 04 91 lpm r16, Z
tempV = pgm_read_byte(sineTablePtr);
aea: fc 01 movw r30, r24
aec: e4 90 lpm r14, Z
aee: 03 c0 rjmp .+6 ; 0xaf6 <__vector_10+0xfe>
}
else
{
tempV = pgm_read_byte(sineTablePtr++);
af0: e4 90 lpm r14, Z
tempW = pgm_read_byte(sineTablePtr);
af2: fc 01 movw r30, r24
af4: 04 91 lpm r16, Z
#ifdef PURE_SINE_DRIVE
tempU = 128 - ((uint16_t)(amplitude * tempU) >> 9);
tempV = 128 - ((uint16_t)(amplitude * tempV) >> 9);
tempW = 128 - ((uint16_t)(amplitude * tempW) >> 9);
#else
tempU = ((uint16_t)(amplitude * tempU) >> 8);
af6: 62 9e mul r6, r18
af8: 90 01 movw r18, r0
afa: 11 24 eor r1, r1
tempV = ((uint16_t)(amplitude * tempV) >> 8);
afc: 6e 9c mul r6, r14
afe: 70 01 movw r14, r0
b00: 11 24 eor r1, r1
tempW = ((uint16_t)(amplitude * tempW) >> 8);
b02: 60 9e mul r6, r16
b04: 80 01 movw r16, r0
b06: 11 24 eor r1, r1
#endif
{
uint8_t compareHigh, compareLow;
InsertDeadband(tempU, &compareHigh, &compareLow);
b08: ae 01 movw r20, r28
b0a: 4f 5f subi r20, 0xFF ; 255
b0c: 5f 4f sbci r21, 0xFF ; 255
b0e: be 01 movw r22, r28
b10: 6e 5f subi r22, 0xFE ; 254
b12: 7f 4f sbci r23, 0xFF ; 255
b14: 83 2f mov r24, r19
b16: 0e 94 12 03 call 0x624 ; 0x624 <InsertDeadband>
OCR0A = compareHigh;
b1a: 8a 81 ldd r24, Y+2 ; 0x02
b1c: 87 bd out 0x27, r24 ; 39
OCR0B = compareLow;
b1e: 89 81 ldd r24, Y+1 ; 0x01
b20: 88 bd out 0x28, r24 ; 40
InsertDeadband(tempV, &compareHigh, &compareLow);
b22: ae 01 movw r20, r28
b24: 4f 5f subi r20, 0xFF ; 255
b26: 5f 4f sbci r21, 0xFF ; 255
b28: be 01 movw r22, r28
b2a: 6e 5f subi r22, 0xFE ; 254
b2c: 7f 4f sbci r23, 0xFF ; 255
b2e: 8f 2d mov r24, r15
b30: 0e 94 12 03 call 0x624 ; 0x624 <InsertDeadband>
OCR1AL = compareHigh;
b34: 8a 81 ldd r24, Y+2 ; 0x02
b36: 80 93 88 00 sts 0x0088, r24 ; 0x800088 <__TEXT_REGION_LENGTH__+0x7e0088>
OCR1BL = compareLow;
b3a: 89 81 ldd r24, Y+1 ; 0x01
b3c: 80 93 8a 00 sts 0x008A, r24 ; 0x80008a <__TEXT_REGION_LENGTH__+0x7e008a>
InsertDeadband(tempW, &compareHigh, &compareLow);
b40: ae 01 movw r20, r28
b42: 4f 5f subi r20, 0xFF ; 255
b44: 5f 4f sbci r21, 0xFF ; 255
b46: be 01 movw r22, r28
b48: 6e 5f subi r22, 0xFE ; 254
b4a: 7f 4f sbci r23, 0xFF ; 255
b4c: 81 2f mov r24, r17
b4e: 0e 94 12 03 call 0x624 ; 0x624 <InsertDeadband>
OCR2A = compareHigh;
b52: 8a 81 ldd r24, Y+2 ; 0x02
b54: 80 93 b3 00 sts 0x00B3, r24 ; 0x8000b3 <__TEXT_REGION_LENGTH__+0x7e00b3>
OCR2B = compareLow;
b58: 89 81 ldd r24, Y+1 ; 0x01
b5a: 80 93 b4 00 sts 0x00B4, r24 ; 0x8000b4 <__TEXT_REGION_LENGTH__+0x7e00b4>
}
// regular task calls the SpeedController
speedRegTicks++;
b5e: 80 91 22 01 lds r24, 0x0122 ; 0x800122 <speedRegTicks.2484>
b62: 8f 5f subi r24, 0xFF ; 255
b64: 80 93 22 01 sts 0x0122, r24 ; 0x800122 <speedRegTicks.2484>
if (speedRegTicks >= SPEED_CONTROLLER_TIME_BASE)
b68: 88 3c cpi r24, 0xC8 ; 200
b6a: 08 f4 brcc .+2 ; 0xb6e <__vector_10+0x176>
b6c: 51 c0 rjmp .+162 ; 0xc10 <__vector_10+0x218>
*/
static void SpeedController(void)
{
int32_t outputValue, amplitudeValue;
// calculate the frequency
if (fastFlags.externalControl) {
b6e: 90 fe sbrs r9, 0
b70: 16 c0 rjmp .+44 ; 0xb9e <__vector_10+0x1a6>
//Calculate an increment setpoint from the analog speed input.
int16_t incrementSetpoint = ((uint32_t)speedInput * SPEED_CONTROLLER_MAX_INCREMENT) / SPEED_CONTROLLER_MAX_INPUT;
b72: 20 91 3a 01 lds r18, 0x013A ; 0x80013a <speedInput>
//PID regulator with feed forward from speed input.
outputValue = (uint32_t)speedInput;
b76: c0 90 3a 01 lds r12, 0x013A ; 0x80013a <speedInput>
outputValue += PID_Controller(incrementSetpoint, ((uint16_t)Inco),(pidData_t *) &pidParameters);
b7a: e8 2d mov r30, r8
b7c: f0 e0 ldi r31, 0x00 ; 0
{
int32_t outputValue, amplitudeValue;
// calculate the frequency
if (fastFlags.externalControl) {
//Calculate an increment setpoint from the analog speed input.
int16_t incrementSetpoint = ((uint32_t)speedInput * SPEED_CONTROLLER_MAX_INCREMENT) / SPEED_CONTROLLER_MAX_INPUT;
b7e: 30 e0 ldi r19, 0x00 ; 0
b80: af ef ldi r26, 0xFF ; 255
b82: b0 e0 ldi r27, 0x00 ; 0
b84: 0e 94 56 09 call 0x12ac ; 0x12ac <__umulhisi3>
b88: bb 27 eor r27, r27
b8a: a9 2f mov r26, r25
b8c: 98 2f mov r25, r24
b8e: 87 2f mov r24, r23
//PID regulator with feed forward from speed input.
outputValue = (uint32_t)speedInput;
outputValue += PID_Controller(incrementSetpoint, ((uint16_t)Inco),(pidData_t *) &pidParameters);
b90: 46 e2 ldi r20, 0x26 ; 38
b92: 51 e0 ldi r21, 0x01 ; 1
b94: bf 01 movw r22, r30
b96: 0e 94 00 02 call 0x400 ; 0x400 <PID_Controller>
Inco = (uint16_t)outputValue;
b9a: 8c 0d add r24, r12
b9c: 88 2e mov r8, r24
}
// clamp
freq = DIVISIONEER/(SINE_TABLE_DISP/Inco);
b9e: 68 2d mov r22, r8
ba0: 70 e0 ldi r23, 0x00 ; 0
ba2: 80 e0 ldi r24, 0x00 ; 0
ba4: 9b e4 ldi r25, 0x4B ; 75
ba6: 0e 94 ed 08 call 0x11da ; 0x11da <__udivmodhi4>
baa: 9b 01 movw r18, r22
bac: 40 e0 ldi r20, 0x00 ; 0
bae: 50 e0 ldi r21, 0x00 ; 0
bb0: 66 ed ldi r22, 0xD6 ; 214
bb2: 7c ed ldi r23, 0xDC ; 220
bb4: 81 e0 ldi r24, 0x01 ; 1
bb6: 90 e0 ldi r25, 0x00 ; 0
bb8: 0e 94 15 09 call 0x122a ; 0x122a <__udivmodsi4>
bbc: 30 93 25 01 sts 0x0125, r19 ; 0x800125 <freq+0x1>
bc0: 20 93 24 01 sts 0x0124, r18 ; 0x800124 <freq>
amplitudeValue = (freq/10)*VperHz;
bc4: c9 01 movw r24, r18
bc6: 6a e0 ldi r22, 0x0A ; 10
bc8: 70 e0 ldi r23, 0x00 ; 0
bca: 0e 94 ed 08 call 0x11da ; 0x11da <__udivmodhi4>
bce: 76 9e mul r7, r22
bd0: 90 01 movw r18, r0
bd2: 77 9e mul r7, r23
bd4: 30 0d add r19, r0
bd6: 11 24 eor r1, r1
bd8: b9 01 movw r22, r18
bda: 80 e0 ldi r24, 0x00 ; 0
bdc: 90 e0 ldi r25, 0x00 ; 0
if (amplitudeValue < 1)
bde: 23 2b or r18, r19
be0: 59 f0 breq .+22 ; 0xbf8 <__vector_10+0x200>
{
amplitudeValue = 0;
}
else if (amplitudeValue > 2549)
be2: 66 3f cpi r22, 0xF6 ; 246
be4: f9 e0 ldi r31, 0x09 ; 9
be6: 7f 07 cpc r23, r31
be8: 81 05 cpc r24, r1
bea: 91 05 cpc r25, r1
bec: 44 f0 brlt .+16 ; 0xbfe <__vector_10+0x206>
{
amplitudeValue = 2550;
bee: 66 ef ldi r22, 0xF6 ; 246
bf0: 79 e0 ldi r23, 0x09 ; 9
bf2: 80 e0 ldi r24, 0x00 ; 0
bf4: 90 e0 ldi r25, 0x00 ; 0
bf6: 03 c0 rjmp .+6 ; 0xbfe <__vector_10+0x206>
// clamp
freq = DIVISIONEER/(SINE_TABLE_DISP/Inco);
amplitudeValue = (freq/10)*VperHz;
if (amplitudeValue < 1)
{
amplitudeValue = 0;
bf8: 60 e0 ldi r22, 0x00 ; 0
bfa: 70 e0 ldi r23, 0x00 ; 0
bfc: cb 01 movw r24, r22
}
else if (amplitudeValue > 2549)
{
amplitudeValue = 2550;
}
amplitude = amplitudeValue / 10;
bfe: 2a e0 ldi r18, 0x0A ; 10
c00: 30 e0 ldi r19, 0x00 ; 0
c02: 40 e0 ldi r20, 0x00 ; 0
c04: 50 e0 ldi r21, 0x00 ; 0
c06: 0e 94 37 09 call 0x126e ; 0x126e <__divmodsi4>
c0a: 62 2e mov r6, r18
// regular task calls the SpeedController
speedRegTicks++;
if (speedRegTicks >= SPEED_CONTROLLER_TIME_BASE)
{
SpeedController();
speedRegTicks = 0;
c0c: 10 92 22 01 sts 0x0122, r1 ; 0x800122 <speedRegTicks.2484>
}
}
c10: 0f 90 pop r0
c12: 0f 90 pop r0
c14: df 91 pop r29
c16: cf 91 pop r28
c18: ff 91 pop r31
c1a: ef 91 pop r30
c1c: bf 91 pop r27
c1e: af 91 pop r26
c20: 9f 91 pop r25
c22: 8f 91 pop r24
c24: 7f 91 pop r23
c26: 6f 91 pop r22
c28: 5f 91 pop r21
c2a: 4f 91 pop r20
c2c: 3f 91 pop r19
c2e: 2f 91 pop r18
c30: 1f 91 pop r17
c32: 0f 91 pop r16
c34: ff 90 pop r15
c36: ef 90 pop r14
c38: df 90 pop r13
c3a: cf 90 pop r12
c3c: 0f 90 pop r0
c3e: 0f be out 0x3f, r0 ; 63
c40: 0f 90 pop r0
c42: 1f 90 pop r1
c44: 18 95 reti
00000c46 <__vector_21>:
* this is declared as non-blocking
*
* Only the 8 most significant bits of the ADC result are used.
*/
ISR(ADC_vect, ISR_NOBLOCK)
{
c46: 78 94 sei
c48: 1f 92 push r1
c4a: 0f 92 push r0
c4c: 0f b6 in r0, 0x3f ; 63
c4e: 0f 92 push r0
c50: 11 24 eor r1, r1
c52: 2f 93 push r18
c54: 8f 93 push r24
c56: 9f 93 push r25
if (fastFlags.externalControl) {
c58: 90 fe sbrs r9, 0
c5a: 22 c0 rjmp .+68 ; 0xca0 <__vector_21+0x5a>
switch (ADMUX)
c5c: 80 91 7c 00 lds r24, 0x007C ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c>
c60: 84 36 cpi r24, 0x64 ; 100
c62: 59 f0 breq .+22 ; 0xc7a <__vector_21+0x34>
c64: 85 36 cpi r24, 0x65 ; 101
c66: b1 f4 brne .+44 ; 0xc94 <__vector_21+0x4e>
case ADMUX_FREQUENCY:
speedInput = (speedInput + ADCH) >> 1; // do some averaging
ADMUX = ADMUX_AMPLITUDE;
break;
case ADMUX_AMPLITUDE:
VperHz = (VperHz + ADCH) >> 1;
c68: 80 91 79 00 lds r24, 0x0079 ; 0x800079 <__TEXT_REGION_LENGTH__+0x7e0079>
c6c: 90 e0 ldi r25, 0x00 ; 0
c6e: 87 0d add r24, r7
c70: 91 1d adc r25, r1
c72: 95 95 asr r25
c74: 87 95 ror r24
c76: 78 2e mov r7, r24
c78: 0d c0 rjmp .+26 ; 0xc94 <__vector_21+0x4e>
{
if (fastFlags.externalControl) {
switch (ADMUX)
{
case ADMUX_FREQUENCY:
speedInput = (speedInput + ADCH) >> 1; // do some averaging
c7a: 20 91 3a 01 lds r18, 0x013A ; 0x80013a <speedInput>
c7e: 80 91 79 00 lds r24, 0x0079 ; 0x800079 <__TEXT_REGION_LENGTH__+0x7e0079>
c82: 90 e0 ldi r25, 0x00 ; 0
c84: 82 0f add r24, r18
c86: 91 1d adc r25, r1
c88: 95 95 asr r25
c8a: 87 95 ror r24
c8c: 80 93 3a 01 sts 0x013A, r24 ; 0x80013a <speedInput>
ADMUX = ADMUX_AMPLITUDE;
c90: 85 e6 ldi r24, 0x65 ; 101
c92: 01 c0 rjmp .+2 ; 0xc96 <__vector_21+0x50>
VperHz = (VperHz + ADCH) >> 1;
ADMUX = ADMUX_FREQUENCY;
break;
default:
//This is probably an error and should be handled. Instead we set the multiplexer and just run away
ADMUX = ADMUX_FREQUENCY;
c94: 84 e6 ldi r24, 0x64 ; 100
c96: 80 93 7c 00 sts 0x007C, r24 ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c>
break;
}
// restart the ADC
ADCSRA = (1 << ADEN) | (1 << ADSC) | (0 << ADATE) | (1 << ADIF) | (1 << ADIE) | ADC_PRESCALER;
c9a: 8e ed ldi r24, 0xDE ; 222
c9c: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
}
}
ca0: 9f 91 pop r25
ca2: 8f 91 pop r24
ca4: 2f 91 pop r18
ca6: 0f 90 pop r0
ca8: 0f be out 0x3f, r0 ; 63
caa: 0f 90 pop r0
cac: 1f 90 pop r1
cae: 18 95 reti
00000cb0 <toggle_e>:
#if LCD_IO_MODE
/* toggle Enable Pin to initiate write */
static void toggle_e(void)
{
lcd_e_high();
cb0: 28 9a sbi 0x05, 0 ; 5
lcd_e_delay();
cb2: 00 c0 rjmp .+0 ; 0xcb4 <toggle_e+0x4>
lcd_e_low();
cb4: 28 98 cbi 0x05, 0 ; 5
cb6: 08 95 ret
00000cb8 <lcd_write>:
0: write instruction
Returns: none
*************************************************************************/
#if LCD_IO_MODE
static void lcd_write(uint8_t data,uint8_t rs)
{
cb8: 1f 93 push r17
cba: cf 93 push r28
cbc: df 93 push r29
cbe: 1f 92 push r1
cc0: cd b7 in r28, 0x3d ; 61
cc2: de b7 in r29, 0x3e ; 62
unsigned char dataBits ;
if (rs) { /* write data (RS=1, RW=0) */
cc4: 66 23 and r22, r22
cc6: 11 f0 breq .+4 ; 0xccc <lcd_write+0x14>
lcd_rs_high();
cc8: 2c 9a sbi 0x05, 4 ; 5
cca: 01 c0 rjmp .+2 ; 0xcce <lcd_write+0x16>
} else { /* write instruction (RS=0, RW=0) */
lcd_rs_low();
ccc: 2c 98 cbi 0x05, 4 ; 5
}
lcd_rw_low();
cce: 2d 98 cbi 0x05, 5 ; 5
if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
&& (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
{
/* configure data pins as output */
DDR(LCD_DATA0_PORT) |= 0x0F;
cd0: 97 b1 in r25, 0x07 ; 7
cd2: 9f 60 ori r25, 0x0F ; 15
cd4: 97 b9 out 0x07, r25 ; 7
/* output high nibble first */
dataBits = LCD_DATA0_PORT & 0xF0;
cd6: 98 b1 in r25, 0x08 ; 8
cd8: 19 2f mov r17, r25
cda: 10 7f andi r17, 0xF0 ; 240
LCD_DATA0_PORT = dataBits |((data>>4)&0x0F);
cdc: 98 2f mov r25, r24
cde: 92 95 swap r25
ce0: 9f 70 andi r25, 0x0F ; 15
ce2: 91 2b or r25, r17
ce4: 98 b9 out 0x08, r25 ; 8
lcd_e_toggle();
ce6: 89 83 std Y+1, r24 ; 0x01
ce8: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
/* output low nibble */
LCD_DATA0_PORT = dataBits | (data&0x0F);
cec: 89 81 ldd r24, Y+1 ; 0x01
cee: 8f 70 andi r24, 0x0F ; 15
cf0: 81 2b or r24, r17
cf2: 88 b9 out 0x08, r24 ; 8
lcd_e_toggle();
cf4: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
/* all data pins high (inactive) */
LCD_DATA0_PORT = dataBits | 0x0F;
cf8: 1f 60 ori r17, 0x0F ; 15
cfa: 18 b9 out 0x08, r17 ; 8
LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
}
}
cfc: 0f 90 pop r0
cfe: df 91 pop r29
d00: cf 91 pop r28
d02: 1f 91 pop r17
d04: 08 95 ret
00000d06 <lcd_read.constprop.0>:
if (rs)
lcd_rs_high(); /* RS=1: read data */
else
lcd_rs_low(); /* RS=0: read busy flag */
d06: 2c 98 cbi 0x05, 4 ; 5
lcd_rw_high(); /* RW=1 read mode */
d08: 2d 9a sbi 0x05, 5 ; 5
if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
&& ( LCD_DATA0_PIN == 0 )&& (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
{
DDR(LCD_DATA0_PORT) &= 0xF0; /* configure data pins as input */
d0a: 87 b1 in r24, 0x07 ; 7
d0c: 80 7f andi r24, 0xF0 ; 240
d0e: 87 b9 out 0x07, r24 ; 7
lcd_e_high();
d10: 28 9a sbi 0x05, 0 ; 5
lcd_e_delay();
d12: 00 c0 rjmp .+0 ; 0xd14 <lcd_read.constprop.0+0xe>
data = PIN(LCD_DATA0_PORT) << 4; /* read high nibble first */
d14: 96 b1 in r25, 0x06 ; 6
lcd_e_low();
d16: 28 98 cbi 0x05, 0 ; 5
lcd_e_delay(); /* Enable 500ns low */
d18: 00 c0 rjmp .+0 ; 0xd1a <lcd_read.constprop.0+0x14>
lcd_e_high();
d1a: 28 9a sbi 0x05, 0 ; 5
lcd_e_delay();
d1c: 00 c0 rjmp .+0 ; 0xd1e <lcd_read.constprop.0+0x18>
data |= PIN(LCD_DATA0_PORT)&0x0F; /* read low nibble */
d1e: 26 b1 in r18, 0x06 ; 6
d20: 2f 70 andi r18, 0x0F ; 15
{
DDR(LCD_DATA0_PORT) &= 0xF0; /* configure data pins as input */
lcd_e_high();
lcd_e_delay();
data = PIN(LCD_DATA0_PORT) << 4; /* read high nibble first */
d22: 89 2f mov r24, r25
d24: 82 95 swap r24
d26: 80 7f andi r24, 0xF0 ; 240
lcd_e_delay(); /* Enable 500ns low */
lcd_e_high();
lcd_e_delay();
data |= PIN(LCD_DATA0_PORT)&0x0F; /* read low nibble */
lcd_e_low();
d28: 28 98 cbi 0x05, 0 ; 5
if ( PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN) ) data |= 0x04;
if ( PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN) ) data |= 0x08;
lcd_e_low();
}
return data;
}
d2a: 82 2b or r24, r18
d2c: 08 95 ret
00000d2e <lcd_waitbusy>:
{
register uint8_t c;
/* wait until busy flag is cleared */
while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) {}
d2e: 0e 94 83 06 call 0xd06 ; 0xd06 <lcd_read.constprop.0>
d32: 87 fd sbrc r24, 7
d34: fc cf rjmp .-8 ; 0xd2e <lcd_waitbusy>
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
d36: 88 e0 ldi r24, 0x08 ; 8
d38: 90 e0 ldi r25, 0x00 ; 0
d3a: 01 97 sbiw r24, 0x01 ; 1
d3c: f1 f7 brne .-4 ; 0xd3a <lcd_waitbusy+0xc>
/* the address counter is updated 4us after the busy flag is cleared */
delay(2);
/* now read the address counter */
return (lcd_read(0)); // return address counter
d3e: 0c 94 83 06 jmp 0xd06 ; 0xd06 <lcd_read.constprop.0>
00000d42 <lcd_command>:
Send LCD controller instruction command
Input: instruction to send to LCD controller, see HD44780 data sheet
Returns: none
*************************************************************************/
void lcd_command(uint8_t cmd)
{
d42: cf 93 push r28
d44: c8 2f mov r28, r24
lcd_waitbusy();
d46: 0e 94 97 06 call 0xd2e ; 0xd2e <lcd_waitbusy>
lcd_write(cmd,0);
d4a: 60 e0 ldi r22, 0x00 ; 0
d4c: 8c 2f mov r24, r28
}
d4e: cf 91 pop r28
Returns: none
*************************************************************************/
void lcd_command(uint8_t cmd)
{
lcd_waitbusy();
lcd_write(cmd,0);
d50: 0c 94 5c 06 jmp 0xcb8 ; 0xcb8 <lcd_write>
00000d54 <lcd_data>:
Send data byte to LCD controller
Input: data to send to LCD controller, see HD44780 data sheet
Returns: none
*************************************************************************/
void lcd_data(uint8_t data)
{
d54: cf 93 push r28
d56: c8 2f mov r28, r24
lcd_waitbusy();
d58: 0e 94 97 06 call 0xd2e ; 0xd2e <lcd_waitbusy>
lcd_write(data,1);
d5c: 61 e0 ldi r22, 0x01 ; 1
d5e: 8c 2f mov r24, r28
}
d60: cf 91 pop r28
Returns: none
*************************************************************************/
void lcd_data(uint8_t data)
{
lcd_waitbusy();
lcd_write(data,1);
d62: 0c 94 5c 06 jmp 0xcb8 ; 0xcb8 <lcd_write>
00000d66 <lcd_gotoxy>:
{
#if LCD_LINES==1
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
#endif
#if LCD_LINES==2
if ( y==0 )
d66: 61 11 cpse r22, r1
d68: 02 c0 rjmp .+4 ; 0xd6e <lcd_gotoxy+0x8>
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
d6a: 80 58 subi r24, 0x80 ; 128
d6c: 01 c0 rjmp .+2 ; 0xd70 <lcd_gotoxy+0xa>
else
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
d6e: 80 54 subi r24, 0x40 ; 64
d70: 0c 94 a1 06 jmp 0xd42 ; 0xd42 <lcd_command>
00000d74 <lcd_getxy>:
/*************************************************************************
*************************************************************************/
int lcd_getxy(void)
{
return lcd_waitbusy();
d74: 0e 94 97 06 call 0xd2e ; 0xd2e <lcd_waitbusy>
}
d78: 90 e0 ldi r25, 0x00 ; 0
d7a: 08 95 ret
00000d7c <lcd_clrscr>:
/*************************************************************************
Clear display and set cursor to home position
*************************************************************************/
void lcd_clrscr(void)
{
lcd_command(1<<LCD_CLR);
d7c: 81 e0 ldi r24, 0x01 ; 1
d7e: 0c 94 a1 06 jmp 0xd42 ; 0xd42 <lcd_command>
00000d82 <lcd_home>:
/*************************************************************************
Set cursor to home position
*************************************************************************/
void lcd_home(void)
{
lcd_command(1<<LCD_HOME);
d82: 82 e0 ldi r24, 0x02 ; 2
d84: 0c 94 a1 06 jmp 0xd42 ; 0xd42 <lcd_command>
00000d88 <lcd_putc>:
Display character at current cursor position
Input: character to be displayed
Returns: none
*************************************************************************/
void lcd_putc(char c)
{
d88: cf 93 push r28
d8a: c8 2f mov r28, r24
uint8_t pos;
pos = lcd_waitbusy(); // read busy-flag and address counter
d8c: 0e 94 97 06 call 0xd2e ; 0xd2e <lcd_waitbusy>
if (c=='\n')
d90: ca 30 cpi r28, 0x0A ; 10
d92: 49 f4 brne .+18 ; 0xda6 <lcd_putc+0x1e>
#if LCD_LINES==1
addressCounter = 0;
#endif
#if LCD_LINES==2
if ( pos < (LCD_START_LINE2) )
d94: 80 34 cpi r24, 0x40 ; 64
d96: 10 f0 brcs .+4 ; 0xd9c <lcd_putc+0x14>
addressCounter = LCD_START_LINE2;
else
addressCounter = LCD_START_LINE1;
d98: 80 e0 ldi r24, 0x00 ; 0
d9a: 01 c0 rjmp .+2 ; 0xd9e <lcd_putc+0x16>
#if LCD_LINES==1
addressCounter = 0;
#endif
#if LCD_LINES==2
if ( pos < (LCD_START_LINE2) )
addressCounter = LCD_START_LINE2;
d9c: 80 e4 ldi r24, 0x40 ; 64
addressCounter = LCD_START_LINE4;
else
addressCounter = LCD_START_LINE1;
#endif
#endif
lcd_command((1<<LCD_DDRAM)+addressCounter);
d9e: 80 58 subi r24, 0x80 ; 128
lcd_waitbusy();
#endif
lcd_write(c, 1);
}
}/* lcd_putc */
da0: cf 91 pop r28
addressCounter = LCD_START_LINE4;
else
addressCounter = LCD_START_LINE1;
#endif
#endif
lcd_command((1<<LCD_DDRAM)+addressCounter);
da2: 0c 94 a1 06 jmp 0xd42 ; 0xd42 <lcd_command>
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#endif
lcd_waitbusy();
#endif
lcd_write(c, 1);
da6: 61 e0 ldi r22, 0x01 ; 1
da8: 8c 2f mov r24, r28
}
}/* lcd_putc */
daa: cf 91 pop r28
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#endif
lcd_waitbusy();
#endif
lcd_write(c, 1);
dac: 0c 94 5c 06 jmp 0xcb8 ; 0xcb8 <lcd_write>
00000db0 <lcd_puts>:
Input: string to be displayed
Returns: none
*************************************************************************/
void lcd_puts(const char *s)
/* print string on lcd (no auto linefeed) */
{
db0: cf 93 push r28
db2: df 93 push r29
db4: ec 01 movw r28, r24
register char c;
while ( (c = *s++) ) {
db6: 89 91 ld r24, Y+
db8: 88 23 and r24, r24
dba: 19 f0 breq .+6 ; 0xdc2 <lcd_puts+0x12>
lcd_putc(c);
dbc: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
dc0: fa cf rjmp .-12 ; 0xdb6 <lcd_puts+0x6>
}
}/* lcd_puts */
dc2: df 91 pop r29
dc4: cf 91 pop r28
dc6: 08 95 ret
00000dc8 <lcd_puts_p>:
Input: string from program memory be be displayed
Returns: none
*************************************************************************/
void lcd_puts_p(const char *progmem_s)
/* print string from program memory on lcd (no auto linefeed) */
{
dc8: cf 93 push r28
dca: df 93 push r29
dcc: fc 01 movw r30, r24
register char c;
while ( (c = pgm_read_byte(progmem_s++)) ) {
dce: 84 91 lpm r24, Z
dd0: ef 01 movw r28, r30
dd2: 21 96 adiw r28, 0x01 ; 1
dd4: 88 23 and r24, r24
dd6: 21 f0 breq .+8 ; 0xde0 <lcd_puts_p+0x18>
lcd_putc(c);
dd8: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
ddc: fe 01 movw r30, r28
dde: f7 cf rjmp .-18 ; 0xdce <lcd_puts_p+0x6>
}
}/* lcd_puts_p */
de0: df 91 pop r29
de2: cf 91 pop r28
de4: 08 95 ret
00000de6 <lcd_init>:
LCD_DISP_ON_CURSOR display on, cursor on
LCD_DISP_CURSOR_BLINK display on, cursor on flashing
Returns: none
*************************************************************************/
void lcd_init(uint8_t dispAttr)
{
de6: 1f 93 push r17
de8: cf 93 push r28
dea: df 93 push r29
dec: 18 2f mov r17, r24
}
else if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
&& (LCD_DATA0_PIN == 0 ) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
{
/* configure all port bits as output (all LCD data lines on same port, but control lines on different ports) */
DDR(LCD_DATA0_PORT) |= 0x0F;
dee: 97 b1 in r25, 0x07 ; 7
df0: 9f 60 ori r25, 0x0F ; 15
df2: 97 b9 out 0x07, r25 ; 7
DDR(LCD_RS_PORT) |= _BV(LCD_RS_PIN);
df4: 24 9a sbi 0x04, 4 ; 4
DDR(LCD_RW_PORT) |= _BV(LCD_RW_PIN);
df6: 25 9a sbi 0x04, 5 ; 4
DDR(LCD_E_PORT) |= _BV(LCD_E_PIN);
df8: 20 9a sbi 0x04, 0 ; 4
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
dfa: e0 e0 ldi r30, 0x00 ; 0
dfc: fa ef ldi r31, 0xFA ; 250
dfe: 31 97 sbiw r30, 0x01 ; 1
e00: f1 f7 brne .-4 ; 0xdfe <lcd_init+0x18>
DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN);
}
delay(16000); /* wait 16ms or more after power-on */
/* initial write to lcd is 8bit */
LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN); // _BV(LCD_FUNCTION)>>4;
e02: 41 9a sbi 0x08, 1 ; 8
LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN); // _BV(LCD_FUNCTION_8BIT)>>4;
e04: 40 9a sbi 0x08, 0 ; 8
lcd_e_toggle();
e06: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
e0a: e0 e0 ldi r30, 0x00 ; 0
e0c: fe e4 ldi r31, 0x4E ; 78
e0e: 31 97 sbiw r30, 0x01 ; 1
e10: f1 f7 brne .-4 ; 0xe0e <lcd_init+0x28>
LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN); // _BV(LCD_FUNCTION_8BIT)>>4;
lcd_e_toggle();
delay(4992); /* delay, busy flag can't be checked here */
/* repeat last command */
lcd_e_toggle();
e12: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
e16: c0 e0 ldi r28, 0x00 ; 0
e18: d1 e0 ldi r29, 0x01 ; 1
e1a: fe 01 movw r30, r28
e1c: 31 97 sbiw r30, 0x01 ; 1
e1e: f1 f7 brne .-4 ; 0xe1c <lcd_init+0x36>
/* repeat last command */
lcd_e_toggle();
delay(64); /* delay, busy flag can't be checked here */
/* repeat last command a third time */
lcd_e_toggle();
e20: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
e24: fe 01 movw r30, r28
e26: 31 97 sbiw r30, 0x01 ; 1
e28: f1 f7 brne .-4 ; 0xe26 <lcd_init+0x40>
/* repeat last command a third time */
lcd_e_toggle();
delay(64); /* delay, busy flag can't be checked here */
/* now configure for 4bit mode */
LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN); // LCD_FUNCTION_4BIT_1LINE>>4
e2a: 40 98 cbi 0x08, 0 ; 8
lcd_e_toggle();
e2c: 0e 94 58 06 call 0xcb0 ; 0xcb0 <toggle_e>
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" ); // 2 cycles
else
__asm__ __volatile__ (
e30: 21 97 sbiw r28, 0x01 ; 1
e32: f1 f7 brne .-4 ; 0xe30 <lcd_init+0x4a>
/* Display with KS0073 controller requires special commands for enabling 4 line mode */
lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_ON);
lcd_command(KS0073_4LINES_MODE);
lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_OFF);
#else
lcd_command(LCD_FUNCTION_DEFAULT); /* function set: display lines */
e34: 88 e2 ldi r24, 0x28 ; 40
e36: 0e 94 a1 06 call 0xd42 ; 0xd42 <lcd_command>
#endif
lcd_command(LCD_DISP_OFF); /* display off */
e3a: 88 e0 ldi r24, 0x08 ; 8
e3c: 0e 94 a1 06 call 0xd42 ; 0xd42 <lcd_command>
lcd_clrscr(); /* display clear */
e40: 0e 94 be 06 call 0xd7c ; 0xd7c <lcd_clrscr>
lcd_command(LCD_MODE_DEFAULT); /* set entry mode */
e44: 86 e0 ldi r24, 0x06 ; 6
e46: 0e 94 a1 06 call 0xd42 ; 0xd42 <lcd_command>
lcd_command(dispAttr); /* display/cursor control */
e4a: 81 2f mov r24, r17
}/* lcd_init */
e4c: df 91 pop r29
e4e: cf 91 pop r28
e50: 1f 91 pop r17
lcd_command(LCD_FUNCTION_DEFAULT); /* function set: display lines */
#endif
lcd_command(LCD_DISP_OFF); /* display off */
lcd_clrscr(); /* display clear */
lcd_command(LCD_MODE_DEFAULT); /* set entry mode */
lcd_command(dispAttr); /* display/cursor control */
e52: 0c 94 a1 06 jmp 0xd42 ; 0xd42 <lcd_command>
00000e56 <main>:
* Lets initialize all variables here - even if its only for completeness
*******************************************************************************************+
*/
int main(void)
{
cli();
e56: f8 94 cli
// variables
amplitude = 0 ;
e58: 61 2c mov r6, r1
speedInput = 0 ;
e5a: 10 92 3a 01 sts 0x013A, r1 ; 0x80013a <speedInput>
Inco = 1;
e5e: 88 24 eor r8, r8
e60: 83 94 inc r8
parameter = 0;
e62: 10 92 21 01 sts 0x0121, r1 ; 0x800121 <parameter>
*/
static void PortsInit(void)
{
// Port C is LCD Data Output and ADC Input
// the LCD lib does this on its own, but here for completeness
DDRC = 0b00001111;
e66: 8f e0 ldi r24, 0x0F ; 15
e68: 87 b9 out 0x07, r24 ; 7
// PORTB, PORTD outputs
// clr pullups but do nothing else here. The sine driver will take care of the output states
PORTB &= ~(PWM_PATTERN_PORTB);
e6a: 85 b1 in r24, 0x05 ; 5
e6c: 81 7f andi r24, 0xF1 ; 241
e6e: 85 b9 out 0x05, r24 ; 5
PORTD &= ~(PWM_PATTERN_PORTD);
e70: 8b b1 in r24, 0x0b ; 11
e72: 87 79 andi r24, 0x97 ; 151
e74: 8b b9 out 0x0b, r24 ; 11
// Set the inputs on Port D for the three buttons
DDRD &= ~BUTTON_MASK;
e76: 8a b1 in r24, 0x0a ; 10
e78: 88 7f andi r24, 0xF8 ; 248
e7a: 8a b9 out 0x0a, r24 ; 10
// Enable pull-up on input signals.
PORTD |= _BV(DIRECTION_COMMAND_PIN) | _BV(EXTERNAL_CONTROL_PIN) | BUTTON_MASK ;
e7c: 8b b1 in r24, 0x0b ; 11
e7e: 87 69 ori r24, 0x97 ; 151
e80: 8b b9 out 0x0b, r24 ; 11
Inco = 1;
parameter = 0;
//Initialize peripherals.
PortsInit();
/* initialize display, cursor off */
lcd_init(LCD_DISP_ON);
e82: 8c e0 ldi r24, 0x0C ; 12
e84: 0e 94 f3 06 call 0xde6 ; 0xde6 <lcd_init>
lcd_home();
e88: 0e 94 c1 06 call 0xd82 ; 0xd82 <lcd_home>
#ifdef PURE_SINE_DRIVE
lcd_puts_P( "VF Sinus Drive\n" );
#else
lcd_puts_P( "VF Motor Drive\n" );
e8c: 8d eb ldi r24, 0xBD ; 189
e8e: 90 e0 ldi r25, 0x00 ; 0
e90: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
#endif
lcd_putc('0'); // diagnostic outputs
e94: 80 e3 ldi r24, 0x30 ; 48
e96: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
* all PWM signals are aligned.
*/
static void TimersInit(void)
{
//Set all timers in "Phase correct mode". Do not enable outputs yet.
TCCR0A = (1 << WGM00);
e9a: 81 e0 ldi r24, 0x01 ; 1
e9c: 84 bd out 0x24, r24 ; 36
TCCR1A = (1 << WGM11);
e9e: 92 e0 ldi r25, 0x02 ; 2
ea0: 90 93 80 00 sts 0x0080, r25 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7e0080>
TCCR2A = (1 << WGM20);
ea4: 80 93 b0 00 sts 0x00B0, r24 ; 0x8000b0 <__TEXT_REGION_LENGTH__+0x7e00b0>
//Set top value of Timer/counter1.
ICR1 = 0xff;
ea8: 2f ef ldi r18, 0xFF ; 255
eaa: 30 e0 ldi r19, 0x00 ; 0
eac: 30 93 87 00 sts 0x0087, r19 ; 0x800087 <__TEXT_REGION_LENGTH__+0x7e0087>
eb0: 20 93 86 00 sts 0x0086, r18 ; 0x800086 <__TEXT_REGION_LENGTH__+0x7e0086>
//Synchronize timers. These values were determined by running the simulator
TCNT0 = 0;
eb4: 16 bc out 0x26, r1 ; 38
TCNT1 = 3;
eb6: 23 e0 ldi r18, 0x03 ; 3
eb8: 30 e0 ldi r19, 0x00 ; 0
eba: 30 93 85 00 sts 0x0085, r19 ; 0x800085 <__TEXT_REGION_LENGTH__+0x7e0085>
ebe: 20 93 84 00 sts 0x0084, r18 ; 0x800084 <__TEXT_REGION_LENGTH__+0x7e0084>
TCNT2 = 5;
ec2: 95 e0 ldi r25, 0x05 ; 5
ec4: 90 93 b2 00 sts 0x00B2, r25 ; 0x8000b2 <__TEXT_REGION_LENGTH__+0x7e00b2>
// Start all 3 timers.
TCCR0B = (0 << CS01) | (1 << CS00);
ec8: 85 bd out 0x25, r24 ; 37
TCCR1B = (1 << WGM13) | (0 << CS11) | (1 << CS10);
eca: 91 e1 ldi r25, 0x11 ; 17
ecc: 90 93 81 00 sts 0x0081, r25 ; 0x800081 <__TEXT_REGION_LENGTH__+0x7e0081>
TCCR2B = (0 << CS21) | (1 << CS20);
ed0: 80 93 b1 00 sts 0x00B1, r24 ; 0x8000b1 <__TEXT_REGION_LENGTH__+0x7e00b1>
lcd_puts_P( "VF Motor Drive\n" );
#endif
lcd_putc('0'); // diagnostic outputs
// timers
TimersInit();
lcd_putc('1');
ed4: 81 e3 ldi r24, 0x31 ; 49
ed6: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
*/
static void PinChangeIntInit(void)
{
// Initialize pin change interrupt on direction command pin
// PD7 is PCINT23
PCMSK2 = _BV(PCINT23);
eda: 80 e8 ldi r24, 0x80 ; 128
edc: 80 93 6d 00 sts 0x006D, r24 ; 0x80006d <__TEXT_REGION_LENGTH__+0x7e006d>
// Enable pin change interrupt on ports with pin change signals
PCICR = (1 << PCIE2);
ee0: 84 e0 ldi r24, 0x04 ; 4
ee2: 80 93 68 00 sts 0x0068, r24 ; 0x800068 <__TEXT_REGION_LENGTH__+0x7e0068>
// timers
TimersInit();
lcd_putc('1');
// jumpers
PinChangeIntInit();
lcd_putc('2');
ee6: 82 e3 ldi r24, 0x32 ; 50
ee8: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
* remember this is init only and will only be run ONCE...
*/
static void ADCInit(void)
{
ADCSRA = (1 << ADEN) | (0 << ADSC) | (0 << ADATE) | (1 << ADIF) | (0 << ADIE) | (ADC_PRESCALER);
eec: 86 e9 ldi r24, 0x96 ; 150
eee: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
// disable digital inputs on analog channels
DIDR0 = ( 1 << ADC_CHANNEL_FREQUENCY) | (1 << ADC_CHANNEL_AMPLITUDE );
ef2: 80 e3 ldi r24, 0x30 ; 48
ef4: 80 93 7e 00 sts 0x007E, r24 ; 0x80007e <__TEXT_REGION_LENGTH__+0x7e007e>
//Select initial AD conversion channel.
ADMUX = ADMUX_FREQUENCY;
ef8: 84 e6 ldi r24, 0x64 ; 100
efa: 80 93 7c 00 sts 0x007C, r24 ; 0x80007c <__TEXT_REGION_LENGTH__+0x7e007c>
//Set trigger source to free run
ADCSRB = (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0);
efe: 10 92 7b 00 sts 0x007B, r1 ; 0x80007b <__TEXT_REGION_LENGTH__+0x7e007b>
//Initialize ADC and start once, no IRQ
ADCSRA = (1 << ADEN) | (1 << ADSC) | (0 << ADATE) | (0 << ADIF) | (0 << ADIE) | (ADC_PRESCALER);
f02: 86 ec ldi r24, 0xC6 ; 198
f04: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
/* This really does nothing except restarting the ADC with IRQ enabled
* If you want to calibrate, do it here.
*/
static void CalibADC(void)
{
DisablePWMOutputs();
f08: 0e 94 b1 02 call 0x562 ; 0x562 <DisablePWMOutputs>
f0c: 2f ef ldi r18, 0xFF ; 255
f0e: 83 ec ldi r24, 0xC3 ; 195
f10: 99 e0 ldi r25, 0x09 ; 9
f12: 21 50 subi r18, 0x01 ; 1
f14: 80 40 sbci r24, 0x00 ; 0
f16: 90 40 sbci r25, 0x00 ; 0
f18: e1 f7 brne .-8 ; 0xf12 <main+0xbc>
f1a: 00 c0 rjmp .+0 ; 0xf1c <main+0xc6>
f1c: 00 00 nop
_delay_ms(200);
//Initialize ADC and restart, now with IRQ
ADCSRA = (1 << ADEN) | (1 << ADSC) | (0 << ADATE) | (1 << ADIF) | (1 << ADIE) | (ADC_PRESCALER);
f1e: 8e ed ldi r24, 0xDE ; 222
f20: 80 93 7a 00 sts 0x007A, r24 ; 0x80007a <__TEXT_REGION_LENGTH__+0x7e007a>
// jumpers
PinChangeIntInit();
lcd_putc('2');
// analog
ADCInit();
lcd_putc('3');
f24: 83 e3 ldi r24, 0x33 ; 51
f26: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
PID_Init(PID_K_P, PID_K_I, PID_K_D,(pidData_t *) &pidParameters);
f2a: 26 e2 ldi r18, 0x26 ; 38
f2c: 31 e0 ldi r19, 0x01 ; 1
f2e: 40 e1 ldi r20, 0x10 ; 16
f30: 50 e0 ldi r21, 0x00 ; 0
f32: 68 e0 ldi r22, 0x08 ; 8
f34: 70 e0 ldi r23, 0x00 ; 0
f36: 80 e6 ldi r24, 0x60 ; 96
f38: 90 e0 ldi r25, 0x00 ; 0
f3a: 0e 94 d7 01 call 0x3ae ; 0x3ae <PID_Init>
lcd_putc('4');
f3e: 84 e3 ldi r24, 0x34 ; 52
f40: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
//Initialize fastflags
{
fastFlags.externalControl = FALSE;
f44: e8 94 clt
f46: 90 f8 bld r9, 0
fastFlags.desiredDirection = DIRECTION_FORWARD;
f48: e8 94 clt
f4a: 91 f8 bld r9, 1
fastFlags.driveWaveform = WAVEFORM_UNDEFINED;
f4c: e9 2d mov r30, r9
f4e: ec 60 ori r30, 0x0C ; 12
f50: 9e 2e mov r9, r30
}
lcd_putc('5');
f52: 85 e3 ldi r24, 0x35 ; 53
f54: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
* Running this function triggers a reading of the direction
* input pin. The desiredDirection flag is set accordingly.
*/
static void DesiredDirectionUpdate(void)
{
if ( bit_is_clear(PIND,DIRECTION_COMMAND_PIN) )
f58: 89 b1 in r24, 0x09 ; 9
{
fastFlags.desiredDirection = DIRECTION_REVERSE;
f5a: 80 95 com r24
f5c: 88 1f adc r24, r24
f5e: 88 27 eor r24, r24
f60: 88 1f adc r24, r24
f62: 80 fb bst r24, 0
f64: 91 f8 bld r9, 1
/* select control method by examining the EXTERNAL_CONTROL_PIN
* if it is jumpered to ground, we derive V/Hz and Inco from analog signals
*/
static void DesiredControlUpdate(void)
{
if ( bit_is_clear(PIND,EXTERNAL_CONTROL_PIN) )
f66: 4c 99 sbic 0x09, 4 ; 9
f68: 03 c0 rjmp .+6 ; 0xf70 <main+0x11a>
{
fastFlags.externalControl = TRUE;
f6a: 68 94 set
f6c: 90 f8 bld r9, 0
f6e: 02 c0 rjmp .+4 ; 0xf74 <main+0x11e>
}
else
{
fastFlags.externalControl = FALSE;
f70: e8 94 clt
f72: 90 f8 bld r9, 0
lcd_putc('5');
// read the port pins and set fastFlags accordingly
DesiredDirectionUpdate();
DesiredControlUpdate();
// Enable Timer1 capture event interrupt.
TIFR1 = _BV(ICF1) | _BV(OCF1B) | _BV(OCF1A) | _BV(TOV1) ;
f74: 87 e2 ldi r24, 0x27 ; 39
f76: 86 bb out 0x16, r24 ; 22
TIMSK1 = _BV(ICIE1);
f78: 80 e2 ldi r24, 0x20 ; 32
f7a: 80 93 6f 00 sts 0x006F, r24 ; 0x80006f <__TEXT_REGION_LENGTH__+0x7e006f>
lcd_putc('6');
f7e: 86 e3 ldi r24, 0x36 ; 54
f80: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
f84: ff ef ldi r31, 0xFF ; 255
f86: 29 e6 ldi r18, 0x69 ; 105
f88: 88 e1 ldi r24, 0x18 ; 24
f8a: f1 50 subi r31, 0x01 ; 1
f8c: 20 40 sbci r18, 0x00 ; 0
f8e: 80 40 sbci r24, 0x00 ; 0
f90: e1 f7 brne .-8 ; 0xf8a <main+0x134>
f92: 00 c0 rjmp .+0 ; 0xf94 <main+0x13e>
f94: 00 00 nop
* A fail here would be fatal to the PA. So if somehow a wrong value is read
* we set to MIN_DEAD_TIME to save the life of the PA.
*/
static void EEPROMInit(void)
{
lcd_gotoxy(0,1);
f96: 61 e0 ldi r22, 0x01 ; 1
f98: 80 e0 ldi r24, 0x00 ; 0
f9a: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
lcd_puts_P( "Reading EEPROM ");
f9e: 8b e9 ldi r24, 0x9B ; 155
fa0: 90 e0 ldi r25, 0x00 ; 0
fa2: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
DEAD_TIME_HALF = eeprom_read_byte(&ee_DEAD_TIME_HALF);
fa6: 88 e0 ldi r24, 0x08 ; 8
fa8: 90 e0 ldi r25, 0x00 ; 0
faa: 0e 94 ad 09 call 0x135a ; 0x135a <eeprom_read_byte>
fae: 80 93 1e 01 sts 0x011E, r24 ; 0x80011e <DEAD_TIME_HALF>
if (DEAD_TIME_HALF < MIN_DEAD_TIME) DEAD_TIME_HALF = MIN_DEAD_TIME;
fb2: 80 91 1e 01 lds r24, 0x011E ; 0x80011e <DEAD_TIME_HALF>
fb6: 88 30 cpi r24, 0x08 ; 8
fb8: 18 f4 brcc .+6 ; 0xfc0 <main+0x16a>
fba: 88 e0 ldi r24, 0x08 ; 8
fbc: 80 93 1e 01 sts 0x011E, r24 ; 0x80011e <DEAD_TIME_HALF>
// Working parameters
Inco = eeprom_read_byte(&ee_Inco);
fc0: 87 e0 ldi r24, 0x07 ; 7
fc2: 90 e0 ldi r25, 0x00 ; 0
fc4: 0e 94 ad 09 call 0x135a ; 0x135a <eeprom_read_byte>
fc8: 88 2e mov r8, r24
VperHz = eeprom_read_byte(&ee_VperHz);
fca: 86 e0 ldi r24, 0x06 ; 6
fcc: 90 e0 ldi r25, 0x00 ; 0
fce: 0e 94 ad 09 call 0x135a ; 0x135a <eeprom_read_byte>
fd2: 78 2e mov r7, r24
// PID values
pidParameters.P_Factor = eeprom_read_word(&ee_pid_P);
fd4: 84 e0 ldi r24, 0x04 ; 4
fd6: 90 e0 ldi r25, 0x00 ; 0
fd8: 0e 94 b5 09 call 0x136a ; 0x136a <eeprom_read_word>
fdc: 90 93 2d 01 sts 0x012D, r25 ; 0x80012d <pidParameters+0x7>
fe0: 80 93 2c 01 sts 0x012C, r24 ; 0x80012c <pidParameters+0x6>
pidParameters.I_Factor = eeprom_read_word(&ee_pid_I);
fe4: 82 e0 ldi r24, 0x02 ; 2
fe6: 90 e0 ldi r25, 0x00 ; 0
fe8: 0e 94 b5 09 call 0x136a ; 0x136a <eeprom_read_word>
fec: 90 93 2f 01 sts 0x012F, r25 ; 0x80012f <pidParameters+0x9>
ff0: 80 93 2e 01 sts 0x012E, r24 ; 0x80012e <pidParameters+0x8>
pidParameters.D_Factor = eeprom_read_word(&ee_pid_D);
ff4: 80 e0 ldi r24, 0x00 ; 0
ff6: 90 e0 ldi r25, 0x00 ; 0
ff8: 0e 94 b5 09 call 0x136a ; 0x136a <eeprom_read_word>
ffc: 90 93 31 01 sts 0x0131, r25 ; 0x800131 <pidParameters+0xb>
1000: 80 93 30 01 sts 0x0130, r24 ; 0x800130 <pidParameters+0xa>
1004: 9f ef ldi r25, 0xFF ; 255
1006: e9 e6 ldi r30, 0x69 ; 105
1008: f8 e1 ldi r31, 0x18 ; 24
100a: 91 50 subi r25, 0x01 ; 1
100c: e0 40 sbci r30, 0x00 ; 0
100e: f0 40 sbci r31, 0x00 ; 0
1010: e1 f7 brne .-8 ; 0x100a <main+0x1b4>
1012: 00 c0 rjmp .+0 ; 0x1014 <main+0x1be>
1014: 00 00 nop
_delay_ms(500);
lcd_gotoxy(0,1);
1016: 61 e0 ldi r22, 0x01 ; 1
1018: 80 e0 ldi r24, 0x00 ; 0
101a: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
lcd_puts_P( "Read Done ");
101e: 8a e8 ldi r24, 0x8A ; 138
1020: 90 e0 ldi r25, 0x00 ; 0
1022: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
1026: 2f ef ldi r18, 0xFF ; 255
1028: 89 e6 ldi r24, 0x69 ; 105
102a: 98 e1 ldi r25, 0x18 ; 24
102c: 21 50 subi r18, 0x01 ; 1
102e: 80 40 sbci r24, 0x00 ; 0
1030: 90 40 sbci r25, 0x00 ; 0
1032: e1 f7 brne .-8 ; 0x102c <main+0x1d6>
1034: 00 c0 rjmp .+0 ; 0x1036 <main+0x1e0>
1036: 00 00 nop
/* wait for button release
* Don't ask why this is here --- ok, you may ask: Its here if some fool powers
* up the VFD and keeps the buttons pressed or the buttons somehow are stuck.
* That would probly lead to undesired operation and so - - - lets wait
*/
if (keyin() > 0){};
1038: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
TIMSK1 = _BV(ICIE1);
lcd_putc('6');
_delay_ms(500);
// read in stored values
EEPROMInit();
lcd_putc('7');
103c: 87 e3 ldi r24, 0x37 ; 55
103e: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
lcd_clrscr();
1042: 0e 94 be 06 call 0xd7c ; 0xd7c <lcd_clrscr>
lcd_command(LCD_DISP_ON_CURSOR);
1046: 8e e0 ldi r24, 0x0E ; 14
1048: 0e 94 a1 06 call 0xd42 ; 0xd42 <lcd_command>
// this line is only written once, actual values are always displayed in line 2
lcd_puts_P( "Freq V/Hz Amp " );
104c: 8c ea ldi r24, 0xAC ; 172
104e: 90 e0 ldi r25, 0x00 ; 0
1050: 0e 94 e4 06 call 0xdc8 ; 0xdc8 <lcd_puts_p>
/* activate the engine by enabling interrupts globally and let sine driver take over. */
sei();
1054: 78 94 sei
if (keyin() > 0) {
i++;
if (i<10) _delay_ms(60);
else {
_delay_ms(10);
i = 11;
1056: 0b e0 ldi r16, 0x0B ; 11
const uint8_t *p = cursorpos;
lcd_gotoxy(0,1);
printdec(freq);printspc();lcd_gotoxy(6,1);
printdec(VperHz);printspc();printspc();lcd_gotoxy(12,1);
printnum((uint16_t)(amplitude*100)/255);lcd_putc('%');printspc();
1058: cf ef ldi r28, 0xFF ; 255
105a: d0 e0 ldi r29, 0x00 ; 0
*/
static void execCommand(void)
{
char n;
static uint8_t i;
n = keyin();
105c: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
// first make sure we get inputs from buttons and not from analog inputs
if (!fastFlags.externalControl){
1060: 90 fc sbrc r9, 0
1062: 3f c0 rjmp .+126 ; 0x10e2 <main+0x28c>
switch (n)
1064: 82 30 cpi r24, 0x02 ; 2
1066: a9 f0 breq .+42 ; 0x1092 <main+0x23c>
1068: 18 f4 brcc .+6 ; 0x1070 <main+0x21a>
106a: 81 30 cpi r24, 0x01 ; 1
106c: 31 f0 breq .+12 ; 0x107a <main+0x224>
106e: 3e c0 rjmp .+124 ; 0x10ec <main+0x296>
1070: 83 30 cpi r24, 0x03 ; 3
1072: c9 f1 breq .+114 ; 0x10e6 <main+0x290>
1074: 84 30 cpi r24, 0x04 ; 4
1076: 01 f1 breq .+64 ; 0x10b8 <main+0x262>
1078: 39 c0 rjmp .+114 ; 0x10ec <main+0x296>
{
// black button - cycle through parameters
case 1 : parameter++; if (parameter > NUMPARAMS) parameter = 0;
107a: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
107e: 8f 5f subi r24, 0xFF ; 255
1080: 80 93 21 01 sts 0x0121, r24 ; 0x800121 <parameter>
1084: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
1088: 82 30 cpi r24, 0x02 ; 2
108a: 90 f1 brcs .+100 ; 0x10f0 <main+0x29a>
108c: 10 92 21 01 sts 0x0121, r1 ; 0x800121 <parameter>
1090: 2f c0 rjmp .+94 ; 0x10f0 <main+0x29a>
break;
// red button - decrement parameter
case 2 :
switch (parameter) {
1092: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
1096: 88 23 and r24, r24
1098: 19 f0 breq .+6 ; 0x10a0 <main+0x24a>
109a: 81 30 cpi r24, 0x01 ; 1
109c: 39 f0 breq .+14 ; 0x10ac <main+0x256>
109e: 28 c0 rjmp .+80 ; 0x10f0 <main+0x29a>
case 0 : if (Inco < 1) Inco = 1;
10a0: 81 10 cpse r8, r1
10a2: 02 c0 rjmp .+4 ; 0x10a8 <main+0x252>
10a4: 88 24 eor r8, r8
10a6: 83 94 inc r8
Inco--;
10a8: 8a 94 dec r8
10aa: 22 c0 rjmp .+68 ; 0x10f0 <main+0x29a>
break;
case 1 : if (VperHz < 1) VperHz = 1;
10ac: 71 10 cpse r7, r1
10ae: 02 c0 rjmp .+4 ; 0x10b4 <main+0x25e>
10b0: 77 24 eor r7, r7
10b2: 73 94 inc r7
VperHz--;
10b4: 7a 94 dec r7
10b6: 1c c0 rjmp .+56 ; 0x10f0 <main+0x29a>
default : break;
}
break;
// green button - increment parameter
case 4 :
switch (parameter) {
10b8: 80 91 21 01 lds r24, 0x0121 ; 0x800121 <parameter>
10bc: 88 23 and r24, r24
10be: 19 f0 breq .+6 ; 0x10c6 <main+0x270>
10c0: 81 30 cpi r24, 0x01 ; 1
10c2: 41 f0 breq .+16 ; 0x10d4 <main+0x27e>
10c4: 15 c0 rjmp .+42 ; 0x10f0 <main+0x29a>
case 0 :if (Inco > 254) Inco = 254;
10c6: ef ef ldi r30, 0xFF ; 255
10c8: 8e 12 cpse r8, r30
10ca: 02 c0 rjmp .+4 ; 0x10d0 <main+0x27a>
10cc: 2e ef ldi r18, 0xFE ; 254
10ce: 82 2e mov r8, r18
Inco++;
10d0: 83 94 inc r8
10d2: 0e c0 rjmp .+28 ; 0x10f0 <main+0x29a>
break;
case 1 :if (VperHz > 254) VperHz = 254;
10d4: ff ef ldi r31, 0xFF ; 255
10d6: 7f 12 cpse r7, r31
10d8: 02 c0 rjmp .+4 ; 0x10de <main+0x288>
10da: 9e ef ldi r25, 0xFE ; 254
10dc: 79 2e mov r7, r25
VperHz++;
10de: 73 94 inc r7
10e0: 07 c0 rjmp .+14 ; 0x10f0 <main+0x29a>
break;
default: i = 0; break;
} // switch
} else { // external control
// with external control we only can go to the extended menu
switch (n)
10e2: 83 30 cpi r24, 0x03 ; 3
10e4: 19 f4 brne .+6 ; 0x10ec <main+0x296>
{
// pressing black (1) and red (2) button simultaneously goes to sub menu
case 3 : execExtendedCommand();
10e6: 0e 94 9b 03 call 0x736 ; 0x736 <execExtendedCommand>
10ea: 02 c0 rjmp .+4 ; 0x10f0 <main+0x29a>
break;
default: i = 0; break;
10ec: 10 92 23 01 sts 0x0123, r1 ; 0x800123 <i.2396>
} // switch
} // external control
// simple autorepeater
if (keyin() > 0) {
10f0: 0e 94 36 03 call 0x66c ; 0x66c <keyin>
10f4: 88 23 and r24, r24
10f6: c9 f0 breq .+50 ; 0x112a <main+0x2d4>
i++;
10f8: 80 91 23 01 lds r24, 0x0123 ; 0x800123 <i.2396>
10fc: 8f 5f subi r24, 0xFF ; 255
10fe: 80 93 23 01 sts 0x0123, r24 ; 0x800123 <i.2396>
if (i<10) _delay_ms(60);
1102: 8a 30 cpi r24, 0x0A ; 10
1104: 50 f4 brcc .+20 ; 0x111a <main+0x2c4>
1106: 2f ef ldi r18, 0xFF ; 255
1108: 8d ee ldi r24, 0xED ; 237
110a: 92 e0 ldi r25, 0x02 ; 2
110c: 21 50 subi r18, 0x01 ; 1
110e: 80 40 sbci r24, 0x00 ; 0
1110: 90 40 sbci r25, 0x00 ; 0
1112: e1 f7 brne .-8 ; 0x110c <main+0x2b6>
1114: 00 c0 rjmp .+0 ; 0x1116 <main+0x2c0>
1116: 00 00 nop
1118: 08 c0 rjmp .+16 ; 0x112a <main+0x2d4>
111a: ef e3 ldi r30, 0x3F ; 63
111c: fc e9 ldi r31, 0x9C ; 156
111e: 31 97 sbiw r30, 0x01 ; 1
1120: f1 f7 brne .-4 ; 0x111e <main+0x2c8>
1122: 00 c0 rjmp .+0 ; 0x1124 <main+0x2ce>
1124: 00 00 nop
else {
_delay_ms(10);
i = 11;
1126: 00 93 23 01 sts 0x0123, r16 ; 0x800123 <i.2396>
*/
static void showPars(void)
{
const uint8_t *p = cursorpos;
lcd_gotoxy(0,1);
112a: 61 e0 ldi r22, 0x01 ; 1
112c: 80 e0 ldi r24, 0x00 ; 0
112e: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
printdec(freq);printspc();lcd_gotoxy(6,1);
1132: 80 91 24 01 lds r24, 0x0124 ; 0x800124 <freq>
1136: 90 91 25 01 lds r25, 0x0125 ; 0x800125 <freq+0x1>
113a: 0e 94 d8 02 call 0x5b0 ; 0x5b0 <printdec>
113e: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
1142: 61 e0 ldi r22, 0x01 ; 1
1144: 86 e0 ldi r24, 0x06 ; 6
1146: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
printdec(VperHz);printspc();printspc();lcd_gotoxy(12,1);
114a: 87 2d mov r24, r7
114c: 90 e0 ldi r25, 0x00 ; 0
114e: 0e 94 d8 02 call 0x5b0 ; 0x5b0 <printdec>
1152: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
1156: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
115a: 61 e0 ldi r22, 0x01 ; 1
115c: 8c e0 ldi r24, 0x0C ; 12
115e: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
printnum((uint16_t)(amplitude*100)/255);lcd_putc('%');printspc();
1162: f4 e6 ldi r31, 0x64 ; 100
1164: 6f 9e mul r6, r31
1166: c0 01 movw r24, r0
1168: 11 24 eor r1, r1
116a: be 01 movw r22, r28
116c: 0e 94 ed 08 call 0x11da ; 0x11da <__udivmodhi4>
1170: cb 01 movw r24, r22
1172: 4a e0 ldi r20, 0x0A ; 10
1174: 60 e0 ldi r22, 0x00 ; 0
1176: 71 e0 ldi r23, 0x01 ; 1
1178: 0e 94 78 09 call 0x12f0 ; 0x12f0 <__itoa_ncheck>
lcd_putc(dectable[n]);
}
}
static void printnum(int16_t number) {
uint8_t n,i;
a = itoa(number,dectable,10);
117c: 80 93 3b 01 sts 0x013B, r24 ; 0x80013b <a>
i = strlen(dectable);
1180: e0 e0 ldi r30, 0x00 ; 0
1182: f1 e0 ldi r31, 0x01 ; 1
1184: 01 90 ld r0, Z+
1186: 00 20 and r0, r0
1188: e9 f7 brne .-6 ; 0x1184 <main+0x32e>
118a: 31 97 sbiw r30, 0x01 ; 1
118c: e0 50 subi r30, 0x00 ; 0
118e: f1 40 sbci r31, 0x01 ; 1
1190: 1e 2f mov r17, r30
1192: 80 e0 ldi r24, 0x00 ; 0
1194: e8 2e mov r14, r24
1196: 81 e0 ldi r24, 0x01 ; 1
1198: f8 2e mov r15, r24
119a: 67 01 movw r12, r14
119c: 8c 2d mov r24, r12
119e: 8e 19 sub r24, r14
for (n=0;n < i;n++) {
11a0: 81 17 cp r24, r17
11a2: 30 f4 brcc .+12 ; 0x11b0 <main+0x35a>
lcd_putc(dectable[n]);
11a4: f6 01 movw r30, r12
11a6: 81 91 ld r24, Z+
11a8: 6f 01 movw r12, r30
11aa: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
11ae: f6 cf rjmp .-20 ; 0x119c <main+0x346>
const uint8_t *p = cursorpos;
lcd_gotoxy(0,1);
printdec(freq);printspc();lcd_gotoxy(6,1);
printdec(VperHz);printspc();printspc();lcd_gotoxy(12,1);
printnum((uint16_t)(amplitude*100)/255);lcd_putc('%');printspc();
11b0: 85 e2 ldi r24, 0x25 ; 37
11b2: 0e 94 c4 06 call 0xd88 ; 0xd88 <lcd_putc>
11b6: 0e 94 d5 02 call 0x5aa ; 0x5aa <printspc>
lcd_gotoxy(pgm_read_byte(p+parameter),1); // set cursor below active parameter
11ba: e0 91 21 01 lds r30, 0x0121 ; 0x800121 <parameter>
11be: f0 e0 ldi r31, 0x00 ; 0
11c0: e7 5d subi r30, 0xD7 ; 215
11c2: fe 4f sbci r31, 0xFE ; 254
11c4: 84 91 lpm r24, Z
11c6: 61 e0 ldi r22, 0x01 ; 1
11c8: 0e 94 b3 06 call 0xd66 ; 0xd66 <lcd_gotoxy>
11cc: 8f e1 ldi r24, 0x1F ; 31
11ce: 9e e4 ldi r25, 0x4E ; 78
11d0: 01 97 sbiw r24, 0x01 ; 1
11d2: f1 f7 brne .-4 ; 0x11d0 <main+0x37a>
11d4: 00 c0 rjmp .+0 ; 0x11d6 <main+0x380>
11d6: 00 00 nop
11d8: 41 cf rjmp .-382 ; 0x105c <main+0x206>
000011da <__udivmodhi4>:
11da: aa 1b sub r26, r26
11dc: bb 1b sub r27, r27
11de: 51 e1 ldi r21, 0x11 ; 17
11e0: 07 c0 rjmp .+14 ; 0x11f0 <__udivmodhi4_ep>
000011e2 <__udivmodhi4_loop>:
11e2: aa 1f adc r26, r26
11e4: bb 1f adc r27, r27
11e6: a6 17 cp r26, r22
11e8: b7 07 cpc r27, r23
11ea: 10 f0 brcs .+4 ; 0x11f0 <__udivmodhi4_ep>
11ec: a6 1b sub r26, r22
11ee: b7 0b sbc r27, r23
000011f0 <__udivmodhi4_ep>:
11f0: 88 1f adc r24, r24
11f2: 99 1f adc r25, r25
11f4: 5a 95 dec r21
11f6: a9 f7 brne .-22 ; 0x11e2 <__udivmodhi4_loop>
11f8: 80 95 com r24
11fa: 90 95 com r25
11fc: bc 01 movw r22, r24
11fe: cd 01 movw r24, r26
1200: 08 95 ret
00001202 <__divmodhi4>:
1202: 97 fb bst r25, 7
1204: 07 2e mov r0, r23
1206: 16 f4 brtc .+4 ; 0x120c <__divmodhi4+0xa>
1208: 00 94 com r0
120a: 07 d0 rcall .+14 ; 0x121a <__divmodhi4_neg1>
120c: 77 fd sbrc r23, 7
120e: 09 d0 rcall .+18 ; 0x1222 <__divmodhi4_neg2>
1210: 0e 94 ed 08 call 0x11da ; 0x11da <__udivmodhi4>
1214: 07 fc sbrc r0, 7
1216: 05 d0 rcall .+10 ; 0x1222 <__divmodhi4_neg2>
1218: 3e f4 brtc .+14 ; 0x1228 <__divmodhi4_exit>
0000121a <__divmodhi4_neg1>:
121a: 90 95 com r25
121c: 81 95 neg r24
121e: 9f 4f sbci r25, 0xFF ; 255
1220: 08 95 ret
00001222 <__divmodhi4_neg2>:
1222: 70 95 com r23
1224: 61 95 neg r22
1226: 7f 4f sbci r23, 0xFF ; 255
00001228 <__divmodhi4_exit>:
1228: 08 95 ret
0000122a <__udivmodsi4>:
122a: a1 e2 ldi r26, 0x21 ; 33
122c: 1a 2e mov r1, r26
122e: aa 1b sub r26, r26
1230: bb 1b sub r27, r27
1232: fd 01 movw r30, r26
1234: 0d c0 rjmp .+26 ; 0x1250 <__udivmodsi4_ep>
00001236 <__udivmodsi4_loop>:
1236: aa 1f adc r26, r26
1238: bb 1f adc r27, r27
123a: ee 1f adc r30, r30
123c: ff 1f adc r31, r31
123e: a2 17 cp r26, r18
1240: b3 07 cpc r27, r19
1242: e4 07 cpc r30, r20
1244: f5 07 cpc r31, r21
1246: 20 f0 brcs .+8 ; 0x1250 <__udivmodsi4_ep>
1248: a2 1b sub r26, r18
124a: b3 0b sbc r27, r19
124c: e4 0b sbc r30, r20
124e: f5 0b sbc r31, r21
00001250 <__udivmodsi4_ep>:
1250: 66 1f adc r22, r22
1252: 77 1f adc r23, r23
1254: 88 1f adc r24, r24
1256: 99 1f adc r25, r25
1258: 1a 94 dec r1
125a: 69 f7 brne .-38 ; 0x1236 <__udivmodsi4_loop>
125c: 60 95 com r22
125e: 70 95 com r23
1260: 80 95 com r24
1262: 90 95 com r25
1264: 9b 01 movw r18, r22
1266: ac 01 movw r20, r24
1268: bd 01 movw r22, r26
126a: cf 01 movw r24, r30
126c: 08 95 ret
0000126e <__divmodsi4>:
126e: 05 2e mov r0, r21
1270: 97 fb bst r25, 7
1272: 1e f4 brtc .+6 ; 0x127a <__divmodsi4+0xc>
1274: 00 94 com r0
1276: 0e 94 4e 09 call 0x129c ; 0x129c <__negsi2>
127a: 57 fd sbrc r21, 7
127c: 07 d0 rcall .+14 ; 0x128c <__divmodsi4_neg2>
127e: 0e 94 15 09 call 0x122a ; 0x122a <__udivmodsi4>
1282: 07 fc sbrc r0, 7
1284: 03 d0 rcall .+6 ; 0x128c <__divmodsi4_neg2>
1286: 4e f4 brtc .+18 ; 0x129a <__divmodsi4_exit>
1288: 0c 94 4e 09 jmp 0x129c ; 0x129c <__negsi2>
0000128c <__divmodsi4_neg2>:
128c: 50 95 com r21
128e: 40 95 com r20
1290: 30 95 com r19
1292: 21 95 neg r18
1294: 3f 4f sbci r19, 0xFF ; 255
1296: 4f 4f sbci r20, 0xFF ; 255
1298: 5f 4f sbci r21, 0xFF ; 255
0000129a <__divmodsi4_exit>:
129a: 08 95 ret
0000129c <__negsi2>:
129c: 90 95 com r25
129e: 80 95 com r24
12a0: 70 95 com r23
12a2: 61 95 neg r22
12a4: 7f 4f sbci r23, 0xFF ; 255
12a6: 8f 4f sbci r24, 0xFF ; 255
12a8: 9f 4f sbci r25, 0xFF ; 255
12aa: 08 95 ret
000012ac <__umulhisi3>:
12ac: a2 9f mul r26, r18
12ae: b0 01 movw r22, r0
12b0: b3 9f mul r27, r19
12b2: c0 01 movw r24, r0
12b4: a3 9f mul r26, r19
12b6: 70 0d add r23, r0
12b8: 81 1d adc r24, r1
12ba: 11 24 eor r1, r1
12bc: 91 1d adc r25, r1
12be: b2 9f mul r27, r18
12c0: 70 0d add r23, r0
12c2: 81 1d adc r24, r1
12c4: 11 24 eor r1, r1
12c6: 91 1d adc r25, r1
12c8: 08 95 ret
000012ca <__mulshisi3>:
12ca: b7 ff sbrs r27, 7
12cc: 0c 94 6d 09 jmp 0x12da ; 0x12da <__muluhisi3>
000012d0 <__mulohisi3>:
12d0: 0e 94 6d 09 call 0x12da ; 0x12da <__muluhisi3>
12d4: 82 1b sub r24, r18
12d6: 93 0b sbc r25, r19
12d8: 08 95 ret
000012da <__muluhisi3>:
12da: 0e 94 56 09 call 0x12ac ; 0x12ac <__umulhisi3>
12de: a5 9f mul r26, r21
12e0: 90 0d add r25, r0
12e2: b4 9f mul r27, r20
12e4: 90 0d add r25, r0
12e6: a4 9f mul r26, r20
12e8: 80 0d add r24, r0
12ea: 91 1d adc r25, r1
12ec: 11 24 eor r1, r1
12ee: 08 95 ret
000012f0 <__itoa_ncheck>:
12f0: bb 27 eor r27, r27
12f2: 4a 30 cpi r20, 0x0A ; 10
12f4: 31 f4 brne .+12 ; 0x1302 <__itoa_ncheck+0x12>
12f6: 99 23 and r25, r25
12f8: 22 f4 brpl .+8 ; 0x1302 <__itoa_ncheck+0x12>
12fa: bd e2 ldi r27, 0x2D ; 45
12fc: 90 95 com r25
12fe: 81 95 neg r24
1300: 9f 4f sbci r25, 0xFF ; 255
1302: 0c 94 84 09 jmp 0x1308 ; 0x1308 <__utoa_common>
00001306 <__utoa_ncheck>:
1306: bb 27 eor r27, r27
00001308 <__utoa_common>:
1308: fb 01 movw r30, r22
130a: 55 27 eor r21, r21
130c: aa 27 eor r26, r26
130e: 88 0f add r24, r24
1310: 99 1f adc r25, r25
1312: aa 1f adc r26, r26
1314: a4 17 cp r26, r20
1316: 10 f0 brcs .+4 ; 0x131c <__utoa_common+0x14>
1318: a4 1b sub r26, r20
131a: 83 95 inc r24
131c: 50 51 subi r21, 0x10 ; 16
131e: b9 f7 brne .-18 ; 0x130e <__utoa_common+0x6>
1320: a0 5d subi r26, 0xD0 ; 208
1322: aa 33 cpi r26, 0x3A ; 58
1324: 08 f0 brcs .+2 ; 0x1328 <__utoa_common+0x20>
1326: a9 5d subi r26, 0xD9 ; 217
1328: a1 93 st Z+, r26
132a: 00 97 sbiw r24, 0x00 ; 0
132c: 79 f7 brne .-34 ; 0x130c <__utoa_common+0x4>
132e: b1 11 cpse r27, r1
1330: b1 93 st Z+, r27
1332: 11 92 st Z+, r1
1334: cb 01 movw r24, r22
1336: 0c 94 9d 09 jmp 0x133a ; 0x133a <strrev>
0000133a <strrev>:
133a: dc 01 movw r26, r24
133c: fc 01 movw r30, r24
133e: 67 2f mov r22, r23
1340: 71 91 ld r23, Z+
1342: 77 23 and r23, r23
1344: e1 f7 brne .-8 ; 0x133e <strrev+0x4>
1346: 32 97 sbiw r30, 0x02 ; 2
1348: 04 c0 rjmp .+8 ; 0x1352 <strrev+0x18>
134a: 7c 91 ld r23, X
134c: 6d 93 st X+, r22
134e: 70 83 st Z, r23
1350: 62 91 ld r22, -Z
1352: ae 17 cp r26, r30
1354: bf 07 cpc r27, r31
1356: c8 f3 brcs .-14 ; 0x134a <strrev+0x10>
1358: 08 95 ret
0000135a <eeprom_read_byte>:
135a: f9 99 sbic 0x1f, 1 ; 31
135c: fe cf rjmp .-4 ; 0x135a <eeprom_read_byte>
135e: 92 bd out 0x22, r25 ; 34
1360: 81 bd out 0x21, r24 ; 33
1362: f8 9a sbi 0x1f, 0 ; 31
1364: 99 27 eor r25, r25
1366: 80 b5 in r24, 0x20 ; 32
1368: 08 95 ret
0000136a <eeprom_read_word>:
136a: a8 e1 ldi r26, 0x18 ; 24
136c: b0 e0 ldi r27, 0x00 ; 0
136e: 42 e0 ldi r20, 0x02 ; 2
1370: 50 e0 ldi r21, 0x00 ; 0
1372: 0c 94 d0 09 jmp 0x13a0 ; 0x13a0 <eeprom_read_blraw>
00001376 <eeprom_write_byte>:
1376: 26 2f mov r18, r22
00001378 <eeprom_write_r18>:
1378: f9 99 sbic 0x1f, 1 ; 31
137a: fe cf rjmp .-4 ; 0x1378 <eeprom_write_r18>
137c: 1f ba out 0x1f, r1 ; 31
137e: 92 bd out 0x22, r25 ; 34
1380: 81 bd out 0x21, r24 ; 33
1382: 20 bd out 0x20, r18 ; 32
1384: 0f b6 in r0, 0x3f ; 63
1386: f8 94 cli
1388: fa 9a sbi 0x1f, 2 ; 31
138a: f9 9a sbi 0x1f, 1 ; 31
138c: 0f be out 0x3f, r0 ; 63
138e: 01 96 adiw r24, 0x01 ; 1
1390: 08 95 ret
00001392 <eeprom_write_word>:
1392: 0e 94 bb 09 call 0x1376 ; 0x1376 <eeprom_write_byte>
1396: 27 2f mov r18, r23
1398: 0c 94 bc 09 jmp 0x1378 ; 0x1378 <eeprom_write_r18>
0000139c <eeprom_read_block>:
139c: dc 01 movw r26, r24
139e: cb 01 movw r24, r22
000013a0 <eeprom_read_blraw>:
13a0: fc 01 movw r30, r24
13a2: f9 99 sbic 0x1f, 1 ; 31
13a4: fe cf rjmp .-4 ; 0x13a2 <eeprom_read_blraw+0x2>
13a6: 06 c0 rjmp .+12 ; 0x13b4 <eeprom_read_blraw+0x14>
13a8: f2 bd out 0x22, r31 ; 34
13aa: e1 bd out 0x21, r30 ; 33
13ac: f8 9a sbi 0x1f, 0 ; 31
13ae: 31 96 adiw r30, 0x01 ; 1
13b0: 00 b4 in r0, 0x20 ; 32
13b2: 0d 92 st X+, r0
13b4: 41 50 subi r20, 0x01 ; 1
13b6: 50 40 sbci r21, 0x00 ; 0
13b8: b8 f7 brcc .-18 ; 0x13a8 <eeprom_read_blraw+0x8>
13ba: 08 95 ret
000013bc <_exit>:
13bc: f8 94 cli
000013be <__stop_program>:
13be: ff cf rjmp .-2 ; 0x13be <__stop_program>