2 Taster 4 Led 2 Servo

Drei geschweifte Klammern ergänzt und Strg+t gedrückt, dann sieht es so aus, als Service für Mitleser (der Compiler ist zufrieden, aber nicht auf Funktion getestet):

#include <Servo.h> // zugriff auf Servo Bibliothek

const int BUTTONw1 = 22; // Pushbutton Pin auf dem Board (22)
const int BUTTONw2 = 23; // Pushbutton Pin auf dem Board (23)
const int BUTTONw3 = 24;
const int BUTTONw4 = 25;
const int BUTTONw5 = 26;
const int BUTTONw6 = 27;
const int LEDw1lks = 6;
const int LEDw2lks = 7;
const int LEDw2re = 4;
const int LEDw1re = 5;
const int LEDw3lks = 28;
const int LEDw3re = 29;
const int LEDw4lks = 30;
const int LEDw4re = 31;
const int LEDw5lks = 32;
const int LEDw5re = 33;
const int LEDw6lks = 34;
const int LEDw6re = 35;
bool val_1 = 0; // speichert den Zustand des Tasters
bool old_val_1 = 0; // speichert den vorherigen wert von val
bool val_2 = 0; // speichert den Zustand des Tasters
bool old_val_2 = 0; // speichert den vorherigen wert von val
bool val_3 = 0;
bool old_val_3 = 0;
bool val_4 = 0;
bool old_val_4 = 0;
bool val_5 = 0;
bool old_val_5 = 0;
bool val_6 = 0;
bool old_val_6 = 0;
bool statew1 = 0; // 0 = Servo Position eins 1 = Servo Position zwei
bool statew2 = 0; // 0 = Servo Position eins 1 = Servo Position zwei
bool statew3 = 0;
bool statew4 = 0;
bool statew5 = 0;
bool statew6 = 0;
Servo servow1; // deklariert den Namen des ersten Servos
Servo servow2;
Servo servow3;
Servo servow4;
Servo servow5;
Servo servow6;
void setup() {
  pinMode(BUTTONw1, INPUT_PULLUP); // Gibt an dass Buttom ein Input ist - DAS IST GEÄNDERT
  pinMode(BUTTONw2, INPUT_PULLUP);
  pinMode(BUTTONw3, INPUT_PULLUP);
  pinMode(BUTTONw4, INPUT_PULLUP);
  pinMode(BUTTONw5, INPUT_PULLUP);
  pinMode(BUTTONw6, INPUT_PULLUP);
  servow1.attach(9); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow1.write(36); // gibt die Grundstellung des Servo beim start an
  servow2.attach(10); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow2.write(36); // gibt die Grundstellung des Servo beim start an
  servow3.attach(11); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow3.write(36); // gibt die Grundstellung des Servo beim start an
  servow4.attach(12); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow4.write(36); // gibt die Grundstellung des Servo beim start an
  servow5.attach(13); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow5.write(36); // gibt die Grundstellung des Servo beim start an
  servow6.attach(14); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
  servow6.write(36); // gibt die Grundstellung des Servo beim start an
  pinMode(LEDw1lks, OUTPUT);
  pinMode(LEDw2lks, OUTPUT);
  pinMode(LEDw2re, OUTPUT);
  pinMode(LEDw1re, OUTPUT);
  pinMode(LEDw3lks, OUTPUT);
  pinMode(LEDw3re, OUTPUT);
  pinMode(LEDw4lks, OUTPUT);
  pinMode(LEDw4re, OUTPUT);
  pinMode(LEDw5lks, OUTPUT);
  pinMode(LEDw5re, OUTPUT);
  pinMode(LEDw6lks, OUTPUT);
  pinMode(LEDw6re, OUTPUT);

}

