Arduino

Der Arduino findet bei uns auf der Modellbahn des öfteren seinen Einsatz. Nicht aber nur als „fertige Platine“, sondern viel häufiger als Prozessor (Mikrocontroller), der in einer eigenen Schaltung verbaut ist. Ein paar unserer Schaltungen stellen wir auf diesen Unterseiten vor…

Doch was ist Arduino?

Arduino ist eine aus Soft- und Hardware Plattform, d.h. man bekommt die Hardware als Komponente und die Software, mir der man diese Komponente programmieren kann. Dabei ist, sowohl die Hardware als auch die Software quelloffen, d.h. jeder kann an der Entwicklung teilnehmen bzw. jeder kann auch den Quellcode einsehen und verändern. So gibt es auch viele modifizierte Arduino-Hardware, die aber immer auf der Basis des „Ur-Arduinos“ hergestellt werden. Wenn man das nötige Know-how hat, kann man auch selber den Arduino umbauen. Viele Hersteller (oft aus China) bieten auch billigere Versionen des Arduinos an, was aber völlig legal ist, da, wie gesagt, nicht nur die Software, sondern auch die Hardware quelloffen ist. Dennoch muss man bei „billigen“ Arduinos darauf achten, dass er nach dem Standard gebaut wurde und die gleichen Ein- und Ausgänge hat sowie mit den „Shields“ (siehe unten) zusammen arbeitet.

Die Hardware des Arduino ist eigentlich ein recht einfaches Board. Es besitzt als Herzstück einen Mikrocontroller (ATmega328P), der auf analoge und digitale Ein- bzw. Ausgänge gelegt ist. Da das Board über Steckverbinder verfügt, kann man im Handumdrehen LEDs, Motoren, Relais, Schalter, … direkt an das Board anschließen. Natürlich macht aber oft der Umweg über ein Steckbrett sinn. Gerade aber beim Steckbrett kann man die gemeinsamme Masse (GND) sowie 5 Volt bzw. 3 Volt direkt vom Arduino Board auf das Steckbrett auskoppeln.

Die Software zur Programmierung basiert auf „Processing„. Sie soll auch Menschen den Einstig in die Welt der Mikrocontroller ermöglichen, die sonst nicht so versiert mit dem Thema sind. Daher wird das Arduino Projekt auch oft in Schulen verwendet oder aber auch in Universitäten. Denn die Programmiersprache ist an C bzw. C++ angelehnt und kann durchaus mächtig sein und steht anderen Sprachen in nichts nach. Der Einstieg und die ersten Erfolge stellen sich aber schnell ein und machen Lust auf Vertiefungen im Wissen der Programmierung. Durch das Inkludieren von Bibliotheken kann man komplexe Abläufe oft auch simplifizieren und muss lediglich Variablen befüllen, die dann in einem komplexen Skript in der Bibliothek berechnet werden.

Arduino Stand alone

Auf unserer Modellbahn-Anlage ist es das Ziel, den Arduino, genauer, den Mikrocontroller ATmega328P, als „Stand alone“ Mikrocontroller zu betreiben in einer eigenen Schaltung. Die Aufgaben werden dabei sein, Lichter, Motoren, … per DCC-Befehl zu steuern. Dadurch können die „Decoder“ der üblichen Modellbahn-Hersteller ergänzt werden, da es viele Programme, die man sich wünscht, nicht käuflich zu erwerben gibt. D.h., das „Arduino Board“ ist für uns legiglich eine Programmierumgebung und wird nicht unter die Modellbahn-Anlage geschraubt.

Arduino-Shields

Durch sogenannte „Shields“, die man auf den Arduino aufstecken kann, ist der Arduino durch verschiedene Funktionen erweiterbar, z.B. mit einem WLAN- oder Netzwerkanschluss, durch ein Motortreiber-Shield, durch ein LED-Shield, Relais-Shield, … Die unterschiedlichen Shields werden wir noch vorstellen, mit manchen ist es sogar möglich, eine DCC-Digitalzentrale zu bauen. Das Projekt DCC++ werden wir auf dieser Seite auch noch genauer anschauen und testen.

