3 Taster schalten je ein Relais und ein 4. Taster schaltet alle 3

namenloserxd · February 14, 2023, 5:19pm

Hallo zusammen,

nachdem ich hier in den letzten Tagen viel gelesen und gelernt hab, bin ich jetzt an einem Punkt an dem ich nicht mehr weiter komme. Somit hab ich mich jetzt angemeldet.

Also erstmal: Hallo an alle

Kurz zu meinem Projekt:
Ich möchte ein Mähwerk bauen. Ich hab mir schon einige Geräte selbst gebaut, welche auch super funktionieren. Diese Geräte waren bisher aber alle "Dumm". Das ist mein erstes Projekt, wo wirklich eine Intelligenz/Steuerung dahinter stecken soll. Preislich wie auch Größenhalber habe ich mich für ein Arduino Mega entschieden. Ohne Erfahrung mit der Programmierung habe begonnen ein Programm zu schrieben um das Gerät zu steuern.

Dazu möchte ich Taster verwenden. Heißt -> wenn ich Taster 1 drücke soll Relais 1 ein/ausschalten und auch bleiben. So auch mit Taster 2 und 3. Das hab ich durch eine "Selbsthaltung" der Taster realisiert.

Jetzt zum Problem:

Ich möchte, egal in welchem Zustand sich die Relais 1-3 befinden, mit Taster 4 sie jeweils alle 3 Relais ein- oder ausschalten. Aktuell blockiere ich mich aber mit den Tastern 1-3 selbst.
Ich möchte, wenn Taster 5 aktiv ist, dass:
Relais 1 = "HIGH" wird, wenn Sensor 1 = "HIGH"
Relais 2 = "HIGH" wird, wenn Sensor 2 = "HIGH"
Relais 3 = "HIGH" wird, wenn Sensor 3 = "HIGH"

Aber auch da blockiere ich mich gerade selbst mit den Tastern 1-3. Also an sich beides mal das selbe Problem, aber ich komme nicht drauf, wie ich das lösen kann.

Ich sehe mein Problem im letzten Abschnitt. Gekennzeichnet mit "Problem ab hier?"
Hier mein Code:

int LED1_PIN = 23;                  //LED linker Balken an/aus
int LED2_PIN = 22;                  //LED mittlerer Balken an/aus
int LED3_PIN = 21;                  //LED rechter Balken an/aus
int LED4_PIN = 19;                  //LED alle Balken an/aus
int LED5_PIN = 20;                  //LED automatik Balken an/aus
int RELAIS1_PIN = 18;               //Linker Balken an/aus
int RELAIS2_PIN = 17;               //Mittlerer Balken an/aus
int RELAIS3_PIN = 16;               //Rechter Balken an/aus
int RELAIS4_PIN = 1;                //Linker Balken hoch/runter
int RELAIS5_PIN = 1;                //Mittlerer Balken hoch/runter
int RELAIS6_PIN = 13;               //Rechter Balken hoch/runter
int BUTTON1_PIN = 2;                //Taster linker Balken an/aus
int BUTTON2_PIN = 3;                //Taster mittlerer Balken an/aus
int BUTTON3_PIN = 4;                //Taster rechter Balken an/aus
int BUTTON4_PIN = 5;                //Taster alle Balken an/aus
int BUTTON5_PIN = 6;                //Taster automatik Balken an/aus
int BUTTON6_PIN = 7;                //Taster Überbrücken
int SENSOR1_PIN = 7;                //Sensor linker Balken ausgehoben
int SENSOR2_PIN = 8;                //Sensor mittlerer Balken ausgehoben
int SENSOR3_PIN = 9;                //Sensor rechter Balken ausgehoben
int THUMBWHEEL11_PIN = 11;          //Daumenrad linker Balken hoch
int THUMBWHEEL12_PIN = 12;          //Daumenrad linker Balken runter
int THUMBWHEEL21_PIN = 13;          //Daumenrad mittlerer Balken hoch
int THUMBWHEEL22_PIN = 14;          //Daumenrad mittlerer Balken runter
int THUMBWHEEL31_PIN = 15;          //Daumenrad rechter Balken hoch
int THUMBWHEEL32_PIN = 16;          //Daumenrad rechter Balken runter
int THUMBWHEEL41_PIN = 17;          //Daumenrad alle Balken hoch
int THUMBWHEEL42_PIN = 18;          //Daumenrad alle Balken runter
int SPEEDSENSOR_PIN = 19;           //Drehzahlsensor

