Arduino

Digitaltechnik und Elektronik der Modellbahn-Anlage.de

Arduino-Logo

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…

Arduino Uno

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

Wie man eine DCC Digitalzentrale von der Modellbahn an einen Arduino anschließt, erfährt man auf der Seite „DCC und Arduino“. Den Schaltplan gibt es nachstehend schonmal als Vorgeschmack.

DCC Anschluss am Mikrocontroller (z.B. Arduino)
DCC Anschluss am Mikrocontroller (z.B. Arduino)

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

Blinkenlight Shield mit 20 LEDs für Arduino
Blinkenlight Shield mit 20 LEDs für Arduino

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.

Bibliotheken für Arduino

Wir verwenden unterschiedliche Bibliotheken für den Arduino. Diese werden bei den jeweiligen Projekten markiert. Eine Sammlung ALLER Bibliotheken aus den Projekten werden wir aber auch hier aufbauen nud pflegen. Evtl. werden die angebotenen Bibliotheken über die Arduino IDE zum Update angeboten. Das Update der Bibliothek sollte man dann unbedingt ausführen!

DCC-Bibliothek

Diese Bibliothek hilft dabei, das DCC-Signal zu interpretieren und damit in einem Sketch besser umgehen zu können.

Soft PMW

Diese Bibliothek zum Thema Soft PMW dient dazu, dass jede LED (max 20 Stück) an jedem Ausgang gedimmt werden können, auch wenn der Ausgang kein PMW-Kanal ist.