void loop()
{ val_1 = digitalRead(BUTTONw1); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_1 == LOW) && (old_val_1 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew1 = 1 - statew1;
    delay(500);
  }

  old_val_1 = val_1; // aktueller val wird zu val alt

  if (statew1 == 1) {
    servow1.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw1lks, HIGH);
    digitalWrite(LEDw1re, LOW);
    delay(20);

  }
  else {
    servow1.write(36); // stelle servo auf startposition
    digitalWrite(LEDw1lks, LOW);
    digitalWrite(LEDw1re, HIGH);
  }
  //WEICHE 2
  val_2 = digitalRead(BUTTONw2); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_2 == LOW) && (old_val_2 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew2 = 1 - statew2;
    delay(500);
  }

  old_val_2 = val_2; // aktueller val wird zu val alt

  if (statew2 == 1) {
    servow2.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw2lks, HIGH);
    digitalWrite(LEDw2re, LOW);
    delay(20);

  }
  else {
    servow2.write(36); // stelle servo auf startposition
    digitalWrite(LEDw2lks, LOW);
    digitalWrite(LEDw2re, HIGH);
  }
  //WEICHE3
  val_3 = digitalRead(BUTTONw3); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_3 == LOW) && (old_val_3 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew3 = 1 - statew3;
    delay(500);
  }

  old_val_3 = val_3; // aktueller val wird zu val alt

  if (statew3 == 1) {
    servow3.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw3lks, HIGH);
    digitalWrite(LEDw3re, LOW);
    delay(20);

  }
  else {
    servow3.write(36); // stelle servo auf startposition
    digitalWrite(LEDw3lks, LOW);
    digitalWrite(LEDw3re, HIGH);
  }
  //WEICHE 4
  val_4 = digitalRead(BUTTONw4); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_4 == LOW) && (old_val_4 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew4 = 1 - statew4;
    delay(500);
  }

  old_val_4 = val_4; // aktueller val wird zu val alt

  if (statew4 == 1) {
    servow4.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw4lks, HIGH);
    digitalWrite(LEDw4re, LOW);
    delay(20);

  }
  else {
    servow4.write(36); // stelle servo auf startposition
    digitalWrite(LEDw4lks, LOW);
    digitalWrite(LEDw4re, HIGH);
  }
  //WEICHE 5
  val_5 = digitalRead(BUTTONw5); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_5 == LOW) && (old_val_5 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew5 = 1 - statew5;
    delay(500);
  }

  old_val_5 = val_5; // aktueller val wird zu val alt

  if (statew5 == 1) {
    servow5.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw5lks, HIGH);
    digitalWrite(LEDw5re, LOW);
    delay(20);

  }
  else {
    servow5.write(36); // stelle servo auf startposition
    digitalWrite(LEDw5lks, LOW);
    digitalWrite(LEDw5re, HIGH);
  }
  //WEICHE 6
  val_6 = digitalRead(BUTTONw6); // liest den Input aus und cheked ob er gedrückt ist.
  if ((val_6 == LOW) && (old_val_6 == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
    statew6 = 1 - statew6;
    delay(500);
  }

  old_val_6 = val_6; // aktueller val wird zu val alt

  if (statew6 == 1) {
    servow6.write(85); // Stelle servo auf 100 grad
    digitalWrite(LEDw6lks, HIGH);
    digitalWrite(LEDw6re, LOW);
    delay(20);

  }
  else {
    servow6.write(36); // stelle servo auf startposition
    digitalWrite(LEDw6lks, LOW);
    digitalWrite(LEDw6re, HIGH);
  }
}

Variante mit Feld und Schleife, als Service für Mitleser (der Compiler ist zufrieden, aber nicht auf Funktion getestet):

#include <Servo.h> // zugriff auf Servo Bibliothek

const byte BUTTONw[] = {22, 23, 24, 25, 26, 27}; // Pushbutton Pin auf dem Board
const byte LEDwlks[] = {6, 7, 28, 30, 32, 34};
const byte LEDwre[] = {4, 5, 29, 31, 33, 35};
const byte SERVOpin[] = {9, 10, 11, 12, 13, 14};
const byte ANZw = sizeof(BUTTONw) / sizeof(BUTTONw[0]);
bool val[ANZw]; // speichert den Zustand des Tasters
bool old_val[ANZw]; // speichert den vorherigen wert von val
bool statew[ANZw]; // 0 = Servo Position eins 1 = Servo Position zwei
Servo servow[ANZw]; // deklariert den Namen des ersten Servos

