Hallo zusammen,

in Hirschberg, Mühltroff und Wählitz steuern wir die Weichen mit Outbusen, Servos und Nano Arduinos.

Aktuell haben wir das Problem, dass wir in nicht nachvollziehbaren Momenten Phantomstellungen haben.
Das bedeutet, dass sich Weichen automatisch stellen (hin und zurück) ohne, dass der Outbus überhaupt berührt wurde. Manchmal nur einmal pro Session und manchmal 2-3 pro Stunde in unterschiedlichen Abständen.
Nun hatten wir die Vermutung, dass dies an einem fehlerhaften Signal liegt, welches dem Arduino mitgeteilt wird. Jedoch wird in den Momenten der Phantomstellungen auch keine andere Weiche betätigt. Dieses Phänomen passiert auch, wenn eine Lok über das Modul fährt, obwohl der Stromkreis vom Gleis vollkommen vom Versorgungsstromkreis für die Arduinos und Servos getrennt ist.

Hier nochmal ein paar kurze Infos zu unserem Aufbau:
- Arduino wird mit 5V versorgt
- Outbus mit 2 poligen Schalter für den Stellbefehl zum Arduino und der Polarisierung der Weiche
- Servo ist am gleichen Versorgungsstromkreis angeschlossen, wie der Arduino
- Wir haben auch mehrere Servos und Arduinos getestet mit keiner Veränderung

Anbei das Sketch, welches wir für die Weichen nutzen.

Ich weiß nicht, ob es ein Problem bei der Hardware oder Software gibt.
Eventuell kann man das Problem auch Softwareseitig relativ einfach beheben.(Eventuell durch eine Abfrage, welche nochmal den Outbus abfragt?)
Jedoch fehlt mir hier aktuell bei der Programmierung die Expertise bzw. weiß ich nicht, wie ich weiter mache.

#include <Servo.h>
 
Servo servo;
 
int Weiche01_Links = 40;   // Abzweig
int Weiche01_Mitte = 70;
int Weiche01_Rechts = 100;  // Gerade
int Weiche01_soll = Weiche01_Mitte;
int Weiche01_Servo = 6;
int Weiche01_Taster = 2; // vom Umschalter
 
int sz = 50; // Stellgeschwindigkeit Servo
 
void setup() 
{
  delay (1000);
  digitalWrite(Weiche01_Taster,LOW);
  pinMode(Weiche01_Taster, INPUT_PULLUP);
  servo.attach(Weiche01_Servo);
  servo.write(Weiche01_Mitte);
  delay(sz);
  servo.detach();
}
 
void loop() 
{
  if (digitalRead(Weiche01_Taster) == HIGH)
    {
    while (Weiche01_Links < Weiche01_soll)
      {
      servo.attach(Weiche01_Servo);
      Weiche01_soll--;
      servo.write(Weiche01_soll);
      delay(sz);
      if (Weiche01_soll == Weiche01_Links) 
        {
        servo.detach(); 
        }
      }
    }
  if (digitalRead(Weiche01_Taster) == LOW)
    {
    while (Weiche01_Rechts > Weiche01_soll)
      {
      servo.attach(Weiche01_Servo);
      Weiche01_soll++;
      servo.write(Weiche01_soll);
      delay(sz);
      if (Weiche01_soll == Weiche01_Rechts) 
        {
        servo.detach();
        }     
     }
   } 
}
 

Ich wäre euch für Hilfe sehr dankbar.

Viele Grüße
Mathias

Hallo Mathias,

Ist das Kabel vom Outbus zum Arduino geschirmt?

Wir hatten bei unseren Arduino Schaltungen teilweise große Probleme mit Induktionsströmen, welche durch Weichenantriebe oder Loks verursacht wurden. Inbesondere die Köf II von Brawa hat sich da hervorgetan. Ich könnte mir vorstellen, dass das bei dir auch auftritt.

Softwareseitig kann man da gegensteuern, indem der Outbus Schalter mehrmals abgefragt wird. Ich habe dir einen möglichen Fix angehangen. Dabei wird der Schalter 10x im Abstand von je 10ms ausgelesen. Nur wenn jedes Mal der gleiche Wert ausgelesen wird, wird im Anschluss die Weiche gestellt.

Grüße
Frank

#include <Servo.h>
 
Servo servo;
 
int Weiche01_Links = 40;   // Abzweig
int Weiche01_Mitte = 70;
int Weiche01_Rechts = 100;  // Gerade
int Weiche01_soll = Weiche01_Mitte;
int Weiche01_Servo = 6;
int Weiche01_Taster = 2; // vom Umschalter
 
