AVR Embedded Tutorial - Entry Lazarus and Arduino/de

Einstieg Lazarus und Arduino

Lazarus mit AVR-Crosscompiler für Arduino Nano/Uno bauen

Das Tutorial wurde getestet mit:

• Linux Mint 18.2 64Bit
• Arduino-IDE 1.8.5
• FPCUPdelux V1.6.0h ( Sollte immer der neuste sein ! )
• svn 1.9.3
• FPC 3.1.1 ( erstellt mit FPCUPdelux )
• Lazarus 1.9 ( erstellt mit FPCUPdelux )

Unter Windows läuft dies mit ähnlicher Konfiguration.

Erforderliche Tools:

• FPCUPdelux:
  • https://github.com/newpascal/fpcupdeluxe/releases - fpcupdelux zum Erstellen des AVR-Crosscompilers. ( Download: fpcupdeluxe-[OS] ).
• Arduino-Software:
  • https://www.arduino.cc/en/Main/Software - Arduino-Software. Wird für avrdude gebraucht.
• Subversion:
  • Ubuntu/Debian:

    sudo apt-get install subversion
    

  • SuSE:

    sudo zypper install subversion
    

  • Windows: Wen nicht vorhanden, hier downloaden und installieren.
    • https://sourceforge.net/projects/win32svn/?source=typ_redirect
• Arduino Uno oder Nano, am besten mit einem ATmega328p.

FPCUPdelux installieren:

• Den Download von FPCUPdelux am besten in einen neuen leeren Ordner kopieren.
• Die kopierte Datei am besten im Datei-Manager mit einen Doppelklick starten. Unter Linux wird gefragt, ob die Datei ausführbar gemacht werden soll, dies mit Ja beantworten.

Dann sollte die FPCUPdelux-GUI starten.

Mit FPCUPdelux Lazarus bauen:

Trunk bauen:

• ListBoxen links-oben FPC version und Lazarus version auf trunk stellen.
• Mit [Install/update FPC+Laz] die Lazarus Basis-Trunk-Version bauen.

Wenn alles ohne Fehler durchläuft bekommt man die aktuelle Trunk von FPC/Lazarus, normale Desktopanwendungen kann man mit dieser schon erstellen. Und es sollte auf dem Dekstop ein ein Icon Lazarus_fpcupdelux entstanden sein.

  Hinweis: Es könnte sein, dass die SVNs Schwierigkeiten machen. Dann nicht verzagen und es zu einem späterem Zeitpunkt nochmals probieren. ;-
Einen nicht aktuellen FPCUPdelux kann auch Schwierigkeiten machen.

AVR-Crosscompiler bauen:

• Button [Setup+] drücken, um einen Dialog mit weiteren Optionen zu öffnen. Dort folgendes einstellen:
  • CPU: avr
  • OS: embedded
  • Cross Build Options Overide: -Cpavr5
  • Cross SubArch Overide: avr5

• Dialog mit [OK] beenden.
• Im Hauptfenster noch folgende CheckBoxen anwählen:
  • CPU: avr
  • OS: embedded
• Button [Install cross-compiler] drücken, somit wird der Cross-Compiler gebaut.

Wenn alles fehlerfrei gelaufen ist, FPCUPdelux beenden.

Erstes Projekt

Lazarus vorbereiten

• Lazarus mit dem neunen Desktop-Icon (Lazarus_fpcupdelux) starten.
• Tool/Options/General/Language Lazarus auf deutsch stellen.
• Mit [Ok] bestätigen und Lazarus neu starten.

Lazarus sollte jetzt deutsch sein.

Projekt erstellen und vorbereiten

• Datei/neu.../Einfaches Programm ein neues Project erstellen.
• Projekt/Projekteinstellungen.../Konfiguration und Ziele folgendes einstellen.
  • Ziel-Betriebsystem (-T): Embedded
  • Ziel-CPU-Familie (-P): avr
  • Zielprozessor (-Cp): AVR5

• Projekt/Projekteinstellungen.../Debuggen: den Haken Debugger-Information für GDB erzeugen entfernen.
  
• Projekt/Projekteinstellungen.../Benutzerdefinierten Einstellungen/Benutzerdefinierten Einstellungen noch -WpATMEGA328P eintragen.
  
• Projekt/Projekteinstellungen.../Compiler-Kommandos/Nachher ausführen
  • Haken Kompilieren und Neu kompilieren entfernen.
  • bei Befehl: eintragen:

    /home/tux/Programme/arduino-1.8.5/hardware/tools/avr/bin/avrdude -C/home/tux/Programme/arduino-1.8.5/hardware/tools/avr/etc/avrdude.conf -v -patmega328p -carduino -P/dev/ttyUSB0 -b57600 -D -Uflash:w:Project1.hex:i
    

  Hinweis: Die Pfade müssen noch an die eigenen Installationen angepasst werden.

Empfehlungen:

• Projekt/Projekteinstellungen.../Benutzerdefinierten Einstellungen/Benutzerdefinierten Einstellungen noch -al eintragen, dies erzeugt eine *.s-Datei, welche das Programm als ASM-Code enthält.
  
• Mit {$O-} am Programmanfang die Codeoptimierung ausschalten, ansonsten optimiert der Compiler Sachen, die er nicht sollte. Ich musste schon feststellen, das Port-Zugriffe falsch/nicht gemacht wurden.

Treiber installieren

Windows:

Für original Arduinos werden die Treiber mit der Arduino-IDE mitgeliefert. Bei Nachbauten ist es unter Umständen nötig, Treiber zu installieren. Meistens ist dies der 340-341-Driver. Ab Windows 10 sind auch diese Treiber dabei.

