Go Down

Topic: Projekt Wassersammler - Motor stoppen und Ventilstatus abfragen (Read 777 times) previous topic - next topic

KampfHund

Hallo Leute,

ich habe mir mittlerweile etwas Arduino Grundwissen angeeignet jedoch komme ich leider auf keinen grünen Zweig :/

Mein Projekt: Regenwasser von der Dachrinne abzweigen für ein Fass.

- Ich habe ein Ventil dass mir das Dachwasser zur Regentonne leitet
- Einen Ultraschallsensor um die Distanz im Tank zu messen.
- Ein Schwimmer falls die Ultraschallmessung versagt.
- Eine Pumpe die dann zum bewässern dient ( soweit bin ich noch nicht!)
- Einen Schalter um die Pumpe manuell zu starten ( Im Winter Wasser ab pumpen)

Verwendete Komponenten:
Arduino Nano
L298N DC Motor Treiber - DC Motor Ventil
12V Pumpe vermutlich über ein Relaise dann ( fehlt noch)
Ultraschallsensor
Schalter


Soweit die Daten.


Wo ich im Moment scheitere ist:

Das Ventil hat keine Endschalter, diese würde ich gerne sparen!
Ich würde gerne das Ventil 3 Sekunden lang fahren lassen bis es geöffnet ist und auch die selbe Zeit wieder zum schliessen nutzen.

Start ist mit Ventil geschlossen.

Ich dachte mir wenn ich dies mit
if ((mm <= abstandstop) && (ventilstatus == false))
mache würde es funktionieren...

Leider bekomme ich es nicht hin dass der Status vom Ventil dann auf true gesetzt wird.
der Fehler muss an dem boolean liegen da ich nicht sicher weiß wie ich das boolean auf true schreibe.

Könnt ihr mir hier unter die Arme greifen da ich wirklich keine Ahnung mehr habe, mein Kopf raucht schon seit ein paar Tagen. Immer und immer wieder habe ich einen anderen Ansatz versucht...


Code: [Select]
#include <Wire.h>

// PIN Belegungen
const int triggerPin = 2;                  // Ultraschall Sensor
const int echoPin = 3;                     // Ultraschall Sensor
const int fullstop = 4;                    // Tank Schwimmer wenn Ultraschall versagt
const int manuellPumpe = 5;                // Manuelle entleerung des Tanks ( Winter)

// Motor 1

#define enA 6                              // Pin D6 - Getriebemotor Ventil Dachrinne Signal
#define in1 7                              // Pin D7 - Getriebemotor Ventil öffnen
#define in2 8                              // Pin D8 - Getriebemotor Ventil schließen

// Einstellbare Werte -----------------------------------------------------------------#
//                                                                                     #
int abstandstop = 100;              // Abstand zum Wasser für Stop                #
int abstandstart = 150;             // Abstand zum Wasser für füllen              #
long dzeit = 3000;                   // Motor laufzeit in Millisekunden            #

boolean ventilstatus = false;       // Ventil Status einlesen - LOW = geschlossen #
//                                                                                     #
//                                                                                     #
//                                                                                     #
//-------------------------------------------------------------------------------------#


void setup() {

  pinMode(triggerPin, OUTPUT);            // Ultraschall Sensor
  pinMode(echoPin, INPUT);                // Ultraschall Sensor
  pinMode(fullstop, INPUT);               // Tank Schwimmer - zweiter füll Stop
  pinMode(manuellPumpe, INPUT);           // Manuelle entleerung ( Schalter )

  pinMode(enA, OUTPUT);                   // Getriebemotor Ventil Dachrinne
  pinMode(in1, OUTPUT);                   // Getriebemotor Ventil öffnen
  pinMode(in2, OUTPUT);                   // Getriebemotor Ventil schließen

}

