1 Relais mit 2 verschiedene Blinkraten

Hallo,

ich habe erst kurz vor mit Arduino angefangen um eine Heizungssteuerung für meine Werkstatt zu programmieren und bis jetzt konnte ich noch alles über die Forums Suche finden was ich brauchte. Bis jetzt…

Und Zwar möchte ich gern eine Signalhupe ertönen lassen bei einer gewissen Temperatur in einem schnellen Intervall. Und wenn ich Nachlegen muss in einem langsamen Intervall.

Hab das auch schon versucht zu programmieren, aber in keinem der Beiden Zustände zieht das Relais für die Hupe. Die Kontrol-LED leuchtet sehr sehr schwach und nur für Bruchteile von Sekunden.
Mit nur einem Intervall programmiert funktioniert es ohne Problem.

Hier mein Programm in Auszügen:

Edit: Update vom Programm siehe Post 5


const int P1 = 34; //Signalhorn Warnung
const int P2 = 34; //Signalhorn Nachlegen


// Blinker
//-----------------------------------------------------

int P1WarnungState = LOW;
unsigned long P1WarnungMillis = 0;
long P1WarnungAn = 500;
long P1WarnungAus = 1000;

int P2NachlegenState = LOW;
unsigned long P2NachlegenMillis = 0;
long P2NachlegenAn = 5000;
long P2NachlegenAus = 3000;


void loop() {

// P1 - Signalhorn (Warnung)
//-----------------------------------------------------

if (((M4 == 1) || (M5 == 1)) && (P1WarnungState == HIGH) && (currentMillis - P1WarnungMillis >= P1WarnungAn))
{
 P1WarnungState = LOW;  // Turn it off
 P1WarnungMillis = currentMillis;  // Remember the time
 digitalWrite(P1, P1WarnungState);  // Update the actual LED
}
else if (((M4 == 1) || (M5 == 1)) && (P1WarnungState == LOW) && (currentMillis - P1WarnungMillis >= P1WarnungAus))
{
 P1WarnungState = HIGH;  // turn it on
 P1WarnungMillis = currentMillis;   // Remember the time
 digitalWrite(P1, P1WarnungState);    // Update the actual LED
}

if ((M4 == 0) && (M5 == 0)) {
 digitalWrite(P1, HIGH);
}


// P2 - Signalhorn (Nachlegen)
//-----------------------------------------------------

if (((M6 == 1)) && (P2NachlegenState == HIGH) && (currentMillis - P2NachlegenMillis >= P2NachlegenAn))
{
 P2NachlegenState = LOW;  // Turn it off
 P2NachlegenMillis = currentMillis;  // Remember the time
 digitalWrite(P2, P2NachlegenState);  // Update the actual LED
}
else if (((M6 == 1) || (M5 == 1)) && (P2NachlegenState == LOW) && (currentMillis - P2NachlegenMillis >= P2NachlegenAus))
{
 P2NachlegenState = HIGH;  // turn it on
 P2NachlegenMillis = currentMillis;   // Remember the time
 digitalWrite(P2, P2NachlegenState);    // Update the actual LED
}

if ((M6 == 0)) {
 digitalWrite(P2, HIGH);
}


// Uebertemperaturmeldung
//-----------------------------------------------------

if (BT1Temp >= Uebertemperatur) {
 (M4=1);
}

if (BT1Temp < Uebertemperatur) {
 (M4=0);
}

// Vorlauf gleich Rücklauf Warnung
//-----------------------------------------------------

if ((BT1Temp <= BT2Temp) && ((BT1Temp >= 30) || (BT2Temp >= 30))) {
 (M5=1);
}

if ((BT1Temp > BT2Temp) || ((BT1Temp < 30) && (BT2Temp < 30))) {
 (M5=0);
}


// Nachlegen
//-----------------------------------------------------

if ((BT1Temp <= Nachlegetemperatur)  && (M2 == 1) && (M4 == 0) && (M5 == 0)) {
 (M6=1);
}

if ((BT1Temp > Nachlegetemperatur + 2) || (M2 == 0)) {
 (M6=0);
 
}

Danke im Voraus für eure Hilfe

du solltest deine Ausgänge auch als OUTPUT deklarieren.

ardubu:
du solltest deine Ausgänge auch als OUTPUT deklarieren.

Sind sie, hab es jetzt nur nicht hier reingeschrieben. Funktioniert ja wie gesagt schon beim verwenden von nur einem Intervall.
Hab es jetzt editiert in meinem Beitrag.

Setze Deinen Sketch bitte in Codetags (</> oben links im Forumseditor). Damit ist er von allen vernünftig lesbar und Du hast mehr potentielle Helfer.

Gruß Tommy

Hab es jetzt editiert in meinem Beitrag

Wo?
Und wenn du es tust, dann pack das Ganze doch auch gleich in Codetags ( </> )

Auszüge kannst du gerne machen, indem du überflüssiges entfernst oder vereinfachst, so dass das Ganze noch kompiliert und den Fehler zeigt. Die Definition verwendeter Variablen ist übrigens nie überflüssig.

Ob ein Output-Pin eine LED normal, schwach oder garnicht leuchten lässt, ist nur selten eine Frage von ausführbaren Anweisungen in loop(). Oft eher ein Problem in der Verdrahtung und Stromversorgung.

const int P1 = 34; //Signalhorn Warnung
const int P2 = 34; //Signalhorn Nachlegen

Überlagern verschiedener Blinkfrequenzen auf einem Pin geht nicht so einfach, fürchte ich…

Wo?
Und wenn du es tust, dann pack das Ganze doch auch gleich in Codetags ( </> )

Konnte es nach meinem Post nicht mehr editieren weil ich 5min warten musste :confused:

Ob ein Output-Pin eine LED normal, schwach oder garnicht leuchten lässt, ist nur selten eine Frage von ausführbaren Anweisungen in loop(). Oft eher ein Problem in der Verdrahtung und Stromversorgung.

An der Verkablung oder Stromversorgung kann es nicht liegen da, wie schon mehrfach gesagt, es mit nur einer Blinkrate perfekt funktioniert.

Setze Deinen Sketch bitte in Codetags (</> oben links im Forumseditor). Damit ist er von allen vernünftig lesbar und Du hast mehr potentielle Helfer.

Gruß Tommy

Danke für den Tipp hab ich noch nicht gewusst.

So ich hoffe diesmal ist alles drin.


// Werte
//-----------------------------------------------------

const int Normaltemperatur = 80;
const int Austemperatur = 30;
const int Warntemperatur = 103;
const int LueftertemperaturAn = 80;
const int LueftertemperaturAus = 70;
const int Uebertemperatur = 103;
const int Nachlegetemperatur = 70;


// Werte
//-----------------------------------------------------

#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 1
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);