/*Taster zu Schalter:*/

bool Status_b1 = 0;
int Zaehler_b1 = 0;
bool letzterStatus_b1 = 0;

bool Status_b2 = 0;
int Zaehler_b2 = 0;
bool letzterStatus_b2 = 0;

bool Status_b3 = 0;
int Zaehler_b3 = 0;
bool letzterStatus_b3 = 0;

bool Status_b4 = 0;
int Zaehler_b4 = 0;
bool letzterStatus_b4 = 0;

bool Status_b5 = 0;
int Zaehler_b5 = 0;
bool letzterStatus_b5 = 0;

void button_switch(int& relais_pin, bool& current_state, int& button_counter, bool& last_state) 
{
  if (current_state != last_state && current_state == 1)
  {
    button_counter++;
  }

  else if (button_counter % 2 == 0)
  {
    digitalWrite(relais_pin, LOW);
    button_counter = 0;    
  }

  else
  {
    digitalWrite(relais_pin, HIGH);
  }
  last_state = current_state;
  Serial.println(button_counter);
}

/*LED blinken*/
  int ledState1 = LOW;
  long myTimer1 = 0;
  long myTimeout1 = 500;

  int ledState2 = LOW;
  long myTimer2 = 0;
  long myTimeout2 = 500;

  int ledState3 = LOW;
  long myTimer3 = 0;
  long myTimeout3 = 500;

  int ledState4 = LOW;
  long myTimer4 = 0;
  long myTimeout4 = 500;


void setup() {

/*Taster zu Schalter:*/

  Serial.begin(9600);

  pinMode(LED1_PIN, OUTPUT);
  pinMode(RELAIS1_PIN, OUTPUT);
  pinMode(BUTTON1_PIN, INPUT);

  pinMode(LED2_PIN, OUTPUT);
  pinMode(RELAIS2_PIN, OUTPUT);
  pinMode(BUTTON2_PIN, INPUT);
 
  pinMode(LED3_PIN, OUTPUT);
  pinMode(RELAIS3_PIN, OUTPUT);
  pinMode(BUTTON3_PIN, INPUT);

  pinMode(LED4_PIN, OUTPUT);
  pinMode(BUTTON4_PIN, INPUT);
 
  pinMode(LED5_PIN, OUTPUT);
  pinMode(BUTTON5_PIN, INPUT);

  pinMode(RELAIS4_PIN, OUTPUT);
  pinMode(RELAIS5_PIN, OUTPUT);
  pinMode(RELAIS6_PIN, OUTPUT);
  
  pinMode(SENSOR1_PIN, INPUT);
  pinMode(SENSOR2_PIN, INPUT);
  pinMode(SENSOR3_PIN, INPUT);

}
  
