home Herstellungstechnologie Produktionsanlagen
Industrielle Fertigung
Industrielles Internet der Dinge | Industrielle Materialien | Gerätewartung und Reparatur | Industrielle Programmierung |
home  MfgRobots >> Industrielle Fertigung >  >> Manufacturing Technology >> Industrietechnik

Automatisches Pflanzenbewässerungs- und Bewässerungssystem – Schaltkreis, Code und Projektbericht

Automatische Anlage Bewässerung System – Vollständiger Quellcode, Schaltungs- und Projektbericht – PDF-Download

Einführung

Im täglichen Betrieb ist das Gießen der Pflanzen die wichtigste kulturelle Praxis und die arbeitsintensivste Aufgabe. Egal welches Wetter es ist, entweder zu heiß und kalt oder zu trocken und nass, es ist sehr wichtig, die Wassermenge zu kontrollieren, die zu den Pflanzen gelangt. Es wird also effektiv sein, eine Idee eines automatischen Pflanzenbewässerungssystems zu verwenden, das Pflanzen bewässert, wenn sie es brauchen. Ein wichtiger Aspekt dieses Projekts ist:„wann und wie viel zu gießen“. Um manuelle Tätigkeiten für den Menschen zum Gießen von Pflanzen zu reduzieren, wird eine Idee eines Pflanzenbewässerungssystems übernommen. Die Methode zur kontinuierlichen Überwachung der Bodenfeuchtigkeit und zur Entscheidung, ob eine Bewässerung erforderlich ist oder nicht und wie viel Wasser in der Pflanzenerde benötigt wird. Dieses Projekt kann in Subsysteme wie gruppiert werden; Stromversorgung, Relais, Magnetventil, Arduino GSM-Schild, Bodenfeuchtesensor und LCD.

Im Wesentlichen ist das System so konzipiert und programmiert, dass der Bodenfeuchtesensor den Feuchtigkeitsgehalt der Pflanzen zu einem bestimmten Zeitpunkt erfasst, wenn der Feuchtigkeitsgehalt des Sensors unter dem angegebenen Wert liegt des Schwellenwerts, der entsprechend dem Wasserbedarf der jeweiligen Pflanze vordefiniert ist, dann wird die gewünschte Wassermenge zugeführt, bis sie den vordefinierten Schwellenwert erreicht.

Das System meldet seinen aktuellen Zustand und sendet die Erinnerungsnachricht zum Gießen von Pflanzen und zum Nachfüllen von Wasser in den Tank. All diese Benachrichtigungen können mit dem Arduino GSM-Schild erfolgen.

Ziel des Projekts:

Da heutzutage, im Zeitalter der fortschrittlichen Technologie und Elektronik, der Lebensstil des Menschen smarter, einfacher, einfacher und viel bequemer sein soll. Also deshalb; Es besteht ein Bedarf an vielen automatisierten Systemen im täglichen Leben der Menschen, um ihre täglichen Aktivitäten und Jobs zu reduzieren. Hier ist eine Idee eines solchen Systems, das als automatisches Pflanzenbewässerungssystem bezeichnet wird, sehr nützlich. Viele Menschen haben große Probleme damit, die Pflanzen im Garten zu gießen, besonders wenn sie nicht zu Hause sind. Dieses Modell verwendet Sensortechnologien mit Mikrocontrollern, um ein intelligentes Schaltgerät herzustellen, das Millionen von Menschen hilft.

In seiner grundlegendsten Form ist das System so programmiert, dass der Bodenfeuchtigkeitssensor den Feuchtigkeitsgehalt der Pflanze zu einem bestimmten Zeitpunkt erfasst, wenn der Feuchtigkeitsgehalt des Sensors vorhanden ist kleiner als der festgelegte Schwellenwert ist, der entsprechend der bestimmten Pflanze vordefiniert ist, dann wird der Pflanze die gewünschte Wassermenge zugeführt, bis ihr Feuchtigkeitsniveau den vordefinierten Schwellenwert erreicht. Das System umfasst einen Feuchtigkeits- und Temperatursensor, der die aktuelle Atmosphäre des Systems verfolgt und einen Einfluss darauf hat, wann die Bewässerung erfolgt. Das Magnetventil steuert den Wasserfluss im System, wenn Arduino den Wert vom Feuchtigkeitssensor liest, löst es das Magnetventil entsprechend dem gewünschten Zustand aus. Darüber hinaus meldet das System seine aktuellen Zustände und sendet die Erinnerungsnachricht zum Gießen von Pflanzen und erhält eine SMS vom Empfänger. All diese Benachrichtigungen können mit dem Arduino GSM-Schild erfolgen.

