AVR und Umstieg von Assembler auf C Programmierung

Auweia....da hab ich mir in meinem betagten Alter ja was vorgenommen.
Seit Jahren programmiere ich die AVR-Familie hobbymäßig in Assembler.
Ortungspieper für Modell-Flächenmodelle, Kransteuerungen für Modelleisenbahn usw.
Was mir keine Ruhe lässt, wäre ein Roboter-Bausatz von der Fa. Reichelt.
Auf dem Sockel sitzt ein Atmega16.
Zur Zeit habe ich Studio4 von Atmel auf dem Nootebok.
Ein Kollege meinte heute, ich solle mich auf C konzentrieren und nicht C++.
Ein Anfängerbuch liegt hier vor mir.
Ich solle die Entwicklungsumgebung winAVR "Programmers Notepad 2
Version v.2.0.5.32" mit dem GNU - Compiler Vers. 3.4.1. aus dem Internet
runter laden.
Das Buch ist schon älter, wäre diese Version noch aktuell?
Mit meinen Studio4 kann ich mit C wahrscheinlich nichts anfangen, oder?
Innerlich bin ich gegen C etwas voreingenommen, wenn ich öfters mal das "IF" sehe.
Das erinnert mich so an die 70er Jahre, wo das GFA-Basic aktuell war.
Auf der anderen Seite ist es mit Assembler ein Zeilenaufwand, um eine Zeitschleife
von 5 Sekunden aufzubauen.

Grüße

Rolf

Hallo Rolf,

inzwischen ist WinAVR Geschichte, die Toolchain gibt es jetzt direkt von Atmel.
Die Version von Programmers Notepad ist ziemlich egal und AVR Studio 4 sollte auch mit der AVR Toolchain funktionieren.

mfG
Markus

Hallo Rolf,

Da gehe ich mit deinem Kollegen einig, C++ ist nicht wirklich ideal auf µC, das braucht schnell ml zu viel Code.

Was hast du gegen "if"?
"CMP" braucht man in Assembler auch jede Menge oder halt die ganzen "BRx".

Der C-Compiler hat übrigens eine Option welche dir ein Listing mit deinem C-Code erzeugt und zusätzlich das was er als Assembler daraus gestrickt hat ;-)
Wenn du einen Compiler mit guter Optimierung hast, wirst du dich als Assembler-Programmiere oft erst einmal etwas wundern; da kommt oft recht genialer Code dabei raus!

MfG Peter(TOO)

danke für Eure Antworten! Peter hat schon Recht, wenn ich in Assembler 20 Pseudobefehle brxx entdecke,
die unterschiedlich auf das Register "SREG" mit seinen Bits Carry, Zero usw. zugreifen.
Ich könnte ja mal ganz einfach mit meinen Studio4 beginnen, indem ich eine LED zum blinken bewege.
Das Buch ist von Günter Schmitt (5.Auflage Oldenburg). Programmieren in Assembler und C
Schaltungen und Anwendungen. Ist empfehlenswert.

Grüße

Rolf
halte Euch auf den Laufenden!

Zitat:

... in meinem betagten Alter ja was vorgenommen ... Zur Zeit habe ich Studio4 von Atmel auf dem Nootebok ...

Hallo Rolf,

du bist nicht der einzige Grauhaardackel oder UHU (Unter HUndert) hier im Forum. Ich habe übrigens vor ein paar Jahren mit Assembler auf AVRs angefangen (mit Blick auf alte Z80-Erfahrungen mit Assembler und FORTRAN), bin aber nach ein, zwei Jahren auf C übergegangen. Das ist bei mir immer noch eine Art sehr persönlicher Dialekt, sprich "Cäh" *ggg* aber es geht so.

