Code:
tstu.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00000290 00000000 00000000 00000074 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000022 00800060 00000290 00000304 2**0
CONTENTS, ALLOC, LOAD, DATA
2 .debug_aranges 00000020 00000000 00000000 00000326 2**0
CONTENTS, READONLY, DEBUGGING
3 .debug_pubnames 000000ae 00000000 00000000 00000346 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_info 000007f8 00000000 00000000 000003f4 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_abbrev 0000017b 00000000 00000000 00000bec 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_line 000004bf 00000000 00000000 00000d67 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_frame 000000c0 00000000 00000000 00001228 2**2
CONTENTS, READONLY, DEBUGGING
8 .debug_str 0000014f 00000000 00000000 000012e8 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_loc 000002b7 00000000 00000000 00001437 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 2a 00 jmp 0x54 ; 0x54 <__ctors_end>
4: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
8: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
c: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
10: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
14: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
18: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
1c: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
20: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
24: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
28: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
2c: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
30: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
34: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
38: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
3c: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
40: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
44: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
48: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
4c: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
50: 0c 94 3f 00 jmp 0x7e ; 0x7e <__bad_interrupt>
00000054 <__ctors_end>:
54: 11 24 eor r1, r1
56: 1f be out 0x3f, r1 ; 63
58: cf e5 ldi r28, 0x5F ; 95
5a: d8 e0 ldi r29, 0x08 ; 8
5c: de bf out 0x3e, r29 ; 62
5e: cd bf out 0x3d, r28 ; 61
00000060 <__do_copy_data>:
60: 10 e0 ldi r17, 0x00 ; 0
62: a0 e6 ldi r26, 0x60 ; 96
64: b0 e0 ldi r27, 0x00 ; 0
66: e0 e9 ldi r30, 0x90 ; 144
68: f2 e0 ldi r31, 0x02 ; 2
6a: 02 c0 rjmp .+4 ; 0x70 <.do_copy_data_start>
0000006c <.do_copy_data_loop>:
6c: 05 90 lpm r0, Z+
6e: 0d 92 st X+, r0
00000070 <.do_copy_data_start>:
70: a2 38 cpi r26, 0x82 ; 130
72: b1 07 cpc r27, r17
74: d9 f7 brne .-10 ; 0x6c <.do_copy_data_loop>
76: 0e 94 ee 00 call 0x1dc ; 0x1dc <main>
7a: 0c 94 46 01 jmp 0x28c ; 0x28c <_exit>
0000007e <__bad_interrupt>:
7e: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
00000082 <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);
82: 98 b3 in r25, 0x18 ; 24
84: 28 2f mov r18, r24
86: 22 95 swap r18
88: 2f 70 andi r18, 0x0F ; 15
8a: 90 7f andi r25, 0xF0 ; 240
8c: 29 2b or r18, r25
8e: 28 bb out 0x18, r18 ; 24
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
90: 31 e0 ldi r19, 0x01 ; 1
92: 93 2f mov r25, r19
94: 9a 95 dec r25
96: f1 f7 brne .-4 ; 0x94 <lcd_send+0x12>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
98: c5 9a sbi 0x18, 5 ; 24
9a: 23 e0 ldi r18, 0x03 ; 3
9c: 92 2f mov r25, r18
9e: 9a 95 dec r25
a0: f1 f7 brne .-4 ; 0x9e <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);
a2: c5 98 cbi 0x18, 5 ; 24
// 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);
a4: 98 b3 in r25, 0x18 ; 24
a6: 8f 70 andi r24, 0x0F ; 15
a8: 90 7f andi r25, 0xF0 ; 240
aa: 98 2b or r25, r24
ac: 98 bb out 0x18, r25 ; 24
ae: 3a 95 dec r19
b0: f1 f7 brne .-4 ; 0xae <lcd_send+0x2c>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
b2: c5 9a sbi 0x18, 5 ; 24
b4: 2a 95 dec r18
b6: f1 f7 brne .-4 ; 0xb4 <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);
b8: c5 98 cbi 0x18, 5 ; 24
ba: 84 e1 ldi r24, 0x14 ; 20
bc: 8a 95 dec r24
be: f1 f7 brne .-4 ; 0xbc <lcd_send+0x3a>
// unteres Nibble setzen
LCD_PORT = (LCD_PORT & 0xF0) | (data & 0x0F);
_delay_us(5);
lcd_enable();
_delay_us(60);
LCD_PORT &= 0xF0;
c0: 88 b3 in r24, 0x18 ; 24
c2: 80 7f andi r24, 0xF0 ; 240
c4: 88 bb out 0x18, r24 ; 24
}
c6: 08 95 ret
000000c8 <lcd_command>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// sendet einen Befehl an das LCD
void lcd_command(unsigned char temp1)
{
LCD_PORT &= ~(1<<LCD_RS); // RS auf 0 setzen
c8: c4 98 cbi 0x18, 4 ; 24
lcd_send(temp1);
ca: 0e 94 41 00 call 0x82 ; 0x82 <lcd_send>
}
ce: 08 95 ret
000000d0 <lcd_data>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// sendet ein Datenbyte an das LCD
void lcd_data(unsigned char temp1)
{
LCD_PORT |= (1<<LCD_RS); // RS auf 1 setzen
d0: c4 9a sbi 0x18, 4 ; 24
lcd_send(temp1);
d2: 0e 94 41 00 call 0x82 ; 0x82 <lcd_send>
}
d6: 08 95 ret
000000d8 <lcd_enable>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
d8: c5 9a sbi 0x18, 5 ; 24
da: 83 e0 ldi r24, 0x03 ; 3
dc: 8a 95 dec r24
de: f1 f7 brne .-4 ; 0xdc <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);
e0: c5 98 cbi 0x18, 5 ; 24
}
e2: 08 95 ret
000000e4 <lcd_clear>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Sendet den Befehl zur Löschung des Displays
void lcd_clear(void)
{
lcd_command(CLEAR_DISPLAY);
e4: 81 e0 ldi r24, 0x01 ; 1
e6: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
ea: 82 ee ldi r24, 0xE2 ; 226
ec: 94 e0 ldi r25, 0x04 ; 4
ee: 01 97 sbiw r24, 0x01 ; 1
f0: f1 f7 brne .-4 ; 0xee <lcd_clear+0xa>
_delay_ms(5);
}
f2: 08 95 ret
000000f4 <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
f4: 87 b3 in r24, 0x17 ; 23
f6: 8f 63 ori r24, 0x3F ; 63
f8: 87 bb out 0x17, r24 ; 23
fa: 8c e4 ldi r24, 0x4C ; 76
fc: 9d e1 ldi r25, 0x1D ; 29
fe: 01 97 sbiw r24, 0x01 ; 1
100: f1 f7 brne .-4 ; 0xfe <lcd_init+0xa>
// muss 3mal hintereinander gesendet werden zur Initialisierung
_delay_ms(30);
LCD_PORT = (LCD_PORT & 0xF0 & ~(1<<LCD_RS)) | 0x03;
102: 88 b3 in r24, 0x18 ; 24
104: 80 7e andi r24, 0xE0 ; 224
106: 83 60 ori r24, 0x03 ; 3
108: 88 bb out 0x18, r24 ; 24
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
10a: c5 9a sbi 0x18, 5 ; 24
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
10c: 93 e0 ldi r25, 0x03 ; 3
10e: 89 2f mov r24, r25
110: 8a 95 dec r24
112: f1 f7 brne .-4 ; 0x110 <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);
114: c5 98 cbi 0x18, 5 ; 24
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
116: e2 ee ldi r30, 0xE2 ; 226
118: f4 e0 ldi r31, 0x04 ; 4
11a: 31 97 sbiw r30, 0x01 ; 1
11c: f1 f7 brne .-4 ; 0x11a <lcd_init+0x26>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
11e: c5 9a sbi 0x18, 5 ; 24
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
120: 89 2f mov r24, r25
122: 8a 95 dec r24
124: f1 f7 brne .-4 ; 0x122 <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);
126: c5 98 cbi 0x18, 5 ; 24
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
128: 2a ef ldi r18, 0xFA ; 250
12a: 30 e0 ldi r19, 0x00 ; 0
12c: f9 01 movw r30, r18
12e: 31 97 sbiw r30, 0x01 ; 1
130: f1 f7 brne .-4 ; 0x12e <lcd_init+0x3a>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
132: c5 9a sbi 0x18, 5 ; 24
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
134: 89 2f mov r24, r25
136: 8a 95 dec r24
138: f1 f7 brne .-4 ; 0x136 <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);
13a: c5 98 cbi 0x18, 5 ; 24
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
13c: f9 01 movw r30, r18
13e: 31 97 sbiw r30, 0x01 ; 1
140: f1 f7 brne .-4 ; 0x13e <lcd_init+0x4a>
lcd_enable();
_delay_ms(1);
lcd_enable();
_delay_ms(1);
LCD_PORT = (LCD_PORT & 0xF0 & ~(1<<LCD_RS)) | 0x02;
142: 88 b3 in r24, 0x18 ; 24
144: 80 7e andi r24, 0xE0 ; 224
146: 82 60 ori r24, 0x02 ; 2
148: 88 bb out 0x18, r24 ; 24
14a: f9 01 movw r30, r18
14c: 31 97 sbiw r30, 0x01 ; 1
14e: f1 f7 brne .-4 ; 0x14c <lcd_init+0x58>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// erzeugt den Enable-Puls
void lcd_enable(void)
{
LCD_PORT |= (1<<LCD_EN1);
150: c5 9a sbi 0x18, 5 ; 24
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
152: 9a 95 dec r25
154: f1 f7 brne .-4 ; 0x152 <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);
156: c5 98 cbi 0x18, 5 ; 24
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
158: c9 01 movw r24, r18
15a: 01 97 sbiw r24, 0x01 ; 1
15c: f1 f7 brne .-4 ; 0x15a <lcd_init+0x66>
_delay_ms(1);
lcd_enable();
_delay_ms(1);
// 4Bit / 2 Zeilen / 5x7
lcd_command(CMD_SetIFOptions | 0x08);
15e: 88 e2 ldi r24, 0x28 ; 40
160: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
// Display ein / Cursor aus / kein Blinken
lcd_command(CMD_SetDisplayAndCursor | 0x04);
164: 8c e0 ldi r24, 0x0C ; 12
166: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
// inkrement / kein Scrollen
lcd_command(CMD_SetEntryMode | 0x02);
16a: 86 e0 ldi r24, 0x06 ; 6
16c: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
lcd_clear();
170: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_clear>
}
174: 08 95 ret
00000176 <lcd_string>:
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schreibt einen String auf das LCD
void lcd_string(char *data)
{
176: cf 93 push r28
178: df 93 push r29
17a: ec 01 movw r28, r24
17c: 03 c0 rjmp .+6 ; 0x184 <lcd_string+0xe>
while(*data) {
lcd_data(*data);
17e: 0e 94 68 00 call 0xd0 ; 0xd0 <lcd_data>
data++;
182: 21 96 adiw r28, 0x01 ; 1
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Schreibt einen String auf das LCD
void lcd_string(char *data)
{
while(*data) {
184: 88 81 ld r24, Y
186: 88 23 and r24, r24
188: d1 f7 brne .-12 ; 0x17e <lcd_string+0x8>
lcd_data(*data);
data++;
}
}
18a: df 91 pop r29
18c: cf 91 pop r28
18e: 08 95 ret
00000190 <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)
{ //
190: 0f 93 push r16
192: 1f 93 push r17
194: cf 93 push r28
196: df 93 push r29
198: 8b 01 movw r16, r22
lcd_command(LCD_SET_CGADR|(code<<3)); // Startposition des Zeichens einstellen
19a: 88 0f add r24, r24
19c: 88 0f add r24, r24
19e: 88 0f add r24, r24
1a0: 80 64 ori r24, 0x40 ; 64
1a2: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
1a6: c0 e0 ldi r28, 0x00 ; 0
1a8: d0 e0 ldi r29, 0x00 ; 0
for (uint8_t i=0; i<8; i++) // Bitmuster übertragen
{ //
lcd_data(data[i]); //
1aa: f8 01 movw r30, r16
1ac: ec 0f add r30, r28
1ae: fd 1f adc r31, r29
1b0: 80 81 ld r24, Z
1b2: 0e 94 68 00 call 0xd0 ; 0xd0 <lcd_data>
1b6: 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
1b8: c8 30 cpi r28, 0x08 ; 8
1ba: d1 05 cpc r29, r1
1bc: b1 f7 brne .-20 ; 0x1aa <lcd_generatechar+0x1a>
{ //
lcd_data(data[i]); //
} //
} // Ende void lcd_generatechar(uint8_t code,
1be: df 91 pop r29
1c0: cf 91 pop r28
1c2: 1f 91 pop r17
1c4: 0f 91 pop r16
1c6: 08 95 ret
000001c8 <wms>:
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
1c8: 20 e4 ldi r18, 0x40 ; 64
1ca: 36 e0 ldi r19, 0x06 ; 6
1cc: 04 c0 rjmp .+8 ; 0x1d6 <wms+0xe>
1ce: f9 01 movw r30, r18
1d0: 31 97 sbiw r30, 0x01 ; 1
1d2: f1 f7 brne .-4 ; 0x1d0 <wms+0x8>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
1d4: 01 97 sbiw r24, 0x01 ; 1
1d6: 00 97 sbiw r24, 0x00 ; 0
1d8: d1 f7 brne .-12 ; 0x1ce <wms+0x6>
"brne 1b"
: "=w" (__c)
: "0" (__c)
);
}
}
1da: 08 95 ret
000001dc <main>:
// === HAUPTProgramm ========================================================== =
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int main(void) //
{ //
// - - - - - - - - - - - - - - -
DDRA = 0b00000000; // Alles auf Eingang mit (0)
1dc: 1a ba out 0x1a, r1 ; 26
PORTA = 0b11111111; // mit PullUp (1)
1de: 8f ef ldi r24, 0xFF ; 255
1e0: 8b bb out 0x1b, r24 ; 27
//
DDRB = 0b11111111; // Ausgänge mit (1)
1e2: 87 bb out 0x17, r24 ; 23
PORTB = 0b00000000; //
1e4: 18 ba out 0x18, r1 ; 24
//
DDRC = 0b11000000; //
1e6: 90 ec ldi r25, 0xC0 ; 192
1e8: 94 bb out 0x14, r25 ; 20
PORTC = 0b00111111; //
1ea: 9f e3 ldi r25, 0x3F ; 63
1ec: 95 bb out 0x15, r25 ; 21
//
DDRD = 0b00000000; //
1ee: 11 ba out 0x11, r1 ; 17
PORTD = 0b11111111; //
1f0: 82 bb out 0x12, r24 ; 18
1f2: 88 ee ldi r24, 0xE8 ; 232
1f4: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
1f6: 20 e4 ldi r18, 0x40 ; 64
1f8: 36 e0 ldi r19, 0x06 ; 6
1fa: f9 01 movw r30, r18
1fc: 31 97 sbiw r30, 0x01 ; 1
1fe: f1 f7 brne .-4 ; 0x1fc <main+0x20>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
200: 01 97 sbiw r24, 0x01 ; 1
202: d9 f7 brne .-10 ; 0x1fa <main+0x1e>
// NC (TasteC) SCK, PB7 NC Pin8 |___________________________
// GND Pin9
// Vcc Pn10 | Anmerkg: ENABLE line !
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
wms( 1000 ); // Wait
lcd_init(); //
204: 0e 94 7a 00 call 0xf4 ; 0xf4 <lcd_init>
208: 88 ee ldi r24, 0xE8 ; 232
20a: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
20c: 20 e4 ldi r18, 0x40 ; 64
20e: 36 e0 ldi r19, 0x06 ; 6
210: f9 01 movw r30, r18
212: 31 97 sbiw r30, 0x01 ; 1
214: f1 f7 brne .-4 ; 0x212 <main+0x36>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
216: 01 97 sbiw r24, 0x01 ; 1
218: d9 f7 brne .-10 ; 0x210 <main+0x34>
// Vcc Pn10 | Anmerkg: ENABLE line !
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
wms( 1000 ); // Wait
lcd_init(); //
wms( 1000 ); // Wait
lcd_clear(); // Vor LCD-Ausgabe Display leeren
21a: 0e 94 72 00 call 0xe4 ; 0xe4 <lcd_clear>
21e: 88 ee ldi r24, 0xE8 ; 232
220: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
222: 20 e4 ldi r18, 0x40 ; 64
224: 36 e0 ldi r19, 0x06 ; 6
226: f9 01 movw r30, r18
228: 31 97 sbiw r30, 0x01 ; 1
22a: f1 f7 brne .-4 ; 0x228 <main+0x4c>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
22c: 01 97 sbiw r24, 0x01 ; 1
22e: d9 f7 brne .-10 ; 0x226 <main+0x4a>
wms( 1000 ); // Wait
// - - - - - - - - - - - - - - -
//lcd_string("Grußoberallgeier");
//lcd_string("Gruss 18.9.19:23");
lcd_string("ABCDefghIJKLmnop");
230: 80 e6 ldi r24, 0x60 ; 96
232: 90 e0 ldi r25, 0x00 ; 0
234: 0e 94 bb 00 call 0x176 ; 0x176 <lcd_string>
238: 88 ee ldi r24, 0xE8 ; 232
23a: 93 e0 ldi r25, 0x03 ; 3
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
{
uint16_t __c = 1600;
__asm__ volatile (
23c: 20 e4 ldi r18, 0x40 ; 64
23e: 36 e0 ldi r19, 0x06 ; 6
240: f9 01 movw r30, r18
242: 31 97 sbiw r30, 0x01 ; 1
244: f1 f7 brne .-4 ; 0x242 <main+0x66>
// ============================================================================= =
// ============================================================================= =
//### Programm pausieren lassen !! Der Pausenwert ist nur experimentell !
void wms(uint16_t ms) //
{
for(; ms>0; ms--)
246: 01 97 sbiw r24, 0x01 ; 1
248: d9 f7 brne .-10 ; 0x240 <main+0x64>
// - - - - - - - - - - - - - - -
//void wms(uint16_t ms) // Waitroutine
wms( 1000 ); // Wait
// - - - - - - - - - - - - - - -
Line2(); // An den Anfang der 2. Zeile springen
24a: 80 ec ldi r24, 0xC0 ; 192
24c: 0e 94 64 00 call 0xc8 ; 0xc8 <lcd_command>
lcd_string(" So gehts ;-) "); // Zeile löschen
250: 81 e7 ldi r24, 0x71 ; 113
252: 90 e0 ldi r25, 0x00 ; 0
254: 0e 94 bb 00 call 0x176 ; 0x176 <lcd_string>
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
return 0; //
} //
258: 80 e0 ldi r24, 0x00 ; 0
25a: 90 e0 ldi r25, 0x00 ; 0
25c: 08 95 ret
0000025e <lcd_eep_string>:
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//String aus EEPROM laden und an LCD senden
void lcd_eep_string(const unsigned char *data)
{ //
25e: cf 93 push r28
260: df 93 push r29
262: ec 01 movw r28, r24
unsigned char c;
while(1) //
{ //
c = eeprom_read_byte(data); //
264: ce 01 movw r24, r28
266: 0e 94 3e 01 call 0x27c ; 0x27c <__eerd_byte_m32>
if(c==0) return; //
26a: 88 23 and r24, r24
26c: 21 f0 breq .+8 ; 0x276 <lcd_eep_string+0x18>
lcd_data(c); //
26e: 0e 94 68 00 call 0xd0 ; 0xd0 <lcd_data>
data++; //
272: 21 96 adiw r28, 0x01 ; 1
274: f7 cf rjmp .-18 ; 0x264 <lcd_eep_string+0x6>
}
} // Ende void lcd_eep_string(const
276: df 91 pop r29
278: cf 91 pop r28
27a: 08 95 ret
0000027c <__eerd_byte_m32>:
27c: e1 99 sbic 0x1c, 1 ; 28
27e: fe cf rjmp .-4 ; 0x27c <__eerd_byte_m32>
280: 9f bb out 0x1f, r25 ; 31
282: 8e bb out 0x1e, r24 ; 30
284: e0 9a sbi 0x1c, 0 ; 28
286: 99 27 eor r25, r25
288: 8d b3 in r24, 0x1d ; 29
28a: 08 95 ret
0000028c <_exit>:
28c: f8 94 cli
0000028e <__stop_program>:
28e: ff cf rjmp .-2 ; 0x28e <__stop_program>
Ach so - noch eben das Mainmodul dazu:
Lesezeichen