void loop() {

  Serial.begin(9600);                     // Serielle Schnittstelle initialisieren
  Serial.println("");                     // Serieller Text
  Serial.println("");                     // Serieller Text

  Serial.print("Status Ventil: ");
  Serial.println(ventilstatus);
  delay(500);


  long duration, inches, mm;              // Ultraschall Distanzsensor
  digitalWrite(triggerPin, LOW);          // Ultraschall Distanzsensor
  delayMicroseconds(2);                   // Ultraschall Distanzsensor verzögerer
  digitalWrite(triggerPin, HIGH);         // Ultraschall Distanzsensor
  delayMicroseconds(5);                   // Ultraschall Distanzsensor verzögerer
  digitalWrite(triggerPin, LOW);          // Ultraschall Distanzsensor

  duration = pulseIn(echoPin, HIGH);      // Ultraschall Distanzsensor

  mm = microsecondsToMillis(duration);    // Ultraschall Distanzsensor

  Serial.print(mm);                       // Seriell Ultraschall Sensor - Millimeter
  Serial.println(" mm");                  // Serieller Text - mm
  Serial.print(duration);                 // Seriell Ultraschall Sensor - Zeit
  Serial.println(" Sekunden");            // Serieller Text - Sekunden
  delay(1000);                            // Zeit abwarten um Daten besser lesen zu können




  if ((mm <= abstandstop) && (ventilstatus == false))   // Wenn Abstand (mm) kleiner oder gleich - Ventil schließen
  {
    digitalWrite(in1, LOW);               // Ventil schließen
    digitalWrite(in2, HIGH);               // Ventil schließen
    analogWrite(enA, 255);                // Motor Geschwindigkeit 0-255
    delay(dzeit);
    digitalWrite(ventilstatus, true);
    Serial.print("Ventil: ");
    Serial.println(ventilstatus);
    delay(500);

    digitalWrite(in1, LOW);         // Ventil stoppen ( bzw. Motor)
    digitalWrite(in2, LOW);         // Ventil stoppen ( bzw. Motor)
    analogWrite(enA, 255);          // Motor Geschwindigkeit 0-255

  }

  /*
    if (mm >= abstandstart)                   // Wenn Abstand (mm) größer oder gleich - Ventil öffnen
    {
      digitalWrite(in1, HIGH);              // Ventil öffnen
      digitalWrite(in2, LOW);               // Ventil öffnen
      analogWrite(enA, 255);                // Motor Geschwindigkeit 0-255
      delay(dzeit);                         // Zeit bis Ventil ganz offen
      digitalWrite(in1, LOW);               // Ventil stoppen ( bzw. Motor)
      digitalWrite(in2, LOW);               // Ventil stoppen ( bzw. Motor)
    }
        else
          {
            digitalWrite(in1, LOW);         // Ventil stoppen ( bzw. Motor)
            digitalWrite(in2, LOW);         // Ventil stoppen ( bzw. Motor)
            analogWrite(enA, 255);          // Motor Geschwindigkeit 0-255
          }
  */

}


long microsecondsToMillis(long microseconds)
{
  return microseconds / 3 / 2;
}



KampfHund

Was ich noch vergessen habe.

Somit fährt der Motor momentan natürlich unendlich! Was er aber nicht darf.
Der Motor für das Ventil darf 3 Sekunden fahren und dann sollte das boolean auf True sein und der Motor gestoppt.

Danke euch

LG ALex

uwefed


MicroBahner

Hallo Alex,
zum einen hast Du im loop Befehle, die generell ins setup gehören, zumindest der Serial.begin hat im loop nichts zu suchen.

Leider bekomme ich es nicht hin dass der Status vom Ventil dann auf true gesetzt wird.
Damit:
Code: [Select]
    digitalWrite(ventilstatus, true);
kann das auch nicht funktionieren. Da setzt Du einen Ausgang, Du willst aber doch einfach deinen Merker setzen.
Schreibe da einfach
Code: [Select]
ventilstatus = true;um den Merker zu setzen.

Edit: Du solltest dich auch schonmal mit den Programmiertechniken befassen, die das delay() entbehrlich machen. Noch geht das, aber wenn Du alles realisieren willst, was oben in deiner Liste steht, wirst Du mit delay() scheitern.
Gruß, Franz-Peter

KampfHund

Hallo zusammen,

das Ventil ist dieses hier

Werde hier so einen Motor anbauen Linearmotor

Wobei dieser Endschalter integriert hat aber teurer ist
( Linear actuator)

-----

Das mit dem Serial.begin ist mir verrutscht  :o   Danke!


Ja ich dachte ich kann das so lösen :)
in diesem Fall muss hier stehen: ventilstatus = true;

Delay:
Okay werde ich versuchen. Ist dies das Blink without delay Tutorial?