void loop() {

  /*Taster zu Schalter:*/

  Status_b1 = digitalRead(BUTTON1_PIN);
  Status_b2 = digitalRead(BUTTON2_PIN);
  Status_b3 = digitalRead(BUTTON3_PIN);
  Status_b4 = digitalRead(BUTTON4_PIN);
  Status_b5 = digitalRead(BUTTON5_PIN);

  button_switch(RELAIS1_PIN, Status_b1, Zaehler_b1, letzterStatus_b1);
  button_switch(RELAIS2_PIN, Status_b2, Zaehler_b2, letzterStatus_b2);
  button_switch(RELAIS3_PIN, Status_b3, Zaehler_b3, letzterStatus_b3);
  button_switch(LED4_PIN, Status_b4, Zaehler_b4, letzterStatus_b4);
  button_switch(LED5_PIN, Status_b5, Zaehler_b5, letzterStatus_b5);
  
  delay(50);

/*LED blinken / leuchten*/
if (digitalRead(RELAIS1_PIN) == LOW)                 //LED 1 blinken
{  
  if (millis() > myTimeout1 + myTimer1 ) {
    myTimer1 = millis();
    if (ledState1 == LOW) ledState1 = HIGH;
    else ledState1 = LOW;
    digitalWrite(LED1_PIN, ledState1);
  }
}
else{
  digitalWrite(LED1_PIN, HIGH);
    }

if (digitalRead(RELAIS2_PIN) == LOW)                 //LED 2 blinken
{  
  if (millis() > myTimeout2 + myTimer2 ) {
    myTimer2 = millis();
    if (ledState2 == LOW) ledState2 = HIGH;
    else ledState2 = LOW;
    digitalWrite(LED2_PIN, ledState2);
  }
}
else{
  digitalWrite(LED2_PIN, HIGH);
    }

if (digitalRead(RELAIS3_PIN) == LOW)                 //LED 1 blinken
{  
  if (millis() > myTimeout3 + myTimer3 ) {
    myTimer3 = millis();
    if (ledState3 == LOW) ledState3 = HIGH;
    else ledState3 = LOW;
    digitalWrite(LED3_PIN, ledState3);
  }
}
else{
  digitalWrite(LED3_PIN, HIGH);
    }


if (digitalRead(LED4_PIN) == LOW)                     //LED 4 aus? Abfrage
{  
  if (millis() > myTimeout4 + myTimer4 ) {
    myTimer4 = millis();
    if (ledState4 == LOW) ledState4 = HIGH;
    else ledState4 = LOW;
    digitalWrite(LED4_PIN, ledState4);
  }
}
  else{
  digitalWrite(LED1_PIN, HIGH);
  digitalWrite(LED2_PIN, HIGH);
  digitalWrite(LED3_PIN, HIGH);

//Problem ab hier?

  digitalWrite(RELAIS1_PIN, LOW);             //Mähwerke an
  digitalWrite(RELAIS2_PIN, LOW);
  digitalWrite(RELAIS3_PIN, LOW);
  }


    /*Automatik ein/aus Mähwerke*/
  if (digitalRead(Status_b1) == 1 && (SENSOR1_PIN) == HIGH && (RELAIS1_PIN) == LOW)
  {
  digitalWrite(RELAIS1_PIN, HIGH);  
  }

  if (digitalRead(Status_b2) == 1 && (SENSOR2_PIN) == HIGH && (RELAIS2_PIN) == LOW)
  {
  digitalWrite(RELAIS2_PIN, HIGH);  
  }

  if (digitalRead(Status_b3) == 1 && (SENSOR3_PIN) == HIGH && (RELAIS3_PIN) == LOW)
  {
  digitalWrite(RELAIS3_PIN, HIGH);  
  }
}

Ich bin mir sicher, dass sich einiges leichter oder besser lösen lässt, aber für das erste Programm ist es denke ich mal nicht so schlecht.

Danke schonmal für eure Hilfe

Tommy56 · February 14, 2023, 5:25pm

Meinst Du damit eine Hardware-Selbsthaltung?
Weil ein Ausgabe-Pin behält seinen Zustand, bis Du ihn änderst. Dazu musst Du nicht extra etwas tun.

Beim Taster 4: Was soll der machen, wenn 1 Aus und 2 Ein sind?
Welche Sensoren meinst Du bei Taster 5?

Gruß Tommy
Gruß Tommy

noiasca · February 14, 2023, 5:34pm

das müsstest du besser erklären.

Was wäre wenn RelaisA eingeschaltet wurde, und RelaisB und RelaisC noch ausgeschaltet sind.
Was soll dann ein Tastendruck auf TasteD machen ... zunächst alle 3 Relais einschalten oder alle 3 ausschalten (obwohl nur Relais A ein ist).

Mit welchem Microcontroller arbeitest du (weil Pin = 14 ... wo ist der bei dir?)

