Bewässerungsautomat Programmversion 0.2 alpha

Achtung!

Es liegt eine neuere Programmversion vor: Bewässerungsautomat Programmversion 0.3 alpha

Gegenüber Programmversion 0.1 alpha wurden insbesondere zwei Änderungen vorgenommen:

Es wird kein LCD verwendet.
Es werden Neopixel anstatt LEDs verwendet.

Anmerkungen:

Das Programm lässt sich kompilieren, wurde aber noch nicht getestet.
Der Analog-Pin A0 ist nur dem Prinzip nach eingebunden. Die Messwerte werden sicherlich nicht zwischen 0 und 100 liegen.

Hilfreicher Link für die vorgenommenen Änderungen:

https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library

Was noch zu tun ist:

Der DHT22 könnte eingebunden werden. Der Sensor misst die Temperatur und Luftfeuchte. Daraus ließe sich der Taupunkt berechnen. Dieser Wert wäre interessant, weil Kondenswasser im Gehäuse gefährlich wäre.
Damit die Neopixel blinken oder pulsieren können, müsste das Programm ohne den delay-Befehl auskommen.
Der Wasserstandssensor für den Vorratstank muss noch „richtig“ eingebunden werden.
Die Helligkeit der Neopixel soll vom Umgebungslicht abhängig sein.
Bluetooth

// Unterschiede zu Programmversion 0.1:
//   - kein LCD
//   - Neopixel anstatt LEDs

// include the library code:
#include <Adafruit_NeoPixel.h>

// Definiert die Pins für die NeoPixels
int neoPin1 = 12;            // Neopixel an Blumenkastenensor 1
int neoPin2 = 11;            // Neopixel an Blumenkastenensor 2
int neoPin3 = 10;            // Neopixel an Blumenkastenensor 3
int neoPin4 = 9;             // Neopixel an Blumenkastenensor 4
int neoPin5 = 8;             // Neopixelring am Wasserstandssensor im Vorratsbehälter
int neoPin6 = 7;             // Neopixelring im Gehäusedeckel

// Definiert die NeoPixels
Adafruit_NeoPixel neopix1 = Adafruit_NeoPixel(1, neoPin1, NEO_RGBW + NEO_KHZ800);
Adafruit_NeoPixel neopix2 = Adafruit_NeoPixel(1, neoPin2, NEO_RGBW + NEO_KHZ800);
Adafruit_NeoPixel neopix3 = Adafruit_NeoPixel(1, neoPin3, NEO_RGBW + NEO_KHZ800);
Adafruit_NeoPixel neopix4 = Adafruit_NeoPixel(1, neoPin4, NEO_RGBW + NEO_KHZ800);
Adafruit_NeoPixel neopix5 = Adafruit_NeoPixel(12, neoPin5, NEO_RGBW + NEO_KHZ800);
Adafruit_NeoPixel neopix6 = Adafruit_NeoPixel(24, neoPin6, NEO_RGBW + NEO_KHZ800);

// Definiert die Pins für die Hall-Sensoren
int hallPin1 = 31;        // Hall-Sensor 1
int hallPin2 = 33;        // Hall-Sensor 2
int hallPin3 = 35;        // Hall-Sensor 3
int hallPin4 = 37;        // Hall-Sensor 4

// Definiert den Pin für den Level-Sensor im Vorratsbehälter
int levelPin = A0;

// Definiert die Pins für die Pumpenrelais
int relPin1 = 30;        // Pumpe 1
int relPin2 = 32;        // Pumpe 2
int relPin3 = 34;        // Pumpe 3
int relPin4 = 36;        // Pumpe 4

// Definiert die Variablen
int hall1 = 0;
int hall2 = 0;
int hall3 = 0;
int hall4 = 0;
int level = 0;

void setup() {
  // Initialisiere die NeoPixel-Pins
  pinMode(neoPin1, OUTPUT);
  pinMode(neoPin2, OUTPUT);
  pinMode(neoPin3, OUTPUT);
  pinMode(neoPin4, OUTPUT);
  pinMode(neoPin5, OUTPUT);
  pinMode(neoPin6, OUTPUT);

  // Initialisiere die Hall-Pins als Input. Außerdem werden die internen Pullup-Widerstände aktiviert.
  // Liegt an dem Hall-Sensor ein Magnetfeld an, ist der Input LOW, ansonsten ist der Input HIGH.
  pinMode(hallPin1, INPUT_PULLUP);
  pinMode(hallPin2, INPUT_PULLUP);
  pinMode(hallPin3, INPUT_PULLUP);
  pinMode(hallPin4, INPUT_PULLUP);

  // Initialisiere die Relais-Pins
  pinMode(relPin1, OUTPUT);
  pinMode(relPin2, OUTPUT);
  pinMode(relPin3, OUTPUT);
  pinMode(relPin4, OUTPUT);

  // Initialisiere den Wasserstandsanzeiger 
  pinMode(level, INPUT);

  // Initialisiere alle NeoPixels
  neopix1.begin();
  neopix1.show(); // Initialize all pixels to 'off'
  neopix2.begin();
  neopix2.show(); // Initialize all pixels to 'off'
  neopix3.begin();
  neopix3.show(); // Initialize all pixels to 'off'
  neopix4.begin();
  neopix4.show(); // Initialize all pixels to 'off'
  neopix5.begin();
  neopix5.show(); // Initialize all pixels to 'off'
  neopix6.begin();
  neopix6.show(); // Initialize all pixels to 'off'
  
  // Debugging output
  Serial.begin(9600);
 
}