// Taster
//-----------------------------------------------------

const int S1 = 3; //Modus Zurücksetzen
const int S2 = 4; //Anheizen
const int S3 = 5; //Normalbetrieb
const int S4 = 6; //Herunterfahren
const int S5 = 7; //Nachgelegt


// Analog Eingänge
//-----------------------------------------------------

int BT1 = A3; //Vorlauf Sensor
int BT2 = A4; //Rücklauf Sensor
int BT1Sensor;
int BT2Sensor;
int BT1Temp = 0;
int BT2Temp = 0;


// Ausgänge
//-----------------------------------------------------

const int KT1 = 23; //Selbsthaltung "Kein Modus"
const int WP1 = 31; //Wasserpumpe 1
const int WP2 = 30; //Wasserpumpe 2
const int WP3 = 33; //Wasserpumpe 3
const int ML1 = 35; //Motorlüfter
const int P1 = 34; //Signalhorn Warnung
const int P2 = 34; //Signalhorn Nachlegen
const int P3 = 22; //Meldeleuchte Rot
const int P4 = 25; //Meldeleuchte Gelb
const int P5 = 24; //Meldeleuchte Grün



// Tasterzustände
//-----------------------------------------------------

int S1State = 0;
int S2State = 0;
int S3State = 0;
int S4State = 0;
int S5State = 0;


// Merker
//-----------------------------------------------------