Hintergrund des Systems

In der Schule wurde anhand der Bücher der Wissenschaft studiert, dass die Pflanzen in vielerlei Hinsicht für die gesamte Menschheit sehr wichtig sind. Denn sie halten die Umwelt sauber, indem sie von Zeit zu Zeit frischen Sauerstoff produzieren. Automatische Pflanzenbewässerungssysteme werden mit der Zunahme von Alltagsgegenständen, die mit fortschrittlichen Technologien verbunden sind, immer häufiger und diese Systeme werden immer häufiger implementiert. Orte wie Wohnungen sowie auf industrieller Ebene. Der Hauptnutzen dieser Systeme ist Effizienz und Benutzerfreundlichkeit.

Pflanzenbewässerungssystem bietet Pflanzenliebhabern die Möglichkeit, ihre heimische Pflanze während ihrer Abwesenheit mitzunehmen – durch den Einsatz effizienter und zuverlässiger Komponenten, wie z. B. verschiedener Arten von Sensortechnologien.

Es gibt verschiedene/unkomplizierte Arten von Bewässerungssystemen für Zimmerpflanzen, je nach benötigtem Automatisierungsgrad.

Im abschließenden PDF-Bericht (kostenloser herunterladbarer Link ist am Ende des Beitragsinhalts angegeben) werden die folgenden Abschnitte detailliert beschrieben.

Verwandtes Projekt:Was sind ATMega-Mikrocontroller und wie kann man damit ein LED-Projekt erstellen?

Produkt- und Komponentenspezifikationen

Anforderungs-ID SRS-GSM-001
Titel GSM-Modul
Beschreibung Das System enthält das GSM-Modul, das Alarm-SMS an den Empfänger sendet und eine SMS vom Benutzer empfängt.
Version Version 1.0
Anforderungs-ID SRS-Mikrocontroller -001
Titel ATmega328p
Beschreibung Das System enthält den Mikrocontroller, der normalerweise mit Arduino Uno geliefert wird. Dieser Mikrocontroller liest die Messwerte des Sensors und steuert das Gesamtsystem.
Version Version 1.0
Anforderungs-ID SRS-Temperatur und Luftfeuchtigkeit-001
Titel DHT11
Beschreibung Das System umfasst den Temperatur- und Feuchtigkeitssensor, der die aktuellen Temperatur- und Feuchtigkeitswerte der Umgebung verfolgt und den Messwert an den Mikrocontroller zurücksendet.
Version Version 1.0
Anforderungs-ID SRS-Feuchtigkeit-001
Titel Grove-Bodenfeuchtigkeitssensor
Beschreibung Das System umfasst den Bodenfeuchtigkeitssensor, der den Messwert von der Feuchtigkeit des Bodens nimmt und den Messwert an den Mikrocontroller zurücksendet.
Version Version 1.0
Anforderungs-ID SRS-LCD-001
Titel Hitachi-16×2-LCD
Beschreibung Das System enthält die LCD-Schnittstelle für den Benutzer, die die von den verschiedenen Sensoren im System erfassten Messwerte anzeigt.
Version Version 1.0

Verwandter Beitrag:Arduino-Programmierung:Was ist Arduino und wie wird es programmiert?

Arduino-basiertes automatisches Pflanzenbewässerungssystem:

Blockdiagramm der automatischen Pflanzenbewässerung

Schematisches Schaltbild eines automatischen Pflanzenbewässerungs- und Bewässerungssystems

