Subversion Repositories MK3Mag

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 ingob 1
 
2
main.elf:     file format elf32-avr
3
 
4
Sections:
5
Idx Name          Size      VMA       LMA       File off  Algn
6
 
7
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
8
  1 .data         00000024  00800060  00001bec  00001c80  2**0
9
                  CONTENTS, ALLOC, LOAD, DATA
10
  2 .bss          00000156  00800084  00800084  00001ca4  2**0
11
                  ALLOC
12
  3 .noinit       00000000  008001da  008001da  00001ca4  2**0
13
                  CONTENTS
14
  4 .eeprom       00000000  00810000  00810000  00001ca4  2**0
15
                  CONTENTS
16
  5 .stab         0000036c  00000000  00000000  00001ca4  2**2
17
                  CONTENTS, READONLY, DEBUGGING
18
  6 .stabstr      00000084  00000000  00000000  00002010  2**0
19
                  CONTENTS, READONLY, DEBUGGING
20
  7 .debug_aranges 000000b4  00000000  00000000  00002094  2**0
21
                  CONTENTS, READONLY, DEBUGGING
22
  8 .debug_pubnames 000006f5  00000000  00000000  00002148  2**0
23
                  CONTENTS, READONLY, DEBUGGING
24
  9 .debug_info   00001a41  00000000  00000000  0000283d  2**0
25
                  CONTENTS, READONLY, DEBUGGING
26
 10 .debug_abbrev 00000774  00000000  00000000  0000427e  2**0
27
                  CONTENTS, READONLY, DEBUGGING
28
 11 .debug_line   0000169d  00000000  00000000  000049f2  2**0
29
                  CONTENTS, READONLY, DEBUGGING
30
 12 .debug_str    00000874  00000000  00000000  0000608f  2**0
31
                  CONTENTS, READONLY, DEBUGGING
32
Disassembly of section .text:
33
 
34
00000000 <__vectors>:
35
       0:	0c 94 85 00 	jmp	0x10a <__init>
36
       4:	0c 94 7e 0b 	jmp	0x16fc <__vector_1>
37
       8:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
38
       c:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
39
      10:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
40
      14:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
41
      18:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
42
      1c:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
43
      20:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
44
      24:	0c 94 67 09 	jmp	0x12ce <__vector_9>
45
      28:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
46
      2c:	0c 94 96 0b 	jmp	0x172c <__vector_11>
47
      30:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
48
      34:	0c 94 18 02 	jmp	0x430 <__vector_13>
49
      38:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
50
      3c:	0c 94 e3 01 	jmp	0x3c6 <__vector_15>
51
      40:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
52
      44:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
53
      48:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
54
      4c:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
55
      50:	0c 94 a0 00 	jmp	0x140 <__bad_interrupt>
56
 
57
00000054 <__ctors_end>:
58
      54:	20 2d       	mov	r18, r0
59
      56:	2d 20       	and	r2, r13
60
      58:	52 65       	ori	r21, 0x52	; 82
61
      5a:	6d 6f       	ori	r22, 0xFD	; 253
62
      5c:	74 65       	ori	r23, 0x54	; 84
63
      5e:	20 20       	and	r2, r0
64
      60:	2d 2d       	mov	r18, r13
65
      62:	20 20       	and	r2, r0
66
      64:	20 20       	and	r2, r0
67
      66:	20 20       	and	r2, r0
68
	...
69
 
70
00000069 <__c.1>:
71
      69:	20 2d 2d 20 44 69 73 70 6c 61 79 20 2d 2d 20 20      -- Display --
72
      79:	20 20 20 20 00                                          .
73
 
74
0000007e <__c.2>:
75
      7e:	20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20
76
      8e:	20 20 20 20 00                                          .
77
 
78
00000093 <__c.3>:
79
      93:	20 20 77 77 77 2e 4d 69 63 72 6f 53 50 53 2e 63       www.MicroSPS.c
80
      a3:	6f 6d 20 20 00                                      om  .
81
 
82
000000a8 <__c.2>:
83
      a8:	25 73 00                                            %s.
84
 
85
000000ab <__c.3>:
86
      ab:	25 73 00                                            %s.
87
 
88
000000ae <__c.4>:
89
      ae:	25 73 00                                            %s.
90
 
91
000000b1 <__c.5>:
92
      b1:	25 73 00                                            %s.
93
 
94
000000b4 <__c.3>:
95
      b4:	56 65 72 62 69 6e 64 65 6e 20 6d 69 74 00           Verbinden mit.
96
 
97
000000c2 <__c.4>:
98
      c2:	4d 69 63 72 6f 53 50 53 3a 25 32 69 20 00           MicroSPS:%2i .
99
 
100
000000d0 <__c.5>:
101
      d0:	4d 61 78 20 41 64 72 65 73 73 65 00                 Max Adresse.
102
 
103
000000dc <__c.6>:
104
      dc:	25 32 69 20 00                                      %2i .
105
 
106
000000e1 <__c.7>:
107
      e1:	43 68 65 63 6b 73 75 6d 00                          Checksum.
108
 
109
000000ea <__c.8>:
110
      ea:	45 72 72 6f 72 73 3a 25 35 69 20 00                 Errors:%5i .
111
 
112
000000f6 <__c.9>:
113
      f6:	44 69 73 70 6c 61 79 00                             Display.
114
 
115
000000fe <__c.10>:
116
      fe:	5a 65 69 6c 65 6e 3a 25 31 69 20 00                 Zeilen:%1i .
117
 
118
0000010a <__init>:
119
     10a:	11 24       	eor	r1, r1
120
     10c:	1f be       	out	0x3f, r1	; 63
121
     10e:	cf e5       	ldi	r28, 0x5F	; 95
122
     110:	d8 e0       	ldi	r29, 0x08	; 8
123
     112:	de bf       	out	0x3e, r29	; 62
124
     114:	cd bf       	out	0x3d, r28	; 61
125
 
126
00000116 <__do_copy_data>:
127
     116:	10 e0       	ldi	r17, 0x00	; 0
128
     118:	a0 e6       	ldi	r26, 0x60	; 96
129
     11a:	b0 e0       	ldi	r27, 0x00	; 0
130
     11c:	ec ee       	ldi	r30, 0xEC	; 236
131
     11e:	fb e1       	ldi	r31, 0x1B	; 27
132
     120:	02 c0       	rjmp	.+4      	; 0x126 <.do_copy_data_start>
133
 
134
00000122 <.do_copy_data_loop>:
135
     122:	05 90       	lpm	r0, Z+
136
     124:	0d 92       	st	X+, r0
137
 
138
00000126 <.do_copy_data_start>:
139
     126:	a4 38       	cpi	r26, 0x84	; 132
140
     128:	b1 07       	cpc	r27, r17
141
     12a:	d9 f7       	brne	.-10     	; 0x122 <.do_copy_data_loop>
142
 
143
0000012c <__do_clear_bss>:
144
     12c:	11 e0       	ldi	r17, 0x01	; 1
145
     12e:	a4 e8       	ldi	r26, 0x84	; 132
146
     130:	b0 e0       	ldi	r27, 0x00	; 0
147
     132:	01 c0       	rjmp	.+2      	; 0x136 <.do_clear_bss_start>
148
 
149
00000134 <.do_clear_bss_loop>:
150
     134:	1d 92       	st	X+, r1
151
 
152
00000136 <.do_clear_bss_start>:
153
     136:	aa 3d       	cpi	r26, 0xDA	; 218
154
     138:	b1 07       	cpc	r27, r17
155
     13a:	e1 f7       	brne	.-8      	; 0x134 <.do_clear_bss_loop>
156
     13c:	0c 94 e5 00 	jmp	0x1ca <main>
157
 
158
00000140 <__bad_interrupt>:
159
     140:	0c 94 00 00 	jmp	0x0 <__vectors>
160
 
161
00000144 <Sekundentakt_Init>:
162
unsigned int IntervallDebug = 250, IntervallDisplay = 120;
163
 
164
void Sekundentakt_Init(void)
165
{
166
  _SekTimer = SetDelay(1000);
167
     144:	88 ee       	ldi	r24, 0xE8	; 232
168
     146:	93 e0       	ldi	r25, 0x03	; 3
169
     148:	0e 94 a8 09 	call	0x1350 <SetDelay>
170
     14c:	90 93 91 00 	sts	0x0091, r25
171
     150:	80 93 90 00 	sts	0x0090, r24
172
     154:	08 95       	ret
173
 
174
00000156 <Sekundentakt>:
175
}
176
 
177
void Sekundentakt(void)
178
{
179
 if(CheckDelay(_SekTimer))
180
     156:	80 91 90 00 	lds	r24, 0x0090
181
     15a:	90 91 91 00 	lds	r25, 0x0091
182
     15e:	0e 94 b1 09 	call	0x1362 <CheckDelay>
183
     162:	88 23       	and	r24, r24
184
     164:	31 f1       	breq	.+76     	; 0x1b2 <Sekundentakt+0x5c>
185
 {
186
  GetKeyboard();
187
     166:	0e 94 d2 09 	call	0x13a4 <GetKeyboard>
188
  _SekTimer += 1000;
189
     16a:	80 91 90 00 	lds	r24, 0x0090
190
     16e:	90 91 91 00 	lds	r25, 0x0091
191
     172:	88 51       	subi	r24, 0x18	; 24
192
     174:	9c 4f       	sbci	r25, 0xFC	; 252
193
     176:	90 93 91 00 	sts	0x0091, r25
194
     17a:	80 93 90 00 	sts	0x0090, r24
195
  if(!CntDatensaetzeProSekunde) UebertragungUnterbrochen = 1; else UebertragungUnterbrochen = 0;
196
     17e:	80 91 66 00 	lds	r24, 0x0066
197
     182:	88 23       	and	r24, r24
198
     184:	21 f4       	brne	.+8      	; 0x18e <Sekundentakt+0x38>
199
     186:	81 e0       	ldi	r24, 0x01	; 1
200
     188:	80 93 84 00 	sts	0x0084, r24
201
     18c:	02 c0       	rjmp	.+4      	; 0x192 <Sekundentakt+0x3c>
202
     18e:	10 92 84 00 	sts	0x0084, r1
203
  CntDatensaetzeProSekunde = 0;
204
     192:	10 92 66 00 	sts	0x0066, r1
205
  if(++Sekunde == 60)
206
     196:	80 91 8d 00 	lds	r24, 0x008D
207
     19a:	8f 5f       	subi	r24, 0xFF	; 255
208
     19c:	80 93 8d 00 	sts	0x008D, r24
209
     1a0:	8c 33       	cpi	r24, 0x3C	; 60
210
     1a2:	39 f4       	brne	.+14     	; 0x1b2 <Sekundentakt+0x5c>
211
   {
212
    Sekunde = 0;
213
     1a4:	10 92 8d 00 	sts	0x008D, r1
214
    Minute++;
215
     1a8:	80 91 8c 00 	lds	r24, 0x008C
216
     1ac:	8f 5f       	subi	r24, 0xFF	; 255
217
     1ae:	80 93 8c 00 	sts	0x008C, r24
218
     1b2:	08 95       	ret
219
 
220
000001b4 <Init>:
221
   }
222
 }
223
}
224
 
225
void Init(void)
226
{
227
  VersionInfo.Hauptversion = 0;
228
     1b4:	10 92 c9 00 	sts	0x00C9, r1
229
  VersionInfo.Nebenversion = 99;
230
     1b8:	83 e6       	ldi	r24, 0x63	; 99
231
     1ba:	80 93 ca 00 	sts	0x00CA, r24
232
  VersionInfo.PCKompatibel = 1;
233
     1be:	81 e0       	ldi	r24, 0x01	; 1
234
     1c0:	80 93 cb 00 	sts	0x00CB, r24
235
  VersionInfo.Commercial = 0x00;
236
     1c4:	10 92 cc 00 	sts	0x00CC, r1
237
     1c8:	08 95       	ret
238
 
239
000001ca <main>:
240
}
241
 
242
#define MENU   0
243
#define REMOTE 1
244
 
