Motivation: Angeregt durch das Thema Weichensteuerung Schritt für Schritt möchte ich die dort von mir vorgestellte Anregung an dieser Stelle näher erläutern. Mit einer Suche im Forum nach "agmue anleitung" lassen sich meine Anleitungen vom Anfänger für den Anfänger wiederfinden.
Aufgabe: Die Weiche einer Modellbahn kann zwischen Gleis 1 und Gleis 2 wechseln. Ein auf Gleis 1 einfahrender Zug löst einen Reedkontakt aus, der Gleis 1 stromlos macht, gleichzeitig Gleis 2 mit Strom versorgt und die Weiche auf Gleis 2 umlegt.
Inhalt: Schrittkette und Zeitsteuerung in einer Klasse.
Als Anfänger schreibt man zuerst eine Lösung für eine Weiche, kopiert den Text mit etwas anderen Variablennamen. Bei vielen Weichen führt das schnell zu einem unübersichtlichen Bandwurmprogramm.
Abhilfe schaffen Variablenfelder und eine Funktion, die man mit dem Feldindex aufruft. Allerdings stehen zu einer Weiche gehörende Werte in unterschiedlichen Feldern.
Um zu einer Weiche gehörende Variablen verschiedenen Typs zusammenfassen zu können, kann man eine Struktur oder Klasse verwenden. Diese integriert dann auch noch die Funktion als Methode der Struktur oder Klasse.
Struktur und Klasse unterscheiden sich nur dadurch, daß eine Struktur am Anfang öffentlich (public) ist, während eine Klasse privat (private) ist. Ich verwende eine Klasse.
Der private Teil ist nur innerhalb einer Klasse zugänglich, der öffentliche auch von außerhalb. Meist sind nur Methoden öffentlich.
Erläuterungen zum Programm:
Um die ungeliebte Nutzung der millis() zu umgehen, nutzen wir die "Eieruhr" dieser Bibliothek.
#include <MobaTools.h>
Die Klasse fängt mit den für alle Methoden gültigen Objekten an, also Konstanten, Variablen und Instanzen anderer Bibliotheken. Diesen Objekten können Anfangswerte zugewiesen werden, wenn dies nicht im Konstruktor geschieht.
class Gleis {
private: // Die folgenden Objekte sind nur innerhalb der Klasse zugänglich. Am Anfang einer Klasse überflüssig.
enum {WARTEN, IMPULSAUS}; // Benennung und Numerierung der Schritte der Schrittkette
const byte reedPinA, reedPinG, stromRpin, weicheApin, weicheGpin; // A = abbiegend; G = gerade
byte schritt = WARTEN;
MoToTimer weichenImpuls;
const uint32_t weichenImpulsLaenge = 300; // in Millisekunden
Der Konstruktor steht im öffentlichen Teil und erzeugt Objekte. Innerhalb der runden Klammern müssen Reihenfolge und Typ genau der späteren Instanzierung entsprechen. Nach dem Doppelpunkt werden den vor dem Konstruktor festgelegten Objekten Werte zugewiesen, wobei nun die aus der Instanz kommenden Werte verwendet werden können. Dabei entspricht reedPinA(_reedPinA) der Zuweisung reedPinA=_reedPinA, wobei der grüne Teil dem Wert aus der Instanz entspricht und der blaue die interne Konstante oder Variable. Die geschweiften Klammern werden hier nicht genutzt und bleiben daher leer.
public:
Gleis(const byte _reedPinA, const byte _reedPinG, const byte _stromRpin, const byte _weicheApin, const byte _weicheGpin)
: reedPinA(_reedPinA), reedPinG(_reedPinG), stromRpin(_stromRpin), weicheApin(_weicheApin), weicheGpin(_weicheGpin)
{}
Jetzt springe ich zur Instanzierung. Der Feldvariablen gleis[] wird der Typ der vorher festgelegten Klasse Gleis zugewiesen. Ohne ausführliche Kommentare sieht das so aus:
Gleis gleis[] {
//reedPinA, reedPinG, stromRpin, weicheApin, weicheGpin
{ 12, 11, 8, 7, 6 }, // 1. Weiche
{ 10, 9, 5, 4, 3 } // 2. Weiche
};
Das Feld gleis[0] enthält im ersten Feldelement die Pins für die erste Weiche, gleis[1] enthält die Pins für die zweite Weiche. Beide Feldelemente werden als Instanzen der Klasse für die Methoden init() und stellen() in for-Schleifen aufgerufen. Die Instanzen arbeiten vollkommen unabhängig voneinander.
void setup() {
for (Gleis &g : gleis) g.init();
}
void loop() {
for (Gleis &g : gleis) g.stellen();
}
Eine Klasse kann auch Funktionen enthalten, die Methoden genannt werden.
Die Methode init() legt den Zustand der Pins fest. Bei LOW-aktiven Relais wird das Ausgangs-Bit erst auf HIGH gesetzt, bevor der Ausgang zum Ausgang wird. Damit wird ein kurzes Relaisschalten verhindert.
Die Methode stellen() liest die Reedkontakte und steuert die zwei Relais zur Weichenstellung an. Die Schrittkette (=endlicher Automat, =finite state machine) wartet auf ein Signal vom Reedkontakt, schaltet den Strom von einem Gleis zum anderen, steuert ein Gleisrelaus an, startet die "Eieruhr" und schaltet zum nächsten Schritt. Dieser schaltet nach Ablauf der "Eieruhr" die Weichenrelais ab.
Das Programm im Zusammenhang:
#include <MobaTools.h> // Kann mittels Arduino-IDE installiert werden.
class Gleis {
private: // Die folgenden Objekte sind nur innerhalb der Klasse zugänglich. Am Anfang einer Klasse überflüssig.
enum {WARTEN, IMPULSAUS}; // Benennung und Numerierung der Schritte der Schrittkette
const byte reedPinA, reedPinG, stromRpin, weicheApin, weicheGpin; // A = abbiegend; G = gerade
byte schritt = WARTEN;
MoToTimer weichenImpuls;
const uint32_t weichenImpulsLaenge = 300; // in Millisekunden
public:
Gleis(const byte _reedPinA, const byte _reedPinG, const byte _stromRpin, const byte _weicheApin, const byte _weicheGpin)
: reedPinA(_reedPinA), reedPinG(_reedPinG), stromRpin(_stromRpin), weicheApin(_weicheApin), weicheGpin(_weicheGpin)
{}
void init() {
pinMode(reedPinA, INPUT_PULLUP);
pinMode(reedPinG, INPUT_PULLUP);
digitalWrite(stromRpin, HIGH);
pinMode(stromRpin, OUTPUT);
digitalWrite(weicheApin, HIGH);
pinMode(weicheApin, OUTPUT);
digitalWrite(weicheGpin, HIGH);
pinMode(weicheGpin, OUTPUT);
}
void stellen() {
switch (schritt) {
case WARTEN:
if ( !digitalRead(reedPinA) ) {
digitalWrite(stromRpin, HIGH); // Gleis Abzweig stromlos, Gleis Gerade bestromt
digitalWrite(weicheGpin, LOW); // Weiche Impuls auf Gleis Gerade ein
weichenImpuls.setTime(weichenImpulsLaenge); // "Eieruhr" aufziehen
schritt = IMPULSAUS;
}
if ( !digitalRead(reedPinG) ) {
digitalWrite(stromRpin, LOW); // Gleis Gerade stromlos, Gleis Abzweig bestromt
digitalWrite(weicheApin, LOW); // Weiche Impuls auf Gleis Abzweig ein
weichenImpuls.setTime(weichenImpulsLaenge); // "Eieruhr" aufziehen
schritt = IMPULSAUS;
}
break;
case IMPULSAUS:
if ( weichenImpuls.expired() ) {
digitalWrite(weicheGpin, HIGH); // Weiche Impuls auf Gleis Gerade ein
digitalWrite(weicheApin, HIGH); // Weiche Impuls auf Gleis Abzweig ein
schritt = WARTEN;
}
break;
}
}
};
Gleis gleis[] {
//reedPinA, reedPinG, stromRpin, weicheApin, weicheGpin
{ // 1. Weiche
12, //Zugerkennung Reedkontakt Gleis 1
11, //Zugerkennung Reedkontakt Gleis 2
8, //Relais für Stromumschaltung Gleis 1 zu Gleis 2
7, //Relais für Weiche geradeaus
6 //Relais für Weiche abbiegend, LEDgelb
},
{ // 2. Weiche
10, //Zugerkennung Reedkontakt Gleis 3
9, //Zugerkennung Reedkontakt Gleis 4
5, //Relais für Stromumschaltung Gleis 3 zu Gleis 4
4, //Relais für Weiche geradeaus
3 //Relais für Weiche abbiegend
}
};
void setup() {
for (Gleis &g : gleis) g.init();
}
void loop() {
for (Gleis &g : gleis) g.stellen();
}
Wenn ich mit diesem Thema einen Anfänger zur Nutzung einer Struktur oder Klasse überreden könnte, würde ich mich freuen.