Nach diesem System gibt es in diesem Projekt zwei Funktionskomponenten, nämlich Feuchtigkeitssensor und Motor/Wasserpumpe. In seiner einfachsten Form misst der Feuchtigkeitssensor das Niveau der Bodenfeuchtigkeit. Dann versorgt der Motor/die Wasserpumpe die Pflanzen mit Wasser.

Zum Vergrößern Bild anklicken

Das Schema oben in der obigen Abbildung beschreibt das Gesamtverhalten des Systems. Project verwendet Arduino Uno, um den Motor zu steuern. Es besteht aus einer H-Brücke, die den Fluss des Servomotors steuert, dh Takt- oder Gegentaktrichtung. Der Feuchtigkeitssensor misst den Bodenstand und sendet das Signal an Arduino, dann öffnet Arduino den Servomotor, wenn eine Bewässerung erforderlich ist. Dann versorgt die Motor-/Wasserpumpe die Pflanzen mit Wasser, bis der gewünschte Feuchtigkeitsgrad erreicht ist.

Formen Sie den Prototyp in der obigen Abbildung. Der Feuchtigkeitssensor erfasst den Feuchtigkeitsgehalt und sendet das Signal an Arduino, und dann öffnet Arduino die Wasserpumpe mit Hilfe der H-Brücke und bewässert die jeweilige Pflanze. Dies erfolgt mithilfe der Arduino IDE-Software.

Verwandtes Projekt:Elektronisches Projekt zur Ampelsteuerung mit IC 4017 &555 Timer

Projektdesign

In diesem Abschnitt geht es um abgeschlossene Arbeiten im Software- und Hardwaredesign. Es gibt auch einen Einblick darüber, was das System beinhaltet und warum verschiedene Komponenten ausgewählt wurden, um ein vollständig fertiges automatisches Pflanzenbewässerungssystem herzustellen. Betrachten Sie ein Diagramm in Abbildung zeigt das grundlegende konzeptionelle Modell des Systems mit ausgewählten Komponenten.

Die Funktionalität des in der obigen Abbildung gezeigten Blockdiagramms des automatisierten Pflanzenbewässerungssystems ist unten dargestellt:

Weitere Details zu den Komponenten finden Sie in der PDF-Datei (unten)

Verwandtes Projekt:Was ist Raspberry Pi? Projekte mit Raspberry Pi erstellen

Hardwaredesign

Sensorschema

Abbildung unten zeigt das Schema der Sensorschaltung. Wie alle Sensoren, die mit dem analogen Arduino-Pin A0-A3 verbunden sind. Pin A0 war für den Temperatur- und Feuchtigkeitssensor reserviert, während die Pins A1-A3 für Feuchtigkeitssensoren reserviert waren. Alle Sensoren haben eine gemeinsame Stromversorgung von 5 V und Masse, wie im Schema gezeigt.

LCD-Schema :

Abbildung unten zeigt das Schema des LCD. Der digitale Pin 8 – 13 wurde für das LCD reserviert, wie im Schema gezeigt. Pin 1 und Pin 3 sind die Stromversorgung und Masse, während Pin 2 der Kontraststift auf dem LCD ist, der den Kontrast steuert und mit dem Potentiometer verbunden ist. Beim Anschließen von LCD muss beachtet werden, dass digitale Pins von Arduino und Datenpins von LCD in der richtigen Reihenfolge angeschlossen werden müssen, da LCD sonst nur Müll auf dem Bildschirm anzeigt.

Magnetspulenschema

Diagramm unten in der Abbildung unten zeigt den Schaltplan des Magnetkreises. Digital Pin 4 – 7 war für die Solenoide reserviert. Da die Schaltung aus Relais, Transistoren, Widerständen und LEDs anstelle des Solenoids besteht (CadStar hat kein Solenoid-Symbol). Im Schaltplan verwendet das Relais 5 V. Während 5 V auch in den NO-Kanal der Relais gehen, liegt dies daran, dass im Schaltplan LEDs den Magneten ersetzen, der mit (5 V) arbeitet, gefolgt von einem 220-Ohm-Widerstand.