Zu Studio4 kann ich nur sagen, dass ich nach Ausflügen in die Version AVRStudio5 und -6 wieder zu Version vier zurückkam (Version 4.18 Build 700 auf WIN7pro64). Gerade die Version 6 hat einen hübsch großen Overhead, der für richtig große Projekte bestimmt sinnvoll ist. Bei meinem aktuell größten Projekt, einem Roboter mit aktuell sieben (Controller-)Platinen, dazu MOtortreiberplatine etc., insgesamt vermutlich irgendwo bei dreissig- bis vierzigtausend Zeilen C, ist das für mich immer noch übersichtlich genug. Andererseits findet sich ein junger Programmierer aus meinem Umfeld (19J, Jugend-forscht-Team) prächtig wohl mit der 6er-Version auf nem Notebook für ein mega328er Projekt und an die dreitausend Codezeilen.

Nun mal ein kleiner Appetithappen. Peter hat schon davon geschrieben: "...C-Compiler ... Option ... C-Code erzeugt und zusätzlich ... Assembler ...".

Beispiel ist hier der so genannte *.lls-file aus einem meiner Projektchen als Teil des Compilats aus dem Studio4; vollständig und ohne Änderungen. Darin findest Du einiges an Assemblermnemonics und verteilt darin die originalen C-Sequenzen. Durch diese eingestreuten Quellzeilen ist eine perfekte Navigation von Deinem C-Code aus durch die maschinenlauffähige Programmversion möglich - siehe rot markierte Zeile "int main(void) //. " in beiden Beispielen.

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:

Code:

/* >> Stand ..\C3\tstu\tstu_mega32.c =============================================================================== = *** Aufgabenstellung : LCD auf Port B !!! des mega644/8 MHz int. Osc. ============================================================================== */ #define F_CPU 1e6 // - - - - - - - - - - - - - - - - #include <lcd_162_xta.c> // LCD-Lib ähnlich Tr-Tester, akt. PORTB, PB0..7 //#include <lcd_162_mini-no-wait.c> // LCD-Lib ähnl Tr-Tester, PORTB, PB0..7 // ============================================================================= = // ============================================================================= = // ============================================================================= = //### Programm pausieren lassen !! Der Pausenwert ist nur experimentell ! void wms(uint16_t ms) // { for(; ms>0; ms--) { uint16_t __c = 1600; __asm__ volatile ( "1: sbiw %0,1" "\n\t" "brne 1b" : "=w" (__c) : "0" (__c) ); } } // ============================================================================= = // ============================================================================= = // === HAUPTProgramm ========================================================== = // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - int main(void) // { // // - - - - - - - - - - - - - - - DDRA = 0b00000000; // Alles auf Eingang mit (0) PORTA = 0b11111111; // mit PullUp (1) // DDRB = 0b11111111; // Ausgänge mit (1) PORTB = 0b00000000; // // DDRC = 0b11000000; // PORTC = 0b00111111; // // DDRD = 0b00000000; // PORTD = 0b11111111; // // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - // ####>>>> Initialisierung/Anschlüsse von PORT B für LCD DEM 16x2 // data bit 4 PB0 0 A WS Pin1 | // data bit 5 PB1 1 A Pin2 | -- Der 10-polige Wannenstecker // data bit 6 PB2 2 A Pin3 | ist an die Belegung // data bit 7 SCK, PB3 3 A Pin4 | des Transitortester angepasst // RS line PB4 RS Pin5 | es kommen noch // ENABLE line MOSI, PB5 EN1 Pin6 | Pin 9 GND und // 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 ! // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - wms( 1000 ); // Wait lcd_init(); // wms( 1000 ); // Wait lcd_clear(); // Vor LCD-Ausgabe Display leeren // - - - - - - - - - - - - - - - wms( 1000 ); // Wait // - - - - - - - - - - - - - - - lcd_string("ABCDefghIJKLmnop"); // - - - - - - - - - - - - - - - //void wms(uint16_t ms) // Waitroutine wms( 1000 ); // Wait // - - - - - - - - - - - - - - - Line2(); // An den Anfang der 2. Zeile springen lcd_string(" So gehts ;-) "); // Zeile löschen // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - return 0; // } // // ===== Ende des Testabschnittes, er kann aus mehreren Abschnitten bestehen ==== // =============================================================================== /* Übersetzungskommentar (tstu) Programsize Datasize Build 20.1.2014 at 11:50:13 11224 bytes (34.3% Full) 1960 bytes (95.7% Full) ============================================================ */

