Système d'arrosage et d'irrigation automatique des plantes - Circuit, code et rapport de projet
Installation automatique Arrosage Système – Code source complet, circuit et rapport de projet – Téléchargement PDF
Introduction
Dans les opérations quotidiennes liées à l'arrosage des plantes, il s'agit de la pratique culturelle la plus importante et de la tâche la plus exigeante en main-d'œuvre. Peu importe le temps qu'il fait, qu'il soit trop chaud et froid ou trop sec et humide, il est très important de contrôler la quantité d'eau qui atteint les plantes. Ainsi, il sera efficace d'utiliser une idée de système d'arrosage automatique des plantes qui arrose les plantes quand elles en ont besoin. Un aspect important de ce projet est que :« quand et combien arroser ». Pour réduire les activités manuelles de l'homme à l'arrosage des plantes, une idée de système d'arrosage des plantes est adoptée. La méthode utilisée pour surveiller le niveau d'humidité du sol en continu et pour décider si l'arrosage est nécessaire ou non, et combien d'eau est nécessaire dans le sol de la plante. Ce projet peut être regroupé en sous-systèmes tels que ; alimentation, relais, électrovanne, blindage Arduino GSM, capteur d'humidité du sol et LCD.
Essentiellement, le système est conçu et programmé de telle manière que le capteur d'humidité du sol détecte le niveau d'humidité des plantes à un moment donné, si le niveau d'humidité du capteur est inférieur à la valeur spécifiée de seuil qui est prédéfini en fonction des besoins en eau de la plante particulière, puis la quantité d'eau souhaitée est fournie jusqu'à ce qu'elle atteigne la valeur de seuil prédéfinie.
Le système signale ses états actuels et envoie le message de rappel concernant l'arrosage des plantes et l'ajout d'eau dans le réservoir. Toutes ces notifications peuvent être effectuées en utilisant le shield Arduino GSM.
- Projet connexe : Circuit d'alarme de pluie - Projet de détecteur de neige, d'eau et de pluie
Objectif du projet :
Depuis que de nos jours, à l'ère de la technologie de pointe et de l'électronique, le style de vie de l'humain devrait être intelligent, plus simple, plus facile et beaucoup plus pratique. Ainsi donc; il y a un besoin pour de nombreux systèmes automatisés dans la routine de la vie quotidienne de l'homme pour réduire ses activités et son travail quotidiens. Ici, une idée d'un tel système nommé système d'arrosage automatique des plantes est très utile. Comme beaucoup de gens sont confrontés à de nombreux problèmes pour arroser les plantes du jardin, surtout lorsqu'ils sont loin de chez eux. Ce modèle utilise des technologies de capteurs avec microcontrôleur afin de créer un dispositif de commutation intelligent pour aider des millions de personnes.
Dans sa forme la plus élémentaire, le système est programmé de telle manière que le capteur d'humidité du sol qui détecte le niveau d'humidité de la plante à un moment donné, si le niveau d'humidité du capteur est inférieure à la valeur de seuil spécifiée qui est prédéfinie en fonction de la plante particulière que la quantité d'eau souhaitée est fournie à la plante jusqu'à ce que son niveau d'humidité atteigne la valeur de seuil prédéfinie. Le système implique un capteur d'humidité et de température qui surveille l'atmosphère actuelle du système et a une influence sur le moment de l'arrosage. L'électrovanne contrôlera le débit d'eau dans le système, lorsque Arduino lit la valeur du capteur d'humidité, il déclenche l'électrovanne en fonction de la condition souhaitée. De plus, le système signale ses états actuels et envoie le message de rappel sur l'arrosage des plantes et reçoit des SMS du destinataire. Toutes ces notifications peuvent être effectuées en utilisant le shield Arduino GSM.
- Projet connexe : Schéma du circuit de l'indicateur de niveau d'eau – Deux projets simples
Contexte du système
Il a été étudié à l'école à partir des livres de science que les plantes sont très impératives pour toute l'humanité à bien des égards. Comme ils gardent l'environnement propre en produisant de temps en temps de l'oxygène frais. Les systèmes d'arrosage automatique des plantes sont devenus de plus en plus nombreux avec l'augmentation du nombre d'objets du quotidien connectés aux technologies de pointe, ces systèmes sont mis en œuvre à un rythme croissant. Des endroits comme les maisons ainsi que sur les niveaux industriels. L'utilisation principale de ces systèmes est l'efficacité et la facilité d'utilisation.
Le système d'arrosage des plantes offre la possibilité aux amoureux des plantes d'emporter leur plante d'origine pendant leur absence - grâce à l'utilisation de composants efficaces et fiables tels que différents types de technologies de capteurs.
Il existe plusieurs types différents/simples de système d'arrosage des plantes d'intérieur, selon le niveau d'automatisation nécessaire.
- Projet connexe : Système d'irrigation intelligent – Schéma de circuit et code
Dans le rapport pdf final (un lien téléchargeable gratuit est donné à la fin du contenu de l'article), les sections suivantes sont décrites en détail.
- Globes et piques d'arrosage pour plantes
- Système d'arrosage intérieur goutte à goutte
- Technologie des capteurs
- Capteurs de température et d'humidité
- Capteur de température
- Capteurs d'humidité
- Capteurs d'humidité du sol
- Thermostat bimétallique
- Thermistance
- Détecteurs de température résistifs (RTD)
- Thermocouples
- CI de capteur, LM35
- Capteur de température numérique (ADT7301)
- DHT11 et DHT22
- Module GSM
- Architecture GSM
- Relais
- Transistor
- LCD Hitachi 16×2
Projet connexe :Qu'est-ce que les microcontrôleurs ATMega et comment créer un projet LED avec ?
Spécifications des produits et composants
| ID d'exigence | SRS-GSM-001 |
| Titre | Module GSM |
| Description | Le système comprend le module GSM, qui envoie des SMS d'alerte au destinataire et reçoit un SMS de l'utilisateur. |
| Version | Version 1.0 |
| ID d'exigence | SRS-Microcontrôleur -001 |
| Titre | ATmega328p |
| Description | Le système comprend le microcontrôleur qui est généralement fourni avec Arduino Uno. ce microcontrôleur lit la lecture du capteur et contrôle l'ensemble du système. |
| Version | Version 1.0 |
| ID d'exigence | SRS-Température et humidité-001 |
| Titre | DHT11 |
| Description | Le système comprend le capteur de température et d'humidité, qui garde une trace des valeurs actuelles de température et d'humidité de l'environnement et renvoie la lecture au microcontrôleur. |
| Version | Version 1.0 |
| ID d'exigence | SRS-Moisture-001 |
| Titre | Capteur d'humidité du sol Grove |
| Description | Le système comprend le capteur d'humidité du sol, qui prend la lecture de l'humidité du sol et renvoie la lecture au microcontrôleur. |
| Version | Version 1.0 |
| ID d'exigence | SRS-LCD-001 |
| Titre | LCD Hitachi 16×2 |
| Description | Le système comprend l'interface LCD pour l'utilisateur, qui affiche la lecture prise par les différents capteurs du système. |
| Version | Version 1.0 |
Article connexe :Programmation Arduino :qu'est-ce qu'Arduino et comment le programmer ?
Système d'arrosage automatisé des plantes basé sur Arduino :
Schéma fonctionnel de l'arrosage automatique des plantes
Schéma de circuit schématique du système d'arrosage et d'irrigation automatique des plantes
Selon ce système, il y a deux composants fonctionnels dans ce projet, à savoir le capteur d'humidité et le moteur/pompe à eau. Dans sa forme la plus élémentaire, le capteur d'humidité détecte le niveau d'humidité du sol. Ensuite, le moteur/pompe à eau fournit de l'eau aux plantes.
Cliquez sur l'image pour l'agrandir 
Le schéma ci-dessus dans la figure ci-dessus décrit le comportement global du système. Le projet utilise Arduino Uno pour contrôler le moteur. Il se compose d'un pont en H qui contrôle le flux du servomoteur, c'est-à-dire le sens d'horloge ou anti-horloge. Le capteur d'humidité mesure le niveau de sol et envoie le signal à Arduino, puis Arduino ouvrira le servomoteur si un arrosage est nécessaire. Ensuite, le moteur/pompe à eau alimente les plantes en eau jusqu'à ce que le niveau d'humidité souhaité soit atteint. 
Formez le prototype de la figure ci-dessus. Le capteur d'humidité détecte le niveau d'humidité et envoie le signal à Arduino, puis Arduino ouvre la pompe à eau à l'aide du pont en H et arrose la plante particulière. Ceci est fait en utilisant le logiciel Arduino IDE.
Projet connexe :projet électronique de contrôle des feux de circulation à l'aide de la minuterie IC 4017 et 555
Conception du projet
Cette section traite de tout travail terminé dans la conception de logiciels et la conception de matériel. Il donne également un aperçu de ce que le système comprend et pourquoi différents composants ont été choisis pour créer un système d'arrosage automatisé entièrement terminé. Considérez un diagramme dans la figure montre le modèle conceptuel de base du système utilisant les composants choisis. 
La fonctionnalité du schéma fonctionnel illustrée dans la figure ci-dessus du système d'arrosage automatisé de l'usine est illustrée ci-dessous :
- Le système comprend un module GSM qui envoie des SMS au destinataire et reçoit des SMS du destinataire.
- Il utilise des capteurs d'humidité, de température et d'humidité du sol.
- Il comprend également des électrovannes ainsi qu'un circuit d'électrovanne qui contrôle le débit d'eau à travers les électrovannes.
- Le capteur d'humidité est utilisé pour déterminer le niveau d'humidité d'une plante particulière. Ce niveau d'humidité est lu par le microcontrôleur, car il boucle et voit si la valeur du capteur est supérieure à la valeur seuil ou non. Si la valeur est supérieure à la valeur prédéfinie, le module GSM est prêt à envoyer un SMS au destinataire.
- Le capteur de température et d'humidité est utilisé pour déterminer s'il fait trop chaud pour la plante ou si l'humidité est trop élevée pour être gérée. Ceci est lu par la puce ATmega328p (En savoir plus sur Qu'est-ce qu'ATmega) sur Arduino Uno. ces lectures seront utilisées pour déterminer si tous les solénoïdes du système doivent être activés ou désactivés.
Plus de détails sur les composants peuvent être trouvés dans le fichier pdf (ci-dessous)
Projet connexe :Qu'est-ce que le Raspberry Pi ? Créer des projets avec Raspberry Pi
Conception matérielle
Schéma du capteur
La figure ci-dessous montre le schéma du circuit du capteur. Comme tous les capteurs connectés à la broche analogique Arduino A0-A3. La broche A0 était réservée au capteur de température et d'humidité tandis que les broches A1-A3 étaient réservées aux capteurs d'humidité. Tous les capteurs ont une alimentation commune 5V et Ground comme indiqué dans le schéma. 
Schéma LCD :
La figure ci-dessous montre le schéma de l'écran LCD. La broche numérique 8 à 13 était réservée à l'écran LCD, comme indiqué dans le schéma. Les broches 1 et 3 sont l'alimentation et la masse tandis que la broche 2 est la broche de contraste sur l'écran LCD qui contrôle le contraste et est connectée au potentiomètre. Il faut garder à l'esprit lors de la connexion de l'écran LCD que les broches numériques d'Arduino et les broches de données de l'écran LCD doivent être connectées dans le bon ordre, sinon l'écran LCD n'affichera que des déchets sur l'écran. 
Schéma du solénoïde
Ainsi, lorsque la tension est appliquée à la base des transistors. Le transistor passe à la terre, permettant à la bobine du relais d'être magnétisée et de se commuter sur le canal normalement fermé, grâce à quoi la LED connectée à ce relais particulier s'allume et lorsque la tension appliquée sur la base du transistor chute, le transistor revient à la normale et la bobine du relais se démagnétise et le relais passe à nouveau sur le canal NO, grâce à quoi la LED s'éteint à nouveau. 
Après avoir terminé tous les schémas du circuit, la prochaine étape consiste à les construire sur le Veroboard. Il est important de concevoir à l'avance le circuit sur la feuille de planification de la disposition du stripboard car il existe certains principes de conception d'un circuit sur Veroboard qui sont les suivants :
- Marquez d'abord la ligne d'alimentation Vs et GND en haut à droite de la feuille de planification de la disposition du panneau.
- N'oubliez pas de couper la piste entre les broches d'un circuit intégré. Marquez les coupes sur le schéma avec un X.
- Essayez de faire en sorte que la résistance et les condensateurs axiaux reposent à plat sur le stripboard. Les résistances nécessitent généralement un espace de 4 trous, le condensateur un espace de 8 trous.
- Si possible, numérotez la broche des circuits intégrés. La face inférieure de la Veroboard est constituée des pistes de cuivre dans lesquelles la tension circule horizontalement. Différentes conceptions Veroboard des schémas ci-dessus sont présentées ci-dessous :
Projet connexe :Contrôleur de niveau d'eau entièrement automatique utilisant SRF04
Conception de logiciels
Après avoir terminé le matériel, il est temps de tester le matériel avec le logiciel. Dans cette section, la mise en œuvre de la conception du logiciel sera décrite en détail pour chacune des différentes automatisations/technologies utilisées dans le système. Cela inclut le code Arduino écrit et téléchargé sur l'Arduino.
La première chose à faire était de faire fonctionner le circuit du solénoïde et de déterminer comment le solénoïde agirait du point de vue du microcontrôleur. Pour cela, un petit organigramme a été créé, qui peut être vu dans la section de flux du logiciel dans la figure ci-dessus.
Arduino IDE a été utilisé pour télécharger le logiciel sur l'Arduino. Pour le circuit solénoïde de base, un programme simple a été écrit qui fait clignoter la LED toutes les 1 sec. Les broches numériques 4, 5, 6 et 7 ont été définies initialement qui testent le programme et le circuit. Ainsi, lorsque le programme s'exécute, il effectue toutes les initialisations de base, définit toutes les broches de sortie dans la configuration void (), puis saute dans la boucle void () où il s'exécute constamment et fait clignoter les LED toutes les 1 secondes.
Après cela, un petit programme a été écrit et téléchargé sur l'Arduino qui obtient les lectures des différents capteurs et les imprime sur l'écran LCD. Pour cela, un petit organigramme a été créé, qui peut également être vu dans la section de flux du logiciel dans la figure donnée. Lorsque le programme entre dans la boucle vide (), il obtient les lectures du capteur et effectue tous les calculs de base et les imprime sur l'écran LCD.
Projet d'électronique de base connexe :système de contrôle automatique de l'éclairage public utilisant le transistor LDR et BC 547
La prochaine étape consiste à télécharger le logiciel du module GSM sur l'Arduino, à travers lequel le GSM pourrait communiquer avec le microcontrôleur. Le test du modem a été effectué initialement, ce qui effectue toutes les initialisations et bibliothèques de base pour le GSM, obtient le numéro IMEI et vérifie si le modem fonctionne correctement une fois qu'il a commencé à communiquer avec Arduino. L'étape suivante est le test de connexion réseau qui a essentiellement initialisé le GSM et affiche tous les autres réseaux que le module GSM peut prendre en charge.
Une fois que le module GSM est testé et fonctionne correctement, il est temps d'utiliser le module GSM pour communiquer avec le destinataire, ce qui signifie envoyer des SMS au destinataire et recevoir des SMS de sa part. Pour ce faire, un autre programme de câblage Arduino simple a été écrit et téléchargé sur l'Arduino. Le programme a initialisé le GSM et envoyé des SMS au destinataire, tandis qu'un autre programme Arduino a été écrit dans lequel le GSM reçoit les SMS de l'utilisateur final.
Enfin, une fois toute la conception du logiciel terminée, il est temps de fusionner toute la conception du logiciel et de créer un logiciel de travail final pour le système. Différentes approches algorithmiques ont été appliquées, qui peuvent être vues dans la section de flux de logiciels pour faire fonctionner le logiciel final et faire ce qu'il est censé faire. La figure ci-dessus montre le fonctionnement du logiciel final où il prend une lecture, envoie des SMS, reçoit des SMS et commence à faire ce qu'il faisait auparavant.
Remarque :tout le code du logiciel peut être consulté dans l'annexe ci-dessous.
REMARQUE :tout le code du logiciel peut être consulté dans l'annexe. La sortie du test du modem et du test de connexion réseau n'a pas été incluse dans le rapport car le rapport réel a été fait après la soumission du matériel.
Projet connexe :Comment créer des projets électriques et électroniques de base dans LabVIEW ?
Construction de projet et test de logiciel
Après avoir terminé avec succès la conception du matériel et des logiciels, il est temps de construire et de tester le projet. Dans cette section du rapport, des détails seront donnés sur la façon dont les différentes conceptions matérielles sont mises en œuvre et testées. Cette section explique également s'il y avait un problème caché dans le code du logiciel qui était important pour dépanner et évacuer et pour construire le projet avec succès. le processus étape par étape peut être vu dans le rapport complet du projet dans le fichier pdf ci-dessous, comme la procédure de construction et de test.
Tests de logiciels
La phase de test du logiciel est également un aspect important du développement du projet. Le test logiciel est une procédure d'exécution d'un programme ou d'une application dans le but de trouver les bogues logiciels. Il peut également être exprimé comme le processus de validation et de vérification qu'un logiciel ou une application répond à ses exigences techniques, fonctionne comme accepté et peut être exécuté avec une marque similaire. Pour tester le logiciel, différentes approches ont été adoptées. Un document de spécification des exigences logicielles (SRS) a été rédigé, qui traite pleinement du comportement attendu d'un système logiciel.
Projet connexe :projet électronique de circuit de commutation Clap utilisant une minuterie 555
| ID d'exigence | SRS-Capteur-010 |
| Titre | Capteur |
| Description | Les capteurs du système prennent les lectures et les renvoient au microcontrôleur. |
| Version | V 1.0 |
| ID d'exigence | SRS-Data-020 |
| Titre | Affichage des données |
| Description | Lorsque les utilisateurs essaient d'obtenir la lecture du système. L'écran doit afficher des données à l'utilisateur, par exemple :la température et la valeur d'humidité suivies des relevés d'humidité. |
| Version | V1.0 |
| ID d'exigence | SRS-Microcontrôleur-030 |
| Titre | Microcontrôleur |
| Description | Le microcontrôleur dans le système agit comme un cerveau du système qui gère tout dans le système |
| Version | V1.0 |
| ID d'exigence | SRS-Latch-040 |
| Titre | Loquet |
| Description | Le loquet du système étend les broches numériques du microcontrôleur |
| Version | V1.0 |
| ID d'exigence | SRS-GSM-050 |
| Titre | GSM |
| Description | Le système réagira en envoyant une alerte SMS au destinataire chaque fois que le microcontrôleur lui demandera de le faire. |
| Version | V1.0 |
Après avoir écrit la conception du logiciel de document SRS, nous sommes passés à la phase de test statique qui comprend la révision du document. C'est là que la vérification des exigences a lieu. Il existe quatre types de méthodes de vérification définis ci-dessous :
- Inspection (I) :contrôle ou vérification visuelle
- Analyse (A) :vérification basée sur des preuves analytiques
- Démonstration (D) :vérification des caractéristiques opérationnelles, sans mesure quantitative.
- Test (T) :vérification des caractéristiques quantitatives par mesure quantitative. Pour chaque exigence du document SRS, une méthode de vérification est définie avec l'abréviation I, A, D et T.
Vérification :
| ID d'exigence | Titre de l'exigence | Méthode |
| REQ-010 | Vérifiez que les capteurs du système obtiennent des lectures | I |
| REQ-020 | Vérifiez que les données sont affichées à l'écran. | D |
| REQ-030 | Il est vérifié que le microcontrôleur du système gère ou fonctionne correctement car il donne un résultat de 100 % pour chaque requête. | D |
| REQ-040 | Vérifiez que le circuit de verrouillage faisait ce qui est censé faire. Qui prend l'entrée sin 3 et crache 8 broches | A |
| REQ-050 | Vérifier que le SMS a bien été envoyé et reçu par GSM | D |
Résultats
Comme tous les tests effectués avec un résultat satisfaisant. Puisqu'il n'y a pas de résultat particulier en tant que tel qui doit être documenté. Comme le système fonctionne avec un capteur d'humidité et DHT11 (température et humidité) qui prend la lecture en fonction de la température et de l'humidité ambiantes actuelles. Les lectures du capteur d'humidité dans le circuit dépendent également du niveau d'humidité actuel de la plante. Sinon, le résultat global du circuit en termes de fonctionnalité était bon pour la motivation.
Article connexe :Programmation Arduino PWM et ses fonctions dans Arduino
Code logiciel final et complet pour les plantes d'arrosage automatique et les systèmes d'irrigation
Remarque : Plus de codes liés au projet peuvent être trouvés dans le fichier pdf, tels que l'exemple de code pour tester l'électrovanne, le code pour tester les capteurs du système, le code de test du modem GSM, le code de connexion réseau GSM, le GSM envoie le code d'alerte SMS, le code SMS de réception GSM,
Code final du projet d'arrosage automatique des plantes
#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
- Title:
- Format:
- Size:
- Pages:
- Download:
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 15Technologie industrielle
- Échecs probables dans les systèmes éprouvés
- Circuit et fonctionnement du système d'ouverture de porte automatique à détection de mouvement
- Système d'alarme Arduino :SERENA
- Système d'arrosage automatique des plantes avec Arduino
- Système d'arrosage des plantes domestiques
- Survivre à un projet de migration du système de contrôle
- Violations courantes du Code de l'électricité dont vous devez être conscient
- Comprendre le système de transmission automatique
- Comprendre le système de lubrification automatique