Also, wenn die Spannung an die Basis der Transistoren angelegt wird. Der Transistor schaltet auf Masse, wodurch die Spule des Relais magnetisiert werden kann, und schaltet sich selbst auf einen normalerweise geschlossenen Kanal, wodurch die mit diesem bestimmten Relais verbundene LED aufleuchtet und wenn die an der Transistorbasis anliegende Spannung abfällt, schaltet sich der Transistor wieder in den Normalzustand zurück und die Spule des Relais wird entmagnetisiert und das Relais schaltet wieder auf NO-Kanal, wodurch die LED wieder ausgeht.

Nachdem der gesamte Schaltplan der Schaltung fertiggestellt ist, besteht der nächste Schritt darin, sie auf dem Veroboard zu bauen. Es ist wichtig, die Schaltung auf dem Stripboard-Layout-Planungsblatt im Voraus zu entwerfen, da es bestimmte Prinzipien für das Entwerfen einer Schaltung auf Veroboard gibt, die wie folgt sind:

  1. Markieren Sie zuerst die Vs- und GND-Stromleitung oben rechts auf dem Planungsblatt für das Stripboard-Layout.
  2. Denken Sie daran, die Leiterbahn zwischen den Pins eines ICs zu schneiden. Markieren Sie die Schnitte auf dem Diagramm mit einem X.
  3. Versuchen Sie, Widerstände und Axialkondensatoren flach auf die Platine zu legen. Widerstände benötigen in der Regel einen Abstand von 4 Löchern, Kondensatoren einen Abstand von 8 Löchern.
  4. Nummeriert möglichst die Pins der ICs. Die Unterseite des Veroboards besteht aus den Kupferbahnen, in denen die Spannung horizontal verläuft. Verschiedene Veroboard-Designs der obigen Schaltpläne sind unten dargestellt:

Verwandtes Projekt:Vollautomatischer Wasserstandsregler mit SRF04

Softwaredesign

Nachdem Sie die Hardware fertiggestellt haben, ist es an der Zeit, die Hardware mit der Software zu testen. In diesem Abschnitt wird die Implementierung des Softwaredesigns für jede der verschiedenen Automatisierungen/Technologien, die innerhalb des Systems verwendet werden, detailliert beschrieben. Dies schließt den Arduino-Code ein, der auf den Arduino geschrieben und hochgeladen wurde.

Das erste, was getan wurde, war, die Solenoidschaltung zum Laufen zu bringen und wie sich das Solenoid aus Sicht des Mikrocontrollers verhalten würde. Dafür wurde ein kleines Flussdiagramm erstellt, das im Abschnitt Softwarefluss in der obigen Abbildung zu sehen ist.

Arduino IDE wurde verwendet, um die Software auf den Arduino hochzuladen. Für die grundlegende Solenoidschaltung wurde ein einfaches Programm geschrieben, das die LED grundsätzlich alle 1 Sekunde blinkt. Anfangs wurden die digitalen Pins 4, 5, 6 und 7 definiert, die das Programm und die Schaltung testen. Wenn das Programm also läuft, nimmt es alle grundlegenden Initialisierungen vor, definiert alle Ausgangspins in void setup () und springt dann in die void-Schleife (), wo es ständig läuft und alle 1 Sekunde LEDs blinkt.

Danach wurde ein kleines Programm geschrieben und auf das Arduino hochgeladen, das die Messwerte von den verschiedenen Sensoren erhält und sie auf dem LCD druckt. Dafür wurde ein kleines Flussdiagramm erstellt, das auch unter Softwareflussabschnitt in der gegebenen Abbildung zu sehen ist. Wenn das Programm in die Void-Schleife () geht, erhält es die Messwerte vom Sensor, führt alle grundlegenden Berechnungen durch und druckt sie auf dem LCD aus.

Verwandtes grundlegendes Elektronikprojekt:Automatisches Straßenlaternensteuerungssystem mit LDR &BC 547 Transistor