void setup() {
  for (byte w = 0; w < ANZw; w++)
  {
    pinMode(BUTTONw[w], INPUT_PULLUP); // Gibt an dass Buttom ein Input ist - DAS IST GEÄNDERT
    servow[w].attach(SERVOpin[w]); // gibt an auf welchem Pin der Servo mit dem steuerkabel anliegt
    servow[w].write(36); // gibt die Grundstellung des Servo beim start an
    pinMode(LEDwlks[w], OUTPUT);
    pinMode(LEDwre[w], OUTPUT);
  }
}

void loop()
{
  for (byte w = 0; w < ANZw; w++)
  {
    val[w] = digitalRead(BUTTONw[w]); // liest den Input aus und cheked ob er gedrückt ist.
    if ((val[w] == LOW) && (old_val[w] == HIGH)) {   // HIER IST DIE ABFRAGE GEÄNDERT
      statew[w] = 1 - statew[w];
      delay(500);
    }

    old_val[w] = val[w]; // aktueller val wird zu val alt

    if (statew[w] == 1) {
      servow[w].write(85); // Stelle servo auf 100 grad
      digitalWrite(LEDwlks[w], HIGH);
      digitalWrite(LEDwre[w], LOW);
      delay(20);
    }
    else {
      servow[w].write(36); // stelle servo auf startposition
      digitalWrite(LEDwlks[w], LOW);
      digitalWrite(LEDwre[w], HIGH);
    }
  }
}

Ich möchte hier nur zeigen, wie man von einem Programm “sechsmal kopiert” zu einer Variante mit Feldern und Schleife gelangt. Das noch vorhandene Verbesserungspotential habe ich ignoriert.

Hi,

ich bräcuhte nochmal Eure Hilfe.
Ich hab jetzt 2 Taster 4 Leds und 2 Servos (an den Weichen) angeschlossen. Funktioniert auch die 1. Minuten. Danach reagiert der Arduino wie als wäre der Akku leer. Er versucht zu schalten schafft es aber nicht die Servos zusteuern. Wenn ich stromlos mache 10 Sekunden warte und ihn wieder ans Netz hänge klappt wieder alles für ein paar Minuten.

Angeschlossen ist er mit dem mitgelieferten Netzteil.

Hat jemand eine Idee was das sein kann und wie das behebe?

Gruß

Hi

Was passiert, wenn Du den Arduino 'nur' resettest?
Hast Du bereits versucht, Die vom betreffenden Arduino irgend welche Werte anzeigen zu lassen, daß Du vll. erkennen kannst, wo's hakt?

... z.B. ein LCD per I²C an-häkeln und im Sketch ein/zwei Dutzend Ausgaben.

MfG

resetten wie? der hängt in dem moment nicht am PC.
Lcd-display hab ich keins dran hab mich auch noch nicht mit dem Thema beschäftigt.

wiliam_t_riker:
Ich hab jetzt 2 Taster 4 Leds und 2 Servos (an den Weichen) angeschlossen.

Wie hast Du die angeschlossen? Wo kommen die 5V für die Servos her? Die kannst Du nicht aus dem 5V-Anschluß des Mega versorgen.
Zeig mal, wie Du das alles verdrahtet hast ( Schaltbild ).

ach kann ich nicht dachte das das geht? Aber warum funktioniert das die ersten Minuten und dann nicht mehr?

Ein reset bringt auch nix erst wenn den Stromlos mache funzt es wieder.

wiliam_t_riker:
Aber warum funktioniert das die ersten Minuten und dann nicht mehr?