void loop() {
  // Auslesen der digitalen Eingänge
  hall1 = digitalRead(hallPin1);
  hall2 = digitalRead(hallPin2);
  hall3 = digitalRead(hallPin3);
  hall4 = digitalRead(hallPin4);
  level = analogRead(levelPin);

  // Ausgabe der Eingangssignale an den Hall-Pins und dem Analog-Pin an die serielle Schnittstelle
  Serial.println(hall1);
  Serial.println(hall2);
  Serial.println(hall3);
  Serial.println(hall4);
  Serial.println(level);

  // Ansteuerung der Pumpen. 
  // Ist der Wasserstand niedrig, liegt kein Magnetfeld am Hall-Sensor an (Input = LOW). 
  // Die entsprechende Pumpe wird aktiviert, bis der Soll-Wasserstand erreicht ist (Input = HIGH), 
  // - sofern keine andere Pumpe läuft und
  // - sofern Wasser im Vorratsbehälter ist.
  if(hall1 = LOW && level > 5 && digitalRead(relPin2) == HIGH && digitalRead(relPin3) == HIGH && digitalRead(relPin4) == HIGH) digitalWrite(relPin1, LOW);
  if(hall1 = HIGH) digitalWrite(relPin1, HIGH);
  
  if(hall2 = LOW && level > 5 && digitalRead(relPin1) == HIGH && digitalRead(relPin3) == HIGH && digitalRead(relPin4) == HIGH) digitalWrite(relPin2, LOW);
  if(hall2 = HIGH) digitalWrite(relPin2, HIGH);
  
  if(hall3 = LOW && level > 5 && digitalRead(relPin1) == HIGH && digitalRead(relPin2) == HIGH && digitalRead(relPin4) == HIGH) digitalWrite(relPin3, LOW);
  if(hall3 = HIGH) digitalWrite(relPin3, HIGH);
  
  if(hall4 = LOW && level > 5 && digitalRead(relPin1) == HIGH && digitalRead(relPin2) == HIGH && digitalRead(relPin3) == HIGH) digitalWrite(relPin4, LOW);
  if(hall4 = HIGH) digitalWrite(relPin4, HIGH);


  // Ansteuerung der NeoPixels in den Blumenkastensensoren
  if(hall1 = LOW) neopix1.setPixelColor(0, 0, 127, 0, 127); //grün-weiß, wenn Wasserstand ok
  if(hall1 = HIGH) neopix1.setPixelColor(0, 255, 0, 0, 0);  //rot, wenn Wasserstand niedrig
  neopix1.show();
  
  if(hall2 = LOW) neopix2.setPixelColor(0, 0, 127, 0, 127); //grün-weiß, wenn Wasserstand ok
  if(hall2 = HIGH) neopix2.setPixelColor(0, 255, 0, 0, 0);  //rot, wenn Wasserstand niedrig
  neopix2.show();
  
  if(hall3 = LOW) neopix3.setPixelColor(0, 0, 127, 0, 127); //grün-weiß, wenn Wasserstand ok
  if(hall3 = HIGH) neopix3.setPixelColor(0, 255, 0, 0, 0);  //rot, wenn Wasserstand niedrig
  neopix3.show();
  
  if(hall4 = LOW) neopix4.setPixelColor(0, 0, 127, 0, 127); //grün-weiß, wenn Wasserstand ok
  if(hall4 = HIGH) neopix4.setPixelColor(0, 255, 0, 0, 0);  //rot, wenn Wasserstand niedrig
  neopix4.show();


  //Ansteuerung des NeoPixel-Rings im Wasserstandssensor für den Vorratsbehälter

  neopix5.setPixelColor(0, 0, 0, 0, 127);
  neopix5.setPixelColor(11, 0, 0, 0, 127);
 
    if (level >= 90) {
      neopix5.setPixelColor(10, 0, 127, 0, 0);
    } else if (level < 90) {
      neopix5.setPixelColor(10, 0, 0, 0, 0);
    }
    
    if (level >= 80) {
      neopix5.setPixelColor(9, 0, 127, 0, 0);
    } else if (level < 80) {
      neopix5.setPixelColor(9, 0, 0, 0, 0);
    }
    
    if (level >= 70) {
      neopix5.setPixelColor(8, 0, 127, 0, 0);
    } else if (level < 70) {
      neopix5.setPixelColor(8, 0, 0, 0, 0);
    }
    
    if (level >= 60) {
      neopix5.setPixelColor(7, 0, 127, 0, 0);
    } else if (level < 60) {
      neopix5.setPixelColor(7, 0, 0, 0, 0);
    }
    
    if (level >= 50) {
      neopix5.setPixelColor(6, 64, 64, 0, 0);
    } else if (level < 50) {
      neopix5.setPixelColor(6, 0, 0, 0, 0);
    }
    
    if (level >= 40) {
      neopix5.setPixelColor(5, 64, 64, 0, 0);
    } else if (level < 40) {
      neopix5.setPixelColor(5, 0, 0, 0, 0);
    }
    
    if (level >= 30) {
      neopix5.setPixelColor(4, 64, 64, 0, 0);
    } else if (level < 30) {
      neopix5.setPixelColor(4, 0, 0, 0, 0);
    }
    
    if (level >= 20) {
      neopix5.setPixelColor(3, 127, 0, 0, 0);
    } else if (level < 20) {
      neopix5.setPixelColor(3, 0, 0, 0, 0);
    }
    
    if (level >= 10) {
      neopix5.setPixelColor(2, 127, 0, 0, 0);
    } else if (level <10) {
      neopix5.setPixelColor(2, 0, 0, 0, 0);
    }
    
    neopix5.show();
    
    
  delay(1000);                    // 1 Sek Pause
}

Tags: #Arduino #Bewässerungsautomat #Code