Aufbau eines Programms

Alle Programme haben eines gemeinsam: Sie starten, durchlaufen einen Setup-Teil, der Grundlegende Einstellungen festlegt und springt dann in eine Schleife, die sich unendlich lange wiederholt, zumindest so lange, bis dem Decoder bzw. Mikrocontroller der Modellbahnstrom genommen wird.

Der Teil, indem die Deklarationen getroffen werden, startet mit „void setup()“. Dieser Teil wird auch nur genau 1x durchlaufen, nämlich dann, wenn der Mikrocontroller zum ersten mal Strom bekommt. Dann werden alle Ein- und Ausgänge sowie globalen Variablen gesetzt.

Die „Dauerschleife“ startet mit „void loop()“. Diese wird niemals (für den Anfang lassen wir diese Bahauptung so stehen) verlassen. In ihr ist alles geregelt, was während eine Programmablaufs passieren soll, also ob z.B. auf den Druck einer Taste regaiert werden soll oder nicht und ob Ausgänge geschalten werden sollen oder nicht.

Nachstehend findet man ein Beispiel-Programm, das erklärt, wie man die Programme aufbaut: Die zwei // leiten dabei immer einen Kommentar ein, d.h. eine Beschreibung im Programm zur besseren Lesbarkeit oder zum besseren Verständnids. Die // sagen dem Compiler, dass hier nichts zu zun ist und die Codezeile zu ignorieren ist.

// ----------------------------------------------------------
  // Arduino - Programmaufbau


  // Deklarationsteil.
  // Hier werden die Variablen und Konstanten deklariert.
  // Hier können Bibliotheken eingebunden werden.

  void setup() {

    // Der erste Methodenblock heißt void setup()
    // Das Teil des Programms wird nach dem Start nur einmal ausgeführt.
    // Hier kann man die Kanäle (Pins) z.B. als In- oder Output bestimmen.

  }

  void loop() {

    // Der zweite Methodenblock heißt void loop()
    // Das Teil des Programms wird ständig wiederholt.
    // Hier wird normalerweise der eigentliche Programmcode untergebracht.

  }

Während dieser „Code“ noch recht einleuchtend klingt, wollen wir mal ein richtiges Beispiel ansehen, das auch noch sehr einfach ist, aber schon etwas schwieriger zu lesen. Aber wir erinnern uns immer an den Code von oben – die Struktur bleibt die Gleiche, nur die Synthax ändert sich nun:

  // Diode-Blinker


  const int LedPin = 13;
  // Die Konstante LedPin wird als Integer deklariert und mit Wert 13 belegt.

  void setup() {
    pinMode (LedPin, OUTPUT);
    // Pin Nr. 13 (LedPin=13) des Arduino-Boards wird als Ausgang definiert.
  }

  void loop() {
    digitalWrite(LedPin,HIGH); // LED wird eingeschaltet
    delay(1000); // Eine Sekunde warten
    digitalWrite(LedPin,LOW); // LED wird ausgeschaltet
    delay(1000); // Eine Sekunde warten
  }

  // ----------------------------------------------------------

Delay…

Wir haben in dem Code „delay(1000)“ kennengelernt. Dieser Code heißt, dass der Mikrocontroller an dieser Stelle genau 1000ms, also 1 Sekunde, nichts tut. Also nichts! Also WIRKLICH nichts. Gar nichts!

Das mag einem logisch erscheinen, die LED soll angehen, 1 Sekunde leuchten, dann ausgehen und 1 Sekunde ausbleiben. Für den Anfang ist das Programm völlig ok und tut genau das, was es soll. Aber…

Was ist, wenn der Decoder (Schaltung mit Mikrocontroller als „Gehirn“) nicht nur die LED blinken lassen soll, sondern auch noch darauf warten soll, dass ein DCC-Befehl empfangen werden soll?

