: #include "timer.h" #include "UartPrintF.h" int main(void) { d0: cf e5 ldi r28, 0x5F ; 95 d2: d4 e0 ldi r29, 0x04 ; 4 d4: de bf out 0x3e, r29 ; 62 d6: cd bf out 0x3d, r28 ; 61 double a1=1.234, a2=2.756, a=0.0; int i; u16 a16; u08 data; u16 ticks1,ticks2; /* timer 1 ticks needed for sqrt */ timer_init(); /* init timer1 */ d8: 0e 94 73 01 call 0x2e6 /* Initialise UART */ UART_Init(); dc: 0e 94 61 01 call 0x2c2 PRINT("Hello World !"); e0: 84 e5 ldi r24, 0x54 ; 84 e2: 90 e0 ldi r25, 0x00 ; 0 e4: 0e 94 15 01 call 0x22a EOL(); e8: 0e 94 23 01 call 0x246 for (;;) { /* loop forever */ UartPrintF("Press any key..."); ec: 80 e6 ldi r24, 0x60 ; 96 ee: 90 e0 ldi r25, 0x00 ; 0 f0: 9f 93 push r25 f2: 8f 93 push r24 f4: 0e 94 7a 01 call 0x2f4 EOL(); f8: 0e 94 23 01 call 0x246 ticks1 = TCNT1; /* start measurement */ fc: ec b4 in r14, 0x2c ; 44 fe: fd b4 in r15, 0x2d ; 45 //UartPrintF("Ticks1? %u\r\n",ticks1); //for(i=0;i<1000;i++) a = a1 * a2; a16 = (unsigned int)(a*1000); ticks2 = TCNT1; /* start measurement */ 100: 0c b5 in r16, 0x2c ; 44 102: 1d b5 in r17, 0x2d ; 45 UartPrintF("a16? %u\r\n",a16); 104: 88 e4 ldi r24, 0x48 ; 72 106: 9d e0 ldi r25, 0x0D ; 13 108: a0 e0 ldi r26, 0x00 ; 0 10a: b0 e0 ldi r27, 0x00 ; 0 10c: 9f 93 push r25 10e: 8f 93 push r24 110: 81 e7 ldi r24, 0x71 ; 113 112: 90 e0 ldi r25, 0x00 ; 0 114: 9f 93 push r25 116: 8f 93 push r24 118: 0e 94 7a 01 call 0x2f4 UartPrintF("Ticks1? %u\r\n",ticks1); 11c: ff 92 push r15 11e: ef 92 push r14 120: 8b e7 ldi r24, 0x7B ; 123 122: 90 e0 ldi r25, 0x00 ; 0 124: 9f 93 push r25 126: 8f 93 push r24 128: 0e 94 7a 01 call 0x2f4 UartPrintF("Ticks2? %u\r\n",ticks2); 12c: 1f 93 push r17 12e: 0f 93 push r16 130: 88 e8 ldi r24, 0x88 ; 136 132: 90 e0 ldi r25, 0x00 ; 0 134: 9f 93 push r25 136: 8f 93 push r24 138: 0e 94 7a 01 call 0x2f4 UartPrintF("dTicks? %u us\r\n",(ticks2-ticks1)/4); 13c: 0e 19 sub r16, r14 13e: 1f 09 sbc r17, r15 140: 16 95 lsr r17 142: 07 95 ror r16 144: 16 95 lsr r17 146: 07 95 ror r16 148: 1f 93 push r17 14a: 0f 93 push r16 14c: 85 e9 ldi r24, 0x95 ; 149 14e: 90 e0 ldi r25, 0x00 ; 0 150: 9f 93 push r25 152: 8f 93 push r24 154: 0e 94 7a 01 call 0x2f4 data = UART_ReceiveByte(); 158: 0e 94 0b 01 call 0x216 15c: 18 2f mov r17, r24 PRINT(" -> You pressed '"); 15e: 8d b7 in r24, 0x3d ; 61 160: 9e b7 in r25, 0x3e ; 62 162: 42 96 adiw r24, 0x12 ; 18 164: 0f b6 in r0, 0x3f ; 63 166: f8 94 cli 168: 9e bf out 0x3e, r25 ; 62 16a: 0f be out 0x3f, r0 ; 63 16c: 8d bf out 0x3d, r24 ; 61 16e: 82 e6 ldi r24, 0x62 ; 98 170: 90 e0 ldi r25, 0x00 ; 0 172: 0e 94 15 01 call 0x22a UART_SendByte(data); 176: 81 2f mov r24, r17 178: 0e 94 02 01 call 0x204 PRINT("' which is 0x"); 17c: 84 e7 ldi r24, 0x74 ; 116 17e: 90 e0 ldi r25, 0x00 ; 0 180: 0e 94 15 01 call 0x22a UART_Printfu08(data); 184: 81 2f mov r24, r17 186: 0e 94 3b 01 call 0x276 PRINT(" in hexadecimal."); 18a: 82 e8 ldi r24, 0x82 ; 130 18c: 90 e0 ldi r25, 0x00 ; 0 18e: aa cf rjmp .-172 ; 0xe4 00000190 <__vector_13>: prog_char UART_pszEndOfLine[3] = {0x0d,0x0a,0}; /* UART Transmit Complete Interrupt Function */ SIGNAL(SIG_UART_TRANS) { 190: 1f 92 push r1 192: 0f 92 push r0 194: 0f b6 in r0, 0x3f ; 63 196: 0f 92 push r0 198: 11 24 eor r1, r1 19a: 8f 93 push r24 19c: ef 93 push r30 19e: ff 93 push r31 /* Test if a string is being sent */ if (pUART_Buffer!=0) 1a0: e0 91 ac 00 lds r30, 0x00AC 1a4: f0 91 ad 00 lds r31, 0x00AD 1a8: 30 97 sbiw r30, 0x00 ; 0 1aa: 79 f0 breq .+30 ; 0x1ca { /* Go to next character in string */ pUART_Buffer++; 1ac: 31 96 adiw r30, 0x01 ; 1 1ae: f0 93 ad 00 sts 0x00AD, r31 1b2: e0 93 ac 00 sts 0x00AC, r30 /* Test if the end of string has been reached */ if (PRG_RDB(pUART_Buffer)==0) 1b6: e4 91 lpm r30, Z 1b8: ee 23 and r30, r30 1ba: 29 f4 brne .+10 ; 0x1c6 { /* String has been sent */ pUART_Buffer = 0; 1bc: 10 92 ad 00 sts 0x00AD, r1 1c0: 10 92 ac 00 sts 0x00AC, r1 /* Indicate that the UART is now ready to send */ UART_Ready = 1; 1c4: 02 c0 rjmp .+4 ; 0x1ca return; } /* Send next character in string */ outp( PRG_RDB(pUART_Buffer), UDR ); 1c6: ec b9 out 0x0c, r30 ; 12 return; 1c8: 03 c0 rjmp .+6 ; 0x1d0 } /* Indicate that the UART is now ready to send */ UART_Ready = 1; 1ca: 81 e0 ldi r24, 0x01 ; 1 1cc: 80 93 ab 00 sts 0x00AB, r24 } 1d0: ff 91 pop r31 1d2: ef 91 pop r30 1d4: 8f 91 pop r24 1d6: 0f 90 pop r0 1d8: 0f be out 0x3f, r0 ; 63 1da: 0f 90 pop r0 1dc: 1f 90 pop r1 1de: 18 95 reti 000001e0 <__vector_11>: /* UART Receive Complete Interrupt Function */ SIGNAL(SIG_UART_RECV) { 1e0: 1f 92 push r1 1e2: 0f 92 push r0 1e4: 0f b6 in r0, 0x3f ; 63 1e6: 0f 92 push r0 1e8: 11 24 eor r1, r1 1ea: 8f 93 push r24 /* Indicate that the UART has received a character */ UART_ReceivedChar = 1; 1ec: 81 e0 ldi r24, 0x01 ; 1 1ee: 80 93 aa 00 sts 0x00AA, r24 /* Store received character */ UART_RxChar = inp(UDR); 1f2: 8c b1 in r24, 0x0c ; 12 1f4: 80 93 ae 00 sts 0x00AE, r24 } 1f8: 8f 91 pop r24 1fa: 0f 90 pop r0 1fc: 0f be out 0x3f, r0 ; 63 1fe: 0f 90 pop r0 200: 1f 90 pop r1 202: 18 95 reti 00000204 : void UART_SendByte(u08 Data) { 204: 98 2f mov r25, r24 /* wait for UART to become available */ while(!UART_Ready); 206: 80 91 ab 00 lds r24, 0x00AB 20a: 88 23 and r24, r24 20c: e1 f3 breq .-8 ; 0x206 UART_Ready = 0; 20e: 10 92 ab 00 sts 0x00AB, r1 /* Send character */ outp( Data, UDR ); 212: 9c b9 out 0x0c, r25 ; 12 } 214: 08 95 ret 00000216 : u08 UART_ReceiveByte(void) { /* wait for UART to indicate that a character has been received */ while(!UART_ReceivedChar); 216: 80 91 aa 00 lds r24, 0x00AA 21a: 88 23 and r24, r24 21c: e1 f3 breq .-8 ; 0x216 UART_ReceivedChar = 0; 21e: 10 92 aa 00 sts 0x00AA, r1 /* read byte from UART data buffer */ return UART_RxChar; 222: 80 91 ae 00 lds r24, 0x00AE 226: 99 27 eor r25, r25 } 228: 08 95 ret 0000022a : void UART_PrintfProgStr(u08* pBuf) { 22a: fc 01 movw r30, r24 /* wait for UART to become available */ while(!UART_Ready); 22c: 80 91 ab 00 lds r24, 0x00AB 230: 88 23 and r24, r24 232: e1 f3 breq .-8 ; 0x22c UART_Ready = 0; 234: 10 92 ab 00 sts 0x00AB, r1 /* Indicate to ISR the string to be sent */ pUART_Buffer = pBuf; 238: f0 93 ad 00 sts 0x00AD, r31 23c: e0 93 ac 00 sts 0x00AC, r30 /* Send first character */ outp( PRG_RDB(pUART_Buffer), UDR ); 240: 84 91 lpm r24, Z 242: 8c b9 out 0x0c, r24 ; 12 } 244: 08 95 ret 00000246 : void UART_PrintfEndOfLine(void) { /* wait for UART to become available */ while(!UART_Ready); 246: 80 91 ab 00 lds r24, 0x00AB 24a: 88 23 and r24, r24 24c: e1 f3 breq .-8 ; 0x246 UART_Ready = 0; 24e: 10 92 ab 00 sts 0x00AB, r1 /* Indicate to ISR the string to be sent */ pUART_Buffer = UART_pszEndOfLine; 252: e3 e9 ldi r30, 0x93 ; 147 254: f0 e0 ldi r31, 0x00 ; 0 256: f0 93 ad 00 sts 0x00AD, r31 25a: e0 93 ac 00 sts 0x00AC, r30 /* Send first character */ outp( PRG_RDB(pUART_Buffer), UDR ); 25e: 84 91 lpm r24, Z 260: 8c b9 out 0x0c, r24 ; 12 } 262: 08 95 ret 00000264 : void UART_PrintfU4(u08 Data) { /* Send 4-bit hex value */ u08 Character = Data&0x0f; 264: 8f 70 andi r24, 0x0F ; 15 if (Character>9) 266: 8a 30 cpi r24, 0x0A ; 10 268: 10 f0 brcs .+4 ; 0x26e { Character+='A'-10; 26a: 89 5c subi r24, 0xC9 ; 201 26c: 01 c0 rjmp .+2 ; 0x270 } else { Character+='0'; 26e: 80 5d subi r24, 0xD0 ; 208 } UART_SendByte(Character); 270: 0e 94 02 01 call 0x204 } 274: 08 95 ret 00000276 : void UART_Printfu08(u08 Data) { 276: 1f 93 push r17 278: 18 2f mov r17, r24 /* Send 8-bit hex value */ UART_PrintfU4(Data>>4); 27a: 82 95 swap r24 27c: 8f 70 andi r24, 0x0F ; 15 27e: 0e 94 32 01 call 0x264 UART_PrintfU4(Data ); 282: 81 2f mov r24, r17 284: 0e 94 32 01 call 0x264 } 288: 1f 91 pop r17 28a: 08 95 ret 0000028c : void UART_Printfu16(u16 Data) { 28c: 0f 93 push r16 28e: 1f 93 push r17 290: 8c 01 movw r16, r24 /* Send 16-bit hex value */ UART_PrintfU4(Data>>12); 292: 89 2f mov r24, r25 294: 99 27 eor r25, r25 296: 82 95 swap r24 298: 8f 70 andi r24, 0x0F ; 15 29a: 0e 94 32 01 call 0x264 UART_PrintfU4(Data>> 8); 29e: 81 2f mov r24, r17 2a0: 99 27 eor r25, r25 2a2: 0e 94 32 01 call 0x264 UART_PrintfU4(Data>> 4); 2a6: c8 01 movw r24, r16 2a8: 24 e0 ldi r18, 0x04 ; 4 2aa: 96 95 lsr r25 2ac: 87 95 ror r24 2ae: 2a 95 dec r18 2b0: e1 f7 brne .-8 ; 0x2aa 2b2: 0e 94 32 01 call 0x264 UART_PrintfU4(Data ); 2b6: 80 2f mov r24, r16 2b8: 0e 94 32 01 call 0x264 } 2bc: 1f 91 pop r17 2be: 0f 91 pop r16 2c0: 08 95 ret 000002c2 : /* void UART_Init(void) { UART_Ready = 1; UART_ReceivedChar = 0; pUART_Buffer = 0; // enable RxD/TxD and interrupts //outp(BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN),UCSRB); UCSRB = (1<>8); 2d4: 10 bc out 0x20, r1 ; 32 UBRRL = (unsigned char)UART_BAUD_SELECT; 2d6: 89 e1 ldi r24, 0x19 ; 25 2d8: 89 b9 out 0x09, r24 ; 9 /* Enable receiver and transmitter */ UCSRB = (1<: void timer_init(void) /* initialize timer 1 */ { outp(0, TIMSK); /* disable timer interrupts */ 2e6: 19 be out 0x39, r1 ; 57 outp(0, TCCR1A); /* disable PWM and stuff */ 2e8: 1f bc out 0x2f, r1 ; 47 outp(0, TCNT1H); /* reset TCNT1 */ 2ea: 1d bc out 0x2d, r1 ; 45 outp(0, TCNT1L); /* reset TCNT1 */ 2ec: 1c bc out 0x2c, r1 ; 44 outp(PRSC1_SELECT, TCCR1B); /* count with cpu clock/PRSC1 */ 2ee: 81 e0 ldi r24, 0x01 ; 1 2f0: 8e bd out 0x2e, r24 ; 46 } 2f2: 08 95 ret 000002f4 : Ein Zahlenwert nach dem % bzw. dem - gibt die Breite des Ausgabefeldes an. Die Ausgabe erfolgt falls notwendig auch mit mehr Zeichen. */ { 2f4: bf 92 push r11 2f6: cf 92 push r12 2f8: df 92 push r13 2fa: ef 92 push r14 2fc: ff 92 push r15 2fe: 0f 93 push r16 300: 1f 93 push r17 302: cf 93 push r28 304: df 93 push r29 306: cd b7 in r28, 0x3d ; 61 308: de b7 in r29, 0x3e ; 62 30a: 61 97 sbiw r28, 0x11 ; 17 30c: 0f b6 in r0, 0x3f ; 63 30e: f8 94 cli 310: de bf out 0x3e, r29 ; 62 312: 0f be out 0x3f, r0 ; 63 314: cd bf out 0x3d, r28 ; 61 316: 6d e1 ldi r22, 0x1D ; 29 318: e6 2e mov r14, r22 31a: f1 2c mov r15, r1 31c: ec 0e add r14, r28 31e: fd 1e adc r15, r29 320: d7 01 movw r26, r14 322: 0d 91 ld r16, X+ 324: 1d 91 ld r17, X+ 326: 7d 01 movw r14, r26 #define SCRATCH 16 BYTE scratch[SCRATCH]; BYTE format_flag; WORD u_val=0, base; BYTE *ptr; va_list ap; BYTE hexA = 'a'; 328: 51 e6 ldi r21, 0x61 ; 97 32a: b5 2e mov r11, r21 nSent = 0; 32c: 10 92 a7 00 sts 0x00A7, r1 330: 10 92 a6 00 sts 0x00A6, r1 va_start (ap, format); for (;;) { /* In der folgenden Schleife werden alle Zeichen direkt weitergegeben, sofern es sich nicht um ein Platzhalterzeichen '%' handelt. */ while ((format_flag = *format++) != '%') { 334: f8 01 movw r30, r16 336: 81 91 ld r24, Z+ 338: 8f 01 movw r16, r30 33a: 89 8b std Y+17, r24 ; 0x11 33c: 85 32 cpi r24, 0x25 ; 37 33e: 61 f0 breq .+24 ; 0x358 if (!format_flag) { // Ende des Formatstrings erreicht 340: 89 89 ldd r24, Y+17 ; 0x11 342: 88 23 and r24, r24 344: 09 f4 brne .+2 ; 0x348 346: bc c0 rjmp .+376 ; 0x4c0 va_end (ap); return (nSent); } // Ende des Strings noch nicht erreicht // und kein Platzhalterzeichen, also ausgeben UartWrite (format_flag); 348: 0e 94 c6 02 call 0x58c 34c: d8 01 movw r26, r16 34e: 8d 91 ld r24, X+ 350: 8d 01 movw r16, r26 352: 89 8b std Y+17, r24 ; 0x11 354: 85 32 cpi r24, 0x25 ; 37 356: a1 f7 brne .-24 ; 0x340 } // Mit %10s kann beispielsweise ein 4 Zeichen langer String in // einem 10 Zeichen langen Feld ausgegeben werden. Zus�tzlich // kann mit einem - Zeichen die Ausrichtung angegeben werden. // UartPrintF ("%10s", "Hallo") ergibt " Hallo" // UartPrintF ("%-10s", "Hallo") ergibt "Hallo " // Desweiteren kann mit %05d angegeben werden, dass ein Zahlwenwert // in einem rechtsb�ndigen Feld der L�nge 5 ausgegeben wird wobei // links mit Nullen aufgef�llt wird. format_flag = *format++; 358: f8 01 movw r30, r16 35a: 81 91 ld r24, Z+ 35c: 8f 01 movw r16, r30 35e: 89 8b std Y+17, r24 ; 0x11 if (format_flag == '-') { 360: 90 91 a9 00 lds r25, 0x00A9 364: 8d 32 cpi r24, 0x2D ; 45 366: 41 f4 brne .+16 ; 0x378 flags.fLeftJust = 1; 368: 91 60 ori r25, 0x01 ; 1 36a: 90 93 a9 00 sts 0x00A9, r25 format_flag = *format++; 36e: df 01 movw r26, r30 370: 8d 91 ld r24, X+ 372: 8d 01 movw r16, r26 374: 89 8b std Y+17, r24 ; 0x11 376: 03 c0 rjmp .+6 ; 0x37e } else flags.fLeftJust = 0; 378: 9e 7f andi r25, 0xFE ; 254 37a: 90 93 a9 00 sts 0x00A9, r25 nFieldWidth = 0; 37e: 10 92 a8 00 sts 0x00A8, r1 while (format_flag >= '0' && format_flag <= '9') { 382: 29 89 ldd r18, Y+17 ; 0x11 384: 82 2f mov r24, r18 386: 80 53 subi r24, 0x30 ; 48 388: 8a 30 cpi r24, 0x0A ; 10 38a: 98 f4 brcc .+38 ; 0x3b2 nFieldWidth *= 10; 38c: 90 91 a8 00 lds r25, 0x00A8 nFieldWidth += format_flag - '0'; 390: 8a e0 ldi r24, 0x0A ; 10 392: 98 9f mul r25, r24 394: 80 2d mov r24, r0 396: 11 24 eor r1, r1 398: 82 0f add r24, r18 39a: 80 53 subi r24, 0x30 ; 48 39c: 80 93 a8 00 sts 0x00A8, r24 format_flag = *format++; 3a0: f8 01 movw r30, r16 3a2: 91 91 ld r25, Z+ 3a4: 8f 01 movw r16, r30 3a6: 29 2f mov r18, r25 3a8: 89 2f mov r24, r25 3aa: 80 53 subi r24, 0x30 ; 48 3ac: 8a 30 cpi r24, 0x0A ; 10 3ae: 70 f3 brcs .-36 ; 0x38c 3b0: 99 8b std Y+17, r25 ; 0x11 } switch (format_flag) { 3b2: 29 89 ldd r18, Y+17 ; 0x11 3b4: 82 2f mov r24, r18 3b6: 99 27 eor r25, r25 3b8: 89 36 cpi r24, 0x69 ; 105 3ba: 91 05 cpc r25, r1 3bc: d1 f1 breq .+116 ; 0x432 3be: 8a 36 cpi r24, 0x6A ; 106 3c0: 91 05 cpc r25, r1 3c2: 74 f4 brge .+28 ; 0x3e0 3c4: 83 36 cpi r24, 0x63 ; 99 3c6: 91 05 cpc r25, r1 3c8: e1 f0 breq .+56 ; 0x402 3ca: 84 36 cpi r24, 0x64 ; 100 3cc: 91 05 cpc r25, r1 3ce: 24 f4 brge .+8 ; 0x3d8 3d0: 88 35 cpi r24, 0x58 ; 88 3d2: 91 05 cpc r25, r1 3d4: 91 f1 breq .+100 ; 0x43a 3d6: 1c c0 rjmp .+56 ; 0x410 3d8: 84 36 cpi r24, 0x64 ; 100 3da: 91 05 cpc r25, r1 3dc: 51 f1 breq .+84 ; 0x432 3de: 18 c0 rjmp .+48 ; 0x410 3e0: 83 37 cpi r24, 0x73 ; 115 3e2: 91 05 cpc r25, r1 3e4: d1 f0 breq .+52 ; 0x41a 3e6: 84 37 cpi r24, 0x74 ; 116 3e8: 91 05 cpc r25, r1 3ea: 24 f4 brge .+8 ; 0x3f4 3ec: 8f 36 cpi r24, 0x6F ; 111 3ee: 91 05 cpc r25, r1 3f0: e1 f0 breq .+56 ; 0x42a 3f2: 0e c0 rjmp .+28 ; 0x410 3f4: 85 37 cpi r24, 0x75 ; 117 3f6: 91 05 cpc r25, r1 3f8: e1 f0 breq .+56 ; 0x432 3fa: 88 37 cpi r24, 0x78 ; 120 3fc: 91 05 cpc r25, r1 3fe: f9 f0 breq .+62 ; 0x43e 400: 07 c0 rjmp .+14 ; 0x410 case 'c': format_flag = va_arg (ap, int); 402: f7 01 movw r30, r14 404: 82 e0 ldi r24, 0x02 ; 2 406: 90 e0 ldi r25, 0x00 ; 0 408: e8 0e add r14, r24 40a: f9 1e adc r15, r25 40c: 80 81 ld r24, Z 40e: 89 8b std Y+17, r24 ; 0x11 default: UartWriteBuf (&format_flag, 1); 410: 61 e0 ldi r22, 0x01 ; 1 412: 70 e0 ldi r23, 0x00 ; 0 414: ce 01 movw r24, r28 416: 41 96 adiw r24, 0x11 ; 17 418: 50 c0 rjmp .+160 ; 0x4ba continue; case 's': ptr = va_arg (ap, char *); 41a: f7 01 movw r30, r14 41c: a2 e0 ldi r26, 0x02 ; 2 41e: b0 e0 ldi r27, 0x00 ; 0 420: ea 0e add r14, r26 422: fb 1e adc r15, r27 424: 20 81 ld r18, Z 426: 31 81 ldd r19, Z+1 ; 0x01 UartWriteBuf (ptr, -1); 428: 45 c0 rjmp .+138 ; 0x4b4 continue; case 'o': base = 8; 42a: 48 e0 ldi r20, 0x08 ; 8 42c: c4 2e mov r12, r20 42e: d1 2c mov r13, r1 goto CONVERSION_LOOP; 430: 09 c0 rjmp .+18 ; 0x444 case 'i': case 'd': case 'u': base = 10; 432: 3a e0 ldi r19, 0x0A ; 10 434: c3 2e mov r12, r19 436: d1 2c mov r13, r1 goto CONVERSION_LOOP; 438: 05 c0 rjmp .+10 ; 0x444 case 'X': hexA = 'A'; 43a: 91 e4 ldi r25, 0x41 ; 65 43c: b9 2e mov r11, r25 // Weiter wie 'x' case 'x': base = 16; 43e: 80 e1 ldi r24, 0x10 ; 16 440: c8 2e mov r12, r24 442: d1 2c mov r13, r1 CONVERSION_LOOP: u_val = va_arg (ap, int); 444: f7 01 movw r30, r14 446: 82 e0 ldi r24, 0x02 ; 2 448: 90 e0 ldi r25, 0x00 ; 0 44a: e8 0e add r14, r24 44c: f9 1e adc r15, r25 44e: 01 90 ld r0, Z+ 450: f0 81 ld r31, Z 452: e0 2d mov r30, r0 flags.fNegative = 0; 454: 80 91 a9 00 lds r24, 0x00A9 458: 8d 7f andi r24, 0xFD ; 253 45a: 80 93 a9 00 sts 0x00A9, r24 if (format_flag == 'd' || format_flag == 'i') { 45e: 24 36 cpi r18, 0x64 ; 100 460: 11 f0 breq .+4 ; 0x466 462: 29 36 cpi r18, 0x69 ; 105 464: 41 f4 brne .+16 ; 0x476 // Negative Werte auswerten if (((int) u_val) < 0) { 466: f7 ff sbrs r31, 7 468: 06 c0 rjmp .+12 ; 0x476 flags.fNegative = 1; 46a: 82 60 ori r24, 0x02 ; 2 46c: 80 93 a9 00 sts 0x00A9, r24 u_val = -u_val; 470: f0 95 com r31 472: e1 95 neg r30 474: ff 4f sbci r31, 0xFF ; 255 } } // Der Scratchpuffer wird von rechts nach links aufgef�llt // beginnend mit dem niederwertigsten Digit. ptr = scratch + SCRATCH; *--ptr = 0; // Abschliessendes NULL-Byte eintragen 476: 9e 01 movw r18, r28 478: 20 5f subi r18, 0xF0 ; 240 47a: 3f 4f sbci r19, 0xFF ; 255 47c: 18 8a std Y+16, r1 ; 0x10 do { char ch = u_val % base + '0'; 47e: cf 01 movw r24, r30 480: b6 01 movw r22, r12 482: 0e 94 d3 02 call 0x5a6 486: 80 5d subi r24, 0xD0 ; 208 if (ch > '9') ch += hexA - '9' - 1; 488: 8a 33 cpi r24, 0x3A ; 58 48a: 10 f0 brcs .+4 ; 0x490 48c: 8b 0d add r24, r11 48e: 8a 53 subi r24, 0x3A ; 58 *--ptr = ch; 490: d9 01 movw r26, r18 492: 8e 93 st -X, r24 494: 9d 01 movw r18, r26 u_val /= base; 496: cf 01 movw r24, r30 498: b6 01 movw r22, r12 49a: 0e 94 d3 02 call 0x5a6 49e: fb 01 movw r30, r22 } while (u_val); 4a0: 67 2b or r22, r23 4a2: 69 f7 brne .-38 ; 0x47e if (flags.fNegative) *--ptr = '-'; 4a4: 80 91 a9 00 lds r24, 0x00A9 4a8: 81 ff sbrs r24, 1 4aa: 04 c0 rjmp .+8 ; 0x4b4 4ac: 8d e2 ldi r24, 0x2D ; 45 4ae: f9 01 movw r30, r18 4b0: 82 93 st -Z, r24 4b2: 9f 01 movw r18, r30 UartWriteBuf (ptr, -1); // Scratchpuffer ausgeben 4b4: 6f ef ldi r22, 0xFF ; 255 4b6: 7f ef ldi r23, 0xFF ; 255 4b8: c9 01 movw r24, r18 4ba: 0e 94 74 02 call 0x4e8 4be: 3a cf rjmp .-396 ; 0x334 } } } /* end of UartPrintF */ 4c0: 80 91 a6 00 lds r24, 0x00A6 4c4: 90 91 a7 00 lds r25, 0x00A7 4c8: 61 96 adiw r28, 0x11 ; 17 4ca: 0f b6 in r0, 0x3f ; 63 4cc: f8 94 cli 4ce: de bf out 0x3e, r29 ; 62 4d0: 0f be out 0x3f, r0 ; 63 4d2: cd bf out 0x3d, r28 ; 61 4d4: df 91 pop r29 4d6: cf 91 pop r28 4d8: 1f 91 pop r17 4da: 0f 91 pop r16 4dc: ff 90 pop r15 4de: ef 90 pop r14 4e0: df 90 pop r13 4e2: cf 90 pop r12 4e4: bf 90 pop r11 4e6: 08 95 ret 000004e8 : static void UartWriteBuf (BYTE *pBuf, int nLen) /********************************************************************** Schreibt einen Puffer auf den UART. Dabei werden die Feldbreite und -ausrichtung ber�cksichtigt. in : pBuf Adresse der auszugebenden Daten. in : nLen Anzahl auszugebende Zeichen. Wird hier -1 angegeben so wird ausgegeben bis ein NULL-Zeichen gefunden wird. */ { 4e8: ef 92 push r14 4ea: ff 92 push r15 4ec: 0f 93 push r16 4ee: 1f 93 push r17 4f0: cf 93 push r28 4f2: df 93 push r29 4f4: 7c 01 movw r14, r24 4f6: 8b 01 movw r16, r22 BYTE *p; int n; if (nLen == -1) { 4f8: 6f 5f subi r22, 0xFF ; 255 4fa: 7f 4f sbci r23, 0xFF ; 255 4fc: 59 f4 brne .+22 ; 0x514 // L�nge bestimmen p = pBuf; nLen = 0; 4fe: 00 e0 ldi r16, 0x00 ; 0 500: 10 e0 ldi r17, 0x00 ; 0 while (*p++) nLen++; 502: f7 01 movw r30, r14 504: 81 91 ld r24, Z+ 506: 88 23 and r24, r24 508: 29 f0 breq .+10 ; 0x514 50a: 0f 5f subi r16, 0xFF ; 255 50c: 1f 4f sbci r17, 0xFF ; 255 50e: 81 91 ld r24, Z+ 510: 88 23 and r24, r24 512: d9 f7 brne .-10 ; 0x50a } // Feld bei Bedarf links auff�llen if (!flags.fLeftJust) { 514: 80 91 a9 00 lds r24, 0x00A9 518: 80 fd sbrc r24, 0 51a: 11 c0 rjmp .+34 ; 0x53e for (n=nLen; n < nFieldWidth; n++) UartWrite (' '); 51c: e8 01 movw r28, r16 51e: 80 91 a8 00 lds r24, 0x00A8 522: 99 27 eor r25, r25 524: 08 17 cp r16, r24 526: 19 07 cpc r17, r25 528: 54 f4 brge .+20 ; 0x53e 52a: 80 e2 ldi r24, 0x20 ; 32 52c: 0e 94 c6 02 call 0x58c 530: 21 96 adiw r28, 0x01 ; 1 532: 80 91 a8 00 lds r24, 0x00A8 536: 99 27 eor r25, r25 538: c8 17 cp r28, r24 53a: d9 07 cpc r29, r25 53c: b4 f3 brlt .-20 ; 0x52a } // Pufferinhalt schreiben for (n=0; n < nLen; n++) UartWrite (*pBuf++); 53e: 10 16 cp r1, r16 540: 11 06 cpc r1, r17 542: 44 f4 brge .+16 ; 0x554 544: e8 01 movw r28, r16 546: f7 01 movw r30, r14 548: 81 91 ld r24, Z+ 54a: 7f 01 movw r14, r30 54c: 0e 94 c6 02 call 0x58c 550: 21 97 sbiw r28, 0x01 ; 1 552: c9 f7 brne .-14 ; 0x546 // Feld bei Bedarf rechts auff�llen if (flags.fLeftJust) { 554: 80 91 a9 00 lds r24, 0x00A9 558: 80 ff sbrs r24, 0 55a: 11 c0 rjmp .+34 ; 0x57e for (n=nLen; n < nFieldWidth; n++) UartWrite (' '); 55c: e8 01 movw r28, r16 55e: 80 91 a8 00 lds r24, 0x00A8 562: 99 27 eor r25, r25 564: 08 17 cp r16, r24 566: 19 07 cpc r17, r25 568: 54 f4 brge .+20 ; 0x57e 56a: 80 e2 ldi r24, 0x20 ; 32 56c: 0e 94 c6 02 call 0x58c 570: 21 96 adiw r28, 0x01 ; 1 572: 80 91 a8 00 lds r24, 0x00A8 576: 99 27 eor r25, r25 578: c8 17 cp r28, r24 57a: d9 07 cpc r29, r25 57c: b4 f3 brlt .-20 ; 0x56a } } /* end of Blank */ 57e: df 91 pop r29 580: cf 91 pop r28 582: 1f 91 pop r17 584: 0f 91 pop r16 586: ff 90 pop r15 588: ef 90 pop r14 58a: 08 95 ret 0000058c : static void UartWrite (BYTE c) /********************************************************************** Gibt ein Zeichen auf den UART aus und wartet, bis das Zeichen in das Transmit Shift Register uebernommen wurde. */ { outp (c, UDR); 58c: 8c b9 out 0x0c, r24 ; 12 // warten, bis das Datenregister des UART leer ist. Dies wird // durch Bit 5 (UDRE) im UART Status Register angezeigt. while (bit_is_clear (UCSRA, UDRE)) { 58e: 5d 9b sbis 0x0b, 5 ; 11 590: fe cf rjmp .-4 ; 0x58e // Ja, ja, einfach nur warten } nSent++; 592: 80 91 a6 00 lds r24, 0x00A6 596: 90 91 a7 00 lds r25, 0x00A7 59a: 01 96 adiw r24, 0x01 ; 1 59c: 90 93 a7 00 sts 0x00A7, r25 5a0: 80 93 a6 00 sts 0x00A6, r24 } /* end of UartWrite */ 5a4: 08 95 ret 000005a6 <__udivmodhi4>: 5a6: aa 1b sub r26, r26 5a8: bb 1b sub r27, r27 5aa: 51 e1 ldi r21, 0x11 ; 17 5ac: 07 c0 rjmp .+14 ; 0x5bc 000005ae <__udivmodhi4_loop>: 5ae: aa 1f adc r26, r26 5b0: bb 1f adc r27, r27 5b2: a6 17 cp r26, r22 5b4: b7 07 cpc r27, r23 5b6: 10 f0 brcs .+4 ; 0x5bc 5b8: a6 1b sub r26, r22 5ba: b7 0b sbc r27, r23 000005bc <__udivmodhi4_ep>: 5bc: 88 1f adc r24, r24 5be: 99 1f adc r25, r25 5c0: 5a 95 dec r21 5c2: a9 f7 brne .-22 ; 0x5ae 5c4: 80 95 com r24 5c6: 90 95 com r25 5c8: bc 01 movw r22, r24 5ca: cd 01 movw r24, r26 5cc: 08 95 ret