BrushLess-Ctrl_V0_41_10A.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .text 00001bca 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE 1 .data 00000018 00800060 00001bca 00001c5e 2**0 CONTENTS, ALLOC, LOAD, DATA 2 .bss 00000328 00800078 00800078 00001c76 2**0 ALLOC 3 .debug_aranges 000000e0 00000000 00000000 00001c76 2**0 CONTENTS, READONLY, DEBUGGING 4 .debug_pubnames 000005da 00000000 00000000 00001d56 2**0 CONTENTS, READONLY, DEBUGGING 5 .debug_info 00001379 00000000 00000000 00002330 2**0 CONTENTS, READONLY, DEBUGGING 6 .debug_abbrev 0000077a 00000000 00000000 000036a9 2**0 CONTENTS, READONLY, DEBUGGING 7 .debug_line 00001739 00000000 00000000 00003e23 2**0 CONTENTS, READONLY, DEBUGGING 8 .debug_frame 000002e0 00000000 00000000 0000555c 2**2 CONTENTS, READONLY, DEBUGGING 9 .debug_str 000005bf 00000000 00000000 0000583c 2**0 CONTENTS, READONLY, DEBUGGING 10 .debug_loc 0000073a 00000000 00000000 00005dfb 2**0 CONTENTS, READONLY, DEBUGGING 11 .debug_ranges 00000018 00000000 00000000 00006535 2**0 CONTENTS, READONLY, DEBUGGING Disassembly of section .text: 00000000 <__vectors>: 0: 12 c0 rjmp .+36 ; 0x26 <__ctors_end> 2: 50 ca rjmp .-2912 ; 0xfffff4a4 <__eeprom_end+0xff7ef4a4> 4: 2b c0 rjmp .+86 ; 0x5c <__bad_interrupt> 6: 2a c0 rjmp .+84 ; 0x5c <__bad_interrupt> 8: b5 ca rjmp .-2710 ; 0xfffff574 <__eeprom_end+0xff7ef574> a: b5 c9 rjmp .-3222 ; 0xfffff376 <__eeprom_end+0xff7ef376> c: 27 c0 rjmp .+78 ; 0x5c <__bad_interrupt> e: 26 c0 rjmp .+76 ; 0x5c <__bad_interrupt> 10: a1 c9 rjmp .-3262 ; 0xfffff354 <__eeprom_end+0xff7ef354> 12: a9 c8 rjmp .-3758 ; 0xfffff166 <__eeprom_end+0xff7ef166> 14: 23 c0 rjmp .+70 ; 0x5c <__bad_interrupt> 16: 65 c7 rjmp .+3786 ; 0xee2 <__vector_11> 18: 21 c0 rjmp .+66 ; 0x5c <__bad_interrupt> 1a: 3a c6 rjmp .+3188 ; 0xc90 <__vector_13> 1c: 1f c0 rjmp .+62 ; 0x5c <__bad_interrupt> 1e: 1e c0 rjmp .+60 ; 0x5c <__bad_interrupt> 20: 22 cb rjmp .-2492 ; 0xfffff666 <__eeprom_end+0xff7ef666> 22: 57 ca rjmp .-2898 ; 0xfffff4d2 <__eeprom_end+0xff7ef4d2> 24: 1b c0 rjmp .+54 ; 0x5c <__bad_interrupt> 00000026 <__ctors_end>: 26: 11 24 eor r1, r1 28: 1f be out 0x3f, r1 ; 63 2a: cf e5 ldi r28, 0x5F ; 95 2c: d4 e0 ldi r29, 0x04 ; 4 2e: de bf out 0x3e, r29 ; 62 30: cd bf out 0x3d, r28 ; 61 00000032 <__do_copy_data>: 32: 10 e0 ldi r17, 0x00 ; 0 34: a0 e6 ldi r26, 0x60 ; 96 36: b0 e0 ldi r27, 0x00 ; 0 38: ea ec ldi r30, 0xCA ; 202 3a: fb e1 ldi r31, 0x1B ; 27 3c: 02 c0 rjmp .+4 ; 0x42 <.do_copy_data_start> 0000003e <.do_copy_data_loop>: 3e: 05 90 lpm r0, Z+ 40: 0d 92 st X+, r0 00000042 <.do_copy_data_start>: 42: a8 37 cpi r26, 0x78 ; 120 44: b1 07 cpc r27, r17 46: d9 f7 brne .-10 ; 0x3e <.do_copy_data_loop> 00000048 <__do_clear_bss>: 48: 13 e0 ldi r17, 0x03 ; 3 4a: a8 e7 ldi r26, 0x78 ; 120 4c: b0 e0 ldi r27, 0x00 ; 0 4e: 01 c0 rjmp .+2 ; 0x52 <.do_clear_bss_start> 00000050 <.do_clear_bss_loop>: 50: 1d 92 st X+, r1 00000052 <.do_clear_bss_start>: 52: a0 3a cpi r26, 0xA0 ; 160 54: b1 07 cpc r27, r17 56: e1 f7 brne .-8 ; 0x50 <.do_clear_bss_loop> 58: 46 d4 rcall .+2188 ; 0x8e6
5a: b5 cd rjmp .-1174 ; 0xfffffbc6 <__eeprom_end+0xff7efbc6> 0000005c <__bad_interrupt>: 5c: d1 cf rjmp .-94 ; 0x0 <__vectors> 0000005e : // void SetPWM(void) //############################################################################ { unsigned char tmp_pwm; tmp_pwm = PWM; 5e: 40 91 78 00 lds r20, 0x0078 if(tmp_pwm > MaxPWM) // Strombegrenzung 62: 80 91 64 00 lds r24, 0x0064 66: 84 17 cp r24, r20 68: 10 f4 brcc .+4 ; 0x6e { tmp_pwm = MaxPWM; PORTC |= ROT; 6a: ab 9a sbi 0x15, 3 ; 21 6c: 48 2f mov r20, r24 } if(Strom > MAX_STROM) // Strombegrenzung 6e: 20 91 7a 00 lds r18, 0x007A 72: 30 91 7b 00 lds r19, 0x007B 76: 29 3c cpi r18, 0xC9 ; 201 78: 31 05 cpc r19, r1 7a: c8 f0 brcs .+50 ; 0xae { OCR1A = 0; OCR1B = 0; OCR2 = 0; 7c: 1b bc out 0x2b, r1 ; 43 7e: 1a bc out 0x2a, r1 ; 42 80: 19 bc out 0x29, r1 ; 41 82: 18 bc out 0x28, r1 ; 40 84: 13 bc out 0x23, r1 ; 35 PORTD &= ~0x38; 86: 82 b3 in r24, 0x12 ; 18 88: 87 7c andi r24, 0xC7 ; 199 8a: 82 bb out 0x12, r24 ; 18 PORTC |= ROT; 8c: ab 9a sbi 0x15, 3 ; 21 DebugOut.Analog[6]++; 8e: 80 91 90 03 lds r24, 0x0390 92: 90 91 91 03 lds r25, 0x0391 96: 01 96 adiw r24, 0x01 ; 1 98: 90 93 91 03 sts 0x0391, r25 9c: 80 93 90 03 sts 0x0390, r24 Strom--; a0: 21 50 subi r18, 0x01 ; 1 a2: 30 40 sbci r19, 0x00 ; 0 a4: 30 93 7b 00 sts 0x007B, r19 a8: 20 93 7a 00 sts 0x007A, r18 ac: 08 95 ret OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm; #endif #ifdef _16KHZ //OCR1A = 2 * (int)tmp_pwm; OCR1B = 2 * (int)tmp_pwm; OCR2 = tmp_pwm; OCR1A = tmp_pwm; OCR1B = tmp_pwm; OCR2 = tmp_pwm; ae: 84 2f mov r24, r20 b0: 90 e0 ldi r25, 0x00 ; 0 b2: 9b bd out 0x2b, r25 ; 43 b4: 8a bd out 0x2a, r24 ; 42 b6: 99 bd out 0x29, r25 ; 41 b8: 88 bd out 0x28, r24 ; 40 ba: 43 bd out 0x23, r20 ; 35 bc: 08 95 ret 000000be : } } void DebugAusgaben(void) { DebugOut.Analog[0] = Strom; be: e4 e8 ldi r30, 0x84 ; 132 c0: f3 e0 ldi r31, 0x03 ; 3 c2: 80 91 7a 00 lds r24, 0x007A c6: 90 91 7b 00 lds r25, 0x007B ca: 90 93 85 03 sts 0x0385, r25 ce: 80 93 84 03 sts 0x0384, r24 DebugOut.Analog[1] = Mittelstrom; d2: 80 91 7d 00 lds r24, 0x007D d6: 80 93 86 03 sts 0x0386, r24 da: 13 82 std Z+3, r1 ; 0x03 DebugOut.Analog[2] = SIO_Drehzahl; dc: 80 91 8b 00 lds r24, 0x008B e0: 90 91 8c 00 lds r25, 0x008C e4: 90 93 89 03 sts 0x0389, r25 e8: 80 93 88 03 sts 0x0388, r24 DebugOut.Analog[3] = PPM_Signal; ec: 80 91 a5 00 lds r24, 0x00A5 f0: 90 91 a6 00 lds r25, 0x00A6 f4: 90 93 8b 03 sts 0x038B, r25 f8: 80 93 8a 03 sts 0x038A, r24 DebugOut.Analog[4] = OCR2; fc: 83 b5 in r24, 0x23 ; 35 fe: 80 93 8c 03 sts 0x038C, r24 102: 11 86 std Z+9, r1 ; 0x09 // DebugOut.Analog[5] = PWM; } 104: 08 95 ret 00000106 : //############################################################################ // void PWM_Init(void) //############################################################################ { PWM_OFF; 106: 1b bc out 0x2b, r1 ; 43 108: 1a bc out 0x2a, r1 ; 42 10a: 19 bc out 0x29, r1 ; 41 10c: 18 bc out 0x28, r1 ; 40 10e: 13 bc out 0x23, r1 ; 35 110: 91 e0 ldi r25, 0x01 ; 1 112: 9f bd out 0x2f, r25 ; 47 114: 81 e4 ldi r24, 0x41 ; 65 116: 85 bd out 0x25, r24 ; 37 118: 8e e0 ldi r24, 0x0E ; 14 11a: 87 bb out 0x17, r24 ; 23 11c: 88 b3 in r24, 0x18 ; 24 11e: 81 7f andi r24, 0xF1 ; 241 120: 88 bb out 0x18, r24 ; 24 TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (0 << WGM12) | 122: 9e bd out 0x2e, r25 ; 46 (0 << WGM13) | (0<< ICES1) | (0 << ICNC1); /* TCCR1B = (1 << CS10) | (0 << CS11) | (0 << CS12) | (1 << WGM12) | (0 << WGM13) | (0<< ICES1) | (0 << ICNC1); */ } 124: 08 95 ret 00000126 : //############################################################################ // void Wait(unsigned char dauer) //############################################################################ { dauer = (unsigned char)TCNT0 + dauer; 126: 92 b7 in r25, 0x32 ; 50 128: 98 0f add r25, r24 while((TCNT0 - dauer) & 0x80); 12a: 82 b7 in r24, 0x32 ; 50 12c: 89 1b sub r24, r25 12e: 87 fd sbrc r24, 7 130: fc cf rjmp .-8 ; 0x12a } 132: 08 95 ret 00000134 : } return(0); } unsigned char Delay(unsigned int timer) { 134: 01 c0 rjmp .+2 ; 0x138 while(timer--) { // if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;} asm volatile(""); 136: 01 97 sbiw r24, 0x01 ; 1 return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 138: 00 97 sbiw r24, 0x00 ; 0 13a: e9 f7 brne .-6 ; 0x136 { // if(SENSE_H) { PORTC |= ROT; } else { PORTC &= ~ROT;} asm volatile(""); } return(0); } 13c: 80 e0 ldi r24, 0x00 ; 0 13e: 08 95 ret 00000140 : unsigned char SollwertErmittlung(void) //############################################################################ { static unsigned int sollwert = 0; unsigned int ppm; if(!I2C_Timeout) // bei Erreichen von 0 ist der Wert ungültig 140: 80 91 80 00 lds r24, 0x0080 144: 90 91 81 00 lds r25, 0x0081 148: 89 2b or r24, r25 14a: 09 f0 breq .+2 ; 0x14e 14c: 59 c0 rjmp .+178 ; 0x200 { if(SIO_Timeout) // es gibt gültige SIO-Daten 14e: 80 91 82 00 lds r24, 0x0082 152: 90 91 83 00 lds r25, 0x0083 156: 89 2b or r24, r25 158: 99 f0 breq .+38 ; 0x180 { sollwert = (MAX_PWM * (unsigned int) SIO_Sollwert) / 200; // skalieren auf 0-200 = 0-255 15a: 90 91 90 00 lds r25, 0x0090 15e: 8f ef ldi r24, 0xFF ; 255 160: 98 9f mul r25, r24 162: c0 01 movw r24, r0 164: 11 24 eor r1, r1 166: 68 ec ldi r22, 0xC8 ; 200 168: 70 e0 ldi r23, 0x00 ; 0 16a: 86 db rcall .-2292 ; 0xfffff878 <__eeprom_end+0xff7ef878> 16c: 70 93 8f 00 sts 0x008F, r23 170: 60 93 8e 00 sts 0x008E, r22 PPM_Betrieb = 0; 174: 10 92 67 00 sts 0x0067, r1 ICP_INT_DISABLE; 178: 89 b7 in r24, 0x39 ; 57 17a: 8f 7d andi r24, 0xDF ; 223 17c: 89 bf out 0x39, r24 ; 57 17e: 31 c0 rjmp .+98 ; 0x1e2 PORTC &= ~ROT; } else if(anz_ppm_werte > 20) // es gibt gültige PPM-Daten 180: 80 91 a9 00 lds r24, 0x00A9 184: 85 31 cpi r24, 0x15 ; 21 186: 78 f1 brcs .+94 ; 0x1e6 { PPM_Betrieb = 1; 188: 81 e0 ldi r24, 0x01 ; 1 18a: 80 93 67 00 sts 0x0067, r24 ppm = PPM_Signal; 18e: 20 91 a5 00 lds r18, 0x00A5 192: 30 91 a6 00 lds r19, 0x00A6 if(ppm > 300) ppm = 0; // ungültiges Signal 196: 41 e0 ldi r20, 0x01 ; 1 198: 2d 32 cpi r18, 0x2D ; 45 19a: 34 07 cpc r19, r20 19c: 30 f4 brcc .+12 ; 0x1aa if(ppm > 200) ppm = 200; 19e: 29 3c cpi r18, 0xC9 ; 201 1a0: 31 05 cpc r19, r1 1a2: 40 f4 brcc .+16 ; 0x1b4 if(ppm <= MIN_PPM) sollwert = 0; 1a4: 2b 30 cpi r18, 0x0B ; 11 1a6: 31 05 cpc r19, r1 1a8: 38 f4 brcc .+14 ; 0x1b8 1aa: 10 92 8f 00 sts 0x008F, r1 1ae: 10 92 8e 00 sts 0x008E, r1 1b2: 17 c0 rjmp .+46 ; 0x1e2 1b4: 28 ec ldi r18, 0xC8 ; 200 1b6: 30 e0 ldi r19, 0x00 ; 0 else { sollwert = (int) MIN_PWM + ((MAX_PWM - MIN_PWM) * (ppm - MIN_PPM)) / (190 - MIN_PPM); 1b8: 8c ef ldi r24, 0xFC ; 252 1ba: 90 e0 ldi r25, 0x00 ; 0 1bc: ac 01 movw r20, r24 1be: 24 9f mul r18, r20 1c0: c0 01 movw r24, r0 1c2: 25 9f mul r18, r21 1c4: 90 0d add r25, r0 1c6: 34 9f mul r19, r20 1c8: 90 0d add r25, r0 1ca: 11 24 eor r1, r1 1cc: 88 5d subi r24, 0xD8 ; 216 1ce: 99 40 sbci r25, 0x09 ; 9 1d0: 64 eb ldi r22, 0xB4 ; 180 1d2: 70 e0 ldi r23, 0x00 ; 0 1d4: 51 db rcall .-2398 ; 0xfffff878 <__eeprom_end+0xff7ef878> 1d6: 6d 5f subi r22, 0xFD ; 253 1d8: 7f 4f sbci r23, 0xFF ; 255 1da: 70 93 8f 00 sts 0x008F, r23 1de: 60 93 8e 00 sts 0x008E, r22 } PORTC &= ~ROT; 1e2: ab 98 cbi 0x15, 3 ; 21 1e4: 19 c0 rjmp .+50 ; 0x218 } else // Kein gültiger Sollwert { if(!TEST_SCHUB) { if(sollwert) sollwert--; } 1e6: 80 91 8e 00 lds r24, 0x008E 1ea: 90 91 8f 00 lds r25, 0x008F 1ee: 00 97 sbiw r24, 0x00 ; 0 1f0: 29 f0 breq .+10 ; 0x1fc 1f2: 01 97 sbiw r24, 0x01 ; 1 1f4: 90 93 8f 00 sts 0x008F, r25 1f8: 80 93 8e 00 sts 0x008E, r24 PORTC |= ROT; 1fc: ab 9a sbi 0x15, 3 ; 21 1fe: 0c c0 rjmp .+24 ; 0x218 } } else // I2C-Daten sind gültig { sollwert = I2C_RXBuffer; 200: 80 91 95 03 lds r24, 0x0395 204: 80 93 8e 00 sts 0x008E, r24 208: 10 92 8f 00 sts 0x008F, r1 PPM_Betrieb = 0; 20c: 10 92 67 00 sts 0x0067, r1 PORTC &= ~ROT; 210: ab 98 cbi 0x15, 3 ; 21 ICP_INT_DISABLE; 212: 89 b7 in r24, 0x39 ; 57 214: 8f 7d andi r24, 0xDF ; 223 216: 89 bf out 0x39, r24 ; 57 } if(sollwert > MAX_PWM) sollwert = MAX_PWM; 218: 80 91 8e 00 lds r24, 0x008E 21c: 90 91 8f 00 lds r25, 0x008F 220: 8f 3f cpi r24, 0xFF ; 255 222: 91 05 cpc r25, r1 224: 39 f0 breq .+14 ; 0x234 226: 30 f0 brcs .+12 ; 0x234 228: 8f ef ldi r24, 0xFF ; 255 22a: 90 e0 ldi r25, 0x00 ; 0 22c: 90 93 8f 00 sts 0x008F, r25 230: 80 93 8e 00 sts 0x008E, r24 return(sollwert); } 234: 80 91 8e 00 lds r24, 0x008E 238: 08 95 ret 0000023a : */ #define TEST_STROMGRENZE 120 unsigned char DelayM(unsigned int timer) { 23a: cf 93 push r28 23c: df 93 push r29 23e: ec 01 movw r28, r24 240: 17 c0 rjmp .+46 ; 0x270 while(timer--) { FastADConvert(); 242: 5f d8 rcall .-3906 ; 0xfffff302 <__eeprom_end+0xff7ef302> 244: 21 97 sbiw r28, 0x01 ; 1 if(Strom > (TEST_STROMGRENZE + RuheStrom)) 246: 80 91 b5 02 lds r24, 0x02B5 24a: 90 91 b6 02 lds r25, 0x02B6 24e: 88 58 subi r24, 0x88 ; 136 250: 9f 4f sbci r25, 0xFF ; 255 252: 20 91 7a 00 lds r18, 0x007A 256: 30 91 7b 00 lds r19, 0x007B 25a: 82 17 cp r24, r18 25c: 93 07 cpc r25, r19 25e: 40 f4 brcc .+16 ; 0x270 { FETS_OFF; 260: 82 b3 in r24, 0x12 ; 18 262: 87 7c andi r24, 0xC7 ; 199 264: 82 bb out 0x12, r24 ; 18 266: 88 b3 in r24, 0x18 ; 24 268: 81 7f andi r24, 0xF1 ; 241 26a: 88 bb out 0x18, r24 ; 24 26c: 81 e0 ldi r24, 0x01 ; 1 26e: 03 c0 rjmp .+6 ; 0x276 #define TEST_STROMGRENZE 120 unsigned char DelayM(unsigned int timer) { while(timer--) 270: 20 97 sbiw r28, 0x00 ; 0 272: 39 f7 brne .-50 ; 0x242 274: 80 e0 ldi r24, 0x00 ; 0 FETS_OFF; return(1); } } return(0); } 276: df 91 pop r29 278: cf 91 pop r28 27a: 08 95 ret 0000027c : dauer = (unsigned char)TCNT0 + dauer; while((TCNT0 - dauer) & 0x80); } void RotBlink(unsigned char anz) { 27c: 1f 93 push r17 27e: 18 2f mov r17, r24 sei(); // Interrupts ein 280: 78 94 sei 282: 09 c0 rjmp .+18 ; 0x296 while(anz--) { PORTC |= ROT; 284: ab 9a sbi 0x15, 3 ; 21 Delay_ms(300); 286: 8c e2 ldi r24, 0x2C ; 44 288: 91 e0 ldi r25, 0x01 ; 1 28a: d2 d7 rcall .+4004 ; 0x1230 PORTC &= ~ROT; 28c: ab 98 cbi 0x15, 3 ; 21 Delay_ms(300); 28e: 8c e2 ldi r24, 0x2C ; 44 290: 91 e0 ldi r25, 0x01 ; 1 292: ce d7 rcall .+3996 ; 0x1230 294: 11 50 subi r17, 0x01 ; 1 } void RotBlink(unsigned char anz) { sei(); // Interrupts ein while(anz--) 296: 11 23 and r17, r17 298: a9 f7 brne .-22 ; 0x284 PORTC |= ROT; Delay_ms(300); PORTC &= ~ROT; Delay_ms(300); } Delay_ms(1000); 29a: 88 ee ldi r24, 0xE8 ; 232 29c: 93 e0 ldi r25, 0x03 ; 3 29e: c8 d7 rcall .+3984 ; 0x1230 } 2a0: 1f 91 pop r17 2a2: 08 95 ret 000002a4 : #define LOW_B_EIN PORTD |= 0x10 #define LOW_C_EIN PORTD |= 0x20 void MotorTon(void) //############################################################################ { 2a4: af 92 push r10 2a6: bf 92 push r11 2a8: df 92 push r13 2aa: ef 92 push r14 2ac: ff 92 push r15 2ae: 0f 93 push r16 2b0: 1f 93 push r17 2b2: df 93 push r29 2b4: cf 93 push r28 2b6: cd b7 in r28, 0x3d ; 61 2b8: de b7 in r29, 0x3e ; 62 2ba: 27 97 sbiw r28, 0x07 ; 7 2bc: 0f b6 in r0, 0x3f ; 63 2be: f8 94 cli 2c0: de bf out 0x3e, r29 ; 62 2c2: 0f be out 0x3f, r0 ; 63 2c4: cd bf out 0x3d, r28 ; 61 unsigned char ADR_TAB[7] = {0,0,0,1,1,2,2}; 2c6: de 01 movw r26, r28 2c8: 11 96 adiw r26, 0x01 ; 1 2ca: e8 e6 ldi r30, 0x68 ; 104 2cc: f0 e0 ldi r31, 0x00 ; 0 2ce: 87 e0 ldi r24, 0x07 ; 7 2d0: 01 90 ld r0, Z+ 2d2: 0d 92 st X+, r0 2d4: 81 50 subi r24, 0x01 ; 1 2d6: e1 f7 brne .-8 ; 0x2d0 unsigned int timer = 300,i; unsigned int t = 0; unsigned char anz = 0,MosfetOkay = 0, grenze = 50; PORTC &= ~ROT; 2d8: ab 98 cbi 0x15, 3 ; 21 Delay_ms(300 * ADR_TAB[MotorAdresse]); 2da: 80 91 66 00 lds r24, 0x0066 2de: fe 01 movw r30, r28 2e0: e8 0f add r30, r24 2e2: f1 1d adc r31, r1 2e4: 81 81 ldd r24, Z+1 ; 0x01 2e6: 90 e0 ldi r25, 0x00 ; 0 2e8: 2c e2 ldi r18, 0x2C ; 44 2ea: 31 e0 ldi r19, 0x01 ; 1 2ec: ac 01 movw r20, r24 2ee: 42 9f mul r20, r18 2f0: c0 01 movw r24, r0 2f2: 43 9f mul r20, r19 2f4: 90 0d add r25, r0 2f6: 52 9f mul r21, r18 2f8: 90 0d add r25, r0 2fa: 11 24 eor r1, r1 2fc: 99 d7 rcall .+3890 ; 0x1230 DISABLE_SENSE_INT; 2fe: 10 92 b1 00 sts 0x00B1, r1 302: 43 98 cbi 0x08, 3 ; 8 cli();//Globale Interrupts Ausschalten 304: f8 94 cli uart_putchar('\n'); 306: 8a e0 ldi r24, 0x0A ; 10 308: df d5 rcall .+3006 ; 0xec8 STEUER_OFF; 30a: 82 b3 in r24, 0x12 ; 18 30c: 87 7c andi r24, 0xC7 ; 199 30e: 82 bb out 0x12, r24 ; 18 310: 1b bc out 0x2b, r1 ; 43 312: 1a bc out 0x2a, r1 ; 42 314: 19 bc out 0x29, r1 ; 41 316: 18 bc out 0x28, r1 ; 40 318: 13 bc out 0x23, r1 ; 35 31a: 81 e0 ldi r24, 0x01 ; 1 31c: 8f bd out 0x2f, r24 ; 47 31e: 81 e4 ldi r24, 0x41 ; 65 320: 85 bd out 0x25, r24 ; 37 322: 8e e0 ldi r24, 0x0E ; 14 324: 87 bb out 0x17, r24 ; 23 326: 88 b3 in r24, 0x18 ; 24 328: 81 7f andi r24, 0xF1 ; 241 32a: 88 bb out 0x18, r24 ; 24 Strom_max = 0; 32c: 10 92 7c 00 sts 0x007C, r1 DelayM(50); 330: 82 e3 ldi r24, 0x32 ; 50 332: 90 e0 ldi r25, 0x00 ; 0 334: 82 df rcall .-252 ; 0x23a RuheStrom = Strom_max; 336: 80 91 7c 00 lds r24, 0x007C 33a: 80 93 b5 02 sts 0x02B5, r24 33e: 10 92 b6 02 sts 0x02B6, r1 // uart_putchar(RuheStrom + 'A'); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ High-Mosfets auf Kurzschluss testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Strom = 0; 342: 10 92 7b 00 sts 0x007B, r1 346: 10 92 7a 00 sts 0x007A, r1 if(anz) while(1) RotBlink(anz); // bei Kurzschluss nicht starten */ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ LOW-Mosfets auf Schalten und Kurzschluss testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test 34a: 8c b1 in r24, 0x0c ; 12 34c: 80 32 cpi r24, 0x20 ; 32 34e: 31 f0 breq .+12 ; 0x35c 350: 38 ee ldi r19, 0xE8 ; 232 352: e3 2e mov r14, r19 354: 33 e0 ldi r19, 0x03 ; 3 356: f3 2e mov r15, r19 358: 82 e3 ldi r24, 0x32 ; 50 35a: 06 c0 rjmp .+12 ; 0x368 35c: 8f e5 ldi r24, 0x5F ; 95 35e: b4 d5 rcall .+2920 ; 0xec8 360: ee 24 eor r14, r14 362: ea 94 dec r14 364: fe 2c mov r15, r14 366: 88 e2 ldi r24, 0x28 ; 40 Strom = 0; 368: 10 92 7b 00 sts 0x007B, r1 36c: 10 92 7a 00 sts 0x007A, r1 370: 00 e0 ldi r16, 0x00 ; 0 372: 10 e0 ldi r17, 0x00 ; 0 FETS_OFF; Delay(5); HIGH_A_EIN; DelayM(1); FETS_OFF; if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;} 374: a8 2e mov r10, r24 376: bb 24 eor r11, r11 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test Strom = 0; for(i=0;i FETS_OFF; 380: 82 b3 in r24, 0x12 ; 18 382: 87 7c andi r24, 0xC7 ; 199 384: 82 bb out 0x12, r24 ; 18 386: 88 b3 in r24, 0x18 ; 24 388: 81 7f andi r24, 0xF1 ; 241 38a: 88 bb out 0x18, r24 ; 24 Delay(5); HIGH_A_EIN; 38c: c3 9a sbi 0x18, 3 ; 24 DelayM(1); 38e: 81 e0 ldi r24, 0x01 ; 1 390: 90 e0 ldi r25, 0x00 ; 0 392: 53 df rcall .-346 ; 0x23a FETS_OFF; 394: 82 b3 in r24, 0x12 ; 18 396: 87 7c andi r24, 0xC7 ; 199 398: 82 bb out 0x12, r24 ; 18 39a: 88 b3 in r24, 0x18 ; 24 39c: 81 7f andi r24, 0xF1 ; 241 39e: 88 bb out 0x18, r24 ; 24 if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;} 3a0: 80 91 b5 02 lds r24, 0x02B5 3a4: 90 91 b6 02 lds r25, 0x02B6 3a8: 8a 0d add r24, r10 3aa: 9b 1d adc r25, r11 3ac: 20 91 7a 00 lds r18, 0x007A 3b0: 30 91 7b 00 lds r19, 0x007B 3b4: 82 17 cp r24, r18 3b6: 93 07 cpc r25, r19 3b8: 38 f0 brcs .+14 ; 0x3c8 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ LOW-Mosfets auf Schalten und Kurzschluss testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(UDR == ' ') {t = 65535; grenze = 40; uart_putchar('_');} else t = 1000; // Ausführlicher Test Strom = 0; for(i=0;i 3c4: dd 24 eor r13, r13 3c6: 0a c0 rjmp .+20 ; 0x3dc FETS_OFF; Delay(5); HIGH_A_EIN; DelayM(1); FETS_OFF; if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;} 3c8: 84 e3 ldi r24, 0x34 ; 52 3ca: 7e d5 rcall .+2812 ; 0xec8 3cc: 82 b3 in r24, 0x12 ; 18 3ce: 87 7c andi r24, 0xC7 ; 199 3d0: 82 bb out 0x12, r24 ; 18 3d2: 88 b3 in r24, 0x18 ; 24 3d4: 81 7f andi r24, 0xF1 ; 241 3d6: 88 bb out 0x18, r24 ; 24 3d8: 24 e0 ldi r18, 0x04 ; 4 3da: d2 2e mov r13, r18 3dc: 80 e1 ldi r24, 0x10 ; 16 3de: 97 e2 ldi r25, 0x27 ; 39 3e0: 00 c0 rjmp .+0 ; 0x3e2 return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 3e2: 01 97 sbiw r24, 0x01 ; 1 3e4: 5f ef ldi r21, 0xFF ; 255 3e6: 8f 3f cpi r24, 0xFF ; 255 3e8: 95 07 cpc r25, r21 3ea: d9 f7 brne .-10 ; 0x3e2 if(Strom > grenze + RuheStrom) {anz = 4; uart_putchar('4'); FETS_OFF; break;} Delay(5); } Delay(10000); Strom = 0; 3ec: 10 92 7b 00 sts 0x007B, r1 3f0: 10 92 7a 00 sts 0x007A, r1 3f4: 00 e0 ldi r16, 0x00 ; 0 3f6: 10 e0 ldi r17, 0x00 ; 0 for(i=0;i FETS_OFF; 400: 82 b3 in r24, 0x12 ; 18 402: 87 7c andi r24, 0xC7 ; 199 404: 82 bb out 0x12, r24 ; 18 406: 88 b3 in r24, 0x18 ; 24 408: 81 7f andi r24, 0xF1 ; 241 40a: 88 bb out 0x18, r24 ; 24 Delay(5); HIGH_B_EIN; 40c: c2 9a sbi 0x18, 2 ; 24 DelayM(1); 40e: 81 e0 ldi r24, 0x01 ; 1 410: 90 e0 ldi r25, 0x00 ; 0 412: 13 df rcall .-474 ; 0x23a FETS_OFF; 414: 82 b3 in r24, 0x12 ; 18 416: 87 7c andi r24, 0xC7 ; 199 418: 82 bb out 0x12, r24 ; 18 41a: 88 b3 in r24, 0x18 ; 24 41c: 81 7f andi r24, 0xF1 ; 241 41e: 88 bb out 0x18, r24 ; 24 if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); FETS_OFF;break;} 420: 80 91 b5 02 lds r24, 0x02B5 424: 90 91 b6 02 lds r25, 0x02B6 428: 8a 0d add r24, r10 42a: 9b 1d adc r25, r11 42c: 20 91 7a 00 lds r18, 0x007A 430: 30 91 7b 00 lds r19, 0x007B 434: 82 17 cp r24, r18 436: 93 07 cpc r25, r19 438: 30 f0 brcs .+12 ; 0x446 Delay(5); } Delay(10000); Strom = 0; for(i=0;i 444: 0a c0 rjmp .+20 ; 0x45a FETS_OFF; Delay(5); HIGH_B_EIN; DelayM(1); FETS_OFF; if(Strom > grenze + RuheStrom) {anz = 5; uart_putchar('5'); FETS_OFF;break;} 446: 85 e3 ldi r24, 0x35 ; 53 448: 3f d5 rcall .+2686 ; 0xec8 44a: 82 b3 in r24, 0x12 ; 18 44c: 87 7c andi r24, 0xC7 ; 199 44e: 82 bb out 0x12, r24 ; 18 450: 88 b3 in r24, 0x18 ; 24 452: 81 7f andi r24, 0xF1 ; 241 454: 88 bb out 0x18, r24 ; 24 456: 95 e0 ldi r25, 0x05 ; 5 458: d9 2e mov r13, r25 Delay(5); } Strom = 0; 45a: 10 92 7b 00 sts 0x007B, r1 45e: 10 92 7a 00 sts 0x007A, r1 462: 80 e1 ldi r24, 0x10 ; 16 464: 97 e2 ldi r25, 0x27 ; 39 466: 00 c0 rjmp .+0 ; 0x468 <__stack+0x9> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 468: 01 97 sbiw r24, 0x01 ; 1 46a: 2f ef ldi r18, 0xFF ; 255 46c: 8f 3f cpi r24, 0xFF ; 255 46e: 92 07 cpc r25, r18 470: d9 f7 brne .-10 ; 0x468 <__stack+0x9> 472: 00 e0 ldi r16, 0x00 ; 0 474: 10 e0 ldi r17, 0x00 ; 0 Strom = 0; Delay(10000); for(i=0;i FETS_OFF; 47e: 82 b3 in r24, 0x12 ; 18 480: 87 7c andi r24, 0xC7 ; 199 482: 82 bb out 0x12, r24 ; 18 484: 88 b3 in r24, 0x18 ; 24 486: 81 7f andi r24, 0xF1 ; 241 488: 88 bb out 0x18, r24 ; 24 Delay(5); HIGH_C_EIN; 48a: c1 9a sbi 0x18, 1 ; 24 DelayM(1); 48c: 81 e0 ldi r24, 0x01 ; 1 48e: 90 e0 ldi r25, 0x00 ; 0 490: d4 de rcall .-600 ; 0x23a FETS_OFF; 492: 82 b3 in r24, 0x12 ; 18 494: 87 7c andi r24, 0xC7 ; 199 496: 82 bb out 0x12, r24 ; 18 498: 88 b3 in r24, 0x18 ; 24 49a: 81 7f andi r24, 0xF1 ; 241 49c: 88 bb out 0x18, r24 ; 24 if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); FETS_OFF; break;} 49e: 80 91 b5 02 lds r24, 0x02B5 4a2: 90 91 b6 02 lds r25, 0x02B6 4a6: 8a 0d add r24, r10 4a8: 9b 1d adc r25, r11 4aa: 20 91 7a 00 lds r18, 0x007A 4ae: 30 91 7b 00 lds r19, 0x007B 4b2: 82 17 cp r24, r18 4b4: 93 07 cpc r25, r19 4b6: 30 f0 brcs .+12 ; 0x4c4 <__stack+0x65> } Strom = 0; Delay(10000); for(i=0;i 4c2: 0b c0 rjmp .+22 ; 0x4da <__stack+0x7b> FETS_OFF; Delay(5); HIGH_C_EIN; DelayM(1); FETS_OFF; if(Strom > grenze + RuheStrom) {anz = 6; uart_putchar('6'); FETS_OFF; break;} 4c4: 86 e3 ldi r24, 0x36 ; 54 4c6: 00 d5 rcall .+2560 ; 0xec8 4c8: 82 b3 in r24, 0x12 ; 18 4ca: 87 7c andi r24, 0xC7 ; 199 4cc: 82 bb out 0x12, r24 ; 18 4ce: 88 b3 in r24, 0x18 ; 24 4d0: 81 7f andi r24, 0xF1 ; 241 4d2: 88 bb out 0x18, r24 ; 24 4d4: 86 e0 ldi r24, 0x06 ; 6 4d6: d8 2e mov r13, r24 4d8: 02 c0 rjmp .+4 ; 0x4de <__stack+0x7f> Delay(5); } if(anz) while(1) RotBlink(anz); // bei Kurzschluss nicht starten 4da: dd 20 and r13, r13 4dc: 19 f0 breq .+6 ; 0x4e4 <__stack+0x85> 4de: 8d 2d mov r24, r13 4e0: cd de rcall .-614 ; 0x27c 4e2: fd cf rjmp .-6 ; 0x4de <__stack+0x7f> //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ High-Mosfets auf Schalten testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ SENSE_A; 4e4: 80 91 8d 00 lds r24, 0x008D 4e8: 87 b9 out 0x07, r24 ; 7 FETS_OFF; 4ea: 82 b3 in r24, 0x12 ; 18 4ec: 87 7c andi r24, 0xC7 ; 199 4ee: 82 bb out 0x12, r24 ; 18 4f0: 88 b3 in r24, 0x18 ; 24 4f2: 81 7f andi r24, 0xF1 ; 241 4f4: 88 bb out 0x18, r24 ; 24 LOW_B_EIN; // Low B ein 4f6: 94 9a sbi 0x12, 4 ; 18 LOW_C_EIN; // Low C ein 4f8: 95 9a sbi 0x12, 5 ; 18 Strom = 0; 4fa: 10 92 7b 00 sts 0x007B, r1 4fe: 10 92 7a 00 sts 0x007A, r1 502: 00 e0 ldi r16, 0x00 ; 0 504: 10 e0 ldi r17, 0x00 ; 0 506: ff 24 eor r15, r15 #define SOUND2_A 330 #define SOUND3_A 360 for(i=0; i< (TONDAUER / SOUND2_A) ; i++) { HIGH_A_EIN; // Test A 508: c3 9a sbi 0x18, 3 ; 24 Delay(SOUND_E); if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;}; 50a: 80 e0 ldi r24, 0x00 ; 0 50c: e5 d6 rcall .+3530 ; 0x12d8 50e: c3 97 sbiw r24, 0x33 ; 51 510: 18 f0 brcs .+6 ; 0x518 <__stack+0xb9> 512: 41 e0 ldi r20, 0x01 ; 1 514: f4 2a or r15, r20 516: 02 c0 rjmp .+4 ; 0x51c <__stack+0xbd> 518: 5e ef ldi r21, 0xFE ; 254 51a: f5 22 and r15, r21 PORTB = 0; 51c: 18 ba out 0x18, r1 ; 24 51e: 8c e2 ldi r24, 0x2C ; 44 520: 91 e0 ldi r25, 0x01 ; 1 522: 00 c0 rjmp .+0 ; 0x524 <__stack+0xc5> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 524: 01 97 sbiw r24, 0x01 ; 1 526: 2f ef ldi r18, 0xFF ; 255 528: 8f 3f cpi r24, 0xFF ; 255 52a: 92 07 cpc r25, r18 52c: d9 f7 brne .-10 ; 0x524 <__stack+0xc5> #define SOUND_E 1 // 1 #define SOUND1_A 300 #define SOUND2_A 330 #define SOUND3_A 360 for(i=0; i< (TONDAUER / SOUND2_A) ; i++) 52e: 0f 5f subi r16, 0xFF ; 255 530: 1f 4f sbci r17, 0xFF ; 255 532: 09 37 cpi r16, 0x79 ; 121 534: 11 05 cpc r17, r1 536: 41 f7 brne .-48 ; 0x508 <__stack+0xa9> Delay(SOUND_E); if(MessAD(0) > 50) { MosfetOkay |= 0x01; } else { MosfetOkay &= ~0x01;}; PORTB = 0; Delay(SOUND1_A); } FETS_OFF; 538: 82 b3 in r24, 0x12 ; 18 53a: 87 7c andi r24, 0xC7 ; 199 53c: 82 bb out 0x12, r24 ; 18 53e: 88 b3 in r24, 0x18 ; 24 540: 81 7f andi r24, 0xF1 ; 241 542: 88 bb out 0x18, r24 ; 24 LOW_A_EIN; // Low A ein 544: 93 9a sbi 0x12, 3 ; 18 LOW_C_EIN; // Low C ein 546: 95 9a sbi 0x12, 5 ; 18 548: 00 e0 ldi r16, 0x00 ; 0 54a: 10 e0 ldi r17, 0x00 ; 0 for(i=0; i<(TONDAUER / SOUND1_A); i++) { HIGH_B_EIN; // Test B 54c: c2 9a sbi 0x18, 2 ; 24 Delay(SOUND_E); if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;}; 54e: 81 e0 ldi r24, 0x01 ; 1 550: c3 d6 rcall .+3462 ; 0x12d8 552: c3 97 sbiw r24, 0x33 ; 51 554: 18 f0 brcs .+6 ; 0x55c <__stack+0xfd> 556: 42 e0 ldi r20, 0x02 ; 2 558: f4 2a or r15, r20 55a: 02 c0 rjmp .+4 ; 0x560 <__stack+0x101> 55c: 5d ef ldi r21, 0xFD ; 253 55e: f5 22 and r15, r21 PORTB = 0; 560: 18 ba out 0x18, r1 ; 24 562: 8c e2 ldi r24, 0x2C ; 44 564: 91 e0 ldi r25, 0x01 ; 1 566: 00 c0 rjmp .+0 ; 0x568 <__stack+0x109> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 568: 01 97 sbiw r24, 0x01 ; 1 56a: 2f ef ldi r18, 0xFF ; 255 56c: 8f 3f cpi r24, 0xFF ; 255 56e: 92 07 cpc r25, r18 570: d9 f7 brne .-10 ; 0x568 <__stack+0x109> } FETS_OFF; LOW_A_EIN; // Low A ein LOW_C_EIN; // Low C ein for(i=0; i<(TONDAUER / SOUND1_A); i++) 572: 0f 5f subi r16, 0xFF ; 255 574: 1f 4f sbci r17, 0xFF ; 255 576: 05 38 cpi r16, 0x85 ; 133 578: 11 05 cpc r17, r1 57a: 41 f7 brne .-48 ; 0x54c <__stack+0xed> if(MessAD(1) > 50) { MosfetOkay |= 0x02; } else { MosfetOkay &= ~0x02;}; PORTB = 0; Delay(SOUND1_A); } FETS_OFF; 57c: 82 b3 in r24, 0x12 ; 18 57e: 87 7c andi r24, 0xC7 ; 199 580: 82 bb out 0x12, r24 ; 18 582: 88 b3 in r24, 0x18 ; 24 584: 81 7f andi r24, 0xF1 ; 241 586: 88 bb out 0x18, r24 ; 24 LOW_A_EIN; // Low A ein 588: 93 9a sbi 0x12, 3 ; 18 LOW_B_EIN; // Low B ein 58a: 94 9a sbi 0x12, 4 ; 18 58c: 00 e0 ldi r16, 0x00 ; 0 58e: 10 e0 ldi r17, 0x00 ; 0 for(i=0; i<(TONDAUER / SOUND3_A); i++) { HIGH_C_EIN; // Test C 590: c1 9a sbi 0x18, 1 ; 24 Delay(SOUND_E); if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;}; 592: 82 e0 ldi r24, 0x02 ; 2 594: a1 d6 rcall .+3394 ; 0x12d8 596: c3 97 sbiw r24, 0x33 ; 51 598: 18 f0 brcs .+6 ; 0x5a0 <__stack+0x141> 59a: 44 e0 ldi r20, 0x04 ; 4 59c: f4 2a or r15, r20 59e: 02 c0 rjmp .+4 ; 0x5a4 <__stack+0x145> 5a0: 5b ef ldi r21, 0xFB ; 251 5a2: f5 22 and r15, r21 PORTB = 0; 5a4: 18 ba out 0x18, r1 ; 24 5a6: 8a e4 ldi r24, 0x4A ; 74 5a8: 91 e0 ldi r25, 0x01 ; 1 5aa: 00 c0 rjmp .+0 ; 0x5ac <__stack+0x14d> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 5ac: 01 97 sbiw r24, 0x01 ; 1 5ae: 2f ef ldi r18, 0xFF ; 255 5b0: 8f 3f cpi r24, 0xFF ; 255 5b2: 92 07 cpc r25, r18 5b4: d9 f7 brne .-10 ; 0x5ac <__stack+0x14d> } FETS_OFF; LOW_A_EIN; // Low A ein LOW_B_EIN; // Low B ein for(i=0; i<(TONDAUER / SOUND3_A); i++) 5b6: 0f 5f subi r16, 0xFF ; 255 5b8: 1f 4f sbci r17, 0xFF ; 255 5ba: 0f 36 cpi r16, 0x6F ; 111 5bc: 11 05 cpc r17, r1 5be: 41 f7 brne .-48 ; 0x590 <__stack+0x131> Delay(SOUND_E); if(MessAD(2) > 50) { MosfetOkay |= 0x04; } else { MosfetOkay &= ~0x04;}; PORTB = 0; Delay(SOUND2_A); } FETS_OFF; 5c0: 82 b3 in r24, 0x12 ; 18 5c2: 87 7c andi r24, 0xC7 ; 199 5c4: 82 bb out 0x12, r24 ; 18 5c6: 88 b3 in r24, 0x18 ; 24 5c8: 81 7f andi r24, 0xF1 ; 241 5ca: 88 bb out 0x18, r24 ; 24 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ Low-Mosfets auf Schalten testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // SENSE_B; LOW_A_EIN; // Low A ein 5cc: 93 9a sbi 0x12, 3 ; 18 5ce: 00 e0 ldi r16, 0x00 ; 0 5d0: 10 e0 ldi r17, 0x00 ; 0 for(i=0; i< (TONDAUER / SOUND2_A) ; i++) { HIGH_B_EIN; // Test B 5d2: c2 9a sbi 0x18, 2 ; 24 Delay(SOUND_E); if(MessAD(0) > 128) { MosfetOkay &= ~0x08;} else { MosfetOkay |= 0x08;}; 5d4: 80 e0 ldi r24, 0x00 ; 0 5d6: 80 d6 rcall .+3328 ; 0x12d8 5d8: 81 38 cpi r24, 0x81 ; 129 5da: 91 05 cpc r25, r1 5dc: 18 f0 brcs .+6 ; 0x5e4 <__stack+0x185> 5de: 47 ef ldi r20, 0xF7 ; 247 5e0: f4 22 and r15, r20 5e2: 02 c0 rjmp .+4 ; 0x5e8 <__stack+0x189> 5e4: 58 e0 ldi r21, 0x08 ; 8 5e6: f5 2a or r15, r21 PORTB = 0; 5e8: 18 ba out 0x18, r1 ; 24 5ea: 8a e4 ldi r24, 0x4A ; 74 5ec: 91 e0 ldi r25, 0x01 ; 1 5ee: 00 c0 rjmp .+0 ; 0x5f0 <__stack+0x191> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 5f0: 01 97 sbiw r24, 0x01 ; 1 5f2: 2f ef ldi r18, 0xFF ; 255 5f4: 8f 3f cpi r24, 0xFF ; 255 5f6: 92 07 cpc r25, r18 5f8: d9 f7 brne .-10 ; 0x5f0 <__stack+0x191> //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+ Low-Mosfets auf Schalten testen //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // SENSE_B; LOW_A_EIN; // Low A ein for(i=0; i< (TONDAUER / SOUND2_A) ; i++) 5fa: 0f 5f subi r16, 0xFF ; 255 5fc: 1f 4f sbci r17, 0xFF ; 255 5fe: 09 37 cpi r16, 0x79 ; 121 600: 11 05 cpc r17, r1 602: 39 f7 brne .-50 ; 0x5d2 <__stack+0x173> PORTB = 0; Delay(SOUND2_A); } //++++++++++++++++++++++++++++++++++++ LOW_C_EIN; // Low C ein 604: 95 9a sbi 0x12, 5 ; 18 606: 00 e0 ldi r16, 0x00 ; 0 608: 10 e0 ldi r17, 0x00 ; 0 for(i=0; i<(TONDAUER / SOUND1_A); i++) { HIGH_B_EIN; // Test B 60a: c2 9a sbi 0x18, 2 ; 24 Delay(SOUND_E); if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;}; 60c: 82 e0 ldi r24, 0x02 ; 2 60e: 64 d6 rcall .+3272 ; 0x12d8 610: 81 38 cpi r24, 0x81 ; 129 612: 91 05 cpc r25, r1 614: 18 f0 brcs .+6 ; 0x61c <__stack+0x1bd> 616: 4f ed ldi r20, 0xDF ; 223 618: f4 22 and r15, r20 61a: 02 c0 rjmp .+4 ; 0x620 <__stack+0x1c1> 61c: 50 e2 ldi r21, 0x20 ; 32 61e: f5 2a or r15, r21 PORTB = 0; 620: 18 ba out 0x18, r1 ; 24 622: 88 e6 ldi r24, 0x68 ; 104 624: 91 e0 ldi r25, 0x01 ; 1 626: 00 c0 rjmp .+0 ; 0x628 <__stack+0x1c9> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 628: 01 97 sbiw r24, 0x01 ; 1 62a: 2f ef ldi r18, 0xFF ; 255 62c: 8f 3f cpi r24, 0xFF ; 255 62e: 92 07 cpc r25, r18 630: d9 f7 brne .-10 ; 0x628 <__stack+0x1c9> Delay(SOUND2_A); } //++++++++++++++++++++++++++++++++++++ LOW_C_EIN; // Low C ein for(i=0; i<(TONDAUER / SOUND1_A); i++) 632: 0f 5f subi r16, 0xFF ; 255 634: 1f 4f sbci r17, 0xFF ; 255 636: 05 38 cpi r16, 0x85 ; 133 638: 11 05 cpc r17, r1 63a: 39 f7 brne .-50 ; 0x60a <__stack+0x1ab> Delay(SOUND_E); if(MessAD(2) > 128) { MosfetOkay &= ~0x20;} else { MosfetOkay |= 0x20;}; PORTB = 0; Delay(SOUND3_A); } FETS_OFF; 63c: 82 b3 in r24, 0x12 ; 18 63e: 87 7c andi r24, 0xC7 ; 199 640: 82 bb out 0x12, r24 ; 18 642: 88 b3 in r24, 0x18 ; 24 644: 81 7f andi r24, 0xF1 ; 241 646: 88 bb out 0x18, r24 ; 24 //++++++++++++++++++++++++++++++++++++ FETS_OFF; 648: 82 b3 in r24, 0x12 ; 18 64a: 87 7c andi r24, 0xC7 ; 199 64c: 82 bb out 0x12, r24 ; 18 64e: 88 b3 in r24, 0x18 ; 24 650: 81 7f andi r24, 0xF1 ; 241 652: 88 bb out 0x18, r24 ; 24 LOW_B_EIN; // Low B ein 654: 94 9a sbi 0x12, 4 ; 18 656: 00 e0 ldi r16, 0x00 ; 0 658: 10 e0 ldi r17, 0x00 ; 0 for(i=0; i<(TONDAUER / SOUND3_A); i++) { HIGH_C_EIN; // Test C 65a: c1 9a sbi 0x18, 1 ; 24 Delay(SOUND_E); if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;}; 65c: 81 e0 ldi r24, 0x01 ; 1 65e: 3c d6 rcall .+3192 ; 0x12d8 660: 81 38 cpi r24, 0x81 ; 129 662: 91 05 cpc r25, r1 664: 18 f0 brcs .+6 ; 0x66c <__stack+0x20d> 666: 4f ee ldi r20, 0xEF ; 239 668: f4 22 and r15, r20 66a: 02 c0 rjmp .+4 ; 0x670 <__stack+0x211> 66c: 50 e1 ldi r21, 0x10 ; 16 66e: f5 2a or r15, r21 PORTB = 0; 670: 18 ba out 0x18, r1 ; 24 672: 88 e6 ldi r24, 0x68 ; 104 674: 91 e0 ldi r25, 0x01 ; 1 676: 00 c0 rjmp .+0 ; 0x678 <__stack+0x219> return(0); } unsigned char Delay(unsigned int timer) { while(timer--) 678: 01 97 sbiw r24, 0x01 ; 1 67a: 2f ef ldi r18, 0xFF ; 255 67c: 8f 3f cpi r24, 0xFF ; 255 67e: 92 07 cpc r25, r18 680: d9 f7 brne .-10 ; 0x678 <__stack+0x219> } FETS_OFF; //++++++++++++++++++++++++++++++++++++ FETS_OFF; LOW_B_EIN; // Low B ein for(i=0; i<(TONDAUER / SOUND3_A); i++) 682: 0f 5f subi r16, 0xFF ; 255 684: 1f 4f sbci r17, 0xFF ; 255 686: 0f 36 cpi r16, 0x6F ; 111 688: 11 05 cpc r17, r1 68a: 39 f7 brne .-50 ; 0x65a <__stack+0x1fb> Delay(SOUND_E); if(MessAD(1) > 128) { MosfetOkay &= ~0x10;} else { MosfetOkay |= 0x10;}; PORTB = 0; Delay(SOUND3_A); } FETS_OFF; 68c: 82 b3 in r24, 0x12 ; 18 68e: 87 7c andi r24, 0xC7 ; 199 690: 82 bb out 0x12, r24 ; 18 692: 88 b3 in r24, 0x18 ; 24 694: 81 7f andi r24, 0xF1 ; 241 696: 88 bb out 0x18, r24 ; 24 //++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ sei();//Globale Interrupts Einschalten 698: 78 94 sei Delay(SOUND_E); PORTB = 0; Delay(SOUND8_A); } */ Delay_ms(300 * (3-ADR_TAB[MotorAdresse])); 69a: 80 91 66 00 lds r24, 0x0066 69e: fe 01 movw r30, r28 6a0: e8 0f add r30, r24 6a2: f1 1d adc r31, r1 6a4: 21 81 ldd r18, Z+1 ; 0x01 6a6: 83 e0 ldi r24, 0x03 ; 3 6a8: 90 e0 ldi r25, 0x00 ; 0 6aa: 82 1b sub r24, r18 6ac: 91 09 sbc r25, r1 6ae: 2c e2 ldi r18, 0x2C ; 44 6b0: 31 e0 ldi r19, 0x01 ; 1 6b2: ac 01 movw r20, r24 6b4: 42 9f mul r20, r18 6b6: c0 01 movw r24, r0 6b8: 43 9f mul r20, r19 6ba: 90 0d add r25, r0 6bc: 52 9f mul r21, r18 6be: 90 0d add r25, r0 6c0: 11 24 eor r1, r1 6c2: b6 d5 rcall .+2924 ; 0x1230 if(!(MosfetOkay & 0x01)) { anz = 1; UDR='A'; } else 6c4: f0 fc sbrc r15, 0 6c6: 04 c0 rjmp .+8 ; 0x6d0 <__stack+0x271> 6c8: 81 e4 ldi r24, 0x41 ; 65 6ca: 8c b9 out 0x0c, r24 ; 12 6cc: 11 e0 ldi r17, 0x01 ; 1 6ce: 1d c0 rjmp .+58 ; 0x70a <__stack+0x2ab> if(!(MosfetOkay & 0x02)) { anz = 2; UDR='B'; } else 6d0: f1 fc sbrc r15, 1 6d2: 04 c0 rjmp .+8 ; 0x6dc <__stack+0x27d> 6d4: 82 e4 ldi r24, 0x42 ; 66 6d6: 8c b9 out 0x0c, r24 ; 12 6d8: 12 e0 ldi r17, 0x02 ; 2 6da: 17 c0 rjmp .+46 ; 0x70a <__stack+0x2ab> if(!(MosfetOkay & 0x04)) { anz = 3; UDR='C'; } else 6dc: f2 fc sbrc r15, 2 6de: 04 c0 rjmp .+8 ; 0x6e8 <__stack+0x289> 6e0: 83 e4 ldi r24, 0x43 ; 67 6e2: 8c b9 out 0x0c, r24 ; 12 6e4: 13 e0 ldi r17, 0x03 ; 3 6e6: 11 c0 rjmp .+34 ; 0x70a <__stack+0x2ab> if(!(MosfetOkay & 0x08)) { anz = 4; UDR='a'; } else 6e8: f3 fc sbrc r15, 3 6ea: 04 c0 rjmp .+8 ; 0x6f4 <__stack+0x295> 6ec: 81 e6 ldi r24, 0x61 ; 97 6ee: 8c b9 out 0x0c, r24 ; 12 6f0: 14 e0 ldi r17, 0x04 ; 4 6f2: 0b c0 rjmp .+22 ; 0x70a <__stack+0x2ab> if(!(MosfetOkay & 0x10)) { anz = 5; UDR='b'; } else 6f4: f4 fc sbrc r15, 4 6f6: 04 c0 rjmp .+8 ; 0x700 <__stack+0x2a1> 6f8: 82 e6 ldi r24, 0x62 ; 98 6fa: 8c b9 out 0x0c, r24 ; 12 6fc: 15 e0 ldi r17, 0x05 ; 5 6fe: 05 c0 rjmp .+10 ; 0x70a <__stack+0x2ab> if(!(MosfetOkay & 0x20)) { anz = 6; UDR='c'; } 700: f5 fc sbrc r15, 5 702: 06 c0 rjmp .+12 ; 0x710 <__stack+0x2b1> 704: 83 e6 ldi r24, 0x63 ; 99 706: 8c b9 out 0x0c, r24 ; 12 708: 16 e0 ldi r17, 0x06 ; 6 // if(anz) Delay_ms(1000); if(anz) while(1) RotBlink(anz); // bei Kurzschluss nicht starten 70a: 81 2f mov r24, r17 70c: b7 dd rcall .-1170 ; 0x27c 70e: fd cf rjmp .-6 ; 0x70a <__stack+0x2ab> RotBlink(anz); 710: 80 e0 ldi r24, 0x00 ; 0 712: b4 dd rcall .-1176 ; 0x27c uart_putchar('.'); 714: 8e e2 ldi r24, 0x2E ; 46 716: d8 d3 rcall .+1968 ; 0xec8 } 718: 27 96 adiw r28, 0x07 ; 7 71a: 0f b6 in r0, 0x3f ; 63 71c: f8 94 cli 71e: de bf out 0x3e, r29 ; 62 720: 0f be out 0x3f, r0 ; 63 722: cd bf out 0x3d, r28 ; 61 724: cf 91 pop r28 726: df 91 pop r29 728: 1f 91 pop r17 72a: 0f 91 pop r16 72c: ff 90 pop r15 72e: ef 90 pop r14 730: df 90 pop r13 732: bf 90 pop r11 734: af 90 pop r10 736: 08 95 ret 00000738 : //############################################################################ // char Anwerfen(unsigned char pwm) //############################################################################ { 738: 6f 92 push r6 73a: 7f 92 push r7 73c: 9f 92 push r9 73e: af 92 push r10 740: bf 92 push r11 742: cf 92 push r12 744: df 92 push r13 746: ef 92 push r14 748: ff 92 push r15 74a: 0f 93 push r16 74c: 1f 93 push r17 74e: cf 93 push r28 750: df 93 push r29 752: 98 2e mov r9, r24 unsigned long timer = 300,i; DISABLE_SENSE_INT; 754: 10 92 b1 00 sts 0x00B1, r1 758: 43 98 cbi 0x08, 3 ; 8 PWM = 5; 75a: 85 e0 ldi r24, 0x05 ; 5 75c: 90 e0 ldi r25, 0x00 ; 0 75e: 90 93 79 00 sts 0x0079, r25 762: 80 93 78 00 sts 0x0078, r24 SetPWM(); 766: 7b dc rcall .-1802 ; 0x5e Manuell(); 768: 0f d7 rcall .+3614 ; 0x1588 // Delay_ms(200); MinUpmPulse = SetDelay(300); 76a: 8c e2 ldi r24, 0x2C ; 44 76c: 91 e0 ldi r25, 0x01 ; 1 76e: 4c d5 rcall .+2712 ; 0x1208 770: 90 93 b4 02 sts 0x02B4, r25 774: 80 93 b3 02 sts 0x02B3, r24 778: 09 c0 rjmp .+18 ; 0x78c while(!CheckDelay(MinUpmPulse)) { FastADConvert(); 77a: c3 d5 rcall .+2950 ; 0x1302 if(Strom > 120) 77c: 80 91 7a 00 lds r24, 0x007A 780: 90 91 7b 00 lds r25, 0x007B 784: 89 37 cpi r24, 0x79 ; 121 786: 91 05 cpc r25, r1 788: 08 f0 brcs .+2 ; 0x78c 78a: 5c c0 rjmp .+184 ; 0x844 PWM = 5; SetPWM(); Manuell(); // Delay_ms(200); MinUpmPulse = SetDelay(300); while(!CheckDelay(MinUpmPulse)) 78c: 80 91 b3 02 lds r24, 0x02B3 790: 90 91 b4 02 lds r25, 0x02B4 794: 43 d5 rcall .+2694 ; 0x121c 796: 88 23 and r24, r24 798: 81 f3 breq .-32 ; 0x77a STEUER_OFF; // Abschalten wegen Kurzschluss RotBlink(10); return(0); } } PWM = pwm; 79a: 90 92 78 00 sts 0x0078, r9 79e: 10 92 79 00 sts 0x0079, r1 7a2: 5c e2 ldi r21, 0x2C ; 44 7a4: a5 2e mov r10, r21 7a6: 51 e0 ldi r21, 0x01 ; 1 7a8: b5 2e mov r11, r21 7aa: c1 2c mov r12, r1 7ac: d1 2c mov r13, r1 } void DebugAusgaben(void) { DebugOut.Analog[0] = Strom; DebugOut.Analog[1] = Mittelstrom; 7ae: c6 e8 ldi r28, 0x86 ; 134 7b0: d3 e0 ldi r29, 0x03 ; 3 DebugOut.Analog[2] = SIO_Drehzahl; DebugOut.Analog[3] = PPM_Signal; DebugOut.Analog[4] = OCR2; 7b2: 46 e0 ldi r20, 0x06 ; 6 7b4: 64 2e mov r6, r20 7b6: 71 2c mov r7, r1 7b8: 6c 0e add r6, r28 7ba: 7d 1e adc r7, r29 STEUER_OFF; // Abschalten wegen Kurzschluss RotBlink(10); return(0); } } PWM = pwm; 7bc: ee 24 eor r14, r14 7be: ff 24 eor r15, r15 7c0: 87 01 movw r16, r14 while(1) { for(i=0;i 7ca: 6c d2 rcall .+1240 ; 0xca4 7cc: 01 c0 rjmp .+2 ; 0x7d0 else DatenUebertragung(); 7ce: 6e d4 rcall .+2268 ; 0x10ac //############################################################################ // void Wait(unsigned char dauer) //############################################################################ { dauer = (unsigned char)TCNT0 + dauer; 7d0: 82 b7 in r24, 0x32 ; 50 7d2: 8c 59 subi r24, 0x9C ; 156 while((TCNT0 - dauer) & 0x80); 7d4: 98 2f mov r25, r24 7d6: 82 b7 in r24, 0x32 ; 50 7d8: 89 1b sub r24, r25 7da: 87 fd sbrc r24, 7 7dc: fc cf rjmp .-8 ; 0x7d6 } } PWM = pwm; while(1) { for(i=0;i } } void DebugAusgaben(void) { DebugOut.Analog[0] = Strom; 7f2: 80 91 7a 00 lds r24, 0x007A 7f6: 90 91 7b 00 lds r25, 0x007B 7fa: 90 93 85 03 sts 0x0385, r25 7fe: 80 93 84 03 sts 0x0384, r24 DebugOut.Analog[1] = Mittelstrom; 802: 80 91 7d 00 lds r24, 0x007D 806: 80 93 86 03 sts 0x0386, r24 80a: 19 82 std Y+1, r1 ; 0x01 DebugOut.Analog[2] = SIO_Drehzahl; 80c: 80 91 8b 00 lds r24, 0x008B 810: 90 91 8c 00 lds r25, 0x008C 814: 90 93 89 03 sts 0x0389, r25 818: 80 93 88 03 sts 0x0388, r24 DebugOut.Analog[3] = PPM_Signal; 81c: 80 91 a5 00 lds r24, 0x00A5 820: 90 91 a6 00 lds r25, 0x00A6 824: 90 93 8b 03 sts 0x038B, r25 828: 80 93 8a 03 sts 0x038A, r24 DebugOut.Analog[4] = OCR2; 82c: 83 b5 in r24, 0x23 ; 35 82e: 80 93 8c 03 sts 0x038C, r24 832: f3 01 movw r30, r6 834: 11 82 std Z+1, r1 ; 0x01 if(!UebertragungAbgeschlossen) SendUart(); else DatenUebertragung(); Wait(100); // warten } DebugAusgaben(); FastADConvert(); 836: 65 d5 rcall .+2762 ; 0x1302 if(Strom > 60) 838: 80 91 7a 00 lds r24, 0x007A 83c: 90 91 7b 00 lds r25, 0x007B 840: cd 97 sbiw r24, 0x3d ; 61 842: a8 f0 brcs .+42 ; 0x86e { STEUER_OFF; // Abschalten wegen Kurzschluss 844: 82 b3 in r24, 0x12 ; 18 846: 87 7c andi r24, 0xC7 ; 199 848: 82 bb out 0x12, r24 ; 18 84a: 1b bc out 0x2b, r1 ; 43 84c: 1a bc out 0x2a, r1 ; 42 84e: 19 bc out 0x29, r1 ; 41 850: 18 bc out 0x28, r1 ; 40 852: 13 bc out 0x23, r1 ; 35 854: 81 e0 ldi r24, 0x01 ; 1 856: 8f bd out 0x2f, r24 ; 47 858: 81 e4 ldi r24, 0x41 ; 65 85a: 85 bd out 0x25, r24 ; 37 85c: 8e e0 ldi r24, 0x0E ; 14 85e: 87 bb out 0x17, r24 ; 23 860: 88 b3 in r24, 0x18 ; 24 862: 81 7f andi r24, 0xF1 ; 241 864: 88 bb out 0x18, r24 ; 24 RotBlink(10); 866: 8a e0 ldi r24, 0x0A ; 10 868: 09 dd rcall .-1518 ; 0x27c 86a: 80 e0 ldi r24, 0x00 ; 0 86c: 2e c0 rjmp .+92 ; 0x8ca return(0); } timer-= timer/15+1; 86e: c6 01 movw r24, r12 870: b5 01 movw r22, r10 872: 2f e0 ldi r18, 0x0F ; 15 874: 30 e0 ldi r19, 0x00 ; 0 876: 40 e0 ldi r20, 0x00 ; 0 878: 50 e0 ldi r21, 0x00 ; 0 87a: 12 d8 rcall .-4060 ; 0xfffff8a0 <__eeprom_end+0xff7ef8a0> 87c: 20 95 com r18 87e: 30 95 com r19 880: 40 95 com r20 882: 50 95 com r21 884: a2 0e add r10, r18 886: b3 1e adc r11, r19 888: c4 1e adc r12, r20 88a: d5 1e adc r13, r21 if(timer < 25) { if(TEST_MANUELL) timer = 25; else return(1); } 88c: f9 e1 ldi r31, 0x19 ; 25 88e: af 16 cp r10, r31 890: b1 04 cpc r11, r1 892: c1 04 cpc r12, r1 894: d1 04 cpc r13, r1 896: c0 f0 brcs .+48 ; 0x8c8 Manuell(); 898: 77 d6 rcall .+3310 ; 0x1588 Phase++; 89a: 80 91 af 00 lds r24, 0x00AF 89e: 8f 5f subi r24, 0xFF ; 255 8a0: 80 93 af 00 sts 0x00AF, r24 Phase %= 6; 8a4: 80 91 af 00 lds r24, 0x00AF 8a8: 66 e0 ldi r22, 0x06 ; 6 8aa: da d7 rcall .+4020 ; 0x1860 <__udivmodqi4> 8ac: 90 93 af 00 sts 0x00AF, r25 AdConvert(); 8b0: dc d4 rcall .+2488 ; 0x126a PWM = pwm; 8b2: 90 92 78 00 sts 0x0078, r9 8b6: 10 92 79 00 sts 0x0079, r1 SetPWM(); 8ba: d1 db rcall .-2142 ; 0x5e if(SENSE) 8bc: 44 9b sbis 0x08, 4 ; 8 8be: 7e cf rjmp .-260 ; 0x7bc { PORTD ^= GRUEN; 8c0: 82 b3 in r24, 0x12 ; 18 8c2: 80 58 subi r24, 0x80 ; 128 8c4: 82 bb out 0x12, r24 ; 18 8c6: 7a cf rjmp .-268 ; 0x7bc 8c8: 81 e0 ldi r24, 0x01 ; 1 } } } 8ca: df 91 pop r29 8cc: cf 91 pop r28 8ce: 1f 91 pop r17 8d0: 0f 91 pop r16 8d2: ff 90 pop r15 8d4: ef 90 pop r14 8d6: df 90 pop r13 8d8: cf 90 pop r12 8da: bf 90 pop r11 8dc: af 90 pop r10 8de: 9f 90 pop r9 8e0: 7f 90 pop r7 8e2: 6f 90 pop r6 8e4: 08 95 ret 000008e6
: //############################################################################ //Hauptprogramm int main (void) //############################################################################ { 8e6: 5f 92 push r5 8e8: 6f 92 push r6 8ea: 7f 92 push r7 8ec: 8f 92 push r8 8ee: 9f 92 push r9 8f0: af 92 push r10 8f2: bf 92 push r11 8f4: cf 92 push r12 8f6: df 92 push r13 8f8: ef 92 push r14 8fa: ff 92 push r15 8fc: 0f 93 push r16 8fe: 1f 93 push r17 900: cf 93 push r28 902: df 93 push r29 char altPhase = 0; int test = 0; unsigned int Blink,TestschubTimer; unsigned int Blink2,MittelstromTimer,DrehzahlMessTimer,MotorGestopptTimer; DDRC = 0x08; 904: 88 e0 ldi r24, 0x08 ; 8 906: 84 bb out 0x14, r24 ; 20 PORTC = 0x08; 908: 85 bb out 0x15, r24 ; 21 DDRD = 0x3A; 90a: 8a e3 ldi r24, 0x3A ; 58 90c: 81 bb out 0x11, r24 ; 17 PORTD = 0x00; 90e: 12 ba out 0x12, r1 ; 18 DDRB = 0x0E; 910: 8e e0 ldi r24, 0x0E ; 14 912: 87 bb out 0x17, r24 ; 23 PORTB = 0x31; 914: 81 e3 ldi r24, 0x31 ; 49 916: 88 bb out 0x18, r24 ; 24 #if (MOTORADRESSE == 0) PORTB |= (ADR1 + ADR2); // Pullups für Adresswahl 918: 88 b3 in r24, 0x18 ; 24 91a: 80 6c ori r24, 0xC0 ; 192 91c: 88 bb out 0x18, r24 ; 24 for(test=0;test<500;test++); if(PINB & ADR1) 91e: b6 9b sbis 0x16, 6 ; 22 920: 06 c0 rjmp .+12 ; 0x92e { if (PINB & ADR2) MotorAdresse = 1; 922: b7 9b sbis 0x16, 7 ; 22 924: 02 c0 rjmp .+4 ; 0x92a 926: 81 e0 ldi r24, 0x01 ; 1 928: 07 c0 rjmp .+14 ; 0x938 else MotorAdresse = 2; 92a: 82 e0 ldi r24, 0x02 ; 2 92c: 05 c0 rjmp .+10 ; 0x938 } else { if (PINB & ADR2) MotorAdresse = 3; 92e: b7 9b sbis 0x16, 7 ; 22 930: 02 c0 rjmp .+4 ; 0x936 932: 83 e0 ldi r24, 0x03 ; 3 934: 01 c0 rjmp .+2 ; 0x938 else MotorAdresse = 4; 936: 84 e0 ldi r24, 0x04 ; 4 938: 80 93 66 00 sts 0x0066, r24 } HwVersion = 11; 93c: 8b e0 ldi r24, 0x0B ; 11 93e: 80 93 b2 00 sts 0x00B2, r24 #else MotorAdresse = MOTORADRESSE; HwVersion = 10; #endif if(PIND & 0x80) {HwVersion = 12; IntRef = 0xc0;} 942: 87 9b sbis 0x10, 7 ; 16 944: 06 c0 rjmp .+12 ; 0x952 946: 8c e0 ldi r24, 0x0C ; 12 948: 80 93 b2 00 sts 0x00B2, r24 94c: 80 ec ldi r24, 0xC0 ; 192 94e: 80 93 8d 00 sts 0x008D, r24 DDRD = 0xBA; 952: 8a eb ldi r24, 0xBA ; 186 954: 81 bb out 0x11, r24 ; 17 UART_Init(); 956: c4 d3 rcall .+1928 ; 0x10e0 Timer0_Init(); 958: 4e d4 rcall .+2204 ; 0x11f6 sei();//Globale Interrupts Einschalten 95a: 78 94 sei } Delay_ms(500); */ // UART_Init(); // war doppelt PWM_Init(); 95c: d4 db rcall .-2136 ; 0x106 InitIC2_Slave(0x50); 95e: 80 e5 ldi r24, 0x50 ; 80 960: b0 d5 rcall .+2912 ; 0x14c2 InitPPM(); 962: eb d4 rcall .+2518 ; 0x133a Blink = SetDelay(101); 964: 85 e6 ldi r24, 0x65 ; 101 966: 90 e0 ldi r25, 0x00 ; 0 968: 4f d4 rcall .+2206 ; 0x1208 Blink2 = SetDelay(102); 96a: 86 e6 ldi r24, 0x66 ; 102 96c: 90 e0 ldi r25, 0x00 ; 0 96e: 4c d4 rcall .+2200 ; 0x1208 MinUpmPulse = SetDelay(103); 970: 87 e6 ldi r24, 0x67 ; 103 972: 90 e0 ldi r25, 0x00 ; 0 974: 49 d4 rcall .+2194 ; 0x1208 976: 90 93 b4 02 sts 0x02B4, r25 97a: 80 93 b3 02 sts 0x02B3, r24 MittelstromTimer = SetDelay(254); 97e: 8e ef ldi r24, 0xFE ; 254 980: 90 e0 ldi r25, 0x00 ; 0 982: 42 d4 rcall .+2180 ; 0x1208 984: 6c 01 movw r12, r24 DrehzahlMessTimer = SetDelay(1005); 986: 8d ee ldi r24, 0xED ; 237 988: 93 e0 ldi r25, 0x03 ; 3 98a: 3e d4 rcall .+2172 ; 0x1208 98c: ec 01 movw r28, r24 TestschubTimer = SetDelay(1006); 98e: 8e ee ldi r24, 0xEE ; 238 990: 93 e0 ldi r25, 0x03 ; 3 992: 3a d4 rcall .+2164 ; 0x1208 994: 03 c0 rjmp .+6 ; 0x99c while(!CheckDelay(MinUpmPulse)) { if(SollwertErmittlung()) break; 996: d4 db rcall .-2136 ; 0x140 998: 88 23 and r24, r24 99a: 39 f4 brne .+14 ; 0x9aa Blink2 = SetDelay(102); MinUpmPulse = SetDelay(103); MittelstromTimer = SetDelay(254); DrehzahlMessTimer = SetDelay(1005); TestschubTimer = SetDelay(1006); while(!CheckDelay(MinUpmPulse)) 99c: 80 91 b3 02 lds r24, 0x02B3 9a0: 90 91 b4 02 lds r25, 0x02B4 9a4: 3b d4 rcall .+2166 ; 0x121c 9a6: 88 23 and r24, r24 9a8: b1 f3 breq .-20 ; 0x996 { if(SollwertErmittlung()) break; } GRN_ON; 9aa: 80 91 b2 00 lds r24, 0x00B2 9ae: 8c 30 cpi r24, 0x0C ; 12 9b0: 10 f4 brcc .+4 ; 0x9b6 9b2: 97 9a sbi 0x12, 7 ; 18 9b4: 01 c0 rjmp .+2 ; 0x9b8 9b6: 97 98 cbi 0x12, 7 ; 18 PWM = 0; 9b8: 10 92 79 00 sts 0x0079, r1 9bc: 10 92 78 00 sts 0x0078, r1 SetPWM(); 9c0: 4e db rcall .-2404 ; 0x5e SFIOR = 0x08; // Analog Comperator ein 9c2: 88 e0 ldi r24, 0x08 ; 8 9c4: 80 bf out 0x30, r24 ; 48 ADMUX = 1; 9c6: 81 e0 ldi r24, 0x01 ; 1 9c8: 87 b9 out 0x07, r24 ; 7 MinUpmPulse = SetDelay(10); 9ca: 8a e0 ldi r24, 0x0A ; 10 9cc: 90 e0 ldi r25, 0x00 ; 0 9ce: 1c d4 rcall .+2104 ; 0x1208 9d0: 90 93 b4 02 sts 0x02B4, r25 9d4: 80 93 b3 02 sts 0x02B3, r24 DebugOut.Analog[1] = 1; 9d8: 81 e0 ldi r24, 0x01 ; 1 9da: 90 e0 ldi r25, 0x00 ; 0 9dc: 90 93 87 03 sts 0x0387, r25 9e0: 80 93 86 03 sts 0x0386, r24 PPM_Signal = 0; 9e4: 10 92 a6 00 sts 0x00A6, r1 9e8: 10 92 a5 00 sts 0x00A5, r1 if(!SollwertErmittlung()) MotorTon(); 9ec: a9 db rcall .-2222 ; 0x140 9ee: 88 23 and r24, r24 9f0: 09 f4 brne .+2 ; 0x9f4 9f2: 58 dc rcall .-1872 ; 0x2a4 //MotorTon(); PORTB = 0x31; // Pullups wieder einschalten 9f4: 81 e3 ldi r24, 0x31 ; 49 9f6: 88 bb out 0x18, r24 ; 24 9f8: 10 e0 ldi r17, 0x00 ; 0 STEUER_OFF; } } else { if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch 9fa: ff 24 eor r15, r15 9fc: f3 94 inc r15 // nach 1,5 Sekunden den Motor als gestoppt betrachten if(CheckDelay(MotorGestopptTimer)) { DISABLE_SENSE_INT; MotorGestoppt = 1; STEUER_OFF; 9fe: f1 e4 ldi r31, 0x41 ; 65 a00: ef 2e mov r14, r31 a02: ee e0 ldi r30, 0x0E ; 14 a04: 5e 2e mov r5, r30 if(Anwerfen(10)) { GRN_ON; MotorGestoppt = 0; Phase--; PWM = 1; a06: 71 e0 ldi r23, 0x01 ; 1 a08: 67 2e mov r6, r23 a0a: 71 2c mov r7, r1 SetPWM(); SENSE_TOGGLE_INT; ENABLE_SENSE_INT; MinUpmPulse = SetDelay(20); while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren PWM = 15; a0c: 6f e0 ldi r22, 0x0F ; 15 a0e: 86 2e mov r8, r22 a10: 91 2c mov r9, r1 a12: 01 c0 rjmp .+2 ; 0xa16 DebugOut.Analog[1] = 1; PPM_Signal = 0; if(!SollwertErmittlung()) MotorTon(); //MotorTon(); PORTB = 0x31; // Pullups wieder einschalten a14: 10 2f mov r17, r16 while (1) { //ShowSense(); if(!TEST_SCHUB) PWM = SollwertErmittlung(); a16: 94 db rcall .-2264 ; 0x140 a18: 80 93 78 00 sts 0x0078, r24 a1c: 10 92 79 00 sts 0x0079, r1 //I2C_TXBuffer = PWM; // Antwort über I2C-Bus if(MANUELL_PWM) PWM = MANUELL_PWM; // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(Phase != altPhase) // es gab eine Kommutierung im Interrupt a20: 00 91 af 00 lds r16, 0x00AF a24: 01 17 cp r16, r17 a26: 69 f0 breq .+26 ; 0xa42 { MotorGestoppt = 0; a28: 10 92 63 00 sts 0x0063, r1 ZeitFuerBerechnungen = 0; // direkt nach einer Kommutierung ist Zeit a2c: 10 92 62 00 sts 0x0062, r1 MinUpmPulse = SetDelay(250); // Timeout, falls ein Motor stehen bleibt a30: 8a ef ldi r24, 0xFA ; 250 a32: 90 e0 ldi r25, 0x00 ; 0 a34: e9 d3 rcall .+2002 ; 0x1208 a36: 90 93 b4 02 sts 0x02B4, r25 a3a: 80 93 b3 02 sts 0x02B3, r24 altPhase = Phase; a3e: 00 91 af 00 lds r16, 0x00AF } // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(!PWM) // Sollwert == 0 a42: 80 91 78 00 lds r24, 0x0078 a46: 90 91 79 00 lds r25, 0x0079 a4a: 89 2b or r24, r25 a4c: e1 f4 brne .+56 ; 0xa86 { MotorAnwerfen = 0; // kein Startversuch a4e: 10 92 88 00 sts 0x0088, r1 ZeitFuerBerechnungen = 0; a52: 10 92 62 00 sts 0x0062, r1 // nach 1,5 Sekunden den Motor als gestoppt betrachten if(CheckDelay(MotorGestopptTimer)) a56: c5 01 movw r24, r10 a58: e1 d3 rcall .+1986 ; 0x121c a5a: 88 23 and r24, r24 a5c: f1 f0 breq .+60 ; 0xa9a { DISABLE_SENSE_INT; a5e: 10 92 b1 00 sts 0x00B1, r1 a62: 43 98 cbi 0x08, 3 ; 8 MotorGestoppt = 1; a64: f0 92 63 00 sts 0x0063, r15 STEUER_OFF; a68: 82 b3 in r24, 0x12 ; 18 a6a: 87 7c andi r24, 0xC7 ; 199 a6c: 82 bb out 0x12, r24 ; 18 a6e: 1b bc out 0x2b, r1 ; 43 a70: 1a bc out 0x2a, r1 ; 42 a72: 19 bc out 0x29, r1 ; 41 a74: 18 bc out 0x28, r1 ; 40 a76: 13 bc out 0x23, r1 ; 35 a78: ff bc out 0x2f, r15 ; 47 a7a: e5 bc out 0x25, r14 ; 37 a7c: 57 ba out 0x17, r5 ; 23 a7e: 88 b3 in r24, 0x18 ; 24 a80: 81 7f andi r24, 0xF1 ; 241 a82: 88 bb out 0x18, r24 ; 24 a84: 0a c0 rjmp .+20 ; 0xa9a } } else { if(MotorGestoppt) MotorAnwerfen = 1; // Startversuch a86: 80 91 63 00 lds r24, 0x0063 a8a: 88 23 and r24, r24 a8c: 11 f0 breq .+4 ; 0xa92 a8e: f0 92 88 00 sts 0x0088, r15 MotorGestopptTimer = SetDelay(1500); a92: 8c ed ldi r24, 0xDC ; 220 a94: 95 e0 ldi r25, 0x05 ; 5 a96: b8 d3 rcall .+1904 ; 0x1208 a98: 5c 01 movw r10, r24 } if(MotorGestoppt && !TEST_SCHUB) PWM = 0; a9a: 80 91 63 00 lds r24, 0x0063 a9e: 88 23 and r24, r24 aa0: 21 f0 breq .+8 ; 0xaaa aa2: 10 92 79 00 sts 0x0079, r1 aa6: 10 92 78 00 sts 0x0078, r1 SetPWM(); aaa: d9 da rcall .-2638 ; 0x5e // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(!ZeitFuerBerechnungen++) aac: 80 91 62 00 lds r24, 0x0062 ab0: 8f 5f subi r24, 0xFF ; 255 ab2: 80 93 62 00 sts 0x0062, r24 ab6: 81 50 subi r24, 0x01 ; 1 ab8: 09 f0 breq .+2 ; 0xabc aba: ac cf rjmp .-168 ; 0xa14 { if(MotorGestoppt) abc: 80 91 63 00 lds r24, 0x0063 ac0: 88 23 and r24, r24 ac2: 41 f0 breq .+16 ; 0xad4 { GRN_ON; ac4: 80 91 b2 00 lds r24, 0x00B2 ac8: 8c 30 cpi r24, 0x0C ; 12 aca: 10 f4 brcc .+4 ; 0xad0 acc: 97 9a sbi 0x12, 7 ; 18 ace: 01 c0 rjmp .+2 ; 0xad2 ad0: 97 98 cbi 0x12, 7 ; 18 FastADConvert(); ad2: 17 d4 rcall .+2094 ; 0x1302 DebugAusgaben(); // welche Werte sollen angezeigt werden? if(!UebertragungAbgeschlossen) SendUart(); else DatenUebertragung(); } // Berechnen des Mittleren Stroms zur (langsamen) Strombegrenzung if(CheckDelay(MittelstromTimer)) ad4: c6 01 movw r24, r12 ad6: a2 d3 rcall .+1860 ; 0x121c ad8: 88 23 and r24, r24 ada: a9 f1 breq .+106 ; 0xb46 { MittelstromTimer = SetDelay(50); // alle 50ms adc: 82 e3 ldi r24, 0x32 ; 50 ade: 90 e0 ldi r25, 0x00 ; 0 ae0: 93 d3 rcall .+1830 ; 0x1208 ae2: 6c 01 movw r12, r24 if(Mittelstrom < Strom) Mittelstrom++;// Mittelwert des Stroms bilden ae4: 80 91 7d 00 lds r24, 0x007D ae8: 48 2f mov r20, r24 aea: 50 e0 ldi r21, 0x00 ; 0 aec: 20 91 7a 00 lds r18, 0x007A af0: 30 91 7b 00 lds r19, 0x007B af4: 42 17 cp r20, r18 af6: 53 07 cpc r21, r19 af8: 10 f4 brcc .+4 ; 0xafe afa: 8f 5f subi r24, 0xFF ; 255 afc: 04 c0 rjmp .+8 ; 0xb06 else if(Mittelstrom > Strom) Mittelstrom--; afe: 24 17 cp r18, r20 b00: 35 07 cpc r19, r21 b02: 18 f4 brcc .+6 ; 0xb0a b04: 81 50 subi r24, 0x01 ; 1 b06: 80 93 7d 00 sts 0x007D, r24 if(Strom > MAX_STROM) MaxPWM -= MaxPWM / 32; b0a: 29 3c cpi r18, 0xC9 ; 201 b0c: 31 05 cpc r19, r1 b0e: 48 f0 brcs .+18 ; 0xb22 b10: 80 91 64 00 lds r24, 0x0064 b14: 98 2f mov r25, r24 b16: 92 95 swap r25 b18: 96 95 lsr r25 b1a: 97 70 andi r25, 0x07 ; 7 b1c: 89 1b sub r24, r25 b1e: 80 93 64 00 sts 0x0064, r24 if((Mittelstrom > LIMIT_STROM))// Strom am Limit? b22: 80 91 7d 00 lds r24, 0x007D b26: 90 91 64 00 lds r25, 0x0064 b2a: 89 37 cpi r24, 0x79 ; 121 b2c: 38 f0 brcs .+14 ; 0xb3c { if(MaxPWM) MaxPWM--;// dann die Maximale PWM herunterfahren b2e: 99 23 and r25, r25 b30: 19 f0 breq .+6 ; 0xb38 b32: 91 50 subi r25, 0x01 ; 1 b34: 90 93 64 00 sts 0x0064, r25 PORTC |= ROT; b38: ab 9a sbi 0x15, 3 ; 21 b3a: 05 c0 rjmp .+10 ; 0xb46 } else { if(MaxPWM < MAX_PWM) MaxPWM++; b3c: 9f 3f cpi r25, 0xFF ; 255 b3e: 19 f0 breq .+6 ; 0xb46 b40: 9f 5f subi r25, 0xFF ; 255 b42: 90 93 64 00 sts 0x0064, r25 } } if(CheckDelay(DrehzahlMessTimer)) // Ist-Drehzahl bestimmen b46: ce 01 movw r24, r28 b48: 69 d3 rcall .+1746 ; 0x121c b4a: 88 23 and r24, r24 b4c: 91 f0 breq .+36 ; 0xb72 { DrehzahlMessTimer = SetDelay(10); b4e: 8a e0 ldi r24, 0x0A ; 10 b50: 90 e0 ldi r25, 0x00 ; 0 b52: 5a d3 rcall .+1716 ; 0x1208 b54: ec 01 movw r28, r24 SIO_Drehzahl = CntKommutierungen;//(6 * CntKommutierungen) / (POLANZAHL / 2); b56: 80 91 89 00 lds r24, 0x0089 b5a: 90 91 8a 00 lds r25, 0x008A b5e: 90 93 8c 00 sts 0x008C, r25 b62: 80 93 8b 00 sts 0x008B, r24 CntKommutierungen = 0; b66: 10 92 8a 00 sts 0x008A, r1 b6a: 10 92 89 00 sts 0x0089, r1 // if(PPM_Timeout == 0) // keine PPM-Signale ZeitZumAdWandeln = 1; b6e: f0 92 65 00 sts 0x0065, r15 } } } #endif // Motor Stehen geblieben if((CheckDelay(MinUpmPulse) && SIO_Drehzahl == 0) || MotorAnwerfen) b72: 80 91 b3 02 lds r24, 0x02B3 b76: 90 91 b4 02 lds r25, 0x02B4 b7a: 50 d3 rcall .+1696 ; 0x121c b7c: 88 23 and r24, r24 b7e: 31 f0 breq .+12 ; 0xb8c b80: 80 91 8b 00 lds r24, 0x008B b84: 90 91 8c 00 lds r25, 0x008C b88: 89 2b or r24, r25 b8a: 29 f0 breq .+10 ; 0xb96 b8c: 80 91 88 00 lds r24, 0x0088 b90: 88 23 and r24, r24 b92: 09 f4 brne .+2 ; 0xb96 b94: 3f cf rjmp .-386 ; 0xa14 { MotorGestoppt = 1; b96: f0 92 63 00 sts 0x0063, r15 DISABLE_SENSE_INT; b9a: 10 92 b1 00 sts 0x00B1, r1 b9e: 43 98 cbi 0x08, 3 ; 8 MinUpmPulse = SetDelay(100); ba0: 84 e6 ldi r24, 0x64 ; 100 ba2: 90 e0 ldi r25, 0x00 ; 0 ba4: 31 d3 rcall .+1634 ; 0x1208 ba6: 90 93 b4 02 sts 0x02B4, r25 baa: 80 93 b3 02 sts 0x02B3, r24 if(MotorAnwerfen) bae: 80 91 88 00 lds r24, 0x0088 bb2: 88 23 and r24, r24 bb4: 09 f4 brne .+2 ; 0xbb8 bb6: 2e cf rjmp .-420 ; 0xa14 { PORTC &= ~ROT; bb8: ab 98 cbi 0x15, 3 ; 21 Strom_max = 0; bba: 10 92 7c 00 sts 0x007C, r1 MotorAnwerfen = 0; bbe: 10 92 88 00 sts 0x0088, r1 if(Anwerfen(10)) bc2: 8a e0 ldi r24, 0x0A ; 10 bc4: b9 dd rcall .-1166 ; 0x738 bc6: 88 23 and r24, r24 bc8: 09 f4 brne .+2 ; 0xbcc bca: 5b c0 rjmp .+182 ; 0xc82 { GRN_ON; bcc: 80 91 b2 00 lds r24, 0x00B2 bd0: 8c 30 cpi r24, 0x0C ; 12 bd2: 10 f4 brcc .+4 ; 0xbd8 bd4: 97 9a sbi 0x12, 7 ; 18 bd6: 01 c0 rjmp .+2 ; 0xbda bd8: 97 98 cbi 0x12, 7 ; 18 MotorGestoppt = 0; bda: 10 92 63 00 sts 0x0063, r1 Phase--; bde: 80 91 af 00 lds r24, 0x00AF be2: 81 50 subi r24, 0x01 ; 1 be4: 80 93 af 00 sts 0x00AF, r24 PWM = 1; be8: 70 92 79 00 sts 0x0079, r7 bec: 60 92 78 00 sts 0x0078, r6 SetPWM(); bf0: 36 da rcall .-2964 ; 0x5e SENSE_TOGGLE_INT; bf2: 88 b1 in r24, 0x08 ; 8 bf4: 8c 7f andi r24, 0xFC ; 252 bf6: 88 b9 out 0x08, r24 ; 8 ENABLE_SENSE_INT; bf8: f0 92 b1 00 sts 0x00B1, r15 bfc: 88 b1 in r24, 0x08 ; 8 bfe: 8a 60 ori r24, 0x0A ; 10 c00: 88 b9 out 0x08, r24 ; 8 MinUpmPulse = SetDelay(20); c02: 84 e1 ldi r24, 0x14 ; 20 c04: 90 e0 ldi r25, 0x00 ; 0 c06: 00 d3 rcall .+1536 ; 0x1208 c08: 90 93 b4 02 sts 0x02B4, r25 c0c: 80 93 b3 02 sts 0x02B3, r24 while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren c10: 80 91 b3 02 lds r24, 0x02B3 c14: 90 91 b4 02 lds r25, 0x02B4 c18: 01 d3 rcall .+1538 ; 0x121c c1a: 88 23 and r24, r24 c1c: c9 f3 breq .-14 ; 0xc10 PWM = 15; c1e: 90 92 79 00 sts 0x0079, r9 c22: 80 92 78 00 sts 0x0078, r8 SetPWM(); c26: 1b da rcall .-3018 ; 0x5e MinUpmPulse = SetDelay(300); c28: 8c e2 ldi r24, 0x2C ; 44 c2a: 91 e0 ldi r25, 0x01 ; 1 c2c: ed d2 rcall .+1498 ; 0x1208 c2e: 90 93 b4 02 sts 0x02B4, r25 c32: 80 93 b3 02 sts 0x02B3, r24 c36: 18 c0 rjmp .+48 ; 0xc68 while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten { if(Strom > LIMIT_STROM/2) c38: 80 91 7a 00 lds r24, 0x007A c3c: 90 91 7b 00 lds r25, 0x007B c40: cd 97 sbiw r24, 0x3d ; 61 c42: 90 f0 brcs .+36 ; 0xc68 { STEUER_OFF; // Abschalten wegen Kurzschluss c44: 82 b3 in r24, 0x12 ; 18 c46: 87 7c andi r24, 0xC7 ; 199 c48: 82 bb out 0x12, r24 ; 18 c4a: 1b bc out 0x2b, r1 ; 43 c4c: 1a bc out 0x2a, r1 ; 42 c4e: 19 bc out 0x29, r1 ; 41 c50: 18 bc out 0x28, r1 ; 40 c52: 13 bc out 0x23, r1 ; 35 c54: ff bc out 0x2f, r15 ; 47 c56: e5 bc out 0x25, r14 ; 37 c58: 57 ba out 0x17, r5 ; 23 c5a: 88 b3 in r24, 0x18 ; 24 c5c: 81 7f andi r24, 0xF1 ; 241 c5e: 88 bb out 0x18, r24 ; 24 RotBlink(10); c60: 8a e0 ldi r24, 0x0A ; 10 c62: 0c db rcall .-2536 ; 0x27c MotorAnwerfen = 1; c64: f0 92 88 00 sts 0x0088, r15 MinUpmPulse = SetDelay(20); while(!CheckDelay(MinUpmPulse)); // kurz Synchronisieren PWM = 15; SetPWM(); MinUpmPulse = SetDelay(300); while(!CheckDelay(MinUpmPulse)) // kurz Durchstarten c68: 80 91 b3 02 lds r24, 0x02B3 c6c: 90 91 b4 02 lds r25, 0x02B4 c70: d5 d2 rcall .+1450 ; 0x121c c72: 88 23 and r24, r24 c74: 09 f3 breq .-62 ; 0xc38 RotBlink(10); MotorAnwerfen = 1; } } // Drehzahlmessung wieder aufsetzen DrehzahlMessTimer = SetDelay(50); c76: 82 e3 ldi r24, 0x32 ; 50 c78: 90 e0 ldi r25, 0x00 ; 0 c7a: c6 d2 rcall .+1420 ; 0x1208 c7c: ec 01 movw r28, r24 c7e: 07 e0 ldi r16, 0x07 ; 7 c80: c9 ce rjmp .-622 ; 0xa14 altPhase = 7; } else if(SollwertErmittlung()) MotorAnwerfen = 1; c82: 5e da rcall .-2884 ; 0x140 c84: 88 23 and r24, r24 c86: 09 f4 brne .+2 ; 0xc8a c88: c5 ce rjmp .-630 ; 0xa14 c8a: f0 92 88 00 sts 0x0088, r15 c8e: c2 ce rjmp .-636 ; 0xa14 00000c90 <__vector_13>: int Debug_Timer; SIGNAL(INT_VEC_TX) { c90: 1f 92 push r1 c92: 0f 92 push r0 c94: 0f b6 in r0, 0x3f ; 63 c96: 0f 92 push r0 c98: 11 24 eor r1, r1 } c9a: 0f 90 pop r0 c9c: 0f be out 0x3f, r0 ; 63 c9e: 0f 90 pop r0 ca0: 1f 90 pop r1 ca2: 18 95 reti 00000ca4 : void SendUart(void) { static unsigned int ptr = 0; unsigned char tmp_tx; if(!(UCSRA & 0x40)) return; ca4: 5e 9b sbis 0x0b, 6 ; 11 ca6: 24 c0 rjmp .+72 ; 0xcf0 if(!UebertragungAbgeschlossen) ca8: 80 91 6f 00 lds r24, 0x006F cac: 88 23 and r24, r24 cae: e1 f4 brne .+56 ; 0xce8 { ptr++; // die [0] wurde schon gesendet cb0: 80 91 a0 00 lds r24, 0x00A0 cb4: 90 91 a1 00 lds r25, 0x00A1 cb8: 01 96 adiw r24, 0x01 ; 1 cba: 90 93 a1 00 sts 0x00A1, r25 cbe: 80 93 a0 00 sts 0x00A0, r24 tmp_tx = SendeBuffer[ptr]; cc2: fc 01 movw r30, r24 cc4: e8 54 subi r30, 0x48 ; 72 cc6: fd 4f sbci r31, 0xFD ; 253 cc8: e0 81 ld r30, Z if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF)) cca: ed 30 cpi r30, 0x0D ; 13 ccc: 19 f0 breq .+6 ; 0xcd4 cce: 84 36 cpi r24, 0x64 ; 100 cd0: 91 05 cpc r25, r1 cd2: 39 f4 brne .+14 ; 0xce2 { ptr = 0; cd4: 10 92 a1 00 sts 0x00A1, r1 cd8: 10 92 a0 00 sts 0x00A0, r1 UebertragungAbgeschlossen = 1; cdc: 81 e0 ldi r24, 0x01 ; 1 cde: 80 93 6f 00 sts 0x006F, r24 } USR |= (1: } // -------------------------------------------------------------------------- void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer { cf2: 1f 93 push r17 cf4: cf 93 push r28 cf6: df 93 push r29 cf8: ec 01 movw r28, r24 cfa: 70 e0 ldi r23, 0x00 ; 0 { a = RxdBuffer[ptrIn++] - '='; b = RxdBuffer[ptrIn++] - '='; c = RxdBuffer[ptrIn++] - '='; d = RxdBuffer[ptrIn++] - '='; if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden cfc: a2 2f mov r26, r18 cfe: b0 e0 ldi r27, 0x00 ; 0 d00: 11 97 sbiw r26, 0x01 ; 1 d02: 48 c0 rjmp .+144 ; 0xd94 unsigned char a,b,c,d; unsigned char ptr = 0; unsigned char x,y,z; while(len) { a = RxdBuffer[ptrIn++] - '='; d04: e4 2f mov r30, r20 d06: f0 e0 ldi r31, 0x00 ; 0 d08: e2 5e subi r30, 0xE2 ; 226 d0a: fc 4f sbci r31, 0xFC ; 252 d0c: 30 81 ld r19, Z b = RxdBuffer[ptrIn++] - '='; d0e: 4f 5f subi r20, 0xFF ; 255 d10: e4 2f mov r30, r20 d12: f0 e0 ldi r31, 0x00 ; 0 d14: e2 5e subi r30, 0xE2 ; 226 d16: fc 4f sbci r31, 0xFC ; 252 d18: 50 81 ld r21, Z c = RxdBuffer[ptrIn++] - '='; d1a: 4f 5f subi r20, 0xFF ; 255 d1c: e4 2f mov r30, r20 d1e: f0 e0 ldi r31, 0x00 ; 0 d20: e2 5e subi r30, 0xE2 ; 226 d22: fc 4f sbci r31, 0xFC ; 252 d24: 10 81 ld r17, Z d = RxdBuffer[ptrIn++] - '='; d26: 4f 5f subi r20, 0xFF ; 255 d28: e4 2f mov r30, r20 d2a: f0 e0 ldi r31, 0x00 ; 0 d2c: e2 5e subi r30, 0xE2 ; 226 d2e: fc 4f sbci r31, 0xFC ; 252 d30: 20 81 ld r18, Z d32: 4f 5f subi r20, 0xFF ; 255 if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden d34: 84 2f mov r24, r20 d36: 90 e0 ldi r25, 0x00 ; 0 d38: 8a 17 cp r24, r26 d3a: 9b 07 cpc r25, r27 d3c: 74 f5 brge .+92 ; 0xd9a unsigned char ptr = 0; unsigned char x,y,z; while(len) { a = RxdBuffer[ptrIn++] - '='; b = RxdBuffer[ptrIn++] - '='; d3e: 5d 53 subi r21, 0x3D ; 61 x = (a << 2) | (b >> 4); y = ((b & 0x0f) << 4) | (c >> 2); z = ((c & 0x03) << 6) | d; if(len--) ptrOut[ptr++] = x; else break; d40: fe 01 movw r30, r28 d42: e7 0f add r30, r23 d44: f1 1d adc r31, r1 d46: 85 2f mov r24, r21 d48: 82 95 swap r24 d4a: 8f 70 andi r24, 0x0F ; 15 d4c: 3d 53 subi r19, 0x3D ; 61 d4e: 33 0f add r19, r19 d50: 33 0f add r19, r19 d52: 38 2b or r19, r24 d54: 30 83 st Z, r19 if(len--) ptrOut[ptr++] = y; else break; d56: 61 30 cpi r22, 0x01 ; 1 d58: 01 f1 breq .+64 ; 0xd9a unsigned char x,y,z; while(len) { a = RxdBuffer[ptrIn++] - '='; b = RxdBuffer[ptrIn++] - '='; c = RxdBuffer[ptrIn++] - '='; d5a: 91 2f mov r25, r17 d5c: 9d 53 subi r25, 0x3D ; 61 x = (a << 2) | (b >> 4); y = ((b & 0x0f) << 4) | (c >> 2); z = ((c & 0x03) << 6) | d; if(len--) ptrOut[ptr++] = x; else break; if(len--) ptrOut[ptr++] = y; else break; d5e: 7f 5f subi r23, 0xFF ; 255 d60: fe 01 movw r30, r28 d62: e7 0f add r30, r23 d64: f1 1d adc r31, r1 d66: 71 50 subi r23, 0x01 ; 1 d68: 52 95 swap r21 d6a: 50 7f andi r21, 0xF0 ; 240 d6c: 89 2f mov r24, r25 d6e: 86 95 lsr r24 d70: 86 95 lsr r24 d72: 58 2b or r21, r24 d74: 50 83 st Z, r21 if(len--) ptrOut[ptr++] = z; else break; d76: 62 30 cpi r22, 0x02 ; 2 d78: 81 f0 breq .+32 ; 0xd9a d7a: 63 50 subi r22, 0x03 ; 3 d7c: 7e 5f subi r23, 0xFE ; 254 d7e: fe 01 movw r30, r28 d80: e7 0f add r30, r23 d82: f1 1d adc r31, r1 d84: 92 95 swap r25 d86: 99 0f add r25, r25 d88: 99 0f add r25, r25 d8a: 90 7c andi r25, 0xC0 ; 192 d8c: 2d 53 subi r18, 0x3D ; 61 d8e: 92 2b or r25, r18 d90: 90 83 st Z, r25 d92: 7f 5f subi r23, 0xFF ; 255 void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer { unsigned char a,b,c,d; unsigned char ptr = 0; unsigned char x,y,z; while(len) d94: 66 23 and r22, r22 d96: 09 f0 breq .+2 ; 0xd9a d98: b5 cf rjmp .-150 ; 0xd04 if(len--) ptrOut[ptr++] = x; else break; if(len--) ptrOut[ptr++] = y; else break; if(len--) ptrOut[ptr++] = z; else break; } } d9a: df 91 pop r29 d9c: cf 91 pop r28 d9e: 1f 91 pop r17 da0: 08 95 ret 00000da2 : }; // -------------------------------------------------------------------------- void AddCRC(unsigned int wieviele) { da2: dc 01 movw r26, r24 da4: 20 e0 ldi r18, 0x00 ; 0 da6: 30 e0 ldi r19, 0x00 ; 0 da8: 40 e0 ldi r20, 0x00 ; 0 daa: 50 e0 ldi r21, 0x00 ; 0 dac: 08 c0 rjmp .+16 ; 0xdbe unsigned int tmpCRC = 0,i; for(i = 0; i < wieviele;i++) { tmpCRC += SendeBuffer[i]; dae: fa 01 movw r30, r20 db0: e8 54 subi r30, 0x48 ; 72 db2: fd 4f sbci r31, 0xFD ; 253 db4: 80 81 ld r24, Z db6: 28 0f add r18, r24 db8: 31 1d adc r19, r1 // -------------------------------------------------------------------------- void AddCRC(unsigned int wieviele) { unsigned int tmpCRC = 0,i; for(i = 0; i < wieviele;i++) dba: 4f 5f subi r20, 0xFF ; 255 dbc: 5f 4f sbci r21, 0xFF ; 255 dbe: 4a 17 cp r20, r26 dc0: 5b 07 cpc r21, r27 dc2: a8 f3 brcs .-22 ; 0xdae { tmpCRC += SendeBuffer[i]; } tmpCRC %= 4096; dc4: 3f 70 andi r19, 0x0F ; 15 SendeBuffer[i++] = '=' + tmpCRC / 64; dc6: c9 01 movw r24, r18 dc8: 36 e0 ldi r19, 0x06 ; 6 dca: 96 95 lsr r25 dcc: 87 95 ror r24 dce: 3a 95 dec r19 dd0: e1 f7 brne .-8 ; 0xdca dd2: 83 5c subi r24, 0xC3 ; 195 dd4: fd 01 movw r30, r26 dd6: e8 54 subi r30, 0x48 ; 72 dd8: fd 4f sbci r31, 0xFD ; 253 dda: 80 83 st Z, r24 ddc: 11 96 adiw r26, 0x01 ; 1 SendeBuffer[i++] = '=' + tmpCRC % 64; dde: 2f 73 andi r18, 0x3F ; 63 de0: 23 5c subi r18, 0xC3 ; 195 de2: fd 01 movw r30, r26 de4: e8 54 subi r30, 0x48 ; 72 de6: fd 4f sbci r31, 0xFD ; 253 de8: 20 83 st Z, r18 SendeBuffer[i++] = '\r'; dea: a7 54 subi r26, 0x47 ; 71 dec: bd 4f sbci r27, 0xFD ; 253 dee: 8d e0 ldi r24, 0x0D ; 13 df0: 8c 93 st X, r24 UebertragungAbgeschlossen = 0; df2: 10 92 6f 00 sts 0x006F, r1 UDR = SendeBuffer[0]; df6: 80 91 b8 02 lds r24, 0x02B8 dfa: 8c b9 out 0x0c, r24 ; 12 } dfc: 08 95 ret 00000dfe : // -------------------------------------------------------------------------- void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len) { dfe: cf 93 push r28 e00: df 93 push r29 e02: ea 01 movw r28, r20 e04: b2 2f mov r27, r18 unsigned int pt = 0; unsigned char a,b,c; unsigned char ptr = 0; SendeBuffer[pt++] = '#'; // Startzeichen e06: 93 e2 ldi r25, 0x23 ; 35 e08: 90 93 b8 02 sts 0x02B8, r25 SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...) e0c: 60 93 b9 02 sts 0x02B9, r22 SendeBuffer[pt++] = cmd; // Commando e10: 80 93 ba 02 sts 0x02BA, r24 e14: 63 e0 ldi r22, 0x03 ; 3 e16: 70 e0 ldi r23, 0x00 ; 0 e18: a0 e0 ldi r26, 0x00 ; 0 e1a: 4e c0 rjmp .+156 ; 0xeb8 while(len) { if(len) { a = snd[ptr++]; len--;} else a = 0; e1c: fe 01 movw r30, r28 e1e: ea 0f add r30, r26 e20: f1 1d adc r31, r1 e22: 90 81 ld r25, Z e24: af 5f subi r26, 0xFF ; 255 e26: b1 50 subi r27, 0x01 ; 1 if(len) { b = snd[ptr++]; len--;} else b = 0; e28: 19 f4 brne .+6 ; 0xe30 e2a: 30 e0 ldi r19, 0x00 ; 0 e2c: 40 e0 ldi r20, 0x00 ; 0 e2e: 0f c0 rjmp .+30 ; 0xe4e e30: fe 01 movw r30, r28 e32: ea 0f add r30, r26 e34: f1 1d adc r31, r1 e36: 40 81 ld r20, Z e38: af 5f subi r26, 0xFF ; 255 e3a: b1 50 subi r27, 0x01 ; 1 if(len) { c = snd[ptr++]; len--;} else c = 0; e3c: 11 f4 brne .+4 ; 0xe42 e3e: 30 e0 ldi r19, 0x00 ; 0 e40: 06 c0 rjmp .+12 ; 0xe4e e42: fe 01 movw r30, r28 e44: ea 0f add r30, r26 e46: f1 1d adc r31, r1 e48: 30 81 ld r19, Z e4a: af 5f subi r26, 0xFF ; 255 e4c: b1 50 subi r27, 0x01 ; 1 SendeBuffer[pt++] = '=' + (a >> 2); e4e: 89 2f mov r24, r25 e50: 86 95 lsr r24 e52: 86 95 lsr r24 e54: 83 5c subi r24, 0xC3 ; 195 e56: fb 01 movw r30, r22 e58: e8 54 subi r30, 0x48 ; 72 e5a: fd 4f sbci r31, 0xFD ; 253 e5c: 80 83 st Z, r24 SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4)); e5e: 24 2f mov r18, r20 e60: 22 95 swap r18 e62: 2f 70 andi r18, 0x0F ; 15 e64: 89 2f mov r24, r25 e66: 90 e0 ldi r25, 0x00 ; 0 e68: 83 70 andi r24, 0x03 ; 3 e6a: 90 70 andi r25, 0x00 ; 0 e6c: 54 e0 ldi r21, 0x04 ; 4 e6e: 88 0f add r24, r24 e70: 99 1f adc r25, r25 e72: 5a 95 dec r21 e74: e1 f7 brne .-8 ; 0xe6e e76: 28 2b or r18, r24 e78: 23 5c subi r18, 0xC3 ; 195 e7a: fb 01 movw r30, r22 e7c: e7 54 subi r30, 0x47 ; 71 e7e: fd 4f sbci r31, 0xFD ; 253 e80: 20 83 st Z, r18 SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6)); e82: 84 2f mov r24, r20 e84: 90 e0 ldi r25, 0x00 ; 0 e86: 8f 70 andi r24, 0x0F ; 15 e88: 90 70 andi r25, 0x00 ; 0 e8a: 88 0f add r24, r24 e8c: 99 1f adc r25, r25 e8e: 88 0f add r24, r24 e90: 99 1f adc r25, r25 e92: 23 2f mov r18, r19 e94: 22 95 swap r18 e96: 26 95 lsr r18 e98: 26 95 lsr r18 e9a: 23 70 andi r18, 0x03 ; 3 e9c: 28 2b or r18, r24 e9e: 23 5c subi r18, 0xC3 ; 195 ea0: fb 01 movw r30, r22 ea2: e6 54 subi r30, 0x46 ; 70 ea4: fd 4f sbci r31, 0xFD ; 253 ea6: 20 83 st Z, r18 SendeBuffer[pt++] = '=' + ( c & 0x3f); ea8: 3f 73 andi r19, 0x3F ; 63 eaa: 33 5c subi r19, 0xC3 ; 195 eac: fb 01 movw r30, r22 eae: e5 54 subi r30, 0x45 ; 69 eb0: fd 4f sbci r31, 0xFD ; 253 eb2: 30 83 st Z, r19 eb4: 6c 5f subi r22, 0xFC ; 252 eb6: 7f 4f sbci r23, 0xFF ; 255 SendeBuffer[pt++] = '#'; // Startzeichen SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...) SendeBuffer[pt++] = cmd; // Commando while(len) eb8: bb 23 and r27, r27 eba: 09 f0 breq .+2 ; 0xebe ebc: af cf rjmp .-162 ; 0xe1c SendeBuffer[pt++] = '=' + (a >> 2); SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4)); SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6)); SendeBuffer[pt++] = '=' + ( c & 0x3f); } AddCRC(pt); ebe: cb 01 movw r24, r22 ec0: 70 df rcall .-288 ; 0xda2 } ec2: df 91 pop r29 ec4: cf 91 pop r28 ec6: 08 95 ret 00000ec8 : //############################################################################ //Routine für die Serielle Ausgabe int uart_putchar (char c) //############################################################################ { ec8: 1f 93 push r17 eca: 18 2f mov r17, r24 if (c == '\n') ecc: 8a 30 cpi r24, 0x0A ; 10 ece: 11 f4 brne .+4 ; 0xed4 uart_putchar('\r'); ed0: 8d e0 ldi r24, 0x0D ; 13 ed2: fa df rcall .-12 ; 0xec8 //Warten solange bis Zeichen gesendet wurde loop_until_bit_is_set(USR, UDRE); ed4: 5d 9b sbis 0x0b, 5 ; 11 ed6: fe cf rjmp .-4 ; 0xed4 //Ausgabe des Zeichens UDR = c; ed8: 1c b9 out 0x0c, r17 ; 12 return (0); } eda: 80 e0 ldi r24, 0x00 ; 0 edc: 90 e0 ldi r25, 0x00 ; 0 ede: 1f 91 pop r17 ee0: 08 95 ret 00000ee2 <__vector_11>: //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //++ Empfangs-Part der Datenübertragung //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ SIGNAL(INT_VEC_RX) { ee2: 1f 92 push r1 ee4: 0f 92 push r0 ee6: 0f b6 in r0, 0x3f ; 63 ee8: 0f 92 push r0 eea: 11 24 eor r1, r1 eec: 2f 93 push r18 eee: 3f 93 push r19 ef0: 4f 93 push r20 ef2: 5f 93 push r21 ef4: 6f 93 push r22 ef6: 7f 93 push r23 ef8: 8f 93 push r24 efa: 9f 93 push r25 efc: af 93 push r26 efe: bf 93 push r27 f00: cf 93 push r28 f02: df 93 push r29 f04: ef 93 push r30 f06: ff 93 push r31 static unsigned int crc; static unsigned char crc1,crc2,buf_ptr; static unsigned char UartState = 0; unsigned char CrcOkay = 0; SioTmp = UDR; f08: 8c b1 in r24, 0x0c ; 12 f0a: 80 93 91 00 sts 0x0091, r24 if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0; f0e: 40 91 9b 00 lds r20, 0x009B f12: 44 36 cpi r20, 0x64 ; 100 f14: 10 f0 brcs .+4 ; 0xf1a <__vector_11+0x38> f16: 10 92 9a 00 sts 0x009A, r1 if(SioTmp == '\r' && UartState == 2) f1a: 50 91 91 00 lds r21, 0x0091 f1e: 5d 30 cpi r21, 0x0D ; 13 f20: 09 f0 breq .+2 ; 0xf24 <__vector_11+0x42> f22: 64 c0 rjmp .+200 ; 0xfec <__vector_11+0x10a> f24: 80 91 9a 00 lds r24, 0x009A f28: 82 30 cpi r24, 0x02 ; 2 f2a: 09 f0 breq .+2 ; 0xf2e <__vector_11+0x4c> f2c: 5f c0 rjmp .+190 ; 0xfec <__vector_11+0x10a> { UartState = 0; f2e: 10 92 9a 00 sts 0x009A, r1 crc -= RxdBuffer[buf_ptr-2]; f32: a4 2f mov r26, r20 f34: b0 e0 ldi r27, 0x00 ; 0 f36: fd 01 movw r30, r26 f38: e4 5e subi r30, 0xE4 ; 228 f3a: fc 4f sbci r31, 0xFC ; 252 f3c: 30 81 ld r19, Z crc -= RxdBuffer[buf_ptr-1]; f3e: ed 01 movw r28, r26 f40: c3 5e subi r28, 0xE3 ; 227 f42: dc 4f sbci r29, 0xFC ; 252 f44: 28 81 ld r18, Y crc %= 4096; f46: 80 91 9e 00 lds r24, 0x009E f4a: 90 91 9f 00 lds r25, 0x009F f4e: 83 1b sub r24, r19 f50: 91 09 sbc r25, r1 f52: 82 1b sub r24, r18 f54: 91 09 sbc r25, r1 f56: 9f 70 andi r25, 0x0F ; 15 f58: 90 93 9f 00 sts 0x009F, r25 f5c: 80 93 9e 00 sts 0x009E, r24 crc1 = '=' + crc / 64; f60: 9c 01 movw r18, r24 f62: 66 e0 ldi r22, 0x06 ; 6 f64: 36 95 lsr r19 f66: 27 95 ror r18 f68: 6a 95 dec r22 f6a: e1 f7 brne .-8 ; 0xf64 <__vector_11+0x82> f6c: 23 5c subi r18, 0xC3 ; 195 f6e: 20 93 9d 00 sts 0x009D, r18 crc2 = '=' + crc % 64; f72: 98 2f mov r25, r24 f74: 9f 73 andi r25, 0x3F ; 63 f76: 93 5c subi r25, 0xC3 ; 195 f78: 90 93 9c 00 sts 0x009C, r25 CrcOkay = 0; if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; }; f7c: 80 81 ld r24, Z f7e: 28 17 cp r18, r24 f80: 09 f0 breq .+2 ; 0xf84 <__vector_11+0xa2> f82: 80 c0 rjmp .+256 ; 0x1084 <__vector_11+0x1a2> f84: 88 81 ld r24, Y f86: 98 17 cp r25, r24 f88: 09 f0 breq .+2 ; 0xf8c <__vector_11+0xaa> f8a: 7c c0 rjmp .+248 ; 0x1084 <__vector_11+0x1a2> if(CrcOkay) // Datensatz schon verarbeitet { //NeuerDatensatzEmpfangen = 1; AnzahlEmpfangsBytes = buf_ptr; f8c: 40 93 99 00 sts 0x0099, r20 RxdBuffer[buf_ptr] = '\r'; f90: a2 5e subi r26, 0xE2 ; 226 f92: bc 4f sbci r27, 0xFC ; 252 f94: 5c 93 st X, r21 if(/*(RxdBuffer[1] == MeineSlaveAdresse || (RxdBuffer[1] == 'a')) && */(RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando f96: 80 91 20 03 lds r24, 0x0320 f9a: 82 35 cpi r24, 0x52 ; 82 f9c: 49 f4 brne .+18 ; 0xfb0 <__vector_11+0xce> f9e: 2c e0 ldi r18, 0x0C ; 12 fa0: 88 e1 ldi r24, 0x18 ; 24 fa2: 90 e0 ldi r25, 0x00 ; 0 fa4: 0f b6 in r0, 0x3f ; 63 fa6: f8 94 cli fa8: a8 95 wdr faa: 81 bd out 0x21, r24 ; 33 fac: 0f be out 0x3f, r0 ; 63 fae: 21 bd out 0x21, r18 ; 33 uart_putchar(RxdBuffer[2]); fb0: 80 91 20 03 lds r24, 0x0320 fb4: 89 df rcall .-238 ; 0xec8 if (RxdBuffer[2] == 't') // Motortest fb6: 80 91 20 03 lds r24, 0x0320 fba: 84 37 cpi r24, 0x74 ; 116 fbc: 09 f0 breq .+2 ; 0xfc0 <__vector_11+0xde> fbe: 62 c0 rjmp .+196 ; 0x1084 <__vector_11+0x1a2> { Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes); fc0: 20 91 99 00 lds r18, 0x0099 fc4: 83 e9 ldi r24, 0x93 ; 147 fc6: 90 e0 ldi r25, 0x00 ; 0 fc8: 66 e0 ldi r22, 0x06 ; 6 fca: 43 e0 ldi r20, 0x03 ; 3 fcc: 92 de rcall .-732 ; 0xcf2 SIO_Sollwert = MotorTest[MotorAdresse - 1]; fce: e0 91 66 00 lds r30, 0x0066 fd2: f0 e0 ldi r31, 0x00 ; 0 fd4: ee 56 subi r30, 0x6E ; 110 fd6: ff 4f sbci r31, 0xFF ; 255 fd8: 80 81 ld r24, Z fda: 80 93 90 00 sts 0x0090, r24 SIO_Timeout = 500; // werte für 500ms gültig fde: 84 ef ldi r24, 0xF4 ; 244 fe0: 91 e0 ldi r25, 0x01 ; 1 fe2: 90 93 83 00 sts 0x0083, r25 fe6: 80 93 82 00 sts 0x0082, r24 fea: 4c c0 rjmp .+152 ; 0x1084 <__vector_11+0x1a2> } } } else switch(UartState) fec: 80 91 9a 00 lds r24, 0x009A ff0: 81 30 cpi r24, 0x01 ; 1 ff2: f9 f0 breq .+62 ; 0x1032 <__vector_11+0x150> ff4: 81 30 cpi r24, 0x01 ; 1 ff6: 20 f0 brcs .+8 ; 0x1000 <__vector_11+0x11e> ff8: 82 30 cpi r24, 0x02 ; 2 ffa: 09 f0 breq .+2 ; 0xffe <__vector_11+0x11c> ffc: 41 c0 rjmp .+130 ; 0x1080 <__vector_11+0x19e> ffe: 24 c0 rjmp .+72 ; 0x1048 <__vector_11+0x166> { case 0: if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet 1000: 80 91 91 00 lds r24, 0x0091 1004: 83 32 cpi r24, 0x23 ; 35 1006: 39 f4 brne .+14 ; 0x1016 <__vector_11+0x134> 1008: 80 91 92 00 lds r24, 0x0092 100c: 88 23 and r24, r24 100e: 19 f4 brne .+6 ; 0x1016 <__vector_11+0x134> 1010: 81 e0 ldi r24, 0x01 ; 1 1012: 80 93 9a 00 sts 0x009A, r24 buf_ptr = 0; RxdBuffer[buf_ptr++] = SioTmp; 1016: 80 91 91 00 lds r24, 0x0091 101a: 80 93 1e 03 sts 0x031E, r24 101e: 81 e0 ldi r24, 0x01 ; 1 1020: 80 93 9b 00 sts 0x009B, r24 crc = SioTmp; 1024: 80 91 91 00 lds r24, 0x0091 1028: 80 93 9e 00 sts 0x009E, r24 102c: 10 92 9f 00 sts 0x009F, r1 1030: 29 c0 rjmp .+82 ; 0x1084 <__vector_11+0x1a2> break; case 1: // Adresse auswerten UartState++; 1032: 82 e0 ldi r24, 0x02 ; 2 1034: 80 93 9a 00 sts 0x009A, r24 RxdBuffer[buf_ptr++] = SioTmp; 1038: e4 2f mov r30, r20 103a: f0 e0 ldi r31, 0x00 ; 0 103c: 80 91 91 00 lds r24, 0x0091 1040: e2 5e subi r30, 0xE2 ; 226 1042: fc 4f sbci r31, 0xFC ; 252 1044: 80 83 st Z, r24 1046: 09 c0 rjmp .+18 ; 0x105a <__vector_11+0x178> crc += SioTmp; break; case 2: // Eingangsdaten sammeln RxdBuffer[buf_ptr] = SioTmp; 1048: e4 2f mov r30, r20 104a: f0 e0 ldi r31, 0x00 ; 0 104c: 80 91 91 00 lds r24, 0x0091 1050: e2 5e subi r30, 0xE2 ; 226 1052: fc 4f sbci r31, 0xFC ; 252 1054: 80 83 st Z, r24 if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++; 1056: 44 36 cpi r20, 0x64 ; 100 1058: 20 f4 brcc .+8 ; 0x1062 <__vector_11+0x180> 105a: 4f 5f subi r20, 0xFF ; 255 105c: 40 93 9b 00 sts 0x009B, r20 1060: 02 c0 rjmp .+4 ; 0x1066 <__vector_11+0x184> else UartState = 0; 1062: 10 92 9a 00 sts 0x009A, r1 crc += SioTmp; 1066: 20 91 91 00 lds r18, 0x0091 106a: 80 91 9e 00 lds r24, 0x009E 106e: 90 91 9f 00 lds r25, 0x009F 1072: 82 0f add r24, r18 1074: 91 1d adc r25, r1 1076: 90 93 9f 00 sts 0x009F, r25 107a: 80 93 9e 00 sts 0x009E, r24 107e: 02 c0 rjmp .+4 ; 0x1084 <__vector_11+0x1a2> break; default: UartState = 0; 1080: 10 92 9a 00 sts 0x009A, r1 break; } #endif }; 1084: ff 91 pop r31 1086: ef 91 pop r30 1088: df 91 pop r29 108a: cf 91 pop r28 108c: bf 91 pop r27 108e: af 91 pop r26 1090: 9f 91 pop r25 1092: 8f 91 pop r24 1094: 7f 91 pop r23 1096: 6f 91 pop r22 1098: 5f 91 pop r21 109a: 4f 91 pop r20 109c: 3f 91 pop r19 109e: 2f 91 pop r18 10a0: 0f 90 pop r0 10a2: 0f be out 0x3f, r0 ; 63 10a4: 0f 90 pop r0 10a6: 1f 90 pop r1 10a8: 18 95 reti 000010aa : } // -------------------------------------------------------------------------- void WriteProgramData(unsigned int pos, unsigned char wert) { } 10aa: 08 95 ret 000010ac : //--------------------------------------------------------------------------------------------- void DatenUebertragung(void) { if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen)) // im Singlestep-Betrieb in jedem Schtitt senden 10ac: 80 91 1c 03 lds r24, 0x031C 10b0: 90 91 1d 03 lds r25, 0x031D 10b4: b3 d0 rcall .+358 ; 0x121c 10b6: 88 23 and r24, r24 10b8: 91 f0 breq .+36 ; 0x10de 10ba: 80 91 6f 00 lds r24, 0x006F 10be: 88 23 and r24, r24 10c0: 71 f0 breq .+28 ; 0x10de { SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut)); 10c2: 84 e4 ldi r24, 0x44 ; 68 10c4: 60 91 b7 02 lds r22, 0x02B7 10c8: 42 e8 ldi r20, 0x82 ; 130 10ca: 53 e0 ldi r21, 0x03 ; 3 10cc: 22 e1 ldi r18, 0x12 ; 18 10ce: 97 de rcall .-722 ; 0xdfe Debug_Timer = SetDelay(50); // Sendeintervall 10d0: 82 e3 ldi r24, 0x32 ; 50 10d2: 90 e0 ldi r25, 0x00 ; 0 10d4: 99 d0 rcall .+306 ; 0x1208 10d6: 90 93 1d 03 sts 0x031D, r25 10da: 80 93 1c 03 sts 0x031C, r24 10de: 08 95 ret 000010e0 : void UART_Init (void) //############################################################################ { //Enable TXEN im Register UCR TX-Data Enable & RX Enable UCR=(1 << TXEN) | (1 << RXEN); 10e0: 88 e1 ldi r24, 0x18 ; 24 10e2: 8a b9 out 0x0a, r24 ; 10 // UART Double Speed (U2X) USR |= (1< Debug_Timer = SetDelay(200); 10f6: 88 ec ldi r24, 0xC8 ; 200 10f8: 90 e0 ldi r25, 0x00 ; 0 10fa: 86 d0 rcall .+268 ; 0x1208 10fc: 90 93 1d 03 sts 0x031D, r25 1100: 80 93 1c 03 sts 0x031C, r24 // Version beim Start ausgeben (nicht schön, aber geht... ) uart_putchar ('\n');uart_putchar ('B');uart_putchar ('L');uart_putchar (':'); 1104: 8a e0 ldi r24, 0x0A ; 10 1106: e0 de rcall .-576 ; 0xec8 1108: 82 e4 ldi r24, 0x42 ; 66 110a: de de rcall .-580 ; 0xec8 110c: 8c e4 ldi r24, 0x4C ; 76 110e: dc de rcall .-584 ; 0xec8 1110: 8a e3 ldi r24, 0x3A ; 58 1112: da de rcall .-588 ; 0xec8 uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10); 1114: 86 e5 ldi r24, 0x56 ; 86 1116: d8 de rcall .-592 ; 0xec8 1118: 80 e3 ldi r24, 0x30 ; 48 111a: d6 de rcall .-596 ; 0xec8 111c: 8e e2 ldi r24, 0x2E ; 46 111e: d4 de rcall .-600 ; 0xec8 1120: 84 e3 ldi r24, 0x34 ; 52 1122: d2 de rcall .-604 ; 0xec8 1124: 81 e3 ldi r24, 0x31 ; 49 1126: d0 de rcall .-608 ; 0xec8 uart_putchar ('\n');uart_putchar('H');uart_putchar('W');uart_putchar (':');uart_putchar('1');uart_putchar('.');uart_putchar ((0x30-10) + HwVersion); 1128: 8a e0 ldi r24, 0x0A ; 10 112a: ce de rcall .-612 ; 0xec8 112c: 88 e4 ldi r24, 0x48 ; 72 112e: cc de rcall .-616 ; 0xec8 1130: 87 e5 ldi r24, 0x57 ; 87 1132: ca de rcall .-620 ; 0xec8 1134: 8a e3 ldi r24, 0x3A ; 58 1136: c8 de rcall .-624 ; 0xec8 1138: 81 e3 ldi r24, 0x31 ; 49 113a: c6 de rcall .-628 ; 0xec8 113c: 8e e2 ldi r24, 0x2E ; 46 113e: c4 de rcall .-632 ; 0xec8 1140: 80 91 b2 00 lds r24, 0x00B2 1144: 8a 5d subi r24, 0xDA ; 218 1146: c0 de rcall .-640 ; 0xec8 uart_putchar ('\n');uart_putchar ('A');uart_putchar ('D');uart_putchar ('R'); uart_putchar (':'); uart_putchar (0x30 + MotorAdresse); 1148: 8a e0 ldi r24, 0x0A ; 10 114a: be de rcall .-644 ; 0xec8 114c: 81 e4 ldi r24, 0x41 ; 65 114e: bc de rcall .-648 ; 0xec8 1150: 84 e4 ldi r24, 0x44 ; 68 1152: ba de rcall .-652 ; 0xec8 1154: 82 e5 ldi r24, 0x52 ; 82 1156: b8 de rcall .-656 ; 0xec8 1158: 8a e3 ldi r24, 0x3A ; 58 115a: b6 de rcall .-660 ; 0xec8 115c: 80 91 66 00 lds r24, 0x0066 1160: 80 5d subi r24, 0xD0 ; 208 1162: b2 de rcall .-668 ; 0xec8 } 1164: 08 95 ret 00001166 <__vector_9>: T0_RISING_EDGE = 7 }; SIGNAL(SIG_OVERFLOW0) { 1166: 1f 92 push r1 1168: 0f 92 push r0 116a: 0f b6 in r0, 0x3f ; 63 116c: 0f 92 push r0 116e: 11 24 eor r1, r1 1170: 8f 93 push r24 1172: 9f 93 push r25 static unsigned char cnt; Timer0Overflow++; 1174: 80 91 94 03 lds r24, 0x0394 1178: 8f 5f subi r24, 0xFF ; 255 117a: 80 93 94 03 sts 0x0394, r24 if(!cnt--) 117e: 80 91 a4 00 lds r24, 0x00A4 1182: 81 50 subi r24, 0x01 ; 1 1184: 80 93 a4 00 sts 0x00A4, r24 1188: 8f 5f subi r24, 0xFF ; 255 118a: 71 f5 brne .+92 ; 0x11e8 <__vector_9+0x82> { cnt = 3; 118c: 83 e0 ldi r24, 0x03 ; 3 118e: 80 93 a4 00 sts 0x00A4, r24 CountMilliseconds += 1; 1192: 80 91 a2 00 lds r24, 0x00A2 1196: 90 91 a3 00 lds r25, 0x00A3 119a: 01 96 adiw r24, 0x01 ; 1 119c: 90 93 a3 00 sts 0x00A3, r25 11a0: 80 93 a2 00 sts 0x00A2, r24 if(I2C_Timeout) I2C_Timeout--; 11a4: 80 91 80 00 lds r24, 0x0080 11a8: 90 91 81 00 lds r25, 0x0081 11ac: 00 97 sbiw r24, 0x00 ; 0 11ae: 29 f0 breq .+10 ; 0x11ba <__vector_9+0x54> 11b0: 01 97 sbiw r24, 0x01 ; 1 11b2: 90 93 81 00 sts 0x0081, r25 11b6: 80 93 80 00 sts 0x0080, r24 if(PPM_Timeout) PPM_Timeout--; else anz_ppm_werte = 0; 11ba: 80 91 a8 00 lds r24, 0x00A8 11be: 88 23 and r24, r24 11c0: 31 f0 breq .+12 ; 0x11ce <__vector_9+0x68> 11c2: 80 91 a8 00 lds r24, 0x00A8 11c6: 81 50 subi r24, 0x01 ; 1 11c8: 80 93 a8 00 sts 0x00A8, r24 11cc: 02 c0 rjmp .+4 ; 0x11d2 <__vector_9+0x6c> 11ce: 10 92 a9 00 sts 0x00A9, r1 if(SIO_Timeout) SIO_Timeout--; 11d2: 80 91 82 00 lds r24, 0x0082 11d6: 90 91 83 00 lds r25, 0x0083 11da: 00 97 sbiw r24, 0x00 ; 0 11dc: 29 f0 breq .+10 ; 0x11e8 <__vector_9+0x82> 11de: 01 97 sbiw r24, 0x01 ; 1 11e0: 90 93 83 00 sts 0x0083, r25 11e4: 80 93 82 00 sts 0x0082, r24 } } 11e8: 9f 91 pop r25 11ea: 8f 91 pop r24 11ec: 0f 90 pop r0 11ee: 0f be out 0x3f, r0 ; 63 11f0: 0f 90 pop r0 11f2: 1f 90 pop r1 11f4: 18 95 reti 000011f6 : void Timer0_Init(void) { TCCR0 = TIMER_TEILER; 11f6: 82 e0 ldi r24, 0x02 ; 2 11f8: 83 bf out 0x33, r24 ; 51 // TCNT0 = -TIMER_RELOAD_VALUE; // reload TIM0_START; 11fa: 89 b7 in r24, 0x39 ; 57 11fc: 81 60 ori r24, 0x01 ; 1 11fe: 89 bf out 0x39, r24 ; 57 TIMER2_INT_ENABLE; 1200: 89 b7 in r24, 0x39 ; 57 1202: 80 64 ori r24, 0x40 ; 64 1204: 89 bf out 0x39, r24 ; 57 } 1206: 08 95 ret 00001208 : unsigned int SetDelay(unsigned int t) { return(CountMilliseconds + t - 1); 1208: 20 91 a2 00 lds r18, 0x00A2 120c: 30 91 a3 00 lds r19, 0x00A3 1210: 21 50 subi r18, 0x01 ; 1 1212: 30 40 sbci r19, 0x00 ; 0 1214: 28 0f add r18, r24 1216: 39 1f adc r19, r25 } 1218: c9 01 movw r24, r18 121a: 08 95 ret 0000121c : char CheckDelay (unsigned int t) { return(((t - CountMilliseconds) & 0x8000) >> 8); 121c: 20 91 a2 00 lds r18, 0x00A2 1220: 30 91 a3 00 lds r19, 0x00A3 1224: 82 1b sub r24, r18 1226: 93 0b sbc r25, r19 1228: 80 70 andi r24, 0x00 ; 0 122a: 90 78 andi r25, 0x80 ; 128 } 122c: 89 2f mov r24, r25 122e: 08 95 ret 00001230 : } unsigned int SetDelay(unsigned int t) { return(CountMilliseconds + t - 1); 1230: 20 91 a2 00 lds r18, 0x00A2 1234: 30 91 a3 00 lds r19, 0x00A3 1238: 21 50 subi r18, 0x01 ; 1 123a: 30 40 sbci r19, 0x00 ; 0 123c: 28 0f add r18, r24 123e: 39 1f adc r19, r25 } char CheckDelay (unsigned int t) { return(((t - CountMilliseconds) & 0x8000) >> 8); 1240: 80 91 a2 00 lds r24, 0x00A2 1244: 90 91 a3 00 lds r25, 0x00A3 void Delay_ms(unsigned int w) { unsigned int akt; akt = SetDelay(w); while (!CheckDelay(akt)); 1248: a9 01 movw r20, r18 124a: 48 1b sub r20, r24 124c: 59 0b sbc r21, r25 124e: ca 01 movw r24, r20 1250: 80 70 andi r24, 0x00 ; 0 1252: 90 78 andi r25, 0x80 ; 128 1254: 99 23 and r25, r25 1256: a1 f3 breq .-24 ; 0x1240 } 1258: 08 95 ret 0000125a : //############################################################################ //Init ADC void ADC_Init(void) //############################################################################ { ADCSRA = 0xA6; // Free Run & 1MHZ 125a: 86 ea ldi r24, 0xA6 ; 166 125c: 86 b9 out 0x06, r24 ; 6 ADMUX = 7 | IntRef; // Kanal 7 125e: 80 91 8d 00 lds r24, 0x008D 1262: 87 60 ori r24, 0x07 ; 7 1264: 87 b9 out 0x07, r24 ; 7 ADCSRA |= 0x40; // Start 1266: 36 9a sbi 0x06, 6 ; 6 } 1268: 08 95 ret 0000126a : void AdConvert(void) //############################################################################ { unsigned int i=0; unsigned char sense; sense = ADMUX; // Sense-Kanal merken 126a: 27 b1 in r18, 0x07 ; 7 ADMUX = 0x06 | IntRef; // Kanal 6 126c: 90 91 8d 00 lds r25, 0x008D 1270: 96 60 ori r25, 0x06 ; 6 1272: 97 b9 out 0x07, r25 ; 7 SFIOR = 0x00; // Analog Comperator aus 1274: 10 be out 0x30, r1 ; 48 ADCSRA = 0xD3; // Converter ein, single 1276: 83 ed ldi r24, 0xD3 ; 211 1278: 86 b9 out 0x06, r24 ; 6 ADCSRA |= 0x10; // Ready löschen 127a: 34 9a sbi 0x06, 4 ; 6 ADMUX = 0x06 | IntRef; // Kanal 6 127c: 97 b9 out 0x07, r25 ; 7 ADCSRA |= 0x40; // Start 127e: 36 9a sbi 0x06, 6 ; 6 while (((ADCSRA & 0x10) == 0)); 1280: 34 9b sbis 0x06, 4 ; 6 1282: fe cf rjmp .-4 ; 0x1280 ADMUX = sense; // zurück auf den Sense-Kanal 1284: 27 b9 out 0x07, r18 ; 7 i = ADCW * 4; 1286: 84 b1 in r24, 0x04 ; 4 1288: 95 b1 in r25, 0x05 ; 5 // if(i > 300) i = 300; Strom = (i + Strom * 7) / 8; 128a: 20 91 7a 00 lds r18, 0x007A 128e: 30 91 7b 00 lds r19, 0x007B 1292: a9 01 movw r20, r18 1294: 63 e0 ldi r22, 0x03 ; 3 1296: 44 0f add r20, r20 1298: 55 1f adc r21, r21 129a: 6a 95 dec r22 129c: e1 f7 brne .-8 ; 0x1296 129e: 42 1b sub r20, r18 12a0: 53 0b sbc r21, r19 12a2: 88 0f add r24, r24 12a4: 99 1f adc r25, r25 12a6: 88 0f add r24, r24 12a8: 99 1f adc r25, r25 12aa: 48 0f add r20, r24 12ac: 59 1f adc r21, r25 12ae: 83 e0 ldi r24, 0x03 ; 3 12b0: 56 95 lsr r21 12b2: 47 95 ror r20 12b4: 8a 95 dec r24 12b6: e1 f7 brne .-8 ; 0x12b0 12b8: 50 93 7b 00 sts 0x007B, r21 12bc: 40 93 7a 00 sts 0x007A, r20 if (Strom_max < Strom) Strom_max = Strom; 12c0: 80 91 7c 00 lds r24, 0x007C 12c4: 90 e0 ldi r25, 0x00 ; 0 12c6: 84 17 cp r24, r20 12c8: 95 07 cpc r25, r21 12ca: 10 f4 brcc .+4 ; 0x12d0 12cc: 40 93 7c 00 sts 0x007C, r20 ADCSRA = 0x00; 12d0: 16 b8 out 0x06, r1 ; 6 SFIOR = 0x08; // Analog Comperator ein 12d2: 88 e0 ldi r24, 0x08 ; 8 12d4: 80 bf out 0x30, r24 ; 48 } 12d6: 08 95 ret 000012d8 : //Strom Analogwerte lesen unsigned int MessAD(unsigned char channel) //############################################################################ { unsigned char sense; sense = ADMUX; // Sense-Kanal merken 12d8: 27 b1 in r18, 0x07 ; 7 channel |= IntRef; 12da: 90 91 8d 00 lds r25, 0x008D 12de: 98 2b or r25, r24 ADMUX = channel; // Kanal 6 12e0: 97 b9 out 0x07, r25 ; 7 SFIOR = 0x00; // Analog Comperator aus 12e2: 10 be out 0x30, r1 ; 48 ADCSRA = 0xD3; // Converter ein, single 12e4: 83 ed ldi r24, 0xD3 ; 211 12e6: 86 b9 out 0x06, r24 ; 6 ADCSRA |= 0x10; // Ready löschen 12e8: 34 9a sbi 0x06, 4 ; 6 ADMUX = channel; // Kanal 6 12ea: 97 b9 out 0x07, r25 ; 7 ADCSRA |= 0x40; // Start 12ec: 36 9a sbi 0x06, 6 ; 6 while (((ADCSRA & 0x10) == 0)); 12ee: 34 9b sbis 0x06, 4 ; 6 12f0: fe cf rjmp .-4 ; 0x12ee ADMUX = sense; // zurück auf den Sense-Kanal 12f2: 27 b9 out 0x07, r18 ; 7 ADCSRA = 0x00; 12f4: 16 b8 out 0x06, r1 ; 6 SFIOR = 0x08; // Analog Comperator ein 12f6: 88 e0 ldi r24, 0x08 ; 8 12f8: 80 bf out 0x30, r24 ; 48 return(ADCW); 12fa: 24 b1 in r18, 0x04 ; 4 12fc: 35 b1 in r19, 0x05 ; 5 } 12fe: c9 01 movw r24, r18 1300: 08 95 ret 00001302 : //Strom Analogwerte lesen void FastADConvert(void) //############################################################################ { unsigned int i=0; i = MessAD(6) * 4; 1302: 86 e0 ldi r24, 0x06 ; 6 1304: e9 df rcall .-46 ; 0x12d8 1306: 9c 01 movw r18, r24 1308: 22 0f add r18, r18 130a: 33 1f adc r19, r19 130c: 22 0f add r18, r18 130e: 33 1f adc r19, r19 1310: 29 3c cpi r18, 0xC9 ; 201 1312: 31 05 cpc r19, r1 1314: 10 f0 brcs .+4 ; 0x131a 1316: 28 ec ldi r18, 0xC8 ; 200 1318: 30 e0 ldi r19, 0x00 ; 0 // i = ADCW * 4; if(i > 200) i = 200; Strom = i;//(i + Strom * 1) / 2; 131a: 30 93 7b 00 sts 0x007B, r19 131e: 20 93 7a 00 sts 0x007A, r18 if (Strom_max < Strom) Strom_max = Strom; 1322: 80 91 7c 00 lds r24, 0x007C 1326: 90 e0 ldi r25, 0x00 ; 0 1328: 82 17 cp r24, r18 132a: 93 07 cpc r25, r19 132c: 10 f4 brcc .+4 ; 0x1332 132e: 20 93 7c 00 sts 0x007C, r18 ADCSRA = 0x00; 1332: 16 b8 out 0x06, r1 ; 6 SFIOR = 0x08; // Analog Comperator ein 1334: 88 e0 ldi r24, 0x08 ; 8 1336: 80 bf out 0x30, r24 ; 48 } 1338: 08 95 ret 0000133a : //############################################################################ // void InitPPM(void) //############################################################################ { TCCR1B |= (1<: //############################################################################ // SIGNAL(SIG_OVERFLOW1) //############################################################################ { 1354: 1f 92 push r1 1356: 0f 92 push r0 1358: 0f b6 in r0, 0x3f ; 63 135a: 0f 92 push r0 135c: 11 24 eor r1, r1 135e: 8f 93 push r24 Timer1Overflow++; 1360: 80 91 a7 00 lds r24, 0x00A7 1364: 8f 5f subi r24, 0xFF ; 255 1366: 80 93 a7 00 sts 0x00A7, r24 } 136a: 8f 91 pop r24 136c: 0f 90 pop r0 136e: 0f be out 0x3f, r0 ; 63 1370: 0f 90 pop r0 1372: 1f 90 pop r1 1374: 18 95 reti 00001376 <__vector_5>: //############################################################################ // SIGNAL(SIG_INPUT_CAPTURE1) //############################################################################ { 1376: 1f 92 push r1 1378: 0f 92 push r0 137a: 0f b6 in r0, 0x3f ; 63 137c: 0f 92 push r0 137e: 11 24 eor r1, r1 1380: 2f 93 push r18 1382: 3f 93 push r19 1384: 4f 93 push r20 1386: 5f 93 push r21 1388: 8f 93 push r24 138a: 9f 93 push r25 static unsigned int tim_alt; static unsigned int ppm; if(TCCR1B & (1< { Timer1Overflow = 0; 1392: 10 92 a7 00 sts 0x00A7, r1 tim_alt = ICR1; 1396: 86 b5 in r24, 0x26 ; 38 1398: 97 b5 in r25, 0x27 ; 39 139a: 90 93 ad 00 sts 0x00AD, r25 139e: 80 93 ac 00 sts 0x00AC, r24 ICP_NEG_FLANKE; 13a2: 8e b5 in r24, 0x2e ; 46 13a4: 8f 7b andi r24, 0xBF ; 191 13a6: 8e bd out 0x2e, r24 ; 46 PPM_Timeout = 100; 13a8: 84 e6 ldi r24, 0x64 ; 100 13aa: 80 93 a8 00 sts 0x00A8, r24 13ae: 6f c0 rjmp .+222 ; 0x148e <__vector_5+0x118> } else // Negative Flanke { ICP_POS_FLANKE; 13b0: 8e b5 in r24, 0x2e ; 46 13b2: 80 64 ori r24, 0x40 ; 64 13b4: 8e bd out 0x2e, r24 ; 46 #ifdef _32KHZ ppm = (ICR1 - tim_alt + (int) Timer1Overflow * 256) / 32; #endif #ifdef _16KHZ ppm = (ICR1 - tim_alt + (int) Timer1Overflow * 512) / 32; 13b6: 26 b5 in r18, 0x26 ; 38 13b8: 37 b5 in r19, 0x27 ; 39 13ba: 40 91 a7 00 lds r20, 0x00A7 13be: 80 91 ac 00 lds r24, 0x00AC 13c2: 90 91 ad 00 lds r25, 0x00AD 13c6: 28 1b sub r18, r24 13c8: 39 0b sbc r19, r25 13ca: 94 2f mov r25, r20 13cc: 99 0f add r25, r25 13ce: 80 e0 ldi r24, 0x00 ; 0 13d0: 28 0f add r18, r24 13d2: 39 1f adc r19, r25 13d4: 85 e0 ldi r24, 0x05 ; 5 13d6: 36 95 lsr r19 13d8: 27 95 ror r18 13da: 8a 95 dec r24 13dc: e1 f7 brne .-8 ; 0x13d6 <__vector_5+0x60> 13de: 30 93 ab 00 sts 0x00AB, r19 13e2: 20 93 aa 00 sts 0x00AA, r18 #endif if(ppm < 280) ppm = 280; 13e6: 28 51 subi r18, 0x18 ; 24 13e8: 31 40 sbci r19, 0x01 ; 1 13ea: 30 f4 brcc .+12 ; 0x13f8 <__vector_5+0x82> 13ec: 88 e1 ldi r24, 0x18 ; 24 13ee: 91 e0 ldi r25, 0x01 ; 1 13f0: 90 93 ab 00 sts 0x00AB, r25 13f4: 80 93 aa 00 sts 0x00AA, r24 ppm -= 280; 13f8: 40 91 aa 00 lds r20, 0x00AA 13fc: 50 91 ab 00 lds r21, 0x00AB 1400: 48 51 subi r20, 0x18 ; 24 1402: 51 40 sbci r21, 0x01 ; 1 if(PPM_Signal < ppm) PPM_Signal++; 1404: 80 91 a5 00 lds r24, 0x00A5 1408: 90 91 a6 00 lds r25, 0x00A6 140c: 84 17 cp r24, r20 140e: 95 07 cpc r25, r21 1410: 30 f4 brcc .+12 ; 0x141e <__vector_5+0xa8> 1412: 80 91 a5 00 lds r24, 0x00A5 1416: 90 91 a6 00 lds r25, 0x00A6 141a: 01 96 adiw r24, 0x01 ; 1 141c: 0c c0 rjmp .+24 ; 0x1436 <__vector_5+0xc0> else if(PPM_Signal > ppm) PPM_Signal--; 141e: 80 91 a5 00 lds r24, 0x00A5 1422: 90 91 a6 00 lds r25, 0x00A6 1426: 48 17 cp r20, r24 1428: 59 07 cpc r21, r25 142a: 48 f4 brcc .+18 ; 0x143e <__vector_5+0xc8> 142c: 80 91 a5 00 lds r24, 0x00A5 1430: 90 91 a6 00 lds r25, 0x00A6 1434: 01 97 sbiw r24, 0x01 ; 1 1436: 90 93 a6 00 sts 0x00A6, r25 143a: 80 93 a5 00 sts 0x00A5, r24 if(FILTER_PPM) ppm = (PPM_Signal * FILTER_PPM + ppm) / (FILTER_PPM + 1); // Filtern 143e: 80 91 a5 00 lds r24, 0x00A5 1442: 90 91 a6 00 lds r25, 0x00A6 1446: 9c 01 movw r18, r24 1448: 22 0f add r18, r18 144a: 33 1f adc r19, r19 144c: 22 0f add r18, r18 144e: 33 1f adc r19, r19 1450: 22 0f add r18, r18 1452: 33 1f adc r19, r19 1454: 28 1b sub r18, r24 1456: 39 0b sbc r19, r25 1458: 24 0f add r18, r20 145a: 35 1f adc r19, r21 145c: 83 e0 ldi r24, 0x03 ; 3 145e: 36 95 lsr r19 1460: 27 95 ror r18 1462: 8a 95 dec r24 1464: e1 f7 brne .-8 ; 0x145e <__vector_5+0xe8> 1466: 30 93 ab 00 sts 0x00AB, r19 146a: 20 93 aa 00 sts 0x00AA, r18 PPM_Signal = ppm; 146e: 30 93 a6 00 sts 0x00A6, r19 1472: 20 93 a5 00 sts 0x00A5, r18 if(anz_ppm_werte < 255) anz_ppm_werte++; 1476: 80 91 a9 00 lds r24, 0x00A9 147a: 8f 3f cpi r24, 0xFF ; 255 147c: 29 f0 breq .+10 ; 0x1488 <__vector_5+0x112> 147e: 80 91 a9 00 lds r24, 0x00A9 1482: 8f 5f subi r24, 0xFF ; 255 1484: 80 93 a9 00 sts 0x00A9, r24 ZeitZumAdWandeln = 1; 1488: 81 e0 ldi r24, 0x01 ; 1 148a: 80 93 65 00 sts 0x0065, r24 } } 148e: 9f 91 pop r25 1490: 8f 91 pop r24 1492: 5f 91 pop r21 1494: 4f 91 pop r20 1496: 3f 91 pop r19 1498: 2f 91 pop r18 149a: 0f 90 pop r0 149c: 0f be out 0x3f, r0 ; 63 149e: 0f 90 pop r0 14a0: 1f 90 pop r1 14a2: 18 95 reti 000014a4 <__vector_1>: //############################################################################ // SIGNAL(SIG_INTERRUPT0) //############################################################################ { 14a4: 1f 92 push r1 14a6: 0f 92 push r0 14a8: 0f b6 in r0, 0x3f ; 63 14aa: 0f 92 push r0 14ac: 11 24 eor r1, r1 14ae: 8f 93 push r24 CLR_INT0_FLAG; // IntFlag Loeschen 14b0: 8a b7 in r24, 0x3a ; 58 14b2: 8f 7b andi r24, 0xBF ; 191 14b4: 8a bf out 0x3a, r24 ; 58 } 14b6: 8f 91 pop r24 14b8: 0f 90 pop r0 14ba: 0f be out 0x3f, r0 ; 63 14bc: 0f 90 pop r0 14be: 1f 90 pop r1 14c0: 18 95 reti 000014c2 : //############################################################################ //I2C (TWI) Interface Init void InitIC2_Slave(uint8_t adr) //############################################################################ { TWAR = adr + (2*MotorAdresse); // Eigene Adresse setzen 14c2: 90 91 66 00 lds r25, 0x0066 14c6: 99 0f add r25, r25 14c8: 98 0f add r25, r24 14ca: 92 b9 out 0x02, r25 ; 2 TWCR = (1<: //############################################################################ //ISR, die bei einem Ereignis auf dem Bus ausgelöst wird. Im Register TWSR befindet //sich dann ein Statuscode, anhand dessen die Situation festgestellt werden kann. ISR (TWI_vect) //############################################################################ { 14d2: 1f 92 push r1 14d4: 0f 92 push r0 14d6: 0f b6 in r0, 0x3f ; 63 14d8: 0f 92 push r0 14da: 11 24 eor r1, r1 14dc: 8f 93 push r24 14de: 9f 93 push r25 switch (TWSR & 0xF8) 14e0: 81 b1 in r24, 0x01 ; 1 14e2: 90 e0 ldi r25, 0x00 ; 0 14e4: 88 7f andi r24, 0xF8 ; 248 14e6: 90 70 andi r25, 0x00 ; 0 14e8: 80 38 cpi r24, 0x80 ; 128 14ea: 91 05 cpc r25, r1 14ec: c9 f0 breq .+50 ; 0x1520 <__vector_17+0x4e> 14ee: 81 38 cpi r24, 0x81 ; 129 14f0: 91 05 cpc r25, r1 14f2: 34 f4 brge .+12 ; 0x1500 <__vector_17+0x2e> 14f4: 00 97 sbiw r24, 0x00 ; 0 14f6: 91 f1 breq .+100 ; 0x155c <__vector_17+0x8a> 14f8: 80 36 cpi r24, 0x60 ; 96 14fa: 91 05 cpc r25, r1 14fc: 91 f5 brne .+100 ; 0x1562 <__vector_17+0x90> 14fe: 0a c0 rjmp .+20 ; 0x1514 <__vector_17+0x42> 1500: 88 3b cpi r24, 0xB8 ; 184 1502: 91 05 cpc r25, r1 1504: b9 f0 breq .+46 ; 0x1534 <__vector_17+0x62> 1506: 88 3f cpi r24, 0xF8 ; 248 1508: 91 05 cpc r25, r1 150a: 29 f1 breq .+74 ; 0x1556 <__vector_17+0x84> 150c: 88 3a cpi r24, 0xA8 ; 168 150e: 91 05 cpc r25, r1 1510: 41 f5 brne .+80 ; 0x1562 <__vector_17+0x90> 1512: 10 c0 rjmp .+32 ; 0x1534 <__vector_17+0x62> { case SR_SLA_ACK: TWCR |= (1< return; // Daten Empfangen case SR_PREV_ACK: I2C_RXBuffer = TWDR; 1520: 83 b1 in r24, 0x03 ; 3 1522: 80 93 95 03 sts 0x0395, r24 I2C_Timeout = 500; 1526: 84 ef ldi r24, 0xF4 ; 244 1528: 91 e0 ldi r25, 0x01 ; 1 152a: 90 93 81 00 sts 0x0081, r25 152e: 80 93 80 00 sts 0x0080, r24 1532: 0e c0 rjmp .+28 ; 0x1550 <__vector_17+0x7e> } TWCR |= (1< { TWDR = Mittelstrom; 153c: 80 91 7d 00 lds r24, 0x007D 1540: 83 b9 out 0x03, r24 ; 3 Byte_Counter++; 1542: 81 e0 ldi r24, 0x01 ; 1 1544: 80 93 ae 00 sts 0x00AE, r24 1548: 03 c0 rjmp .+6 ; 0x1550 <__vector_17+0x7e> } else { TWDR = MaxPWM; 154a: 80 91 64 00 lds r24, 0x0064 154e: 83 b9 out 0x03, r24 ; 3 } TWCR |= (1< return; // Bus-Fehler zurücksetzen case TWI_BUS_ERR_2: TWCR |=(1<: //############################################################################ // SIGNAL(SIG_OVERFLOW2) //############################################################################ { 1574: 1f 92 push r1 1576: 0f 92 push r0 1578: 0f b6 in r0, 0x3f ; 63 157a: 0f 92 push r0 157c: 11 24 eor r1, r1 } 157e: 0f 90 pop r0 1580: 0f be out 0x3f, r0 ; 63 1582: 0f 90 pop r0 1584: 1f 90 pop r1 1586: 18 95 reti 00001588 : //############################################################################ // void Manuell(void) //############################################################################ { switch(Phase) 1588: 80 91 af 00 lds r24, 0x00AF 158c: 82 30 cpi r24, 0x02 ; 2 158e: 69 f1 breq .+90 ; 0x15ea 1590: 83 30 cpi r24, 0x03 ; 3 1592: 30 f4 brcc .+12 ; 0x15a0 1594: 88 23 and r24, r24 1596: 69 f0 breq .+26 ; 0x15b2 1598: 81 30 cpi r24, 0x01 ; 1 159a: 09 f0 breq .+2 ; 0x159e 159c: 63 c0 rjmp .+198 ; 0x1664 159e: 17 c0 rjmp .+46 ; 0x15ce 15a0: 84 30 cpi r24, 0x04 ; 4 15a2: 09 f4 brne .+2 ; 0x15a6 15a4: 3f c0 rjmp .+126 ; 0x1624 15a6: 84 30 cpi r24, 0x04 ; 4 15a8: 68 f1 brcs .+90 ; 0x1604 15aa: 85 30 cpi r24, 0x05 ; 5 15ac: 09 f0 breq .+2 ; 0x15b0 15ae: 5a c0 rjmp .+180 ; 0x1664 15b0: 4b c0 rjmp .+150 ; 0x1648 { case 0: STEUER_A_H; 15b2: 81 ea ldi r24, 0xA1 ; 161 15b4: 8f bd out 0x2f, r24 ; 47 15b6: 81 e6 ldi r24, 0x61 ; 97 15b8: 85 bd out 0x25, r24 ; 37 15ba: 88 e0 ldi r24, 0x08 ; 8 15bc: 87 bb out 0x17, r24 ; 23 STEUER_B_L; 15be: 82 b3 in r24, 0x12 ; 18 15c0: 87 7d andi r24, 0xD7 ; 215 15c2: 82 bb out 0x12, r24 ; 18 15c4: 94 9a sbi 0x12, 4 ; 18 SENSE_C; 15c6: 80 91 8d 00 lds r24, 0x008D 15ca: 82 60 ori r24, 0x02 ; 2 15cc: 38 c0 rjmp .+112 ; 0x163e SENSE_RISING_INT; break; case 1: STEUER_A_H; 15ce: 81 ea ldi r24, 0xA1 ; 161 15d0: 8f bd out 0x2f, r24 ; 47 15d2: 81 e6 ldi r24, 0x61 ; 97 15d4: 85 bd out 0x25, r24 ; 37 15d6: 88 e0 ldi r24, 0x08 ; 8 15d8: 87 bb out 0x17, r24 ; 23 STEUER_C_L; 15da: 82 b3 in r24, 0x12 ; 18 15dc: 87 7e andi r24, 0xE7 ; 231 15de: 82 bb out 0x12, r24 ; 18 15e0: 95 9a sbi 0x12, 5 ; 18 SENSE_B; 15e2: 80 91 8d 00 lds r24, 0x008D 15e6: 81 60 ori r24, 0x01 ; 1 15e8: 1a c0 rjmp .+52 ; 0x161e SENSE_FALLING_INT; break; case 2: STEUER_B_H; 15ea: 81 ea ldi r24, 0xA1 ; 161 15ec: 8f bd out 0x2f, r24 ; 47 15ee: 81 e6 ldi r24, 0x61 ; 97 15f0: 85 bd out 0x25, r24 ; 37 15f2: 84 e0 ldi r24, 0x04 ; 4 15f4: 87 bb out 0x17, r24 ; 23 STEUER_C_L; 15f6: 82 b3 in r24, 0x12 ; 18 15f8: 87 7e andi r24, 0xE7 ; 231 15fa: 82 bb out 0x12, r24 ; 18 15fc: 95 9a sbi 0x12, 5 ; 18 SENSE_A; 15fe: 80 91 8d 00 lds r24, 0x008D 1602: 1d c0 rjmp .+58 ; 0x163e SENSE_RISING_INT; break; case 3: STEUER_B_H; 1604: 81 ea ldi r24, 0xA1 ; 161 1606: 8f bd out 0x2f, r24 ; 47 1608: 81 e6 ldi r24, 0x61 ; 97 160a: 85 bd out 0x25, r24 ; 37 160c: 84 e0 ldi r24, 0x04 ; 4 160e: 87 bb out 0x17, r24 ; 23 STEUER_A_L; 1610: 82 b3 in r24, 0x12 ; 18 1612: 8f 7c andi r24, 0xCF ; 207 1614: 82 bb out 0x12, r24 ; 18 1616: 93 9a sbi 0x12, 3 ; 18 SENSE_C; 1618: 80 91 8d 00 lds r24, 0x008D 161c: 82 60 ori r24, 0x02 ; 2 161e: 87 b9 out 0x07, r24 ; 7 SENSE_FALLING_INT; 1620: 40 98 cbi 0x08, 0 ; 8 1622: 08 95 ret break; case 4: STEUER_C_H; 1624: 81 ea ldi r24, 0xA1 ; 161 1626: 8f bd out 0x2f, r24 ; 47 1628: 81 e6 ldi r24, 0x61 ; 97 162a: 85 bd out 0x25, r24 ; 37 162c: 82 e0 ldi r24, 0x02 ; 2 162e: 87 bb out 0x17, r24 ; 23 STEUER_A_L; 1630: 82 b3 in r24, 0x12 ; 18 1632: 8f 7c andi r24, 0xCF ; 207 1634: 82 bb out 0x12, r24 ; 18 1636: 93 9a sbi 0x12, 3 ; 18 SENSE_B; 1638: 80 91 8d 00 lds r24, 0x008D 163c: 81 60 ori r24, 0x01 ; 1 163e: 87 b9 out 0x07, r24 ; 7 SENSE_RISING_INT; 1640: 88 b1 in r24, 0x08 ; 8 1642: 83 60 ori r24, 0x03 ; 3 1644: 88 b9 out 0x08, r24 ; 8 1646: 08 95 ret break; case 5: STEUER_C_H; 1648: 81 ea ldi r24, 0xA1 ; 161 164a: 8f bd out 0x2f, r24 ; 47 164c: 81 e6 ldi r24, 0x61 ; 97 164e: 85 bd out 0x25, r24 ; 37 1650: 82 e0 ldi r24, 0x02 ; 2 1652: 87 bb out 0x17, r24 ; 23 STEUER_B_L; 1654: 82 b3 in r24, 0x12 ; 18 1656: 87 7d andi r24, 0xD7 ; 215 1658: 82 bb out 0x12, r24 ; 18 165a: 94 9a sbi 0x12, 4 ; 18 SENSE_A; 165c: 80 91 8d 00 lds r24, 0x008D 1660: 87 b9 out 0x07, r24 ; 7 SENSE_FALLING_INT; 1662: 40 98 cbi 0x08, 0 ; 8 1664: 08 95 ret 00001666 <__vector_16>: // + Interruptroutine // + Wird durch den Analogkomperator ausgelöst // + Dadurch wird das Kommutieren erzeugt SIGNAL(SIG_COMPARATOR) //############################################################################ { 1666: 1f 92 push r1 1668: 0f 92 push r0 166a: 0f b6 in r0, 0x3f ; 63 166c: 0f 92 push r0 166e: 11 24 eor r1, r1 1670: cf 92 push r12 1672: df 92 push r13 1674: ef 92 push r14 1676: ff 92 push r15 1678: 0f 93 push r16 167a: 1f 93 push r17 167c: 2f 93 push r18 167e: 3f 93 push r19 1680: 4f 93 push r20 1682: 5f 93 push r21 1684: 6f 93 push r22 1686: 7f 93 push r23 1688: 8f 93 push r24 168a: 9f 93 push r25 168c: af 93 push r26 168e: bf 93 push r27 1690: ef 93 push r30 1692: ff 93 push r31 } break; case 4: STEUER_C_H; 1694: 61 ea ldi r22, 0xA1 ; 161 1696: f6 2e mov r15, r22 1698: 01 e6 ldi r16, 0x61 ; 97 169a: 52 e0 ldi r21, 0x02 ; 2 169c: c5 2e mov r12, r21 Phase++; CntKommutierungen++; } else { STEUER_B_H; 169e: 44 e0 ldi r20, 0x04 ; 4 16a0: d4 2e mov r13, r20 break; case 5: STEUER_B_L; if(!sense) { STEUER_A_H; 16a2: 38 e0 ldi r19, 0x08 ; 8 16a4: e3 2e mov r14, r19 //############################################################################ { unsigned char sense = 0; do { if(SENSE_H) sense = 1; else sense = 0; 16a6: 88 b1 in r24, 0x08 ; 8 16a8: 90 e0 ldi r25, 0x00 ; 0 16aa: 25 e0 ldi r18, 0x05 ; 5 16ac: 96 95 lsr r25 16ae: 87 95 ror r24 16b0: 2a 95 dec r18 16b2: e1 f7 brne .-8 ; 0x16ac <__vector_16+0x46> 16b4: 18 2f mov r17, r24 16b6: 11 70 andi r17, 0x01 ; 1 switch(Phase) 16b8: 80 91 af 00 lds r24, 0x00AF 16bc: 82 30 cpi r24, 0x02 ; 2 16be: 09 f4 brne .+2 ; 0x16c2 <__vector_16+0x5c> 16c0: 50 c0 rjmp .+160 ; 0x1762 <__vector_16+0xfc> 16c2: 83 30 cpi r24, 0x03 ; 3 16c4: 30 f4 brcc .+12 ; 0x16d2 <__vector_16+0x6c> 16c6: 88 23 and r24, r24 16c8: 71 f0 breq .+28 ; 0x16e6 <__vector_16+0x80> 16ca: 81 30 cpi r24, 0x01 ; 1 16cc: 09 f0 breq .+2 ; 0x16d0 <__vector_16+0x6a> 16ce: a5 c0 rjmp .+330 ; 0x181a <__vector_16+0x1b4> 16d0: 22 c0 rjmp .+68 ; 0x1716 <__vector_16+0xb0> 16d2: 84 30 cpi r24, 0x04 ; 4 16d4: 09 f4 brne .+2 ; 0x16d8 <__vector_16+0x72> 16d6: 70 c0 rjmp .+224 ; 0x17b8 <__vector_16+0x152> 16d8: 84 30 cpi r24, 0x04 ; 4 16da: 08 f4 brcc .+2 ; 0x16de <__vector_16+0x78> 16dc: 58 c0 rjmp .+176 ; 0x178e <__vector_16+0x128> 16de: 85 30 cpi r24, 0x05 ; 5 16e0: 09 f0 breq .+2 ; 0x16e4 <__vector_16+0x7e> 16e2: 9b c0 rjmp .+310 ; 0x181a <__vector_16+0x1b4> 16e4: 80 c0 rjmp .+256 ; 0x17e6 <__vector_16+0x180> { case 0: STEUER_A_H; 16e6: ff bc out 0x2f, r15 ; 47 16e8: 05 bd out 0x25, r16 ; 37 16ea: e7 ba out 0x17, r14 ; 23 if(sense) 16ec: 11 23 and r17, r17 16ee: 71 f0 breq .+28 ; 0x170c <__vector_16+0xa6> { STEUER_C_L; 16f0: 82 b3 in r24, 0x12 ; 18 16f2: 87 7e andi r24, 0xE7 ; 231 16f4: 82 bb out 0x12, r24 ; 18 16f6: 95 9a sbi 0x12, 5 ; 18 if(ZeitZumAdWandeln) AdConvert(); 16f8: 80 91 65 00 lds r24, 0x0065 16fc: 81 11 cpse r24, r1 16fe: b5 dd rcall .-1174 ; 0x126a SENSE_FALLING_INT; 1700: 40 98 cbi 0x08, 0 ; 8 SENSE_B; 1702: 80 91 8d 00 lds r24, 0x008D 1706: 81 60 ori r24, 0x01 ; 1 1708: 87 b9 out 0x07, r24 ; 7 170a: 18 c0 rjmp .+48 ; 0x173c <__vector_16+0xd6> Phase++; CntKommutierungen++; } else { STEUER_B_L; 170c: 82 b3 in r24, 0x12 ; 18 170e: 87 7d andi r24, 0xD7 ; 215 1710: 82 bb out 0x12, r24 ; 18 1712: 94 9a sbi 0x12, 4 ; 18 1714: 82 c0 rjmp .+260 ; 0x181a <__vector_16+0x1b4> } break; case 1: STEUER_C_L; 1716: 82 b3 in r24, 0x12 ; 18 1718: 87 7e andi r24, 0xE7 ; 231 171a: 82 bb out 0x12, r24 ; 18 171c: 95 9a sbi 0x12, 5 ; 18 if(!sense) 171e: 11 23 and r17, r17 1720: e1 f4 brne .+56 ; 0x175a <__vector_16+0xf4> { STEUER_B_H; 1722: ff bc out 0x2f, r15 ; 47 1724: 05 bd out 0x25, r16 ; 37 1726: d7 ba out 0x17, r13 ; 23 if(ZeitZumAdWandeln) AdConvert(); 1728: 80 91 65 00 lds r24, 0x0065 172c: 81 11 cpse r24, r1 172e: 9d dd rcall .-1222 ; 0x126a SENSE_A; 1730: 80 91 8d 00 lds r24, 0x008D 1734: 87 b9 out 0x07, r24 ; 7 SENSE_RISING_INT; 1736: 88 b1 in r24, 0x08 ; 8 1738: 83 60 ori r24, 0x03 ; 3 173a: 88 b9 out 0x08, r24 ; 8 Phase++; 173c: 80 91 af 00 lds r24, 0x00AF 1740: 8f 5f subi r24, 0xFF ; 255 1742: 80 93 af 00 sts 0x00AF, r24 CntKommutierungen++; 1746: 80 91 89 00 lds r24, 0x0089 174a: 90 91 8a 00 lds r25, 0x008A 174e: 01 96 adiw r24, 0x01 ; 1 1750: 90 93 8a 00 sts 0x008A, r25 1754: 80 93 89 00 sts 0x0089, r24 1758: 60 c0 rjmp .+192 ; 0x181a <__vector_16+0x1b4> } else { STEUER_A_H; 175a: ff bc out 0x2f, r15 ; 47 175c: 05 bd out 0x25, r16 ; 37 175e: e7 ba out 0x17, r14 ; 23 1760: 5c c0 rjmp .+184 ; 0x181a <__vector_16+0x1b4> } break; case 2: STEUER_B_H; 1762: ff bc out 0x2f, r15 ; 47 1764: 05 bd out 0x25, r16 ; 37 1766: d7 ba out 0x17, r13 ; 23 if(sense) 1768: 11 23 and r17, r17 176a: 61 f0 breq .+24 ; 0x1784 <__vector_16+0x11e> { STEUER_A_L; 176c: 82 b3 in r24, 0x12 ; 18 176e: 8f 7c andi r24, 0xCF ; 207 1770: 82 bb out 0x12, r24 ; 18 1772: 93 9a sbi 0x12, 3 ; 18 if(ZeitZumAdWandeln) AdConvert(); 1774: 80 91 65 00 lds r24, 0x0065 1778: 81 11 cpse r24, r1 177a: 77 dd rcall .-1298 ; 0x126a SENSE_C; 177c: 80 91 8d 00 lds r24, 0x008D 1780: 82 60 ori r24, 0x02 ; 2 1782: 29 c0 rjmp .+82 ; 0x17d6 <__vector_16+0x170> Phase++; CntKommutierungen++; } else { STEUER_C_L; 1784: 82 b3 in r24, 0x12 ; 18 1786: 87 7e andi r24, 0xE7 ; 231 1788: 82 bb out 0x12, r24 ; 18 178a: 95 9a sbi 0x12, 5 ; 18 178c: 46 c0 rjmp .+140 ; 0x181a <__vector_16+0x1b4> } break; case 3: STEUER_A_L; 178e: 82 b3 in r24, 0x12 ; 18 1790: 8f 7c andi r24, 0xCF ; 207 1792: 82 bb out 0x12, r24 ; 18 1794: 93 9a sbi 0x12, 3 ; 18 if(!sense) 1796: 11 23 and r17, r17 1798: 59 f4 brne .+22 ; 0x17b0 <__vector_16+0x14a> { STEUER_C_H; 179a: ff bc out 0x2f, r15 ; 47 179c: 05 bd out 0x25, r16 ; 37 179e: c7 ba out 0x17, r12 ; 23 if(ZeitZumAdWandeln) AdConvert(); 17a0: 80 91 65 00 lds r24, 0x0065 17a4: 81 11 cpse r24, r1 17a6: 61 dd rcall .-1342 ; 0x126a SENSE_B; 17a8: 80 91 8d 00 lds r24, 0x008D 17ac: 81 60 ori r24, 0x01 ; 1 17ae: c2 cf rjmp .-124 ; 0x1734 <__vector_16+0xce> Phase++; CntKommutierungen++; } else { STEUER_B_H; 17b0: ff bc out 0x2f, r15 ; 47 17b2: 05 bd out 0x25, r16 ; 37 17b4: d7 ba out 0x17, r13 ; 23 17b6: 31 c0 rjmp .+98 ; 0x181a <__vector_16+0x1b4> } break; case 4: STEUER_C_H; 17b8: ff bc out 0x2f, r15 ; 47 17ba: 05 bd out 0x25, r16 ; 37 17bc: c7 ba out 0x17, r12 ; 23 if(sense) 17be: 11 23 and r17, r17 17c0: 69 f0 breq .+26 ; 0x17dc <__vector_16+0x176> { STEUER_B_L; 17c2: 82 b3 in r24, 0x12 ; 18 17c4: 87 7d andi r24, 0xD7 ; 215 17c6: 82 bb out 0x12, r24 ; 18 17c8: 94 9a sbi 0x12, 4 ; 18 if(ZeitZumAdWandeln) AdConvert(); 17ca: 80 91 65 00 lds r24, 0x0065 17ce: 81 11 cpse r24, r1 17d0: 4c dd rcall .-1384 ; 0x126a SENSE_A; 17d2: 80 91 8d 00 lds r24, 0x008D 17d6: 87 b9 out 0x07, r24 ; 7 SENSE_FALLING_INT; 17d8: 40 98 cbi 0x08, 0 ; 8 17da: b0 cf rjmp .-160 ; 0x173c <__vector_16+0xd6> Phase++; CntKommutierungen++; } else { STEUER_A_L; 17dc: 82 b3 in r24, 0x12 ; 18 17de: 8f 7c andi r24, 0xCF ; 207 17e0: 82 bb out 0x12, r24 ; 18 17e2: 93 9a sbi 0x12, 3 ; 18 17e4: 1a c0 rjmp .+52 ; 0x181a <__vector_16+0x1b4> } break; case 5: STEUER_B_L; 17e6: 82 b3 in r24, 0x12 ; 18 17e8: 87 7d andi r24, 0xD7 ; 215 17ea: 82 bb out 0x12, r24 ; 18 17ec: 94 9a sbi 0x12, 4 ; 18 if(!sense) 17ee: 11 23 and r17, r17 17f0: 89 f4 brne .+34 ; 0x1814 <__vector_16+0x1ae> { STEUER_A_H; 17f2: ff bc out 0x2f, r15 ; 47 17f4: 05 bd out 0x25, r16 ; 37 17f6: e7 ba out 0x17, r14 ; 23 if(ZeitZumAdWandeln) AdConvert(); 17f8: 80 91 65 00 lds r24, 0x0065 17fc: 81 11 cpse r24, r1 17fe: 35 dd rcall .-1430 ; 0x126a SENSE_C; 1800: 80 91 8d 00 lds r24, 0x008D 1804: 82 60 ori r24, 0x02 ; 2 1806: 87 b9 out 0x07, r24 ; 7 SENSE_RISING_INT; 1808: 88 b1 in r24, 0x08 ; 8 180a: 83 60 ori r24, 0x03 ; 3 180c: 88 b9 out 0x08, r24 ; 8 Phase = 0; 180e: 10 92 af 00 sts 0x00AF, r1 1812: 99 cf rjmp .-206 ; 0x1746 <__vector_16+0xe0> CntKommutierungen++; } else { STEUER_C_H; 1814: ff bc out 0x2f, r15 ; 47 1816: 05 bd out 0x25, r16 ; 37 1818: c7 ba out 0x17, r12 ; 23 } break; } } while((SENSE_L && sense) || (SENSE_H && !sense)); 181a: 45 99 sbic 0x08, 5 ; 8 181c: 03 c0 rjmp .+6 ; 0x1824 <__vector_16+0x1be> 181e: 11 23 and r17, r17 1820: 09 f0 breq .+2 ; 0x1824 <__vector_16+0x1be> 1822: 41 cf rjmp .-382 ; 0x16a6 <__vector_16+0x40> 1824: 45 9b sbis 0x08, 5 ; 8 1826: 03 c0 rjmp .+6 ; 0x182e <__vector_16+0x1c8> 1828: 11 23 and r17, r17 182a: 09 f4 brne .+2 ; 0x182e <__vector_16+0x1c8> 182c: 3c cf rjmp .-392 ; 0x16a6 <__vector_16+0x40> ZeitZumAdWandeln = 0; 182e: 10 92 65 00 sts 0x0065, r1 } 1832: ff 91 pop r31 1834: ef 91 pop r30 1836: bf 91 pop r27 1838: af 91 pop r26 183a: 9f 91 pop r25 183c: 8f 91 pop r24 183e: 7f 91 pop r23 1840: 6f 91 pop r22 1842: 5f 91 pop r21 1844: 4f 91 pop r20 1846: 3f 91 pop r19 1848: 2f 91 pop r18 184a: 1f 91 pop r17 184c: 0f 91 pop r16 184e: ff 90 pop r15 1850: ef 90 pop r14 1852: df 90 pop r13 1854: cf 90 pop r12 1856: 0f 90 pop r0 1858: 0f be out 0x3f, r0 ; 63 185a: 0f 90 pop r0 185c: 1f 90 pop r1 185e: 18 95 reti 00001860 <__udivmodqi4>: 1860: 99 1b sub r25, r25 1862: 79 e0 ldi r23, 0x09 ; 9 1864: 04 c0 rjmp .+8 ; 0x186e <__udivmodqi4_ep> 00001866 <__udivmodqi4_loop>: 1866: 99 1f adc r25, r25 1868: 96 17 cp r25, r22 186a: 08 f0 brcs .+2 ; 0x186e <__udivmodqi4_ep> 186c: 96 1b sub r25, r22 0000186e <__udivmodqi4_ep>: 186e: 88 1f adc r24, r24 1870: 7a 95 dec r23 1872: c9 f7 brne .-14 ; 0x1866 <__udivmodqi4_loop> 1874: 80 95 com r24 1876: 08 95 ret 00001878 <__udivmodhi4>: 1878: aa 1b sub r26, r26 187a: bb 1b sub r27, r27 187c: 51 e1 ldi r21, 0x11 ; 17 187e: 07 c0 rjmp .+14 ; 0x188e <__udivmodhi4_ep> 00001880 <__udivmodhi4_loop>: 1880: aa 1f adc r26, r26 1882: bb 1f adc r27, r27 1884: a6 17 cp r26, r22 1886: b7 07 cpc r27, r23 1888: 10 f0 brcs .+4 ; 0x188e <__udivmodhi4_ep> 188a: a6 1b sub r26, r22 188c: b7 0b sbc r27, r23 0000188e <__udivmodhi4_ep>: 188e: 88 1f adc r24, r24 1890: 99 1f adc r25, r25 1892: 5a 95 dec r21 1894: a9 f7 brne .-22 ; 0x1880 <__udivmodhi4_loop> 1896: 80 95 com r24 1898: 90 95 com r25 189a: bc 01 movw r22, r24 189c: cd 01 movw r24, r26 189e: 08 95 ret 000018a0 <__udivmodsi4>: 18a0: a1 e2 ldi r26, 0x21 ; 33 18a2: 1a 2e mov r1, r26 18a4: aa 1b sub r26, r26 18a6: bb 1b sub r27, r27 18a8: fd 01 movw r30, r26 18aa: 0d c0 rjmp .+26 ; 0x18c6 <__udivmodsi4_ep> 000018ac <__udivmodsi4_loop>: 18ac: aa 1f adc r26, r26 18ae: bb 1f adc r27, r27 18b0: ee 1f adc r30, r30 18b2: ff 1f adc r31, r31 18b4: a2 17 cp r26, r18 18b6: b3 07 cpc r27, r19 18b8: e4 07 cpc r30, r20 18ba: f5 07 cpc r31, r21 18bc: 20 f0 brcs .+8 ; 0x18c6 <__udivmodsi4_ep> 18be: a2 1b sub r26, r18 18c0: b3 0b sbc r27, r19 18c2: e4 0b sbc r30, r20 18c4: f5 0b sbc r31, r21 000018c6 <__udivmodsi4_ep>: 18c6: 66 1f adc r22, r22 18c8: 77 1f adc r23, r23 18ca: 88 1f adc r24, r24 18cc: 99 1f adc r25, r25 18ce: 1a 94 dec r1 18d0: 69 f7 brne .-38 ; 0x18ac <__udivmodsi4_loop> 18d2: 60 95 com r22 18d4: 70 95 com r23 18d6: 80 95 com r24 18d8: 90 95 com r25 18da: 9b 01 movw r18, r22 18dc: ac 01 movw r20, r24 18de: bd 01 movw r22, r26 18e0: cf 01 movw r24, r30 18e2: 08 95 ret 000018e4 : 18e4: 0f 93 push r16 18e6: 1f 93 push r17 18e8: cf 93 push r28 18ea: df 93 push r29 18ec: 8c 01 movw r16, r24 18ee: eb 01 movw r28, r22 18f0: 00 97 sbiw r24, 0x00 ; 0 18f2: 31 f4 brne .+12 ; 0x1900 18f4: 61 15 cp r22, r1 18f6: 71 05 cpc r23, r1 18f8: 19 f4 brne .+6 ; 0x1900 18fa: 20 e0 ldi r18, 0x00 ; 0 18fc: 30 e0 ldi r19, 0x00 ; 0 18fe: 37 c0 rjmp .+110 ; 0x196e 1900: 81 e0 ldi r24, 0x01 ; 1 1902: 90 e0 ldi r25, 0x00 ; 0 1904: 6e e0 ldi r22, 0x0E ; 14 1906: 70 e0 ldi r23, 0x00 ; 0 1908: 38 d0 rcall .+112 ; 0x197a 190a: fc 01 movw r30, r24 190c: 9c 01 movw r18, r24 190e: 00 97 sbiw r24, 0x00 ; 0 1910: 71 f1 breq .+92 ; 0x196e 1912: 80 e8 ldi r24, 0x80 ; 128 1914: 83 83 std Z+3, r24 ; 0x03 1916: 20 97 sbiw r28, 0x00 ; 0 1918: 71 f0 breq .+28 ; 0x1936 191a: d3 87 std Z+11, r29 ; 0x0b 191c: c2 87 std Z+10, r28 ; 0x0a 191e: 81 e8 ldi r24, 0x81 ; 129 1920: 83 83 std Z+3, r24 ; 0x03 1922: 80 91 96 03 lds r24, 0x0396 1926: 90 91 97 03 lds r25, 0x0397 192a: 89 2b or r24, r25 192c: 21 f4 brne .+8 ; 0x1936 192e: f0 93 97 03 sts 0x0397, r31 1932: e0 93 96 03 sts 0x0396, r30 1936: 01 15 cp r16, r1 1938: 11 05 cpc r17, r1 193a: c9 f0 breq .+50 ; 0x196e 193c: 11 87 std Z+9, r17 ; 0x09 193e: 00 87 std Z+8, r16 ; 0x08 1940: 83 81 ldd r24, Z+3 ; 0x03 1942: 82 60 ori r24, 0x02 ; 2 1944: 83 83 std Z+3, r24 ; 0x03 1946: 80 91 98 03 lds r24, 0x0398 194a: 90 91 99 03 lds r25, 0x0399 194e: 89 2b or r24, r25 1950: 71 f4 brne .+28 ; 0x196e 1952: f0 93 99 03 sts 0x0399, r31 1956: e0 93 98 03 sts 0x0398, r30 195a: 80 91 9a 03 lds r24, 0x039A 195e: 90 91 9b 03 lds r25, 0x039B 1962: 89 2b or r24, r25 1964: 21 f4 brne .+8 ; 0x196e 1966: f0 93 9b 03 sts 0x039B, r31 196a: e0 93 9a 03 sts 0x039A, r30 196e: c9 01 movw r24, r18 1970: df 91 pop r29 1972: cf 91 pop r28 1974: 1f 91 pop r17 1976: 0f 91 pop r16 1978: 08 95 ret 0000197a : 197a: 0f 93 push r16 197c: 1f 93 push r17 197e: cf 93 push r28 1980: df 93 push r29 1982: 68 9f mul r22, r24 1984: 80 01 movw r16, r0 1986: 69 9f mul r22, r25 1988: 10 0d add r17, r0 198a: 78 9f mul r23, r24 198c: 10 0d add r17, r0 198e: 11 24 eor r1, r1 1990: c8 01 movw r24, r16 1992: 0d d0 rcall .+26 ; 0x19ae 1994: ec 01 movw r28, r24 1996: 00 97 sbiw r24, 0x00 ; 0 1998: 21 f0 breq .+8 ; 0x19a2 199a: 60 e0 ldi r22, 0x00 ; 0 199c: 70 e0 ldi r23, 0x00 ; 0 199e: a8 01 movw r20, r16 19a0: 0b d1 rcall .+534 ; 0x1bb8 19a2: ce 01 movw r24, r28 19a4: df 91 pop r29 19a6: cf 91 pop r28 19a8: 1f 91 pop r17 19aa: 0f 91 pop r16 19ac: 08 95 ret 000019ae : 19ae: cf 93 push r28 19b0: df 93 push r29 19b2: bc 01 movw r22, r24 19b4: 82 30 cpi r24, 0x02 ; 2 19b6: 91 05 cpc r25, r1 19b8: 10 f4 brcc .+4 ; 0x19be 19ba: 62 e0 ldi r22, 0x02 ; 2 19bc: 70 e0 ldi r23, 0x00 ; 0 19be: a0 91 9e 03 lds r26, 0x039E 19c2: b0 91 9f 03 lds r27, 0x039F 19c6: ed 01 movw r28, r26 19c8: e0 e0 ldi r30, 0x00 ; 0 19ca: f0 e0 ldi r31, 0x00 ; 0 19cc: 40 e0 ldi r20, 0x00 ; 0 19ce: 50 e0 ldi r21, 0x00 ; 0 19d0: 21 c0 rjmp .+66 ; 0x1a14 19d2: 88 81 ld r24, Y 19d4: 99 81 ldd r25, Y+1 ; 0x01 19d6: 86 17 cp r24, r22 19d8: 97 07 cpc r25, r23 19da: 69 f4 brne .+26 ; 0x19f6 19dc: 8a 81 ldd r24, Y+2 ; 0x02 19de: 9b 81 ldd r25, Y+3 ; 0x03 19e0: 30 97 sbiw r30, 0x00 ; 0 19e2: 19 f0 breq .+6 ; 0x19ea 19e4: 93 83 std Z+3, r25 ; 0x03 19e6: 82 83 std Z+2, r24 ; 0x02 19e8: 04 c0 rjmp .+8 ; 0x19f2 19ea: 90 93 9f 03 sts 0x039F, r25 19ee: 80 93 9e 03 sts 0x039E, r24 19f2: fe 01 movw r30, r28 19f4: 34 c0 rjmp .+104 ; 0x1a5e 19f6: 68 17 cp r22, r24 19f8: 79 07 cpc r23, r25 19fa: 38 f4 brcc .+14 ; 0x1a0a 19fc: 41 15 cp r20, r1 19fe: 51 05 cpc r21, r1 1a00: 19 f0 breq .+6 ; 0x1a08 1a02: 84 17 cp r24, r20 1a04: 95 07 cpc r25, r21 1a06: 08 f4 brcc .+2 ; 0x1a0a 1a08: ac 01 movw r20, r24 1a0a: fe 01 movw r30, r28 1a0c: 8a 81 ldd r24, Y+2 ; 0x02 1a0e: 9b 81 ldd r25, Y+3 ; 0x03 1a10: 9c 01 movw r18, r24 1a12: e9 01 movw r28, r18 1a14: 20 97 sbiw r28, 0x00 ; 0 1a16: e9 f6 brne .-70 ; 0x19d2 1a18: 41 15 cp r20, r1 1a1a: 51 05 cpc r21, r1 1a1c: a9 f1 breq .+106 ; 0x1a88 1a1e: ca 01 movw r24, r20 1a20: 86 1b sub r24, r22 1a22: 97 0b sbc r25, r23 1a24: 04 97 sbiw r24, 0x04 ; 4 1a26: 08 f4 brcc .+2 ; 0x1a2a 1a28: ba 01 movw r22, r20 1a2a: e0 e0 ldi r30, 0x00 ; 0 1a2c: f0 e0 ldi r31, 0x00 ; 0 1a2e: 2a c0 rjmp .+84 ; 0x1a84 1a30: 8d 91 ld r24, X+ 1a32: 9c 91 ld r25, X 1a34: 11 97 sbiw r26, 0x01 ; 1 1a36: 84 17 cp r24, r20 1a38: 95 07 cpc r25, r21 1a3a: f9 f4 brne .+62 ; 0x1a7a 1a3c: 64 17 cp r22, r20 1a3e: 75 07 cpc r23, r21 1a40: 81 f4 brne .+32 ; 0x1a62 1a42: 12 96 adiw r26, 0x02 ; 2 1a44: 8d 91 ld r24, X+ 1a46: 9c 91 ld r25, X 1a48: 13 97 sbiw r26, 0x03 ; 3 1a4a: 30 97 sbiw r30, 0x00 ; 0 1a4c: 19 f0 breq .+6 ; 0x1a54 1a4e: 93 83 std Z+3, r25 ; 0x03 1a50: 82 83 std Z+2, r24 ; 0x02 1a52: 04 c0 rjmp .+8 ; 0x1a5c 1a54: 90 93 9f 03 sts 0x039F, r25 1a58: 80 93 9e 03 sts 0x039E, r24 1a5c: fd 01 movw r30, r26 1a5e: 32 96 adiw r30, 0x02 ; 2 1a60: 4f c0 rjmp .+158 ; 0x1b00 1a62: ca 01 movw r24, r20 1a64: 86 1b sub r24, r22 1a66: 97 0b sbc r25, r23 1a68: fd 01 movw r30, r26 1a6a: e8 0f add r30, r24 1a6c: f9 1f adc r31, r25 1a6e: 61 93 st Z+, r22 1a70: 71 93 st Z+, r23 1a72: 02 97 sbiw r24, 0x02 ; 2 1a74: 8d 93 st X+, r24 1a76: 9c 93 st X, r25 1a78: 43 c0 rjmp .+134 ; 0x1b00 1a7a: fd 01 movw r30, r26 1a7c: 82 81 ldd r24, Z+2 ; 0x02 1a7e: 93 81 ldd r25, Z+3 ; 0x03 1a80: 9c 01 movw r18, r24 1a82: d9 01 movw r26, r18 1a84: 10 97 sbiw r26, 0x00 ; 0 1a86: a1 f6 brne .-88 ; 0x1a30 1a88: 80 91 9c 03 lds r24, 0x039C 1a8c: 90 91 9d 03 lds r25, 0x039D 1a90: 89 2b or r24, r25 1a92: 41 f4 brne .+16 ; 0x1aa4 1a94: 80 91 73 00 lds r24, 0x0073 1a98: 90 91 74 00 lds r25, 0x0074 1a9c: 90 93 9d 03 sts 0x039D, r25 1aa0: 80 93 9c 03 sts 0x039C, r24 1aa4: 40 91 75 00 lds r20, 0x0075 1aa8: 50 91 76 00 lds r21, 0x0076 1aac: 41 15 cp r20, r1 1aae: 51 05 cpc r21, r1 1ab0: 41 f4 brne .+16 ; 0x1ac2 1ab2: 4d b7 in r20, 0x3d ; 61 1ab4: 5e b7 in r21, 0x3e ; 62 1ab6: 80 91 71 00 lds r24, 0x0071 1aba: 90 91 72 00 lds r25, 0x0072 1abe: 48 1b sub r20, r24 1ac0: 59 0b sbc r21, r25 1ac2: 20 91 9c 03 lds r18, 0x039C 1ac6: 30 91 9d 03 lds r19, 0x039D 1aca: 24 17 cp r18, r20 1acc: 35 07 cpc r19, r21 1ace: b0 f4 brcc .+44 ; 0x1afc 1ad0: ca 01 movw r24, r20 1ad2: 82 1b sub r24, r18 1ad4: 93 0b sbc r25, r19 1ad6: 86 17 cp r24, r22 1ad8: 97 07 cpc r25, r23 1ada: 80 f0 brcs .+32 ; 0x1afc 1adc: ab 01 movw r20, r22 1ade: 4e 5f subi r20, 0xFE ; 254 1ae0: 5f 4f sbci r21, 0xFF ; 255 1ae2: 84 17 cp r24, r20 1ae4: 95 07 cpc r25, r21 1ae6: 50 f0 brcs .+20 ; 0x1afc 1ae8: 42 0f add r20, r18 1aea: 53 1f adc r21, r19 1aec: 50 93 9d 03 sts 0x039D, r21 1af0: 40 93 9c 03 sts 0x039C, r20 1af4: f9 01 movw r30, r18 1af6: 61 93 st Z+, r22 1af8: 71 93 st Z+, r23 1afa: 02 c0 rjmp .+4 ; 0x1b00 1afc: e0 e0 ldi r30, 0x00 ; 0 1afe: f0 e0 ldi r31, 0x00 ; 0 1b00: cf 01 movw r24, r30 1b02: df 91 pop r29 1b04: cf 91 pop r28 1b06: 08 95 ret 00001b08 : 1b08: cf 93 push r28 1b0a: df 93 push r29 1b0c: 00 97 sbiw r24, 0x00 ; 0 1b0e: 09 f4 brne .+2 ; 0x1b12 1b10: 50 c0 rjmp .+160 ; 0x1bb2 1b12: ec 01 movw r28, r24 1b14: 22 97 sbiw r28, 0x02 ; 2 1b16: 1b 82 std Y+3, r1 ; 0x03 1b18: 1a 82 std Y+2, r1 ; 0x02 1b1a: a0 91 9e 03 lds r26, 0x039E 1b1e: b0 91 9f 03 lds r27, 0x039F 1b22: 10 97 sbiw r26, 0x00 ; 0 1b24: 09 f1 breq .+66 ; 0x1b68 1b26: 40 e0 ldi r20, 0x00 ; 0 1b28: 50 e0 ldi r21, 0x00 ; 0 1b2a: ac 17 cp r26, r28 1b2c: bd 07 cpc r27, r29 1b2e: 08 f1 brcs .+66 ; 0x1b72 1b30: bb 83 std Y+3, r27 ; 0x03 1b32: aa 83 std Y+2, r26 ; 0x02 1b34: fe 01 movw r30, r28 1b36: 21 91 ld r18, Z+ 1b38: 31 91 ld r19, Z+ 1b3a: e2 0f add r30, r18 1b3c: f3 1f adc r31, r19 1b3e: ae 17 cp r26, r30 1b40: bf 07 cpc r27, r31 1b42: 79 f4 brne .+30 ; 0x1b62 1b44: 8d 91 ld r24, X+ 1b46: 9c 91 ld r25, X 1b48: 11 97 sbiw r26, 0x01 ; 1 1b4a: 28 0f add r18, r24 1b4c: 39 1f adc r19, r25 1b4e: 2e 5f subi r18, 0xFE ; 254 1b50: 3f 4f sbci r19, 0xFF ; 255 1b52: 39 83 std Y+1, r19 ; 0x01 1b54: 28 83 st Y, r18 1b56: 12 96 adiw r26, 0x02 ; 2 1b58: 8d 91 ld r24, X+ 1b5a: 9c 91 ld r25, X 1b5c: 13 97 sbiw r26, 0x03 ; 3 1b5e: 9b 83 std Y+3, r25 ; 0x03 1b60: 8a 83 std Y+2, r24 ; 0x02 1b62: 41 15 cp r20, r1 1b64: 51 05 cpc r21, r1 1b66: 71 f4 brne .+28 ; 0x1b84 1b68: d0 93 9f 03 sts 0x039F, r29 1b6c: c0 93 9e 03 sts 0x039E, r28 1b70: 20 c0 rjmp .+64 ; 0x1bb2 1b72: 12 96 adiw r26, 0x02 ; 2 1b74: 8d 91 ld r24, X+ 1b76: 9c 91 ld r25, X 1b78: 13 97 sbiw r26, 0x03 ; 3 1b7a: ad 01 movw r20, r26 1b7c: 00 97 sbiw r24, 0x00 ; 0 1b7e: 11 f0 breq .+4 ; 0x1b84 1b80: dc 01 movw r26, r24 1b82: d3 cf rjmp .-90 ; 0x1b2a 1b84: fa 01 movw r30, r20 1b86: d3 83 std Z+3, r29 ; 0x03 1b88: c2 83 std Z+2, r28 ; 0x02 1b8a: 21 91 ld r18, Z+ 1b8c: 31 91 ld r19, Z+ 1b8e: e2 0f add r30, r18 1b90: f3 1f adc r31, r19 1b92: ce 17 cp r28, r30 1b94: df 07 cpc r29, r31 1b96: 69 f4 brne .+26 ; 0x1bb2 1b98: 88 81 ld r24, Y 1b9a: 99 81 ldd r25, Y+1 ; 0x01 1b9c: 28 0f add r18, r24 1b9e: 39 1f adc r19, r25 1ba0: 2e 5f subi r18, 0xFE ; 254 1ba2: 3f 4f sbci r19, 0xFF ; 255 1ba4: fa 01 movw r30, r20 1ba6: 31 83 std Z+1, r19 ; 0x01 1ba8: 20 83 st Z, r18 1baa: 8a 81 ldd r24, Y+2 ; 0x02 1bac: 9b 81 ldd r25, Y+3 ; 0x03 1bae: 93 83 std Z+3, r25 ; 0x03 1bb0: 82 83 std Z+2, r24 ; 0x02 1bb2: df 91 pop r29 1bb4: cf 91 pop r28 1bb6: 08 95 ret 00001bb8 : 1bb8: dc 01 movw r26, r24 1bba: 01 c0 rjmp .+2 ; 0x1bbe 1bbc: 6d 93 st X+, r22 1bbe: 41 50 subi r20, 0x01 ; 1 1bc0: 50 40 sbci r21, 0x00 ; 0 1bc2: e0 f7 brcc .-8 ; 0x1bbc 1bc4: 08 95 ret 00001bc6 <_exit>: 1bc6: f8 94 cli 00001bc8 <__stop_program>: 1bc8: ff cf rjmp .-2 ; 0x1bc8 <__stop_program>