Ich nehme mal an, Du versorgst den Mega über die Hohlbuchse? Der 5V-Regler auf dem Mega ist nicht besonders kräftig. Wenn Du darüber die Servos versorgst wird der zu heiß und schaltet dann ab. Wenn Du stromlos machst, kühlt er wieder ab, und dann geht es wieder kurz.

Was für ein Netzteil hast Du den da dran? Für die Servos brauchst Du auf jeden Fall eine eigene stabile 5V-Versorgung.

Hallo,

wenn ich einen Tipp geben darf. Ich würde den Aufbau anders angehen - strukturierter. :wink:
Da alles was eine Weiche benötigt hier gleich ist drängt sich ein struct förmlich auf.
Was benötigt eine Weiche beim TO?

Vorschlag

enum class State : bool {links, rechts};
State seite = State::links;

struct Daten
{
  const byte pinTasterL;
  const byte pinTasterR;
  const byte pinLedL;
  const byte pinLedR;
  State stateTaster;
  State oldStateTaster;
  State positionWeiche;
  State oldPositionWeiche;

  Daten(byte pTL, byte pTR, byte pLL, byte pLR):
    // Initialisierungsliste
    pinTasterL{pTL},
    pinTasterR{pTR},
    pinLedL{pLL},
    pinLedR{pLR},
    stateTaster{State::links},
    oldStateTaster{State::links},
    positionWeiche{State::links},
    oldPositionWeiche{State::links}
  {}
};

Daten weiche[] = {
  {2, 3, 4, 5},    // 1. Weiche, Pins laut Initialisierungsliste
  {6, 7, 8, 9},    // 2. Weiche
};

void setup(void) {
  
}

void loop(void) {

}

Dann kannste über jeden Member der "weiche" mit den MobaTool in for Schleifen drübergehen. Ggf. fügste die Startparameter hinzu falls jede Weiche individuell initialisiert werden soll.

Ja wird über die Hohldose mit strom versorgt. Also ein extra Netzteil mit 5 v für die Servos? Wieviel Ampere darf das netzteil max. ausspucken?

Man könnte es auch mit einer Klasse machen. Angeregt durch dieses Thema hatte ich da mal was für ein anderes Thema geschrieben:

/*  Demo zum Anschluß mehrerer Weichen, realisiert mit objektorientierter Programmierung (OOP)
     Anstelle von Funktionen und Feldern werden Methoden und Strukturen verwendet.
     Die Methoden sehen so aus, als seien sie für eine Weiche geschrieben,
     tatsächlich können aber bis zu 16 Weichen, begrenzt durch die Bibliothek, verwendet werden,
     wenn die Pins wie beim Mega2560 ausreichen.
     Beim Drücken des Tasters geht die LED aus, der Servo bewegt die Zunge mit eingestellter Geschwindigkeit
     in die andere Position, die LED für die neue Position geht an, der Servo wird nach einer Sekunde ausgeschaltet.

     Ausgaben auf den seriellen Monitor dienen nur der Veranschaulichung und können entfernt werden.
*/
#include <MobaTools.h>
const byte ZUNGENGESCHWINDIGKEIT = 10;  // entspricht 1,7 Sekunden