Linux:

Bei aktuellen Linux, zB. Mint/Ubuntu/Debian sind die Treiber schon installiert. (SusE müsste jemand testen)

Dafür muss man meistens noch die COM-Ports(USB-UART) für die User frei geben. Dies geschieht mit folgendem Befehl:

sudo adduser $USER dialout

Erstes Projekt starten

Dann sollte für ein erstes Blink-Programm (Source im nächsten Kapitel) nichts mehr im Wege stehen. Mit [Ctrl + Shift + F9] Programm kompilieren und hochladen. Wenn alles funktioniert hat, sollte die LED an Pin13 ca. alle 1 Sekunden blinken.

Start mit [F9]

Wenn man mit [F9] starten will, kommt immer eine Fehlermeldung. Diese kann man unterbinden. Bei Lazarus folgendes ändern:

• Werkzeuge/Einstellungen.../Tastaturbelegung/Befehle aus dem Menu 'Start'/Programm starten, auf Unbekannt stellen.
• Werkzeuge/Einstellungen.../Tastaturbelegung/Befehle aus dem Menu 'Start'/Start ohne Debugger, die Haken bei Shift und Ctrl entfernen.

Somit kann man ganz normal mit [F9] hochladen und starten. Man muss dabei aber bedenken, dass dann der Debugger auch unterbunden ist, wenn man dann mit Lazarus ein normales PC-Programm schreibt!

Verschiedene Sourcen für den Einstieg

Pin13 Blinker

program Project1;
const
  BP5 = 5;       // Pin 13 des Arduino
  dl  = 250000;  // Ungefähr 1/2 Sek.

  procedure delay(t: int32);
  var
    i: Int32;
  begin
    for i := 0 to t do begin
      asm
        nop;
      end;
    end;
  end;

begin
  DDRB := DDRB or (1 shl BP5);          // Port auf Output schalten
  repeat
    PORTB := PORTB or (1 shl BP5);      // Port auf High
    delay(dl);                          // warten

    PORTB := PORTB and not (1 shl BP5); // Port auf Low
    delay(dl);                          // warten
  until 1 = 2;                          // Endlosschleife
end.

Serielle Ein/Ausgabe

Für die serielle Ausgabe wird ein Terminal mit folgenden Einstellungen gebraucht:

• Baud Rate: 9600
• Bits: 8
• Stopbits: 1
• Parity: none

program Project1;
const
  CPU_Clock = 16000000; // Taktfrequenz Arduino, default 16MHz.
  Baud      = 9600;     // Baudrate
  Teiler    = CPU_Clock div (16 * Baud) - 1;

  procedure UARTInit;
  begin
    UBRR0 := Teiler;

    UCSR0A := (0 shl U2X0);
    UCSR0B := (1 shl TXEN0) or (1 shl RXEN0);
    UCSR0C := (%011 shl UCSZ0);
  end;

  procedure UARTSendChar(c: char);
  begin
    while UCSR0A and (1 shl UDRE0) = 0 do begin
    end;
    UDR0 := byte(c);
  end;

  function UARTReadChar: char;
  begin
    while UCSR0A and (1 shl RXC0) = 0 do begin
    end;
    Result := char(UDR0);
  end;

  procedure UARTSendString(s: ShortString);
  var
    i: integer;
  begin
    for i := 1 to length(s) do begin
      UARTSendChar(s[i]);
    end;
  end;

begin
  UARTInit;
  repeat
    if UARTReadChar = #32 then begin
      UARTSendString('Hello World !'#13#10);
    end;
  until 1 = 2;
end.

Einfacher Timer-Interrupt

Pro Sekunde wird der Pin13 auf HIGH geschalten.

program Project1;
const
  BP5 = 5; // Pin 13 des Arduino

  procedure sei; assembler;
  asm
    Sei
  end;

  procedure Timer2_Interrupt; alias: 'TIMER2_OVF_ISR'; interrupt; public;
  const
    zaehler: integer = 0;
    cl = 16000000 div 1024 div 256 div 2; // 16'000'000Hz / Clock / TCNT / 2 = 0,5Sek
  begin
    Inc(zaehler);
    if zaehler = cl then begin
      PORTB := PORTB or (1 shl BP5);
    end;
    if zaehler >= cl * 2 then begin
      PORTB := PORTB and not (1 shl BP5);
      zaehler := 0;
    end;
  end;

begin
  DDRB := DDRB or (1 shl BP5); // Pin 13 Output

  TCCR2A := %00;               // Normaler Timer
  TCCR2B := %111;              // Clock / 1024
  TIMSK2 := (1 shl TOIE2);     // enable timer2 overflow interrupt.
  sei();                       // Interrupts einschalten.

  repeat
    // mache Irgendwas
  until 1 = 2;
end.

Schlusswort

Für welche, die schon mit der Arduino-IDE programmiert haben, habe sicher festgestellt, das es dort sehr viele fertige Bibliotheken gibt. Man kann damit sehr einfach und schnell etwas coden, aber dafür ist dort sehr vieles verborgen.
Mit Lazarus muss man alles selbst machen und sich somit mit den Registern de AVRs auseinandersetzen. Dies hat aber auch einen grossen Vorteil, man weis, was man macht. Auch kann man so optimierteren Code erzeugen.

Danke

Das wichtigste zum Schluss:

• Ein grosses Dankeschön an die Entwickler von FPCUPdelux !

Ohne dieses Toll wäre AVR mit Lazarus immer noch eine Zangengeburt !

Siehe auch

• Übersichtseite AVR Embedded Tutorial/de