AVR und Umstieg von Assembler auf C Programmierung

**hegewald** · 08.02.2015, 17:47

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

**markusj** · 08.02.2015, 19:50

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

**Peter(TOO)** · 08.02.2015, 21:00

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)

**hegewald** · 09.02.2015, 07:48

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!

**oberallgeier** · 09.02.2015, 13:34

... 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)

 ============================================================ */

**askazo** · 09.02.2015, 14:13

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

**Besserwessi** · 09.02.2015, 16:20

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.

**oberallgeier** · 09.02.2015, 16:34

... 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.

**hegewald** · 12.02.2015, 08:51

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

**oberallgeier** · 12.02.2015, 09:49

Hallo Rolf!

... 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.