int sz = 50; // Stellgeschwindigkeit Servo
 
bool Weiche_Links = true;
bool Eingabe_unklar = false;
 
void setup() 
{
  delay (1000);
  digitalWrite(Weiche01_Taster,LOW);
  pinMode(Weiche01_Taster, INPUT_PULLUP);
  servo.attach(Weiche01_Servo);
  servo.write(Weiche01_Mitte);
  delay(sz);
  servo.detach();
}
 
void loop() 
{
  // Initialisieren
  Weiche_Links = digitalRead(Weiche01_Taster);
  Eingabe_unklar = false;
 
  // Lese den Schalter 10x hintereinander aus und vergleiche mit dem inital ausgelsesenen Wert
  for (int i=0; i <= 10; i++)
  {      
    // Falls ein abweichender Wert ausgelesen wird, breche die Schleife ab setze Eingabe_unklar = true
    if (Weiche_Links != digitalRead(Weiche01_Taster))
    {
      Eingabe_unklar = true;
      break;
    }
    // kurze Pause vor dem erneuten Einlesen
    delay(10);   
  }
 
  // falls unklare Eingabe, überspringe diesen Schritt
  if (!Eingabe_unklar)
  {
    if (Weiche_Links)
      {
      while (Weiche01_Links < Weiche01_soll)
        {
        servo.attach(Weiche01_Servo);
        Weiche01_soll--;
        servo.write(Weiche01_soll);
        delay(sz);
        if (Weiche01_soll == Weiche01_Links) 
          {
          servo.detach(); 
          }
        }
      }
    else
      {
      while (Weiche01_Rechts > Weiche01_soll)
        {
        servo.attach(Weiche01_Servo);
        Weiche01_soll++;
        servo.write(Weiche01_soll);
        delay(sz);
        if (Weiche01_soll == Weiche01_Rechts) 
          {
          servo.detach();
          }     
       }
     }
   } 
}
 
 

Hallo Mathias

ich hatte bei meinen Steuerungen Probleme mit der gemeinsamen Spannungsversorgung von Prozessor und den Servos. Die Servos haben teilweise so hohe Anlaufströme gehabt, sodass der Prozessor einen Reset durch Unterspannung bekommen hat. Das Problem habe ich gelöst durch getrennte 5V Versorgung des Prozessors und der Servos. Seitdem war Ruhe bei mir.

Vielleicht ist das auch bei dir das Problem.

Gruß Olaf

Moin,

was ich schon in der Software sehe, dass für die Taster nur der interne Pullup genommen wird. In den AVR Controllern haben die irgendwelche Werte zwischen 20k und 50k. Sicherer ist ein externer Pullup von 10k. Ganz sicher ist eine Beschaltung der Eingangsports mit einer Suppressordiode gegen zu hohe Spannungen und wenn es nicht für ein Timing kritisch ist, ein 100nF X7R Kondensator nach Masse. Wenn man noch eine kleine Drossel so um die 100µH in Reihe legt, hat man schon fast das Optimum an Eingangsschutz.

Die Entprellung per Software macht man besser mit einem Timer, nicht mit einer Schleife. Die Schleife hält das ganze Programm für den Zeitraum auf. Das ist bei der for Schleife nicht weiter tragisch, die benötigt ja nur ein paar µs. Die Entprellzeit eines Tasters sollte aber im Bereich von ms liegen, so ein typischer Standardwert sind 25ms.

Gleiches gilt eigentlich auch für das Stellen der Servos. Da ist dann sogar noch ein delay vorhanden, in der Zeit macht der Controller nichts anderes, als nur zu warten. Für all solche Dinge haben Controller eigentlich Timer :-)

Was auch viel vergessen wird sind beim Einsatz von Linearreglern die 100nF vom Eingang und Ausgang nach Masse, so knapp an den Pins, wie es nur irgendwie geht. Die Regler neigen sonst zum Schwingen. Damit ist die Versorgungsspannung für den Controller dann hinüber.

Ich weiß nicht, ob der Brown-Out Detector (BOD) im Controller bei den üblichen Arduino Boards aktiviert ist, das geschieht über ein FUSE Bit. Die Spannung dazu kann man über FUSE Bits einstellen. Wenn der BOD auf 4.3V steht, macht der Controller natürlich zügig einen Stop, wenn die Versorgungsspannung nicht so toll ist. Mögliche Spannungen sind 1.8, 2.7 und 4.3V oder Disabled.

Leistungsspitzen kann man mit entsprechenden Elektrolyt-Kondensatoren am Controller abfangen.