Als nächstes muss die Software für das GSM-Modul auf den Arduino hochgeladen werden, über den GSM mit dem Mikrocontroller kommunizieren könnte. Zunächst wurde ein Modemtest durchgeführt, der alle grundlegenden Initialisierungen und Bibliotheken für das GSM durchführt und die IMEI-Nummer erhält und prüft, ob das Modem ordnungsgemäß funktioniert, sobald die Kommunikation mit Arduino beginnt. Der nächste Schritt ist der Netzwerkverbindungstest, der das GSM grundsätzlich initialisiert und alle anderen Netzwerke anzeigt, die das GSM-Modul unterstützen kann.

Sobald das GSM-Modul getestet wurde und ordnungsgemäß funktioniert, ist es an der Zeit, das GSM-Modul zu verwenden, um mit dem Empfänger zu kommunizieren, was bedeutet, dass SMS an den Empfänger gesendet und SMS von ihm empfangen werden. Dazu wurde ein weiteres einfaches Arduino-Verdrahtungsprogramm geschrieben und auf den Arduino hochgeladen. Das Programm initialisiert den GSM und sendet SMS an den Empfänger, im Gegensatz dazu wurde ein anderes Arduino-Programm geschrieben, in dem GSM die SMS vom Endbenutzer empfängt.

Nachdem das gesamte Softwaredesign abgeschlossen ist, ist es schließlich an der Zeit, das gesamte Softwaredesign zusammenzuführen und eine endgültige funktionierende Software für das System zu erstellen. Es wurden verschiedene Algorithmusansätze angewendet, die im Abschnitt Softwarefluss zu sehen sind, um die endgültige Software zum Laufen zu bringen und das zu tun, was sie tun soll. Die obige Abbildung zeigt die Funktionsweise der endgültigen Software, bei der sie eine Messung durchführt, SMS sendet, SMS empfängt und mit dem beginnt, was sie zuvor getan hat.

Hinweis:Der gesamte Softwarecode kann im Anhang unten eingesehen werden.

HINWEIS:Der gesamte Softwarecode kann im Anhang eingesehen werden. Die Ausgabe des Modemtests und des Netzwerkverbindungstests wurde nicht in den Bericht aufgenommen, da der eigentliche Bericht nach der Einreichung der Hardware erstellt wurde.

Verwandtes Projekt:Wie erstellt man grundlegende Elektro- und Elektronikprojekte in LabVIEW?

Projektaufbau und  Softwaretests

Nachdem das gesamte Hardware- und Softwaredesign erfolgreich abgeschlossen wurde, ist es an der Zeit, das Projekt zu erstellen und zu testen. In diesem Abschnitt des Berichts werden Details dazu gegeben, wie die unterschiedlichen Hardwaredesigns implementiert und getestet werden. In diesem Abschnitt wird auch darüber gesprochen, ob es versteckte Probleme im Softwarecode gab, die wichtig waren, um Fehler zu beheben und zu evakuieren und das Projekt erfolgreich zu erstellen. Der Schritt-für-Schritt-Prozess kann im vollständigen Projektbericht in der unten angegebenen PDF-Datei eingesehen werden, wie z. B. Konstruktions- und Testverfahren.

Softwaretests

Die Software-Testphase ist ebenfalls ein wichtiger Aspekt der Projektentwicklung. Softwaretesten ist ein Verfahren zum Ausführen eines Programms oder einer Anwendung mit dem Ziel, Softwarefehler zu finden. Es kann auch als Prozess der Validierung und Verifizierung ausgedrückt werden, dass ein Softwareprogramm oder eine Anwendung ihre technischen Anforderungen erfüllt, wie akzeptiert funktioniert und mit einer ähnlichen Marke ausgeführt werden kann. Um die Software zu testen, wurden verschiedene Ansätze verfolgt. Ein Dokument zur Softwareanforderungsspezifikation (SRS) wurde geschrieben, das das erwartete Verhalten eines Softwaresystems vollständig anspricht.

Verwandtes Projekt:Clap Switch Circuit Electronic Project mit 555 Timer

