AVR Embedded Tutorial - Entry Lazarus and Arduino/de

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.4.0t
svn 1.9.3

Unter Windows läuft die mit ähnlicher Konfiguration.

Erforderliche Tools:

FPCUPdelux:
https://github.com/newpascal/fpcupdeluxe/releases fpcupdelux zum erstellen des AVR-Crosscompilers.
Line: fpcupdeluxe-[OS].

Arduino-Software:
https://www.arduino.cc/en/Main/Software Arduino-Software. Wird für avrdude gebraucht.

Subvesion:
- Ubuntu/Debian: sudo apt-get install subversion
- Windows: Wird nicht gebraucht.

FPCUPdelux installieren:

Der 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:

Zuerst bei den ListBoxen links-oben FPC version und Lazarus version auf trunk gestellt werden. Anschliessend mit [Install/update FPC+Laz] die Lazarus Basis-Version bauen. Wen 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.

Es könnte sein, das die SVNs Schwierigkeiten machen, dann nicht verzagen und es an einem späterem Zeitpunkt nochmals probieren. ;-)

AVR-Crosscompiler bauen:

Für den AVR-Cross-Compiler muss man noch, den Button [Setup+] drücken, um ein 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

Anschliessend den Button [Install cross-compiler] drücken, somit wird der Cross-Compiler gebaut.

Wen alles fehlerfrei gelaufen ist, FPCUPdelux beenden.

Erstes Project

Lazarus vorbereiten

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

Project erstellen und vorbereiten

Über Datei/neu.../Einfaches Programm ein neues Project erstellen. Bei Projekt/Projekteinstellungen.../Konfiguration und Ziele folgendes einstellen.

Ziel-Betriebsystem (-T): Embedded
Ziel-CPU-Familie (-P): avr
Zielprozessor (-Cp): AVR5

Bei Project/Projecteinstellungen.../Debuggen: den Haken Debugger-Information für GDB erzeugen entfernen.
Bei Project/Projecteinstellungen.../Benutzerdefinierten Einstellungen/Benutzerdefinierten Einstellungen noch -WpATMEGA328P eintragen.
Bei Project/Projecteinstellungen.../Compiler-Kommandos/Nachher ausführen, die Hacken Kompilieren und Neu kompilieren entfernen.
Bei Befehl folgendes eintagen:
/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 den eigene Installationen angepasst werden.

Arduino vorbereiten

Den Arduino an einen freien USB-Port anschliessen.

USB frei geben (nur Linux)

Wen nicht schon geschehen, in einem Terminal noch den USB-Port frei geben.

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. Wen alles funktioniert hat, sollte die LED an Pin13 ca. alle 1 Sekunden blinken.

Start mit F9

Wen 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 Hacken bei Shift und Ctrl entfernen.

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

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

program Project1;
const
  CPU_Clock = 16000000; // Taktfrequenz Arduino, default 16MHz.
  Baud      = 9600;     // Baudrate
  UCSZ01    = 2;        // Gibt es nicht in der Unit Atmega328p.
  Teiler    = CPU_Clock div (2 * Baud) - 1;

  procedure UARTInit;
  begin
    UBRR0 := Teiler;

    UCSR0A := UCSR0A or (0 shl U2X0);
    UCSR0B := UCSR0B or (1 shl TXEN0) or (1 shl RXEN0);
    UCSR0C := UCSR0C or (1 shl UMSEL0) or (1 shl UCSZ01) or (1 shl UCSZ0);

    DDRD := DDRD or (1 shl 4);
  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
  until 1 = 2;
end.