namenloserxd · February 14, 2023, 5:39pm

Nein eine Softwarelösung. Über Status, Zähler und letzter Status "schalte" ich mit den Tastern. Ich möchte ja nur kurz tasten und die Relais sollen so geschalten werden, bis ich wieder einen Taster betätige.
Am liebsten wäre mir, wenn ich Taster 4 betätige, erstmal alle 3 Relais an gehen und bei erneutem drücken aus gehen.
Über kapazitive Sensoren möchte ich die Relais 1-3 schalten. Das allerdings nur wenn Taster 5 eingeschalten ist. Das ist der unterste Block im Programm.

-ich arbeite mit einem Arduino Mega

paulpaulson · February 14, 2023, 5:40pm

Hallo namenloserxd

Ja, es läßt sich extrem schlanker in der objektorientierten Programmierung umsetzen.
Das Programm hat Balken in verschieden Orientierungen. Daraus läßt sich prima ein Objekt mit den relevanten Ausprägungen definieren.
Ein Service kümmert sich entweder ereignis- oder zeitgesteuert um diese Objekte.

Tommy56 · February 14, 2023, 5:43pm

Das heißt, wenn Taster 5 eingeschaltet ist, sind die Taster 1-4 wirkungslos.

Gruß Tommy

namenloserxd · February 14, 2023, 5:44pm

@paulpaulson Also da verstehe ich nur Bahnhof😅

@Tommy56 ja genau. Sorry hab ich vergessen so zu schreiben

herbk · February 14, 2023, 5:47pm

Ich denke die Aufgabe ist zu komplex um sie nur im Loop (überschaubar) abzuarbeiten.
Das ganze in Funktionen aufteilen die nur dann angesprungen werden wenn eine "besondere" Aktion gewünscht ist wie z.B. alle Schalter aus.
Im Loop nur die Eingänge abfragen.

Wie Tommy56 schon geschrieben hat. Der Zustand des Ausgangs bleibt bestehen auch wenn der Taster wieder losgelassen ist.

herbk · February 14, 2023, 5:51pm

Sozusagen als "Hautschalter" ?

Btw.: Willst Du das Mähwerk elektrisch betreiben oder hydraulisch?

Tommy56 · February 14, 2023, 5:53pm

Ok.
Dann würde ich für jeden Taster und jeden Ausgang eine Statusvariable vom Typ boolean (AN/AUS - 1/0) vorsehen.
Zuerst im Loop den Taster 5 abfragen und dessen Zustand setzen.
Wenn 5==AN, die Sensoren steuern die Zustände der Ausgänge
ansonsten
Taster 4 Abfragen und dessen Zustand setzen. Wenn er seinen Zustand wechselt (alt != neu) , in Abhängigkeit davon die Ausgangszustände setzen.
Ansonsten die Tasten 1-3 auf die Ausgangszustände wirken lassen.

Am Ende die Ausgänge in Abhängigkeit der Ausgangszustände schalten.

Das Zusammenspiel von 1-3 und 4 ist nicht eindeutig.

Das mal als Denkansatz.

Gruß Tommy

noiasca · February 14, 2023, 5:56pm

mal Schritt 1 nur Taster A-C und D.

noiasca · February 14, 2023, 5:58pm

was soll passieren, wenn Taster E losgelassen wird? Alle Ausgänge abfallen lassen oder eingeschaltet lassen?

noiasca · February 14, 2023, 6:04pm

da hats wohl auch was - zweimal Pin 7???

herbk · February 14, 2023, 6:15pm

Das hatte ich vorhin überlesen...
Meine Idee zur Funktion:
Die Taster 1 bis 4 sind zum manuellen schalten (testen) der Mähantriebe
Taster 5 sagt ab jetzt arbeiten wir, die Mähantriebe werden jetzt nicht mehr von den Tastern sondern von den Sensoren die an den Mähbalken sind gesteuert

??

Ich denke etwas mehr Erklärung zur gedachten Funktion würde wirklich helfen...