Anforderungs-ID SRS-Sensor-010
Titel Sensor
Beschreibung Sensoren im System erfassen die Messwerte und senden sie an den Mikrocontroller zurück.
Version V 1.0
Anforderungs-ID SRS-Daten-020
Titel Datenanzeige
Beschreibung Wenn die Benutzer versuchen, den Messwert vom System abzurufen. Das Display sollte dem Benutzer beispielsweise Daten angezeigt haben:Temperatur- und Feuchtigkeitswert, gefolgt von Feuchtigkeitsmesswerten.
Version V1.0
Anforderungs-ID SRS-Mikrocontroller-030
Titel Mikrocontroller
Beschreibung Mikrocontroller im System fungieren als Gehirn des Systems, das alles im System verwaltet
Version V1.0
Anforderungs-ID SRS-Latch-040
Titel Verriegelung
Beschreibung Latch im System erweitert die digitalen Pins für den Mikrocontroller
Version V1.0
Anforderungs-ID SRS-GSM-050
Titel GSM
Beschreibung Das System reagiert, indem es eine SMS-Benachrichtigung an den Empfänger sendet, wenn der Mikrocontroller es dazu auffordert.
Version V1.0

Nach dem Schreiben des SRS-Dokuments ging das Softwaredesign in die statische Testphase über, die die Überprüfung des Dokuments beinhaltet. Hier erfolgt die Überprüfung der Anforderungen. Im Folgenden werden vier verschiedene Arten von Überprüfungsmethoden definiert:

  1. Inspektion (I): Kontrolle oder visuelle Überprüfung
  2. Analyse (A):Verifizierung basierend auf analytischen Nachweisen
  3. Demonstration (D):Überprüfung der Betriebseigenschaften, ohne quantitative Messung.
  4. Test (T):Überprüfung quantitativer Merkmale mit quantitativer Messung. Für jede Anforderung des SRS-Dokuments wird eine Verifizierungsmethode mit den Abkürzungen I, A, D und T definiert.

Verifizierung:

aus
Anforderungs-ID Titel der Anforderung Methode
REQ-010 Überprüfen Sie, ob die Sensoren des Systems Messwerte erhalten I
REQ-020 Vergewissern Sie sich, dass die Daten auf dem Bildschirm angezeigt werden. D
REQ-030 Es wurde verifiziert, dass der Mikrocontroller des Systems ordnungsgemäß verwaltet oder funktioniert, da er für jede Anfrage ein 100%-iges Ergebnis liefert. D
REQ-040 Stellen Sie sicher, dass die Latch-Schaltung das tat, was sie tun sollte. Das nimmt sin 3 Input und spuckt 8 PinsA
REQ-050 Überprüfen Sie, ob die SMS per GSM gesendet und empfangen wurde D

Ergebnisse

Da alle Tests mit zufriedenstellendem Ergebnis durchgeführt wurden. Da es kein besonderes Ergebnis gibt, das dokumentiert werden muss. Da das System mit einem Feuchtigkeits- und DHT11-Sensor (Temperatur und Feuchtigkeit) arbeitet, der die aktuelle Raumtemperatur und -feuchtigkeit misst. Die Messwerte des Feuchtigkeitssensors im Kreislauf hängen auch vom aktuellen Feuchtigkeitsgehalt der Pflanze ab. Ansonsten war das Gesamtergebnis der Schaltung in Bezug auf die Funktionalität gut für die Motivation.

Verwandter Beitrag:Arduino PWM-Programmierung und ihre Funktionen in Arduino

Endgültiger und vollständiger Softwarecode für automatische Bewässerungsanlagen und Bewässerungssysteme

Hinweis: Weitere Codes im Zusammenhang mit dem Projekt finden Sie in der PDF-Datei, z. B. Beispielcode zum Testen des Magnetventils, Code zum Testen von Systemsensoren, GSM-Modem-Testcode, GSM-Netzwerkverbindungscode, GSM-Sende-SMS-Warncode, GSM-Empfangs-SMS-Code,

Endgültiger Projektcode für die automatische Bewässerung von Pflanzen 