In diesem Fall werde ich jetzt nochmal alles umschreiben und nochmal posten.
Bin gespannt ob mir der Motor dann nicht mehr durch läuft :)

Danke

LG Alex

Tommy56

Ja, das ist BlinkWithoutDelay. Du kannst Dir zur Unterstützung mal die Nachtwächtererklärung anschauen.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

Scherheinz

Der Motor ist mit der Übersetzung sehr kräftig und wenn du über Zeit fährst wird dein PVC Ventil nicht lange halten. Evtl könntest du den Strom des Motors messen und wenn er bei Endlage ansteigt abschalten, das würde auch funktionieren falls mal was dazwischen hängt oder das Ventil klemmt.

Der zweite Linearantrieb ist nutzlos da er feste Endschalter hat am Ende seines Weges also nach 100mm und dein Ventil hat nur 75mm. Außerdem würde er mit den 150kg!!!! dein Ventil einfach zerlegen
Hier könnte ihre Werbung stehen

Theseus

- Ich habe ein Ventil dass mir das Dachwasser zur Regentonne leitet
Wenn es die Einbaubedingungen zulassen, wäre ein Regensammler vielleicht eine Überlegung wert: Beispiel bei Amazon

Das funktioniert ganz ohne Strom nach dem Prinzip der kommunizierenden Röhren. Das Fass kann aus physikalischen Gründen nicht überlaufen.

Scherheinz

Kostet im Baumarkt nur 14€  ;)  Hab auch so einen, wollte ihm aber nicht den Projektspaß nehmen  :) 
Hier könnte ihre Werbung stehen

gandalfderarier

Servus Jungs,

jetzt mal ohne scheiß - was haltet ihr davon den Leuten zu helfen anstatt ihnen Sinnlose Vorschläge zu machen?
Ein Arduino ist zum bastel da - ist doch schön wenn sich jemand dafür interessiert und somit seine Programmierkentnisse erweitern will.
Hier ist ja jeder schlauer als der nächste.


Felix

HotSystems

Servus Jungs,

jetzt mal ohne scheiß...
Und du meinst jetzt allen Ernstes dem TO mit deinem Kommentar geholfen zu haben ?

Da hat bisher jeder hier im Thread mehr nützliche Informationen rüber gebracht.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

gandalfderarier

Wenn es die Einbaubedingungen zulassen, wäre ein Regensammler vielleicht eine Überlegung wert: Beispiel bei Amazon

Das funktioniert ganz ohne Strom nach dem Prinzip der kommunizierenden Röhren. Das Fass kann aus physikalischen Gründen nicht überlaufen.
Und du meinst jetzt allen Ernstes dem TO mit deinem Kommentar geholfen zu haben ?

Da hat bisher jeder hier im Thread mehr nützliche Informationen rüber gebracht.


Mit meinem Kommentar wollte ich nicht darauf ziehlen, dem TO bei seinem Sketch zu helfen, sondern den Leuten klarmachen was sie hier für einen Abfall verbreiten.


Felix

HotSystems

Mit meinem Kommentar wollte ich nicht darauf ziehlen, dem TO bei seinem Sketch zu helfen, sondern den Leuten klarmachen was sie hier für einen Abfall verbreiten.
Alle Beiträge in diesem Thread sind bisher als Hilfestellung für den TO gedacht. Was er letztendlich daraus macht, bleibt ihm überlassen.
Dein Kommentar ist genau das, was du anprangerst.
Helfen tut es keinem.
Also wenn du nichts zum Thema beitragen kannst, lass es lieber.
I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

KampfHund

Hallo Leute,

da ich im Moment viel mehr im Garten verbringe als vor dem PC, ging natürlich nix vorwärts.

Also das Tutorial mit dem Nachtwächter ist Gut und werde ich zukünftig wenn es noch tiefer geht verwenden. ( Bin schon dabei :) )
Jetzt vorerst reicht mir das mit delay(3000) für das Ventil.

Die Variante mit dem Regensammler bringt mir nichts, da das Rohr in keinen Gulli geht sondern schief über ein anderes Dach und zwar auf die Treasse wo es in eine andere Regenrinne mündet.
Deshalb stoppe ich den Fluß in die andere Rinne und zweige es in mein Faß ab.
Ja und es geht um den Spaß zu tüfteln :)

Also Gut, ein DC Motor Modul ist bestellt wo abschaltet wenn der Strom steigt. Danke für den Tipp!
Werde somit den billigen Motor mit Spindel nehmen, sofern der Lieferant auch die passende Spindelmutter endlich auf Lager hat.

----------------
Jetzt zum Code:
----------------

Ich habe endlich den Knopf erfolgreich gelöst. Der Motor was im Moment angeschlossen ist tut das was der Ultraschallsensor gern möchte *juhu*

Was als nächstes zur debatte steht ist die Sache mit dem bewässern
Ich würde gerne vorerst Nägel verwenden als Sensor um die Feuchte zu messen

Wie kopple ich das aber mit der millis funktion?
Ich muss ja schliesslich täglich checken ob es feucht oder trocken ist und in folge dessen für eine gewisse Zeit dann bewässern.

Danke euch schon mal



Bin ja schon mächtig stolz dass es jetzt mit dem Ventil klappt :)
Aber jetzt geht es wirklich tief in die Materie mit den millis: Da raucht es im Moment noch ordentlich *uff*

LG Alex





KampfHund

Hier der aktuelle Code bisher: ( getestet ist erst die Funktion mit dem Ventil )

Code: [Select]
#include <Wire.h>

// PIN Belegungen
const int triggerPin = 2;                  // Ultraschall Sensor - Weißer Draht
const int echoPin = 3;                     // Ultraschall Sensor - Gelber Draht
const int fullstop = 4;                    // Tank Schwimmer wenn Ultraschall versagt - Roter und schwarzer Draht
const int SchalterPumpe = 5;               // Schalter zur manuellen entleerung des Tanks ( Winter)
int statusPumpe = 0;                       // Status der Pumpe
const int Pumpe = 9;                       // Pumpe - 12 Volt über Relaise
int ventil = LOW;                          // Ventil geschlossen initialisieren - Ventil Status
unsigned long Pumpe_timestore;             // Variable Speicher für Systemzeit.
//unsigned long Schalter_timestore;          // Variable für Schalter Zeitspeicher
int bewaessern = LOW;                      // Variable bewässern
//
const int Nagel1 = 15;                      // Eingang A1 - Nagel 1 Sensor
int valNagel1 = 0;                          // Nagel 1 Wert auf 0 initialisieren
//




// Motor 1

#define enA 6                              // Pin D6 - Getriebemotor Ventil Dachrinne Signal
#define in1 7                              // Pin D7 - Getriebemotor Ventil öffnen
#define in2 8                              // Pin D8 - Getriebemotor Ventil schließen

// Einstellbare Werte -----------------------------------------------------------------#
//                                                                                     #
int abstandstop = 100;              // Abstand zum Wasser für Stop                     #
int abstandstart = 150;             // Abstand zum Wasser für füllen                   #
long dzeit = 3000;                   // Motorlaufzeit in Millisekunden
int einTag = 86400000;              // Nach einem Tag - Zeit
int zeitbewaessern = 5000;          // Zeit wo bewässert wird
//int entleerung = 1500000;           // Zeit zum vollen Tank entleeren - 200 Liter
int nagelwert = 800;                // Ab diesem Wert wird bewässert                   #
//                                                                                     #
//                                                                                     #
//                                                                                     #
//                                                                                     #
//                                                                                     #
//-------------------------------------------------------------------------------------#


void setup() {

  pinMode(triggerPin, OUTPUT);            // Ultraschall Sensor
  pinMode(echoPin, INPUT);                // Ultraschall Sensor
  pinMode(fullstop, INPUT);               // Tank Schwimmer - zweiter füll Stop
  pinMode(SchalterPumpe, INPUT);          // Schalter als INPUT deklarieren - Manuelle entleerung
  pinMode(Nagel1, INPUT);                 // Nagel 1 als Eingang deklarieren - Analog Eingang A1
  pinMode(Pumpe, OUTPUT);                 // Pumpe ist ein Ausgang - Pin D9

  
  pinMode(enA, OUTPUT);                   // Getriebemotor Ventil Dachrinne
  pinMode(in1, OUTPUT);                   // Getriebemotor Ventil öffnen
  pinMode(in2, OUTPUT);                   // Getriebemotor Ventil schließen

  Serial.begin(9600);                     // Serielle Schnittstelle initialisieren
  Serial.println("");                     // Serieller Text
  Serial.println("");                     // Serieller Text

}