noiasca · February 14, 2023, 6:22pm

ach blinken soll das auch noch je eingeschaltetem Relais? ... na dann werden wir noch 'ne Blinkklasse bauen

namenloserxd · February 14, 2023, 6:28pm

@herbk puh die Funktionen hab ich noch nicht kapiert.
Das Mähwerk soll hydraulisch betrieben werden. Die Ventile sollen über die Relais geschaltet werden.
Ne ich die Tasten 1-4 sind nicht zum testen der Antriebe sondern auch wirklich um damit zu arbeiten. Es kann sein, dass ich mal nur mit einem oder zwei arbeiten will und dann ohne Automatik. Automatik soll nur sein, wenn die Wiese groß genaug ist

@noiasca Taster E/5 ist auch ein "Schalter". Heißt: einmal betätigen: Automatik ein, zweites mal: Automatik aus.
Das ist nicht so wild, weil der sechste Taster nicht angeschlossen ist. Ist nur Platzhalter.
Ja blinken auch noch, das funktioniert auch😁

noiasca · February 14, 2023, 6:50pm

mit blinki blink:

zum Pulldown Resistor setzen bin ich jetzt zu faul. Wird es aber bei HIGH active Schalter/Taster brauchen.

/*
    Drei Taster schalten je ein Relais
    Ein Mastertaster (schwarz unten) schaltet alle Relais
    Ein Automatik Schalter (der Slider links) schaltet abhängig von Sensoren
    3 "Relais"
    3 "Blink LEDs"
    3 Sensor Schalter (die Slider rechts)

    https://forum.arduino.cc/t/3-taster-schalten-je-ein-relais-und-ein-4-taster-schaltet-alle-3/1090208/

    by noiasca
    to be deleted 2023-04
    code im Forum
*/

class Blink {
    const uint8_t pin;             // the pin for the LED
    uint32_t previousMillis = 0;   // last timestamp
    uint16_t interval = 500;       // blink interval
    uint8_t state = 0;             // 0 no blink, 1 blink on, 2 blink but off phase
  public:
    Blink(uint8_t pin) : pin(pin) {}

    void begin() {
      pinMode(pin, OUTPUT);
    }

    void on() {
      state = 2;  // we start with off phase which will cause an immidiate "on" blink phase
    }

    void off() {
      state = 0;
      digitalWrite(pin, LOW);
    }

    void update(uint32_t currentMillis = millis())
    {
      if (state > 0) {
        if (currentMillis - previousMillis > interval) {
          previousMillis = currentMillis;
          if (state == 1) {
            state = 2;
            digitalWrite(pin, LOW);
          }
          else {
            state = 1;
            digitalWrite(pin, HIGH);
          }
        }
      }
    }
};

class Button {                                   // class to debounce switches
    const uint8_t buttonPin;                        // the pin for the button
    static constexpr uint8_t debounceDelay = 20;    // the debounce time - one value for all buttons (hence "static")
    const bool active;                           // is the button HIGH or LOW active
    bool lastButtonState = HIGH;                 // previous state of pin
    uint8_t lastDebounceTime = 0;                   // previous debounce time (we just need short debounce delay, so the rollover of the byte variable works fine and spares 3 bytes compared to an unsigned long)

  public:
    Button(uint8_t attachTo, bool active = LOW) : buttonPin(attachTo), active(active) {}

    void begin() {                               // sets the pinMode and optionally activates the internal pullups
      if (active == LOW)
        pinMode(buttonPin, INPUT_PULLUP);
      else
        pinMode(buttonPin, INPUT);
    }

    bool wasPressed() {
      bool buttonState = LOW;
      uint8_t reading = LOW;
      if (digitalRead(buttonPin) == active) reading = HIGH;
      if (((millis() & 0xFF ) - lastDebounceTime) > debounceDelay) {
        if (reading != lastButtonState && lastButtonState == LOW) {
          buttonState = HIGH;
        }
        lastDebounceTime = millis() & 0xFF;   // we store just the last byte from millis()
        lastButtonState = reading;
      }
      return buttonState;
    }
};

Button masterButtonPin {5, HIGH};                      // the high active master button
Button buttonPin[] {{2, HIGH}, {3, HIGH}, {4, HIGH}};  // pins for high active buttons
Blink blinkLed[] {23, 22, 21};                         // blink LEDs
const uint8_t relayPin[] {18, 17, 16};                 // pins for relays
const uint8_t sensorPin[] {7, 8, 9};                   // pins for sensor input (in the demo - slider switches)
const uint8_t automaticPin {6};                        // a switch

bool masterState = false;  // remember master State (overall on or overall off)

void setup() {
  Serial.begin(115200);
  masterButtonPin.begin();
  for (auto &i : buttonPin) i.begin();
  for (auto &i : blinkLed) i.begin();
  for (auto &i : relayPin) pinMode(i, OUTPUT);
  for (auto &i : sensorPin) pinMode(i, INPUT);
  pinMode(automaticPin, INPUT);
}

void loop() {
  // auf einzelne Tastendrücke reagieren
  for (int i = 0; i < sizeof(buttonPin) / sizeof(buttonPin[0]); i++)
  {
    if (buttonPin[i].wasPressed()) {
      digitalWrite(relayPin[i], HIGH);
      blinkLed[i].on();
    }
  }

  // auf MasterButton reagieren
  if (masterButtonPin.wasPressed()) {
    masterState = !masterState;
    Serial.print(F("masterState=")); Serial.println(masterState);
    for (int i = 0; i < sizeof(relayPin)/sizeof(relayPin[0]); i++) {
      if (masterState == true ) {
        digitalWrite(relayPin[i], HIGH) ;
        blinkLed[i].on();
      }
      else {
        digitalWrite(i, LOW);
        blinkLed[i].off();
      }
    }
  }

  // gem. Sensor und Automatikschalter reagieren
  static uint8_t previousAutomatic = LOW;
  uint8_t currentAutomatic = digitalRead(automaticPin);
  if (currentAutomatic == HIGH && previousAutomatic == LOW) {
    Serial.println(F("automatik modus ein - abhängig von den Sensordaten"));
    for (int i = 0; i < sizeof(sensorPin) / sizeof(sensorPin[0]); i++) {
      if (digitalRead(sensorPin[i]) == HIGH) {
        digitalWrite(relayPin[i], HIGH);
        blinkLed[i].on();
      }
    }
  }
  else if (currentAutomatic == LOW && previousAutomatic == HIGH) {
    Serial.println(F("automatik modus aus"));
    for (int i = 0; i < sizeof(sensorPin) / sizeof(sensorPin[0]); i++) {
      digitalWrite(relayPin[i], LOW);
      blinkLed[i].off();
    }
  }
  previousAutomatic = currentAutomatic;

  // handle the blink LEDs
  for (auto &i : blinkLed) i.update();
}

wenn ich dir einen abschließenden Tipp geben darf:

NIE Variablen durchzählen.
Schon gar nicht mit 1 zum zählen beginnen (Daher schrieb ich A, B, C ... )
Das deutet meistens auf Arrays hin.

Arrays sind deine neuen Freunde.

und ja, das geht alles noch schöner.
Aber es langt fürs erste.

herbk · February 14, 2023, 7:12pm

Dann mal Einlesen, das macht den Code deutlich übersichtlicher und resistenter gegen Fehler (geht mir zumindest so).
Hier mal ein kleiner Codeschnipsel an dem ich gerade sitze als Beispiel. Hier soll etwas gemacht werden wenn innerhalb einer bestimmten (Umlauf)Zeit ein Signal kommt.
Im Loop messe ich nur die Umlaufzeit und prüfe auf die Bedingung. Ist sie war, dann wird erst die Funktion "machwas" und dann die Funtion "Ausgabe" angesprungen.
Ist die Bedingung nicht war wird auch nirgends hin gesprungen sondern der Lopp wieder von vorne abgearbeitet.