int M1 = 0; //Anheizen
int M2 = 0; //Normal
int M3 = 0; //Herunterfahren
int M4 = 0; // Uebertemperaturmeldung
int M5 = 0; // Vorlauf gleich Rücklauf Warnung
int M6 = 0; // Nachlegen


// Blinker
//-----------------------------------------------------

int P1WarnungState = LOW;
unsigned long P1WarnungMillis = 0;
long P1WarnungAn = 500;
long P1WarnungAus = 1000;

int P2NachlegenState = LOW;
unsigned long P2NachlegenMillis = 0;
long P2NachlegenAn = 5000;
long P2NachlegenAus = 3000;

int P3State = LOW;
unsigned long P3Millis = 0;
long P3An = 500;
long P3Aus = 500;

int P4State = LOW;
unsigned long P4Millis = 0;
long P4An = 1200;
long P4Aus = 1200;

int P5State = LOW;
unsigned long P5Millis = 0;
long P5An = 1000;
long P5Aus = 1000;

// LCD Display
//-----------------------------------------------------

#include <Wire.h>
#include <LiquidCrystal_I2C.h>



// Belegung für 16x4 LCD-Modul QC2204A
// mit Sainsmart LCD2004 I2C-Controller
LiquidCrystal_I2C  lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);


void setup() {

  digitalWrite(WP1, HIGH);
  digitalWrite(WP2, HIGH);
  digitalWrite(WP3, HIGH);
  digitalWrite(ML1, HIGH);
  digitalWrite(P1, HIGH);
  digitalWrite(P2, HIGH);
  digitalWrite(P3, HIGH);
  digitalWrite(P4, HIGH);
  digitalWrite(P5, HIGH);
  
  pinMode(S1, INPUT);
  pinMode(S2, INPUT);
  pinMode(S3, INPUT);
  pinMode(S4, INPUT);
  pinMode(S5, INPUT);

  pinMode(KT1, OUTPUT);
  pinMode(WP1, OUTPUT);
  pinMode(WP2, OUTPUT);
  pinMode(WP3, OUTPUT);
  pinMode(ML1, OUTPUT);
  pinMode(P1, OUTPUT);
  pinMode(P2, OUTPUT);
  pinMode(P3, OUTPUT);
  pinMode(P4, OUTPUT);
  pinMode(P5, OUTPUT);

  Serial.begin(9600);

  lcd.begin(20,4);
  lcd.setCursor(1,1);
  lcd.print("Heizungssteuerung");
  lcd.setCursor(3,2);
  lcd.print("wird geladen..");
  delay(2000);
  lcd.clear();


  // Starte Temperatursensor

  sensors.begin();
  
}

