Hallo zusammen!
Ich bin derzeit an einem kleinen Projekt. Übersichthalber erkläre ich kurz die Funktion und die verwendeten Bauteile. Die aktuellen Fortschritt werde ich hier im ersten Post farblich markieren und aktualisieren, damit jeder sieht wo es noch hapert. Im Anhang ist zusätzlich eine kleine Excel-Skizze. Vielleicht wird es hier sehr viel deutlicher 
Meine Idee ist / war es, jede Abschnitt separat zu betrachten:
- Sensor 1 erkennt -> Relais 1 wird für Laufzeit 1 betätigt
- Sensor 2 erkennt -> Relais 2 wird für Laufzeit 2 betätigt
- Während Relais 1 / 2 oder beide zusammen aktiv -> Relais 3 betätigen
- Nach der Laufzeit von Relais 1 / 2 oder beiden -> Relais 4 kurz betätigen
Das Projekt besteht aus:
1x Pumpe
3x 2-Wege-Ventile
Arduino UNO
4er Relais Board (LOW-Aktiv)
2x Sensor
Einfachheitshalber breche ich alles auf das Relaisboard runter, weil dies im Prinzip für die Gesamtfunktion ausschlaggebend ist.
-> Also Arduino, Sensoren und Relaisboard.
Pin-Belegung:
2 = Sensor 1
3 = Sensor 2
4 = Relais 1
5 = Relais 2
6 = Relais 3
7 = Relais 4
Die Relais sollen zu bestimmten Ereignissen geschaltet werden.
Relais 1 und 2 lösen jeweils mit einem der beiden Sensoren aus. (Bsp.: Wenn Sensor 1 aktiv, dann Relais 1 aktiv für eine bestimmte Laufzeit). -> Funktioniert so wie es soll, auch schön unabhängig voneinander
Knackpunkt1 : Relais 3 soll immer dann betätigt werden, WÄHREND Relais 1 oder 2 oder beide zusammen aktiv sind.
Das Problem hier ist, dass ich zwar das Relais 3 mit dem Sensor geschaltet bekomme, allerdings nur für die Laufzeit des ersten aktiven Relais. Danach geht das Relais 3 aus, obwohl das andere durch den zweiten Sensor geschaltete Relais noch aktiv ist.
Knackpunkt 2 : Relais 4 soll für kurze Zeit betätigt werden, NACHDEM
- die Laufzeit von Ventil 1 vorbei ist
- oder die Laufzeit von Ventil 2 vorbei ist
- oder WENN während der Laufzeit von einem der beiden Relais das andere Relais geschaltet wird.
Also:
Sensor 1 aktiv -> Relais 1 aktiv -> Relais 1 betätigt für bestimmte Laufzeit -> Relais 4 schaltet am Ende der Laufzeit für eine bestimmte Zeit.
Sensor 2 aktiv -> Relais 2 aktiv -> Relais 2 betätigt für bestimmte Laufzeit -> Relais 4 schaltet am Ende der Laufzeit für eine bestimmte Zeit
Sensor 1 aktiv -> Relais 1 aktiv -> Relais 1 betätigt für bestimmte Laufzeit -> Während der Laufzeit von Relais 1 wird Relais 2 über Sensor 2 betätigt -> Relais 4 schaltet erst dann für eine bestimmte Zeit, nachdem die Laufzeit von beiden Relais beendet ist
Ich hoffe, dass ich mich soweit für jeden verständlich und nachvollziehbar ausgedrückt habe. ansonsten fragt mich bitte einfach
Hier der Code den ich soweit habe:
#include <CooperativeTask.h>
/*-------------------------Relais 1----------------------------*/
class Relais1: public Task
{
protected:
const byte sensor1Pin;
const byte relais1Pin;
const unsigned long laufzeit1;
public:
Relais1(const byte sensor1Pin, const byte relais1Pin, const unsigned long laufzeit1):
sensor1Pin(sensor1Pin),
relais1Pin(relais1Pin),
laufzeit1(laufzeit1)
{
}
virtual void init() override
{
pinMode(sensor1Pin, INPUT_PULLUP);
pinMode(relais1Pin, OUTPUT);
digitalWrite(relais1Pin, HIGH);
}
virtual void run() override
{
TaskBlock
{
taskWaitFor(not digitalRead(sensor1Pin));
digitalWrite(relais1Pin, LOW);
taskPause(laufzeit1);
digitalWrite(relais1Pin, HIGH);
}
}
};
Relais1 aktiv1[] {
// {sensor1Pin,relais1Pin,laufzeit1}
{2,4,1000}
};
/*-------------------------Relais 2----------------------------*/
class Relais2: public Task
{
protected:
const byte sensor2Pin;
const byte relais2Pin;
const unsigned long laufzeit2;
public:
Relais2(const byte sensor2Pin, const byte relais2Pin, const unsigned long laufzeit2):
sensor2Pin(sensor2Pin),
relais2Pin(relais2Pin),
laufzeit2(laufzeit2)
{
}
virtual void init() override
{
pinMode(sensor2Pin, INPUT_PULLUP);
pinMode(relais2Pin, OUTPUT);
digitalWrite(relais2Pin, HIGH);
}
virtual void run() override
{
TaskBlock
{
taskWaitFor(not digitalRead(sensor2Pin));
digitalWrite(relais2Pin, LOW);
taskPause(laufzeit2);
digitalWrite(relais2Pin, HIGH);
}
}
};
Relais2 aktiv2[] {
// {sensor1Pin,relais1Pin,laufzeit1}
{3,5,1000}
};
/*------------------------- Relais 3 ----------------------------*/
class Relais3: public Task
{
protected:
const byte relais3Pin;
public:
Relais3(const byte relais3Pin):
relais3Pin(relais3Pin)
{
}
virtual void init() override
{
pinMode(relais3Pin, OUTPUT);
digitalWrite(relais3Pin, HIGH);
}
virtual void run() override
{
TaskBlock
{
taskWaitFor((not digitalRead(4))||(not digitalRead(5)))
if ((not digitalRead(4))||(not digitalRead(5)))
{
digitalWrite(relais3Pin, LOW);
}
else
{
digitalWrite(relais3Pin, HIGH);
}
}
}
};
Relais3 aktiv3[] {
// {relais3Pin}
{6}
};
/*------------------------- Relais 4 ----------------------------*/
class Relais4: public Task
{
protected:
const byte relais4Pin;
public:
Relais4(const byte relais4Pin):
relais4Pin(relais4Pin)
{
}
virtual void init() override
{
pinMode(relais4Pin, OUTPUT);
digitalWrite(relais4Pin, HIGH);
}
virtual void run() override
{
TaskBlock
{
/* Noch keine Lösung
- schalte, wenn die Laufzeit von Relais 1 vorbei
- schalte, wenn die Laufzeit von Relais 2 vorbei
- oder schalte erst dann, wenn die Laufzeit von Relais 1 und Relais 2 vorbei ist. Solange noch eines der beiden Relais aktiv ist, darf nicht geschaltet werden */
}
}
};
Relais4 aktiv4[] {
// {relais3Pin}
{7}
};
/*------------------------------------------------*/
void setup()
{
Scheduler::instance().init();
}
void loop()
{
Scheduler::instance().run();
}
:D. Für jedes Relais, das zeitgesteuert abgeschaltet werden soll legst Du einen Timer an. Immer wenn Du das Relais einschaltest, startest Du auch den Timer('setTime'). Das kann auch während der Laufzeit sein ( der Timer ist retriggerbar ). Läuft der Timer ab ('expired') schaltest Du das Relais wieder ab.
