-         
Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 15

Thema: AVR und Umstieg von Assembler auf C Programmierung

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    20.08.2011
    Beiträge
    61

    AVR und Umstieg von Assembler auf C Programmierung

    Anzeige

    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

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    20.08.2008
    Ort
    Karlsruhe
    Alter
    30
    Beiträge
    1.222
    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
    Tiny ASURO Library: Thread und sf.net Seite

  3. #3
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    27.08.2013
    Ort
    Region Basel
    Alter
    60
    Beiträge
    2.435
    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)
    Manchmal frage ich mich, wieso meine Generation Geräte ohne Simulation entwickeln konnte?

  4. #4
    Benutzer Stammmitglied
    Registriert seit
    20.08.2011
    Beiträge
    61
    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!

  5. #5
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.673
    ... 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)
    
     ============================================================ */
    Geändert von oberallgeier (09.02.2015 um 13:45 Uhr)
    Ciao sagt der JoeamBerg

  6. #6
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    02.11.2005
    Alter
    42
    Beiträge
    1.145
    Zitat Zitat von Peter(TOO) Beitrag anzeigen
    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
    - Das Leben ist zu kurz, um in C zu programmieren -

  7. #7
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    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.

  8. #8
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.673
    ... 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.
    Ciao sagt der JoeamBerg

  9. #9
    Benutzer Stammmitglied
    Registriert seit
    20.08.2011
    Beiträge
    61
    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

  10. #10
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.673
    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.
    Geändert von oberallgeier (12.02.2015 um 10:05 Uhr)
    Ciao sagt der JoeamBerg

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Umstieg von ATMEGA 16 auf 32 Bit AVR
    Von Nomis_Simon im Forum Microcontroller allgemeine Fragen/Andere Microcontroller
    Antworten: 2
    Letzter Beitrag: 09.12.2006, 17:42
  2. Umstieg von Bascom auf uisp + avr-gcc
    Von neurix im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 11.11.2005, 12:27
  3. Umstieg von Basic -> Assembler
    Von kaisobczak im Forum AVR Hardwarethemen
    Antworten: 10
    Letzter Beitrag: 14.04.2005, 08:17
  4. Umstieg von 8051 auf AVR
    Von postmann im Forum AVR Hardwarethemen
    Antworten: 2
    Letzter Beitrag: 16.02.2005, 08:11
  5. Umstieg von Basic auf C2
    Von Matthias im Forum C-Control II
    Antworten: 13
    Letzter Beitrag: 04.01.2004, 09:27

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •