Ich möchte euch heute mal meine Art, Weichen mittels Servos zu stellen, ohne dabei teure Digitalkomponenten zu benötigen.
Bei der Steuerung Meines Bahnhofes Lödderitz wollte ich ein „analoges“ Stellpult haben, mit moderner LED Technik, und die Weichen einfach per Taster stellen. Dabei möchte ich eine echte Rückmeldung haben, und die Weichenstellung am Stellpult mit ausgeleuchtetem Fahrweg anzeigen. Das Stellpult soll dabei intuitiv bedienbar sein, auf Forumbahntreffen wird der Bahnhof ja auch von Anderen bedient.
Ich unterscheide dabei in ortsgestellte und ferngestellte Weichen. Die Ortsgestellten legt der Fahrzeugführer selbst um, in der Regel sind das die Weichen im Rangierbereich, diese werden dann direkt an der Modulseite per Taster gesteuert, eine Rückmeldung per LED ist hier nicht nötig, da der Rangierer direkt an der Weiche steht. Die ferngestellten Weichen werden über das Stellwerk (bei uns das Stellpult) gesteuert, das sind in der Regel die Weichen, welche für die Zugfahrten benutzt werden.
Folgende Anforderungen sollte meine Steuerung erfüllen:
- analog, keine Digitalkomponenten - Stellpult intuitiv bedienbar - Ansteuerung per Servo (Signale, Weichen, Gleissperren) - echte Rückmeldung der Weichenlage - demontierbar für vereinfachte Bastelarbeiten - individuell erweiterbar (Fahrstraßen, etc.)
Zur Stromversorgung des Arduino nutze ich ein 5V Netzteil. Dieses kann direkt in den 5V-Pin eingespeist werden. Wird eine höhere Spannung gewählt muss diese zwingend über den VIN-Pin eingespeist werden, da sie dort über den Bordeigenen Spannungsregler transfomiert wird. M.E. wird der Arduino mit den 5V geschont, der Spannungsregler läuft doch ganz schön heiß, auch ist er bei Kurzschlüssen nicht ganz so empfindlich. Ein weiterer Vorteil ist, dass ich nur einen Versorgungskreis brauche, und damit alle Verbraucher (Servo, Relais, LED etc.) versorgen kann. Für meinen Modulbahnhof Lödderitz nutze ich dabei ein 2A Netzteil.
Servo
Zur Ansteuerung eines Servos wird eine Steuerelektronik benötigt, da ein Servo über Impulse angesprochen wird. Dies kann dann über einen Digitaldecoder (z. B. ESU SwitchPilot o.Ä.) erfolgen. Da ich aber auf Digitalgedöns unter den Modulen verzichten wollte, (mir war der Aufwand einfach zu groß, eine zusätzliche Zentrale am Modul installieren zu müssen), entschied ich mich, es mal mit Mikrocontrolern zu probieren. Da ich bei Dominik schon diverse technische Spielereien mit Arduino gesehen hatte, wollte ich das einfach mal ausprobieren. Da es in der Arduino-Bibliothek bereits eine Servoimplementierung gibt, ist die Ansteuerung von Servos recht simpel. Der Servo muss an einen PWM-Pin (~, hier PIN 3) angeschlossen werden.
Bild 1: Schema Anschluß Servo an den Arduino
Polarisierung
Natürlich soll die Weiche auch polarisiert werden, dies geschieht mittels eines Relais.
Bild 2: Schema mit dem Relais zur Polarisierung (Hier an PIN 8)
Ansteurung per Taster
Mir ist wichtig, die Weichen mit nur einem Taster anzusteuern. Gerade bei ortsgestellten Weichen, ist es von Vorteil, wenn man sich beim Rangieren auf das Fahrzeug konzentrieren kann, und nicht noch überlegen muss, welchen Taster man drücken muss, um die Weiche umzulegen. Dadurch ist die Bedienung intuitiv, die Weiche legt auf Tastendruck um.
Bild 3: Schema Ansteuerung mit einem Taster (Hier an PIN 12)
Rückmeldung per LED
Bei weiter entfernten Weichen, die ferngestellt sind (im Stellwerk) ist es natürlich nötig, den Stellweg auszuleuchten, um eine Rückmeldung über die Fahrstraße und auch den erfolgreichen Umstellvorgang zu bekommen. Dazu sind dann pro Weiche zwei getrennte anzusteuernde LED (oder LED Gruppen, je nach Fasson) nötig.
Bild 4: Schema Rückmeldung per LED (hier an PIN 11 und 13)
Das zur Theorie. Im folgenden Beitrag schreibe ich zur Programmierung.
Dies ist meine selbst entwickelte Lösung, ich freue mich auf Hinweise und Anregungen, ich bin mir sicher, dass es noch Punkte gibt, die verbessert werden können.
1. Einstellung des Servos 2. Stellen des Servos über Taster 3. Weichenpolarisierung 4. Fahrwegausleuchung mit LED
Im folgenden möchte ich euch beschreiben, wie ich vorgegangen bin. Zu Beginn empfehle ich, sich ein Beginnerset zuzulegen, da sind viele Teile zum Testen enthalten. So was z.B. Arduino Starter Kit.
Im Testaufbau wird erstmal keine separate 5V- Spannungsquelle benötigt, da liefert der Arduino selber genug Strom, wenn er über USB an den PC oder per USB Steckernetzteil (vom Handy z.B.) gespeist wird.
1. Einstellung des Servos
Das ist dann der erste Aufbau, um mit der Programmierung zu beginnen:
Bild 5: Testaufbau zum Einstellen der Endlagen des Servos
Um eine Weiche per Servo zu stellen wird nicht die komplette Stellbewegung von 180° benötigt. Mit einem kleinen Testprogramm stelle ich den Servo erstmal auf 90° ein, und kann ihn dann unter der Weiche so positionieren, dass die Weichenzunge mittig zwischen den Backenschienen liegt. Sollte sie bereits anliegen, ist das auch nicht schlimm, es werden ca. 40° vom Stellweg benötigt, und das ist dann in beide Richtungen gegeben.
Auch kann ich mit diesem Testprogramm die Richtungen bestimmen, in welche Richtung ich den Servo dann drehen lassen muss, um die jeweilige Endlage (Gerade bzw. Abzweig) zu erreichen.
int Servo_Gerade = 80; // Endlage des Servos wenn Weiche auf Gerade int Servo_Mitte = 90; // Mittellage, ideal zum Einbau int Servo_Abzweig = 100; // Endlage des Servos wenn Weiche auf Abzweig int Pin_Servo = 3; // Servo an PIN 3
// Anlegen eines Servo-Objektes
Servo servo;
void setup()
{ servo.attach(Pin_Servo); // Aktivieren des PINS servo.write(Servo_Gerade); // Servo fährt zur Position Servo_Gerade (hier 80) delay(1000); servo.write(Servo_Abzweig); // Servo fährt zur Position Servo_Abzweig (hier 100) delay(1000); servo.write(Servo_Mitte); // Servo fährt in die Mittelstellung 90 delay(1000); servo.detach(); // Deaktivieren des Servos (verhindert das Nachregeln) }
void loop() {
}
Nun ist der Servo fertig zum Einbau, und die Werte für die Endlagen können eingestellt werden, indem man die Werte der Variablen entsprechend verändert. Wichtig ist für den Anfang nur, die Werte nicht zu groß zu wählen, um nicht die Stellstange der Weiche zu zerstören.
Noch ein kleines Beispielvideo:
Der Servo dreht nun immer die einzelnen Schritte ab, sobald der Arduino neu gestartet wird.
Stellen des Servos über Taster
Nun soll die Weiche ja auch betätigt werden. Ich wollte das möglichst einfach über einen Taster machen, die Weiche wird umgestellt, sobald dieser gedrückt wird.
Hardwaretechnisch ist es relativ einfach, softwaretechnisch war es dann schon etwas kniffliger.
Bild 6: Anschluß des Tasters an den Arduino
Der nächste Schritt ist relativ groß, und hat mir am Anfang viel Kopfzerbrechen bereitet.
Zunächst poste ich mal den fertigen Code, anschließend gehe ich auf die wichtigen Punkte ein.
int Weiche_Gerade = 60; // Endlage des Servos wenn Weiche auf Gerade int Weiche_Mitte = 90; // Mittellage int Weiche_Abzweig = 120; // Endlage des Servos wenn Weiche auf Abzweig int Weiche_soll = Weiche_Mitte; // Speichervariable für die aktuelle Lage int Stellzeit_Servo_Weiche = 30; // Stellgeschwindigkeit Weiche int Pin_Servo = 3; // Servo an PIN 3
// für den Taster
int Pin_Taster = 12; // Taster an PIN 4 unsigned long entprellzeit = 20; // Zeitintervall der Tasterabfrage unsigned long tasterzeit = 0; // Speichervariable für die Zeit int taster_gedrueckt = 0; // Speichervariable für den Tasterzustand
// Anlegen eines Servo-Objektes
Servo servo;
void setup() {
// Initialisieren der Weiche auf Grundstellung
servo.attach(Pin_Servo); // Aktivierung ServoPin servo.write(Weiche_Mitte); // Servo fährt in Mittelstellung delay(500); // Warten das der Servo die Stellung erreicht hat
// Servo fährt in Stellgeschwindigkeit in die Grundlage (in der Regel Gerade
while (Weiche_Gerade < Weiche_soll) { Weiche_soll--; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Gerade) { servo.detach(); // Deaktivierung Servo } } }
void loop() {
// Definition des PINS
pinMode(Pin_Taster, INPUT);
// Entprellen des Tasters
if (digitalRead(Pin_Taster) == HIGH) { tasterzeit = millis(); // Speichern der aktuellen Zeit taster_gedrueckt = 1; }
// Abfrage der Weichenlage, Servo fährt dann in die jeweils Andere
if ((millis() - tasterzeit > entprellzeit) && taster_gedrueckt == 1 && Weiche_soll == Weiche_Gerade) { while (Weiche_Abzweig > Weiche_soll) { servo.attach(Pin_Servo); Weiche_soll++; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Abzweig) // Abfrage ob Endlage erreicht { servo.detach(); // Deaktivierung Servo taster_gedrueckt = 0; // Zurückstellen des Tasterstatus } } }
}
Wie man sieht, dann doch schon ein ganz schöner Trumm.
Um die einzelnen Schritte erklären zu können, kurz was zum Aufbau des Prorgammes (in der Programmiersprache C im übrigen).
Meine Programme bestehen zu Beginn aus drei Teilen:
1. Variablendeklaration (mit Initialisierung) 2. setup (): Dieser Teil wird immer nur zu Beginn des Programmes genau einmal abgearbeitet 3. loop () : das ist dann die Endlosschleife, die solange durchläuft, bis der Arduino stromlos oder kaputt is
zu 1. Bibliotheken, Variablen, Initialisierung
Hier werden die Variablen deklariert (mit einem Namen und Typ versehen) und nach Möglichkeit gleich initialisiert (es wird ein Wert zugewiesen)
int Weiche_Gerade = 60; // Endlage des Servos wenn Weiche auf Gerade int Weiche_Mitte = 90; // Mittellage int Weiche_Abzweig = 120; // Endlage des Servos wenn Weiche auf Abzweig int Weiche_soll = Weiche_Mitte; // Speichervariable für die aktuelle Lage int Stellzeit_Servo_Weiche = 30; // Stellgeschwindigkeit Weichenservo int Pin_Servo = 3; // Servo an PIN 3
// für den Taster
int Pin_Taster = 12; // Taster an PIN 4 unsigned long entprellzeit = 20; // Zeitintervall der Tasterabfrage unsigned long tasterzeit = 0; // Speichervariable für die Zeit int taster_gedrueckt = 0; // Speichervariable für den Tasterzustand
// Anlegen eines Servo-Objektes
Servo servo;
zu 2. setup()
Hier habe ich das reingepackt, was nur einmal gebraucht wird, im Falle der Weichenstellung die Herstellung der Grundstellung der Weiche, später dann auch der richtigen Polarisierung und der Ausleuchtung mit den richtigen LEDs.
pinMode(Pin_Taster, INPUT); // Definition des PINS
servo.attach(Pin_Servo); // Aktivierung ServoPin servo.write(Weiche_Mitte); // Servo fährt in Mittelstellung delay(500); // Warten das der Servo die Stellung erreicht hat
// Servo fährt in Stellgeschwindigkeit in die Grundlage (in der Regel Gerade
while (Weiche_Gerade < Weiche_soll) { Weiche_soll--; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Gerade) { servo.detach(); // Deaktivierung Servo } } }
zu 3. loop() der Rest
Das Hauptprogramm, dass einfach gesagt permanent die Taster abfragt, und dann die entsprechenden Befehle ausführt, wie hier gewollt das Umlegen der Weiche, später auch das Schalten des Polarisierungsrelais und das An- und Ausschalten der entsprechenden LEDs. Natürlich ist da viel mehr möglich, siehe dazu auch bei Dominiks Anschluß Dobuger
Dieser Teil ist natürlich der umfangreichste und fehleranfälligste. Hier möchte ich noch ein paar Zeilen schreiben.
Taster Entprellen
Anfangs habe ich mich gewundert, warum die gewollte Aktion manchmal erst beim dritten oder gar vierten Tastendruck ausgeführt wird. Ich habe dann recherchiert und bin auf den Auslöser gestoßen. Man muss wissen, dass ein Taster eine gewisse Zeit (ca. 10 ms) braucht, um seinen Zustand von LOW (kein Strom, offen) auf HIGH (+5V, geschlossen) ändert. Daher dieser Code, den ich mir aus diversen Foren und Turorien abgeleitet habe. Im Prinzip wird der Taster dann nicht in jedem Durchlauf des Loops ausgewertet, sondern nur im Abstand der Entprellzeit, hier (unsigned long entprellzeit = 20;) Wählt man den Wert höher, müsste man den Taster entsprechend länger gedrückt halten, um eine saubere Aktion zu erhalten.
1 2 3 4 5 6 7 8 9 10 11 12 13
// Entprellen des Tasters
if (digitalRead(Pin_Taster) == HIGH) { tasterzeit = millis(); // Speichern der aktuellen Zeit taster_gedrueckt = 1; }
// Abfrage der Weichenlage, Servo fährt dann in die jeweils Andere
while (Weiche_Gerade < Weiche_soll) { servo.attach(Pin_Servo); Weiche_soll--; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Gerade) { servo.detach(); // Deaktivierung Servo digitalWrite(Pin_Relais, HIGH); // Anschalten des Ralais taster_gedrueckt = 0; }
.....
while (Weiche_Abzweig > Weiche_soll) { servo.attach(Pin_Servo); Weiche_soll++; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Abzweig) // Abfrage ob Endlage erreicht { servo.detach(); // Deaktivierung Servo digitalWrite(Pin_Relais, LOW); // Auschalten des Ralais taster_gedrueckt = 0; // Zurückstellen des Tasterstatus } }
Nicht wundern, hier habe ich nur den Code eingebettet, der von Bedeutung ist. Ich hoffe ihr findet die zusätzlichen Zeilen.
Natürlich auch wieder ein kleines Beweisvideo, dass es funktioniert:
Update 27.12.2020
4. Fahrwegausleuchung mit LED
Auch der letzte Punkt ist relativ simpel, es müssen nur zwei LED angeschlossen werden, und im Code entsprechend angesprochen werden. Erst ein Bild vom Aufbau, nun mit den beiden LED:
Bild 8: Anschluß der LED
Ich denke, der Anschluß der LED sollte klar sein.
Auch hier wieder nur der Code, der nun zusätzlich nötig ist.
1. Variable
1 2 3 4 5 6
…. int Pin_LED_Gerade = 7; // LED Gerade an PIN 7 int Pin_LED_Abzweig = 6; // LED Abzweig an PIN 8 ….
…. pinMode(Pin_LED_Gerade, OUTPUT); digitalWrite(Pin_LED_Gerade, HIGH); // Initialisieren der LED auf Grundstellung, LED Gerade leuchtet pinMode(Pin_LED_Abzweig, OUTPUT); digitalWrite(Pin_LED_Abzweig, LOW); // Initialisieren der LED auf Grundstellung, LED Abzweig ist aus …. while (Weiche_Gerade < Weiche_soll) { Weiche_soll--; servo.write(Weiche_soll); delay(Stellzeit_Servo_Weiche); if (Weiche_soll == Weiche_Gerade) { servo.detach(); // Deaktivierung Servo pinMode(Pin_Relais, OUTPUT); digitalWrite(Pin_Relais,HIGH); digitalWrite(Pin_LED_Abzweig, LOW); digitalWrite(Pin_LED_Gerade, HIGH); } }
….. if (Weiche_soll == Weiche_Gerade) { servo.detach(); // Deaktivierung Servo digitalWrite(Pin_Relais, HIGH); // Anschalten des Ralais digitalWrite(Pin_LED_Abzweig, LOW); // LED Abweig aus digitalWrite(Pin_LED_Gerade, HIGH); // LED Gerade an taster_gedrueckt = 0; }
…..
if (Weiche_soll == Weiche_Abzweig) // Abfrage ob Endlage erreicht { servo.detach(); // Deaktivierung Servo digitalWrite(Pin_Relais, LOW); // Auschalten des Ralais digitalWrite(Pin_LED_Gerade, LOW); // LED Gerade aus digitalWrite(Pin_LED_Abzweig, HIGH); // LED Abzweig an taster_gedrueckt = 0; // Zurückstellen des Tasterstatus } …..
Wie schon geschrieben ist das relativ simpel, die LED werden nach Abschaltung des Servos entsprechend ab- bzw. angeschaltet.
Natürlich auch wieder was zum kucken:
An meinem Stellpult zum Bahnhof Lödderitz der Forumbahn sieht das Ganze dann so aus:
Viele Grüße,
Micha
PS: Bei Gelegenheit (wenns hell ist) stelle ich auch schärfere Videos (vom Aufbau) ein.
koenntest Du noch etwas zum verwendeten Servo und Relais schreiben? Ein ganz normales Relais direkt mit einem Controller-Port zu schalten ist keine so gute Idee oder das Relais ist kein so ganz normales Relais - was so aussieht, weil Du fuers Relais eine Spannungsversorgung und eine Steuerleitung eingezeichnet hast.
Gruss Tom
Ep. III DB 2L DCC WebsiteMastodon It's boring when it works!
Ich kann morgen gerne mal Bilder von "unten" machen.
Servos hatte ich ebenfalls Chinaware, die habe ich aber wieder rausgeschmissen, da die ziemlich kurzlebig sind. Aktuell teste ich da noch etwas, habe da momentan welche von Reely.
Auf der Platine ist alles drauf, sogar ein Optokoppler zur Trennung. Eine normale Relaisspule am Controllerport funktioniert in der Regel naemlich nur ein einziges Mal, danach ist der Controller hin. Nur damit nicht jemand auf die Idee kommt, das mit nur einem Relais zu probieren.
Gruss Tom
Ep. III DB 2L DCC WebsiteMastodon It's boring when it works!
Zitat von MichaB im Beitrag #10 das ist mir bewusst, ich wollte erstmal einfach beginnen. Ich möchte das Ganze so gestalten, dass auch Anfänger einsteigen können.
Wenn Du immer nur eine Weiche steuern moechtest, dann bietet sich der Arduino Nano an, den gibt es unter 5 EUR und von den Ports her genuegt der vollauf. Da kannst Du pro Weiche rund einen 10er sparen.
Ich verwende zwar die Arduino Libs und IDE nicht, aber mit ATMega arbeite ich schon ewig. Fuer Einsteiger ist die Arduino Umgebung natuerlich besser, weil es da viel vorgefertigt gibt. Will man aber den Controller richtig ausnutzen oder da auch richtig einsteigen, dann fuehrt kein Weg am C Compiler, AVR Studio oder avrgcc und avrdude unter Linux und ein wenig Assembler vorbei.
Gruss Tom
Ep. III DB 2L DCC WebsiteMastodon It's boring when it works!
Du hattest ja deinen erreichten Stand mir zum Wintertreffen gezeigt und erklärt und beim freien Fahren, konnte ich es auch nutzen. Ich finde, es ist ein guter Einstieg in das Thema und es können Erfahrungen gesammelt werden.
Mir persönlich wären die Leitungen vom Prozessorpin zum Servo zu lang und somit u.U. zu störanfällig. Da bin ich auf Erfahrungen gespannt.
Mich würde auch interessieren, was Du unter echter Rückmeldung der Weichenlage verstehst.
Ich habe ja auch noch einen Nahgüterbereich, der per Hand ohne Computer steuerbar sein soll. Ich möchte aber einen Anschluss in die Welt des Digiitalen haben, um nicht mal in einer Sackgasse zu landen. Nun wollte ich wie Du eben keinen Rechner und keine Zentrale zum Schalten für den Handbetrieb verwenden. Andererseits möchte ich auch keine vielen Leitungen zum Steuern von Weichen und Signalen zwischen den Modulen haben. Da soll ein Bus mit seinem einem Kabel (Störsicherheit) existieren und so einen modularen Anschluss der Komponenten ermöglichen.
Aber unabhängig vom Konzept wird es ähnlichen Aufgabenstellungdn und Lösungen geben, wo man voneinander lernen und sich austauschen kann.
Ich freue mich auf weitere Beiträge und wünsche Dir viel Erfolg Manfred
Zitat von dr iv im Beitrag #12 Nun wollte ich wie Du eben keinen Rechner und keine Zentrale zum Schalten für den Handbetrieb verwenden. Andererseits möchte ich auch keine vielen Leitungen zum Steuern von Weichen und Signalen zwischen den Modulen haben. Da soll ein Bus mit seinem einem Kabel (Störsicherheit) existieren und so einen modularen Anschluss der Komponenten ermöglichen.
Man koennte alle Schaltmodule mit einem Datenbus, z.B. RS485, untereinander verbinden und mit einem eigenen Protokoll versehen. Dazu einen Mastercontroller, der alle Signale von Tastern weiterleitet und mit LEDs Zustaende signalisiert. Das waere eine von 1000 Moeglichkeiten sowas zu realisieren, mit einem stoersichereren Datenbus. Der Hardwareaufwand ist minimal, aber die Software muss man dann wohl selbst entwickeln und dann benoetigt man noch ein Gateway, wenn man doch mit dem Rechner steuern moechte.
Einfacher waere da ein Master, der bereits die Daten in einem gaengigen Format erzeugt, also aus einem Tastendruck z.B. ein DCC/Loconet/was auch immer Signal erzeugt. Wenn die einzelnen Module dann dieses Protokoll unterstuetzen, dann steht auch der Steuerung mit einem Rechner nichts mehr im Wege.
Nun hat sich diese Arbeit bereits jemand gemacht, nur eben nicht auf der Softwarebasis mit der Arduinoumgebung, sondern in C. Aber mit der Schaltung liesse sich das alles realisieren, wenn ich Deine Wunschliste richtig verstanden habe. Da die Software OpenSource ist, koennte man darauf aufsetzen. https://www.opendcc.de/elektronik/animat/animat.html
Gruss Tom
Ep. III DB 2L DCC WebsiteMastodon It's boring when it works!
sehr gute Einführung in die Arduino Steuerung. Ich hoffe, die folgenden Beiträge werden genau so gut. Wer sich hiermit in Software und Hardware einarbetet, kann mit wenig finanziellem Aufwand viel bewerkstelligen. Über ein kleines Optokoppler Interface ist das ganze sogar für digitale DCC Steuerung geeignet. Ich habe auch Arduinos im Einsatz und benutze S88N und I2C über mehrere Meter Entfernung störungsfrei. Wer meint, er müsse unbedingt CAN-Bus, BiDiB benutzen, der muß auch entspechende Preise dafür bezahlen.
Ich habe dann dem zweiten Beitrag mal Leben eingehaucht, zwei Punkte fehlen noch, aber die sind nicht ganz so umfangreich.
@ Tom
Zitat Wenn Du immer nur eine Weiche steuern moechtest, dann bietet sich der Arduino Nano an, den gibt es unter 5 EUR und von den Ports her genuegt der vollauf. Da kannst Du pro Weiche rund einen 10er sparen.
....
Darauf gehe ich später noch genauer ein. Nur kurz, ich baue Module, und da sind die Notwendigkeiten etwas anders, ich meine aber, dass man diese durchaus auf den stationären Anlagenbau übertragen kann, z.B. wenn man in Segmenten baut. Letztlich baue ich den Arduino dort hin, wo die Weichen sind, und da sind es mal zwei Weichen, mal 6, dementsprechend werden dann Ports benötigt.
@Heinz
Danke, dass hoffe ich auch, das ist auch mein Ziel. Wie ich aber schon schrieb, ist das meine Lösung, und ich freue mich über Kritik und Verbesserungsvorschläge. Aktuell nutze ich zur Verbindung der Arduinos LAN-Ports mit geschirmten LAN-Kabeln, da gab es bis jetzt (längstes Kabel 20m) keinerlei Störungen. Mit dem Thema I2C (Komunikationsbus zwischen Arduinos) habe ich mich auch schon belesen, aber noch nicht getestet, das soll dann Inhalt von Post #5 sein. Momentan schreibe ich nur Ports und werte sie aus, funktioniert auch, doch dazu später mehr in #4.
Zitat von MichaB im Beitrag #15 Darauf gehe ich später noch genauer ein. Nur kurz, ich baue Module, und da sind die Notwendigkeiten etwas anders, ich meine aber, dass man diese durchaus auf den stationären Anlagenbau übertragen kann, z.B. wenn man in Segmenten baut. Letztlich baue ich den Arduino dort hin, wo die Weichen sind, und da sind es mal zwei Weichen, mal 6, dementsprechend werden dann Ports benötigt.
Alles klar, da hatte ich mehr hinein interpretiert, als in Deiner Antwort bzgl. des I/O Shields stand! Ich war dadurch von einer sehr minimalistischen Version ausgegangen ;-)
Zitat Kabel 20m) keinerlei Störungen. Mit dem Thema I2C (Komunikationsbus zwischen Arduinos) habe ich mich auch schon belesen, aber noch nicht getestet, das soll dann Inhalt von Post #5 sein. Momentan schreibe ich nur Ports und werte sie aus, funktioniert auch, doch dazu später mehr in
I²C ist als Bussystem auf einer Leiterplatte geplant und realisiert worden. Es ist absolut nicht stoersicher und man sollte lange Leitungswege vermeiden. Ich arbeite seit 30 Jahren mit I²C im landwirtschaftlichen Umfeld, wo es von Stoerungen nur so hagelt (wenn der Bauer z.B. mal schnell das E-Schweissgeraet anwirft) und habe da ein wenig Erfahrung gesammelt. Das bedeutet nun nicht, dass es fuer diesen Einsatzzweck nicht geeignet ist, aber bevor man an seinen Softwarefaehigkeiten zweifelt weil die Kommunikation sich seltsam verhaelt, sollte man immer im Hinterkopf behalten, dass man etwas verwendet, was fuer diesen Einsatzzweck nicht konstruiert wurde. Ausserdem haben einige ATMegas einen Bug im TWI Interface, der dazu fuehrt, dass dieses nach dem Aufwachen aus dem Sleep nicht mehr funktioniert. Dazu gibt es Application Notes von Atmel. Es gab da auch noch einen weiteren Bug mit TWBR. Gegenueber den 8051 kompatiblen Controller, von z.B. Siemens, ist I²C mit einem Atmel immer fuer eine Ueberraschung gut ;-)
Gruss Tom
Ep. III DB 2L DCC WebsiteMastodon It's boring when it works!
irgendwie habe ich die Befürchtung, dass das hier noch weit gehen kann....
Da meine aktuelle Lösung funktioniert, und ich mit I2C wohl nur ca. 10 Adern von 63 verfügbaren (habe schon einen PIN am LAN Port gekillt ) sparen würde, die Kabel dadurch nicht tauschen würde, ist das dann wohl nicht ganz so schlimm.
Dennoch möchte ich da mal testen, freue mich auf deine Unterstützung.
Zitat von MichaB im Beitrag #17 Dennoch möchte ich da mal testen, freue mich auf deine Unterstützung.
Wenn ich helfen kann, tue ich das gerne. Allerdings schrieb ich ja schon, dass ich nicht mit der Arduino Umgebung arbeite, sondern die Controller direkt in C programmiere - ich muss dann etwas umdenken, weil die Arduino Umgebung eigentlich alles in einer Bibliothek "versteckt".
Hallo, vielleicht kann ich auch ein wenig zu diesem sehr interessanten Thema beitragen. Ich beschäftige mich schon eine gnaze Weile mit dem Einsatz des Arduino im Moba-Umfeld. Das ist eine sehr spannende Sache, mit der man nebenbei auch noch eine Menge Geld sparen kann. Um vieles zu vereinfachen, habe ich da auch eine Lib geschrieben, die MobaTools. Damit kann man z.B. auch sehr einfach die Servos dazu bewegen, sich langsam zu bewegen . Das macht sich bei Weichen sehr gut - vor allem, wenn auch Weichenlaternen mitbewegt werden sollen. Von den Aufrufen her ist das weitgehend identisch zur Servo.h der IDE . Man kann übrigends auch jeden Pin für die Servosteuerung nutzen, der muss nicht PWM-fähig sein. So lassen sich bis zu 16 Servos mit einem Arduino steuern.
Was die Übertragung der Stellbefehle angeht, finde ich die in #13 gemachten Vorschläge auch interessant. Das allseits bekannte DCC-Protokoll wird auch auf dem Arduino gut unterstützt. Denkbar wäre einen Master-Arduino im Stellpult, der aufgrund der gedrückten Tasten entsprechende DCC-Befehle erzeugt, die dann an die dezentralen Weichencontroller-Arduinos weitergeleitet werden. Dazu bräuchte es auch keinen Booster, Das DCC-Signal kann hier einfach im Sinne eines lokalen Bus als 5V-Logiksignal an die unterlagerten Arduinos weitergegeben werden.
Natürlich sind auch andere Bussysteme - z.B. LocoNet - geeignet. Für die dezentralen Arduino's vor Ort gäb's da auch schon eine fertige Software, die nur konfiguriert werden muss. Aber natürlich macht auch das selbst Programmieren viel Spaß .
P.S. @Tom Die Arduino Umgebung erleichtert zwar den Einstieg ungemein, verhindert aber bei eintsprechenden Kenntnissen keineswegs den Microcontroller bis aufs letzte Bit auszunutzen. Hinter der Arduino IDE steckt der GCC mit der AVR Toolchain, also letztendlich derselbe Compiler wie in AVR Studio. Allerdings sind dort die Debuggingmöglichkeiten ( mit entspr. HW ) wesentlich ausgefeilter.
P.P.S Vielleicht noch ein Hinweis zur Stromversorgung des Arduino: Hier wurde ja vorgeschlagen, den Arduino direkt mit 5V zu versorgen. Das ist ist grundsätzlich zwar möglich, birgt aber auch Gefahren: Wenn man nun gleichzeitig zur Sketchübertragung den PC über USB anschließt, sind ( zumindest beim UNO ) die beiden 5V Versorgungen direkt miteinander verbunden. Das kann im ungünstigsten Fall den USB-Port des PC zerstören. Man sollte dann auf jeden Fall dazu eine USB-Kabel verwenden, bei dem die 5V-Leitung unterbrochen ist. Beim Arduino Nano ist da ein Schutzdiode drin, weshalb dieser Betrieb dort unkritisch ist. Ob die Diode allerdings auch bei allen Klonen dirn ist ist natürlich nicht sicher (bei mir war das bisher aber bei allen so).
zm Thema "Master" Arduinno komme ich,wenn ich meine Lösung hinsichtlich Stellpult vorstelle. Kurz noch eine Verständnisfrage zum DCC-Protokoll. Verstehe ich das richtig, dass man das als Alternative zu I2C nutzen kann?
Aktuell habe ich es so, dass ich im Stellpult einen Masterarduino habe, die Ports dann mit 5V Volt beschalte, und der Slave diese Ports dann auswertet. Das Stellpult ist mit LAN-Kabeln verbunden, und es sind momentan nicht so viele Ports die benötigt werden, sodass die die 8 Pole aktuell reichen, da auch nicht viel mehr geplant ist.
Zur Verbindung über USB:
Ich habe es immer so gehandhabt: Entweder USB oder Fremdeinspeisung, das wolltest du damit doch sagen oder?
H0-Modellbahnforum.de - das Forum mit der Forumbahn!
»
Technik und Steuerung von Fahrzeugen und Anlage
»
Analoge Technik und Fahrzeugtechnik
»
Weichensteuerung mit Arduino - Update 27.12.20 - Fahrwegausleuchtung mit LED
17.01.2020 22:14 (zuletzt bearbeitet: 27.12.2020 20:45)
Thema drucken
Antworten
) sparen würde, die Kabel dadurch nicht tauschen würde, ist das dann wohl nicht ganz so schlimm.
.