245
//############################################################################
246
//Hauptprogramm
247
void main (void)
248
//############################################################################
249
{
250
     1ca:	ca e5       	ldi	r28, 0x5A	; 90
251
     1cc:	d8 e0       	ldi	r29, 0x08	; 8
252
     1ce:	de bf       	out	0x3e, r29	; 62
253
     1d0:	cd bf       	out	0x3d, r28	; 61
254
 char z,txt[]= {"Moin"},key,key_old = 255;
255
     1d2:	de 01       	movw	r26, r28
256
     1d4:	11 96       	adiw	r26, 0x01	; 1
257
     1d6:	e7 e6       	ldi	r30, 0x67	; 103
258
     1d8:	f0 e0       	ldi	r31, 0x00	; 0
259
     1da:	85 e0       	ldi	r24, 0x05	; 5
260
     1dc:	01 90       	ld	r0, Z+
261
     1de:	0d 92       	st	X+, r0
262
     1e0:	81 50       	subi	r24, 0x01	; 1
263
     1e2:	e1 f7       	brne	.-8      	; 0x1dc <main+0x12>
264
 int test = 0;
265
 unsigned int DelayTast;
266
 unsigned int DelayDaten,DelayDisplay;
267
 
268
 
269
 unsigned char mode = REMOTE;
270
     1e4:	91 e0       	ldi	r25, 0x01	; 1
271
     1e6:	b9 2e       	mov	r11, r25
272
 unsigned char neueDatenuebertragung = 1;
273
 
274
	UART_Init();
275
     1e8:	0e 94 cc 04 	call	0x998 <UART_Init>
276
    LCD_Init();
277
     1ec:	0e 94 1f 06 	call	0xc3e <LCD_Init>
278
    UART_Init();
279
     1f0:	0e 94 cc 04 	call	0x998 <UART_Init>
280
	Timer1_Init();
281
     1f4:	0e 94 9e 09 	call	0x133c <Timer1_Init>
282
    Keyboard_Init();
283
     1f8:	0e 94 c9 09 	call	0x1392 <Keyboard_Init>
284
    Sekundentakt_Init();
285
     1fc:	0e 94 a2 00 	call	0x144 <Sekundentakt_Init>
286
    InitIR();
287
     200:	0e 94 67 0b 	call	0x16ce <InitIR>
288
    ADC_Init();
289
     204:	0e 94 42 0c 	call	0x1884 <ADC_Init>
290
    Init();
291
     208:	0e 94 da 00 	call	0x1b4 <Init>
292
 
293
	sei ();//Globale Interrupts Einschalten
294
     20c:	78 94       	sei
295
    DDRB = 0xff;
296
     20e:	8f ef       	ldi	r24, 0xFF	; 255
297
     210:	87 bb       	out	0x17, r24	; 23
298
    PORTB = 0x00;
299
     212:	18 ba       	out	0x18, r1	; 24
300
    LCD_Clear;
301
     214:	81 e0       	ldi	r24, 0x01	; 1
302
     216:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
303
     21a:	0e 94 c9 05 	call	0xb92 <_long_delay>
304
 
305
/*   while(1)
306
*/
307
 
308
 DelayTast = SetDelay(80);
309
     21e:	80 e5       	ldi	r24, 0x50	; 80
310
     220:	90 e0       	ldi	r25, 0x00	; 0
311
     222:	0e 94 a8 09 	call	0x1350 <SetDelay>
312
     226:	7c 01       	movw	r14, r24
313
 DelayDaten = SetDelay(200);
314
     228:	88 ec       	ldi	r24, 0xC8	; 200
315
     22a:	90 e0       	ldi	r25, 0x00	; 0
316
     22c:	0e 94 a8 09 	call	0x1350 <SetDelay>
317
     230:	8c 01       	movw	r16, r24
318
 DelayDisplay = SetDelay(300);
319
     232:	8c e2       	ldi	r24, 0x2C	; 44
320
     234:	91 e0       	ldi	r25, 0x01	; 1
321
     236:	0e 94 a8 09 	call	0x1350 <SetDelay>
322
     23a:	6c 01       	movw	r12, r24
323
 ClearIntervalle();
324
     23c:	0e 94 2e 05 	call	0xa5c <ClearIntervalle>
325
while (1)
326
 {
327
  if(mode == MENU)
328
     240:	bb 20       	and	r11, r11
329
     242:	11 f5       	brne	.+68     	; 0x288 <main+0xbe>
330
    {
331
     Delay_ms(10);
332
     244:	8a e0       	ldi	r24, 0x0A	; 10
333
     246:	90 e0       	ldi	r25, 0x00	; 0
334
     248:	0e 94 bc 09 	call	0x1378 <Delay_ms>
335
     key = GetKeyboard();
336
     24c:	0e 94 d2 09 	call	0x13a4 <GetKeyboard>
337
     Menu(key);
338
     250:	99 27       	eor	r25, r25
339
     252:	0e 94 64 0a 	call	0x14c8 <Menu>
340
	 if(_TASTE5)
341
     256:	cb 9b       	sbis	0x19, 3	; 25
342
     258:	f5 cf       	rjmp	.-22     	; 0x244 <main+0x7a>
343
	  {
344
	   do { Delay_ms(10);} while(_TASTE5);
345
     25a:	8a e0       	ldi	r24, 0x0A	; 10
346
     25c:	90 e0       	ldi	r25, 0x00	; 0
347
     25e:	0e 94 bc 09 	call	0x1378 <Delay_ms>
348
     262:	cb 99       	sbic	0x19, 3	; 25
349
     264:	fa cf       	rjmp	.-12     	; 0x25a <main+0x90>
350
	   mode = REMOTE;
351
     266:	81 e0       	ldi	r24, 0x01	; 1
352
     268:	b8 2e       	mov	r11, r24
353
       DelayTast  = SetDelay(100);
354
     26a:	84 e6       	ldi	r24, 0x64	; 100
355
     26c:	90 e0       	ldi	r25, 0x00	; 0
356
     26e:	0e 94 a8 09 	call	0x1350 <SetDelay>
357
     272:	7c 01       	movw	r14, r24
358
       DelayDaten = SetDelay(200);
359
     274:	88 ec       	ldi	r24, 0xC8	; 200
360
     276:	90 e0       	ldi	r25, 0x00	; 0
361
     278:	0e 94 a8 09 	call	0x1350 <SetDelay>
362
     27c:	8c 01       	movw	r16, r24
363
       LCD_Clear;
364
     27e:	8b 2d       	mov	r24, r11
365
     280:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
366
     284:	0e 94 c9 05 	call	0xb92 <_long_delay>
367
	  }
368
    }
369
  else
370
  if(mode == REMOTE)
371
     288:	81 e0       	ldi	r24, 0x01	; 1
372
     28a:	b8 16       	cp	r11, r24
373
     28c:	c9 f6       	brne	.-78     	; 0x240 <main+0x76>
374
  {
375
    BearbeiteRxDaten();
376
     28e:	0e 94 fe 03 	call	0x7fc <BearbeiteRxDaten>
377
 
378
    if(CheckDelay(DelayDaten))
379
     292:	c8 01       	movw	r24, r16
380
     294:	0e 94 b1 09 	call	0x1362 <CheckDelay>
381
     298:	88 23       	and	r24, r24
382
     29a:	c9 f3       	breq	.-14     	; 0x28e <main+0xc4>
383
      {
384
         Sekundentakt();
385
     29c:	0e 94 ab 00 	call	0x156 <Sekundentakt>
386
  	     DelayDaten = SetDelay(10);
387
     2a0:	8a e0       	ldi	r24, 0x0A	; 10
388
     2a2:	90 e0       	ldi	r25, 0x00	; 0
389
     2a4:	0e 94 a8 09 	call	0x1350 <SetDelay>
390
     2a8:	8c 01       	movw	r16, r24
391
 
392
		 if(CheckDelay(DelayDisplay))
393
     2aa:	c6 01       	movw	r24, r12
394
     2ac:	0e 94 b1 09 	call	0x1362 <CheckDelay>
395
     2b0:	88 23       	and	r24, r24
396
     2b2:	39 f0       	breq	.+14     	; 0x2c2 <main+0xf8>
397
		  {
398
		   DelayDisplay = SetDelay(300);
399
     2b4:	8c e2       	ldi	r24, 0x2C	; 44
400
     2b6:	91 e0       	ldi	r25, 0x01	; 1
401
     2b8:	0e 94 a8 09 	call	0x1350 <SetDelay>
402
     2bc:	6c 01       	movw	r12, r24
403
           PollDisplay = 1;
404
     2be:	b0 92 ed 00 	sts	0x00ED, r11
405
          }
406
          key = GetKeyboard2();
407
     2c2:	0e 94 57 0a 	call	0x14ae <GetKeyboard2>
408
          DatenUebertragung(key);
409
     2c6:	99 27       	eor	r25, r25
410
     2c8:	0e 94 51 05 	call	0xaa2 <DatenUebertragung>
411
 
412
		 if(UebertragungUnterbrochen)
413
     2cc:	80 91 84 00 	lds	r24, 0x0084
414
     2d0:	88 23       	and	r24, r24
415
     2d2:	81 f1       	breq	.+96     	; 0x334 <main+0x16a>
416
		  {
417
						   //01234567890123456789
418
           LCD_printfxy(0,0," -- Remote  --      ");
419
     2d4:	60 e0       	ldi	r22, 0x00	; 0
420
     2d6:	86 2f       	mov	r24, r22
421
     2d8:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
422
     2dc:	84 e5       	ldi	r24, 0x54	; 84
423
     2de:	90 e0       	ldi	r25, 0x00	; 0
424
     2e0:	9f 93       	push	r25
425
     2e2:	8f 93       	push	r24
426
     2e4:	0e 94 e3 06 	call	0xdc6 <_printf_P>
427
           LCD_printfxy(0,1," -- Display --      ");
428
     2e8:	61 e0       	ldi	r22, 0x01	; 1
429
     2ea:	80 e0       	ldi	r24, 0x00	; 0
430
     2ec:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
431
     2f0:	0f 90       	pop	r0
432
     2f2:	0f 90       	pop	r0
433
     2f4:	89 e6       	ldi	r24, 0x69	; 105
434
     2f6:	90 e0       	ldi	r25, 0x00	; 0
435
     2f8:	9f 93       	push	r25
436
     2fa:	8f 93       	push	r24
437
     2fc:	0e 94 e3 06 	call	0xdc6 <_printf_P>
438
           LCD_printfxy(0,2,"                    ");
439
     300:	62 e0       	ldi	r22, 0x02	; 2
440
     302:	80 e0       	ldi	r24, 0x00	; 0
441
     304:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
442
     308:	0f 90       	pop	r0
443
     30a:	0f 90       	pop	r0
444
     30c:	8e e7       	ldi	r24, 0x7E	; 126
445
     30e:	90 e0       	ldi	r25, 0x00	; 0
446
     310:	9f 93       	push	r25
447
     312:	8f 93       	push	r24
448
     314:	0e 94 e3 06 	call	0xdc6 <_printf_P>
449
           LCD_printfxy(0,3,"  www.MicroSPS.com  ");
450
     318:	63 e0       	ldi	r22, 0x03	; 3
451
     31a:	80 e0       	ldi	r24, 0x00	; 0
452
     31c:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
453
     320:	0f 90       	pop	r0
454
     322:	0f 90       	pop	r0
455
     324:	83 e9       	ldi	r24, 0x93	; 147
456
     326:	90 e0       	ldi	r25, 0x00	; 0
457
     328:	9f 93       	push	r25
458
     32a:	8f 93       	push	r24
459
     32c:	0e 94 e3 06 	call	0xdc6 <_printf_P>
460
     330:	0f 90       	pop	r0
461
     332:	0f 90       	pop	r0
462
		  }
463
 
464
		 if(CheckDelay(DelayTast))
465
     334:	c7 01       	movw	r24, r14
466
     336:	0e 94 b1 09 	call	0x1362 <CheckDelay>
467
     33a:	88 23       	and	r24, r24
468
     33c:	09 f4       	brne	.+2      	; 0x340 <main+0x176>
469
     33e:	a7 cf       	rjmp	.-178    	; 0x28e <main+0xc4>
470
		  {
471
		   DelayTast = SetDelay(100);
472
     340:	84 e6       	ldi	r24, 0x64	; 100
473
     342:	90 e0       	ldi	r25, 0x00	; 0
474
     344:	0e 94 a8 09 	call	0x1350 <SetDelay>
475
     348:	7c 01       	movw	r14, r24
476
 
477
           if(_TASTE5)
478
     34a:	cb 9b       	sbis	0x19, 3	; 25
479
     34c:	0c c0       	rjmp	.+24     	; 0x366 <main+0x19c>
480
        	  {
481
        	   do { Delay_ms(10);} while(_TASTE5);
482
     34e:	8a e0       	ldi	r24, 0x0A	; 10
483
     350:	90 e0       	ldi	r25, 0x00	; 0
484
     352:	0e 94 bc 09 	call	0x1378 <Delay_ms>
485
     356:	cb 99       	sbic	0x19, 3	; 25
486
     358:	fa cf       	rjmp	.-12     	; 0x34e <main+0x184>
487
        	   mode = MENU;
488
     35a:	bb 24       	eor	r11, r11
489
               LCD_Clear;
490
     35c:	81 e0       	ldi	r24, 0x01	; 1
491
     35e:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
492
     362:	0e 94 c9 05 	call	0xb92 <_long_delay>
493
     366:	80 91 be 00 	lds	r24, 0x00BE
494
        	  }
495
//           if(key & 0x10)   DebugIn.Digital[0] |= 0x01; else DebugIn.Digital[0] &= ~0x01;
496
           if(PIND & 0x08)  DebugIn.Digital[0] |= 0x02; else DebugIn.Digital[0] &= ~0x02;
497
     36a:	83 9b       	sbis	0x10, 3	; 16
498
     36c:	02 c0       	rjmp	.+4      	; 0x372 <main+0x1a8>
499
     36e:	82 60       	ori	r24, 0x02	; 2
500
     370:	01 c0       	rjmp	.+2      	; 0x374 <main+0x1aa>
501
     372:	8d 7f       	andi	r24, 0xFD	; 253
502
     374:	80 93 be 00 	sts	0x00BE, r24
503
     378:	80 91 be 00 	lds	r24, 0x00BE
504
           if(PIND & 0x10)  DebugIn.Digital[0] |= 0x04; else DebugIn.Digital[0] &= ~0x04;
505
     37c:	84 9b       	sbis	0x10, 4	; 16
506
     37e:	02 c0       	rjmp	.+4      	; 0x384 <main+0x1ba>
507
     380:	84 60       	ori	r24, 0x04	; 4
508
     382:	01 c0       	rjmp	.+2      	; 0x386 <main+0x1bc>
509
     384:	8b 7f       	andi	r24, 0xFB	; 251
510
     386:	80 93 be 00 	sts	0x00BE, r24
511
     38a:	80 91 be 00 	lds	r24, 0x00BE
512
           if(PIND & 0x20)  DebugIn.Digital[0] |= 0x08; else DebugIn.Digital[0] &= ~0x08;
513
     38e:	85 9b       	sbis	0x10, 5	; 16
514
     390:	02 c0       	rjmp	.+4      	; 0x396 <main+0x1cc>
515
     392:	88 60       	ori	r24, 0x08	; 8
516
     394:	01 c0       	rjmp	.+2      	; 0x398 <main+0x1ce>
517
     396:	87 7f       	andi	r24, 0xF7	; 247
518
     398:	80 93 be 00 	sts	0x00BE, r24
519
     39c:	80 91 be 00 	lds	r24, 0x00BE
520
           if(PIND & 0x40)  DebugIn.Digital[0] |= 0x10; else DebugIn.Digital[0] &= ~0x10;
521
     3a0:	86 9b       	sbis	0x10, 6	; 16
522
     3a2:	02 c0       	rjmp	.+4      	; 0x3a8 <main+0x1de>
523
     3a4:	80 61       	ori	r24, 0x10	; 16
524
     3a6:	01 c0       	rjmp	.+2      	; 0x3aa <main+0x1e0>
525
     3a8:	8f 7e       	andi	r24, 0xEF	; 239
526
     3aa:	80 93 be 00 	sts	0x00BE, r24
527
     3ae:	80 91 be 00 	lds	r24, 0x00BE
528
           if(PIND & 0x80)  DebugIn.Digital[0] |= 0x20; else DebugIn.Digital[0] &= ~0x20;
529
     3b2:	87 9b       	sbis	0x10, 7	; 16
530
     3b4:	02 c0       	rjmp	.+4      	; 0x3ba <main+0x1f0>
531
     3b6:	80 62       	ori	r24, 0x20	; 32
532
     3b8:	01 c0       	rjmp	.+2      	; 0x3bc <main+0x1f2>
533
     3ba:	8f 7d       	andi	r24, 0xDF	; 223
534
     3bc:	80 93 be 00 	sts	0x00BE, r24
535
           GetAnalogWerte();
536
     3c0:	0e 94 4e 0c 	call	0x189c <GetAnalogWerte>
537
     3c4:	3d cf       	rjmp	.-390    	; 0x240 <main+0x76>
538
 
539
000003c6 <__vector_15>:
540
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
541
//++ Sende-Part der Datenübertragung
542
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
543
SIGNAL(INT_VEC_TX)
544
{
545
     3c6:	1f 92       	push	r1
546
     3c8:	0f 92       	push	r0
547
     3ca:	0f b6       	in	r0, 0x3f	; 63
548
     3cc:	0f 92       	push	r0
549
     3ce:	11 24       	eor	r1, r1
550
     3d0:	8f 93       	push	r24
551
     3d2:	9f 93       	push	r25
552
     3d4:	ef 93       	push	r30
553
     3d6:	ff 93       	push	r31
554
 static unsigned int ptr = 0;
555
 unsigned char tmp_tx;
556
 if(!UebertragungAbgeschlossen)
557
     3d8:	80 91 6e 00 	lds	r24, 0x006E
558
     3dc:	88 23       	and	r24, r24
559
     3de:	d9 f4       	brne	.+54     	; 0x416 <__vector_15+0x50>
560
  {
561
   ptr++;                    // die [0] wurde schon gesendet
562
     3e0:	80 91 9d 00 	lds	r24, 0x009D
563
     3e4:	90 91 9e 00 	lds	r25, 0x009E
564
     3e8:	01 96       	adiw	r24, 0x01	; 1
565
     3ea:	90 93 9e 00 	sts	0x009E, r25
566
     3ee:	80 93 9d 00 	sts	0x009D, r24
567
   tmp_tx = SendeBuffer[ptr];
568
     3f2:	fc 01       	movw	r30, r24
569
     3f4:	e2 51       	subi	r30, 0x12	; 18
570
     3f6:	ff 4f       	sbci	r31, 0xFF	; 255
571
     3f8:	e0 81       	ld	r30, Z
572
   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
573
     3fa:	ed 30       	cpi	r30, 0x0D	; 13
574
     3fc:	19 f0       	breq	.+6      	; 0x404 <__vector_15+0x3e>
575
     3fe:	84 36       	cpi	r24, 0x64	; 100
576
     400:	91 05       	cpc	r25, r1
577
     402:	39 f4       	brne	.+14     	; 0x412 <__vector_15+0x4c>
578
    {
579
     ptr = 0;
580
     404:	10 92 9e 00 	sts	0x009E, r1
581
     408:	10 92 9d 00 	sts	0x009D, r1
582
     UebertragungAbgeschlossen = 1;
583
     40c:	81 e0       	ldi	r24, 0x01	; 1
584
     40e:	80 93 6e 00 	sts	0x006E, r24
585
    }
586
   UDR = tmp_tx;
587
     412:	ec b9       	out	0x0c, r30	; 12
588
     414:	04 c0       	rjmp	.+8      	; 0x41e <__vector_15+0x58>
589
  }
590
  else ptr = 0;
591
     416:	10 92 9e 00 	sts	0x009E, r1
592
     41a:	10 92 9d 00 	sts	0x009D, r1
593
     41e:	ff 91       	pop	r31
594
     420:	ef 91       	pop	r30
595
     422:	9f 91       	pop	r25
596
     424:	8f 91       	pop	r24
597
     426:	0f 90       	pop	r0
598
     428:	0f be       	out	0x3f, r0	; 63
599
     42a:	0f 90       	pop	r0
600
     42c:	1f 90       	pop	r1
601
     42e:	18 95       	reti
602
 
603
00000430 <__vector_13>:
604
}
605
 
606
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
607
//++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung
608
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
609
SIGNAL(INT_VEC_RX)
610
{
611
     430:	1f 92       	push	r1
612
     432:	0f 92       	push	r0
613
     434:	0f b6       	in	r0, 0x3f	; 63
614
     436:	0f 92       	push	r0
615
     438:	11 24       	eor	r1, r1
616
     43a:	2f 93       	push	r18
617
     43c:	3f 93       	push	r19
618
     43e:	4f 93       	push	r20
619
     440:	5f 93       	push	r21
620
     442:	8f 93       	push	r24
621
     444:	9f 93       	push	r25
622
     446:	af 93       	push	r26
623
     448:	bf 93       	push	r27
624
     44a:	ef 93       	push	r30
625
     44c:	ff 93       	push	r31
626
 static unsigned int crc;
627
 static unsigned char crc1,crc2,buf_ptr;
628
 static unsigned char UartState = 0;
629
 unsigned char CrcOkay = 0;
630
     44e:	20 e0       	ldi	r18, 0x00	; 0
631
 
632
 SioTmp = UDR;
633
     450:	8c b1       	in	r24, 0x0c	; 12
634
     452:	80 93 9c 00 	sts	0x009C, r24
635
 if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
636
     456:	50 91 a3 00 	lds	r21, 0x00A3
637
     45a:	54 36       	cpi	r21, 0x64	; 100
638
     45c:	10 f0       	brcs	.+4      	; 0x462 <__vector_13+0x32>
639
     45e:	20 93 a4 00 	sts	0x00A4, r18
640
 if(SioTmp == '\r' && UartState == 2)
641
     462:	80 91 9c 00 	lds	r24, 0x009C
642
     466:	8d 30       	cpi	r24, 0x0D	; 13
643
     468:	09 f0       	breq	.+2      	; 0x46c <__vector_13+0x3c>
644
     46a:	5b c0       	rjmp	.+182    	; 0x522 <__vector_13+0xf2>
645
     46c:	80 91 a4 00 	lds	r24, 0x00A4
646
     470:	82 30       	cpi	r24, 0x02	; 2
647
     472:	09 f0       	breq	.+2      	; 0x476 <__vector_13+0x46>
648
     474:	56 c0       	rjmp	.+172    	; 0x522 <__vector_13+0xf2>
649
  {
650
   UartState = 0;
651
     476:	20 93 a4 00 	sts	0x00A4, r18
652
   crc -= RxdBuffer[buf_ptr-2];
653
     47a:	85 2f       	mov	r24, r21
654
     47c:	99 27       	eor	r25, r25
655
     47e:	8e 5a       	subi	r24, 0xAE	; 174
656
     480:	9e 4f       	sbci	r25, 0xFE	; 254
657
     482:	fc 01       	movw	r30, r24
658
     484:	32 97       	sbiw	r30, 0x02	; 2
659
     486:	40 81       	ld	r20, Z
660
     488:	20 91 9f 00 	lds	r18, 0x009F
661
     48c:	30 91 a0 00 	lds	r19, 0x00A0
662
     490:	24 1b       	sub	r18, r20
663
     492:	31 09       	sbc	r19, r1
664
   crc -= RxdBuffer[buf_ptr-1];
665
     494:	dc 01       	movw	r26, r24
666
     496:	11 97       	sbiw	r26, 0x01	; 1
667
     498:	8c 91       	ld	r24, X
668
     49a:	28 1b       	sub	r18, r24
669
     49c:	31 09       	sbc	r19, r1
670
   crc %= 4096;
671
     49e:	c9 01       	movw	r24, r18
672
     4a0:	9f 70       	andi	r25, 0x0F	; 15
673
     4a2:	90 93 a0 00 	sts	0x00A0, r25
674
     4a6:	80 93 9f 00 	sts	0x009F, r24
675
   crc1 = '=' + crc / 64;
676
     4aa:	46 e0       	ldi	r20, 0x06	; 6
677
     4ac:	96 95       	lsr	r25
678
     4ae:	87 95       	ror	r24
679
     4b0:	4a 95       	dec	r20
680
     4b2:	e1 f7       	brne	.-8      	; 0x4ac <__vector_13+0x7c>
681
     4b4:	98 2f       	mov	r25, r24
682
     4b6:	93 5c       	subi	r25, 0xC3	; 195
683
     4b8:	90 93 a1 00 	sts	0x00A1, r25
684
   crc2 = '=' + crc % 64;
685
     4bc:	2f 73       	andi	r18, 0x3F	; 63
686
     4be:	30 70       	andi	r19, 0x00	; 0
687
     4c0:	23 5c       	subi	r18, 0xC3	; 195
688
     4c2:	20 93 a2 00 	sts	0x00A2, r18
689
   CrcOkay = 0;
690
   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
691
     4c6:	80 81       	ld	r24, Z
692
     4c8:	98 17       	cp	r25, r24
693
     4ca:	29 f4       	brne	.+10     	; 0x4d6 <__vector_13+0xa6>
694
     4cc:	8c 91       	ld	r24, X
695
     4ce:	28 17       	cp	r18, r24
696
     4d0:	11 f4       	brne	.+4      	; 0x4d6 <__vector_13+0xa6>
697
     4d2:	21 e0       	ldi	r18, 0x01	; 1
698
     4d4:	0a c0       	rjmp	.+20     	; 0x4ea <__vector_13+0xba>
699
     4d6:	20 e0       	ldi	r18, 0x00	; 0
700
     4d8:	80 91 99 00 	lds	r24, 0x0099
701
     4dc:	90 91 9a 00 	lds	r25, 0x009A
702
     4e0:	01 96       	adiw	r24, 0x01	; 1
703
     4e2:	90 93 9a 00 	sts	0x009A, r25
704
     4e6:	80 93 99 00 	sts	0x0099, r24
705
   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
706
     4ea:	80 91 9b 00 	lds	r24, 0x009B
707
     4ee:	88 23       	and	r24, r24
708
     4f0:	09 f0       	breq	.+2      	; 0x4f4 <__vector_13+0xc4>
709
     4f2:	66 c0       	rjmp	.+204    	; 0x5c0 <__vector_13+0x190>
710
     4f4:	22 23       	and	r18, r18
711
     4f6:	09 f4       	brne	.+2      	; 0x4fa <__vector_13+0xca>
712
     4f8:	63 c0       	rjmp	.+198    	; 0x5c0 <__vector_13+0x190>
713
    {
714
	 CntDatensaetzeProSekunde++;
715
     4fa:	80 91 66 00 	lds	r24, 0x0066
716
     4fe:	8f 5f       	subi	r24, 0xFF	; 255
717
     500:	80 93 66 00 	sts	0x0066, r24
718
 	 PC_DebugTimeout = 10;
719
     504:	8a e0       	ldi	r24, 0x0A	; 10
720
     506:	80 93 97 00 	sts	0x0097, r24
721
     NeuerDatensatzEmpfangen = 1;
722
     50a:	81 e0       	ldi	r24, 0x01	; 1
723
     50c:	80 93 9b 00 	sts	0x009B, r24
724
	 AnzahlEmpfangsBytes = buf_ptr;
725
     510:	50 93 98 00 	sts	0x0098, r21
726
     RxdBuffer[buf_ptr] = '\r';
727
     514:	e5 2f       	mov	r30, r21
728
     516:	ff 27       	eor	r31, r31
729
     518:	ee 5a       	subi	r30, 0xAE	; 174
730
     51a:	fe 4f       	sbci	r31, 0xFE	; 254
731
     51c:	8d e0       	ldi	r24, 0x0D	; 13
732
     51e:	80 83       	st	Z, r24
733
     520:	4f c0       	rjmp	.+158    	; 0x5c0 <__vector_13+0x190>
734
//	 if((RxdBuffer[1] == 's') && (RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
735
	}
736
  }
737
  else
738
  switch(UartState)
739
     522:	20 91 a4 00 	lds	r18, 0x00A4
740
     526:	82 2f       	mov	r24, r18
741
     528:	99 27       	eor	r25, r25
742
     52a:	81 30       	cpi	r24, 0x01	; 1
743
     52c:	91 05       	cpc	r25, r1
744
     52e:	f9 f0       	breq	.+62     	; 0x56e <__vector_13+0x13e>
745
     530:	82 30       	cpi	r24, 0x02	; 2
746
     532:	91 05       	cpc	r25, r1
747
     534:	1c f4       	brge	.+6      	; 0x53c <__vector_13+0x10c>
748
     536:	89 2b       	or	r24, r25
749
     538:	21 f0       	breq	.+8      	; 0x542 <__vector_13+0x112>
750
     53a:	40 c0       	rjmp	.+128    	; 0x5bc <__vector_13+0x18c>
751
     53c:	02 97       	sbiw	r24, 0x02	; 2
752
     53e:	11 f1       	breq	.+68     	; 0x584 <__vector_13+0x154>
753
     540:	3d c0       	rjmp	.+122    	; 0x5bc <__vector_13+0x18c>
754
  {
755
   case 0:
756
          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
757
     542:	80 91 9c 00 	lds	r24, 0x009C
758
     546:	83 32       	cpi	r24, 0x23	; 35
759
     548:	39 f4       	brne	.+14     	; 0x558 <__vector_13+0x128>
760
     54a:	80 91 9b 00 	lds	r24, 0x009B
761
     54e:	88 23       	and	r24, r24
762
     550:	19 f4       	brne	.+6      	; 0x558 <__vector_13+0x128>
763
     552:	81 e0       	ldi	r24, 0x01	; 1
764
     554:	80 93 a4 00 	sts	0x00A4, r24
765
		  buf_ptr = 0;
766
		  RxdBuffer[buf_ptr++] = SioTmp;
767
     558:	80 91 9c 00 	lds	r24, 0x009C
768
     55c:	80 93 52 01 	sts	0x0152, r24
769
     560:	81 e0       	ldi	r24, 0x01	; 1
770
     562:	80 93 a3 00 	sts	0x00A3, r24
771
		  crc = SioTmp;
772
     566:	80 91 9c 00 	lds	r24, 0x009C
773
     56a:	99 27       	eor	r25, r25
774
     56c:	22 c0       	rjmp	.+68     	; 0x5b2 <__vector_13+0x182>
775
          break;
776
   case 1: // Adresse auswerten
777
		  UartState++;
778
     56e:	2f 5f       	subi	r18, 0xFF	; 255
779
     570:	20 93 a4 00 	sts	0x00A4, r18
780
		  RxdBuffer[buf_ptr++] = SioTmp;
781
     574:	e5 2f       	mov	r30, r21
782
     576:	ff 27       	eor	r31, r31
783
     578:	ee 5a       	subi	r30, 0xAE	; 174
784
     57a:	fe 4f       	sbci	r31, 0xFE	; 254
785
     57c:	80 91 9c 00 	lds	r24, 0x009C
786
     580:	80 83       	st	Z, r24
787
     582:	09 c0       	rjmp	.+18     	; 0x596 <__vector_13+0x166>
788
		  crc += SioTmp;
789
		  break;
790
   case 2: //  Eingangsdaten sammeln
791
		  RxdBuffer[buf_ptr] = SioTmp;
792
     584:	e5 2f       	mov	r30, r21
793
     586:	ff 27       	eor	r31, r31
794
     588:	ee 5a       	subi	r30, 0xAE	; 174
795
     58a:	fe 4f       	sbci	r31, 0xFE	; 254
796
     58c:	80 91 9c 00 	lds	r24, 0x009C
797
     590:	80 83       	st	Z, r24
798
		  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
799
     592:	54 36       	cpi	r21, 0x64	; 100
800
     594:	20 f4       	brcc	.+8      	; 0x59e <__vector_13+0x16e>
801
     596:	5f 5f       	subi	r21, 0xFF	; 255
802
     598:	50 93 a3 00 	sts	0x00A3, r21
803
     59c:	02 c0       	rjmp	.+4      	; 0x5a2 <__vector_13+0x172>
804
		  else UartState = 0;
805
     59e:	10 92 a4 00 	sts	0x00A4, r1
806
		  crc += SioTmp;
807
     5a2:	20 91 9c 00 	lds	r18, 0x009C
808
     5a6:	80 91 9f 00 	lds	r24, 0x009F
809
     5aa:	90 91 a0 00 	lds	r25, 0x00A0
810
     5ae:	82 0f       	add	r24, r18
811
     5b0:	91 1d       	adc	r25, r1
812
     5b2:	90 93 a0 00 	sts	0x00A0, r25
813
     5b6:	80 93 9f 00 	sts	0x009F, r24
814
		  break;
815
     5ba:	02 c0       	rjmp	.+4      	; 0x5c0 <__vector_13+0x190>
816
   default:
817
          UartState = 0;
818
     5bc:	10 92 a4 00 	sts	0x00A4, r1
819
     5c0:	ff 91       	pop	r31
820
     5c2:	ef 91       	pop	r30
821
     5c4:	bf 91       	pop	r27
822
     5c6:	af 91       	pop	r26
823
     5c8:	9f 91       	pop	r25
824
     5ca:	8f 91       	pop	r24
825
     5cc:	5f 91       	pop	r21
826
     5ce:	4f 91       	pop	r20
827
     5d0:	3f 91       	pop	r19
828
     5d2:	2f 91       	pop	r18
829
     5d4:	0f 90       	pop	r0
830
     5d6:	0f be       	out	0x3f, r0	; 63
831
     5d8:	0f 90       	pop	r0
832
     5da:	1f 90       	pop	r1
833
     5dc:	18 95       	reti
834
 
835
000005de <AddCRC>:
836
          break;
837
  }
838
};
839
 
840
// --------------------------------------------------------------------------
841
void AddCRC(unsigned int wieviele)
842
{
843
     5de:	ac 01       	movw	r20, r24
844
 unsigned int tmpCRC = 0,i;
845
     5e0:	a0 e0       	ldi	r26, 0x00	; 0
846
     5e2:	b0 e0       	ldi	r27, 0x00	; 0
847
 for(i = 0; i < wieviele;i++)
848
     5e4:	9d 01       	movw	r18, r26
849
     5e6:	a8 17       	cp	r26, r24
850
     5e8:	b9 07       	cpc	r27, r25
851
     5ea:	48 f4       	brcc	.+18     	; 0x5fe <AddCRC+0x20>
852
     5ec:	ee ee       	ldi	r30, 0xEE	; 238
853
     5ee:	f0 e0       	ldi	r31, 0x00	; 0
854
  {
855
   tmpCRC += SendeBuffer[i];
856
     5f0:	81 91       	ld	r24, Z+
857
     5f2:	28 0f       	add	r18, r24
858
     5f4:	31 1d       	adc	r19, r1
859
     5f6:	11 96       	adiw	r26, 0x01	; 1
860
     5f8:	a4 17       	cp	r26, r20
861
     5fa:	b5 07       	cpc	r27, r21
862
     5fc:	c8 f3       	brcs	.-14     	; 0x5f0 <AddCRC+0x12>
863
  }
864
   tmpCRC %= 4096;
865
     5fe:	3f 70       	andi	r19, 0x0F	; 15
866
   SendeBuffer[i++] = '=' + tmpCRC / 64;
867
     600:	fd 01       	movw	r30, r26
868
     602:	e2 51       	subi	r30, 0x12	; 18
869
     604:	ff 4f       	sbci	r31, 0xFF	; 255
870
     606:	c9 01       	movw	r24, r18
871
     608:	56 e0       	ldi	r21, 0x06	; 6
872
     60a:	96 95       	lsr	r25
873
     60c:	87 95       	ror	r24
874
     60e:	5a 95       	dec	r21
875
     610:	e1 f7       	brne	.-8      	; 0x60a <AddCRC+0x2c>
876
     612:	83 5c       	subi	r24, 0xC3	; 195
877
     614:	80 83       	st	Z, r24
878
     616:	11 96       	adiw	r26, 0x01	; 1
879
   SendeBuffer[i++] = '=' + tmpCRC % 64;
880
     618:	fd 01       	movw	r30, r26
881
     61a:	e2 51       	subi	r30, 0x12	; 18
882
     61c:	ff 4f       	sbci	r31, 0xFF	; 255
883
     61e:	2f 73       	andi	r18, 0x3F	; 63
884
     620:	30 70       	andi	r19, 0x00	; 0
885
     622:	82 2f       	mov	r24, r18
886
     624:	83 5c       	subi	r24, 0xC3	; 195
887
     626:	80 83       	st	Z, r24
888
   SendeBuffer[i++] = '\r';
889
     628:	a1 51       	subi	r26, 0x11	; 17
890
     62a:	bf 4f       	sbci	r27, 0xFF	; 255
891
     62c:	8d e0       	ldi	r24, 0x0D	; 13
892
     62e:	8c 93       	st	X, r24
893
  UebertragungAbgeschlossen = 0;
894
     630:	10 92 6e 00 	sts	0x006E, r1
895
  UDR = SendeBuffer[0];
896
     634:	80 91 ee 00 	lds	r24, 0x00EE
897
     638:	8c b9       	out	0x0c, r24	; 12
898
     63a:	08 95       	ret
899
 
900
0000063c <SendOutData>:
901
// PrintSendeBuffer();
902
}
903
 
904
 
905
// --------------------------------------------------------------------------
906
void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
907
{
908
     63c:	1f 93       	push	r17
909
     63e:	cf 93       	push	r28
910
     640:	df 93       	push	r29
911
     642:	38 2f       	mov	r19, r24
912
     644:	96 2f       	mov	r25, r22
913
     646:	ea 01       	movw	r28, r20
914
     648:	72 2f       	mov	r23, r18
915
 unsigned int pt = 0,i;
916
 unsigned char a,b,c,d;
917
 unsigned char ptr = 0;
918
     64a:	10 e0       	ldi	r17, 0x00	; 0
919
 unsigned char x,y,z;
920
 //while(!UebertragungAbgeschlossen);
921
 SendeBuffer[pt++] = '#';           // Startzeichen
922
     64c:	83 e2       	ldi	r24, 0x23	; 35
923
     64e:	80 93 ee 00 	sts	0x00EE, r24
924
 SendeBuffer[pt++] = modul+'a'; // Adresse (a=0; b=1,...)
925
     652:	9f 59       	subi	r25, 0x9F	; 159
926
     654:	90 93 ef 00 	sts	0x00EF, r25
927
 SendeBuffer[pt++] = cmd;		  // Commando
928
     658:	30 93 f0 00 	sts	0x00F0, r19
929
     65c:	a3 e0       	ldi	r26, 0x03	; 3
930
     65e:	b0 e0       	ldi	r27, 0x00	; 0
931
 
932
 while(len)
933
  {
934
   if(len) { a = snd[ptr++]; len--;} else a = 0;
935
   if(len) { b = snd[ptr++]; len--;} else b = 0;
936
   if(len) { c = snd[ptr++]; len--;} else c = 0;
937
   SendeBuffer[pt++] = '=' + (a >> 2);
938
   SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
939
   SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
940
   SendeBuffer[pt++] = '=' + ( c & 0x3f);
941
     660:	77 23       	and	r23, r23
942
     662:	09 f4       	brne	.+2      	; 0x666 <SendOutData+0x2a>
943
     664:	58 c0       	rjmp	.+176    	; 0x716 <SendOutData+0xda>
944
     666:	77 23       	and	r23, r23
945
     668:	11 f4       	brne	.+4      	; 0x66e <SendOutData+0x32>
946
     66a:	97 2f       	mov	r25, r23
947
     66c:	07 c0       	rjmp	.+14     	; 0x67c <SendOutData+0x40>
948
     66e:	fe 01       	movw	r30, r28
949
     670:	e1 0f       	add	r30, r17
950
     672:	f1 1d       	adc	r31, r1
951
     674:	1f 5f       	subi	r17, 0xFF	; 255
952
     676:	90 81       	ld	r25, Z
953
     678:	71 50       	subi	r23, 0x01	; 1
954
     67a:	11 f4       	brne	.+4      	; 0x680 <SendOutData+0x44>
955
     67c:	47 2f       	mov	r20, r23
956
     67e:	0e c0       	rjmp	.+28     	; 0x69c <SendOutData+0x60>
957
     680:	fe 01       	movw	r30, r28
958
     682:	e1 0f       	add	r30, r17
959
     684:	f1 1d       	adc	r31, r1
960
     686:	1f 5f       	subi	r17, 0xFF	; 255
961
     688:	40 81       	ld	r20, Z
962
     68a:	71 50       	subi	r23, 0x01	; 1
963
     68c:	39 f0       	breq	.+14     	; 0x69c <SendOutData+0x60>
964
     68e:	fe 01       	movw	r30, r28
965
     690:	e1 0f       	add	r30, r17
966
     692:	f1 1d       	adc	r31, r1
967
     694:	1f 5f       	subi	r17, 0xFF	; 255
968
     696:	60 81       	ld	r22, Z
969
     698:	71 50       	subi	r23, 0x01	; 1
970
     69a:	01 c0       	rjmp	.+2      	; 0x69e <SendOutData+0x62>
971
     69c:	67 2f       	mov	r22, r23
972
     69e:	fd 01       	movw	r30, r26
973
     6a0:	e2 51       	subi	r30, 0x12	; 18
974
     6a2:	ff 4f       	sbci	r31, 0xFF	; 255
975
     6a4:	89 2f       	mov	r24, r25
976
     6a6:	86 95       	lsr	r24
977
     6a8:	86 95       	lsr	r24
978
     6aa:	83 5c       	subi	r24, 0xC3	; 195
979
     6ac:	80 83       	st	Z, r24
980
     6ae:	11 96       	adiw	r26, 0x01	; 1
981
     6b0:	fd 01       	movw	r30, r26
982
     6b2:	e2 51       	subi	r30, 0x12	; 18
983
     6b4:	ff 4f       	sbci	r31, 0xFF	; 255
984
     6b6:	89 2f       	mov	r24, r25
985
     6b8:	99 27       	eor	r25, r25
986
     6ba:	83 70       	andi	r24, 0x03	; 3
987
     6bc:	90 70       	andi	r25, 0x00	; 0
988
     6be:	24 e0       	ldi	r18, 0x04	; 4
989
     6c0:	88 0f       	add	r24, r24
990
     6c2:	99 1f       	adc	r25, r25
991
     6c4:	2a 95       	dec	r18
992
     6c6:	e1 f7       	brne	.-8      	; 0x6c0 <SendOutData+0x84>
993
     6c8:	55 27       	eor	r21, r21
994
     6ca:	9a 01       	movw	r18, r20
995
     6cc:	94 e0       	ldi	r25, 0x04	; 4
996
     6ce:	36 95       	lsr	r19
997
     6d0:	27 95       	ror	r18
998
     6d2:	9a 95       	dec	r25
999
     6d4:	e1 f7       	brne	.-8      	; 0x6ce <SendOutData+0x92>
1000
     6d6:	82 2b       	or	r24, r18
1001
     6d8:	83 5c       	subi	r24, 0xC3	; 195
1002
     6da:	80 83       	st	Z, r24
1003
     6dc:	11 96       	adiw	r26, 0x01	; 1
1004
     6de:	fd 01       	movw	r30, r26
1005
     6e0:	e2 51       	subi	r30, 0x12	; 18
1006
     6e2:	ff 4f       	sbci	r31, 0xFF	; 255
1007
     6e4:	4f 70       	andi	r20, 0x0F	; 15
1008
     6e6:	50 70       	andi	r21, 0x00	; 0
1009
     6e8:	44 0f       	add	r20, r20
1010
     6ea:	55 1f       	adc	r21, r21
1011
     6ec:	44 0f       	add	r20, r20
1012
     6ee:	55 1f       	adc	r21, r21
1013
     6f0:	86 2f       	mov	r24, r22
1014
     6f2:	99 27       	eor	r25, r25
1015
     6f4:	26 e0       	ldi	r18, 0x06	; 6
1016
     6f6:	96 95       	lsr	r25
1017
     6f8:	87 95       	ror	r24
1018
     6fa:	2a 95       	dec	r18
1019
     6fc:	e1 f7       	brne	.-8      	; 0x6f6 <SendOutData+0xba>
1020
     6fe:	84 2b       	or	r24, r20
1021
     700:	83 5c       	subi	r24, 0xC3	; 195
1022
     702:	80 83       	st	Z, r24
1023
     704:	11 96       	adiw	r26, 0x01	; 1
1024
     706:	fd 01       	movw	r30, r26
1025
     708:	e2 51       	subi	r30, 0x12	; 18
1026
     70a:	ff 4f       	sbci	r31, 0xFF	; 255
1027
     70c:	6f 73       	andi	r22, 0x3F	; 63
1028
     70e:	63 5c       	subi	r22, 0xC3	; 195
1029
     710:	60 83       	st	Z, r22
1030
     712:	11 96       	adiw	r26, 0x01	; 1
1031
     714:	a5 cf       	rjmp	.-182    	; 0x660 <SendOutData+0x24>
1032
  }
1033
 AddCRC(pt);
1034
     716:	cd 01       	movw	r24, r26
1035
     718:	0e 94 ef 02 	call	0x5de <AddCRC>
1036
     71c:	df 91       	pop	r29
1037
     71e:	cf 91       	pop	r28
1038
     720:	1f 91       	pop	r17
1039
     722:	08 95       	ret
1040
 
1041
00000724 <Decode64>:
1042
}
1043
 
1044
// --------------------------------------------------------------------------
1045
void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)  // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
1046
{
1047
     724:	1f 93       	push	r17
1048
     726:	cf 93       	push	r28
1049
     728:	df 93       	push	r29
1050
     72a:	ec 01       	movw	r28, r24
1051
 unsigned char a,b,c,d;
1052
 unsigned char ptr = 0;
1053
     72c:	10 e0       	ldi	r17, 0x00	; 0
1054
 unsigned char x,y,z;
1055
 while(len)
1056
  {
1057
   a = RxdBuffer[ptrIn++] - '=';
1058
   b = RxdBuffer[ptrIn++] - '=';
1059
   c = RxdBuffer[ptrIn++] - '=';
1060
   d = RxdBuffer[ptrIn++] - '=';
1061
   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden
1062
 
1063
   x = (a << 2) | (b >> 4);
1064
   y = ((b & 0x0f) << 4) | (c >> 2);
1065
   z = ((c & 0x03) << 6) | d;
1066
 
1067
   if(len--) ptrOut[ptr++] = x; else break;
1068
   if(len--) ptrOut[ptr++] = y; else break;
1069
   if(len--) ptrOut[ptr++] = z;	else break;
1070
     72e:	66 23       	and	r22, r22
1071
     730:	09 f4       	brne	.+2      	; 0x734 <Decode64+0x10>
1072
     732:	60 c0       	rjmp	.+192    	; 0x7f4 <Decode64+0xd0>
1073
     734:	a2 2f       	mov	r26, r18
1074
     736:	bb 27       	eor	r27, r27
1075
     738:	12 97       	sbiw	r26, 0x02	; 2
1076
     73a:	e4 2f       	mov	r30, r20
1077
     73c:	ff 27       	eor	r31, r31
1078
     73e:	ee 5a       	subi	r30, 0xAE	; 174
1079
     740:	fe 4f       	sbci	r31, 0xFE	; 254
1080
     742:	30 81       	ld	r19, Z
1081
     744:	3d 53       	subi	r19, 0x3D	; 61
1082
     746:	4f 5f       	subi	r20, 0xFF	; 255
1083
     748:	e4 2f       	mov	r30, r20
1084
     74a:	ff 27       	eor	r31, r31
1085
     74c:	ee 5a       	subi	r30, 0xAE	; 174
1086
     74e:	fe 4f       	sbci	r31, 0xFE	; 254
1087
     750:	50 81       	ld	r21, Z
1088
     752:	5d 53       	subi	r21, 0x3D	; 61
1089
     754:	4f 5f       	subi	r20, 0xFF	; 255
1090
     756:	e4 2f       	mov	r30, r20
1091
     758:	ff 27       	eor	r31, r31
1092
     75a:	ee 5a       	subi	r30, 0xAE	; 174
1093
     75c:	fe 4f       	sbci	r31, 0xFE	; 254
1094
     75e:	70 81       	ld	r23, Z
1095
     760:	7d 53       	subi	r23, 0x3D	; 61
1096
     762:	4f 5f       	subi	r20, 0xFF	; 255
1097
     764:	e4 2f       	mov	r30, r20
1098
     766:	ff 27       	eor	r31, r31
1099
     768:	ee 5a       	subi	r30, 0xAE	; 174
1100
     76a:	fe 4f       	sbci	r31, 0xFE	; 254
1101
     76c:	e0 81       	ld	r30, Z
1102
     76e:	ed 53       	subi	r30, 0x3D	; 61
1103
     770:	4f 5f       	subi	r20, 0xFF	; 255
1104
     772:	84 2f       	mov	r24, r20
1105
     774:	99 27       	eor	r25, r25
1106
     776:	a8 17       	cp	r26, r24
1107
     778:	b9 07       	cpc	r27, r25
1108
     77a:	e4 f1       	brlt	.+120    	; 0x7f4 <Decode64+0xd0>
1109
     77c:	83 2f       	mov	r24, r19
1110
     77e:	99 27       	eor	r25, r25
1111
     780:	88 0f       	add	r24, r24
1112
     782:	99 1f       	adc	r25, r25
1113
     784:	88 0f       	add	r24, r24
1114
     786:	99 1f       	adc	r25, r25
1115
     788:	35 2f       	mov	r19, r21
1116
     78a:	32 95       	swap	r19
1117
     78c:	3f 70       	andi	r19, 0x0F	; 15
1118
     78e:	38 2b       	or	r19, r24
1119
     790:	85 2f       	mov	r24, r21
1120
     792:	99 27       	eor	r25, r25
1121
     794:	8f 70       	andi	r24, 0x0F	; 15
1122
     796:	90 70       	andi	r25, 0x00	; 0
1123
     798:	f4 e0       	ldi	r31, 0x04	; 4
1124
     79a:	88 0f       	add	r24, r24
1125
     79c:	99 1f       	adc	r25, r25
1126
     79e:	fa 95       	dec	r31
1127
     7a0:	e1 f7       	brne	.-8      	; 0x79a <Decode64+0x76>
1128
     7a2:	57 2f       	mov	r21, r23
1129
     7a4:	56 95       	lsr	r21
1130
     7a6:	56 95       	lsr	r21
1131
     7a8:	58 2b       	or	r21, r24
1132
     7aa:	87 2f       	mov	r24, r23
1133
     7ac:	99 27       	eor	r25, r25
1134
     7ae:	83 70       	andi	r24, 0x03	; 3
1135
     7b0:	90 70       	andi	r25, 0x00	; 0
1136
     7b2:	76 e0       	ldi	r23, 0x06	; 6
1137
     7b4:	88 0f       	add	r24, r24
1138
     7b6:	99 1f       	adc	r25, r25
1139
     7b8:	7a 95       	dec	r23
1140
     7ba:	e1 f7       	brne	.-8      	; 0x7b4 <Decode64+0x90>
1141
     7bc:	8e 2b       	or	r24, r30
1142
     7be:	61 50       	subi	r22, 0x01	; 1
1143
     7c0:	6f 3f       	cpi	r22, 0xFF	; 255
1144
     7c2:	c1 f0       	breq	.+48     	; 0x7f4 <Decode64+0xd0>
1145
     7c4:	fe 01       	movw	r30, r28
1146
     7c6:	e1 0f       	add	r30, r17
1147
     7c8:	f1 1d       	adc	r31, r1
1148
     7ca:	30 83       	st	Z, r19
1149
     7cc:	1f 5f       	subi	r17, 0xFF	; 255
1150
     7ce:	61 50       	subi	r22, 0x01	; 1
1151
     7d0:	6f 3f       	cpi	r22, 0xFF	; 255
1152
     7d2:	81 f0       	breq	.+32     	; 0x7f4 <Decode64+0xd0>
1153
     7d4:	fe 01       	movw	r30, r28
1154
     7d6:	e1 0f       	add	r30, r17
1155
     7d8:	f1 1d       	adc	r31, r1
1156
     7da:	50 83       	st	Z, r21
1157
     7dc:	1f 5f       	subi	r17, 0xFF	; 255
1158
     7de:	61 50       	subi	r22, 0x01	; 1
1159
     7e0:	6f 3f       	cpi	r22, 0xFF	; 255
1160
     7e2:	41 f0       	breq	.+16     	; 0x7f4 <Decode64+0xd0>
1161
     7e4:	fe 01       	movw	r30, r28
1162
     7e6:	e1 0f       	add	r30, r17
1163
     7e8:	f1 1d       	adc	r31, r1
1164
     7ea:	80 83       	st	Z, r24
1165
     7ec:	1f 5f       	subi	r17, 0xFF	; 255
1166
     7ee:	66 23       	and	r22, r22
1167
     7f0:	09 f0       	breq	.+2      	; 0x7f4 <Decode64+0xd0>
1168
     7f2:	a3 cf       	rjmp	.-186    	; 0x73a <Decode64+0x16>
1169
     7f4:	df 91       	pop	r29
1170
     7f6:	cf 91       	pop	r28
1171
     7f8:	1f 91       	pop	r17
1172
     7fa:	08 95       	ret
1173
 
1174
000007fc <BearbeiteRxDaten>:
1175
  }
1176
 
1177
}
1178
 
1179
// --------------------------------------------------------------------------
1180
void BearbeiteRxDaten(void)
1181
{
1182
     7fc:	cf 93       	push	r28
1183
     7fe:	df 93       	push	r29
1184
     800:	cd b7       	in	r28, 0x3d	; 61
1185
     802:	de b7       	in	r29, 0x3e	; 62
1186
     804:	ad 97       	sbiw	r28, 0x2d	; 45
1187
     806:	0f b6       	in	r0, 0x3f	; 63
1188
     808:	f8 94       	cli
1189
     80a:	de bf       	out	0x3e, r29	; 62
1190
     80c:	0f be       	out	0x3f, r0	; 63
1191
     80e:	cd bf       	out	0x3d, r28	; 61
1192
 unsigned int tmp_int_arr1[1];
1193
 unsigned int tmp_int_arr2[2];
1194
 unsigned int tmp_int_arr20[21];
1195
 unsigned char tmp_char_arr3[3];
1196
// unsigned int tmp_int_arr4[4];
1197
 
1198
 if(!NeuerDatensatzEmpfangen) return;
1199
     810:	80 91 9b 00 	lds	r24, 0x009B
1200
     814:	88 23       	and	r24, r24
1201
     816:	09 f4       	brne	.+2      	; 0x81a <BearbeiteRxDaten+0x1e>
1202
     818:	a7 c0       	rjmp	.+334    	; 0x968 <__stack+0x109>
1203
 NeuerDatensatzEmpfangen = 0;
1204
     81a:	10 92 9b 00 	sts	0x009B, r1
1205
 if(ErwarteAntwort == RxdBuffer[2]) AntwortEingetroffen = 1;
1206
     81e:	90 91 6d 00 	lds	r25, 0x006D
1207
     822:	80 91 54 01 	lds	r24, 0x0154
1208
     826:	98 17       	cp	r25, r24
1209
     828:	19 f4       	brne	.+6      	; 0x830 <BearbeiteRxDaten+0x34>
1210
     82a:	81 e0       	ldi	r24, 0x01	; 1
1211
     82c:	80 93 92 00 	sts	0x0092, r24
1212
 switch(RxdBuffer[2])
1213
     830:	80 91 54 01 	lds	r24, 0x0154
1214
     834:	99 27       	eor	r25, r25
1215
     836:	82 33       	cpi	r24, 0x32	; 50
1216
     838:	91 05       	cpc	r25, r1
1217
     83a:	09 f4       	brne	.+2      	; 0x83e <BearbeiteRxDaten+0x42>
1218
     83c:	46 c0       	rjmp	.+140    	; 0x8ca <__stack+0x6b>
1219
     83e:	83 33       	cpi	r24, 0x33	; 51
1220
     840:	91 05       	cpc	r25, r1
1221
     842:	34 f4       	brge	.+12     	; 0x850 <BearbeiteRxDaten+0x54>
1222
     844:	80 33       	cpi	r24, 0x30	; 48
1223
     846:	91 05       	cpc	r25, r1
1224
     848:	99 f0       	breq	.+38     	; 0x870 <__stack+0x11>
1225
     84a:	c1 97       	sbiw	r24, 0x31	; 49
1226
     84c:	49 f1       	breq	.+82     	; 0x8a0 <__stack+0x41>
1227
     84e:	8c c0       	rjmp	.+280    	; 0x968 <__stack+0x109>
1228
     850:	84 34       	cpi	r24, 0x44	; 68
1229
     852:	91 05       	cpc	r25, r1
1230
     854:	09 f4       	brne	.+2      	; 0x858 <BearbeiteRxDaten+0x5c>
1231
     856:	6b c0       	rjmp	.+214    	; 0x92e <__stack+0xcf>
1232
     858:	85 34       	cpi	r24, 0x45	; 69
1233
     85a:	91 05       	cpc	r25, r1
1234
     85c:	24 f4       	brge	.+8      	; 0x866 <__stack+0x7>
1235
     85e:	c3 97       	sbiw	r24, 0x33	; 51
1236
     860:	09 f4       	brne	.+2      	; 0x864 <__stack+0x5>
1237
     862:	48 c0       	rjmp	.+144    	; 0x8f4 <__stack+0x95>
1238
     864:	81 c0       	rjmp	.+258    	; 0x968 <__stack+0x109>
1239
     866:	8b 34       	cpi	r24, 0x4B	; 75
1240
     868:	91 05       	cpc	r25, r1
1241
     86a:	09 f4       	brne	.+2      	; 0x86e <__stack+0xf>
1242
     86c:	6c c0       	rjmp	.+216    	; 0x946 <__stack+0xe7>
1243
     86e:	7c c0       	rjmp	.+248    	; 0x968 <__stack+0x109>
1244
  {
1245
   case '0':// LCD-Zeile0
1246
            Decode64((unsigned char *) &tmp_int_arr20,sizeof(tmp_int_arr20),3,AnzahlEmpfangsBytes);
1247
     870:	20 91 98 00 	lds	r18, 0x0098
1248
     874:	43 e0       	ldi	r20, 0x03	; 3
1249
     876:	6a e2       	ldi	r22, 0x2A	; 42
1250
     878:	ce 01       	movw	r24, r28
1251
     87a:	01 96       	adiw	r24, 0x01	; 1
1252
     87c:	0e 94 92 03 	call	0x724 <Decode64>
1253
            tmp_int_arr20[20] = 0;
1254
     880:	1a a6       	std	Y+42, r1	; 0x2a
1255
     882:	19 a6       	std	Y+41, r1	; 0x29
1256
			DisplayBusy = 1;
1257
     884:	81 e0       	ldi	r24, 0x01	; 1
1258
     886:	80 93 93 00 	sts	0x0093, r24
1259
            LCD_printfxy(0,0,"%s",tmp_int_arr20);
1260
     88a:	60 e0       	ldi	r22, 0x00	; 0
1261
     88c:	86 2f       	mov	r24, r22
1262
     88e:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
1263
     892:	ce 01       	movw	r24, r28
1264
     894:	01 96       	adiw	r24, 0x01	; 1
1265
     896:	9f 93       	push	r25
1266
     898:	8f 93       	push	r24
1267
     89a:	88 ea       	ldi	r24, 0xA8	; 168
1268
     89c:	90 e0       	ldi	r25, 0x00	; 0
1269
     89e:	3e c0       	rjmp	.+124    	; 0x91c <__stack+0xbd>
1270
            break;
1271
   case '1':// LCD-Zeile1
1272
            Decode64((unsigned char *) &tmp_int_arr20,sizeof(tmp_int_arr20),3,AnzahlEmpfangsBytes);
1273
     8a0:	20 91 98 00 	lds	r18, 0x0098
1274
     8a4:	43 e0       	ldi	r20, 0x03	; 3
1275
     8a6:	6a e2       	ldi	r22, 0x2A	; 42
1276
     8a8:	ce 01       	movw	r24, r28
1277
     8aa:	01 96       	adiw	r24, 0x01	; 1
1278
     8ac:	0e 94 92 03 	call	0x724 <Decode64>
1279
            tmp_int_arr20[20] = 0;
1280
     8b0:	1a a6       	std	Y+42, r1	; 0x2a
1281
     8b2:	19 a6       	std	Y+41, r1	; 0x29
1282
            LCD_printfxy(0,1,"%s",tmp_int_arr20);
1283
     8b4:	61 e0       	ldi	r22, 0x01	; 1
1284
     8b6:	80 e0       	ldi	r24, 0x00	; 0
1285
     8b8:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
1286
     8bc:	ce 01       	movw	r24, r28
1287
     8be:	01 96       	adiw	r24, 0x01	; 1
1288
     8c0:	9f 93       	push	r25
1289
     8c2:	8f 93       	push	r24
1290
     8c4:	8b ea       	ldi	r24, 0xAB	; 171
1291
     8c6:	90 e0       	ldi	r25, 0x00	; 0
1292
     8c8:	29 c0       	rjmp	.+82     	; 0x91c <__stack+0xbd>
1293
            break;
1294
   case '2':// LCD-Zeile2
1295
            Decode64((unsigned char *) &tmp_int_arr20,sizeof(tmp_int_arr20),3,AnzahlEmpfangsBytes);
1296
     8ca:	20 91 98 00 	lds	r18, 0x0098
1297
     8ce:	43 e0       	ldi	r20, 0x03	; 3
1298
     8d0:	6a e2       	ldi	r22, 0x2A	; 42
1299
     8d2:	ce 01       	movw	r24, r28
1300
     8d4:	01 96       	adiw	r24, 0x01	; 1
1301
     8d6:	0e 94 92 03 	call	0x724 <Decode64>
1302
            tmp_int_arr20[20] = 0;
1303
     8da:	1a a6       	std	Y+42, r1	; 0x2a
1304
     8dc:	19 a6       	std	Y+41, r1	; 0x29
1305
            LCD_printfxy(0,2,"%s",tmp_int_arr20);
1306
     8de:	62 e0       	ldi	r22, 0x02	; 2
1307
     8e0:	80 e0       	ldi	r24, 0x00	; 0
1308
     8e2:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
1309
     8e6:	ce 01       	movw	r24, r28
1310
     8e8:	01 96       	adiw	r24, 0x01	; 1
1311
     8ea:	9f 93       	push	r25
1312
     8ec:	8f 93       	push	r24
1313
     8ee:	8e ea       	ldi	r24, 0xAE	; 174
1314
     8f0:	90 e0       	ldi	r25, 0x00	; 0
1315
     8f2:	14 c0       	rjmp	.+40     	; 0x91c <__stack+0xbd>
1316
            break;
1317
   case '3':// LCD-Zeile3
1318
            Decode64((unsigned char *) &tmp_int_arr20,sizeof(tmp_int_arr20),3,AnzahlEmpfangsBytes);
1319
     8f4:	20 91 98 00 	lds	r18, 0x0098
1320
     8f8:	43 e0       	ldi	r20, 0x03	; 3
1321
     8fa:	6a e2       	ldi	r22, 0x2A	; 42
1322
     8fc:	ce 01       	movw	r24, r28
1323
     8fe:	01 96       	adiw	r24, 0x01	; 1
1324
     900:	0e 94 92 03 	call	0x724 <Decode64>
1325
            tmp_int_arr20[20] = 0;
1326
     904:	1a a6       	std	Y+42, r1	; 0x2a
1327
     906:	19 a6       	std	Y+41, r1	; 0x29
1328
            LCD_printfxy(0,3,"%s",tmp_int_arr20);
1329
     908:	63 e0       	ldi	r22, 0x03	; 3
1330
     90a:	80 e0       	ldi	r24, 0x00	; 0
1331
     90c:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
1332
     910:	ce 01       	movw	r24, r28
1333
     912:	01 96       	adiw	r24, 0x01	; 1
1334
     914:	9f 93       	push	r25
1335
     916:	8f 93       	push	r24
1336
     918:	81 eb       	ldi	r24, 0xB1	; 177
1337
     91a:	90 e0       	ldi	r25, 0x00	; 0
1338
     91c:	9f 93       	push	r25
1339
     91e:	8f 93       	push	r24
1340
     920:	0e 94 e3 06 	call	0xdc6 <_printf_P>
1341
            break;
1342
     924:	0f 90       	pop	r0
1343
     926:	0f 90       	pop	r0
1344
     928:	0f 90       	pop	r0
1345
     92a:	0f 90       	pop	r0
1346
     92c:	1d c0       	rjmp	.+58     	; 0x968 <__stack+0x109>
1347
   case 'D': // Debug Eingangsdaten
1348
            Decode64((unsigned char *) &DebugOut,sizeof(DebugOut),3,AnzahlEmpfangsBytes);
1349
     92e:	20 91 98 00 	lds	r18, 0x0098
1350
     932:	43 e0       	ldi	r20, 0x03	; 3
1351
     934:	6a e1       	ldi	r22, 0x1A	; 26
1352
     936:	83 ed       	ldi	r24, 0xD3	; 211
1353
     938:	90 e0       	ldi	r25, 0x00	; 0
1354
     93a:	0e 94 92 03 	call	0x724 <Decode64>
1355
			PORTB = DebugOut.Digital[1];
1356
     93e:	80 91 d4 00 	lds	r24, 0x00D4
1357
     942:	88 bb       	out	0x18, r24	; 24
1358
			break;
1359
     944:	11 c0       	rjmp	.+34     	; 0x968 <__stack+0x109>
1360
   case 'K': // Debug Eingangsdaten
1361
            Decode64(tmp_char_arr3,sizeof(tmp_char_arr3),3,AnzahlEmpfangsBytes);
1362
     946:	20 91 98 00 	lds	r18, 0x0098
1363
     94a:	43 e0       	ldi	r20, 0x03	; 3
1364
     94c:	64 2f       	mov	r22, r20
1365
     94e:	ce 01       	movw	r24, r28
1366
     950:	8b 96       	adiw	r24, 0x2b	; 43
1367
     952:	0e 94 92 03 	call	0x724 <Decode64>
1368
            TX_DigTransferKanalL =  tmp_char_arr3[0];
1369
     956:	8b a5       	ldd	r24, Y+43	; 0x2b
1370
     958:	80 93 96 00 	sts	0x0096, r24
1371
            TX_DigTransferKanalH =  tmp_char_arr3[1];
1372
     95c:	8c a5       	ldd	r24, Y+44	; 0x2c
1373
     95e:	80 93 95 00 	sts	0x0095, r24
1374
            TX_DigTransferKanalDaten = tmp_char_arr3[2];
1375
     962:	8d a5       	ldd	r24, Y+45	; 0x2d
1376
     964:	80 93 94 00 	sts	0x0094, r24
1377
     968:	ad 96       	adiw	r28, 0x2d	; 45
1378
     96a:	0f b6       	in	r0, 0x3f	; 63
1379
     96c:	f8 94       	cli
1380
     96e:	de bf       	out	0x3e, r29	; 62
1381
     970:	0f be       	out	0x3f, r0	; 63
1382
     972:	cd bf       	out	0x3d, r28	; 61
1383
     974:	df 91       	pop	r29
1384
     976:	cf 91       	pop	r28
1385
     978:	08 95       	ret
1386
 
1387
0000097a <uart_putchar>:
1388
//if(RxdBuffer[1] == 'b') LCD_printfxy(0,0,"b:%4d %2x",(int)TX_DigTransferKanalH * 256 + TX_DigTransferKanalL,TX_DigTransferKanalDaten);
1389
//if(RxdBuffer[1] == 'c') LCD_printfxy(0,1,"c:%4d %2x",(int)TX_DigTransferKanalH * 256 + TX_DigTransferKanalL,TX_DigTransferKanalDaten);
1390
			break;
1391
/*
1392
 unsigned char Digital[13]; // 0      = Taster, Hauptkarte
1393
                            // 1 + 2  = Debugkanäle
1394
                          	// 3      = Digin,  Hauptkarte
1395
                          	// 4      = Relais, Hauptkarte
1396
							// 5 + 6  = Extern IO1 (12Bit ein 4 Bit aus)
1397
							// 7 + 8  = Extern IO2 (12Bit ein 4 Bit aus)
1398
							// 9 + 10 = Extern IO3 (12Bit ein 4 Bit aus)
1399
							// 11 + 12= Extern IO4 (12Bit ein 4 Bit aus)
1400
*/
1401
 
1402
/*   case 'd': // Debug Eingangsdaten
1403
            Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes);
1404
         	for(unsigned char i=0; i<4;i++)
1405
			 {
1406
              EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2],     DebugIn.Analog[i]);
1407
			  EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8);
1408
			 }
1409
            break;
1410
   case 'g': // "Get"-Anforderung für Debug-Daten // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
1411
            DebugGetAnforderung = 1;
1412
            break;
1413
   case 'v': // Version-Anforderung	und Ausbaustufe
1414
            GetVersionAnforderung = 1;
1415
            break;
1416
   case 'u': // Uhr stellen
1417
            Decode64((unsigned char *) &tmp_int_arr2[0],sizeof(tmp_int_arr2),3,AnzahlEmpfangsBytes);
1418
			ZEITWERT = tmp_int_arr2[0];
1419
			SEK = tmp_int_arr2[1];
1420
            make_time_variables(ZEITWERT);
1421
            RTC_SetTime(STD, MIN, SEK);
1422
            RTC_SetWDay(TAG);
1423
            break;
1424
   case 'i': // Intervalle für die Datenübertragung
1425
            Decode64((unsigned char *) &tmp_int_arr2[0],sizeof(tmp_int_arr2),3,AnzahlEmpfangsBytes);
1426
			Debug_Timer_Intervall =   tmp_int_arr2[0];
1427
			Debug_Display_Intervall = tmp_int_arr2[1];
1428
			SendeDummyDaten = 1;
1429
			break;
1430
   case 's': // single Step	1 = Stop   2 = noch einen Zyklus   3 = noch 2 Zyklen
1431
            Decode64((unsigned char *) &tmp_int_arr1[0],sizeof(tmp_int_arr2),3,AnzahlEmpfangsBytes);
1432
			SingleStep = tmp_int_arr1[0];
1433
			break;
1434
*/
1435
 }
1436
}
1437
 
1438
//############################################################################
1439
//Routine für die Serielle Ausgabe
1440
int uart_putchar (char c)
1441
//############################################################################
1442
{
1443
     97a:	cf 93       	push	r28
1444
     97c:	c8 2f       	mov	r28, r24
1445
	if (c == '\n')
1446
     97e:	8a 30       	cpi	r24, 0x0A	; 10
1447
     980:	19 f4       	brne	.+6      	; 0x988 <uart_putchar+0xe>
1448
		uart_putchar('\r');
1449
     982:	8d e0       	ldi	r24, 0x0D	; 13
1450
     984:	0e 94 bd 04 	call	0x97a <uart_putchar>
1451
	//Warten solange bis Zeichen gesendet wurde
1452
	loop_until_bit_is_set(USR, UDRE);
1453
     988:	5d 9b       	sbis	0x0b, 5	; 11
1454
     98a:	fe cf       	rjmp	.-4      	; 0x988 <uart_putchar+0xe>
1455
	//Ausgabe des Zeichens
1456
	UDR = c;
1457
     98c:	cc b9       	out	0x0c, r28	; 12
1458
 
1459
	return (0);
1460
}
1461
     98e:	80 e0       	ldi	r24, 0x00	; 0
1462
     990:	90 e0       	ldi	r25, 0x00	; 0
1463
     992:	cf 91       	pop	r28
1464
     994:	08 95       	ret
1465
 
1466
00000996 <WriteProgramData>:
1467
 
1468
// --------------------------------------------------------------------------
1469
void WriteProgramData(unsigned int pos, unsigned char wert)
1470
{
1471
     996:	08 95       	ret
1472
 
1473
00000998 <UART_Init>:
1474
  //if (ProgramLocation == IN_RAM) Buffer[pos] = wert;
1475
  // else eeprom_write_byte(&EE_Buffer[pos], wert);
1476
  // Buffer[pos] = wert;
1477
}
1478
 
1479
//############################################################################
1480
//INstallation der Seriellen Schnittstelle
1481
void UART_Init (void)
1482
//############################################################################
1483
{
1484
	//Enable TXEN im Register UCR TX-Data Enable & RX Enable
1485
 
1486
	UCR=(1 << TXEN) | (1 << RXEN);
1487
     998:	88 e1       	ldi	r24, 0x18	; 24
1488
     99a:	8a b9       	out	0x0a, r24	; 10
1489
    // UART Double Speed (U2X)
1490
	USR   |= (1<<U2X);
1491
     99c:	59 9a       	sbi	0x0b, 1	; 11
1492
	// RX-Interrupt Freigabe
1493
	UCSRB |= (1<<RXCIE);
1494
     99e:	57 9a       	sbi	0x0a, 7	; 10
1495
	// TX-Interrupt Freigabe
1496
	UCSRB |= (1<<TXCIE);
1497
     9a0:	56 9a       	sbi	0x0a, 6	; 10
1498
 
1499
	//Teiler wird gesetzt
1500
	UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
1501
     9a2:	81 e2       	ldi	r24, 0x21	; 33
1502
     9a4:	89 b9       	out	0x09, r24	; 9
1503
	//UBRR = 33;
1504
	//öffnet einen Kanal für printf (STDOUT)
1505
	fdevopen (uart_putchar, NULL);
1506
     9a6:	60 e0       	ldi	r22, 0x00	; 0
1507
     9a8:	70 e0       	ldi	r23, 0x00	; 0
1508
     9aa:	8d eb       	ldi	r24, 0xBD	; 189
1509
     9ac:	94 e0       	ldi	r25, 0x04	; 4
1510
     9ae:	0e 94 71 0c 	call	0x18e2 <fdevopen>
1511
     9b2:	08 95       	ret
1512
 
1513
000009b4 <SendeRemoteTasten>:
1514
	//sbi(PORTD,4);
1515
}
1516
 
1517
/*
1518
struct str_DebugIn
1519
{
1520
 unsigned char Digital[2];
1521
 unsigned char RemoteTasten;
1522
 unsigned int Analog[4];
1523
};
1524
*/
1525
void SendeRemoteTasten(unsigned char keys)
1526
{
1527
     9b4:	98 2f       	mov	r25, r24
1528
 while(!UebertragungAbgeschlossen);  // evtl warten
1529
     9b6:	80 91 6e 00 	lds	r24, 0x006E
1530
     9ba:	88 23       	and	r24, r24
1531
     9bc:	e1 f3       	breq	.-8      	; 0x9b6 <SendeRemoteTasten+0x2>
1532
 DebugIn.RemoteTasten = keys;
1533
     9be:	90 93 c0 00 	sts	0x00C0, r25
1534
 DebugIn.Analog[0] = AnalogWerte[0];
1535
     9c2:	80 91 ca 01 	lds	r24, 0x01CA
1536
     9c6:	90 91 cb 01 	lds	r25, 0x01CB
1537
     9ca:	90 93 c2 00 	sts	0x00C2, r25
1538
     9ce:	80 93 c1 00 	sts	0x00C1, r24
1539
 DebugIn.Analog[1] = AnalogWerte[1];
1540
     9d2:	80 91 cc 01 	lds	r24, 0x01CC
1541
     9d6:	90 91 cd 01 	lds	r25, 0x01CD
1542
     9da:	90 93 c4 00 	sts	0x00C4, r25
1543
     9de:	80 93 c3 00 	sts	0x00C3, r24
1544
 DebugIn.Analog[2] = AnalogWerte[2];
1545
     9e2:	80 91 ce 01 	lds	r24, 0x01CE
1546
     9e6:	90 91 cf 01 	lds	r25, 0x01CF
1547
     9ea:	90 93 c6 00 	sts	0x00C6, r25
1548
     9ee:	80 93 c5 00 	sts	0x00C5, r24
1549
 DebugIn.Analog[3] = IR_Code;
1550
     9f2:	80 91 c7 01 	lds	r24, 0x01C7
1551
     9f6:	90 91 c8 01 	lds	r25, 0x01C8
1552
     9fa:	90 93 c8 00 	sts	0x00C8, r25
1553
     9fe:	80 93 c7 00 	sts	0x00C7, r24
1554
 SendOutData('d',SlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn));
1555
     a02:	2b e0       	ldi	r18, 0x0B	; 11
1556
     a04:	4e eb       	ldi	r20, 0xBE	; 190
1557
     a06:	50 e0       	ldi	r21, 0x00	; 0
1558
     a08:	60 91 64 00 	lds	r22, 0x0064
1559
     a0c:	84 e6       	ldi	r24, 0x64	; 100
1560
     a0e:	0e 94 1e 03 	call	0x63c <SendOutData>
1561
     a12:	08 95       	ret
1562
 
1563
00000a14 <SendIntervalle>:
1564
}
1565
 
1566
void SendIntervalle(unsigned int debug, unsigned int disp)
1567
{
1568
     a14:	cf 93       	push	r28
1569
     a16:	df 93       	push	r29
1570
     a18:	cd b7       	in	r28, 0x3d	; 61
1571
     a1a:	de b7       	in	r29, 0x3e	; 62
1572
     a1c:	24 97       	sbiw	r28, 0x04	; 4
1573
     a1e:	0f b6       	in	r0, 0x3f	; 63
1574
     a20:	f8 94       	cli
1575
     a22:	de bf       	out	0x3e, r29	; 62
1576
     a24:	0f be       	out	0x3f, r0	; 63
1577
     a26:	cd bf       	out	0x3d, r28	; 61
1578
 unsigned int tmp_int_arr2[2];
1579
 tmp_int_arr2[0] = debug;
1580
     a28:	9a 83       	std	Y+2, r25	; 0x02
1581
     a2a:	89 83       	std	Y+1, r24	; 0x01
1582
 tmp_int_arr2[1] = disp;
1583
     a2c:	7c 83       	std	Y+4, r23	; 0x04
1584
     a2e:	6b 83       	std	Y+3, r22	; 0x03
1585
 while(!UebertragungAbgeschlossen);  // evtl warten
1586
     a30:	80 91 6e 00 	lds	r24, 0x006E
1587
     a34:	88 23       	and	r24, r24
1588
     a36:	e1 f3       	breq	.-8      	; 0xa30 <SendIntervalle+0x1c>
1589
 SendOutData('i',SlaveAdresse,(unsigned char *) &tmp_int_arr2,sizeof(tmp_int_arr2));
1590
     a38:	24 e0       	ldi	r18, 0x04	; 4
1591
     a3a:	ae 01       	movw	r20, r28
1592
     a3c:	4f 5f       	subi	r20, 0xFF	; 255
1593
     a3e:	5f 4f       	sbci	r21, 0xFF	; 255
1594
     a40:	60 91 64 00 	lds	r22, 0x0064
1595
     a44:	89 e6       	ldi	r24, 0x69	; 105
1596
     a46:	0e 94 1e 03 	call	0x63c <SendOutData>
1597
     a4a:	24 96       	adiw	r28, 0x04	; 4
1598
     a4c:	0f b6       	in	r0, 0x3f	; 63
1599
     a4e:	f8 94       	cli
1600
     a50:	de bf       	out	0x3e, r29	; 62
1601
     a52:	0f be       	out	0x3f, r0	; 63
1602
     a54:	cd bf       	out	0x3d, r28	; 61
1603
     a56:	df 91       	pop	r29
1604
     a58:	cf 91       	pop	r28
1605
     a5a:	08 95       	ret
1606
 
1607
00000a5c <ClearIntervalle>:
1608
}
1609
 
1610
void ClearIntervalle(void)
1611
{
1612
     a5c:	cf 93       	push	r28
1613
     a5e:	df 93       	push	r29
1614
     a60:	cd b7       	in	r28, 0x3d	; 61
1615
     a62:	de b7       	in	r29, 0x3e	; 62
1616
     a64:	24 97       	sbiw	r28, 0x04	; 4
1617
     a66:	0f b6       	in	r0, 0x3f	; 63
1618
     a68:	f8 94       	cli
1619
     a6a:	de bf       	out	0x3e, r29	; 62
1620
     a6c:	0f be       	out	0x3f, r0	; 63
1621
     a6e:	cd bf       	out	0x3d, r28	; 61
1622
 unsigned int tmp_int_arr2[2];
1623
 tmp_int_arr2[0] = 0;
1624
     a70:	1a 82       	std	Y+2, r1	; 0x02
1625
     a72:	19 82       	std	Y+1, r1	; 0x01
1626
 tmp_int_arr2[1] = 0;
1627
     a74:	1c 82       	std	Y+4, r1	; 0x04
1628
     a76:	1b 82       	std	Y+3, r1	; 0x03
1629
 while(!UebertragungAbgeschlossen);  // evtl warten
1630
     a78:	80 91 6e 00 	lds	r24, 0x006E
1631
     a7c:	88 23       	and	r24, r24
1632
     a7e:	e1 f3       	breq	.-8      	; 0xa78 <ClearIntervalle+0x1c>
1633
 SendOutData('i',0,(unsigned char *) &tmp_int_arr2,sizeof(tmp_int_arr2)); // 0= an alle
1634
     a80:	24 e0       	ldi	r18, 0x04	; 4
1635
     a82:	ae 01       	movw	r20, r28
1636
     a84:	4f 5f       	subi	r20, 0xFF	; 255
1637
     a86:	5f 4f       	sbci	r21, 0xFF	; 255
1638
     a88:	60 e0       	ldi	r22, 0x00	; 0
1639
     a8a:	89 e6       	ldi	r24, 0x69	; 105
1640
     a8c:	0e 94 1e 03 	call	0x63c <SendOutData>
1641
     a90:	24 96       	adiw	r28, 0x04	; 4
1642
     a92:	0f b6       	in	r0, 0x3f	; 63
1643
     a94:	f8 94       	cli
1644
     a96:	de bf       	out	0x3e, r29	; 62
1645
     a98:	0f be       	out	0x3f, r0	; 63
1646
     a9a:	cd bf       	out	0x3d, r28	; 61
1647
     a9c:	df 91       	pop	r29
1648
     a9e:	cf 91       	pop	r28
1649
     aa0:	08 95       	ret
1650
 
1651
00000aa2 <DatenUebertragung>:
1652
}
1653
 
1654
void DatenUebertragung(unsigned char key)
1655
{
1656
     aa2:	cf 93       	push	r28
1657
     aa4:	df 93       	push	r29
1658
     aa6:	cd b7       	in	r28, 0x3d	; 61
1659
     aa8:	de b7       	in	r29, 0x3e	; 62
1660
     aaa:	25 97       	sbiw	r28, 0x05	; 5
1661
     aac:	0f b6       	in	r0, 0x3f	; 63
1662
     aae:	f8 94       	cli
1663
     ab0:	de bf       	out	0x3e, r29	; 62
1664
     ab2:	0f be       	out	0x3f, r0	; 63
1665
     ab4:	cd bf       	out	0x3d, r28	; 61
1666
     ab6:	98 2f       	mov	r25, r24
1667
 static unsigned char state = 1;
1668
 unsigned char temp_1[1];
1669
 unsigned char temp_2[2];
1670
 unsigned char temp_3[3];
1671
 unsigned int tmp_int_arr2[2];
1672
 while(!UebertragungAbgeschlossen);  // evtl warten
1673
     ab8:	80 91 6e 00 	lds	r24, 0x006E
1674
     abc:	88 23       	and	r24, r24
1675
     abe:	e1 f3       	breq	.-8      	; 0xab8 <DatenUebertragung+0x16>
1676
 static unsigned char KanalSlave = 1;
1677
 
1678
 if(PollDisplay)
1679
     ac0:	80 91 ed 00 	lds	r24, 0x00ED
1680
     ac4:	88 23       	and	r24, r24
1681
     ac6:	e1 f0       	breq	.+56     	; 0xb00 <DatenUebertragung+0x5e>
1682
  {
1683
   temp_2[0] = key;
1684
     ac8:	9c 83       	std	Y+4, r25	; 0x04
1685
   temp_2[1] = 6;
1686
     aca:	86 e0       	ldi	r24, 0x06	; 6
1687
     acc:	8d 83       	std	Y+5, r24	; 0x05
1688
   if(DisplayZeilen == 4) temp_2[1] = 4 + 9;   // anzahl Zeilen --> + 8 bedeutet: ersten Pollingzyklus freilassen
1689
     ace:	80 91 65 00 	lds	r24, 0x0065
1690
     ad2:	84 30       	cpi	r24, 0x04	; 4
1691
     ad4:	11 f4       	brne	.+4      	; 0xada <DatenUebertragung+0x38>
1692
     ad6:	8d e0       	ldi	r24, 0x0D	; 13
1693
     ad8:	01 c0       	rjmp	.+2      	; 0xadc <DatenUebertragung+0x3a>
1694
   else                   temp_2[1] = 2 + 9;
1695
     ada:	8b e0       	ldi	r24, 0x0B	; 11
1696
     adc:	8d 83       	std	Y+5, r24	; 0x05
1697
   SendOutData('h',SlaveAdresse,(unsigned char *) &temp_2,sizeof(temp_2));
1698
     ade:	22 e0       	ldi	r18, 0x02	; 2
1699
     ae0:	ae 01       	movw	r20, r28
1700
     ae2:	4c 5f       	subi	r20, 0xFC	; 252
1701
     ae4:	5f 4f       	sbci	r21, 0xFF	; 255
1702
     ae6:	60 91 64 00 	lds	r22, 0x0064
1703
     aea:	88 e6       	ldi	r24, 0x68	; 104
1704
     aec:	0e 94 1e 03 	call	0x63c <SendOutData>
1705
   ErwarteAntwort = '0';
1706
     af0:	80 e3       	ldi	r24, 0x30	; 48
1707
     af2:	80 93 6d 00 	sts	0x006D, r24
1708
   DisplayBusy = 90;
1709
     af6:	8a e5       	ldi	r24, 0x5A	; 90
1710
     af8:	80 93 93 00 	sts	0x0093, r24
1711
   PollDisplay = 0;
1712
     afc:	10 92 ed 00 	sts	0x00ED, r1
1713
  }
1714
 
1715
 if(!DisplayBusy)
1716
     b00:	60 91 93 00 	lds	r22, 0x0093
1717
     b04:	66 23       	and	r22, r22
1718
     b06:	e1 f5       	brne	.+120    	; 0xb80 <DatenUebertragung+0xde>
1719
 switch(state)
1720
     b08:	80 91 6f 00 	lds	r24, 0x006F
1721
     b0c:	99 27       	eor	r25, r25
1722
     b0e:	81 30       	cpi	r24, 0x01	; 1
1723
     b10:	91 05       	cpc	r25, r1
1724
     b12:	19 f0       	breq	.+6      	; 0xb1a <DatenUebertragung+0x78>
1725
     b14:	02 97       	sbiw	r24, 0x02	; 2
1726
     b16:	e9 f0       	breq	.+58     	; 0xb52 <DatenUebertragung+0xb0>
1727
     b18:	30 c0       	rjmp	.+96     	; 0xb7a <DatenUebertragung+0xd8>
1728
  {
1729
   case 1:// Display
1730
          SendOutData('k',KanalSlave,(unsigned char *) &temp_3,sizeof(temp_3));
1731
     b1a:	23 e0       	ldi	r18, 0x03	; 3
1732
     b1c:	ae 01       	movw	r20, r28
1733
     b1e:	4f 5f       	subi	r20, 0xFF	; 255
1734
     b20:	5f 4f       	sbci	r21, 0xFF	; 255
1735
     b22:	60 91 70 00 	lds	r22, 0x0070
1736
     b26:	8b e6       	ldi	r24, 0x6B	; 107
1737
     b28:	0e 94 1e 03 	call	0x63c <SendOutData>
1738
		  ErwarteAntwort = 'K';
1739
     b2c:	8b e4       	ldi	r24, 0x4B	; 75
1740
     b2e:	80 93 6d 00 	sts	0x006D, r24
1741
		  if(++KanalSlave > AnzahlTeilnehmer) KanalSlave = 1;
1742
     b32:	80 91 70 00 	lds	r24, 0x0070
1743
     b36:	8f 5f       	subi	r24, 0xFF	; 255
1744
     b38:	80 93 70 00 	sts	0x0070, r24
1745
     b3c:	90 91 6c 00 	lds	r25, 0x006C
1746
     b40:	98 17       	cp	r25, r24
1747
     b42:	18 f4       	brcc	.+6      	; 0xb4a <DatenUebertragung+0xa8>
1748
     b44:	81 e0       	ldi	r24, 0x01	; 1
1749
     b46:	80 93 70 00 	sts	0x0070, r24
1750
          state++;
1751
     b4a:	80 91 6f 00 	lds	r24, 0x006F
1752
     b4e:	8f 5f       	subi	r24, 0xFF	; 255
1753
     b50:	15 c0       	rjmp	.+42     	; 0xb7c <DatenUebertragung+0xda>
1754
		  break;
1755
   case 2:
1756
          temp_3[0] = TX_DigTransferKanalL;
1757
     b52:	80 91 96 00 	lds	r24, 0x0096
1758
     b56:	89 83       	std	Y+1, r24	; 0x01
1759
          temp_3[1] = TX_DigTransferKanalH;
1760
     b58:	80 91 95 00 	lds	r24, 0x0095
1761
     b5c:	8a 83       	std	Y+2, r24	; 0x02
1762
		  temp_3[2] = TX_DigTransferKanalDaten;
1763
     b5e:	80 91 94 00 	lds	r24, 0x0094
1764
     b62:	8b 83       	std	Y+3, r24	; 0x03
1765
          SendOutData('l',0,(unsigned char *) &temp_3,sizeof(temp_3));
1766
     b64:	23 e0       	ldi	r18, 0x03	; 3
1767
     b66:	ae 01       	movw	r20, r28
1768
     b68:	4f 5f       	subi	r20, 0xFF	; 255
1769
     b6a:	5f 4f       	sbci	r21, 0xFF	; 255
1770
     b6c:	8c e6       	ldi	r24, 0x6C	; 108
1771
     b6e:	0e 94 1e 03 	call	0x63c <SendOutData>
1772
		  AntwortEingetroffen = 1; // erwarte keine Antwort
1773
     b72:	81 e0       	ldi	r24, 0x01	; 1
1774
     b74:	80 93 92 00 	sts	0x0092, r24
1775
     b78:	01 c0       	rjmp	.+2      	; 0xb7c <DatenUebertragung+0xda>
1776
          state = 1;
1777
		  break;
1778
 
1779
   default: state = 1;
1780
     b7a:	81 e0       	ldi	r24, 0x01	; 1
1781
     b7c:	80 93 6f 00 	sts	0x006F, r24
1782
     b80:	25 96       	adiw	r28, 0x05	; 5
1783
     b82:	0f b6       	in	r0, 0x3f	; 63
1784
     b84:	f8 94       	cli
1785
     b86:	de bf       	out	0x3e, r29	; 62
1786
     b88:	0f be       	out	0x3f, r0	; 63
1787
     b8a:	cd bf       	out	0x3d, r28	; 61
1788
     b8c:	df 91       	pop	r29
1789
     b8e:	cf 91       	pop	r28
1790
     b90:	08 95       	ret
1791
 
1792
00000b92 <_long_delay>:
1793
#include "main.h"
1794
 
1795
void _long_delay(void)
1796
{
1797
long t = 5000;
1798
     b92:	88 e8       	ldi	r24, 0x88	; 136
1799
     b94:	93 e1       	ldi	r25, 0x13	; 19
1800
     b96:	a0 e0       	ldi	r26, 0x00	; 0
1801
     b98:	b0 e0       	ldi	r27, 0x00	; 0
1802
while (t--);
1803
     b9a:	03 97       	sbiw	r24, 0x03	; 3
1804
     b9c:	a1 09       	sbc	r26, r1
1805
     b9e:	b1 09       	sbc	r27, r1
1806
     ba0:	8f 3f       	cpi	r24, 0xFF	; 255
1807
     ba2:	2f ef       	ldi	r18, 0xFF	; 255
1808
     ba4:	92 07       	cpc	r25, r18
1809
     ba6:	2f ef       	ldi	r18, 0xFF	; 255
1810
     ba8:	a2 07       	cpc	r26, r18
1811
     baa:	2f ef       	ldi	r18, 0xFF	; 255
1812
     bac:	b2 07       	cpc	r27, r18
1813
     bae:	a9 f7       	brne	.-22     	; 0xb9a <_long_delay+0x8>
1814
     bb0:	08 95       	ret
1815
 
1816
00000bb2 <_short_delay>:
1817
}
1818
 
1819
void _short_delay(void)
1820
{
1821
int t = 500;
1822
     bb2:	84 ef       	ldi	r24, 0xF4	; 244
1823
     bb4:	91 e0       	ldi	r25, 0x01	; 1
1824
while (t--);
1825
     bb6:	03 97       	sbiw	r24, 0x03	; 3
1826
     bb8:	2f ef       	ldi	r18, 0xFF	; 255
1827
     bba:	8f 3f       	cpi	r24, 0xFF	; 255
1828
     bbc:	92 07       	cpc	r25, r18
1829
     bbe:	d9 f7       	brne	.-10     	; 0xbb6 <_short_delay+0x4>
1830
     bc0:	08 95       	ret
1831
 
1832
00000bc2 <_lcd_write_command>:
1833
}
1834
 
1835
 
1836
void _lcd_write_command(unsigned char data)
1837
{
1838
     bc2:	28 2f       	mov	r18, r24
1839
  LCD_PORT_w = (data & 0xf0) | DISPLAY_EN;
1840
     bc4:	80 7f       	andi	r24, 0xF0	; 240
1841
     bc6:	98 2f       	mov	r25, r24
1842
     bc8:	94 60       	ori	r25, 0x04	; 4
1843
     bca:	95 bb       	out	0x15, r25	; 21
1844
  LCD_PORT_w = (data & 0xf0) | DISPLAY_EN;
1845
     bcc:	95 bb       	out	0x15, r25	; 21
1846
  LCD_PORT_w = (data & 0xf0);
1847
     bce:	85 bb       	out	0x15, r24	; 21
1848
  LCD_PORT_w = (data & 0xf0);
1849
     bd0:	85 bb       	out	0x15, r24	; 21
1850
  LCD_PORT_w = (data << 4) | DISPLAY_EN;
1851
     bd2:	82 2f       	mov	r24, r18
1852
     bd4:	99 27       	eor	r25, r25
1853
     bd6:	34 e0       	ldi	r19, 0x04	; 4
1854
     bd8:	88 0f       	add	r24, r24
1855
     bda:	99 1f       	adc	r25, r25
1856
     bdc:	3a 95       	dec	r19
1857
     bde:	e1 f7       	brne	.-8      	; 0xbd8 <_lcd_write_command+0x16>
1858
     be0:	84 60       	ori	r24, 0x04	; 4
1859
     be2:	85 bb       	out	0x15, r24	; 21
1860
  LCD_PORT_w = (data << 4) | DISPLAY_EN;
1861
     be4:	85 bb       	out	0x15, r24	; 21
1862
  LCD_PORT_w = (data << 4);
1863
     be6:	22 95       	swap	r18
1864
     be8:	20 7f       	andi	r18, 0xF0	; 240
1865
     bea:	25 bb       	out	0x15, r18	; 21
1866
     bec:	08 95       	ret
1867
 
1868
00000bee <_lcd_write_4bit>:
1869
}
1870
 
1871
void _lcd_write_4bit(unsigned char data)
1872
{
1873
  LCD_PORT_w = (data << 4) | DISPLAY_EN;
1874
     bee:	28 2f       	mov	r18, r24
1875
     bf0:	33 27       	eor	r19, r19
1876
     bf2:	44 e0       	ldi	r20, 0x04	; 4
1877
     bf4:	22 0f       	add	r18, r18
1878
     bf6:	33 1f       	adc	r19, r19
1879
     bf8:	4a 95       	dec	r20
1880
     bfa:	e1 f7       	brne	.-8      	; 0xbf4 <_lcd_write_4bit+0x6>
1881
     bfc:	92 2f       	mov	r25, r18
1882
     bfe:	94 60       	ori	r25, 0x04	; 4
1883
     c00:	95 bb       	out	0x15, r25	; 21
1884
  LCD_PORT_w = (data << 4) | DISPLAY_EN;
1885
     c02:	95 bb       	out	0x15, r25	; 21
1886
  LCD_PORT_w = (data << 4);
1887
     c04:	82 95       	swap	r24
1888
     c06:	80 7f       	andi	r24, 0xF0	; 240
1889
     c08:	85 bb       	out	0x15, r24	; 21
1890
     c0a:	08 95       	ret
1891
 
1892
00000c0c <lcd_write_byte>:
1893
}
1894
 
1895
void lcd_write_byte(unsigned char data)
1896
{
1897
     c0c:	28 2f       	mov	r18, r24
1898
  LCD_PORT_w = (data & 0xf0) | DISPLAY_EN | DISPLAY_RS;
1899
     c0e:	80 7f       	andi	r24, 0xF0	; 240
1900
     c10:	98 2f       	mov	r25, r24
1901
     c12:	95 60       	ori	r25, 0x05	; 5
1902
     c14:	95 bb       	out	0x15, r25	; 21
1903
  LCD_PORT_w = (data & 0xf0) | DISPLAY_RS;
1904
     c16:	81 60       	ori	r24, 0x01	; 1
1905
     c18:	85 bb       	out	0x15, r24	; 21
1906
  LCD_PORT_w = (data << 4)   | DISPLAY_EN | DISPLAY_RS;
1907
     c1a:	82 2f       	mov	r24, r18
1908
     c1c:	99 27       	eor	r25, r25
1909
     c1e:	54 e0       	ldi	r21, 0x04	; 4
1910
     c20:	88 0f       	add	r24, r24
1911
     c22:	99 1f       	adc	r25, r25
1912
     c24:	5a 95       	dec	r21
1913
     c26:	e1 f7       	brne	.-8      	; 0xc20 <lcd_write_byte+0x14>
1914
     c28:	28 2f       	mov	r18, r24
1915
     c2a:	25 60       	ori	r18, 0x05	; 5
1916
     c2c:	25 bb       	out	0x15, r18	; 21
1917
  LCD_PORT_w = (data << 4)   | DISPLAY_RS;
1918
     c2e:	81 60       	ori	r24, 0x01	; 1
1919
     c30:	85 bb       	out	0x15, r24	; 21
1920
     c32:	08 95       	ret
1921
 
1922
00000c34 <my_pput>:
1923
}
1924
 
1925
 
1926
int my_pput(int zeichen)
1927
{
1928
 lcd_write_byte((char) zeichen);
1929
     c34:	0e 94 06 06 	call	0xc0c <lcd_write_byte>
1930
 return(1);
1931
}
1932
     c38:	81 e0       	ldi	r24, 0x01	; 1
1933
     c3a:	90 e0       	ldi	r25, 0x00	; 0
1934
     c3c:	08 95       	ret
1935
 
1936
00000c3e <LCD_Init>:
1937
 
1938
// initialize the LCD controller
1939
void LCD_Init(void)
1940
{
1941
LCD_PORT_DDR = 0xff;//0xf0 | DISPLAY_RS | DISPLAY_EN;
1942
     c3e:	8f ef       	ldi	r24, 0xFF	; 255
1943
     c40:	84 bb       	out	0x14, r24	; 20
1944
_long_delay();
1945
     c42:	0e 94 c9 05 	call	0xb92 <_long_delay>
1946
_long_delay();
1947
     c46:	0e 94 c9 05 	call	0xb92 <_long_delay>
1948
_long_delay();
1949
     c4a:	0e 94 c9 05 	call	0xb92 <_long_delay>
1950
_lcd_write_4bit(0x03);	   // noch 8 Bit
1951
     c4e:	83 e0       	ldi	r24, 0x03	; 3
1952
     c50:	0e 94 f7 05 	call	0xbee <_lcd_write_4bit>
1953
_long_delay();
1954
     c54:	0e 94 c9 05 	call	0xb92 <_long_delay>
1955
_lcd_write_4bit(0x03);	   // noch 8 Bit
1956
     c58:	83 e0       	ldi	r24, 0x03	; 3
1957
     c5a:	0e 94 f7 05 	call	0xbee <_lcd_write_4bit>
1958
_long_delay();
1959
     c5e:	0e 94 c9 05 	call	0xb92 <_long_delay>
1960
_lcd_write_4bit(0x03);	   // noch 8 Bit
1961
     c62:	83 e0       	ldi	r24, 0x03	; 3
1962
     c64:	0e 94 f7 05 	call	0xbee <_lcd_write_4bit>
1963
_long_delay();
1964
     c68:	0e 94 c9 05 	call	0xb92 <_long_delay>
1965
_lcd_write_4bit(0x02);	   // jetzt 4 Bit
1966
     c6c:	82 e0       	ldi	r24, 0x02	; 2
1967
     c6e:	0e 94 f7 05 	call	0xbee <_lcd_write_4bit>
1968
_long_delay();
1969
     c72:	0e 94 c9 05 	call	0xb92 <_long_delay>
1970
_lcd_write_command(0x28);     // 4 Bit Zweizeilig
1971
     c76:	88 e2       	ldi	r24, 0x28	; 40
1972
     c78:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
1973
_long_delay();
1974
     c7c:	0e 94 c9 05 	call	0xb92 <_long_delay>
1975
_lcd_write_command(0x08);     // Display aus
1976
     c80:	88 e0       	ldi	r24, 0x08	; 8
1977
     c82:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
1978
_long_delay();
1979
     c86:	0e 94 c9 05 	call	0xb92 <_long_delay>
1980
_lcd_write_command(0x01);     // Clear
1981
     c8a:	81 e0       	ldi	r24, 0x01	; 1
1982
     c8c:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
1983
_long_delay();
1984
     c90:	0e 94 c9 05 	call	0xb92 <_long_delay>
1985
_lcd_write_command(0x06);     //Entry mode
1986
     c94:	86 e0       	ldi	r24, 0x06	; 6
1987
     c96:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
1988
_long_delay();
1989
     c9a:	0e 94 c9 05 	call	0xb92 <_long_delay>
1990
_lcd_write_command(0x08 + 4); // Display an
1991
     c9e:	8c e0       	ldi	r24, 0x0C	; 12
1992
     ca0:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
1993
_long_delay();
1994
     ca4:	0e 94 c9 05 	call	0xb92 <_long_delay>
1995
     ca8:	08 95       	ret
1996
 
1997
00000caa <LCD_Gotoxy>:
1998
}
1999
 
2000
 
2001
void LCD_Gotoxy(unsigned char x , unsigned char y)
2002
 {
2003
     caa:	1f 93       	push	r17
2004
     cac:	cf 93       	push	r28
2005
     cae:	c8 2f       	mov	r28, r24
2006
     cb0:	16 2f       	mov	r17, r22
2007
  _short_delay();
2008
     cb2:	0e 94 d9 05 	call	0xbb2 <_short_delay>
2009
  switch(y)
2010
     cb6:	81 2f       	mov	r24, r17
2011
     cb8:	99 27       	eor	r25, r25
2012
     cba:	81 30       	cpi	r24, 0x01	; 1
2013
     cbc:	91 05       	cpc	r25, r1
2014
     cbe:	79 f0       	breq	.+30     	; 0xcde <LCD_Gotoxy+0x34>
2015
     cc0:	82 30       	cpi	r24, 0x02	; 2
2016
     cc2:	91 05       	cpc	r25, r1
2017
     cc4:	1c f4       	brge	.+6      	; 0xccc <LCD_Gotoxy+0x22>
2018
     cc6:	89 2b       	or	r24, r25
2019
     cc8:	39 f0       	breq	.+14     	; 0xcd8 <LCD_Gotoxy+0x2e>
2020
     cca:	13 c0       	rjmp	.+38     	; 0xcf2 <LCD_Gotoxy+0x48>
2021
     ccc:	82 30       	cpi	r24, 0x02	; 2
2022
     cce:	91 05       	cpc	r25, r1
2023
     cd0:	49 f0       	breq	.+18     	; 0xce4 <LCD_Gotoxy+0x3a>
2024
     cd2:	03 97       	sbiw	r24, 0x03	; 3
2025
     cd4:	51 f0       	breq	.+20     	; 0xcea <LCD_Gotoxy+0x40>
2026
     cd6:	0d c0       	rjmp	.+26     	; 0xcf2 <LCD_Gotoxy+0x48>
2027
  { case 0 : _lcd_write_command(x + 0x80); break;
2028
     cd8:	8c 2f       	mov	r24, r28
2029
     cda:	80 58       	subi	r24, 0x80	; 128
2030
     cdc:	08 c0       	rjmp	.+16     	; 0xcee <LCD_Gotoxy+0x44>
2031
    case 1 : _lcd_write_command(x + 0xC0); break;
2032
     cde:	8c 2f       	mov	r24, r28
2033
     ce0:	80 54       	subi	r24, 0x40	; 64
2034
     ce2:	05 c0       	rjmp	.+10     	; 0xcee <LCD_Gotoxy+0x44>
2035
    case 2 : _lcd_write_command(x + (0x80 + 20)); break;
2036
     ce4:	8c 2f       	mov	r24, r28
2037
     ce6:	8c 56       	subi	r24, 0x6C	; 108
2038
     ce8:	02 c0       	rjmp	.+4      	; 0xcee <LCD_Gotoxy+0x44>
2039
    case 3 : _lcd_write_command(x + (0xC0 + 20)); break;
2040
     cea:	8c 2f       	mov	r24, r28
2041
     cec:	8c 52       	subi	r24, 0x2C	; 44
2042
     cee:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
2043
     cf2:	cf 91       	pop	r28
2044
     cf4:	1f 91       	pop	r17
2045
     cf6:	08 95       	ret
2046
 
2047
00000cf8 <LCD_Write>:
2048
  }
2049
 }
2050
 
2051
 
2052
void LCD_Write(unsigned char *this_text)
2053
{
2054
     cf8:	1f 93       	push	r17
2055
     cfa:	cf 93       	push	r28
2056
     cfc:	df 93       	push	r29
2057
     cfe:	ec 01       	movw	r28, r24
2058
 unsigned char i = 0;
2059
     d00:	10 e0       	ldi	r17, 0x00	; 0
2060
 while(this_text[i] != 0)
2061
  {
2062
   lcd_write_byte(this_text[i++]);
2063
   _long_delay();
2064
     d02:	88 81       	ld	r24, Y
2065
     d04:	88 23       	and	r24, r24
2066
     d06:	79 f0       	breq	.+30     	; 0xd26 <LCD_Write+0x2e>
2067
     d08:	fe 01       	movw	r30, r28
2068
     d0a:	e1 0f       	add	r30, r17
2069
     d0c:	f1 1d       	adc	r31, r1
2070
     d0e:	1f 5f       	subi	r17, 0xFF	; 255
2071
     d10:	80 81       	ld	r24, Z
2072
     d12:	0e 94 06 06 	call	0xc0c <lcd_write_byte>
2073
     d16:	0e 94 c9 05 	call	0xb92 <_long_delay>
2074
     d1a:	fe 01       	movw	r30, r28
2075
     d1c:	e1 0f       	add	r30, r17
2076
     d1e:	f1 1d       	adc	r31, r1
2077
     d20:	80 81       	ld	r24, Z
2078
     d22:	88 23       	and	r24, r24
2079
     d24:	89 f7       	brne	.-30     	; 0xd08 <LCD_Write+0x10>
2080
     d26:	df 91       	pop	r29
2081
     d28:	cf 91       	pop	r28
2082
     d2a:	1f 91       	pop	r17
2083
     d2c:	08 95       	ret
2084
 
2085
00000d2e <LCD_Putchar>:
2086
  }
2087
}
2088
 
2089
 
2090
char LCD_Putchar(char zeichen)
2091
{
2092
     d2e:	1f 93       	push	r17
2093
     d30:	18 2f       	mov	r17, r24
2094
_short_delay();
2095
     d32:	0e 94 d9 05 	call	0xbb2 <_short_delay>
2096
 lcd_write_byte((char) zeichen);
2097
     d36:	81 2f       	mov	r24, r17
2098
     d38:	0e 94 06 06 	call	0xc0c <lcd_write_byte>
2099
 return(1);
2100
}
2101
     d3c:	81 e0       	ldi	r24, 0x01	; 1
2102
     d3e:	90 e0       	ldi	r25, 0x00	; 0
2103
     d40:	1f 91       	pop	r17
2104
     d42:	08 95       	ret
2105
 
2106
00000d44 <PRINT>:
2107
#include "old_macros.h"
2108
 
2109
//#define LIGHTPRINTF
2110
 
2111
void PRINT(const char * ptr, unsigned int len) {
2112
     d44:	0f 93       	push	r16
2113
     d46:	1f 93       	push	r17
2114
     d48:	cf 93       	push	r28
2115
     d4a:	df 93       	push	r29
2116
     d4c:	8c 01       	movw	r16, r24
2117
     d4e:	eb 01       	movw	r28, r22
2118
	for(;len;len--)
2119
     d50:	67 2b       	or	r22, r23
2120
     d52:	39 f0       	breq	.+14     	; 0xd62 <PRINT+0x1e>
2121
		LCD_Putchar(*ptr++);
2122
     d54:	f8 01       	movw	r30, r16
2123
     d56:	81 91       	ld	r24, Z+
2124
     d58:	8f 01       	movw	r16, r30
2125
     d5a:	0e 94 97 06 	call	0xd2e <LCD_Putchar>
2126
     d5e:	21 97       	sbiw	r28, 0x01	; 1
2127
     d60:	c9 f7       	brne	.-14     	; 0xd54 <PRINT+0x10>
2128
     d62:	df 91       	pop	r29
2129
     d64:	cf 91       	pop	r28
2130
     d66:	1f 91       	pop	r17
2131
     d68:	0f 91       	pop	r16
2132
     d6a:	08 95       	ret
2133
 
2134
00000d6c <PRINTP>:
2135
}
2136
 
2137
void PRINTP(const char * ptr, unsigned int len) {
2138
     d6c:	0f 93       	push	r16
2139
     d6e:	1f 93       	push	r17
2140
     d70:	cf 93       	push	r28
2141
     d72:	df 93       	push	r29
2142
     d74:	8c 01       	movw	r16, r24
2143
     d76:	eb 01       	movw	r28, r22
2144
	for(;len;len--)
2145
     d78:	67 2b       	or	r22, r23
2146
     d7a:	41 f0       	breq	.+16     	; 0xd8c <PRINTP+0x20>
2147
//		LCD_Putchar(PRG_RDB(ptr++));
2148
		LCD_Putchar(pgm_read_byte(ptr++));
2149
     d7c:	f8 01       	movw	r30, r16
2150
     d7e:	0f 5f       	subi	r16, 0xFF	; 255
2151
     d80:	1f 4f       	sbci	r17, 0xFF	; 255
2152
     d82:	84 91       	lpm	r24, Z
2153
     d84:	0e 94 97 06 	call	0xd2e <LCD_Putchar>
2154
     d88:	21 97       	sbiw	r28, 0x01	; 1
2155
     d8a:	c1 f7       	brne	.-16     	; 0xd7c <PRINTP+0x10>
2156
     d8c:	df 91       	pop	r29
2157
     d8e:	cf 91       	pop	r28
2158
     d90:	1f 91       	pop	r17
2159
     d92:	0f 91       	pop	r16
2160
     d94:	08 95       	ret
2161
 
2162
00000d96 <PAD_SP>:
2163
}
2164
 
2165
void PAD_SP(signed char howmany) {
2166
     d96:	cf 93       	push	r28
2167
     d98:	c8 2f       	mov	r28, r24
2168
	for(;howmany>0;howmany--)
2169
     d9a:	18 16       	cp	r1, r24
2170
     d9c:	34 f4       	brge	.+12     	; 0xdaa <PAD_SP+0x14>
2171
		LCD_Putchar(' ');
2172
     d9e:	80 e2       	ldi	r24, 0x20	; 32
2173
     da0:	0e 94 97 06 	call	0xd2e <LCD_Putchar>
2174
     da4:	c1 50       	subi	r28, 0x01	; 1
2175
     da6:	1c 16       	cp	r1, r28
2176
     da8:	d4 f3       	brlt	.-12     	; 0xd9e <PAD_SP+0x8>
2177
     daa:	cf 91       	pop	r28
2178
     dac:	08 95       	ret
2179
 
2180
00000dae <PAD_0>:
2181
}
2182
 
2183
void PAD_0(signed char howmany) {
2184
     dae:	cf 93       	push	r28
2185
     db0:	c8 2f       	mov	r28, r24
2186
	for(;howmany>0;howmany--)
2187
     db2:	18 16       	cp	r1, r24
2188
     db4:	34 f4       	brge	.+12     	; 0xdc2 <PAD_0+0x14>
2189
		LCD_Putchar('0');
2190
     db6:	80 e3       	ldi	r24, 0x30	; 48
2191
     db8:	0e 94 97 06 	call	0xd2e <LCD_Putchar>
2192
     dbc:	c1 50       	subi	r28, 0x01	; 1
2193
     dbe:	1c 16       	cp	r1, r28
2194
     dc0:	d4 f3       	brlt	.-12     	; 0xdb6 <PAD_0+0x8>
2195
     dc2:	cf 91       	pop	r28
2196
     dc4:	08 95       	ret
2197
 
2198
00000dc6 <_printf_P>:
2199
}
2200
 
2201
#define	BUF		40
2202
 
2203
/*
2204
 * Macros for converting digits to letters and vice versa
2205
 */
2206
#define	to_digit(c)	((c) - '0')
2207
#define  is_digit(c)	((c)<='9' && (c)>='0')
2208
#define	to_char(n)	((n) + '0')
2209
 
2210
/*
2211
 * Flags used during conversion.
2212
 */
2213
#define	LONGINT		0x01		/* long integer */
2214
#define	LONGDBL		0x02		/* long double; unimplemented */
2215
#define	SHORTINT		0x04		/* short integer */
2216
#define	ALT			0x08		/* alternate form */
2217
#define	LADJUST		0x10		/* left adjustment */
2218
#define	ZEROPAD		0x20		/* zero (as opposed to blank) pad */
2219
#define	HEXPREFIX	0x40		/* add 0x or 0X prefix */
2220
 
2221
void _printf_P (char const *fmt0, ...)      /* Works with string from FLASH */
2222
{
2223
     dc6:	2f 92       	push	r2
2224
     dc8:	3f 92       	push	r3
2225
     dca:	4f 92       	push	r4
2226
     dcc:	5f 92       	push	r5
2227
     dce:	6f 92       	push	r6
2228
     dd0:	7f 92       	push	r7
2229
     dd2:	8f 92       	push	r8
2230
     dd4:	9f 92       	push	r9
2231
     dd6:	af 92       	push	r10
2232
     dd8:	bf 92       	push	r11
2233
     dda:	cf 92       	push	r12
2234
     ddc:	df 92       	push	r13
2235
     dde:	ef 92       	push	r14
2236
     de0:	ff 92       	push	r15
2237
     de2:	0f 93       	push	r16
2238
     de4:	1f 93       	push	r17
2239
     de6:	cf 93       	push	r28
2240
     de8:	df 93       	push	r29
2241
     dea:	cd b7       	in	r28, 0x3d	; 61
2242
     dec:	de b7       	in	r29, 0x3e	; 62
2243
     dee:	e0 97       	sbiw	r28, 0x30	; 48
2244
     df0:	0f b6       	in	r0, 0x3f	; 63
2245
     df2:	f8 94       	cli
2246
     df4:	de bf       	out	0x3e, r29	; 62
2247
     df6:	0f be       	out	0x3f, r0	; 63
2248
     df8:	cd bf       	out	0x3d, r28	; 61
2249
     dfa:	a5 e4       	ldi	r26, 0x45	; 69
2250
     dfc:	6a 2e       	mov	r6, r26
2251
     dfe:	71 2c       	mov	r7, r1
2252
     e00:	6c 0e       	add	r6, r28
2253
     e02:	7d 1e       	adc	r7, r29
2254
 	va_list ap;
2255
	register const char *fmt; /* format string */
2256
	register char ch;	/* character from fmt */
2257
	register int n;		/* handy integer (short term usage) */
2258
	register char *cp;	/* handy char pointer (short term usage) */
2259
	const char *fmark;	/* for remembering a place in fmt */
2260
	register unsigned char flags;	/* flags as above */
2261
	signed char width;		/* width from format (%8d), or 0 */
2262
	signed char prec;		/* precision from format (%.3d), or -1 */
2263
	char sign;				/* sign prefix (' ', '+', '-', or \0) */
2264
	unsigned long _ulong=0;	/* integer arguments %[diouxX] */
2265
     e04:	1c a6       	std	Y+44, r1	; 0x2c
2266
     e06:	1d a6       	std	Y+45, r1	; 0x2d
2267
     e08:	1e a6       	std	Y+46, r1	; 0x2e
2268
     e0a:	1f a6       	std	Y+47, r1	; 0x2f
2269
#define OCT 8
2270
#define DEC 10
2271
#define HEX 16
2272
	unsigned char base;		/* base for [diouxX] conversion */
2273
	signed char dprec;		/* a copy of prec if [diouxX], 0 otherwise */
2274
	signed char dpad;			/* extra 0 padding needed for integers */
2275
	signed char fieldsz;		/* field size expanded by sign, dpad etc */
2276
	/* The initialization of 'size' is to suppress a warning that
2277
	   'size' might be used unitialized.  It seems gcc can't
2278
	   quite grok this spaghetti code ... */
2279
	signed char size = 0;		/* size of converted field or string */
2280
	char buf[BUF];		/* space for %c, %[diouxX], %[eEfgG] */
2281
	char ox[2];			/* space for 0x hex-prefix */
2282
 
2283
	va_start(ap, fmt0);
2284
 
2285
	fmt = fmt0;
2286
     e0c:	d3 01       	movw	r26, r6
2287
     e0e:	ad 90       	ld	r10, X+
2288
     e10:	bd 90       	ld	r11, X+
2289
     e12:	3d 01       	movw	r6, r26
2290
 
2291
	/*
2292
	 * Scan the format for conversions (`%' character).
2293
	 */
2294
	for (;;) {
2295
		for (fmark = fmt; (ch = pgm_read_byte(fmt)) != '\0' && ch != '%'; fmt++)
2296
     e14:	c5 01       	movw	r24, r10
2297
     e16:	05 c0       	rjmp	.+10     	; 0xe22 <_printf_P+0x5c>
2298
     e18:	05 32       	cpi	r16, 0x25	; 37
2299
     e1a:	39 f0       	breq	.+14     	; 0xe2a <_printf_P+0x64>
2300
     e1c:	08 94       	sec
2301
     e1e:	a1 1c       	adc	r10, r1
2302
     e20:	b1 1c       	adc	r11, r1
2303
     e22:	f5 01       	movw	r30, r10
2304
     e24:	04 91       	lpm	r16, Z
2305
     e26:	00 23       	and	r16, r16
2306
     e28:	b9 f7       	brne	.-18     	; 0xe18 <_printf_P+0x52>
2307
			/* void */;
2308
		if ((n = fmt - fmark) != 0) {
2309
     e2a:	b5 01       	movw	r22, r10
2310
     e2c:	68 1b       	sub	r22, r24
2311
     e2e:	79 0b       	sbc	r23, r25
2312
     e30:	11 f0       	breq	.+4      	; 0xe36 <_printf_P+0x70>
2313
			PRINTP(fmark, n);
2314
     e32:	0e 94 b6 06 	call	0xd6c <PRINTP>
2315
		}
2316
		if (ch == '\0')
2317
     e36:	00 23       	and	r16, r16
2318
     e38:	09 f4       	brne	.+2      	; 0xe3c <_printf_P+0x76>
2319
     e3a:	30 c2       	rjmp	.+1120   	; 0x129c <_printf_P+0x4d6>
2320
			goto done;
2321
		fmt++;		/* skip over '%' */
2322
     e3c:	08 94       	sec
2323
     e3e:	a1 1c       	adc	r10, r1
2324
     e40:	b1 1c       	adc	r11, r1
2325
 
2326
		flags = 0;
2327
     e42:	55 24       	eor	r5, r5
2328
		dprec = 0;
2329
     e44:	58 aa       	std	Y+48, r5	; 0x30
2330
		width = 0;
2331
     e46:	25 2c       	mov	r2, r5
2332
		prec = -1;
2333
     e48:	1f ef       	ldi	r17, 0xFF	; 255
2334
		sign = '\0';
2335
     e4a:	59 a6       	std	Y+41, r5	; 0x29
2336
 
2337
rflag:		ch = PRG_RDB(fmt++);
2338
     e4c:	f5 01       	movw	r30, r10
2339
     e4e:	08 94       	sec
2340
     e50:	a1 1c       	adc	r10, r1
2341
     e52:	b1 1c       	adc	r11, r1
2342
     e54:	04 91       	lpm	r16, Z
2343
reswitch:
2344
#ifdef LIGHTPRINTF
2345
	if (ch=='o' || ch=='u' || (ch|0x20)=='x') {
2346
#else
2347
	if (ch=='u' || (ch|0x20)=='x') {
2348
     e56:	05 37       	cpi	r16, 0x75	; 117
2349
     e58:	21 f0       	breq	.+8      	; 0xe62 <_printf_P+0x9c>
2350
     e5a:	80 2f       	mov	r24, r16
2351
     e5c:	80 62       	ori	r24, 0x20	; 32
2352
     e5e:	88 37       	cpi	r24, 0x78	; 120
2353
     e60:	f1 f4       	brne	.+60     	; 0xe9e <_printf_P+0xd8>
2354
#endif
2355
		if (flags&LONGINT) {
2356
     e62:	50 fe       	sbrs	r5, 0
2357
     e64:	0e c0       	rjmp	.+28     	; 0xe82 <_printf_P+0xbc>
2358
		 	_ulong=va_arg(ap, unsigned long);
2359
     e66:	f3 01       	movw	r30, r6
2360
     e68:	24 e0       	ldi	r18, 0x04	; 4
2361
     e6a:	30 e0       	ldi	r19, 0x00	; 0
2362
     e6c:	62 0e       	add	r6, r18
2363
     e6e:	73 1e       	adc	r7, r19
2364
     e70:	80 81       	ld	r24, Z
2365
     e72:	91 81       	ldd	r25, Z+1	; 0x01
2366
     e74:	a2 81       	ldd	r26, Z+2	; 0x02
2367
     e76:	b3 81       	ldd	r27, Z+3	; 0x03
2368
     e78:	8c a7       	std	Y+44, r24	; 0x2c
2369
     e7a:	9d a7       	std	Y+45, r25	; 0x2d
2370
     e7c:	ae a7       	std	Y+46, r26	; 0x2e
2371
     e7e:	bf a7       	std	Y+47, r27	; 0x2f
2372
     e80:	0e c0       	rjmp	.+28     	; 0xe9e <_printf_P+0xd8>
2373
		} else {
2374
			register unsigned int _d;
2375
			_d=va_arg(ap, unsigned int);
2376
     e82:	f3 01       	movw	r30, r6
2377
     e84:	a2 e0       	ldi	r26, 0x02	; 2
2378
     e86:	b0 e0       	ldi	r27, 0x00	; 0
2379
     e88:	6a 0e       	add	r6, r26
2380
     e8a:	7b 1e       	adc	r7, r27
2381
     e8c:	80 81       	ld	r24, Z
2382
     e8e:	91 81       	ldd	r25, Z+1	; 0x01
2383
			_ulong = flags&SHORTINT ? (unsigned long)(unsigned short)_d : (unsigned long)_d;
2384
     e90:	9c 01       	movw	r18, r24
2385
     e92:	44 27       	eor	r20, r20
2386
     e94:	55 27       	eor	r21, r21
2387
     e96:	2c a7       	std	Y+44, r18	; 0x2c
2388
     e98:	3d a7       	std	Y+45, r19	; 0x2d
2389
     e9a:	4e a7       	std	Y+46, r20	; 0x2e
2390
     e9c:	5f a7       	std	Y+47, r21	; 0x2f
2391
		}
2392
	}
2393
 
2394
#ifndef LIGHTPRINTF
2395
		if(ch==' ') {
2396
     e9e:	00 32       	cpi	r16, 0x20	; 32
2397
     ea0:	21 f4       	brne	.+8      	; 0xeaa <_printf_P+0xe4>
2398
			/*
2399
			 * ``If the space and + flags both appear, the space
2400
			 * flag will be ignored.''
2401
			 *	-- ANSI X3J11
2402
			 */
2403
			if (!sign)
2404
     ea2:	89 a5       	ldd	r24, Y+41	; 0x29
2405
     ea4:	88 23       	and	r24, r24
2406
     ea6:	91 f6       	brne	.-92     	; 0xe4c <_printf_P+0x86>
2407
     ea8:	1b c0       	rjmp	.+54     	; 0xee0 <_printf_P+0x11a>
2408
				sign = ' ';
2409
			goto rflag;
2410
		} else if (ch=='#') {
2411
     eaa:	03 32       	cpi	r16, 0x23	; 35
2412
     eac:	11 f4       	brne	.+4      	; 0xeb2 <_printf_P+0xec>
2413
			flags |= ALT;
2414
     eae:	38 e0       	ldi	r19, 0x08	; 8
2415
     eb0:	81 c0       	rjmp	.+258    	; 0xfb4 <_printf_P+0x1ee>
2416
			goto rflag;
2417
		} else if (ch=='*'||ch=='-') {
2418
     eb2:	0a 32       	cpi	r16, 0x2A	; 42
2419
     eb4:	11 f0       	breq	.+4      	; 0xeba <_printf_P+0xf4>
2420
     eb6:	0d 32       	cpi	r16, 0x2D	; 45
2421
     eb8:	89 f4       	brne	.+34     	; 0xedc <_printf_P+0x116>
2422
			if (ch=='*') {
2423
     eba:	0a 32       	cpi	r16, 0x2A	; 42
2424
     ebc:	51 f4       	brne	.+20     	; 0xed2 <_printf_P+0x10c>
2425
				/*
2426
				 * ``A negative field width argument is taken as a
2427
				 * - flag followed by a positive field width.''
2428
				 *	-- ANSI X3J11
2429
				 * They don't exclude field widths read from args.
2430
				 */
2431
				if ((width = va_arg(ap, int)) >= 0)
2432
     ebe:	f3 01       	movw	r30, r6
2433
     ec0:	42 e0       	ldi	r20, 0x02	; 2
2434
     ec2:	50 e0       	ldi	r21, 0x00	; 0
2435
     ec4:	64 0e       	add	r6, r20
2436
     ec6:	75 1e       	adc	r7, r21
2437
     ec8:	20 80       	ld	r2, Z
2438
     eca:	22 20       	and	r2, r2
2439
     ecc:	0c f0       	brlt	.+2      	; 0xed0 <_printf_P+0x10a>
2440
     ece:	be cf       	rjmp	.-132    	; 0xe4c <_printf_P+0x86>
2441
					goto rflag;
2442
				width = -width;
2443
     ed0:	21 94       	neg	r2
2444
			}
2445
			flags |= LADJUST;
2446
     ed2:	50 e1       	ldi	r21, 0x10	; 16
2447
     ed4:	55 2a       	or	r5, r21
2448
			flags &= ~ZEROPAD; /* '-' disables '0' */
2449
     ed6:	8f ed       	ldi	r24, 0xDF	; 223
2450
     ed8:	58 22       	and	r5, r24
2451
			goto rflag;
2452
     eda:	b8 cf       	rjmp	.-144    	; 0xe4c <_printf_P+0x86>
2453
		} else if (ch=='+') {
2454
     edc:	0b 32       	cpi	r16, 0x2B	; 43
2455
     ede:	11 f4       	brne	.+4      	; 0xee4 <_printf_P+0x11e>
2456
			sign = '+';
2457
     ee0:	09 a7       	std	Y+41, r16	; 0x29
2458
			goto rflag;
2459
     ee2:	b4 cf       	rjmp	.-152    	; 0xe4c <_printf_P+0x86>
2460
		} else if (ch=='.') {
2461
     ee4:	0e 32       	cpi	r16, 0x2E	; 46
2462
     ee6:	c1 f5       	brne	.+112    	; 0xf58 <_printf_P+0x192>
2463
			if ((ch = PRG_RDB(fmt++)) == '*') {
2464
     ee8:	f5 01       	movw	r30, r10
2465
     eea:	08 94       	sec
2466
     eec:	a1 1c       	adc	r10, r1
2467
     eee:	b1 1c       	adc	r11, r1
2468
     ef0:	04 91       	lpm	r16, Z
2469
     ef2:	0a 32       	cpi	r16, 0x2A	; 42
2470
     ef4:	79 f4       	brne	.+30     	; 0xf14 <_printf_P+0x14e>
2471
				n = va_arg(ap, int);
2472
     ef6:	f3 01       	movw	r30, r6
2473
     ef8:	a2 e0       	ldi	r26, 0x02	; 2
2474
     efa:	b0 e0       	ldi	r27, 0x00	; 0
2475
     efc:	6a 0e       	add	r6, r26
2476
     efe:	7b 1e       	adc	r7, r27
2477
     f00:	60 81       	ld	r22, Z
2478
     f02:	71 81       	ldd	r23, Z+1	; 0x01
2479
				prec = n < 0 ? -1 : n;
2480
     f04:	bf ef       	ldi	r27, 0xFF	; 255
2481
     f06:	6f 3f       	cpi	r22, 0xFF	; 255
2482
     f08:	7b 07       	cpc	r23, r27
2483
     f0a:	14 f4       	brge	.+4      	; 0xf10 <_printf_P+0x14a>
2484
     f0c:	6f ef       	ldi	r22, 0xFF	; 255
2485
     f0e:	7f ef       	ldi	r23, 0xFF	; 255
2486
     f10:	16 2f       	mov	r17, r22
2487
				goto rflag;
2488
     f12:	9c cf       	rjmp	.-200    	; 0xe4c <_printf_P+0x86>
2489
			}
2490
			n = 0;
2491
     f14:	60 e0       	ldi	r22, 0x00	; 0
2492
     f16:	70 e0       	ldi	r23, 0x00	; 0
2493
			while (is_digit(ch)) {
2494
				n = n*10 + to_digit(ch);
2495
				ch = PRG_RDB(fmt++);
2496
     f18:	80 2f       	mov	r24, r16
2497
     f1a:	80 53       	subi	r24, 0x30	; 48
2498
     f1c:	8a 30       	cpi	r24, 0x0A	; 10
2499
     f1e:	a0 f4       	brcc	.+40     	; 0xf48 <_printf_P+0x182>
2500
     f20:	cb 01       	movw	r24, r22
2501
     f22:	f3 e0       	ldi	r31, 0x03	; 3
2502
     f24:	88 0f       	add	r24, r24
2503
     f26:	99 1f       	adc	r25, r25
2504
     f28:	fa 95       	dec	r31
2505
     f2a:	e1 f7       	brne	.-8      	; 0xf24 <_printf_P+0x15e>
2506
     f2c:	86 0f       	add	r24, r22
2507
     f2e:	97 1f       	adc	r25, r23
2508
     f30:	68 0f       	add	r22, r24
2509
     f32:	79 1f       	adc	r23, r25
2510
     f34:	60 0f       	add	r22, r16
2511
     f36:	71 1d       	adc	r23, r1
2512
     f38:	60 53       	subi	r22, 0x30	; 48
2513
     f3a:	70 40       	sbci	r23, 0x00	; 0
2514
     f3c:	f5 01       	movw	r30, r10
2515
     f3e:	08 94       	sec
2516
     f40:	a1 1c       	adc	r10, r1
2517
     f42:	b1 1c       	adc	r11, r1
2518
     f44:	04 91       	lpm	r16, Z
2519
     f46:	e8 cf       	rjmp	.-48     	; 0xf18 <_printf_P+0x152>
2520
			}
2521
			prec = n < 0 ? -1 : n;
2522
     f48:	ef ef       	ldi	r30, 0xFF	; 255
2523
     f4a:	6f 3f       	cpi	r22, 0xFF	; 255
2524
     f4c:	7e 07       	cpc	r23, r30
2525
     f4e:	14 f4       	brge	.+4      	; 0xf54 <_printf_P+0x18e>
2526
     f50:	6f ef       	ldi	r22, 0xFF	; 255
2527
     f52:	7f ef       	ldi	r23, 0xFF	; 255
2528
     f54:	16 2f       	mov	r17, r22
2529
			goto reswitch;
2530
     f56:	7f cf       	rjmp	.-258    	; 0xe56 <_printf_P+0x90>
2531
		} else
2532
#endif /* LIGHTPRINTF */
2533
		if (ch=='0') {
2534
     f58:	00 33       	cpi	r16, 0x30	; 48
2535
     f5a:	29 f4       	brne	.+10     	; 0xf66 <_printf_P+0x1a0>
2536
			/*
2537
			 * ``Note that 0 is taken as a flag, not as the
2538
			 * beginning of a field width.''
2539
			 *	-- ANSI X3J11
2540
			 */
2541
			if (!(flags & LADJUST))
2542
     f5c:	54 fc       	sbrc	r5, 4
2543
     f5e:	76 cf       	rjmp	.-276    	; 0xe4c <_printf_P+0x86>
2544
			    flags |= ZEROPAD; /* '-' disables '0' */
2545
     f60:	f0 e2       	ldi	r31, 0x20	; 32
2546
     f62:	5f 2a       	or	r5, r31
2547
			goto rflag;
2548
     f64:	73 cf       	rjmp	.-282    	; 0xe4c <_printf_P+0x86>
2549
		} else if (ch>='1' && ch<='9') {
2550
     f66:	80 2f       	mov	r24, r16
2551
     f68:	81 53       	subi	r24, 0x31	; 49
2552
     f6a:	89 30       	cpi	r24, 0x09	; 9
2553
     f6c:	d8 f4       	brcc	.+54     	; 0xfa4 <_printf_P+0x1de>
2554
			n = 0;
2555
     f6e:	60 e0       	ldi	r22, 0x00	; 0
2556
     f70:	70 e0       	ldi	r23, 0x00	; 0
2557
			do {
2558
				n = 10 * n + to_digit(ch);
2559
     f72:	cb 01       	movw	r24, r22
2560
     f74:	e3 e0       	ldi	r30, 0x03	; 3
2561
     f76:	88 0f       	add	r24, r24
2562
     f78:	99 1f       	adc	r25, r25
2563
     f7a:	ea 95       	dec	r30
2564
     f7c:	e1 f7       	brne	.-8      	; 0xf76 <_printf_P+0x1b0>
2565
     f7e:	86 0f       	add	r24, r22
2566
     f80:	97 1f       	adc	r25, r23
2567
     f82:	68 0f       	add	r22, r24
2568
     f84:	79 1f       	adc	r23, r25
2569
     f86:	60 0f       	add	r22, r16
2570
     f88:	71 1d       	adc	r23, r1
2571
     f8a:	60 53       	subi	r22, 0x30	; 48
2572
     f8c:	70 40       	sbci	r23, 0x00	; 0
2573
				ch = PRG_RDB(fmt++);
2574
     f8e:	f5 01       	movw	r30, r10
2575
     f90:	08 94       	sec
2576
     f92:	a1 1c       	adc	r10, r1
2577
     f94:	b1 1c       	adc	r11, r1
2578
     f96:	04 91       	lpm	r16, Z
2579
			} while (is_digit(ch));
2580
     f98:	80 2f       	mov	r24, r16
2581
     f9a:	80 53       	subi	r24, 0x30	; 48
2582
     f9c:	8a 30       	cpi	r24, 0x0A	; 10
2583
     f9e:	48 f3       	brcs	.-46     	; 0xf72 <_printf_P+0x1ac>
2584
			width = n;
2585
     fa0:	26 2e       	mov	r2, r22
2586
			goto reswitch;
2587
     fa2:	59 cf       	rjmp	.-334    	; 0xe56 <_printf_P+0x90>
2588
		} else if (ch=='h') {
2589
     fa4:	08 36       	cpi	r16, 0x68	; 104
2590
     fa6:	19 f4       	brne	.+6      	; 0xfae <_printf_P+0x1e8>
2591
			flags |= SHORTINT;
2592
     fa8:	24 e0       	ldi	r18, 0x04	; 4
2593
     faa:	52 2a       	or	r5, r18
2594
			goto rflag;
2595
     fac:	4f cf       	rjmp	.-354    	; 0xe4c <_printf_P+0x86>
2596
		} else if (ch=='l') {
2597
     fae:	0c 36       	cpi	r16, 0x6C	; 108
2598
     fb0:	19 f4       	brne	.+6      	; 0xfb8 <_printf_P+0x1f2>
2599
			flags |= LONGINT;
2600
     fb2:	31 e0       	ldi	r19, 0x01	; 1
2601
     fb4:	53 2a       	or	r5, r19
2602
			goto rflag;
2603
     fb6:	4a cf       	rjmp	.-364    	; 0xe4c <_printf_P+0x86>
2604
		} else if (ch=='c') {
2605
     fb8:	03 36       	cpi	r16, 0x63	; 99
2606
     fba:	61 f4       	brne	.+24     	; 0xfd4 <_printf_P+0x20e>
2607
			*(cp = buf) = va_arg(ap, int);
2608
     fbc:	4e 01       	movw	r8, r28
2609
     fbe:	08 94       	sec
2610
     fc0:	81 1c       	adc	r8, r1
2611
     fc2:	91 1c       	adc	r9, r1
2612
     fc4:	f3 01       	movw	r30, r6
2613
     fc6:	42 e0       	ldi	r20, 0x02	; 2
2614
     fc8:	50 e0       	ldi	r21, 0x00	; 0
2615
     fca:	64 0e       	add	r6, r20
2616
     fcc:	75 1e       	adc	r7, r21
2617
     fce:	80 81       	ld	r24, Z
2618
     fd0:	89 83       	std	Y+1, r24	; 0x01
2619
     fd2:	1b c1       	rjmp	.+566    	; 0x120a <_printf_P+0x444>
2620
			size = 1;
2621
			sign = '\0';
2622
		} else if (ch=='D'||ch=='d'||ch=='i') {
2623
     fd4:	04 34       	cpi	r16, 0x44	; 68
2624
     fd6:	21 f0       	breq	.+8      	; 0xfe0 <_printf_P+0x21a>
2625
     fd8:	04 36       	cpi	r16, 0x64	; 100
2626
     fda:	11 f0       	breq	.+4      	; 0xfe0 <_printf_P+0x21a>
2627
     fdc:	09 36       	cpi	r16, 0x69	; 105
2628
     fde:	b1 f5       	brne	.+108    	; 0x104c <_printf_P+0x286>
2629
			if(ch=='D')
2630
     fe0:	04 34       	cpi	r16, 0x44	; 68
2631
     fe2:	11 f4       	brne	.+4      	; 0xfe8 <_printf_P+0x222>
2632
				flags |= LONGINT;
2633
     fe4:	51 e0       	ldi	r21, 0x01	; 1
2634
     fe6:	55 2a       	or	r5, r21
2635
			if (flags&LONGINT) {
2636
     fe8:	50 fe       	sbrs	r5, 0
2637
     fea:	0a c0       	rjmp	.+20     	; 0x1000 <_printf_P+0x23a>
2638
			 	_ulong=va_arg(ap, long);
2639
     fec:	f3 01       	movw	r30, r6
2640
     fee:	84 e0       	ldi	r24, 0x04	; 4
2641
     ff0:	90 e0       	ldi	r25, 0x00	; 0
2642
     ff2:	68 0e       	add	r6, r24
2643
     ff4:	79 1e       	adc	r7, r25
2644
     ff6:	20 81       	ld	r18, Z
2645
     ff8:	31 81       	ldd	r19, Z+1	; 0x01
2646
     ffa:	42 81       	ldd	r20, Z+2	; 0x02
2647
     ffc:	53 81       	ldd	r21, Z+3	; 0x03
2648
     ffe:	0c c0       	rjmp	.+24     	; 0x1018 <_printf_P+0x252>
2649
			} else {
2650
				register int _d;
2651
				_d=va_arg(ap, int);
2652
    1000:	f3 01       	movw	r30, r6
2653
    1002:	42 e0       	ldi	r20, 0x02	; 2
2654
    1004:	50 e0       	ldi	r21, 0x00	; 0
2655
    1006:	64 0e       	add	r6, r20
2656
    1008:	75 1e       	adc	r7, r21
2657
    100a:	80 81       	ld	r24, Z
2658
    100c:	91 81       	ldd	r25, Z+1	; 0x01
2659
				_ulong = flags&SHORTINT ? (long)(short)_d : (long)_d;
2660
    100e:	9c 01       	movw	r18, r24
2661
    1010:	44 27       	eor	r20, r20
2662
    1012:	37 fd       	sbrc	r19, 7
2663
    1014:	40 95       	com	r20
2664
    1016:	54 2f       	mov	r21, r20
2665
    1018:	2c a7       	std	Y+44, r18	; 0x2c
2666
    101a:	3d a7       	std	Y+45, r19	; 0x2d
2667
    101c:	4e a7       	std	Y+46, r20	; 0x2e
2668
    101e:	5f a7       	std	Y+47, r21	; 0x2f
2669
			}
2670
 
2671
			if ((long)_ulong < 0) {
2672
    1020:	8c a5       	ldd	r24, Y+44	; 0x2c
2673
    1022:	9d a5       	ldd	r25, Y+45	; 0x2d
2674
    1024:	ae a5       	ldd	r26, Y+46	; 0x2e
2675
    1026:	bf a5       	ldd	r27, Y+47	; 0x2f
2676
    1028:	b7 ff       	sbrs	r27, 7
2677
    102a:	0d c0       	rjmp	.+26     	; 0x1046 <_printf_P+0x280>
2678
				_ulong = -_ulong;
2679
    102c:	b0 95       	com	r27
2680
    102e:	a0 95       	com	r26
2681
    1030:	90 95       	com	r25
2682
    1032:	81 95       	neg	r24
2683
    1034:	9f 4f       	sbci	r25, 0xFF	; 255
2684
    1036:	af 4f       	sbci	r26, 0xFF	; 255
2685
    1038:	bf 4f       	sbci	r27, 0xFF	; 255
2686
    103a:	8c a7       	std	Y+44, r24	; 0x2c
2687
    103c:	9d a7       	std	Y+45, r25	; 0x2d
2688
    103e:	ae a7       	std	Y+46, r26	; 0x2e
2689
    1040:	bf a7       	std	Y+47, r27	; 0x2f
2690
				sign = '-';
2691
    1042:	8d e2       	ldi	r24, 0x2D	; 45
2692
    1044:	89 a7       	std	Y+41, r24	; 0x29
2693
			}
2694
			base = DEC;
2695
    1046:	7a e0       	ldi	r23, 0x0A	; 10
2696
    1048:	47 2e       	mov	r4, r23
2697
			goto number;
2698
    104a:	7b c0       	rjmp	.+246    	; 0x1142 <_printf_P+0x37c>
2699
		} else
2700
/*
2701
		if (ch=='n') {
2702
			if (flags & LONGINT)
2703
				*va_arg(ap, long *) = ret;
2704
			else if (flags & SHORTINT)
2705
				*va_arg(ap, short *) = ret;
2706
			else
2707
				*va_arg(ap, int *) = ret;
2708
			continue;	// no output
2709
		} else
2710
*/
2711
#ifndef LIGHTPRINTF
2712
		if (ch=='O'||ch=='o') {
2713
    104c:	0f 34       	cpi	r16, 0x4F	; 79
2714
    104e:	11 f0       	breq	.+4      	; 0x1054 <_printf_P+0x28e>
2715
    1050:	0f 36       	cpi	r16, 0x6F	; 111
2716
    1052:	39 f4       	brne	.+14     	; 0x1062 <_printf_P+0x29c>
2717
			if (ch=='O')
2718
    1054:	0f 34       	cpi	r16, 0x4F	; 79
2719
    1056:	11 f4       	brne	.+4      	; 0x105c <_printf_P+0x296>
2720
				flags |= LONGINT;
2721
    1058:	91 e0       	ldi	r25, 0x01	; 1
2722
    105a:	59 2a       	or	r5, r25
2723
			base = OCT;
2724
    105c:	68 e0       	ldi	r22, 0x08	; 8
2725
    105e:	46 2e       	mov	r4, r22
2726
			goto nosign;
2727
    1060:	6f c0       	rjmp	.+222    	; 0x1140 <_printf_P+0x37a>
2728
		} else if (ch=='p') {
2729
    1062:	00 37       	cpi	r16, 0x70	; 112
2730
    1064:	a1 f4       	brne	.+40     	; 0x108e <_printf_P+0x2c8>
2731
			/*
2732
			 * ``The argument shall be a pointer to void.  The
2733
			 * value of the pointer is converted to a sequence
2734
			 * of printable characters, in an implementation-
2735
			 * defined manner.''
2736
			 *	-- ANSI X3J11
2737
			 */
2738
			/* NOSTRICT */
2739
			_ulong = (unsigned int)va_arg(ap, void *);
2740
    1066:	f3 01       	movw	r30, r6
2741
    1068:	a2 e0       	ldi	r26, 0x02	; 2
2742
    106a:	b0 e0       	ldi	r27, 0x00	; 0
2743
    106c:	6a 0e       	add	r6, r26
2744
    106e:	7b 1e       	adc	r7, r27
2745
    1070:	80 81       	ld	r24, Z
2746
    1072:	91 81       	ldd	r25, Z+1	; 0x01
2747
    1074:	9c 01       	movw	r18, r24
2748
    1076:	44 27       	eor	r20, r20
2749
    1078:	55 27       	eor	r21, r21
2750
    107a:	2c a7       	std	Y+44, r18	; 0x2c
2751
    107c:	3d a7       	std	Y+45, r19	; 0x2d
2752
    107e:	4e a7       	std	Y+46, r20	; 0x2e
2753
    1080:	5f a7       	std	Y+47, r21	; 0x2f
2754
			base = HEX;
2755
    1082:	50 e1       	ldi	r21, 0x10	; 16
2756
    1084:	45 2e       	mov	r4, r21
2757
			flags |= HEXPREFIX;
2758
    1086:	30 e4       	ldi	r19, 0x40	; 64
2759
    1088:	53 2a       	or	r5, r19
2760
			ch = 'x';
2761
    108a:	08 e7       	ldi	r16, 0x78	; 120
2762
			goto nosign;
2763
    108c:	59 c0       	rjmp	.+178    	; 0x1140 <_printf_P+0x37a>
2764
		} else if (ch=='s') {  // print a string from RAM
2765
    108e:	03 37       	cpi	r16, 0x73	; 115
2766
    1090:	c1 f5       	brne	.+112    	; 0x1102 <_printf_P+0x33c>
2767
			if ((cp = va_arg(ap, char *)) == NULL) {
2768
    1092:	f3 01       	movw	r30, r6
2769
    1094:	42 e0       	ldi	r20, 0x02	; 2
2770
    1096:	50 e0       	ldi	r21, 0x00	; 0
2771
    1098:	64 0e       	add	r6, r20
2772
    109a:	75 1e       	adc	r7, r21
2773
    109c:	80 80       	ld	r8, Z
2774
    109e:	91 80       	ldd	r9, Z+1	; 0x01
2775
    10a0:	81 14       	cp	r8, r1
2776
    10a2:	91 04       	cpc	r9, r1
2777
    10a4:	89 f4       	brne	.+34     	; 0x10c8 <_printf_P+0x302>
2778
				cp=buf;
2779
    10a6:	4e 01       	movw	r8, r28
2780
    10a8:	08 94       	sec
2781
    10aa:	81 1c       	adc	r8, r1
2782
    10ac:	91 1c       	adc	r9, r1
2783
				cp[0] = '(';
2784
    10ae:	88 e2       	ldi	r24, 0x28	; 40
2785
    10b0:	89 83       	std	Y+1, r24	; 0x01
2786
				cp[1] = 'n';
2787
    10b2:	8e e6       	ldi	r24, 0x6E	; 110
2788
    10b4:	f4 01       	movw	r30, r8
2789
    10b6:	81 83       	std	Z+1, r24	; 0x01
2790
				cp[2] = 'u';
2791
    10b8:	85 e7       	ldi	r24, 0x75	; 117
2792
    10ba:	8b 83       	std	Y+3, r24	; 0x03
2793
				cp[4] = cp[3] = 'l';
2794
    10bc:	8c e6       	ldi	r24, 0x6C	; 108
2795
    10be:	8c 83       	std	Y+4, r24	; 0x04
2796
    10c0:	8d 83       	std	Y+5, r24	; 0x05
2797
				cp[5] = ')';
2798
    10c2:	89 e2       	ldi	r24, 0x29	; 41
2799
    10c4:	8e 83       	std	Y+6, r24	; 0x06
2800
				cp[6] = '\0';
2801
    10c6:	1f 82       	std	Y+7, r1	; 0x07
2802
			}
2803
			if (prec >= 0) {
2804
    10c8:	17 fd       	sbrc	r17, 7
2805
    10ca:	13 c0       	rjmp	.+38     	; 0x10f2 <_printf_P+0x32c>
2806
				/*
2807
				 * can't use strlen; can only look for the
2808
				 * NUL in the first `prec' characters, and
2809
				 * strlen() will go further.
2810
				 */
2811
				char *p = (char*)memchr(cp, 0, prec);
2812
    10cc:	81 2f       	mov	r24, r17
2813
    10ce:	99 27       	eor	r25, r25
2814
    10d0:	87 fd       	sbrc	r24, 7
2815
    10d2:	90 95       	com	r25
2816
    10d4:	ac 01       	movw	r20, r24
2817
    10d6:	60 e0       	ldi	r22, 0x00	; 0
2818
    10d8:	70 e0       	ldi	r23, 0x00	; 0
2819
    10da:	c4 01       	movw	r24, r8
2820
    10dc:	0e 94 64 0c 	call	0x18c8 <memchr>
2821
 
2822
				if (p != NULL) {
2823
    10e0:	00 97       	sbiw	r24, 0x00	; 0
2824
    10e2:	29 f0       	breq	.+10     	; 0x10ee <_printf_P+0x328>
2825
					size = p - cp;
2826
    10e4:	d8 2e       	mov	r13, r24
2827
    10e6:	d8 18       	sub	r13, r8
2828
					if (size > prec)
2829
    10e8:	1d 15       	cp	r17, r13
2830
    10ea:	0c f0       	brlt	.+2      	; 0x10ee <_printf_P+0x328>
2831
    10ec:	90 c0       	rjmp	.+288    	; 0x120e <_printf_P+0x448>
2832
						size = prec;
2833
				} else
2834
					size = prec;
2835
    10ee:	d1 2e       	mov	r13, r17
2836
    10f0:	8e c0       	rjmp	.+284    	; 0x120e <_printf_P+0x448>
2837
			} else
2838
				size = strlen(cp);
2839
    10f2:	f4 01       	movw	r30, r8
2840
    10f4:	01 90       	ld	r0, Z+
2841
    10f6:	00 20       	and	r0, r0
2842
    10f8:	e9 f7       	brne	.-6      	; 0x10f4 <_printf_P+0x32e>
2843
    10fa:	31 97       	sbiw	r30, 0x01	; 1
2844
    10fc:	de 2e       	mov	r13, r30
2845
    10fe:	d8 18       	sub	r13, r8
2846
    1100:	86 c0       	rjmp	.+268    	; 0x120e <_printf_P+0x448>
2847
			sign = '\0';
2848
		} else
2849
#endif /* LIGHTPRINTF */
2850
		if(ch=='U'||ch=='u') {
2851
    1102:	05 35       	cpi	r16, 0x55	; 85
2852
    1104:	11 f0       	breq	.+4      	; 0x110a <_printf_P+0x344>
2853
    1106:	05 37       	cpi	r16, 0x75	; 117
2854
    1108:	39 f4       	brne	.+14     	; 0x1118 <_printf_P+0x352>
2855
			if (ch=='U')
2856
    110a:	05 35       	cpi	r16, 0x55	; 85
2857
    110c:	11 f4       	brne	.+4      	; 0x1112 <_printf_P+0x34c>
2858
				flags |= LONGINT;
2859
    110e:	f1 e0       	ldi	r31, 0x01	; 1
2860
    1110:	5f 2a       	or	r5, r31
2861
			base = DEC;
2862
    1112:	4a e0       	ldi	r20, 0x0A	; 10
2863
    1114:	44 2e       	mov	r4, r20
2864
			goto nosign;
2865
    1116:	14 c0       	rjmp	.+40     	; 0x1140 <_printf_P+0x37a>
2866
		} else if (ch=='X'||ch=='x') {
2867
    1118:	08 35       	cpi	r16, 0x58	; 88
2868
    111a:	19 f0       	breq	.+6      	; 0x1122 <_printf_P+0x35c>
2869
    111c:	08 37       	cpi	r16, 0x78	; 120
2870
    111e:	09 f0       	breq	.+2      	; 0x1122 <_printf_P+0x35c>
2871
    1120:	6c c0       	rjmp	.+216    	; 0x11fa <_printf_P+0x434>
2872
			base = HEX;
2873
    1122:	30 e1       	ldi	r19, 0x10	; 16
2874
    1124:	43 2e       	mov	r4, r19
2875
			/* leading 0x/X only if non-zero */
2876
			if (flags & ALT && _ulong != 0)
2877
    1126:	53 fe       	sbrs	r5, 3
2878
    1128:	0b c0       	rjmp	.+22     	; 0x1140 <_printf_P+0x37a>
2879
    112a:	2c a5       	ldd	r18, Y+44	; 0x2c
2880
    112c:	3d a5       	ldd	r19, Y+45	; 0x2d
2881
    112e:	4e a5       	ldd	r20, Y+46	; 0x2e
2882
    1130:	5f a5       	ldd	r21, Y+47	; 0x2f
2883
    1132:	21 15       	cp	r18, r1
2884
    1134:	31 05       	cpc	r19, r1
2885
    1136:	41 05       	cpc	r20, r1
2886
    1138:	51 05       	cpc	r21, r1
2887
    113a:	11 f0       	breq	.+4      	; 0x1140 <_printf_P+0x37a>
2888
				flags |= HEXPREFIX;
2889
    113c:	30 e4       	ldi	r19, 0x40	; 64
2890
    113e:	53 2a       	or	r5, r19
2891
 
2892
			/* unsigned conversions */
2893
nosign:			sign = '\0';
2894
    1140:	19 a6       	std	Y+41, r1	; 0x29
2895
			/*
2896
			 * ``... diouXx conversions ... if a precision is
2897
			 * specified, the 0 flag will be ignored.''
2898
			 *	-- ANSI X3J11
2899
			 */
2900
number:	if ((dprec = prec) >= 0)
2901
    1142:	18 ab       	std	Y+48, r17	; 0x30
2902
    1144:	17 fd       	sbrc	r17, 7
2903
    1146:	02 c0       	rjmp	.+4      	; 0x114c <_printf_P+0x386>
2904
				flags &= ~ZEROPAD;
2905
    1148:	4f ed       	ldi	r20, 0xDF	; 223
2906
    114a:	54 22       	and	r5, r20
2907
 
2908
			/*
2909
			 * ``The result of converting a zero value with an
2910
			 * explicit precision of zero is no characters.''
2911
			 *	-- ANSI X3J11
2912
			 */
2913
			cp = buf + BUF;
2914
    114c:	29 e2       	ldi	r18, 0x29	; 41
2915
    114e:	82 2e       	mov	r8, r18
2916
    1150:	91 2c       	mov	r9, r1
2917
    1152:	8c 0e       	add	r8, r28
2918
    1154:	9d 1e       	adc	r9, r29
2919
			if (_ulong != 0 || prec != 0) {
2920
    1156:	8c a5       	ldd	r24, Y+44	; 0x2c
2921
    1158:	9d a5       	ldd	r25, Y+45	; 0x2d
2922
    115a:	ae a5       	ldd	r26, Y+46	; 0x2e
2923
    115c:	bf a5       	ldd	r27, Y+47	; 0x2f
2924
    115e:	00 97       	sbiw	r24, 0x00	; 0
2925
    1160:	a1 05       	cpc	r26, r1
2926
    1162:	b1 05       	cpc	r27, r1
2927
    1164:	21 f4       	brne	.+8      	; 0x116e <_printf_P+0x3a8>
2928
    1166:	98 a9       	ldd	r25, Y+48	; 0x30
2929
    1168:	99 23       	and	r25, r25
2930
    116a:	09 f4       	brne	.+2      	; 0x116e <_printf_P+0x3a8>
2931
    116c:	3f c0       	rjmp	.+126    	; 0x11ec <_printf_P+0x426>
2932
    116e:	c4 2c       	mov	r12, r4
2933
    1170:	dd 24       	eor	r13, r13
2934
    1172:	ee 24       	eor	r14, r14
2935
    1174:	ff 24       	eor	r15, r15
2936
				register unsigned char _d,notlastdigit;
2937
				do {
2938
					notlastdigit=(_ulong>=base);
2939
    1176:	33 24       	eor	r3, r3
2940
    1178:	2c a5       	ldd	r18, Y+44	; 0x2c
2941
    117a:	3d a5       	ldd	r19, Y+45	; 0x2d
2942
    117c:	4e a5       	ldd	r20, Y+46	; 0x2e
2943
    117e:	5f a5       	ldd	r21, Y+47	; 0x2f
2944
    1180:	2c 15       	cp	r18, r12
2945
    1182:	3d 05       	cpc	r19, r13
2946
    1184:	4e 05       	cpc	r20, r14
2947
    1186:	5f 05       	cpc	r21, r15
2948
    1188:	10 f0       	brcs	.+4      	; 0x118e <_printf_P+0x3c8>
2949
    118a:	91 e0       	ldi	r25, 0x01	; 1
2950
    118c:	39 2e       	mov	r3, r25
2951
					_d = _ulong % base;
2952
    118e:	6c a5       	ldd	r22, Y+44	; 0x2c
2953
    1190:	7d a5       	ldd	r23, Y+45	; 0x2d
2954
    1192:	8e a5       	ldd	r24, Y+46	; 0x2e
2955
    1194:	9f a5       	ldd	r25, Y+47	; 0x2f
2956
    1196:	a7 01       	movw	r20, r14
2957
    1198:	96 01       	movw	r18, r12
2958
    119a:	0e 94 d4 0d 	call	0x1ba8 <__udivmodsi4>
2959
    119e:	dc 01       	movw	r26, r24
2960
    11a0:	cb 01       	movw	r24, r22
2961
    11a2:	18 2f       	mov	r17, r24
2962
 
2963
					if (_d<10) {
2964
    11a4:	8a 30       	cpi	r24, 0x0A	; 10
2965
    11a6:	10 f4       	brcc	.+4      	; 0x11ac <_printf_P+0x3e6>
2966
						_d+='0';
2967
    11a8:	10 5d       	subi	r17, 0xD0	; 208
2968
    11aa:	04 c0       	rjmp	.+8      	; 0x11b4 <_printf_P+0x3ee>
2969
					} else {
2970
						_d+='a'-10;
2971
    11ac:	19 5a       	subi	r17, 0xA9	; 169
2972
						if (ch=='X') _d&=~0x20;
2973
    11ae:	08 35       	cpi	r16, 0x58	; 88
2974
    11b0:	09 f4       	brne	.+2      	; 0x11b4 <_printf_P+0x3ee>
2975
    11b2:	1f 7d       	andi	r17, 0xDF	; 223
2976
					}
2977
					*--cp=_d;
2978
    11b4:	d4 01       	movw	r26, r8
2979
    11b6:	1e 93       	st	-X, r17
2980
    11b8:	4d 01       	movw	r8, r26
2981
					_ulong /= base;
2982
    11ba:	6c a5       	ldd	r22, Y+44	; 0x2c
2983
    11bc:	7d a5       	ldd	r23, Y+45	; 0x2d
2984
    11be:	8e a5       	ldd	r24, Y+46	; 0x2e
2985
    11c0:	9f a5       	ldd	r25, Y+47	; 0x2f
2986
    11c2:	a7 01       	movw	r20, r14
2987
    11c4:	96 01       	movw	r18, r12
2988
    11c6:	0e 94 d4 0d 	call	0x1ba8 <__udivmodsi4>
2989
    11ca:	2c a7       	std	Y+44, r18	; 0x2c
2990
    11cc:	3d a7       	std	Y+45, r19	; 0x2d
2991
    11ce:	4e a7       	std	Y+46, r20	; 0x2e
2992
    11d0:	5f a7       	std	Y+47, r21	; 0x2f
2993
				} while (notlastdigit);
2994
    11d2:	33 20       	and	r3, r3
2995
    11d4:	81 f6       	brne	.-96     	; 0x1176 <_printf_P+0x3b0>
2996
#ifndef LIGHTPRINTF
2997
				// handle octal leading 0
2998
				if (base==OCT && flags & ALT && *cp != '0')
2999
    11d6:	b8 e0       	ldi	r27, 0x08	; 8
3000
    11d8:	4b 16       	cp	r4, r27
3001
    11da:	41 f4       	brne	.+16     	; 0x11ec <_printf_P+0x426>
3002
    11dc:	53 fe       	sbrs	r5, 3
3003
    11de:	06 c0       	rjmp	.+12     	; 0x11ec <_printf_P+0x426>
3004
    11e0:	10 33       	cpi	r17, 0x30	; 48
3005
    11e2:	21 f0       	breq	.+8      	; 0x11ec <_printf_P+0x426>
3006
					*--cp = '0';
3007
    11e4:	80 e3       	ldi	r24, 0x30	; 48
3008
    11e6:	f4 01       	movw	r30, r8
3009
    11e8:	82 93       	st	-Z, r24
3010
    11ea:	4f 01       	movw	r8, r30
3011
#endif
3012
			}
3013
 
3014
			size = buf + BUF - cp;
3015
    11ec:	ce 01       	movw	r24, r28
3016
    11ee:	01 96       	adiw	r24, 0x01	; 1
3017
    11f0:	d8 2e       	mov	r13, r24
3018
    11f2:	d8 18       	sub	r13, r8
3019
    11f4:	f8 e2       	ldi	r31, 0x28	; 40
3020
    11f6:	df 0e       	add	r13, r31
3021
    11f8:	0b c0       	rjmp	.+22     	; 0x1210 <_printf_P+0x44a>
3022
	} else {  //default
3023
		/* "%?" prints ?, unless ? is NUL */
3024
			if (ch == '\0')
3025
    11fa:	00 23       	and	r16, r16
3026
    11fc:	09 f4       	brne	.+2      	; 0x1200 <_printf_P+0x43a>
3027
    11fe:	4e c0       	rjmp	.+156    	; 0x129c <_printf_P+0x4d6>
3028
				goto done;
3029
			/* pretend it was %c with argument ch */
3030
			cp = buf;
3031
    1200:	4e 01       	movw	r8, r28
3032
    1202:	08 94       	sec
3033
    1204:	81 1c       	adc	r8, r1
3034
    1206:	91 1c       	adc	r9, r1
3035
			*cp = ch;
3036
    1208:	09 83       	std	Y+1, r16	; 0x01
3037
			size = 1;
3038
    120a:	81 e0       	ldi	r24, 0x01	; 1
3039
    120c:	d8 2e       	mov	r13, r24
3040
			sign = '\0';
3041
    120e:	19 a6       	std	Y+41, r1	; 0x29
3042
		}
3043
 
3044
		/*
3045
		 * All reasonable formats wind up here.  At this point,
3046
		 * `cp' points to a string which (if not flags&LADJUST)
3047
		 * should be padded out to `width' places.  If
3048
		 * flags&ZEROPAD, it should first be prefixed by any
3049
		 * sign or other prefix; otherwise, it should be blank
3050
		 * padded before the prefix is emitted.  After any
3051
		 * left-hand padding and prefixing, emit zeroes
3052
		 * required by a decimal [diouxX] precision, then print
3053
		 * the string proper, then emit zeroes required by any
3054
		 * leftover floating precision; finally, if LADJUST,
3055
		 * pad with blanks.
3056
		 */
3057
 
3058
		/*
3059
		 * compute actual size, so we know how much to pad.
3060
		 */
3061
		fieldsz = size;
3062
    1210:	1d 2d       	mov	r17, r13
3063
 
3064
		dpad = dprec - size;
3065
    1212:	c8 a8       	ldd	r12, Y+48	; 0x30
3066
    1214:	cd 18       	sub	r12, r13
3067
		if (dpad < 0)
3068
    1216:	c7 fc       	sbrc	r12, 7
3069
		    dpad = 0;
3070
    1218:	cc 24       	eor	r12, r12
3071
 
3072
		if (sign)
3073
    121a:	89 a5       	ldd	r24, Y+41	; 0x29
3074
    121c:	88 23       	and	r24, r24
3075
    121e:	11 f0       	breq	.+4      	; 0x1224 <_printf_P+0x45e>
3076
			fieldsz++;
3077
    1220:	1f 5f       	subi	r17, 0xFF	; 255
3078
    1222:	02 c0       	rjmp	.+4      	; 0x1228 <_printf_P+0x462>
3079
		else if (flags & HEXPREFIX)
3080
    1224:	56 fc       	sbrc	r5, 6
3081
			fieldsz += 2;
3082
    1226:	1e 5f       	subi	r17, 0xFE	; 254
3083
		fieldsz += dpad;
3084
    1228:	1c 0d       	add	r17, r12
3085
 
3086
		/* right-adjusting blank padding */
3087
		if ((flags & (LADJUST|ZEROPAD)) == 0)
3088
    122a:	e5 2c       	mov	r14, r5
3089
    122c:	ff 24       	eor	r15, r15
3090
    122e:	c7 01       	movw	r24, r14
3091
    1230:	80 73       	andi	r24, 0x30	; 48
3092
    1232:	90 70       	andi	r25, 0x00	; 0
3093
    1234:	89 2b       	or	r24, r25
3094
    1236:	21 f4       	brne	.+8      	; 0x1240 <_printf_P+0x47a>
3095
			PAD_SP(width - fieldsz);
3096
    1238:	82 2d       	mov	r24, r2
3097
    123a:	81 1b       	sub	r24, r17
3098
    123c:	0e 94 cb 06 	call	0xd96 <PAD_SP>
3099
 
3100
		/* prefix */
3101
		if (sign) {
3102
    1240:	89 a5       	ldd	r24, Y+41	; 0x29
3103
    1242:	88 23       	and	r24, r24
3104
    1244:	29 f0       	breq	.+10     	; 0x1250 <_printf_P+0x48a>
3105
			PRINT(&sign, 1);
3106
    1246:	61 e0       	ldi	r22, 0x01	; 1
3107
    1248:	70 e0       	ldi	r23, 0x00	; 0
3108
    124a:	ce 01       	movw	r24, r28
3109
    124c:	89 96       	adiw	r24, 0x29	; 41
3110
    124e:	09 c0       	rjmp	.+18     	; 0x1262 <_printf_P+0x49c>
3111
		} else if (flags & HEXPREFIX) {
3112
    1250:	e6 fe       	sbrs	r14, 6
3113
    1252:	09 c0       	rjmp	.+18     	; 0x1266 <_printf_P+0x4a0>
3114
			ox[0] = '0';
3115
    1254:	80 e3       	ldi	r24, 0x30	; 48
3116
    1256:	8a a7       	std	Y+42, r24	; 0x2a
3117
			ox[1] = ch;
3118
    1258:	0b a7       	std	Y+43, r16	; 0x2b
3119
			PRINT(ox, 2);
3120
    125a:	62 e0       	ldi	r22, 0x02	; 2
3121
    125c:	70 e0       	ldi	r23, 0x00	; 0
3122
    125e:	ce 01       	movw	r24, r28
3123
    1260:	8a 96       	adiw	r24, 0x2a	; 42
3124
    1262:	0e 94 a2 06 	call	0xd44 <PRINT>
3125
		}
3126
 
3127
		/* right-adjusting zero padding */
3128
		if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
3129
    1266:	c7 01       	movw	r24, r14
3130
    1268:	80 73       	andi	r24, 0x30	; 48
3131
    126a:	90 70       	andi	r25, 0x00	; 0
3132
    126c:	80 97       	sbiw	r24, 0x20	; 32
3133
    126e:	21 f4       	brne	.+8      	; 0x1278 <_printf_P+0x4b2>
3134
			PAD_0(width - fieldsz);
3135
    1270:	82 2d       	mov	r24, r2
3136
    1272:	81 1b       	sub	r24, r17
3137
    1274:	0e 94 d7 06 	call	0xdae <PAD_0>
3138
 
3139
		/* leading zeroes from decimal precision */
3140
		PAD_0(dpad);
3141
    1278:	8c 2d       	mov	r24, r12
3142
    127a:	0e 94 d7 06 	call	0xdae <PAD_0>
3143
 
3144
		/* the string or number proper */
3145
		PRINT(cp, size);
3146
    127e:	8d 2d       	mov	r24, r13
3147
    1280:	99 27       	eor	r25, r25
3148
    1282:	87 fd       	sbrc	r24, 7
3149
    1284:	90 95       	com	r25
3150
    1286:	bc 01       	movw	r22, r24
3151
    1288:	c4 01       	movw	r24, r8
3152
    128a:	0e 94 a2 06 	call	0xd44 <PRINT>
3153
 
3154
		/* left-adjusting padding (always blank) */
3155
		if (flags & LADJUST)
3156
    128e:	e4 fe       	sbrs	r14, 4
3157
    1290:	c1 cd       	rjmp	.-1150   	; 0xe14 <_printf_P+0x4e>
3158
			PAD_SP(width - fieldsz);
3159
    1292:	82 2d       	mov	r24, r2
3160
    1294:	81 1b       	sub	r24, r17
3161
    1296:	0e 94 cb 06 	call	0xd96 <PAD_SP>
3162
    129a:	bc cd       	rjmp	.-1160   	; 0xe14 <_printf_P+0x4e>
3163
    129c:	e0 96       	adiw	r28, 0x30	; 48
3164
    129e:	0f b6       	in	r0, 0x3f	; 63
3165
    12a0:	f8 94       	cli
3166
    12a2:	de bf       	out	0x3e, r29	; 62
3167
    12a4:	0f be       	out	0x3f, r0	; 63
3168
    12a6:	cd bf       	out	0x3d, r28	; 61
3169
    12a8:	df 91       	pop	r29
3170
    12aa:	cf 91       	pop	r28
3171
    12ac:	1f 91       	pop	r17
3172
    12ae:	0f 91       	pop	r16
3173
    12b0:	ff 90       	pop	r15
3174
    12b2:	ef 90       	pop	r14
3175
    12b4:	df 90       	pop	r13
3176
    12b6:	cf 90       	pop	r12
3177
    12b8:	bf 90       	pop	r11
3178
    12ba:	af 90       	pop	r10
3179
    12bc:	9f 90       	pop	r9
3180
    12be:	8f 90       	pop	r8
3181
    12c0:	7f 90       	pop	r7
3182
    12c2:	6f 90       	pop	r6
3183
    12c4:	5f 90       	pop	r5
3184
    12c6:	4f 90       	pop	r4
3185
    12c8:	3f 90       	pop	r3
3186
    12ca:	2f 90       	pop	r2
3187
    12cc:	08 95       	ret
3188
 
3189
000012ce <__vector_9>:
3190
};
3191
 
3192
 
3193
SIGNAL (SIG_OVERFLOW1)
3194
{
3195
    12ce:	1f 92       	push	r1
3196
    12d0:	0f 92       	push	r0
3197
    12d2:	0f b6       	in	r0, 0x3f	; 63
3198
    12d4:	0f 92       	push	r0
3199
    12d6:	11 24       	eor	r1, r1
3200
    12d8:	8f 93       	push	r24
3201
    12da:	9f 93       	push	r25
3202
 static unsigned char cnt_10ms = 0;
3203
 TCNT1 -= TIMER_RELOAD_VALUE;
3204
    12dc:	8c b5       	in	r24, 0x2c	; 44
3205
    12de:	9d b5       	in	r25, 0x2d	; 45
3206
    12e0:	8a 5f       	subi	r24, 0xFA	; 250
3207
    12e2:	90 40       	sbci	r25, 0x00	; 0
3208
    12e4:	9d bd       	out	0x2d, r25	; 45
3209
    12e6:	8c bd       	out	0x2c, r24	; 44
3210
 CountMilliseconds++;
3211
    12e8:	80 91 a5 00 	lds	r24, 0x00A5
3212
    12ec:	90 91 a6 00 	lds	r25, 0x00A6
3213
    12f0:	01 96       	adiw	r24, 0x01	; 1
3214
    12f2:	90 93 a6 00 	sts	0x00A6, r25
3215
    12f6:	80 93 a5 00 	sts	0x00A5, r24
3216
 if(DisplayBusy) DisplayBusy--;
3217
    12fa:	80 91 93 00 	lds	r24, 0x0093
3218
    12fe:	88 23       	and	r24, r24
3219
    1300:	29 f0       	breq	.+10     	; 0x130c <__vector_9+0x3e>
3220
    1302:	80 91 93 00 	lds	r24, 0x0093
3221
    1306:	81 50       	subi	r24, 0x01	; 1
3222
    1308:	80 93 93 00 	sts	0x0093, r24
3223
 if(LoescheIrCodeTimer)
3224
    130c:	80 91 7c 00 	lds	r24, 0x007C
3225
    1310:	90 91 7d 00 	lds	r25, 0x007D
3226
    1314:	00 97       	sbiw	r24, 0x00	; 0
3227
    1316:	59 f0       	breq	.+22     	; 0x132e <__vector_9+0x60>
3228
  {
3229
   if(--LoescheIrCodeTimer == 0) IR_Code = 0;
3230
    1318:	01 97       	sbiw	r24, 0x01	; 1
3231
    131a:	90 93 7d 00 	sts	0x007D, r25
3232
    131e:	80 93 7c 00 	sts	0x007C, r24
3233
    1322:	00 97       	sbiw	r24, 0x00	; 0
3234
    1324:	21 f4       	brne	.+8      	; 0x132e <__vector_9+0x60>
3235
    1326:	90 93 c8 01 	sts	0x01C8, r25
3236
    132a:	80 93 c7 01 	sts	0x01C7, r24
3237
    132e:	9f 91       	pop	r25
3238
    1330:	8f 91       	pop	r24
3239
    1332:	0f 90       	pop	r0
3240
    1334:	0f be       	out	0x3f, r0	; 63
3241
    1336:	0f 90       	pop	r0
3242
    1338:	1f 90       	pop	r1
3243
    133a:	18 95       	reti
3244
 
3245
0000133c <Timer1_Init>:
3246
  }
3247
 
3248
}
3249
 
3250
 
3251
void Timer1_Init(void)
3252
{
3253
 
3254
 TCCR1B = TIMER_TEILER;
3255
    133c:	83 e0       	ldi	r24, 0x03	; 3
3256
    133e:	8e bd       	out	0x2e, r24	; 46
3257
 TCNT1 = -TIMER_RELOAD_VALUE;  // reload
3258
    1340:	86 e0       	ldi	r24, 0x06	; 6
3259
    1342:	9f ef       	ldi	r25, 0xFF	; 255
3260
    1344:	9d bd       	out	0x2d, r25	; 45
3261
    1346:	8c bd       	out	0x2c, r24	; 44
3262
 //OCR1  = 0x00;
3263
// Timer(s)/Counter(s) Interrupt(s) initialization
3264
 
3265
#if defined (__AVR_ATmega32__)
3266
  TIMSK |= 0x04;
3267
    1348:	89 b7       	in	r24, 0x39	; 57
3268
    134a:	84 60       	ori	r24, 0x04	; 4
3269
    134c:	89 bf       	out	0x39, r24	; 57
3270
    134e:	08 95       	ret
3271
 
3272
00001350 <SetDelay>:
3273
#endif
3274
 
3275
#if defined (__AVR_ATmega644__)
3276
 TIMSK1 |= _BV(TOIE1);
3277
#endif
3278
 
3279
}
3280
 
3281
 
3282
unsigned int SetDelay (unsigned int t)
3283
{
3284
  return(CountMilliseconds + t - 1);
3285
    1350:	20 91 a5 00 	lds	r18, 0x00A5
3286
    1354:	30 91 a6 00 	lds	r19, 0x00A6
3287
    1358:	28 0f       	add	r18, r24
3288
    135a:	39 1f       	adc	r19, r25
3289
}
3290
    135c:	c9 01       	movw	r24, r18
3291
    135e:	01 97       	sbiw	r24, 0x01	; 1
3292
    1360:	08 95       	ret
3293
 
3294
00001362 <CheckDelay>:
3295
 
3296
char CheckDelay (unsigned int t)
3297
{
3298
  return(((t - CountMilliseconds) & 0x8000) >> 8);
3299
    1362:	20 91 a5 00 	lds	r18, 0x00A5
3300
    1366:	30 91 a6 00 	lds	r19, 0x00A6
3301
    136a:	82 1b       	sub	r24, r18
3302
    136c:	93 0b       	sbc	r25, r19
3303
    136e:	89 2f       	mov	r24, r25
3304
    1370:	99 27       	eor	r25, r25
3305
    1372:	80 78       	andi	r24, 0x80	; 128
3306
}
3307
    1374:	99 27       	eor	r25, r25
3308
    1376:	08 95       	ret
3309
 
3310
00001378 <Delay_ms>:
3311
 
3312
void Delay_ms(unsigned int w)
3313
{
3314
    1378:	cf 93       	push	r28
3315
    137a:	df 93       	push	r29
3316
 unsigned int akt;
3317
 akt = SetDelay(w);
3318
    137c:	0e 94 a8 09 	call	0x1350 <SetDelay>
3319
    1380:	ec 01       	movw	r28, r24
3320
 while (!CheckDelay(akt));
3321
    1382:	ce 01       	movw	r24, r28
3322
    1384:	0e 94 b1 09 	call	0x1362 <CheckDelay>
3323
    1388:	88 23       	and	r24, r24
3324
    138a:	d9 f3       	breq	.-10     	; 0x1382 <Delay_ms+0xa>
3325
    138c:	df 91       	pop	r29
3326
    138e:	cf 91       	pop	r28
3327
    1390:	08 95       	ret
3328
 
3329
00001392 <Keyboard_Init>:
3330
unsigned int KeyTimer = 0;
3331
 
3332
void Keyboard_Init(void)
3333
{
3334
 KeyTimer = SetDelay(KEY_DELAY_MS);
3335
    1392:	82 e3       	ldi	r24, 0x32	; 50
3336
    1394:	90 e0       	ldi	r25, 0x00	; 0
3337
    1396:	0e 94 a8 09 	call	0x1350 <SetDelay>
3338
    139a:	90 93 a9 00 	sts	0x00A9, r25
3339
    139e:	80 93 a8 00 	sts	0x00A8, r24
3340
    13a2:	08 95       	ret
3341
 
3342
000013a4 <GetKeyboard>:
3343
}
3344
 
3345
unsigned char GetKeyboard(void)
3346
{
3347
    13a4:	cf 93       	push	r28
3348
 static char taste1 = 0, taste2 = 0,taste3 = 0,taste4 = 0,taste5 = 0;
3349
 unsigned char ret = 0;
3350
    13a6:	c0 e0       	ldi	r28, 0x00	; 0
3351
 if(CheckDelay(KeyTimer))
3352
    13a8:	80 91 a8 00 	lds	r24, 0x00A8
3353
    13ac:	90 91 a9 00 	lds	r25, 0x00A9
3354
    13b0:	0e 94 b1 09 	call	0x1362 <CheckDelay>
3355
    13b4:	88 23       	and	r24, r24
3356
    13b6:	09 f4       	brne	.+2      	; 0x13ba <GetKeyboard+0x16>
3357
    13b8:	76 c0       	rjmp	.+236    	; 0x14a6 <GetKeyboard+0x102>
3358
 {
3359
  if(_TASTE1) { if(taste1++ == 0 || taste1 == CNT_TASTE) ret |= KEY1;  if(taste1 == CNT_TASTE) taste1 = CNT_TASTE-CNT_TASTE/3;} else taste1 = 0;
3360
    13ba:	cf 9b       	sbis	0x19, 7	; 25
3361
    13bc:	12 c0       	rjmp	.+36     	; 0x13e2 <GetKeyboard+0x3e>
3362
    13be:	80 91 aa 00 	lds	r24, 0x00AA
3363
    13c2:	8f 5f       	subi	r24, 0xFF	; 255
3364
    13c4:	80 93 aa 00 	sts	0x00AA, r24
3365
    13c8:	81 30       	cpi	r24, 0x01	; 1
3366
    13ca:	11 f0       	breq	.+4      	; 0x13d0 <GetKeyboard+0x2c>
3367
    13cc:	8a 30       	cpi	r24, 0x0A	; 10
3368
    13ce:	09 f4       	brne	.+2      	; 0x13d2 <GetKeyboard+0x2e>
3369
    13d0:	c1 e0       	ldi	r28, 0x01	; 1
3370
    13d2:	80 91 aa 00 	lds	r24, 0x00AA
3371
    13d6:	8a 30       	cpi	r24, 0x0A	; 10
3372
    13d8:	31 f4       	brne	.+12     	; 0x13e6 <GetKeyboard+0x42>
3373
    13da:	87 e0       	ldi	r24, 0x07	; 7
3374
    13dc:	80 93 aa 00 	sts	0x00AA, r24
3375
    13e0:	02 c0       	rjmp	.+4      	; 0x13e6 <GetKeyboard+0x42>
3376
    13e2:	c0 93 aa 00 	sts	0x00AA, r28
3377
  if(_TASTE2) { if(taste2++ == 0 || taste2 == CNT_TASTE) ret |= KEY2;  if(taste2 == CNT_TASTE) taste2 = CNT_TASTE-CNT_TASTE/3;} else taste2 = 0;
3378
    13e6:	ce 9b       	sbis	0x19, 6	; 25
3379
    13e8:	12 c0       	rjmp	.+36     	; 0x140e <GetKeyboard+0x6a>
3380
    13ea:	80 91 ab 00 	lds	r24, 0x00AB
3381
    13ee:	8f 5f       	subi	r24, 0xFF	; 255
3382
    13f0:	80 93 ab 00 	sts	0x00AB, r24
3383
    13f4:	81 30       	cpi	r24, 0x01	; 1
3384
    13f6:	11 f0       	breq	.+4      	; 0x13fc <GetKeyboard+0x58>
3385
    13f8:	8a 30       	cpi	r24, 0x0A	; 10
3386
    13fa:	09 f4       	brne	.+2      	; 0x13fe <GetKeyboard+0x5a>
3387
    13fc:	c2 60       	ori	r28, 0x02	; 2
3388
    13fe:	80 91 ab 00 	lds	r24, 0x00AB
3389
    1402:	8a 30       	cpi	r24, 0x0A	; 10
3390
    1404:	31 f4       	brne	.+12     	; 0x1412 <GetKeyboard+0x6e>
3391
    1406:	87 e0       	ldi	r24, 0x07	; 7
3392
    1408:	80 93 ab 00 	sts	0x00AB, r24
3393
    140c:	02 c0       	rjmp	.+4      	; 0x1412 <GetKeyboard+0x6e>
3394
    140e:	10 92 ab 00 	sts	0x00AB, r1
3395
  if(_TASTE3) { if(taste3++ == 0 || taste3 == CNT_TASTE) ret |= KEY3;  if(taste3 == CNT_TASTE) taste3 = CNT_TASTE-CNT_TASTE/3;} else taste3 = 0;
3396
    1412:	cd 9b       	sbis	0x19, 5	; 25
3397
    1414:	12 c0       	rjmp	.+36     	; 0x143a <GetKeyboard+0x96>
3398
    1416:	80 91 ac 00 	lds	r24, 0x00AC
3399
    141a:	8f 5f       	subi	r24, 0xFF	; 255
3400
    141c:	80 93 ac 00 	sts	0x00AC, r24
3401
    1420:	81 30       	cpi	r24, 0x01	; 1
3402
    1422:	11 f0       	breq	.+4      	; 0x1428 <GetKeyboard+0x84>
3403
    1424:	8a 30       	cpi	r24, 0x0A	; 10
3404
    1426:	09 f4       	brne	.+2      	; 0x142a <GetKeyboard+0x86>
3405
    1428:	c4 60       	ori	r28, 0x04	; 4
3406
    142a:	80 91 ac 00 	lds	r24, 0x00AC
3407
    142e:	8a 30       	cpi	r24, 0x0A	; 10
3408
    1430:	31 f4       	brne	.+12     	; 0x143e <GetKeyboard+0x9a>
3409
    1432:	87 e0       	ldi	r24, 0x07	; 7
3410
    1434:	80 93 ac 00 	sts	0x00AC, r24
3411
    1438:	02 c0       	rjmp	.+4      	; 0x143e <GetKeyboard+0x9a>
3412
    143a:	10 92 ac 00 	sts	0x00AC, r1
3413
  if(_TASTE4) { if(taste4++ == 0 || taste4 == CNT_TASTE) ret |= KEY4;  if(taste4 == CNT_TASTE) taste4 = CNT_TASTE-CNT_TASTE/3;} else taste4 = 0;
3414
    143e:	cc 9b       	sbis	0x19, 4	; 25
3415
    1440:	12 c0       	rjmp	.+36     	; 0x1466 <GetKeyboard+0xc2>
3416
    1442:	80 91 ad 00 	lds	r24, 0x00AD
3417
    1446:	8f 5f       	subi	r24, 0xFF	; 255
3418
    1448:	80 93 ad 00 	sts	0x00AD, r24
3419
    144c:	81 30       	cpi	r24, 0x01	; 1
3420
    144e:	11 f0       	breq	.+4      	; 0x1454 <GetKeyboard+0xb0>
3421
    1450:	8a 30       	cpi	r24, 0x0A	; 10
3422
    1452:	09 f4       	brne	.+2      	; 0x1456 <GetKeyboard+0xb2>
3423
    1454:	c8 60       	ori	r28, 0x08	; 8
3424
    1456:	80 91 ad 00 	lds	r24, 0x00AD
3425
    145a:	8a 30       	cpi	r24, 0x0A	; 10
3426
    145c:	31 f4       	brne	.+12     	; 0x146a <GetKeyboard+0xc6>
3427
    145e:	87 e0       	ldi	r24, 0x07	; 7
3428
    1460:	80 93 ad 00 	sts	0x00AD, r24
3429
    1464:	02 c0       	rjmp	.+4      	; 0x146a <GetKeyboard+0xc6>
3430
    1466:	10 92 ad 00 	sts	0x00AD, r1
3431
  if(_TASTE5) { if(taste5++ == 0 || taste5 == CNT_TASTE) ret |= KEY5;  if(taste5 == CNT_TASTE) taste5 = CNT_TASTE-CNT_TASTE/3;} else taste5 = 0;
3432
    146a:	cb 9b       	sbis	0x19, 3	; 25
3433
    146c:	12 c0       	rjmp	.+36     	; 0x1492 <GetKeyboard+0xee>
3434
    146e:	80 91 ae 00 	lds	r24, 0x00AE
3435
    1472:	8f 5f       	subi	r24, 0xFF	; 255
3436
    1474:	80 93 ae 00 	sts	0x00AE, r24
3437
    1478:	81 30       	cpi	r24, 0x01	; 1
3438
    147a:	11 f0       	breq	.+4      	; 0x1480 <GetKeyboard+0xdc>
3439
    147c:	8a 30       	cpi	r24, 0x0A	; 10
3440
    147e:	09 f4       	brne	.+2      	; 0x1482 <GetKeyboard+0xde>
3441
    1480:	c0 61       	ori	r28, 0x10	; 16
3442
    1482:	80 91 ae 00 	lds	r24, 0x00AE
3443
    1486:	8a 30       	cpi	r24, 0x0A	; 10
3444
    1488:	31 f4       	brne	.+12     	; 0x1496 <GetKeyboard+0xf2>
3445
    148a:	87 e0       	ldi	r24, 0x07	; 7
3446
    148c:	80 93 ae 00 	sts	0x00AE, r24
3447
    1490:	02 c0       	rjmp	.+4      	; 0x1496 <GetKeyboard+0xf2>
3448
    1492:	10 92 ae 00 	sts	0x00AE, r1
3449
  KeyTimer = SetDelay(KEY_DELAY_MS);
3450
    1496:	82 e3       	ldi	r24, 0x32	; 50
3451
    1498:	90 e0       	ldi	r25, 0x00	; 0
3452
    149a:	0e 94 a8 09 	call	0x1350 <SetDelay>
3453
    149e:	90 93 a9 00 	sts	0x00A9, r25
3454
    14a2:	80 93 a8 00 	sts	0x00A8, r24
3455
 }
3456
 return(ret);
3457
}
3458
    14a6:	8c 2f       	mov	r24, r28
3459
    14a8:	99 27       	eor	r25, r25
3460
    14aa:	cf 91       	pop	r28
3461
    14ac:	08 95       	ret
3462
 
3463
000014ae <GetKeyboard2>:
3464
 
3465
unsigned char GetKeyboard2(void)
3466
{
3467
 unsigned char ret = 0;
3468
    14ae:	80 e0       	ldi	r24, 0x00	; 0
3469
  if(_TASTE1)  ret |= KEY1;
3470
    14b0:	cf 99       	sbic	0x19, 7	; 25
3471
    14b2:	81 e0       	ldi	r24, 0x01	; 1
3472
  if(_TASTE2)  ret |= KEY2;
3473
    14b4:	ce 99       	sbic	0x19, 6	; 25
3474
    14b6:	82 60       	ori	r24, 0x02	; 2
3475
  if(_TASTE3)  ret |= KEY3;
3476
    14b8:	cd 99       	sbic	0x19, 5	; 25
3477
    14ba:	84 60       	ori	r24, 0x04	; 4
3478
  if(_TASTE4)  ret |= KEY4;
3479
    14bc:	cc 99       	sbic	0x19, 4	; 25
3480
    14be:	88 60       	ori	r24, 0x08	; 8
3481
  if(_TASTE5)  ret |= KEY5;
3482
    14c0:	cb 99       	sbic	0x19, 3	; 25
3483
    14c2:	80 61       	ori	r24, 0x10	; 16
3484
 return(ret);
3485
}
3486
    14c4:	99 27       	eor	r25, r25
3487
    14c6:	08 95       	ret
3488
 
3489
000014c8 <Menu>:
3490
unsigned char KanalVon[MAX_KANAL];
3491
unsigned char KanalAn[MAX_KANAL];
3492
 
3493
void Menu(unsigned char key)
3494
 {
3495
    14c8:	0f 93       	push	r16
3496
    14ca:	1f 93       	push	r17
3497
    14cc:	cf 93       	push	r28
3498
    14ce:	df 93       	push	r29
3499
  static unsigned int  arr = 0;
3500
  static unsigned char MaxMenue = 2,MenuePunkt=0;
3501
  unsigned char kanal = 0;
3502
 
3503
  if(key & KEY1) { if(MenuePunkt) MenuePunkt--; else MenuePunkt = MaxMenue; LCD_Clear; }
3504
    14d0:	c8 2f       	mov	r28, r24
3505
    14d2:	dd 27       	eor	r29, r29
3506
    14d4:	c0 ff       	sbrs	r28, 0
3507
    14d6:	0f c0       	rjmp	.+30     	; 0x14f6 <Menu+0x2e>
3508
    14d8:	80 91 b3 00 	lds	r24, 0x00B3
3509
    14dc:	88 23       	and	r24, r24
3510
    14de:	11 f0       	breq	.+4      	; 0x14e4 <Menu+0x1c>
3511
    14e0:	81 50       	subi	r24, 0x01	; 1
3512
    14e2:	02 c0       	rjmp	.+4      	; 0x14e8 <Menu+0x20>
3513
    14e4:	80 91 7b 00 	lds	r24, 0x007B
3514
    14e8:	80 93 b3 00 	sts	0x00B3, r24
3515
    14ec:	81 e0       	ldi	r24, 0x01	; 1
3516
    14ee:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
3517
    14f2:	0e 94 c9 05 	call	0xb92 <_long_delay>
3518
  if(key & KEY2) { MenuePunkt++; LCD_Clear; }
3519
    14f6:	8e 01       	movw	r16, r28
3520
    14f8:	02 70       	andi	r16, 0x02	; 2
3521
    14fa:	10 70       	andi	r17, 0x00	; 0
3522
    14fc:	c1 ff       	sbrs	r28, 1
3523
    14fe:	0a c0       	rjmp	.+20     	; 0x1514 <Menu+0x4c>
3524
    1500:	80 91 b3 00 	lds	r24, 0x00B3
3525
    1504:	8f 5f       	subi	r24, 0xFF	; 255
3526
    1506:	80 93 b3 00 	sts	0x00B3, r24
3527
    150a:	81 e0       	ldi	r24, 0x01	; 1
3528
    150c:	0e 94 e1 05 	call	0xbc2 <_lcd_write_command>
3529
    1510:	0e 94 c9 05 	call	0xb92 <_long_delay>
3530
  if((key & KEY1) && (key & KEY2)) MenuePunkt = 0;
3531
    1514:	c0 ff       	sbrs	r28, 0
3532
    1516:	04 c0       	rjmp	.+8      	; 0x1520 <Menu+0x58>
3533
    1518:	01 2b       	or	r16, r17
3534
    151a:	11 f0       	breq	.+4      	; 0x1520 <Menu+0x58>
3535
    151c:	10 92 b3 00 	sts	0x00B3, r1
3536
//  LCD_printfxy(13,0,"[%i]",MenuePunkt);
3537
  switch(MenuePunkt)
3538
    1520:	20 91 b3 00 	lds	r18, 0x00B3
3539
    1524:	82 2f       	mov	r24, r18
3540
    1526:	99 27       	eor	r25, r25
3541
    1528:	81 30       	cpi	r24, 0x01	; 1
3542
    152a:	91 05       	cpc	r25, r1
3543
    152c:	09 f4       	brne	.+2      	; 0x1530 <Menu+0x68>
3544
    152e:	41 c0       	rjmp	.+130    	; 0x15b2 <Menu+0xea>
3545
    1530:	82 30       	cpi	r24, 0x02	; 2
3546
    1532:	91 05       	cpc	r25, r1
3547
    1534:	1c f4       	brge	.+6      	; 0x153c <Menu+0x74>
3548
    1536:	89 2b       	or	r24, r25
3549
    1538:	49 f0       	breq	.+18     	; 0x154c <Menu+0x84>
3550
    153a:	bf c0       	rjmp	.+382    	; 0x16ba <Menu+0x1f2>
3551
    153c:	82 30       	cpi	r24, 0x02	; 2
3552
    153e:	91 05       	cpc	r25, r1
3553
    1540:	09 f4       	brne	.+2      	; 0x1544 <Menu+0x7c>
3554
    1542:	6a c0       	rjmp	.+212    	; 0x1618 <Menu+0x150>
3555
    1544:	03 97       	sbiw	r24, 0x03	; 3
3556
    1546:	09 f4       	brne	.+2      	; 0x154a <Menu+0x82>
3557
    1548:	8e c0       	rjmp	.+284    	; 0x1666 <Menu+0x19e>
3558
    154a:	b7 c0       	rjmp	.+366    	; 0x16ba <Menu+0x1f2>
3559
   {
3560
    case 0:
3561
           LCD_printfxy(0,0,"Verbinden mit");
3562
    154c:	60 e0       	ldi	r22, 0x00	; 0
3563
    154e:	86 2f       	mov	r24, r22
3564
    1550:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3565
    1554:	84 eb       	ldi	r24, 0xB4	; 180
3566
    1556:	90 e0       	ldi	r25, 0x00	; 0
3567
    1558:	9f 93       	push	r25
3568
    155a:	8f 93       	push	r24
3569
    155c:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3570
           LCD_printfxy(0,1,"MicroSPS:%2i ",SlaveAdresse);
3571
    1560:	61 e0       	ldi	r22, 0x01	; 1
3572
    1562:	80 e0       	ldi	r24, 0x00	; 0
3573
    1564:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3574
    1568:	0f 90       	pop	r0
3575
    156a:	0f 90       	pop	r0
3576
    156c:	80 91 64 00 	lds	r24, 0x0064
3577
    1570:	99 27       	eor	r25, r25
3578
    1572:	9f 93       	push	r25
3579
    1574:	8f 93       	push	r24
3580
    1576:	82 ec       	ldi	r24, 0xC2	; 194
3581
    1578:	90 e0       	ldi	r25, 0x00	; 0
3582
    157a:	9f 93       	push	r25
3583
    157c:	8f 93       	push	r24
3584
    157e:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3585
           if(key & KEY3 && SlaveAdresse > 1) SlaveAdresse--;
3586
    1582:	0f 90       	pop	r0
3587
    1584:	0f 90       	pop	r0
3588
    1586:	0f 90       	pop	r0
3589
    1588:	0f 90       	pop	r0
3590
    158a:	c2 ff       	sbrs	r28, 2
3591
    158c:	07 c0       	rjmp	.+14     	; 0x159c <Menu+0xd4>
3592
    158e:	80 91 64 00 	lds	r24, 0x0064
3593
    1592:	82 30       	cpi	r24, 0x02	; 2
3594
    1594:	18 f0       	brcs	.+6      	; 0x159c <Menu+0xd4>
3595
    1596:	81 50       	subi	r24, 0x01	; 1
3596
    1598:	80 93 64 00 	sts	0x0064, r24
3597
           if(key & KEY4 && SlaveAdresse < 26) SlaveAdresse++;
3598
    159c:	c3 ff       	sbrs	r28, 3
3599
    159e:	92 c0       	rjmp	.+292    	; 0x16c4 <Menu+0x1fc>
3600
    15a0:	80 91 64 00 	lds	r24, 0x0064
3601
    15a4:	8a 31       	cpi	r24, 0x1A	; 26
3602
    15a6:	08 f0       	brcs	.+2      	; 0x15aa <Menu+0xe2>
3603
    15a8:	8d c0       	rjmp	.+282    	; 0x16c4 <Menu+0x1fc>
3604
    15aa:	8f 5f       	subi	r24, 0xFF	; 255
3605
    15ac:	80 93 64 00 	sts	0x0064, r24
3606
           break;
3607
    15b0:	89 c0       	rjmp	.+274    	; 0x16c4 <Menu+0x1fc>
3608
    case 1:
3609
           LCD_printfxy(0,0,"Max Adresse");
3610
    15b2:	60 e0       	ldi	r22, 0x00	; 0
3611
    15b4:	86 2f       	mov	r24, r22
3612
    15b6:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3613
    15ba:	80 ed       	ldi	r24, 0xD0	; 208
3614
    15bc:	90 e0       	ldi	r25, 0x00	; 0
3615
    15be:	9f 93       	push	r25
3616
    15c0:	8f 93       	push	r24
3617
    15c2:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3618
           LCD_printfxy(0,1,"%2i ",AnzahlTeilnehmer);
3619
    15c6:	61 e0       	ldi	r22, 0x01	; 1
3620
    15c8:	80 e0       	ldi	r24, 0x00	; 0
3621
    15ca:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3622
    15ce:	0f 90       	pop	r0
3623
    15d0:	0f 90       	pop	r0
3624
    15d2:	80 91 6c 00 	lds	r24, 0x006C
3625
    15d6:	99 27       	eor	r25, r25
3626
    15d8:	9f 93       	push	r25
3627
    15da:	8f 93       	push	r24
3628
    15dc:	8c ed       	ldi	r24, 0xDC	; 220
3629
    15de:	90 e0       	ldi	r25, 0x00	; 0
3630
    15e0:	9f 93       	push	r25
3631
    15e2:	8f 93       	push	r24
3632
    15e4:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3633
           if(key & KEY3 && AnzahlTeilnehmer > 1)  AnzahlTeilnehmer--;
3634
    15e8:	0f 90       	pop	r0
3635
    15ea:	0f 90       	pop	r0
3636
    15ec:	0f 90       	pop	r0
3637
    15ee:	0f 90       	pop	r0
3638
    15f0:	c2 ff       	sbrs	r28, 2
3639
    15f2:	07 c0       	rjmp	.+14     	; 0x1602 <Menu+0x13a>
3640
    15f4:	80 91 6c 00 	lds	r24, 0x006C
3641
    15f8:	82 30       	cpi	r24, 0x02	; 2
3642
    15fa:	18 f0       	brcs	.+6      	; 0x1602 <Menu+0x13a>
3643
    15fc:	81 50       	subi	r24, 0x01	; 1
3644
    15fe:	80 93 6c 00 	sts	0x006C, r24
3645
           if(key & KEY4 && AnzahlTeilnehmer < 26) AnzahlTeilnehmer++;
3646
    1602:	c3 ff       	sbrs	r28, 3
3647
    1604:	5f c0       	rjmp	.+190    	; 0x16c4 <Menu+0x1fc>
3648
    1606:	80 91 6c 00 	lds	r24, 0x006C
3649
    160a:	8a 31       	cpi	r24, 0x1A	; 26
3650
    160c:	08 f0       	brcs	.+2      	; 0x1610 <Menu+0x148>
3651
    160e:	5a c0       	rjmp	.+180    	; 0x16c4 <Menu+0x1fc>
3652
    1610:	8f 5f       	subi	r24, 0xFF	; 255
3653
    1612:	80 93 6c 00 	sts	0x006C, r24
3654
           break;
3655
    1616:	56 c0       	rjmp	.+172    	; 0x16c4 <Menu+0x1fc>
3656
    case 2:
3657
           LCD_printfxy(0,0,"Checksum");
3658
    1618:	60 e0       	ldi	r22, 0x00	; 0
3659
    161a:	86 2f       	mov	r24, r22
3660
    161c:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3661
    1620:	81 ee       	ldi	r24, 0xE1	; 225
3662
    1622:	90 e0       	ldi	r25, 0x00	; 0
3663
    1624:	9f 93       	push	r25
3664
    1626:	8f 93       	push	r24
3665
    1628:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3666
           LCD_printfxy(0,1,"Errors:%5i ",CntCrcError);
3667
    162c:	61 e0       	ldi	r22, 0x01	; 1
3668
    162e:	80 e0       	ldi	r24, 0x00	; 0
3669
    1630:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3670
    1634:	0f 90       	pop	r0
3671
    1636:	0f 90       	pop	r0
3672
    1638:	80 91 99 00 	lds	r24, 0x0099
3673
    163c:	90 91 9a 00 	lds	r25, 0x009A
3674
    1640:	9f 93       	push	r25
3675
    1642:	8f 93       	push	r24
3676
    1644:	8a ee       	ldi	r24, 0xEA	; 234
3677
    1646:	90 e0       	ldi	r25, 0x00	; 0
3678
    1648:	9f 93       	push	r25
3679
    164a:	8f 93       	push	r24
3680
    164c:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3681
           if(key & KEY3) CntCrcError = 0;
3682
    1650:	0f 90       	pop	r0
3683
    1652:	0f 90       	pop	r0
3684
    1654:	0f 90       	pop	r0
3685
    1656:	0f 90       	pop	r0
3686
    1658:	c2 ff       	sbrs	r28, 2
3687
    165a:	34 c0       	rjmp	.+104    	; 0x16c4 <Menu+0x1fc>
3688
    165c:	10 92 9a 00 	sts	0x009A, r1
3689
    1660:	10 92 99 00 	sts	0x0099, r1
3690
           break;
3691
    1664:	2f c0       	rjmp	.+94     	; 0x16c4 <Menu+0x1fc>
3692
    case 3:
3693
           LCD_printfxy(0,0,"Display");
3694
    1666:	60 e0       	ldi	r22, 0x00	; 0
3695
    1668:	86 2f       	mov	r24, r22
3696
    166a:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3697
    166e:	86 ef       	ldi	r24, 0xF6	; 246
3698
    1670:	90 e0       	ldi	r25, 0x00	; 0
3699
    1672:	9f 93       	push	r25
3700
    1674:	8f 93       	push	r24
3701
    1676:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3702
           LCD_printfxy(0,1,"Zeilen:%1i ",DisplayZeilen);
3703
    167a:	61 e0       	ldi	r22, 0x01	; 1
3704
    167c:	80 e0       	ldi	r24, 0x00	; 0
3705
    167e:	0e 94 55 06 	call	0xcaa <LCD_Gotoxy>
3706
    1682:	0f 90       	pop	r0
3707
    1684:	0f 90       	pop	r0
3708
    1686:	80 91 65 00 	lds	r24, 0x0065
3709
    168a:	99 27       	eor	r25, r25
3710
    168c:	9f 93       	push	r25
3711
    168e:	8f 93       	push	r24
3712
    1690:	8e ef       	ldi	r24, 0xFE	; 254
3713
    1692:	90 e0       	ldi	r25, 0x00	; 0
3714
    1694:	9f 93       	push	r25
3715
    1696:	8f 93       	push	r24
3716
    1698:	0e 94 e3 06 	call	0xdc6 <_printf_P>
3717
           if(key & KEY3) DisplayZeilen = 4;
3718
    169c:	0f 90       	pop	r0
3719
    169e:	0f 90       	pop	r0
3720
    16a0:	0f 90       	pop	r0
3721
    16a2:	0f 90       	pop	r0
3722
    16a4:	c2 ff       	sbrs	r28, 2
3723
    16a6:	03 c0       	rjmp	.+6      	; 0x16ae <Menu+0x1e6>
3724
    16a8:	84 e0       	ldi	r24, 0x04	; 4
3725
    16aa:	80 93 65 00 	sts	0x0065, r24
3726
           if(key & KEY4) DisplayZeilen = 2;
3727
    16ae:	c3 ff       	sbrs	r28, 3
3728
    16b0:	09 c0       	rjmp	.+18     	; 0x16c4 <Menu+0x1fc>
3729
    16b2:	82 e0       	ldi	r24, 0x02	; 2
3730
    16b4:	80 93 65 00 	sts	0x0065, r24
3731
           break;
3732
    16b8:	05 c0       	rjmp	.+10     	; 0x16c4 <Menu+0x1fc>
3733
 
3734
 
3735
/*    case 1:
3736
    case 2:
3737
    case 3:
3738
    case 4:
3739
	       kanal = MenuePunkt - 1;
3740
           LCD_printfxy(0,0,"Datenkanal:%2i",kanal);
3741
           LCD_printfxy(0,1,"Von:%2i an %2i ",KanalVon[kanal],KanalAn[kanal]);
3742
           if(key & KEY3) KanalVon[kanal]++;
3743
           if(key & KEY4) KanalAn[kanal]++;
3744
		   KanalVon[kanal] % MAX_KANAL;
3745
		   KanalAn[kanal] % MAX_KANAL;
3746
           break;
3747
*/
3748
/*
3749
    case 1:
3750
           LCD_printfxy(0,0,"Intervall");
3751
           LCD_printfxy(0,1,"Display:%3ims ",IntervallDisplay);
3752
           if(key & KEY3 && IntervallDisplay > 25)  IntervallDisplay -= 5;
3753
           if(key & KEY4 && IntervallDisplay < 990) IntervallDisplay += 5;
3754
           break;
3755
    case 2:
3756
           LCD_printfxy(0,0,"Intervall");
3757
           LCD_printfxy(0,1,"Debug:%3ims ",IntervallDebug);
3758
           if(key & KEY3 && IntervallDebug > 25)  IntervallDebug -= 5;
3759
           if(key & KEY4 && IntervallDebug < 990) IntervallDebug += 5;
3760
           break;
3761
 
3762
    case 1:
3763
           LCD_printfxy(0,0,"Time");
3764
           LCD_printfxy(0,1,"%3i:%02i",Minute,Sekunde);
3765
           if(key & KEY3) if(Minute) Minute--;
3766
           if(key & KEY4) Minute++;
3767
           if(key & KEY5) Sekunde = 0;
3768
           break;
3769
    case 2:
3770
           LCD_printfxy(0,0,"Testvariable");
3771
           LCD_printfxy(0,1,"TestInt:%5i",TestInt);
3772
           if(key & KEY3) TestInt--;
3773
           if(key & KEY4) TestInt++;
3774
           break;
3775
    case 3:
3776
           LCD_printfxy(0,0,"Testarray");
3777
           LCD_printfxy(0,1,"Array[%i]=%3i",arr,Array[arr]);
3778
           if(key & KEY5) if(++arr == ARRAYGROESSE) arr = 0;
3779
           if(key & KEY3) Array[arr]--;
3780
           if(key & KEY4) Array[arr]++;
3781
           break;
3782
    case 4:
3783
		    LCD_printfxy(0,0,"Infrarot RC5:");
3784
            LCD_printfxy(0,1,"Adr:%2i Cmd:%3i",(IR_Code >> 8), IR_Code & 0xff);
3785
           break;
3786
*/
3787
    default: MaxMenue = MenuePunkt - 1;
3788
    16ba:	21 50       	subi	r18, 0x01	; 1
3789
    16bc:	20 93 7b 00 	sts	0x007B, r18
3790
             MenuePunkt = 0;
3791
    16c0:	10 92 b3 00 	sts	0x00B3, r1
3792
    16c4:	df 91       	pop	r29
3793
    16c6:	cf 91       	pop	r28
3794
    16c8:	1f 91       	pop	r17
3795
    16ca:	0f 91       	pop	r16
3796
    16cc:	08 95       	ret
3797
 
3798
000016ce <InitIR>:
3799
// Init IR
3800
// ************************************************************************
3801
void InitIR(void)
3802
{
3803
  INT0_ENABLE;           // ext. Int0 enable
3804
    16ce:	8b b7       	in	r24, 0x3b	; 59
3805
    16d0:	80 64       	ori	r24, 0x40	; 64
3806
    16d2:	8b bf       	out	0x3b, r24	; 59
3807
  CLR_INT0_FLAG;            // war |= 0x40
3808
    16d4:	8a b7       	in	r24, 0x3a	; 58
3809
    16d6:	8f 7b       	andi	r24, 0xBF	; 191
3810
    16d8:	8a bf       	out	0x3a, r24	; 58
3811
  INIT_INT0_FLANKE;
3812
    16da:	85 b7       	in	r24, 0x35	; 53
3813
    16dc:	8c 7f       	andi	r24, 0xFC	; 252
3814
    16de:	85 bf       	out	0x35, r24	; 53
3815
    16e0:	85 b7       	in	r24, 0x35	; 53
3816
    16e2:	82 60       	ori	r24, 0x02	; 2
3817
    16e4:	85 bf       	out	0x35, r24	; 53
3818
  TIMER0_PRESCALER = 0x04;           // Timer0: Clk div 256
3819
    16e6:	84 e0       	ldi	r24, 0x04	; 4
3820
    16e8:	83 bf       	out	0x33, r24	; 51
3821
 
3822
  Decodierung_Lauft = 0;
3823
    16ea:	10 92 c9 01 	sts	0x01C9, r1
3824
  New_IR_Code = 0;
3825
    16ee:	10 92 c6 01 	sts	0x01C6, r1
3826
  IR_Code = 0;
3827
    16f2:	10 92 c8 01 	sts	0x01C8, r1
3828
    16f6:	10 92 c7 01 	sts	0x01C7, r1
3829
    16fa:	08 95       	ret
3830
 
3831
000016fc <__vector_1>:
3832
 
3833
 
3834
 
3835
}
3836
// **************************************************************************
3837
// * aufgerufen durch: externer Interrupt
3838
// **************************************************************************
3839
// * Die Funktion wird durch einen externen Interrupt aufgerufen.
3840
// * Sie dient nur zum Starten der Abtastsequenz und zum Triggern auf die
3841
// * Signalflanken in der Mitte der Daten.
3842
// **************************************************************************
3843
SIGNAL (SIG_INTERRUPT0)
3844
{
3845
    16fc:	1f 92       	push	r1
3846
    16fe:	0f 92       	push	r0
3847
    1700:	0f b6       	in	r0, 0x3f	; 63
3848
    1702:	0f 92       	push	r0
3849
    1704:	11 24       	eor	r1, r1
3850
    1706:	8f 93       	push	r24
3851
    // Zeitbasis fuer Timer einstellen
3852
    // Entspricht 1,5 mal einer Bitlaenge
3853
//    PORTB++;
3854
     TCNT0 = -41;
3855
    1708:	87 ed       	ldi	r24, 0xD7	; 215
3856
    170a:	82 bf       	out	0x32, r24	; 50
3857
     TIM0_START;                         // Timer 0 starten,
3858
    170c:	89 b7       	in	r24, 0x39	; 57
3859
    170e:	81 60       	ori	r24, 0x01	; 1
3860
    1710:	89 bf       	out	0x39, r24	; 57
3861
     if(Decodierung_Lauft) INT0_DISABLE; // die erneute Int.-Ausl”sung soll
3862
    1712:	80 91 c9 01 	lds	r24, 0x01C9
3863
    1716:	88 23       	and	r24, r24
3864
    1718:	19 f0       	breq	.+6      	; 0x1720 <__vector_1+0x24>
3865
    171a:	8b b7       	in	r24, 0x3b	; 59
3866
    171c:	8f 7b       	andi	r24, 0xBF	; 191
3867
    171e:	8b bf       	out	0x3b, r24	; 59
3868
    1720:	8f 91       	pop	r24
3869
    1722:	0f 90       	pop	r0
3870
    1724:	0f be       	out	0x3f, r0	; 63
3871
    1726:	0f 90       	pop	r0
3872
    1728:	1f 90       	pop	r1
3873
    172a:	18 95       	reti
3874
 
3875
0000172c <__vector_11>:
3876
		                                   // nur die Timer-Routine erlauben
3877
 
3878
}
3879
 
3880
// **************************************************************************
3881
// * aufgerufen durch: Timerueberlauf Timer 0
3882
// **************************************************************************
3883
// * Die Funktion wird durch einen Timer0-Interrupt aufgerufen.
3884
// * Der Timer wird vom ext. Int0 gestartet.
3885
// * Das Infrarotsignal wird hier abgetastet und die Wertigkeiten der
3886
// * Bits entsprechend aufaddiert. Das empfangende Zeichen wird in der
3887
// * globalen Variablen IR_Code gespeichert. Nach Empfang wird das Bit
3888
// * Neues_Zeichen gesetzt.
3889
// **************************************************************************
3890
SIGNAL (SIG_OVERFLOW0)
3891
{
3892
    172c:	1f 92       	push	r1
3893
    172e:	0f 92       	push	r0
3894
    1730:	0f b6       	in	r0, 0x3f	; 63
3895
    1732:	0f 92       	push	r0
3896
    1734:	11 24       	eor	r1, r1
3897
    1736:	2f 93       	push	r18
3898
    1738:	3f 93       	push	r19
3899
    173a:	4f 93       	push	r20
3900
    173c:	8f 93       	push	r24
3901
    173e:	9f 93       	push	r25
3902
 
3903
static unsigned int  Shift,IR_Code_tmp;
3904
static unsigned char IR_Zaehler=0,IRSperrCounter=0;
3905
// Reinitialize Timer's 0 value
3906
TCNT1 = -41;
3907
    1740:	87 ed       	ldi	r24, 0xD7	; 215
3908
    1742:	9f ef       	ldi	r25, 0xFF	; 255
3909
    1744:	9d bd       	out	0x2d, r25	; 45
3910
    1746:	8c bd       	out	0x2c, r24	; 44
3911
 if (IRSperrCounter)
3912
    1748:	80 91 b9 00 	lds	r24, 0x00B9
3913
    174c:	88 23       	and	r24, r24
3914
    174e:	69 f0       	breq	.+26     	; 0x176a <__vector_11+0x3e>
3915
 { IRSperrCounter--;
3916
    1750:	81 50       	subi	r24, 0x01	; 1
3917
    1752:	80 93 b9 00 	sts	0x00B9, r24
3918
   if (!IRSperrCounter)
3919
    1756:	88 23       	and	r24, r24
3920
    1758:	09 f0       	breq	.+2      	; 0x175c <__vector_11+0x30>
3921
    175a:	8a c0       	rjmp	.+276    	; 0x1870 <__vector_11+0x144>
3922
   {
3923
     TIM0_STOPP;   // Timer0 sperre wird durch ExtInt0 gestartet
3924
    175c:	89 b7       	in	r24, 0x39	; 57
3925
    175e:	8e 7f       	andi	r24, 0xFE	; 254
3926
    1760:	89 bf       	out	0x39, r24	; 57
3927
     CLR_INT0_FLAG;   // IntFlag Loeschen
3928
    1762:	8a b7       	in	r24, 0x3a	; 58
3929
    1764:	8f 7b       	andi	r24, 0xBF	; 191
3930
    1766:	8a bf       	out	0x3a, r24	; 58
3931
    1768:	80 c0       	rjmp	.+256    	; 0x186a <__vector_11+0x13e>
3932
     INT0_ENABLE;   // externen Interrupt wieder freigenben
3933
   }
3934
 }
3935
 else
3936
 {
3937
  if(IR_Zaehler > 1)
3938
    176a:	40 91 b8 00 	lds	r20, 0x00B8
3939
    176e:	42 30       	cpi	r20, 0x02	; 2
3940
    1770:	88 f0       	brcs	.+34     	; 0x1794 <__vector_11+0x68>
3941
	{
3942
	  Decodierung_Lauft = 1;
3943
    1772:	81 e0       	ldi	r24, 0x01	; 1
3944
    1774:	80 93 c9 01 	sts	0x01C9, r24
3945
	    {
3946
         CLR_INT0_FLAG;            // Interrupt Flag loeschen
3947
    1778:	8a b7       	in	r24, 0x3a	; 58
3948
    177a:	8f 7b       	andi	r24, 0xBF	; 191
3949
    177c:	8a bf       	out	0x3a, r24	; 58
3950
	     if(IR_PP) INT0_NEG_FLANKE; // naechste fallende  Flanke soll Int0 ausloesen
3951
    177e:	82 9b       	sbis	0x10, 2	; 16
3952
    1780:	03 c0       	rjmp	.+6      	; 0x1788 <__vector_11+0x5c>
3953
    1782:	85 b7       	in	r24, 0x35	; 53
3954
    1784:	8e 7f       	andi	r24, 0xFE	; 254
3955
    1786:	02 c0       	rjmp	.+4      	; 0x178c <__vector_11+0x60>
3956
	     else      INT0_POS_FLANKE;    // naechste steigende Flanke soll Int0 ausloesen
3957
    1788:	85 b7       	in	r24, 0x35	; 53
3958
    178a:	81 60       	ori	r24, 0x01	; 1
3959
    178c:	85 bf       	out	0x35, r24	; 53
3960
	     INT0_ENABLE;            // externen Int frei
3961
    178e:	8b b7       	in	r24, 0x3b	; 59
3962
    1790:	80 64       	ori	r24, 0x40	; 64
3963
    1792:	8b bf       	out	0x3b, r24	; 59
3964
	    }
3965
	}
3966
 
3967
  if(!IR_Zaehler)              // es beginnt eine neue Abtastung
3968
    1794:	44 23       	and	r20, r20
3969
    1796:	59 f4       	brne	.+22     	; 0x17ae <__vector_11+0x82>
3970
  {                           // es handelt sich um das 1. Sync-Bit
3971
    IR_Code_tmp=0;             // Merker löschen
3972
    1798:	10 92 b7 00 	sts	0x00B7, r1
3973
    179c:	10 92 b6 00 	sts	0x00B6, r1
3974
     Shift=0x8000; //;8192;                // Maske auf MSB
3975
    17a0:	80 e0       	ldi	r24, 0x00	; 0
3976
    17a2:	90 e8       	ldi	r25, 0x80	; 128
3977
    17a4:	90 93 b5 00 	sts	0x00B5, r25
3978
    17a8:	80 93 b4 00 	sts	0x00B4, r24
3979
    17ac:	14 c0       	rjmp	.+40     	; 0x17d6 <__vector_11+0xaa>
3980
  }
3981
  else
3982
  if(IR_PP==1)                // das empfangende Bit ist logisch High
3983
    17ae:	82 9b       	sbis	0x10, 2	; 16
3984
    17b0:	10 c0       	rjmp	.+32     	; 0x17d2 <__vector_11+0xa6>
3985
  {  if(IR_Zaehler>2)         // (IR_Zaehler ist gleich 1 beim 2. Sync-Bit)
3986
    17b2:	43 30       	cpi	r20, 0x03	; 3
3987
    17b4:	70 f0       	brcs	.+28     	; 0x17d2 <__vector_11+0xa6>
3988
      {                       // 2 --> Toggle-Bit (wird übersprungen)
3989
        IR_Code_tmp |= Shift; // entsprechendse Bit setzen
3990
    17b6:	80 91 b6 00 	lds	r24, 0x00B6
3991
    17ba:	90 91 b7 00 	lds	r25, 0x00B7
3992
    17be:	20 91 b4 00 	lds	r18, 0x00B4
3993
    17c2:	30 91 b5 00 	lds	r19, 0x00B5
3994
    17c6:	82 2b       	or	r24, r18
3995
    17c8:	93 2b       	or	r25, r19
3996
    17ca:	90 93 b7 00 	sts	0x00B7, r25
3997
    17ce:	80 93 b6 00 	sts	0x00B6, r24
3998
      }
3999
  }
4000
 
4001
  if ((IR_Zaehler < 2) && !(IR_PP==1)) // startbits überprüfen
4002
    17d2:	42 30       	cpi	r20, 0x02	; 2
4003
    17d4:	20 f4       	brcc	.+8      	; 0x17de <__vector_11+0xb2>
4004
    17d6:	82 99       	sbic	0x10, 2	; 16
4005
    17d8:	02 c0       	rjmp	.+4      	; 0x17de <__vector_11+0xb2>
4006
  {
4007
   IR_Zaehler = 0;
4008
    17da:	10 92 b8 00 	sts	0x00B8, r1
4009
   }
4010
 
4011
  Shift >>=1;                   // Shiftregister um 1 nach rechts schieben
4012
    17de:	80 91 b4 00 	lds	r24, 0x00B4
4013
    17e2:	90 91 b5 00 	lds	r25, 0x00B5
4014
    17e6:	96 95       	lsr	r25
4015
    17e8:	87 95       	ror	r24
4016
    17ea:	90 93 b5 00 	sts	0x00B5, r25
4017
    17ee:	80 93 b4 00 	sts	0x00B4, r24
4018
                               // (für das nächste empf. Bit
4019
  if (Shift == 128) Shift = 32; // Adresse ins HighByte, Kommando ins LowByte
4020
    17f2:	80 38       	cpi	r24, 0x80	; 128
4021
    17f4:	91 05       	cpc	r25, r1
4022
    17f6:	31 f4       	brne	.+12     	; 0x1804 <__vector_11+0xd8>
4023
    17f8:	80 e2       	ldi	r24, 0x20	; 32
4024
    17fa:	90 e0       	ldi	r25, 0x00	; 0
4025
    17fc:	90 93 b5 00 	sts	0x00B5, r25
4026
    1800:	80 93 b4 00 	sts	0x00B4, r24
4027
 
4028
  if(IR_Zaehler++==15)        // Das IR-Wort wurde vollstaendig abgetastet
4029
    1804:	80 91 b8 00 	lds	r24, 0x00B8
4030
    1808:	8f 5f       	subi	r24, 0xFF	; 255
4031
    180a:	80 93 b8 00 	sts	0x00B8, r24
4032
    180e:	80 31       	cpi	r24, 0x10	; 16
4033
    1810:	79 f5       	brne	.+94     	; 0x1870 <__vector_11+0x144>
4034
    {
4035
       CLR_INT0_FLAG;      // IntFlag Loeschen
4036
    1812:	8a b7       	in	r24, 0x3a	; 58
4037
    1814:	8f 7b       	andi	r24, 0xBF	; 191
4038
    1816:	8a bf       	out	0x3a, r24	; 58
4039
       INT0_NEG_FLANKE;      // fallende Flanke
4040
    1818:	85 b7       	in	r24, 0x35	; 53
4041
    181a:	8e 7f       	andi	r24, 0xFE	; 254
4042
    181c:	85 bf       	out	0x35, r24	; 53
4043
       IR_Zaehler = 0;
4044
    181e:	10 92 b8 00 	sts	0x00B8, r1
4045
       Decodierung_Lauft=0;
4046
    1822:	10 92 c9 01 	sts	0x01C9, r1
4047
  /*     if ((HIGH(IR_Code_tmp)==ALLOWED1)|| (HIGH(IR_Code_tmp)==ALLOWED2)||
4048
            (HIGH(IR_Code_tmp)==ALLOWED3)||(HIGH(IR_Code_tmp)==ALLOWED4)||
4049
           (HIGH(IR_Code_tmp)==ALLOWED5) )
4050
         if ((HIGH(IR_Code_tmp)< 10))*/
4051
    if ((HIGH(IR_Code_tmp)< 10 ) && (LOW(IR_Code_tmp)!=0x3F) )
4052
    1826:	80 91 b7 00 	lds	r24, 0x00B7
4053
    182a:	8a 30       	cpi	r24, 0x0A	; 10
4054
    182c:	d8 f4       	brcc	.+54     	; 0x1864 <__vector_11+0x138>
4055
    182e:	80 91 b6 00 	lds	r24, 0x00B6
4056
    1832:	8f 33       	cpi	r24, 0x3F	; 63
4057
    1834:	b9 f0       	breq	.+46     	; 0x1864 <__vector_11+0x138>
4058
        { // nur erlaubt Adressen werden akzepetiert
4059
         IR_Code=IR_Code_tmp;  // IR-Wort in die globale Variable schreiben
4060
    1836:	80 91 b6 00 	lds	r24, 0x00B6
4061
    183a:	90 91 b7 00 	lds	r25, 0x00B7
4062
    183e:	90 93 c8 01 	sts	0x01C8, r25
4063
    1842:	80 93 c7 01 	sts	0x01C7, r24
4064
         New_IR_Code = 1;        // Es ist ein neues Zeichen eingetragen worden
4065
    1846:	81 e0       	ldi	r24, 0x01	; 1
4066
    1848:	80 93 c6 01 	sts	0x01C6, r24
4067
         IRSperrCounter = 4; // weitere Kommandos für 200 * 1,3ms unterdrücken
4068
    184c:	84 e0       	ldi	r24, 0x04	; 4
4069
    184e:	80 93 b9 00 	sts	0x00B9, r24
4070
		 INT0_ENABLE;     // externen Interrupt wieder freigenben
4071
    1852:	8b b7       	in	r24, 0x3b	; 59
4072
    1854:	80 64       	ori	r24, 0x40	; 64
4073
    1856:	8b bf       	out	0x3b, r24	; 59
4074
         LoescheIrCodeTimer = 250;
4075
    1858:	8a ef       	ldi	r24, 0xFA	; 250
4076
    185a:	90 e0       	ldi	r25, 0x00	; 0
4077
    185c:	90 93 7d 00 	sts	0x007D, r25
4078
    1860:	80 93 7c 00 	sts	0x007C, r24
4079
       }
4080
     IRSperrCounter = 4; // weitere Kommandos für 200 * 1,3ms unterdrücken
4081
    1864:	84 e0       	ldi	r24, 0x04	; 4
4082
    1866:	80 93 b9 00 	sts	0x00B9, r24
4083
	 INT0_ENABLE;     // externen Interrupt wieder freigenben
4084
    186a:	8b b7       	in	r24, 0x3b	; 59
4085
    186c:	80 64       	ori	r24, 0x40	; 64
4086
    186e:	8b bf       	out	0x3b, r24	; 59
4087
    1870:	9f 91       	pop	r25
4088
    1872:	8f 91       	pop	r24
4089
    1874:	4f 91       	pop	r20
4090
    1876:	3f 91       	pop	r19
4091
    1878:	2f 91       	pop	r18
4092
    187a:	0f 90       	pop	r0
4093
    187c:	0f be       	out	0x3f, r0	; 63
4094
    187e:	0f 90       	pop	r0
4095
    1880:	1f 90       	pop	r1
4096
    1882:	18 95       	reti
4097
 
4098
00001884 <ADC_Init>:
4099
 
4100
// ---------------------------------------------------------------------------------------
4101
void ADC_Init(void)
4102
{
4103
  ADMUX = 0;
4104
    1884:	17 b8       	out	0x07, r1	; 7
4105
  ADCSRA = 0x86;
4106
    1886:	86 e8       	ldi	r24, 0x86	; 134
4107
    1888:	86 b9       	out	0x06, r24	; 6
4108
    188a:	08 95       	ret
4109
 
4110
0000188c <ReadADC>:
4111
}
4112
 
4113
// ---------------------------------------------------------------------------------------
4114
unsigned int ReadADC(unsigned char adc_input)
4115
{
4116
 ADMUX = adc_input;
4117
    188c:	87 b9       	out	0x07, r24	; 7
4118
 ADCSRA |= 0x40;
4119
    188e:	36 9a       	sbi	0x06, 6	; 6
4120
 //Delay_ms(10);
4121
 while ((ADCSRA & 0x10) == 0);
4122
    1890:	34 9b       	sbis	0x06, 4	; 6
4123
    1892:	fe cf       	rjmp	.-4      	; 0x1890 <ReadADC+0x4>
4124
 ADCSRA |= 0x10;
4125
    1894:	34 9a       	sbi	0x06, 4	; 6
4126
 return ADCW;   // read ad and calc. temp.
4127
    1896:	84 b1       	in	r24, 0x04	; 4
4128
    1898:	95 b1       	in	r25, 0x05	; 5
4129
    189a:	08 95       	ret
4130
 
4131
0000189c <GetAnalogWerte>:
4132
}
4133
 
4134
void GetAnalogWerte(void)
4135
{
4136
 AnalogWerte[0] = ReadADC(0);
4137
    189c:	80 e0       	ldi	r24, 0x00	; 0
4138
    189e:	0e 94 46 0c 	call	0x188c <ReadADC>
4139
    18a2:	90 93 cb 01 	sts	0x01CB, r25
4140
    18a6:	80 93 ca 01 	sts	0x01CA, r24
4141
 AnalogWerte[1] = ReadADC(1);
4142
    18aa:	81 e0       	ldi	r24, 0x01	; 1
4143
    18ac:	0e 94 46 0c 	call	0x188c <ReadADC>
4144
    18b0:	90 93 cd 01 	sts	0x01CD, r25
4145
    18b4:	80 93 cc 01 	sts	0x01CC, r24
4146
 AnalogWerte[2] = ReadADC(2);
4147
    18b8:	82 e0       	ldi	r24, 0x02	; 2
4148
    18ba:	0e 94 46 0c 	call	0x188c <ReadADC>
4149
    18be:	90 93 cf 01 	sts	0x01CF, r25
4150
    18c2:	80 93 ce 01 	sts	0x01CE, r24
4151
    18c6:	08 95       	ret
4152
 
4153
000018c8 <memchr>:
4154
    18c8:	fc 01       	movw	r30, r24
4155
    18ca:	41 50       	subi	r20, 0x01	; 1
4156
    18cc:	50 40       	sbci	r21, 0x00	; 0
4157
    18ce:	30 f0       	brcs	.+12     	; 0x18dc <memchr+0x14>
4158
    18d0:	01 90       	ld	r0, Z+
4159
    18d2:	06 16       	cp	r0, r22
4160
    18d4:	d1 f7       	brne	.-12     	; 0x18ca <memchr+0x2>
4161
    18d6:	31 97       	sbiw	r30, 0x01	; 1
4162
    18d8:	cf 01       	movw	r24, r30
4163
    18da:	08 95       	ret
4164
    18dc:	88 27       	eor	r24, r24
4165
    18de:	99 27       	eor	r25, r25
4166
    18e0:	08 95       	ret
4167
 
4168
000018e2 <fdevopen>:
4169
    18e2:	0f 93       	push	r16
4170
    18e4:	1f 93       	push	r17
4171
    18e6:	cf 93       	push	r28
4172
    18e8:	df 93       	push	r29
4173
    18ea:	8c 01       	movw	r16, r24
4174
    18ec:	eb 01       	movw	r28, r22
4175
    18ee:	00 97       	sbiw	r24, 0x00	; 0
4176
    18f0:	11 f4       	brne	.+4      	; 0x18f6 <fdevopen+0x14>
4177
    18f2:	67 2b       	or	r22, r23
4178
    18f4:	c1 f1       	breq	.+112    	; 0x1966 <fdevopen+0x84>
4179
    18f6:	6e e0       	ldi	r22, 0x0E	; 14
4180
    18f8:	70 e0       	ldi	r23, 0x00	; 0
4181
    18fa:	81 e0       	ldi	r24, 0x01	; 1
4182
    18fc:	90 e0       	ldi	r25, 0x00	; 0
4183
    18fe:	0e 94 b8 0c 	call	0x1970 <calloc>
4184
    1902:	fc 01       	movw	r30, r24
4185
    1904:	89 2b       	or	r24, r25
4186
    1906:	71 f1       	breq	.+92     	; 0x1964 <fdevopen+0x82>
4187
    1908:	80 e8       	ldi	r24, 0x80	; 128
4188
    190a:	83 83       	std	Z+3, r24	; 0x03
4189
    190c:	20 97       	sbiw	r28, 0x00	; 0
4190
    190e:	71 f0       	breq	.+28     	; 0x192c <fdevopen+0x4a>
4191
    1910:	d3 87       	std	Z+11, r29	; 0x0b
4192
    1912:	c2 87       	std	Z+10, r28	; 0x0a
4193
    1914:	81 e8       	ldi	r24, 0x81	; 129
4194
    1916:	83 83       	std	Z+3, r24	; 0x03
4195
    1918:	80 91 d0 01 	lds	r24, 0x01D0
4196
    191c:	90 91 d1 01 	lds	r25, 0x01D1
4197
    1920:	89 2b       	or	r24, r25
4198
    1922:	21 f4       	brne	.+8      	; 0x192c <fdevopen+0x4a>
4199
    1924:	f0 93 d1 01 	sts	0x01D1, r31
4200
    1928:	e0 93 d0 01 	sts	0x01D0, r30
4201
    192c:	01 15       	cp	r16, r1
4202
    192e:	11 05       	cpc	r17, r1
4203
    1930:	c9 f0       	breq	.+50     	; 0x1964 <fdevopen+0x82>
4204
    1932:	11 87       	std	Z+9, r17	; 0x09
4205
    1934:	00 87       	std	Z+8, r16	; 0x08
4206
    1936:	83 81       	ldd	r24, Z+3	; 0x03
4207
    1938:	82 60       	ori	r24, 0x02	; 2
4208
    193a:	83 83       	std	Z+3, r24	; 0x03
4209
    193c:	80 91 d2 01 	lds	r24, 0x01D2
4210
    1940:	90 91 d3 01 	lds	r25, 0x01D3
4211
    1944:	89 2b       	or	r24, r25
4212
    1946:	71 f4       	brne	.+28     	; 0x1964 <fdevopen+0x82>
4213
    1948:	f0 93 d3 01 	sts	0x01D3, r31
4214
    194c:	e0 93 d2 01 	sts	0x01D2, r30
4215
    1950:	80 91 d4 01 	lds	r24, 0x01D4
4216
    1954:	90 91 d5 01 	lds	r25, 0x01D5
4217
    1958:	89 2b       	or	r24, r25
4218
    195a:	21 f4       	brne	.+8      	; 0x1964 <fdevopen+0x82>
4219
    195c:	f0 93 d5 01 	sts	0x01D5, r31
4220
    1960:	e0 93 d4 01 	sts	0x01D4, r30
4221
    1964:	cf 01       	movw	r24, r30
4222
    1966:	df 91       	pop	r29
4223
    1968:	cf 91       	pop	r28
4224
    196a:	1f 91       	pop	r17
4225
    196c:	0f 91       	pop	r16
4226
    196e:	08 95       	ret
4227
 
4228
00001970 <calloc>:
4229
    1970:	0f 93       	push	r16
4230
    1972:	1f 93       	push	r17
4231
    1974:	cf 93       	push	r28
4232
    1976:	df 93       	push	r29
4233
    1978:	86 9f       	mul	r24, r22
4234
    197a:	80 01       	movw	r16, r0
4235
    197c:	87 9f       	mul	r24, r23
4236
    197e:	10 0d       	add	r17, r0
4237
    1980:	96 9f       	mul	r25, r22
4238
    1982:	10 0d       	add	r17, r0
4239
    1984:	11 24       	eor	r1, r1
4240
    1986:	c8 01       	movw	r24, r16
4241
    1988:	0e 94 d4 0c 	call	0x19a8 <malloc>
4242
    198c:	ec 01       	movw	r28, r24
4243
    198e:	00 97       	sbiw	r24, 0x00	; 0
4244
    1990:	29 f0       	breq	.+10     	; 0x199c <calloc+0x2c>
4245
    1992:	a8 01       	movw	r20, r16
4246
    1994:	60 e0       	ldi	r22, 0x00	; 0
4247
    1996:	70 e0       	ldi	r23, 0x00	; 0
4248
    1998:	0e 94 ca 0d 	call	0x1b94 <memset>
4249
    199c:	ce 01       	movw	r24, r28
4250
    199e:	df 91       	pop	r29
4251
    19a0:	cf 91       	pop	r28
4252
    19a2:	1f 91       	pop	r17
4253
    19a4:	0f 91       	pop	r16
4254
    19a6:	08 95       	ret
4255
 
4256
000019a8 <malloc>:
4257
    19a8:	cf 93       	push	r28
4258
    19aa:	df 93       	push	r29
4259
    19ac:	ac 01       	movw	r20, r24
4260
    19ae:	02 97       	sbiw	r24, 0x02	; 2
4261
    19b0:	10 f4       	brcc	.+4      	; 0x19b6 <malloc+0xe>
4262
    19b2:	42 e0       	ldi	r20, 0x02	; 2
4263
    19b4:	50 e0       	ldi	r21, 0x00	; 0
4264
    19b6:	20 e0       	ldi	r18, 0x00	; 0
4265
    19b8:	30 e0       	ldi	r19, 0x00	; 0
4266
    19ba:	a0 91 d8 01 	lds	r26, 0x01D8
4267
    19be:	b0 91 d9 01 	lds	r27, 0x01D9
4268
    19c2:	bd 01       	movw	r22, r26
4269
    19c4:	f9 01       	movw	r30, r18
4270
    19c6:	10 97       	sbiw	r26, 0x00	; 0
4271
    19c8:	09 f4       	brne	.+2      	; 0x19cc <malloc+0x24>
4272
    19ca:	4c c0       	rjmp	.+152    	; 0x1a64 <malloc+0xbc>
4273
    19cc:	8d 91       	ld	r24, X+
4274
    19ce:	9c 91       	ld	r25, X
4275
    19d0:	11 97       	sbiw	r26, 0x01	; 1
4276
    19d2:	84 17       	cp	r24, r20
4277
    19d4:	95 07       	cpc	r25, r21
4278
    19d6:	31 f1       	breq	.+76     	; 0x1a24 <malloc+0x7c>
4279
    19d8:	48 17       	cp	r20, r24
4280
    19da:	59 07       	cpc	r21, r25
4281
    19dc:	38 f4       	brcc	.+14     	; 0x19ec <malloc+0x44>
4282
    19de:	21 15       	cp	r18, r1
4283
    19e0:	31 05       	cpc	r19, r1
4284
    19e2:	19 f0       	breq	.+6      	; 0x19ea <malloc+0x42>
4285
    19e4:	82 17       	cp	r24, r18
4286
    19e6:	93 07       	cpc	r25, r19
4287
    19e8:	08 f4       	brcc	.+2      	; 0x19ec <malloc+0x44>
4288
    19ea:	9c 01       	movw	r18, r24
4289
    19ec:	fd 01       	movw	r30, r26
4290
    19ee:	a2 81       	ldd	r26, Z+2	; 0x02
4291
    19f0:	b3 81       	ldd	r27, Z+3	; 0x03
4292
    19f2:	10 97       	sbiw	r26, 0x00	; 0
4293
    19f4:	59 f7       	brne	.-42     	; 0x19cc <malloc+0x24>
4294
    19f6:	21 15       	cp	r18, r1
4295
    19f8:	31 05       	cpc	r19, r1
4296
    19fa:	a1 f1       	breq	.+104    	; 0x1a64 <malloc+0xbc>
4297
    19fc:	c9 01       	movw	r24, r18
4298
    19fe:	84 1b       	sub	r24, r20
4299
    1a00:	95 0b       	sbc	r25, r21
4300
    1a02:	04 97       	sbiw	r24, 0x04	; 4
4301
    1a04:	08 f4       	brcc	.+2      	; 0x1a08 <malloc+0x60>
4302
    1a06:	a9 01       	movw	r20, r18
4303
    1a08:	db 01       	movw	r26, r22
4304
    1a0a:	e0 e0       	ldi	r30, 0x00	; 0
4305
    1a0c:	f0 e0       	ldi	r31, 0x00	; 0
4306
    1a0e:	10 97       	sbiw	r26, 0x00	; 0
4307
    1a10:	49 f1       	breq	.+82     	; 0x1a64 <malloc+0xbc>
4308
    1a12:	8d 91       	ld	r24, X+
4309
    1a14:	9c 91       	ld	r25, X
4310
    1a16:	11 97       	sbiw	r26, 0x01	; 1
4311
    1a18:	82 17       	cp	r24, r18
4312
    1a1a:	93 07       	cpc	r25, r19
4313
    1a1c:	f9 f4       	brne	.+62     	; 0x1a5c <malloc+0xb4>
4314
    1a1e:	42 17       	cp	r20, r18
4315
    1a20:	53 07       	cpc	r21, r19
4316
    1a22:	79 f4       	brne	.+30     	; 0x1a42 <malloc+0x9a>
4317
    1a24:	ed 01       	movw	r28, r26
4318
    1a26:	8a 81       	ldd	r24, Y+2	; 0x02
4319
    1a28:	9b 81       	ldd	r25, Y+3	; 0x03
4320
    1a2a:	30 97       	sbiw	r30, 0x00	; 0
4321
    1a2c:	19 f0       	breq	.+6      	; 0x1a34 <malloc+0x8c>
4322
    1a2e:	93 83       	std	Z+3, r25	; 0x03
4323
    1a30:	82 83       	std	Z+2, r24	; 0x02
4324
    1a32:	04 c0       	rjmp	.+8      	; 0x1a3c <malloc+0x94>
4325
    1a34:	90 93 d9 01 	sts	0x01D9, r25
4326
    1a38:	80 93 d8 01 	sts	0x01D8, r24
4327
    1a3c:	cd 01       	movw	r24, r26
4328
    1a3e:	02 96       	adiw	r24, 0x02	; 2
4329
    1a40:	4a c0       	rjmp	.+148    	; 0x1ad6 <malloc+0x12e>
4330
    1a42:	24 1b       	sub	r18, r20
4331
    1a44:	35 0b       	sbc	r19, r21
4332
    1a46:	fd 01       	movw	r30, r26
4333
    1a48:	e2 0f       	add	r30, r18
4334
    1a4a:	f3 1f       	adc	r31, r19
4335
    1a4c:	41 93       	st	Z+, r20
4336
    1a4e:	51 93       	st	Z+, r21
4337
    1a50:	22 50       	subi	r18, 0x02	; 2
4338
    1a52:	30 40       	sbci	r19, 0x00	; 0
4339
    1a54:	2d 93       	st	X+, r18
4340
    1a56:	3c 93       	st	X, r19
4341
    1a58:	cf 01       	movw	r24, r30
4342
    1a5a:	3d c0       	rjmp	.+122    	; 0x1ad6 <malloc+0x12e>
4343
    1a5c:	fd 01       	movw	r30, r26
4344
    1a5e:	a2 81       	ldd	r26, Z+2	; 0x02
4345
    1a60:	b3 81       	ldd	r27, Z+3	; 0x03
4346
    1a62:	d5 cf       	rjmp	.-86     	; 0x1a0e <malloc+0x66>
4347
    1a64:	80 91 d6 01 	lds	r24, 0x01D6
4348
    1a68:	90 91 d7 01 	lds	r25, 0x01D7
4349
    1a6c:	89 2b       	or	r24, r25
4350
    1a6e:	41 f4       	brne	.+16     	; 0x1a80 <malloc+0xd8>
4351
    1a70:	80 91 80 00 	lds	r24, 0x0080
4352
    1a74:	90 91 81 00 	lds	r25, 0x0081
4353
    1a78:	90 93 d7 01 	sts	0x01D7, r25
4354
    1a7c:	80 93 d6 01 	sts	0x01D6, r24
4355
    1a80:	e0 91 7e 00 	lds	r30, 0x007E
4356
    1a84:	f0 91 7f 00 	lds	r31, 0x007F
4357
    1a88:	30 97       	sbiw	r30, 0x00	; 0
4358
    1a8a:	41 f4       	brne	.+16     	; 0x1a9c <malloc+0xf4>
4359
    1a8c:	ed b7       	in	r30, 0x3d	; 61
4360
    1a8e:	fe b7       	in	r31, 0x3e	; 62
4361
    1a90:	80 91 82 00 	lds	r24, 0x0082
4362
    1a94:	90 91 83 00 	lds	r25, 0x0083
4363
    1a98:	e8 1b       	sub	r30, r24
4364
    1a9a:	f9 0b       	sbc	r31, r25
4365
    1a9c:	a0 91 d6 01 	lds	r26, 0x01D6
4366
    1aa0:	b0 91 d7 01 	lds	r27, 0x01D7
4367
    1aa4:	9f 01       	movw	r18, r30
4368
    1aa6:	2a 1b       	sub	r18, r26
4369
    1aa8:	3b 0b       	sbc	r19, r27
4370
    1aaa:	24 17       	cp	r18, r20
4371
    1aac:	35 07       	cpc	r19, r21
4372
    1aae:	88 f0       	brcs	.+34     	; 0x1ad2 <malloc+0x12a>
4373
    1ab0:	ca 01       	movw	r24, r20
4374
    1ab2:	02 96       	adiw	r24, 0x02	; 2
4375
    1ab4:	28 17       	cp	r18, r24
4376
    1ab6:	39 07       	cpc	r19, r25
4377
    1ab8:	60 f0       	brcs	.+24     	; 0x1ad2 <malloc+0x12a>
4378
    1aba:	cd 01       	movw	r24, r26
4379
    1abc:	84 0f       	add	r24, r20
4380
    1abe:	95 1f       	adc	r25, r21
4381
    1ac0:	02 96       	adiw	r24, 0x02	; 2
4382
    1ac2:	90 93 d7 01 	sts	0x01D7, r25
4383
    1ac6:	80 93 d6 01 	sts	0x01D6, r24
4384
    1aca:	4d 93       	st	X+, r20
4385
    1acc:	5d 93       	st	X+, r21
4386
    1ace:	cd 01       	movw	r24, r26
4387
    1ad0:	02 c0       	rjmp	.+4      	; 0x1ad6 <malloc+0x12e>
4388
    1ad2:	80 e0       	ldi	r24, 0x00	; 0
4389
    1ad4:	90 e0       	ldi	r25, 0x00	; 0
4390
    1ad6:	df 91       	pop	r29
4391
    1ad8:	cf 91       	pop	r28
4392
    1ada:	08 95       	ret
4393
 
4394
00001adc <free>:
4395
    1adc:	cf 93       	push	r28
4396
    1ade:	df 93       	push	r29
4397
    1ae0:	00 97       	sbiw	r24, 0x00	; 0
4398
    1ae2:	09 f4       	brne	.+2      	; 0x1ae6 <free+0xa>
4399
    1ae4:	54 c0       	rjmp	.+168    	; 0x1b8e <free+0xb2>
4400
    1ae6:	dc 01       	movw	r26, r24
4401
    1ae8:	12 97       	sbiw	r26, 0x02	; 2
4402
    1aea:	ed 01       	movw	r28, r26
4403
    1aec:	1b 82       	std	Y+3, r1	; 0x03
4404
    1aee:	1a 82       	std	Y+2, r1	; 0x02
4405
    1af0:	80 91 d8 01 	lds	r24, 0x01D8
4406
    1af4:	90 91 d9 01 	lds	r25, 0x01D9
4407
    1af8:	00 97       	sbiw	r24, 0x00	; 0
4408
    1afa:	21 f1       	breq	.+72     	; 0x1b44 <free+0x68>
4409
    1afc:	fc 01       	movw	r30, r24
4410
    1afe:	40 e0       	ldi	r20, 0x00	; 0
4411
    1b00:	50 e0       	ldi	r21, 0x00	; 0
4412
    1b02:	ea 17       	cp	r30, r26
4413
    1b04:	fb 07       	cpc	r31, r27
4414
    1b06:	18 f1       	brcs	.+70     	; 0x1b4e <free+0x72>
4415
    1b08:	ed 01       	movw	r28, r26
4416
    1b0a:	fb 83       	std	Y+3, r31	; 0x03
4417
    1b0c:	ea 83       	std	Y+2, r30	; 0x02
4418
    1b0e:	2d 91       	ld	r18, X+
4419
    1b10:	3c 91       	ld	r19, X
4420
    1b12:	11 97       	sbiw	r26, 0x01	; 1
4421
    1b14:	c2 0f       	add	r28, r18
4422
    1b16:	d3 1f       	adc	r29, r19
4423
    1b18:	ce 01       	movw	r24, r28
4424
    1b1a:	02 96       	adiw	r24, 0x02	; 2
4425
    1b1c:	8e 17       	cp	r24, r30
4426
    1b1e:	9f 07       	cpc	r25, r31
4427
    1b20:	71 f4       	brne	.+28     	; 0x1b3e <free+0x62>
4428
    1b22:	8a 81       	ldd	r24, Y+2	; 0x02
4429
    1b24:	9b 81       	ldd	r25, Y+3	; 0x03
4430
    1b26:	28 0f       	add	r18, r24
4431
    1b28:	39 1f       	adc	r19, r25
4432
    1b2a:	2e 5f       	subi	r18, 0xFE	; 254
4433
    1b2c:	3f 4f       	sbci	r19, 0xFF	; 255
4434
    1b2e:	11 96       	adiw	r26, 0x01	; 1
4435
    1b30:	3c 93       	st	X, r19
4436
    1b32:	2e 93       	st	-X, r18
4437
    1b34:	82 81       	ldd	r24, Z+2	; 0x02
4438
    1b36:	93 81       	ldd	r25, Z+3	; 0x03
4439
    1b38:	fd 01       	movw	r30, r26
4440
    1b3a:	93 83       	std	Z+3, r25	; 0x03
4441
    1b3c:	82 83       	std	Z+2, r24	; 0x02
4442
    1b3e:	41 15       	cp	r20, r1
4443
    1b40:	51 05       	cpc	r21, r1
4444
    1b42:	59 f4       	brne	.+22     	; 0x1b5a <free+0x7e>
4445
    1b44:	b0 93 d9 01 	sts	0x01D9, r27
4446
    1b48:	a0 93 d8 01 	sts	0x01D8, r26
4447
    1b4c:	20 c0       	rjmp	.+64     	; 0x1b8e <free+0xb2>
4448
    1b4e:	af 01       	movw	r20, r30
4449
    1b50:	02 80       	ldd	r0, Z+2	; 0x02
4450
    1b52:	f3 81       	ldd	r31, Z+3	; 0x03
4451
    1b54:	e0 2d       	mov	r30, r0
4452
    1b56:	30 97       	sbiw	r30, 0x00	; 0
4453
    1b58:	a1 f6       	brne	.-88     	; 0x1b02 <free+0x26>
4454
    1b5a:	ea 01       	movw	r28, r20
4455
    1b5c:	bb 83       	std	Y+3, r27	; 0x03
4456
    1b5e:	aa 83       	std	Y+2, r26	; 0x02
4457
    1b60:	ca 01       	movw	r24, r20
4458
    1b62:	02 96       	adiw	r24, 0x02	; 2
4459
    1b64:	28 81       	ld	r18, Y
4460
    1b66:	39 81       	ldd	r19, Y+1	; 0x01
4461
    1b68:	82 0f       	add	r24, r18
4462
    1b6a:	93 1f       	adc	r25, r19
4463
    1b6c:	8a 17       	cp	r24, r26
4464
    1b6e:	9b 07       	cpc	r25, r27
4465
    1b70:	71 f4       	brne	.+28     	; 0x1b8e <free+0xb2>
4466
    1b72:	8d 91       	ld	r24, X+
4467
    1b74:	9c 91       	ld	r25, X
4468
    1b76:	11 97       	sbiw	r26, 0x01	; 1
4469
    1b78:	28 0f       	add	r18, r24
4470
    1b7a:	39 1f       	adc	r19, r25
4471
    1b7c:	2e 5f       	subi	r18, 0xFE	; 254
4472
    1b7e:	3f 4f       	sbci	r19, 0xFF	; 255
4473
    1b80:	39 83       	std	Y+1, r19	; 0x01
4474
    1b82:	28 83       	st	Y, r18
4475
    1b84:	fd 01       	movw	r30, r26
4476
    1b86:	82 81       	ldd	r24, Z+2	; 0x02
4477
    1b88:	93 81       	ldd	r25, Z+3	; 0x03
4478
    1b8a:	9b 83       	std	Y+3, r25	; 0x03
4479
    1b8c:	8a 83       	std	Y+2, r24	; 0x02
4480
    1b8e:	df 91       	pop	r29
4481
    1b90:	cf 91       	pop	r28
4482
    1b92:	08 95       	ret
4483
 
4484
00001b94 <memset>:
4485
    1b94:	dc 01       	movw	r26, r24
4486
    1b96:	40 ff       	sbrs	r20, 0
4487
    1b98:	03 c0       	rjmp	.+6      	; 0x1ba0 <memset+0xc>
4488
    1b9a:	01 c0       	rjmp	.+2      	; 0x1b9e <memset+0xa>
4489
    1b9c:	6d 93       	st	X+, r22
4490
    1b9e:	6d 93       	st	X+, r22
4491
    1ba0:	42 50       	subi	r20, 0x02	; 2
4492
    1ba2:	50 40       	sbci	r21, 0x00	; 0
4493
    1ba4:	d8 f7       	brcc	.-10     	; 0x1b9c <memset+0x8>
4494
    1ba6:	08 95       	ret
4495
 
4496
00001ba8 <__udivmodsi4>:
4497
    1ba8:	a1 e2       	ldi	r26, 0x21	; 33
4498
    1baa:	1a 2e       	mov	r1, r26
4499
    1bac:	aa 1b       	sub	r26, r26
4500
    1bae:	bb 1b       	sub	r27, r27
4501
    1bb0:	fd 01       	movw	r30, r26
4502
    1bb2:	0d c0       	rjmp	.+26     	; 0x1bce <__udivmodsi4_ep>
4503
 
4504
00001bb4 <__udivmodsi4_loop>:
4505
    1bb4:	aa 1f       	adc	r26, r26
4506
    1bb6:	bb 1f       	adc	r27, r27
4507
    1bb8:	ee 1f       	adc	r30, r30
4508
    1bba:	ff 1f       	adc	r31, r31
4509
    1bbc:	a2 17       	cp	r26, r18
4510
    1bbe:	b3 07       	cpc	r27, r19
4511
    1bc0:	e4 07       	cpc	r30, r20
4512
    1bc2:	f5 07       	cpc	r31, r21
4513
    1bc4:	20 f0       	brcs	.+8      	; 0x1bce <__udivmodsi4_ep>
4514
    1bc6:	a2 1b       	sub	r26, r18
4515
    1bc8:	b3 0b       	sbc	r27, r19
4516
    1bca:	e4 0b       	sbc	r30, r20
4517
    1bcc:	f5 0b       	sbc	r31, r21
4518
 
4519
00001bce <__udivmodsi4_ep>:
4520
    1bce:	66 1f       	adc	r22, r22
4521
    1bd0:	77 1f       	adc	r23, r23
4522
    1bd2:	88 1f       	adc	r24, r24
4523
    1bd4:	99 1f       	adc	r25, r25
4524
    1bd6:	1a 94       	dec	r1
4525
    1bd8:	69 f7       	brne	.-38     	; 0x1bb4 <__udivmodsi4_loop>
4526
    1bda:	60 95       	com	r22
4527
    1bdc:	70 95       	com	r23
4528
    1bde:	80 95       	com	r24
4529
    1be0:	90 95       	com	r25
4530
    1be2:	9b 01       	movw	r18, r22
4531
    1be4:	ac 01       	movw	r20, r24
4532
    1be6:	bd 01       	movw	r22, r26
4533
    1be8:	cf 01       	movw	r24, r30
4534
    1bea:	08 95       	ret