Gibt es dazu einen Schaltplan, so mit Stromversorgung, Anschluß der externen Taster?

Gruß
Tom

Hallo Mathias,

wenn die Betriebsspannung des Arduino einknickt, bekommt er einen Reset. Dann wird die Funktion init aufgerufen, die die Weiche in Mittelstellung bringt (warum eigentlich?) und danach in Funktionn loop wird sie wieder in die richtige Lage gestellt.
Das Problem lässt sich lösen, indem man die Weiche in der init-Funktion gleich richtig stellt. Wenn die Spannung aber soweit einbricht, dass der Servo einen Einschaltruck macht, hilft das auch nichts.
Die von Frank vorgeschlagene Filterung sollte man trotzdem machen. Das schadet nichts.

Was mir am Code noch aufgefallen ist:
- Was soll digitalWrite(Weiche01_Taster,LOW) bewirken? Hier wird eine Spannung auf einen Eingang gelegt. Das kann einen Kurzschluss machen und dem Chip schaden.
- In der Schleife wird immer wieder erneut servo.attach() aufgerufen. Kann man sich darauf verlassen, dass die Funktion das richtig handelt? Sicherer ist es, das vor der Schleife zu machen.

Ich habe noch eine Blinkfunktion eingebaut: Wenn am Taster-Eingang ein Fehler bemerkt wird, blinkt die LED 0,2s und nach einem Reset 0,5s. Dann kannst du einfach den Arduino filmen und siehst am Blinken, was die Fehlerursache war.

Wenn du nie mehr als einen Servo gleichzeitig stellen willst, ist die delay-Funktion kein Problem.

#include <Servo.h>
 
Servo servo;
const int Weiche01_Links = 40;   // Abzweig
//int Weiche01_Mitte = 70;
const int Weiche01_Rechts = 100;  // Gerade
const int Weiche01_Lagen[2] = {Weiche01_Rechts, Weiche01_Links};
 
const int sz = 50; // Stellgeschwindigkeit Servo
 
// Pins:
const int Weiche01_Servo = 6;
const int Weiche01_Taster = 2; // vom Umschalter
const int LED = 13;
 
int Weiche01_soll = Weiche01_Links;
bool Weiche_Links = true;
 
bool led_blink(unsigned long zeit){
  digitalWrite(LED, true);
  delay(zeit);
  digitalWrite(LED, false);
  delay(zeit);
}
 
bool pin_filter(bool& value, const int pin) // Aendert value, wenn Eingang "pin" stabil ist. Gibt dann true zurueck.
{
  const bool v = digitalRead(pin);
  for (int i = 0; i < 30; ++i) // 30ms lang einlesen.
  {
    delay(1);
    if (digitalRead(pin) != v) 
    {
      led_blink(200);   // LED kurz einschalten, um zu zeigen, dass Signal gestoert ist.
      return false; // value bleibt gleich.
    }
  }
  value = v;
  return true;
}
 
void setup() 
{
  pinMode(LED, OUTPUT);
  led_blink(500);
 
  //digitalWrite(Weiche01_Taster,LOW); // wozu?
  pinMode(Weiche01_Taster, INPUT_PULLUP);
  
  while (!pin_filter(Weiche_Links, Weiche01_Taster)) // Solange Weiche01_Taster einlesen, bis Wert stabil ist
    ;
    
  Weiche01_soll = Weiche01_Lagen[Weiche_Links];
  servo.attach(Weiche01_Servo);
  servo.write(Weiche01_soll);
  delay(500);
  servo.detach();
}
 
void loop() 
{
  pin_filter(Weiche_Links, Weiche01_Taster);
  
  if (Weiche_Links)
  {
    if (Weiche01_Links < Weiche01_soll)
    {
      servo.attach(Weiche01_Servo);
      while (Weiche01_Links < Weiche01_soll)
      {
        Weiche01_soll--;
        servo.write(Weiche01_soll);
        delay(sz);
      }
      servo.detach(); 
    }
  } 
  else
  {
    if (Weiche01_Rechts > Weiche01_soll)
    {
      servo.attach(Weiche01_Servo);
      while (Weiche01_Rechts > Weiche01_soll)
      {
        Weiche01_soll++;
        servo.write(Weiche01_soll);
        delay(sz);
      }
      servo.detach();
    }
  }
}
 
 

Spule und Kondensator am Eingang würde ich lieber nicht machen, das gibt einen Schwingkreis.

Moin,

Zitat von Carlo_ im Beitrag #5

---

Spule und Kondensator am Eingang würde ich lieber nicht machen, das gibt einen Schwingkreis.

---