void loop() {

  long duration, inches, mm;              // Ultraschall Distanzsensor
  digitalWrite(triggerPin, LOW);          // Ultraschall Distanzsensor
  delayMicroseconds(2);                   // Ultraschall Distanzsensor verzögerer
  digitalWrite(triggerPin, HIGH);         // Ultraschall Distanzsensor
  delayMicroseconds(5);                   // Ultraschall Distanzsensor verzögerer
  digitalWrite(triggerPin, LOW);          // Ultraschall Distanzsensor

  duration = pulseIn(echoPin, HIGH);      // Ultraschall Distanzsensor

  mm = microsecondsToMillis(duration);    // Ultraschall Distanzsensor

  Serial.print(mm);                       // Seriell Ultraschall Sensor - Millimeter
  Serial.println(" mm");                  // Serieller Text - mm
  Serial.print(duration);                 // Seriell Ultraschall Sensor - Zeit
  Serial.println(" Sekunden");            // Serieller Text - Sekunden
  delay(1000);                            // Zeit abwarten um Daten besser lesen zu können



// Manuelle Tank entleerung über Schalter an Pin D5 ( Pumpe an D9 )

statusPumpe = digitalRead(SchalterPumpe);  // Schalter Status lesen
  if (statusPumpe == HIGH)                 // Wenn Schalter gedrückt
    {
      digitalWrite(Pumpe, HIGH);           // Pumpe einschalten
    }
      else {
        digitalWrite(Pumpe, LOW);          // Wenn Schalter LOW - Pumpe AUS
      }


// VENTIL Programm /////////////////////////////////
  if ((mm <= abstandstop) and (ventil == LOW))    // Wenn Abstand (mm) kleiner oder gleich UND Ventil geschlossen                
    {
      digitalWrite(in1, LOW);              // Ventil Stop
      digitalWrite(in2, LOW);              // Ventil Stop
      analogWrite(enA, 255);               // Motor Geschwindigkeit 0-255

    }
  if ((mm <= abstandstop) and (ventil == HIGH))   // Wenn Abstand (mm) kleiner oder gleich UND Ventil offen                
    {
      digitalWrite(in1, HIGH);             // Ventil schließen
      digitalWrite(in2, LOW);              // Ventil schließen
      analogWrite(enA, 255);               // Motor Geschwindigkeit 0-255
      delay(dzeit);                        // Zeit bis Ventil geschlossen
    ventil = LOW;                          // Ventil Status auf geschlossen setzen
    }    

if ((mm >= abstandstop) and (ventil == LOW))      // Wenn Abstand (mm) größer oder gleich UND Ventil geschlossen                
    {
      digitalWrite(in1, LOW);              // Ventil öffnen
      digitalWrite(in2, HIGH);             // Ventil öffnen
      analogWrite(enA, 255);               // Motor Geschwindigkeit 0-255
      delay(dzeit);                        // Zeit bis Ventil geöffnet
      ventil = HIGH;                       // Ventil Status auf offen setzen
    }
  if ((mm >= abstandstop) and (ventil == HIGH))    // Wenn Abstand (mm) größer oder gleich UND Ventil geöffnet                
    {
      digitalWrite(in1, LOW);             // Ventil Stop
      digitalWrite(in2, LOW);              // Ventil Stop
      analogWrite(enA, 255);               // Motor Geschwindigkeit 0-255
    }    


    
// Bewässerung der Pflanzen

if (bewaessern == LOW)
  {
    if (millis() - Pumpe_timestore> einTag )
    {
      digitalWrite(Pumpe, HIGH);
      Pumpe_timestore = millis();
      bewaessern = HIGH;
    }
  }
    else
  {
    if (millis() - Pumpe_timestore> zeitbewaessern)
    {
      digitalWrite(Pumpe, LOW);
      bewaessern = LOW;
    }
  }

//const int Nagel1 = 15;                      // Eingang A1 - Nagel 1 Sensor
//int valNagel1 = 0;                          // Nagel 1 Wert auf 0 initialisieren

//int zeitbewaessern = 5000;          // Zeit wo bewässert wird                          
//int nagelwert = 800;                // Ab diesem Wert wird bewässert                  


}


long microsecondsToMillis(long microseconds)
{
  return microseconds / 3 / 2;
}

Go Up