Erstmal Entschuldigung das es vielleicht etwas zu einfach für euch ist, aber ich komm einfach nicht weiter. Habe eine kleine Denkblockade
Also es geht darum: Ich bin gerade dabei eine Bewässerung zu bauen und habe 4 Bereiche die mit jeweils mit einem Magnetventil und Feuchtigkeitssensor ausgestattet ist. Das ganze wird von einer Pumpe mit Wasser beliefert.
Ich wollte das so lösen das so alle 30-60min gecheckt wird ob ein oder alle Beete Wasser brauch und dann nach einander die Ventile eingeschalten wird, jedes Ventil hat da aber eine eigene Dauer da nicht alle denselben Abstand zur Pumpe haben und das Wasser wieder zurückläuft.
Das was ich abgehängt habe ist nur ein kleiner Test.
int MoiPin[] = {A0, A1, A2, A3};
int MoiValue[4];
int MoiLevel[] = {4, 4, 4, 4};
int ValvePin[] = {8, 9, 10, 11};
int ValveTime[] = {1, 2, 3, 4}; //time in sec
int ValveMode[10];
int countValveMoi = 4;
int Timewaitsens = 4; //time in sec
long Timelastsens;
int TimewaitPump = 10; //time sec
long TimelastPump;
void setup() {
// put your setup code here, to run once:
for (int i = 0; i < countValveMoi; i++) {
pinMode(MoiPin[i], INPUT);
pinMode(ValvePin[i], OUTPUT);
}
Serial.begin(9600);
}
void loop() {
//sensor();
if (millis() - Timelastsens >= (Timewaitsens * 1000)) {
for (int i = 0; i < countValveMoi; i++) {
MoiValue[i] = analogRead(MoiPin[i]);
MoiValue[i] = map(MoiValue[i], 0, 1023, 10, 0);
Serial.print(" ");
Serial.print(i);
Serial.print(". ");
Serial.print(MoiValue[i]);
}
Serial.println(" done");
Timelastsens = millis();
}
//valvepump();
if ((millis() - TimelastPump >= (TimewaitPump * 1000)) && ValveMode[10] == 0) {
for (int i = 0; i < countValveMoi; i++) {
if (MoiValue[i] << MoiLevel[i]) {
ValveMode[i] = 1;
}
else {
ValveMode[i] = 0;
}
ValveMode[10] = 1;
}
TimelastPump = millis();
}
if (ValveMode[10] == 1) {
}
}
Du hättest deutlich mehr helfende, wenn du deine Sketche direkt in Code-Tags (Schaltfläche </> oben links im Editorfenster) hier postest.
Dann können auch die Mobilisten alles lesen.
HotSystems:
Du hättest deutlich mehr helfende, wenn du deine Sketche direkt in Code-Tags (Schaltfläche </> oben links im Editorfenster) hier postest.
Dann können auch die Mobilisten alles lesen.
mein Problem ist das ich nicht weiß wie ich es hinbekomme das zuerst das erste Ventil aufmacht (falls es Wasser benötigt) es eine bestimmte Zeit hoffen hält und wieder schließt und danach mit dem nächsten weiter macht (falls das Beet Wasser benötigt).
Und das alles ohne delay zu arbeiten. So das der rest des Programmes (was nicht mit dabei ist) weiter arbeitet.
Die Zeiten die da gerade drinnen stehen stimmen nicht, da es nur zu Versuchszwecken gillt.
Schrittkette ?
bau Dir doch einen Zähler von 1-4 . Wenn die Bedingung erfüllt ist ( Zeit abgelaufen oder es wird kein Wasser benötigt) zählst Du eins weiter. Wenn die Bedingung nicht erfüllt ist bleibt der Zähler stehen.
Wenn die halbe Stunde rum ist Reset zähler und damit wieder von vorne anfangen.
dann mit swich oder If die 4 Zählerstände auswerten.
ich hab hier vor einiger Zeit mal was zu Servomotoren gemacht und dabei zwei Servos mit einer Schrittkette angesteuert.
wie würde das denn dann aussehen? Kan mir das nicht vorstellen und kan nix gescheites finden was gut aussieht. hast du vielleicht einen link zu deinem projekt?
Du gehst an Beet A, steckst den Finger in den Boden und ermittelst die Feuchte.
Wenn das Beet zu trocken ist, stellst Du das Wasser an und stoppst die Zeit, dann stellst Du das Wasser wieder ab.
Nun gehst Du zu Beet B, steckst ...
...
... stellst Du das Wasser wieder ab.
Da Du am letzten Beet bist, gehst Du wieder zu Beet A.
Du selber wirst Dir wohl merken, daß das Beet gerade gegossen wurde und nach der Runde, wo alle Beete gegossen wurden, einen Kaffee schlürfen - aber weder Kaffee noch diese Weitsicht hat der Arduino - Dieser rennt den ganzen Tag im Kreis und wartet darauf, irgend etwas machen zu dürfen.
Du wirst wohl einen Merker für das aktuelle Beet brauchen und was Du gerade dort machen willst.
Wenn Feuchte im Beet ok -> Beet-Merker +1 (bzw. auf 1, um vorne anzufangen).
Die Endbedingung des Gießen kannst Du genau so frei wählen - entweder die ermittelte Feuchte - vll. blöd, da Du ja gerade Wasser drauf kippst - oder per Zeit.
Da der Arduino, wenn Nichts zu gießen gefunden wird, reium die Feuchte der Beete misst, muß Dich auch das Wetter nicht groß kümmern - wenn eines der Beete austrocknet, merkt Das der Arduino und schafft für Abhilfe.
Als Failsafe solltest Du Alles einbauen, was schief gehen kann - ist die Wasserversorgung gegeben?
aka Zapfstelle zugedreht
aka Regenwassertank leer
Läuft die Pumpe?
aka Durchfluss mithalten (entweder Ja/Nein oder 'mitzählen')
Sind die Feuchte-Werte plausibel?
steckt der Sensor im Boden, wird gerade abgewaschen oder liegt frei
kA, was noch Alles beim Beet Bewässern schief gehen kann - Dein Arduino wird Das aber Alles finden
Jortox:
wie würde das denn dann aussehen? Kan mir das nicht vorstellen und kan nix gescheites finden was gut aussieht. hast du vielleicht einen link zu deinem projekt?
Ich habe meine Beitrag zum Thema Servos auch nicht mehr gefunden. Hab Dir aber mal die Schrittkette rauskopiert. So wie das jetzt da steht sollte es aber laufen.
zwischen Case und break kommt dann das was Du machen willst. Messen Ventil auf zu hier wird halt immer nur für unterschiedliche Zeiten gewartet bis es weitergeht. Das ist ja aber bei Dir ähnlich .
Gruß Heinz
// Realisierung einer Schrittkette als Grundgerüst für eine Ablaufsteuerung
// Weiterschalt Bedingung next =TRUE
// in diesem Beispiel wird als Weiterschaltbedingung lediglich eine eine
// Wartezeit verwendet.Dazu gibts die function warte die
// TRUE zurückliefert wenn die Wartezeit abgelaufen ist.
boolean next; // Bedingung zum weiterschalten der Schrittkette
int schritt; // Schrittzähler
int maxschritt = 5 ; // Anzahl max Schritte
void setup() {
Serial.begin(9600);
next = true;
}
void loop() {
if (next) {
schritt++;
Serial.print("Schritt--"); Serial.print(schritt);
Serial.println();
if ( schritt > maxschritt) { // Reset fang wieder von vorne an
schritt = 0;
}
}
switch (schritt) { // Schrittkette auswerten
case 1:
next = warte(1000); // warte 1000ms
break;
case 2:
next = warte(2000);
break;
case 3:
next = warte(3000);
break;
case 4:
next = warte(4000);
break;
}
}// loop ende
// ==================Funktionen ================
// Warte Zeit / Pause
bool warte(uint16_t dt) {
unsigned long static alt_t;
bool static flag;
if (!flag) { // Flanke erkennen und Timer resetten
flag = true;
alt_t = millis();
}
if (millis() - alt_t > dt) { // abfrage auf Zeit abgelaufen
flag = false; // wenn abgelaufen flankenmerker zurück setzten und
return true; // Function mit true verlassen
}
else { // wenn noch nicht abgelaufen function mit false verlassen
return false;
}
}
Nachtrag
@postmaster
Danke für den Hinweis hab das geändert und wünschgemäß optimiert und kommentiert
Die Beschreibung des Projektes von Postmaster-ino ist schon sehr zutreffend.
Dabei kann der Arduino natürlich sehr viel mehr bzw. das Problem besser lösen.
Der muss es nicht strikt hintereinander abarbeiten, sondern kann alle Beete direkt hintereinander prüfen und entsprechend auch die Ventile dazu direkt steuern. Also muss man nicht jeden Vorgang erst abgeschllossen haben um den nächsten abzuarbeiten.
Evtl. ist hier die Programmierung etwas kniffliger, aber mit etwas Übung bekommst du das auch hin.
Wenn du dann deinen ersten Sketch diesbezüglich fertig hast, kannst du diesen gern mit weiteren Fragen hier vorstellen.
Damit du zum Ziel kommst, solltest du dir den Programmablauf auf ein Blatt Papier vorzeichnen.
Beispiele zu allem findest du in der IDE und hier ist BlinkWithoutDelay eines der wichtigsten.
Wenn du das richtig anwendest, kannst du auf die delays fast völlig verzichten.
ein interessantes Beispiel was du hier vorstellst.
Allerdings für Anfänger völlig ungeeignet, da keinerlei Kommentare/Dokumentation dazu vorhanden ist.
Wie soll ein Anfänger das verstehen ?
Bitte das nochmal überdenken.
Und zur besseren Lesbarkeit das Beispiel zuvor in der IDE formatieren und die Leerzeilen entfernen.
@Dieter danke für die Blumen, aber ich habs auf die Schnelle rauskopiet und dann das unwichtige gelöscht und dann das formaiteren zum Schluss vergessen.
@ die Schrittkette ist ja aber auch nicht so kompliziert das man es nicht verstehen kann, zur Funktion hatte ich ja auch schon was gesagt.
mehrere Ventile gleichzeitzg öffen geht natürlich auch, aber nur dann wenn sichergestellt ist das sich dadurch die Menge nicht ändert. wenn dann alle gleichzeitig offen sind kommt eventuell bem letzten nichts mehr an, oder es dröppelt nur noch.
In der IDE macht der Beispiel-Sketch eine durchaus formatierte Figur - hatte ich jetzt auch nicht erwartet, da Das hier doch etwas ... ruppig ... aussieht.
Einzig wird eine Warnung ausgegeben, daß ein Vergleich unsigned signed gemacht wird.
Da in der Funktion wohl keine Negativ-Zeit gewartet werden soll, habe ich bei meiner Kopie das "int dt" in ein "uint16_t dt" angepasst - damit sind bis zu 65535ms Wartezeit möglich.
Nette Funktion - ein Danke geht in Deine Richtung (und der Post steht in meinem Exemplar als Quelle)
Hast du schon gesicherte Erfahrungen mit den Feuchtesensoren?
Das sind bekannte Sorgenkinder. Wenn möglich, würde ich sie redundant aufbauen. Mindestens aber reichlich Ersatz für die Sonden halten.
Wenn Du das Programm für dich selbst machst, dann tu die ein Gefallen: Bau ein Notfallprogramm für den Betrieb ohne Sonde ein. Als Ersatz kann ggf. reichen, die Gießdauer des benachbartes Feldes nehmen.
Wenn Du das Programm für einen Kunden schreibst, dann kannst Du mit der Wartung und den Handel mit Sonden viel Geld machen
Auch nicht einfach das erstes Analogwert pro Sonde nehmen, sondern 10 Messungen machen, davon das Mittelwert nehmen, auch von den 10 Messungen das Maximum und das Minimum ermitteln. Wenn eine Sonde beginnt zu spinnen, dann dürften sich die Ausreißer häufen...
Da sich der TO nicht äußert, welche Feuchtesensoren er benutzt, ist alles dazu nur Spekulation.
Als Anbieter einer Lösung, bei der laufend die Sensoren ausfallen, wird er nicht "viel Geld verdienen", sondern viel Geld für Schadenersatz und Gewährleistung zahlen müssen.
Tommy56:
Als Anbieter einer Lösung, bei der laufend die Sensoren ausfallen, wird er nicht "viel Geld verdienen", sondern viel Geld für Schadenersatz und Gewährleistung zahlen müssen.