Zitat:

Zitat von Peter(TOO)

Da gehe ich mit deinem Kollegen einig, C++ ist nicht wirklich ideal auf µC, das braucht schnell ml zu viel Code.

Das würde ich nicht grundsätzlich so sagen. Wenn man nicht gerade sehr zeitkritisch arbeiten oder stark mit dem Speicherplatz knausern muss, ist C++ eine enorme Erleichterung beim µC programmieren.
Viele Dinge sind ja im µC mehrfach vorhanden (ADCs, UARTs, SPIs etc.) - da bietet es sich wirklich an, für jedes Peripherie-Modul eine Klasse zu schreiben.
Die Wiederverwendbarkeit und Übersichtlichkeit des Codes wächst damit ungemein.

Gruß,
askazo

Auch wenn man später ggf. doch lieber C++ nutzt, schadet es nichts wenn man auch C kennt. Vieles ist da noch gleich und ordentlicher C Code ist meistens auch noch gültiger C++ Code.

Man sollte sich aber schon vom ASM Code lösen - den ASM Code schaut man sich eigentlich nur an, wenn man Zweifel hat (ob man C richtig verstanden hat), oder sehr zeitkritischen Code hat. Vieles geht in C schon einfacher als in ASM - vor allem Sachen mit Vergleichen und 16/32 Bit Zahlen.

Zitat:

... den ASM Code schaut man sich eigentlich nur an, wenn man Zweifel hat (ob man C richtig verstanden hat), oder sehr zeitkritischen Code ...

Genau. So prüfe ich z.B. bei einigen interrupt"verseuchten" Programmen die theoretisch mögliche Laufzeit wenn alle Interrupts nacheinander ablaufen
anhand der aus der *.lls-Datei gefundenen Summe aller ISR-Taktzeiten. Wenn ich dann unterhalb der kürzesten Interruptfrequenz (eigentlich unterhalb der kürzesten ISR-pause) bin, habe ich beste Chancen, dass das Programm sich nicht aufhängt. Wenn die gesamt mögliche Laufzeit aller ISR zu lang ist, konnte schon mal ein nested Interrupt einer (längeren) ISR helfen.

Hallo Leute,
mir raucht der Kopf! Hab ein kleines Programm aus dem Buch von Günter Schmitt
im Editor von Atmel Studio4 geschrieben.
Das Projekt "mega8test" im Studio 4 angelegt, aber noch nicht zum laufen gebracht.
Der Programmer AVR ISP mkII steht mir zur Verfügung.

// Projekt: mega8test 11.02.2015

// Datei: mega8test02.c

// PORTB Output PB7...PB0 = 8x LED
// PORTC Output PC5...PC0 = 6x LED
// PORTD Input PD7...PD0 = 8x Schalter

// Konfiguration: interner Oszillator 1MHz, ext. Reset-Signal

#include <avr/io.h>
#define Takt 1000000 // Systemtakt 1 MHz intern
void main (void) // Hauptfunktion, was ist das?

{ // Anfang der Hauptfunktion

DDRB = 0xFF; // PORTB = Output (Warum ; ?)
DDRC = 0xFF; // PORTC = Output

// Testschleife PC0 gemessen 70,7 KHz

while (1) // unendliche Schleife

{ // Anfang des Schleifenblocks

PORTB = PIND; // Eingabe PORTD nach Ausgabe PORTB

PORTC++; // Dualzähler auf PORTC um 1 erhöhen

} // Ende der while-Schleife
} // Ende der Hauptfuktion main

Frage hierzu:
// muß ich doch vor einem Kommentar setzen.

Aber was ist das denn..//#include <lcd_162_mini-no-wait.c> auch ein Kommentar?

Oder while (1) unendliche Schleife?? Und die (1)

