Hallo zusammen,
vor ein paar Wochen hab ich einen Arduino Uno + Starterkit bekommen, da die meisten Projekte mal durch und Spass dran gefunden.
Als erste Anwendung hab ich mal mit einer Pflanzenbewässerung angefangen, scheint ja ein echter Klassiker zum Start zu sein, hab hier im Forum schon ein paar gute Threads dazu gelesen.
Ich will mal relativ einfach anzufangen und die Sache dann Schritt für Schritt ausauen. Dabei soll das nicht nur so irgendwie funktionieren, sondern ich mag auch gerade am Anfang darauf achten, dass ich einigermaßen brauchbaren Code produziere, über den man sich austauschen kann. Daher wäre mein erstes Anliegen mal über mein Werk drüber zu schauen:
// Konstantendeklaration
// Förderleistungen der Pumpen in den einzelnen Bereichen 0 bis 3 in ml/s
const int FL[] = {20, 20, 20, 20};
// Zeit bis Start erste Bewässerung in Stunden
const float ToFirst_h = 0.005; //18s zum Testen
//Belegung der Pins für die Pumpenrelais
const byte R[] = {2, 3, 4, 5};
// Variablendeklaration - sollen später im loop anpassbar sein
// auszubringende Wassermengen in den einzelnen Bereichen 0 bis 3 in ml
int Menge[] = {100, 75, 200, 125};
// Intervall in dem Wasser ausgebracht werden soll in Stunden
float Intervall_h;
// Kenner ob und wie viele Gießintervalle ausgelassen werden sollen pro Bereich
byte Skip[] = {0, 1, 2, 0};
// Fehlerkenner für Unterbrechung von loop Teilen und Anzeige
byte Failcode;
//globale Variablen für Code
unsigned long StartMillis; //Für Steuerung der Intervalle
unsigned long CurrentMillis;
unsigned long NextIntervall;
byte CurrentSkip[4]; // Zähler für die aktuelle Anzahl der Intervalle die bereits ausgelassen worden sind
unsigned long Pumpenlaufzeit[4];
unsigned long Pumpenlaufzeit_ges;
byte x; //Laufvariable für diverse For Schleifen
void setup()
{
// Initialwerte für Bewässerung
Serial.begin(9600);
Failcode = 0; //Fehlercode 0 = kein Fehler
Intervall_h = 0.01; //Bewässerung alle 36s für Test - später 24 oder so
//Pins für die Relais setzen
for (x = 0; x < 4; x++)
{
pinMode (R[x], OUTPUT);
digitalWrite(R[x], HIGH); //Relais schalten bei LOW
}
StartMillis = millis(); // Startzeit setzen
NextIntervall = ToFirst_h * 3600000; //Erstes Intervall setzen in Millis
//Erste Skipwerte setzen
for (x = 0; x < 4; x++)
{
CurrentSkip[x] = Skip[x];
}
}
void loop()
{
CurrentMillis = millis();
if (CurrentMillis - StartMillis >= NextIntervall)
{
NextIntervall = Intervall_h * 3600000; //Nächstes Intervall setzen in Millis
StartMillis = CurrentMillis; //Start zurücksetzen
//Berechnung der Pumpenlaufzeiten
Calc_Laufzeit();
//Prüfung ob Gesamtlaufzeit Pumpen + Puffer unter Intervall liegt
if (Pumpenlaufzeit_ges > NextIntervall)
{
Failcode = 1;
}
//Pumpen laufen lassen und Skipwerte aktualisieren
if (Failcode == 0)
{
for (x = 0; x < 4; x++)
{
if (CurrentSkip[x] < 1)
{
digitalWrite (R[x], LOW);
delay (Pumpenlaufzeit[x]);
digitalWrite (R[x], HIGH);
delay (250);
CurrentSkip[x] = Skip[x];
}
else
{
CurrentSkip[x]--;
}
}
}
}
Serial.print("Pumpenlaufzeit0: ");
Serial.println(Pumpenlaufzeit[0]);
Serial.print("Pumpenlaufzeit1: ");
Serial.println(Pumpenlaufzeit[1]);
Serial.print("Pumpenlaufzeit2: ");
Serial.println(Pumpenlaufzeit[2]);
Serial.print("Pumpenlaufzeit3: ");
Serial.println(Pumpenlaufzeit[3]);
Serial.print("NextIntervall: ");
Serial.println(NextIntervall);
Serial.print("Fehler: ");
Serial.println(Failcode);
delay(3000);
}
void Calc_Laufzeit()
{
Pumpenlaufzeit_ges = 1000; //Zeit für die maximal 4x 250 ms zwischen den Relais
for (x = 0; x < 4; x++)
{
if (CurrentSkip[x] < 1) //Wenn nicht geskipt wird, Berechnung aus Menge und Förderleistung
{
Pumpenlaufzeit[x] = Menge[x] / FL[x] * 1000;
}
else
{
Pumpenlaufzeit[x] = 0; // Wenn geskipt wird, dann keine Laufzeit
}
Pumpenlaufzeit_ges = Pumpenlaufzeit_ges + Pumpenlaufzeit[x];
}
}
Das System soll 4 Bereiche bewässern.
Der Grundablauf ist simpel:
- warte einen definierten Zeitraum (24h, 12h oder sowas)
- lass 4 Pumpen hintereinander eine definierte Wassermenge ausgeben
- von vorn
Features:
- Wassermengen pro Bereich können direkt eingegeben werden, die Ausgabe wird über Förderleistung in Laufzeit umgerechnet
- Intervalle können geziehlt pro Bereich ausgelassen werden (also nur jeden 2. oder 3. Intervall gießen)
- Erstes Intervall kann gesondert festgelegt werden (damit der Bewässerungszeitpunkt nicht gleich Startzeitpunkt sein muss)
- Bisher wird ein Fehler geprüft und abgefangen - Überscheitet die Gesamtpumpenlaufzeit das Intervall (das würde uns wohl ins Chaos stürzen, sollt aber im Regelbetrieb kaum vorkommen)
Der Code macht soweit mal das was er soll, zumindest mal an 4 Test - Led, die ich über die Relais ansteuere momentan. Trotzdem wäre ich dran interessiert, ob hier noch was verbessert und vereinfacht werden kann. Passt diese Mischung aus Millis() und Delay() oder lieber alles mit Millis steuern? Der Serial.Print Block ist da auch noch nicht optimal, da sehe ich die aktuellen Laufzeiten erst, wenn die Pumpen schon gelaufen sind ...
Weitere Schritte:
- Das Intervall und die Wassermengen sollen online (Mobilphone) während der Laufzeit veränderbar sein
- Einbindung von Sensoren für Feuchtigkeit, Temperatur, etc
- Achja, die Hardware (Tank, Pumpen, Leitungen) muss ich irgendwann mal bauen
- Irgendwann wird das ganze wohl auf eine Pumpe und Ventile zur Steuerung der Bereiche umgebaut
- Abfrage Füllstand Tank ...
Für die Umsetzung der Steuerung aufs Handy ist mir Blynk ins Auge gestochen. Scheint so für den Anfang recht simpelzu sein. Nur ist hier die Frage, wie komm ich mit dem Uno Board ins WLAN, bzw. ist der Uno hier überhaupt das geeignete Board?
Besser scheint ja ein ESP8266 (also sowas:ESP8266) aber das hat auf den ersten Blick nur einen analog Eingang, was mir ungünstig erscheint, wenn ich da irgendwann Feuchtigkeits und Temperatursensoren anschließen will...? Ich hab da auch schon einiges hin und her recherchiert, aber das Feld ist groß und für Einsteiger recht unübersichtlich.
Bin also für Tips, Anregungen, gute Links und sonstigen Input dankbar.
Grüße Olli