#include <dht.h>
#define dht_dpin A0
dht DHT;
//———————–
#include <LiquidCrystal.h>
LiquidCrystal lcd (8, 9, 10, 11, 12, 13);
//———————————-
int plantPotMoisture[3] = {A1, A2, A3};
//———————
#include <GSM.h>
#define PINNUMBER “”
GSM gsmAccess; // include a ‘true’ parameter for debug enabled
GSM_SMS sms;
char remoteNumber[] = “0899506304”;
String moistureMessage = “Moisture is Low on sensor: “;
String SMS_Alert = “Sending SMS!”;
String humidityMsg = “Humidity is High. Open All Solenoids”;
String tempMsg = “Temperature is too HIGH!..Open ALl Solenoids “;
String messageBuffer = “”;
char senderNumber[20];
String stringOne = “Opens1”;
String stringTwo = “Opens2”;
String stringThree = “Opens3”;
String stringFour = “OpenAll”;
//—————
#define solenoidData 5
#define solenoidClockster 4
#define solenoidLatch 6
//—————
const int master = 0;
const int slave1 = 1;
const int slave2 = 2;
const int slave3 = 3;
boolean takeReadings = true;
int serialSolenoidOutput = 0;
void setup()
{
pinMode(solenoidData, OUTPUT);
pinMode(solenoidClockster, OUTPUT);
pinMode(solenoidLatch, OUTPUT);
digitalWrite(solenoidLatch, HIGH);
digitalWrite(solenoidLatch, LOW);
shiftOut(solenoidData, solenoidClockster, MSBFIRST, 0);
digitalWrite(solenoidLatch, HIGH);
//————————-
Serial.begin(9600);
lcd.begin (16, 2);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Wait Until”);
lcd.setCursor(0, 1);
lcd.print(“GSM Initialized!”);
boolean notConnected = true;
while (notConnected)
{
if (gsmAccess.begin(PINNUMBER) == GSM_READY)
notConnected = false;
else
{
Serial.println(“Not connected”);
delay(1000);
}
}
}
void loop()
{
if (takeReadings)
{
moistureSensor();
TempAndHumidity ();
if (DHT.humidity > 50 || DHT.temperature > 25 && takeReadings )
{
takeReadings = false;
if (DHT.humidity > 50)
{
sendSMS(humidityMsg);
}
else if (DHT.temperature > 25)
{
sendSMS(tempMsg);
}
while (!takeReadings)
recieveSMS();
}
if (plantPotMoisture[0] > 30 || plantPotMoisture[1] > 30 || plantPotMoisture[2] > 30 && takeReadings)
{
takeReadings = false;
if (plantPotMoisture[0] > 30)
{
sendSMS(moistureMessage + “1”);
}
else if (plantPotMoisture[1] > 30)
{
sendSMS(moistureMessage + “2”);
}
else
{
sendSMS(moistureMessage + “3”);
}
while (!takeReadings)
recieveSMS();
}
}
}
void moistureSensor()
{
for (int i = 0 ; i < 3; i++)
{
lcd.clear();
plantPotMoisture[i] = analogRead(i);
plantPotMoisture[i] = map(plantPotMoisture[i], 550, 0, 0, 100);
Serial.print(“Mositure” + i );
lcd.print(“Mositure” + i);
Serial.print(plantPotMoisture[i]);
lcd.print(plantPotMoisture[i]);
Serial.println(“%”);
lcd.print(“%”);
delay(1000);
}
}
void TempAndHumidity ()
{
DHT.read11(dht_dpin);
lcd.setCursor(0, 0);
lcd.print(“Humidity=”);
Serial.print(“Current humidity = “);
Serial.print(DHT.humidity);
lcd.print(DHT.humidity);
lcd.print(“%”);
Serial.print(“%”);
Serial.print(“temperature = “);
Serial.print(DHT.temperature);
Serial.println(“C”);
lcd.setCursor(0, 1);
lcd.print(“temp=”);
lcd.print(DHT.temperature);
lcd.print(“C “);
delay(1000);
lcd.clear();
}
void sendSMS(String messageToSend)
{
Serial.print(“Sending a message to mobile number: “);
Serial.println(remoteNumber);
Serial.println(“SENDING”);
lcd.print(SMS_Alert);
Serial.println();
Serial.println(“Message:”);
Serial.println(messageToSend);
sms.beginSMS(remoteNumber);
sms.print(messageToSend);
sms.endSMS();
Serial.println(“\nCOMPLETE!\n”);
lcd.clear();
lcd.print(“Completed!!!”);
}
void recieveSMS()
{
char c;
if (sms.available())
{
lcd.clear();
lcd.print(“Message received from:”);
delay(800);
lcd.clear();
sms.remoteNumber(senderNumber, 20);
lcd.print(senderNumber);
while (c = sms.read())
{
Serial.println(c);
messageBuffer += c;
}
Serial.println(messageBuffer);
if (messageBuffer == stringOne)
{
toggleSolenoid1();
takeReadings = true;
}
else if (messageBuffer == stringTwo)
{
toggleSolenoid2();
takeReadings = true;
}
else if (messageBuffer == stringThree)
{
toggleSolenoid3();
takeReadings = true;
}
else if (messageBuffer == stringFour)
{
toggleAll();
takeReadings = true;
}
else
{
takeReadings = true;
}
messageBuffer = “”;
Serial.println(“\nEND OF MESSAGE”);
// Delete message from modem memory
sms.flush();
Serial.println(“MESSAGE DELETED”);
}
delay(1000);
}
void toggleSolenoid1()
{
solenoidWrite(master, HIGH);
delay(1000);
solenoidWrite(slave1, HIGH);
delay(1000);
solenoidWrite(slave1, LOW);
delay(1000);
solenoidWrite(master, LOW);
delay(1000);
}
void toggleSolenoid2()
{
solenoidWrite(master, HIGH);
delay(1000);
solenoidWrite(slave2, HIGH);
delay(1000);
solenoidWrite(slave2, LOW);
delay(1000);
solenoidWrite(master, LOW);
delay(1000);
}
void toggleSolenoid3()
{
solenoidWrite(master, HIGH);
delay(1000);
solenoidWrite(slave3, HIGH);
delay(1000);
solenoidWrite(slave3, LOW);
delay(1000);
solenoidWrite(master, LOW);
delay(1000);
}
void toggleAll()
{
solenoidWrite(master, HIGH);
delay(1000);
solenoidWrite(slave1, HIGH);
delay(1000);
solenoidWrite(slave2, HIGH);
delay(1000);
solenoidWrite(slave3, HIGH);
delay(1000);
solenoidWrite(slave1, LOW);
delay(1000);
solenoidWrite(slave2, LOW);
delay(1000);
solenoidWrite(slave3, LOW);
delay(1000);
solenoidWrite(master, LOW);
delay(1000);
}
void solenoidWrite(int pin, bool state)
{
if ( pin >= 0 && pin < 8)
{
if (state)
serialSolenoidOutput |= (1 << pin);
else
serialSolenoidOutput &= ~(1 << pin);
}
digitalWrite(solenoidLatch, LOW);
shiftOut(solenoidData, solenoidClockster, MSBFIRST, serialSolenoidOutput);
digitalWrite(solenoidLatch, HIGH);
}

Full Project Report Automatic Watering Plants System (PDF) Free Download

Automated Plant Watering System PDF 4.18MB 77 Here

Related Post:How To Design a PCB (Step by Step &Pictorial Views)

About the author

-Department of Engineering School of Informatics &Engineering Institute of Technology, Blanchardstown Dublin 15


Industrietechnik

  • Herstellungsprozess
  • 3d Drucken
  • Automatisierungssteuerung System
  • Industrietechnik
    1. Wahrscheinliche Fehler in bewährten Systemen
    2. Schaltung und Funktionsweise des automatischen Türöffnungssystems mit Bewegungserkennung
    3. Arduino-Alarmsystem:SERENA
    4. Automatisches Pflanzenbewässerungssystem mit Arduino
    5. Bewässerungssystem für Heimpflanzen
    6. Automatisches Bewässerungssystem
    7. Überleben eines Steuerungssystem-Migrationsprojekts
    8. Häufige Verletzungen des Elektrogesetzes, die Sie kennen sollten
    9. Automatikgetriebe verstehen
    10. Verständnis des automatischen Schmiersystems