Ich muß mir erst mal einige kurze einfache Programme anschaun, um die vielen Zeichen kennen zulernen.

Grüße

Rolf

Hallo Rolf!

Zitat:

... mir raucht der Kopf! ...
// muß ich doch vor einem Kommentar setzen.
Aber was ist das denn..//#include <lcd_162_mini-no-wait.c> auch ein Kommentar?

Rauchen ist beim Kopf zulässig, beim IC bedeutet es meist nix Gutes.

Doppel-Schrägstrich beginnt einen Kommentar bis zum Zeilenende - auch wenns im Prinzip Code ist.
/* (Schrägstrich Stern) beginnt einen Kommentar - der kann mehrzeilig sein und wird mit */ beendet.

A) Bitte schreibe das nächste Mal Deinen Code ins Codefenster. Das bekommst Du im Editor mit dem Button [#] - wenn Du den nicht siehst, dann drücke bitte auf "Erweiterte Ansicht". Im Editor sieht das dann so aus: [.CODE][./CODE] . Im Editor steht aber kein Leerzeichen nach der ersten Klammer. Und das Fenster ist dann erstmal leer. Nun die Schreibweise mit "nix" zwischen [ und C bzw. [ und /:

Code:

.

Dieses Beispiel ist tricky, funktioniert "normalerweise" nicht *gggg*.

B) Schau mal nach meinem Posting vom 09.02.2015, 14:34, bei "main Modul".
Bei Dir könnte das etwa so aussehen:

Code:

// Jetzt fängt der Code an mit Einschluss von Bibliotheken und // Definitionen #include <avr/io.h> #include <util/delay.h> // Hier ist eine "Wartefunktion" enthalten #define Takt 1000000 // Systemtakt 1 MHz intern // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void main (void) // Hauptfunktion, was ist das? // Das ist das eigentliche Hauptprogramm, // die Unterprogramme müssen vorher schon // geschrieben sein oder includierte werden // siehe dazu z.B. die o.g. Bibliotheken io.h etc // - - - - - - - - - - - - - - - - // Nun werden mal die Ports konfiguriert // Ports+Pins als Ein- (0) od. Ausgänge (1) konfigurieren, Pull Ups (1) aktivieren // - - - - - - - - - - - - - - - - DDRA = 0b00000000; // Alle Pins auf Eingang PORTA = 0b11100101; // Pinn 0, 2 sowie fünf bis sieben mit Pullup // DDRB = 0b11111111; // Alle Pins auf Ausgang PORTB = 0b00001111; // Pinn 0-3 high => LEDs an, 4-7 auf low => LEDs aus // DDRC = 0b00111111; // Pinn 0-5 auf Ausgang, 2 Eingänge PORTC = 0b11000000; // Ausgänge 0-4 auf low, 5 auf high, PullUp für 6+7 // DDRD = 0b00000000; // Alles Eingänge PORTD = 0b00001111; // Pullups einschalten (Schalter schaltet gegen GND) // // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Wir bewundern mal die LEDs - an oder aus _delay_ms( 1000); // ... ne ganze Sekunde // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - for ( uint8_t i=0; i< 100; i++) // LEDs 100 mal blinken lassen { // Schleifenanfang // - - - - - - - - - - - - PORTB |= (1<<PB6}; // LED auf PB6 einschalten PORTB &= ~(1<<PB1); // LED auf PB1 ausschalten _delay_ms( 500); // Nun warten wir ne halbe Sekunde (LED bewundern) PORTB &= ~(1<<PB6}; // LED auf PB6 ausschalten PORTB |= (1<<PB1); // LED auf PB1 einschalten _delay_ms( 500); // Nun warten wir ne halbe Sekunde (LED bewundern) } // Ende von for ( uint8_t i=0; i< 100; i++) // - - - - - - - - - - - - return 0; // Ende des Programms /* und zum Schluss noch ein mehrzeiliger Kommentar: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse ... */

Wenn ich ausreichend gefrühstückt habe müsstesollte das funktionieren. Ohne Tastendruck und nur hundert Blinkies.