Code:
tstu.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 00000022 00800100 0000028c 00000300 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 0000028c 00000000 00000000 00000074 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .debug_aranges 00000020 00000000 00000000 00000322 2**0
CONTENTS, READONLY, DEBUGGING
3 .debug_pubnames 000000ae 00000000 00000000 00000342 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_info 00000798 00000000 00000000 000003f0 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_abbrev 0000017b 00000000 00000000 00000b88 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_line 0000049b 00000000 00000000 00000d03 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_frame 000000c0 00000000 00000000 000011a0 2**2
CONTENTS, READONLY, DEBUGGING
8 .debug_str 0000014f 00000000 00000000 00001260 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_loc 00000257 00000000 00000000 000013af 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 38 00 jmp 0x70 ; 0x70 <__ctors_end>
4: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
8: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
10: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
14: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
18: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
1c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
20: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
24: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
28: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
2c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
30: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
34: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
38: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
3c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
40: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
44: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
48: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
4c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
50: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
54: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
58: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
5c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
60: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
64: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
68: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
6c: 0c 94 4d 00 jmp 0x9a ; 0x9a <__bad_interrupt>
00000070 <__ctors_end>:
70: 11 24 eor r1, r1
72: 1f be out 0x3f, r1 ; 63
74: cf ef ldi r28, 0xFF ; 255
76: d0 e1 ldi r29, 0x10 ; 16
78: de bf out 0x3e, r29 ; 62
7a: cd bf out 0x3d, r28 ; 61
0000007c <__do_copy_data>:
7c: 11 e0 ldi r17, 0x01 ; 1
7e: a0 e0 ldi r26, 0x00 ; 0
80: b1 e0 ldi r27, 0x01 ; 1
82: ec e8 ldi r30, 0x8C ; 140
84: f2 e0 ldi r31, 0x02 ; 2
86: 02 c0 rjmp .+4 ; 0x8c <.do_copy_data_start>
00000088 <.do_copy_data_loop>:
88: 05 90 lpm r0, Z+
8a: 0d 92 st X+, r0
0000008c <.do_copy_data_start>:
8c: a2 32 cpi r26, 0x22 ; 34
8e: b1 07 cpc r27, r17
90: d9 f7 brne .-10 ; 0x88 <.do_copy_data_loop>
92: 0e 94 fc 00 call 0x1f8 ; 0x1f8 <main>
96: 0c 94 44 01 jmp 0x288 ; 0x288 <_exit>
0000009a <__bad_interrupt>:
9a: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
0000009e <lcd_send>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//Eigentliche LCD-Zugriffs-Funktion; 4-Bit-Modus
void lcd_send(unsigned char data) {
// oberes Nibble setzen
LCD_PORT = (LCD_PORT & 0xF0) | ((data >> 4) & 0x0F);
9e: 95 b1 in r25, 0x05 ; 5
a0: 28 2f mov r18, r24
a2: 22 95 swap r18
a4: 2f 70 andi r18, 0x0F ; 15
a6: 90 7f andi r25, 0xF0 ; 240
a8: 29 2b or r18, r25
aa: 25 b9 out 0x05, r18 ; 5
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
ac: 3d e0 ldi r19, 0x0D ; 13
ae: 93 2f mov r25, r19
b0: 9a 95 dec r25
b2: f1 f7 brne .-4 ; 0xb0 <lcd_send+0x12>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
b4: 2d 9a sbi 0x05, 5 ; 5
b6: 2a e1 ldi r18, 0x1A ; 26
b8: 92 2f mov r25, r18
ba: 9a 95 dec r25
bc: f1 f7 brne .-4 ; 0xba <lcd_send+0x1c>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
be: 2d 98 cbi 0x05, 5 ; 5
// oberes Nibble setzen
LCD_PORT = (LCD_PORT & 0xF0) | ((data >> 4) & 0x0F);
_delay_us(5);
lcd_enable();
// unteres Nibble setzen
LCD_PORT = (LCD_PORT & 0xF0) | (data & 0x0F);
c0: 95 b1 in r25, 0x05 ; 5
c2: 8f 70 andi r24, 0x0F ; 15
c4: 90 7f andi r25, 0xF0 ; 240
c6: 98 2b or r25, r24
c8: 95 b9 out 0x05, r25 ; 5
ca: 3a 95 dec r19
cc: f1 f7 brne .-4 ; 0xca <lcd_send+0x2c>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
ce: 2d 9a sbi 0x05, 5 ; 5
d0: 2a 95 dec r18
d2: f1 f7 brne .-4 ; 0xd0 <lcd_send+0x32>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
d4: 2d 98 cbi 0x05, 5 ; 5
d6: 80 ea ldi r24, 0xA0 ; 160
d8: 8a 95 dec r24
da: f1 f7 brne .-4 ; 0xd8 <lcd_send+0x3a>
// unteres Nibble setzen
LCD_PORT = (LCD_PORT & 0xF0) | (data & 0x0F);
_delay_us(5);
lcd_enable();
_delay_us(60);
LCD_PORT &= 0xF0;
dc: 85 b1 in r24, 0x05 ; 5
de: 80 7f andi r24, 0xF0 ; 240
e0: 85 b9 out 0x05, r24 ; 5
}
e2: 08 95 ret
000000e4 <lcd_command>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// sendet einen Befehl an das LCD
void lcd_command(unsigned char temp1)
{
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen
e4: 2c 98 cbi 0x05, 4 ; 5
lcd_send(temp1);
e6: 0e 94 4f 00 call 0x9e ; 0x9e <lcd_send>
}
ea: 08 95 ret
000000ec <lcd_data>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// sendet ein Datenbyte an das LCD
void lcd_data(unsigned char temp1)
{
LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen
ec: 2c 9a sbi 0x05, 4 ; 5
lcd_send(temp1);
ee: 0e 94 4f 00 call 0x9e ; 0x9e <lcd_send>
}
f2: 08 95 ret
000000f4 <lcd_enable>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
f4: 2d 9a sbi 0x05, 5 ; 5
f6: 8a e1 ldi r24, 0x1A ; 26
f8: 8a 95 dec r24
fa: f1 f7 brne .-4 ; 0xf8 <lcd_enable+0x4>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
fc: 2d 98 cbi 0x05, 5 ; 5
}
fe: 08 95 ret
00000100 <lcd_clear>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Sendet den Befehl zur Löschung des Displays
void lcd_clear(void)
{
lcd_command(CLEAR_DISPLAY);
100: 81 e0 ldi r24, 0x01 ; 1
102: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
106: 80 e1 ldi r24, 0x10 ; 16
108: 97 e2 ldi r25, 0x27 ; 39
10a: 01 97 sbiw r24, 0x01 ; 1
10c: f1 f7 brne .-4 ; 0x10a <lcd_clear+0xa>
_delay_ms(5);
}
10e: 08 95 ret
00000110 <lcd_init>:
// Initialisierung:
// Muss ganz am Anfang des Programms aufgerufen werden.
void lcd_init(void)
{
LCD_DDR = LCD_DDR | 0x0F | (1<<LCD_RS) | (1<<LCD_EN1); // Port auf Ausgang schalten
110: 84 b1 in r24, 0x04 ; 4
112: 8f 63 ori r24, 0x3F ; 63
114: 84 b9 out 0x04, r24 ; 4
116: 80 e6 ldi r24, 0x60 ; 96
118: 9a ee ldi r25, 0xEA ; 234
11a: 01 97 sbiw r24, 0x01 ; 1
11c: f1 f7 brne .-4 ; 0x11a <lcd_init+0xa>
// muss 3mal hintereinander gesendet werden zur Initialisierung
_delay_ms(30);
LCD_PORT = (LCD_PORT & 0xF0 & ~(1<<LCD_RS)) | 0x03;
11e: 85 b1 in r24, 0x05 ; 5
120: 80 7e andi r24, 0xE0 ; 224
122: 83 60 ori r24, 0x03 ; 3
124: 85 b9 out 0x05, r24 ; 5
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
126: 2d 9a sbi 0x05, 5 ; 5
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
128: 9a e1 ldi r25, 0x1A ; 26
12a: 89 2f mov r24, r25
12c: 8a 95 dec r24
12e: f1 f7 brne .-4 ; 0x12c <lcd_init+0x1c>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
130: 2d 98 cbi 0x05, 5 ; 5
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
132: e0 e1 ldi r30, 0x10 ; 16
134: f7 e2 ldi r31, 0x27 ; 39
136: 31 97 sbiw r30, 0x01 ; 1
138: f1 f7 brne .-4 ; 0x136 <lcd_init+0x26>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
13a: 2d 9a sbi 0x05, 5 ; 5
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
13c: 89 2f mov r24, r25
13e: 8a 95 dec r24
140: f1 f7 brne .-4 ; 0x13e <lcd_init+0x2e>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
142: 2d 98 cbi 0x05, 5 ; 5
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
144: 20 ed ldi r18, 0xD0 ; 208
146: 37 e0 ldi r19, 0x07 ; 7
148: f9 01 movw r30, r18
14a: 31 97 sbiw r30, 0x01 ; 1
14c: f1 f7 brne .-4 ; 0x14a <lcd_init+0x3a>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
14e: 2d 9a sbi 0x05, 5 ; 5
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
150: 89 2f mov r24, r25
152: 8a 95 dec r24
154: f1 f7 brne .-4 ; 0x152 <lcd_init+0x42>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
156: 2d 98 cbi 0x05, 5 ; 5
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
158: f9 01 movw r30, r18
15a: 31 97 sbiw r30, 0x01 ; 1
15c: f1 f7 brne .-4 ; 0x15a <lcd_init+0x4a>
lcd_enable();
_delay_ms(1);
lcd_enable();
_delay_ms(1);
LCD_PORT = (LCD_PORT & 0xF0 & ~(1<<LCD_RS)) | 0x02;
15e: 85 b1 in r24, 0x05 ; 5
160: 80 7e andi r24, 0xE0 ; 224
162: 82 60 ori r24, 0x02 ; 2
164: 85 b9 out 0x05, r24 ; 5
166: f9 01 movw r30, r18
168: 31 97 sbiw r30, 0x01 ; 1
16a: f1 f7 brne .-4 ; 0x168 <lcd_init+0x58>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
16c: 2d 9a sbi 0x05, 5 ; 5
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
16e: 9a 95 dec r25
170: f1 f7 brne .-4 ; 0x16e <lcd_init+0x5e>
_delay_us(10); // kurze Pause
// Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
// http://www.mikrocontroller.net/topic/80900
LCD_PORT &= ~(1<<LCD_EN1);
172: 2d 98 cbi 0x05, 5 ; 5
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
174: c9 01 movw r24, r18
176: 01 97 sbiw r24, 0x01 ; 1
178: f1 f7 brne .-4 ; 0x176 <lcd_init+0x66>
_delay_ms(1);
lcd_enable();
_delay_ms(1);
// 4Bit / 2 Zeilen / 5x7
lcd_command(CMD_SetIFOptions | 0x08);
17a: 88 e2 ldi r24, 0x28 ; 40
17c: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
// Display ein / Cursor aus / kein Blinken
lcd_command(CMD_SetDisplayAndCursor | 0x04);
180: 8c e0 ldi r24, 0x0C ; 12
182: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
// inkrement / kein Scrollen
lcd_command(CMD_SetEntryMode | 0x02);
186: 86 e0 ldi r24, 0x06 ; 6
188: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
lcd_clear();
18c: 0e 94 80 00 call 0x100 ; 0x100 <lcd_clear>
}
190: 08 95 ret
00000192 <lcd_string>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schreibt einen String auf das LCD
void lcd_string(char *data)
{
192: cf 93 push r28
194: df 93 push r29
196: ec 01 movw r28, r24
198: 03 c0 rjmp .+6 ; 0x1a0 <lcd_string+0xe>
while(*data) {
lcd_data(*data);
19a: 0e 94 76 00 call 0xec ; 0xec <lcd_data>
data++;
19e: 21 96 adiw r28, 0x01 ; 1
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schreibt einen String auf das LCD
void lcd_string(char *data)
{
while(*data) {
1a0: 88 81 ld r24, Y
1a2: 88 23 and r24, r24
1a4: d1 f7 brne .-12 ; 0x19a <lcd_string+0x8>
lcd_data(*data);
data++;
}
}
1a6: df 91 pop r29
1a8: cf 91 pop r28
1aa: 08 95 ret
000001ac <lcd_generatechar>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schreibt ein Zeichen in den Character Generator RAM
// Daten liegen direkt im RAM
void lcd_generatechar(uint8_t code, const uint8_t *data)
{ //
1ac: 0f 93 push r16
1ae: 1f 93 push r17
1b0: cf 93 push r28
1b2: df 93 push r29
1b4: 8b 01 movw r16, r22
lcd_command(LCD_SET_CGADR|(code<<3)); // Startposition des Zeichens einstellen
1b6: 88 0f add r24, r24
1b8: 88 0f add r24, r24
1ba: 88 0f add r24, r24
1bc: 80 64 ori r24, 0x40 ; 64
1be: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
1c2: c0 e0 ldi r28, 0x00 ; 0
1c4: d0 e0 ldi r29, 0x00 ; 0
for (uint8_t i=0; i<8; i++) // Bitmuster übertragen
{ //
lcd_data(data[i]); //
1c6: f8 01 movw r30, r16
1c8: ec 0f add r30, r28
1ca: fd 1f adc r31, r29
1cc: 80 81 ld r24, Z
1ce: 0e 94 76 00 call 0xec ; 0xec <lcd_data>
1d2: 21 96 adiw r28, 0x01 ; 1
// Schreibt ein Zeichen in den Character Generator RAM
// Daten liegen direkt im RAM
void lcd_generatechar(uint8_t code, const uint8_t *data)
{ //
lcd_command(LCD_SET_CGADR|(code<<3)); // Startposition des Zeichens einstellen
for (uint8_t i=0; i<8; i++) // Bitmuster übertragen
1d4: c8 30 cpi r28, 0x08 ; 8
1d6: d1 05 cpc r29, r1
1d8: b1 f7 brne .-20 ; 0x1c6 <lcd_generatechar+0x1a>
{ //
lcd_data(data[i]); //
} //
} // Ende void lcd_generatechar(uint8_t code,
1da: df 91 pop r29
1dc: cf 91 pop r28
1de: 1f 91 pop r17
1e0: 0f 91 pop r16
1e2: 08 95 ret
000001e4 <wms>:
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
1e4: 20 e4 ldi r18, 0x40 ; 64
1e6: 36 e0 ldi r19, 0x06 ; 6
1e8: 04 c0 rjmp .+8 ; 0x1f2 <wms+0xe>
1ea: f9 01 movw r30, r18
1ec: 31 97 sbiw r30, 0x01 ; 1
1ee: f1 f7 brne .-4 ; 0x1ec <wms+0x8>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
1f0: 01 97 sbiw r24, 0x01 ; 1
1f2: 00 97 sbiw r24, 0x00 ; 0
1f4: d1 f7 brne .-12 ; 0x1ea <wms+0x6>
"brne 1b"
: "=w" (__c)
: "0" (__c)
);
}
}
1f6: 08 95 ret
000001f8 <main>:
// === HAUPTProgramm ========================================================== =
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int main(void) //
{ //
// - - - - - - - - - - - - - - -
DDRA = 0b00000000; // Alles auf Eingang mit (0)
1f8: 11 b8 out 0x01, r1 ; 1
PORTA = 0b11111111; // mit PullUp (1)
1fa: 9f ef ldi r25, 0xFF ; 255
1fc: 92 b9 out 0x02, r25 ; 2
//
DDRB = 0b01111111; // Ausgänge mit (1)
1fe: 8f e7 ldi r24, 0x7F ; 127
200: 84 b9 out 0x04, r24 ; 4
PORTB = 0b10000000; //
202: 80 e8 ldi r24, 0x80 ; 128
204: 85 b9 out 0x05, r24 ; 5
//
DDRC = 0b11000000; //
206: 80 ec ldi r24, 0xC0 ; 192
208: 87 b9 out 0x07, r24 ; 7
PORTC = 0b00111111; //
20a: 8f e3 ldi r24, 0x3F ; 63
20c: 88 b9 out 0x08, r24 ; 8
//
DDRD = 0b00000000; //
20e: 1a b8 out 0x0a, r1 ; 10
PORTD = 0b11111111; //
210: 9b b9 out 0x0b, r25 ; 11
// R/W (offen) MISO, PB6 R/W Pin7 | Pin 10 Vcc dazu
// NC (TasteC) SCK, PB7 NC Pin8 |___________________________
// GND Pin9
// Vcc Pn10 | Anmerkg: ENABLE line !
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
lcd_init(); //
212: 0e 94 88 00 call 0x110 ; 0x110 <lcd_init>
lcd_clear(); // Vor LCD-Ausgabe Display leeren
216: 0e 94 80 00 call 0x100 ; 0x100 <lcd_clear>
21a: 88 ee ldi r24, 0xE8 ; 232
21c: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
21e: 20 e4 ldi r18, 0x40 ; 64
220: 36 e0 ldi r19, 0x06 ; 6
222: f9 01 movw r30, r18
224: 31 97 sbiw r30, 0x01 ; 1
226: f1 f7 brne .-4 ; 0x224 <main+0x2c>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
228: 01 97 sbiw r24, 0x01 ; 1
22a: d9 f7 brne .-10 ; 0x222 <main+0x2a>
lcd_clear(); // Vor LCD-Ausgabe Display leeren
// - - - - - - - - - - - - - - -
wms( 1000 ); // Wait
// - - - - - - - - - - - - - - -
lcd_string("Grußoberallgeier");
22c: 80 e0 ldi r24, 0x00 ; 0
22e: 91 e0 ldi r25, 0x01 ; 1
230: 0e 94 c9 00 call 0x192 ; 0x192 <lcd_string>
234: 88 ee ldi r24, 0xE8 ; 232
236: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
238: 20 e4 ldi r18, 0x40 ; 64
23a: 36 e0 ldi r19, 0x06 ; 6
23c: f9 01 movw r30, r18
23e: 31 97 sbiw r30, 0x01 ; 1
240: f1 f7 brne .-4 ; 0x23e <main+0x46>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
242: 01 97 sbiw r24, 0x01 ; 1
244: d9 f7 brne .-10 ; 0x23c <main+0x44>
// - - - - - - - - - - - - - - -
//void wms(uint16_t ms) // Waitroutine
wms( 1000 ); // Wait
// - - - - - - - - - - - - - - -
Line2(); // An den Anfang der 2. Zeile springen
246: 80 ec ldi r24, 0xC0 ; 192
248: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_command>
lcd_string(" So gehts ;-) "); // Zeile löschen
24c: 81 e1 ldi r24, 0x11 ; 17
24e: 91 e0 ldi r25, 0x01 ; 1
250: 0e 94 c9 00 call 0x192 ; 0x192 <lcd_string>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
return 0; //
} //
254: 80 e0 ldi r24, 0x00 ; 0
256: 90 e0 ldi r25, 0x00 ; 0
258: 08 95 ret
0000025a <lcd_eep_string>:
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//String aus EEPROM laden und an LCD senden
void lcd_eep_string(const unsigned char *data)
{ //
25a: cf 93 push r28
25c: df 93 push r29
25e: ec 01 movw r28, r24
unsigned char c;
while(1) //
{ //
c = eeprom_read_byte(data); //
260: ce 01 movw r24, r28
262: 0e 94 3c 01 call 0x278 ; 0x278 <__eerd_byte_m644>
if(c==0) return; //
266: 88 23 and r24, r24
268: 21 f0 breq .+8 ; 0x272 <lcd_eep_string+0x18>
lcd_data(c); //
26a: 0e 94 76 00 call 0xec ; 0xec <lcd_data>
data++; //
26e: 21 96 adiw r28, 0x01 ; 1
270: f7 cf rjmp .-18 ; 0x260 <lcd_eep_string+0x6>
}
} // Ende void lcd_eep_string(const
272: df 91 pop r29
274: cf 91 pop r28
276: 08 95 ret
00000278 <__eerd_byte_m644>:
278: f9 99 sbic 0x1f, 1 ; 31
27a: fe cf rjmp .-4 ; 0x278 <__eerd_byte_m644>
27c: 92 bd out 0x22, r25 ; 34
27e: 81 bd out 0x21, r24 ; 33
280: f8 9a sbi 0x1f, 0 ; 31
282: 99 27 eor r25, r25
284: 80 b5 in r24, 0x20 ; 32
286: 08 95 ret
00000288 <_exit>:
288: f8 94 cli
0000028a <__stop_program>:
28a: ff cf rjmp .-2 ; 0x28a <__stop_program>
Zitat von White_Fox
und einem Display mit KS0073 über einen PCF8574 und I2C. War jetzt nicht so schwer wie es sich hier in dem Thread darstellt ...
Berechtigungen
Zitieren
Lesezeichen