class Weiche {
    const byte tasterPin;       // Pin für den Taster
    const byte ledGeradePin;    // Pin für die LED Zustand gerade
    const byte ledAbzweigPin;   // Pin für die LED Zustand Anzweig
    const byte servoPin;        // Pin für den Weichenservo
    const byte winkelG;         // Winkel für die Geradenstellung
    const byte winkelA;         // Winkel für die Abzweigtellung
    const bool grundStellung;   // Grundstellung beim Einschalten: 0=gerade, 1=Abzweig
    bool tasterAlt, tasterAkt;  // Tasterzustände alt und aktuell
    Servo8 weichenServo;        // Objekt der Bibliothek
  public:
    Weiche (const byte tasterPin,  const byte ledGeradePin,  const byte ledAbzweigPin,  const byte servoPin, const byte winkelG, const byte winkelA, const bool grundStellung)
      : tasterPin(tasterPin),  ledGeradePin(ledGeradePin),  ledAbzweigPin(ledAbzweigPin),  servoPin(servoPin), winkelG(winkelG), winkelA(winkelA), grundStellung(grundStellung), tasterAlt(0), tasterAkt(0), weichenServo() {}
    void init() {
      pinMode(tasterPin, INPUT_PULLUP);  // Taster schaltet nach GND
      pinMode(ledGeradePin, OUTPUT);
      pinMode(ledAbzweigPin, OUTPUT);
      weichenServo.attach(servoPin, true);            // Pin für den Weichenservo und Abschalten nach einer Sekunde
      weichenServo.setSpeed(ZUNGENGESCHWINDIGKEIT);   // Weichenzungengeschwindigkeit
      if (grundStellung) {
        weichenServo.write(winkelA);                    // definierten Anfangswinkel anfahren
      } else {
        weichenServo.write(winkelG);                    // definierten Anfangswinkel anfahren
      }
    }
    void stellen() {
      tasterAlt = tasterAkt;
      tasterAkt = digitalRead(tasterPin);
      if (weichenServo.moving() == 0) {
        byte winkel = weichenServo.read();
        if (winkel == winkelG) digitalWrite(ledGeradePin, HIGH);
        if (winkel == winkelA) digitalWrite(ledAbzweigPin, HIGH);
        if (tasterAlt && !tasterAkt) {
          Serial.print(F("Tastendruck Pin ")); Serial.print(tasterPin);
          if (winkel == winkelG) {
            Serial.print(F("\tWeiche Pin ")); Serial.print(servoPin); Serial.println(F(" abbiegen"));
            digitalWrite(ledGeradePin, LOW);
            weichenServo.write(winkelA);
          } else {
            Serial.print(F("\tWeiche Pin ")); Serial.print(servoPin); Serial.println(F(" gerade"));
            digitalWrite(ledAbzweigPin, LOW);
            weichenServo.write(winkelG);
          }
        }
      }
    }
};
Weiche weichen[] = {
  // tasterPin,  ledGeradePin,  ledAbzweigPin,  servoPin, winkelG, winkelA, Grundstellung
  {2, 6, 5, 9, 36, 85, 0}, // jede Zeile entspricht einer Weiche
  {3, 7, 4, 10, 30, 80, 1}
};
void setup() {
  Serial.begin(9600);
  Serial.println(F("Gleisschaltplan"));
  for (Weiche &w : weichen) w.init();
}

void loop() {
  for (Weiche &w : weichen) w.stellen();
}

Ob das nun anfängerfreundlich ist und dem TO hilft, wird sich herausstellen :slight_smile:

@wiliam_t_riker: Wenn Du die Werte in Weiche weichen = {} an Deine Hardware anpaßt, sollte das Programm funktionieren.

Hi

wiliam_t_riker:
Ja wird über die Hohldose mit strom versorgt. Also ein extra Netzteil mit 5 v für die Servos? Wieviel Ampere darf das netzteil max. ausspucken?

So viel, wie Du brauchst.
Nur solltest Du Dich vor Netzteilen mit wahnsinnigen Strömen (20A+) in Acht nehmen - Die schicken die 20A auch durch gaaanz dünne Drähte oder Arduino-Beinchen, wenn's denn 'Mal sein soll'.
Wobei man auch schon mit 'nur' 10A viel Unsinn anstellen kann - Dein Netzteil sollte also den Strom liefern können, Den Deine Servos brauchen werden, plus ein Bisschen Reserve.
Wenn die Servos nominal mit 6V betrieben werden, kann das Netzteil auch die 6V liefern - gibt auch Servos, Die noch mehr Spannung abkönnen, wenn Du aber über Solche stolperst, bist Du wahrscheinlich schon tiefer im Hobby drin. (ebenfalls nur von gelesen)

Die GND der Netzteile müssen alle miteinander (bevorzugt an nur EINEM Punkt) verbunden sein.

MfG

vielen Dank werde das mal probieren