Du siehst in dem Beispiel auch dass "machwas" nur angesprungen wird wenn 2 Bedingungen war sind.
Für das Umschalten von Manuell auf Automatik müsste die Bedingung dann etwa so aussehen:

  if (Taster5 == LOW && Taster1 == HIGH) {            
    digitalwrite(Relais1, HIGH );                                        
  }

Das schaltet jetzt nur ein, nicht beim nächsten Tasterdruck wieder aus, den Codeschnipsel dafür habe ich nicht im Kopf, da muss ich nachgucken...

void loop() {

  if ( digitalRead(3) == HIGH )                       // IR Sensor überwachen und bei Signal Millis merken
  {
    zeit = millis();
  }


  laufzeitalt = laufzeit;                             // macht die aktuelle Rundenzeit zur alten Rundenzeit
  laufzeit = zeit - altzeit;                          // Zeit (Millis) für eine Umdrehung
  differenz = laufzeit - laufzeitalt;                 // vergleicht die Zeit der aktuellen Runde mit der davor
  altzeit = zeit;                                     //aktuelle Zeit zur vorhergehenden Zeit machen

  if (differenz >100 && differenz <1000) {            //wird nur ausgeführt wenn die Zeit zwischen zwei Runden innerhalb der Bedingungen ist
    machwas();                                        //muss an den Rotor / Generator angepasst werden!
    ausgabe;

  }

}


void ausgabe()    {

  lcd.setCursor(0, 0);
  lcd.print("                   ");               
  lcd.setCursor(0, 0);
  lcd.print("Laufzeit: ");                          
  lcd.print(laufzeit);                               
  lcd.setCursor(0, 1);
  lcd.print("                   ");             
  lcd.setCursor(0, 1);
  lcd.print("Lz. alt:  ");                         
  lcd.print(laufzeitalt);                               

  lcd.setCursor(0, 2);
  lcd.print("                   ");                    
  lcd.setCursor(0, 2);
  lcd.print("Differenz ");                           
  lcd.print(differenz);                               

}


void machwas()   {                          


  if (laufzeit < laufzeitalt && strang1 == HIGH )                     //schaltet Strang 2 zu wenn Strang 1 auf volllast und Drehzahl weiter steigt
  {
    digitalWrite(strang2, HIGH);
  }
  else if (laufzeit > laufzeitalt && strang2 == HIGH)                 
  {
    digitalWrite(strang2, LOW);
  }
  else if (laufzeit < laufzeitalt && strang1 == LOW)
  {
    digitalWrite(strang1, HIGH);
  }
  else
  {
    digitalWrite(strang1, LOW);
  }


}

Automatik soll nur sein, wenn die Wiese groß genaug ist
OK, damit ist das klar... Und ich denke wir reden von 3m (oder so) Schnittbreite je Balken
Da würde ich die Ventile aber nicht nur schalten sondern über Stellantriebe auf und zu fahren, einfach auf zu ist zu hart.

herbk · February 14, 2023, 7:18pm

Weshalb ?

noiasca · February 14, 2023, 7:18pm

Das deutet meistens auf Arrays hin.
Soll heißen, Arrays sind dann meist der einfachere Weg - und man kommt dann öfter ohne Codeduplikate aus.

wert1
wert2
wert3

das SCHREIT nach einem Array
wert[3]
dessen Felder von 0 bis 2 zu zählen sind.

Ergo für mich: Einfach nicht machen. Nachdenken wie es besser geht.

Topic		Replies	Views
Mit 6 Taster 14 Ausgänge schalten Deutsch	10	542	September 25, 2022
mehrere Relais mit mehreren Tastern schalten...... Deutsch	25	5992	May 6, 2021
4 Taster 4 Relais An/Aus schalten Deutsch	15	8002	May 6, 2021
Arduino Leonardo Zwei taster zwei-kanal-Relais-Modul Deutsch	8	3810	May 6, 2021
Einsteiger braucht Programmierhilfe Deutsch	34	14952	May 6, 2021

3 Taster schalten je ein Relais und ein 4. Taster schaltet alle 3

Related topics