void loop() {
  S1State = digitalRead(S1);
  S2State = digitalRead(S2);
  S3State = digitalRead(S3);
  S4State = digitalRead(S4);
  S5State = digitalRead(S5);
  unsigned long currentMillis = millis();

  BT1Sensor = analogRead(BT1);
  BT2Sensor = analogRead(BT2);
  BT1Temp = map(BT1Sensor, 470, 0, 0, 125);
  BT2Temp = map(BT2Sensor, 390, 0, 0, 125);

   int sensorValue = analogRead(A4);
  // print out the value you read:
  Serial.println(sensorValue);

  lcd.home();

  sensors.requestTemperatures();


// P1 - Signalhorn (Warnung)
//-----------------------------------------------------

if (((M4 == 1) || (M5 == 1)) && (P1WarnungState == HIGH) && (currentMillis - P1WarnungMillis >= P1WarnungAn))
{
  P1WarnungState = LOW;  // Turn it off
  P1WarnungMillis = currentMillis;  // Remember the time
  digitalWrite(P1, P1WarnungState);  // Update the actual LED
}
else if (((M4 == 1) || (M5 == 1)) && (P1WarnungState == LOW) && (currentMillis - P1WarnungMillis >= P1WarnungAus))
{
  P1WarnungState = HIGH;  // turn it on
  P1WarnungMillis = currentMillis;   // Remember the time
  digitalWrite(P1, P1WarnungState);    // Update the actual LED
}

if ((M4 == 0) && (M5 == 0)) {
  digitalWrite(P1, HIGH);
}



// P2 - Signalhorn (Nachlegen)
//-----------------------------------------------------

if (((M6 == 1)) && (P2NachlegenState == HIGH) && (currentMillis - P2NachlegenMillis >= P2NachlegenAn))
{
  P2NachlegenState = LOW;  // Turn it off
  P2NachlegenMillis = currentMillis;  // Remember the time
  digitalWrite(P2, P2NachlegenState);  // Update the actual LED
}
else if (((M6 == 1) || (M5 == 1)) && (P2NachlegenState == LOW) && (currentMillis - P2NachlegenMillis >= P2NachlegenAus))
{
  P2NachlegenState = HIGH;  // turn it on
  P2NachlegenMillis = currentMillis;   // Remember the time
  digitalWrite(P2, P2NachlegenState);    // Update the actual LED
}

if ((M6 == 0)) {
  digitalWrite(P2, HIGH);
}



//P3 - Meldeleuchte Rot
//-----------------------------------------------------

if (((M5 == 1) || (M4 == 1)) && (P3State == HIGH) && (currentMillis - P3Millis >= P3An))
{
  P3State = LOW;  // Turn it off
  P3Millis = currentMillis;  // Remember the time
  digitalWrite(P3, P3State);  // Update the actual LED
}
else if (((M5 == 1) || (M4 == 1)) && (P3State == LOW) && (currentMillis - P3Millis >= P3Aus))
{
  P3State = HIGH;  // turn it on
  P3Millis = currentMillis;   // Remember the time
  digitalWrite(P3, P3State);    // Update the actual LED
}

if ((M5 == 0) && (M4 == 0)) {
  digitalWrite(P3, HIGH);
}


// P4 - Meldeleuchte Gelb
//-----------------------------------------------------

if ((M6 == 1) && (P4State == HIGH) && (currentMillis - P4Millis >= P4An))
{
  P4State = LOW;  // Turn it off
  P4Millis = currentMillis;  // Remember the time
  digitalWrite(P4, P4State);  // Update the actual LED
}
else if ((M6 == 1) && (P4State == LOW) && (currentMillis - P4Millis >= P4Aus))
{
  P4State = HIGH;  // turn it on
  P4Millis = currentMillis;   // Remember the time
  digitalWrite(P4, P4State);    // Update the actual LED
}

if (M6 == 0) {
  digitalWrite(P4, HIGH);
}


// P5 - Meldeleuchte Grün
//-----------------------------------------------------

if (((M1 == 1) || (M2 == 1)) && ((M3 == 0) || (M4 == 0) || (M5 == 0))) {
  digitalWrite(P5, LOW);
}

else {
  digitalWrite(P5, HIGH);



}

// Uebertemperaturmeldung
//-----------------------------------------------------

if (BT1Temp >= Uebertemperatur) {
  (M4=1);
}

if (BT1Temp < Uebertemperatur) {
  (M4=0);
}

// Vorlauf gleich Rücklauf Warnung
//-----------------------------------------------------

if ((BT1Temp <= BT2Temp) && ((BT1Temp >= 30) || (BT2Temp >= 30))) {
  (M5=1);
}

if ((BT1Temp > BT2Temp) || ((BT1Temp < 30) && (BT2Temp < 30))) {
  (M5=0);
}


// Nachlegen
//-----------------------------------------------------

if ((BT1Temp <= Nachlegetemperatur)  && (M2 == 1) && (M4 == 0) && (M5 == 0)) {
  (M6=1);
}

if ((BT1Temp > Nachlegetemperatur + 2) || (M2 == 0)) {
  (M6=0);
  
}

Gut, jetzt kann ich das auch lesen.

Mich wundert, dass du weder deine Dallas Sensoren nutzt, noch das LCD.
Zwecks Vereinfachung, würde ich den Kram erstmal raus werfen.

Übrigens Vereinfachung...
Deine Bedingungen sind mir zu kompliziert.
Und dir offensichtlich auch.

Da würde ich ansetzen!

Auch M1 bis M6 ...
Gib ihnen bitte vernünftige Namen. Im Kommentar hast du doch die richtigen Bezeichner.
So ist das kaum verstehbar.

Und Zwar möchte ich gern eine Signalhupe ertönen lassen bei einer gewissen Temperatur in einem schnellen Intervall. Und wenn ich Nachlegen muss in einem langsamen Intervall.

Die Beschreibung ist (für mich) nicht ausreichend.
Das Programm macht doch noch viel mehr.

Danke, ( DallasTemperature sensors ist übrigens zur Zeit überflüssig ) :wink:

Und jetzt änderst du bitte

const int P1 = 34; //Signalhorn Warnung
const int P2 = 34; //Signalhorn Nachlegen

auf zwei verschiedene freie Pins und schließt da LEDs dran an...

Wenn du in einem loop Durchlauf den gleichen Pin gleichzeitig HIGH und LOW setzt, ist das Ergebnis AN, AUS oder MITTELSCHWACH, was genau bei dir zu sehen ist, soll erstmal egal sein.
( Was willst du denn in solch einem Fall sehen? )

In Bezug auf Sketch in #5: Nach sensors.requestTemperatures(); sollte eine Temperaturabfrage wie sensors.getTempCByIndex(0); folgen, die ich vermisse.

Danke, ( DallasTemperature sensors ist übrigens zur Zeit überflüssig ) :wink:

Bitte, Ja ist zurzeit überflüssig hab ich vergessen wegzulassen :slight_smile: Sind halt ein paar hundert Zeilen. :confused:

auf zwei verschiedene freie Pins und schließt da LEDs dran an...

Probiere ich sofort.

Wenn du in einem loop Durchlauf den gleichen Pin gleichzeitig HIGH und LOW setzt, ist das Ergebnis AN, AUS oder MITTELSCHWACH, was genau bei dir zu sehen ist, soll erstmal egal sein.
( Was willst du denn in solch einem Fall sehen? )

Ich möchte bei Übertemperatur das die Hupe z.B.: mit 2Hz hupt (schneller Takt) und wenn Holz (Holzofen) Nachgelegt werden soll ein Hupeton in der Minute oder so.
Und in meinen Signalmeldungen ist es eigentlich so programmiert das P1 und P2 nie zur gleichen Zeit HIGH sind.

Zu meinen Merker:
M4: Übertemperatur
M5: Vorlauf kleiner Rücklauf

Wenn einer dieser beider HIGH ist, dann soll schnell gehupt werden.

M6: Temperatur unter 70°C gefallen somit bitte Nachlegen.
Also Einmal in der Minute hupen solange bis wir wieder über 80°C sind.

Und in meinen Signalmeldungen ist es eigentlich so programmiert das P1 und P2 nie zur gleichen Zeit HIGH sind.

Darfst halt, wenn einer HIGH ist, den anderen nicht LOW setzen, sondern musst ihn unverändert lassen.

Wann (ob) das der Fall ist, ist mir auch zu kompliziert mit deinen vielen Merkern.

Oder nimm die vorgeschlagenen zwei Pins und zwei Dioden zum Entkoppeln.

michael_x:
Darfst halt, wenn einer HIGH ist, den anderen nicht LOW setzen, sondern musst ihn unverändert lassen.

Wann (ob) das der Fall ist, ist mir auch zu kompliziert mit deinen vielen Merkern.

Oder nimm die vorgeschlagenen zwei Pins und zwei Dioden zum Entkoppeln.

So hab grade den Pin von P2 geändert, ist jetzt so:

const int P1 = 34; //Signalhorn Warnung
const int P2 = 37; //Signalhorn Nachlegen

Klappt so perfekt. gibt auch zu keinem Zeitpunkt den Fall das beide an sind.
So klappt es zwar aber dafür muss ich leider ein weiteres Relais verwenden.

Es sollte auch funktionieren, die beiden Ausgänge mit Dioden zu entkoppeln aud dann auf ein gemeinsames Relais zum Horn zu gehen. Was für ein Relais verwendest Du?

Gruß Tommy

Tommy56:
Es sollte auch funktionieren, die beiden Ausgänge mit Dioden zu entkoppeln aud dann auf ein gemeinsames Relais zum Horn zu gehen. Was für ein Relais verwendest Du?

Gruß Tommy

16er Relais Karte mit Low Level Trigger. Kann dadurch die Dioden weglassen da die ja direkt auf der Karte schon sind.
Muss nur eine Brücke von dem einen Relais zu dem anderen machen und beide zur Hupe geben. Also 2 Relais für eine Hupe. Werde das jetzt auch so machen, zu mindestens bis ich eine bessere Lösung finde.

Wäre nur schön gewesen wenn ich mir das Relais sparen hätte können. Um für die Zukunft noch Reserven an Relais haben.

Aber Dankebfür eure Hilfe.

Ach, man darf doch da keine Dioden einsetzen....
Da ist ein µC, welcher 16 Millionen Dioden Funktionalitäten ersetzen kann, pro Sekunde.
Ich bin entsetzt.

Wo bleibt denn da der Stolz, die Ehre, und der ganze Kram.
Das wäre das Eingeständnis des Versagens, ohne jede Not.
Wie wird das denn beim nächsten Projekt...

:smiling_imp: :smiling_imp: :smiling_imp: :smiling_imp:

Vergil820:
... zu mindestens bis ich eine bessere Lösung finde.

Nichts gegen Dioden und Relais, aber wenn man Hardware sparen möchte, tut es auch weiche Ware:

// P1 - Signalhorn (Warnung)
  //-----------------------------------------------------

  if ((M4 == 1) || (M5 == 1))
  {
    if ((P1WarnungState == HIGH) && (currentMillis - P1WarnungMillis >= P1WarnungAn))
    {
      P1WarnungState = LOW;  // Turn it off
      P1WarnungMillis = currentMillis;  // Remember the time
      digitalWrite(P1, P1WarnungState);  // Update the actual LED
    }
    else if ((P1WarnungState == LOW) && (currentMillis - P1WarnungMillis >= P1WarnungAus))
    {
      P1WarnungState = HIGH;  // turn it on
      P1WarnungMillis = currentMillis;   // Remember the time
      digitalWrite(P1, P1WarnungState);    // Update the actual LED
    }

    if ((M4 == 0) && (M5 == 0)) {
      digitalWrite(P1, HIGH);
    }
  }
  // P2 - Signalhorn (Nachlegen)
  //-----------------------------------------------------
  else if ((M6 == 1))
  {
    if ((P2NachlegenState == HIGH) && (currentMillis - P2NachlegenMillis >= P2NachlegenAn))
    {
      P2NachlegenState = LOW;  // Turn it off
      P2NachlegenMillis = currentMillis;  // Remember the time
      digitalWrite(P1, P2NachlegenState);  // Update the actual LED
    }
    else if (((M6 == 1) || (M5 == 1)) && (P2NachlegenState == LOW) && (currentMillis - P2NachlegenMillis >= P2NachlegenAus))
    {
      P2NachlegenState = HIGH;  // turn it on
      P2NachlegenMillis = currentMillis;   // Remember the time
      digitalWrite(P1, P2NachlegenState);    // Update the actual LED
    }

    if ((M6 == 0)) {
      digitalWrite(P1, HIGH);
    }
  }

Das dürften Konstanten sein und sollten dann auch im Programm Verwendung finden:

// Analog Eingänge
//-----------------------------------------------------

int BT1 = A3; //Vorlauf Sensor
int BT2 = A4; //Rücklauf Sensor
int BT1Sensor;
int BT2Sensor;
int BT1Temp = 0;
int BT2Temp = 0;
int sensorValue = analogRead(A4);

Hi

Die Bezeichnung erinnern schwer an Elektro und SPS (S Taster, M Merker).
Wenn Er damit zurecht kommt, ggf. hat Er Das ja so gelernt (wie geschrieben: SPS), dann sollten wir Ihm doch Seine Merker lassen.
Steht ja Jedem frei, die Merkbarkeit der Merker per 'Suchen und Ersetzen' anzupassen.

Wäre auch auf eine State-Maschine gegangen, den Takt der Huperei aus millis() abgeleitet und, je nach Fall entschieden, ob eine der Informationen gerade gehupt werden muß.

Aber wie war der Spruch: Ein funktionierender Sketch ist ein guter Sketch.
Verbesserungen gibt Es überall und immer (ok, vll. nicht im Nachbar-Thread mit den 6 Byte für einen toggelnden Pin).

In diesem Sinne: noch viel Spaß mit den Arduinos und der unaufhörlich um 3 Uhr in der Früh nach Nachschub gierenden Heizungs-Tröte :wink:
(programmiere Dir noch eine TOT-Zeit rein, ab wann kein Nachlegen mehr verlangt wird)

MfG

Relais Karte mit Low Level Trigger

P1WarnungState = LOW; // Turn it off
digitalWrite(P1, P1WarnungState); // Update the actual LED

Wenn man den Code ein bisschen putzt, erleichtert man nicht nur anderen, sondern auch sich selbst das Leben. :wink:

Das Programmieren hat, gegenüber Hardwarelösungen, auch den Vorteil, dass “nichts tun” leicht hinzukriegen ist, wenn man will.

Andererseits kann man auch durch Trennen der Logik, das Ganze übersichtlicher strukturieren.
Hier wird das Relais -meiner Meinung nach- ziemlich übersichtlich angesteuert:

void loop() {
  const byte P1=34; // RelaisPin
  ...
  bool Warnung; // true: Hupe einmal je Minute kurz an ( Nachlegen ).
  bool Alarm; // true: Hupe regelmässig "blinken" lassen.

  Warnung = ... ; // Deine bisherige Logik ( oder einfacher )
  Alarm = ... ;

  // Hupe ansteuern ( active LOW )
  // 
  if (Alarm) AlarmHupe();
  else if (Warnung) WarnHupe(P1);
  else digitalWrite(P1, HIGH); // OFF
}

void AlarmHupe() {
  const int ZYKLUS = 1000;
  const int ON = 700;
  static unsigned long t;
  if ( millis() -  t > ZYKLUS ) t = millis();
  if ( millis() - t < ON ) digitalWrite(P1, LOW); // ON
  else   digitalWrite(P1, HIGH); // OFF
}

void WarnHupe(byte p) {
  const unsigned long ZYKLUS = 60000L;
  const int ON = 500;
  static unsigned long t;
  if ( millis() -  t > ZYKLUS ) t = millis();
  if ( millis() - t < ON ) digitalWrite(p, LOW); // ON
  else   digitalWrite(p, HIGH); // OFF
}

Die beiden Funktionen sind recht ähnlich, könnten also auch durch gemeinsamen Code realisiert sein

postmaster-ino:
Die Bezeichnung erinnern schwer an Elektro und SPS (S Taster, M Merker).
Wenn Er damit zurecht kommt, ggf. hat Er Das ja so gelernt (wie geschrieben: SPS), dann sollten wir Ihm doch Seine Merker lassen.
Steht ja Jedem frei, die Merkbarkeit der Merker per 'Suchen und Ersetzen' anzupassen.

Oder das Thema beiseite zu legen. Auch wenn man das von SPS gewöhnt sein sollte, ist es nicht unbedingt verständnisfördernd.

Gruß Tommy

postmaster-ino:
Hi

Die Bezeichnung erinnern schwer an Elektro und SPS (S Taster, M Merker).
Wenn Er damit zurecht kommt, ggf. hat Er Das ja so gelernt (wie geschrieben: SPS), dann sollten wir Ihm doch Seine Merker lassen.
Steht ja Jedem frei, die Merkbarkeit der Merker per ‘Suchen und Ersetzen’ anzupassen.

Ja habe bis jetzt nur ab und zu Siemens S7 und LOGO programmiert und gelernt. Ist wie gesagt mein erstes Arduino Programm.

In diesem Sinne: noch viel Spaß mit den Arduinos und der unaufhörlich um 3 Uhr in der Früh nach Nachschub gierenden Heizungs-Tröte :wink:
(programmiere Dir noch eine TOT-Zeit rein, ab wann kein Nachlegen mehr verlangt wird)

Ist in meiner Werkstatt. Also kann es hupen wie es will. Aber keine Sorge Ruhemodus mit Standby der gesamten Steuerung ist eingebaut.

Ich muss mich jetzt erstmal in eure ganzen Verbesserungen rein lesen.