Sagen wir, das Blinken der LEDs ist für einen Bahnübergang. Die Digitalzentrale soll das Blinken per DCC-Weichenadresse einschalten und auch wieder ausschalten. Man kann nun geneigt sein zu sagen, dass es doch ganz einfach ist, nach jedem „delay(1000)“ wird abgefragt, ob ein DCC-Befehl eingegangen ist. Das wird aber nicht zuverlässig funktionieren, denn der DCC-Befehl liegt gerade mal max. 200ms, eher weniger, an.

DCC am Arduino

Beiträge zum Thema Arduino:

• 
  Arduino Bootloader auf fabrikneuen ATMEGA328P-PU flashen
  von Team Modellbahn-Anlage.de
  1. November 2021
  Wie schon öfters geschrieben, steckt der Reiz in der Programmierung eines ATMEGA328P-PU auch darin, diesen Mikrocontroller mal aus dem Arduino auszubauen und „Stand alone“ in eine eigene Schaltung zu verbauen. Dann aber ist entweder auf dem Experimenten-Board kein Arduino mehr oder es ist keiner mehr für die eigene Platine da, denn alle ATMEGA328P-PU, die in…
  Weiterlesen
• Arduino Bootloader
  von Team Modellbahn-Anlage.de
  10. Oktober 2021
  Will man einen ATmega328P mit Hilfe der Arduino IDE programmieren, benötigt der ATmega328P einen so genannten Bootloader. Dieser ermöglicht, dass das Arduino Programm auf den Mikrocontroller übertragen und ausgeführt werden kann. Wir werden noch zeigen, wie man mit einem Arduino einen anderen als Bootloader-Generator verwenden kann. Will man aber schnell einen Bootloader über ein anderes…
  Weiterlesen
• 
  Miningen Light 2.0
  von Team Modellbahn-Anlage.de
  27. August 2021
  Der nächste Modellbahn-Decoder ist in der Produktion: Miningen-Light Version 2.0. Dieser digitale Decoder kann das DCC-Signal eines digitalen Modellbahntrafos verstehen und darauf reagieren. Die Anzahl der Adressen, auf die der Decoder reagiert, sind dabei fast unendlich. Der Decoder hat viele Möglichkeiten zum Schalten von LEDs, Motoren, Servos, WS2812B LEDs, Knöpfe mit LED-Rückmeldungslichter, … Der Decoder…
  Weiterlesen

Häufig verwendete Shields oder Bibliotheken

Schaltpläne

SPlan 7.0 Schalplan für Arduino Uno

Der Schaltplan dafür wird von uns noch erstellt und folgt noch…

SPlan 7.0 Schaltplan zu Arduino Mega

Der Schaltplan für das Programm „SPlan“ zum Download.

Detaillierter Schaltplan des Arduino als PDF-Datei

Der Schaltplan des Arduino ist auf der Seite https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf zu finden.

Arduino Uno Shields (die wir u.a. verwenden)

Vorlage für Shield-Platine erstellen (Sprint-Layout)

Mit DIESER Datei hat man die Möglichkeit, ein eigenes Shield zu entwerfen und zu ätzen. Die seitlichen Pins sind bereits im Plan eingetragen. Eine Seite, mit allen Shields wird demnächst erstellt…

Test-Shield mit 20 LEDs

Uneingeschränkt zum Testen mit LEDs können wir das „Blinkenlight Shield mit 20 LEDs für Arduino“ empfehlen, es ist noch hier und da käuflich zu erwerben. Zum Prototypen-Test ist es hervorragend geeignet und bietet viele Vorteile. Leider fehlt ein Knopf (Start einer Anwendung) – dazu werden wir demnächst ein eigenes Shield bauen – mit zusätzlichem DCC-Anschluss. Dafür bietet dieses Shield 20 LEDs und somit kann JEDER Ausgang des Arduino verwendet werden.