Automatisch plantenwatering & irrigatiesysteem: Schakeling, code en projectverslag

Automatisch plantenwateringssysteem – Volledige broncode, schakeling & projectverslag – PDF download

Inleiding

In de dagelijkse activiteiten met betrekking tot het wateren van planten zijn de belangrijkste culturele praktijk en de meest arbeidsintensieve taak. Ongeacht welk weer het is, of te heet en koud of te droog en nat, is het cruciaal om de hoeveelheid water die de planten bereikt te controleren. Het is dus effectief om een idee van een automatisch plantenwateringssysteem te gebruiken dat planten water geeft wanneer ze het nodig hebben. Een belangrijk aspect van dit project is: "wanneer en hoeveel water geven". Om handmatige activiteiten voor de mens om planten te wateren te verminderen, wordt een idee van een plantenwateringssysteem toegepast. De methode die wordt gebruikt om het grondvochtgehalte continu te monitoren en te beslissen of wateren nodig is of niet, en hoeveel water nodig is in de plantengrond. Dit project kan worden ingedeeld in subsystemen zoals: voeding, relais, magnetklep, Arduino GSM shield, grondvochtsensor en LCD.

Essenitieel is het systeem zo ontworpen en geprogrammeerd dat de grondvochtsensor het vochtgehalte van planten op een bepaald moment meet, als het vochtgehalte van de sensor lager is dan de gespecificeerde drempelwaarde die vooraf is gedefinieerd volgens de specifieke waterbehoefte van de plant, dan wordt de gewenste hoeveelheid water toegevoerd totdat het de vooraf gedefinieerde drempelwaarde bereikt.

Het systeem rapporteert zijn huidige staten en stuurt een herinneringsbericht over het wateren van planten en om water aan de tank toe te voegen. Al deze meldingen kunnen worden gedaan door gebruik te maken van Arduino GSM shield.

Doel van het project:

Omdat tegenwoordig, in de tijd van geavanceerde technologie en elektronica, de leefstijl van de mens slim, eenvoudiger, gemakkelijker en veel comfortabeler moet zijn. Daarom is er behoefte aan veel geautomatiseerde systemen in de dagelijkse routine van de mens om hun dagelijkse activiteiten en taken te verminderen. Hier is een idee van zo'n systeem genaamd automatische plantenwateringssysteem zeer nuttig. Veel mensen hebben veel problemen met het wateren van planten in de tuin, vooral wanneer ze niet thuis zijn. Dit model gebruikt sensortechnologieën met microcontroller om een slim schakelapparaat te maken om miljoenen mensen te helpen.

In zijn meest basale vorm is het systeem geprogrammeerd op een zodanige manier dat de grondvochtsensor het vochtgehalte van de plant op een bepaald moment meet, als het vochtgehalte van de sensor lager is dan de gespecificeerde drempelwaarde die vooraf is gedefinieerd volgens de specifieke plant, dan wordt de gewenste hoeveelheid water aan de plant toegevoerd totdat het vochtgehalte de vooraf gedefinieerde drempelwaarde bereikt. Het systeem omvat vochtigheids- en temperatuursensoren die de huidige atmosfeer van het systeem in de gaten houden en invloed hebben op wanneer wateren plaatsvindt. Magnetklep zal de waterstroom in het systeem regelen, wanneer Arduino de waarde van de vochtsensor leest, activeert het de magnetklep volgens de gewenste voorwaarde. Daarnaast rapporteert het systeem zijn huidige staten en stuurt het een herinneringsbericht over het wateren van planten en ontvangt SMS van de ontvanger. Al deze meldingen kunnen worden gedaan door gebruik te maken van Arduino GSM shield.

Achtergrond van het systeem

Het is bestudeerd in de school uit de wetenschapsboeken dat planten voor de hele mensheid van groot belang zijn in veel opzichten. Omdat ze de omgeving schoon houden door tijdelijk zuurstof te produceren. Automatische plantenwateringssystemen zijn veel meer gezien met de opkomst van alledaagse voorwerpen die verbonden zijn met geavanceerde technologieën, deze systemen worden in groeiende mate geïmplementeerd. Plaatsen zoals huizen alsook op industriële niveaus. Het hoofdgebruik van deze systemen is efficiëntie en gemak van gebruik.

Plantenwateringssysteem biedt plantenliefhebbers de mogelijkheid om zorgen te dragen voor hun huisplanten terwijl ze weg zijn – door het gebruik van efficiënte en betrouwbare componenten zoals verschillende typen sensortechnologieën.

Er zijn verschillende verschillende/ongecompliceerde typen van binnenlandse plantenwateringssystemen, afhankelijk van het benodigde automatiseringsniveau.

• Gerelateerd project: Slim irrigatiesysteem – Schakeling en code

In de eindige PDF-rapport (gratis downloadbare link staat aan het einde van de postinhoud) worden de volgende secties in detail beschreven.

• Plantenwatering Globes en Spijker
• Binnendruppelsysteem
• Sensortechnologie
• Temperatuur- en vochtigheidsensoren
• Temperatuursensor
• Vochtigheidsensoren
• Grondvochtsensoren
• Bi-Metallische Thermostaat
• Thermistor
• Resistieve Temperatuursensoren (RTD)
• Thermoelementen
• Sensor IC's, LM35
• Digitale temperatuursensor (ADT7301)
• DHT11 en DHT22
• GSM Module
• GSM Architectuur
• Relais
• Transistor
• Hitachi 16×2 LCD

Producten & componenten specificaties

Arduino gebaseerd geautomatiseerd plantenwateringssysteem:

Automatische plantenwatering blokdiagram

Schematisch schakelingsschema van automatische plantenwatering & irrigatiesysteem

Volgens dit systeem zijn er twee functionele componenten in dit project d.w.z. vochtsensor en motor/waterpomp. In zijn meest basale vorm meet de vochtsensor het niveau van de grondvochtigheid. Dan levert de motor/waterpomp water aan de planten.

Klik op afbeelding om te vergroten

Het bovenstaande schema beschrijft het algemene gedrag van het systeem. Het project gebruikt Arduino Uno om de motor te regelen. Het bestaat uit een H-brug die de stroom van de servomotor regelt, d.w.z. klok of tegen de klok in richting. De vochtsensor meet het niveau van de grond en stuurt het signaal naar Arduino, waarna Arduino de servomotor opent als wateren vereist is. Dan levert de motor/waterpomp water aan de planten totdat het gewenste vochtgehalte bereikt is.

Vanaf het prototype in bovenstaande figuur meet de vochtsensor het vochtgehalte en stuurt het signaal naar Arduino en dan opent Arduino de waterpomp met behulp van de H-brug en water de specifieke plant. Dit wordt gedaan door gebruik te maken van Arduino IDE software.

Projectontwerp

Deze sectie gaat over elk werk dat is voltooid in software-ontwerp en hardware-ontwerp. Het gaat ook inzicht in wat het systeem omvat en waarom verschillende componenten zijn gekozen om een volledig geautomatiseerd plantenwateringssysteem te maken. Overweeg een diagram in de figuur dat het basismodel van het systeem toont met gekozen componenten.

De functionaliteit van het blokdiagram getoond in bovenstaande figuur van het geautomatiseerde plantenwateringssysteem is hieronder geïllustreerd:

• Het systeem omvat GSM-module die SMS stuurt naar de ontvanger en SMS ontvangt van de ontvanger.
• Het gebruikt grondvochtigheid, temperatuur- en vochtigheidsensoren.
• Het omvat ook magnetkleppen samen met magnetklep-circuit die de waterstroom door de magnetkleppen regelt.
• De vochtsensor wordt gebruikt om het vochtgehalte van de specifieke plant te bepalen. Dit vochtgehalte wordt gelezen door de microcontroller, aangezien het lus en kijkt of de waarde van de sensor boven de drempelwaarde is of niet. Als de waarde boven de vooraf gedefinieerde waarde is, dan is de GSM-module klaar om een SMS naar de ontvanger te sturen.
• De temperatuur- en vochtigheidsensor wordt gebruikt om te bepalen of het te heet is voor de plant of de vochtigheid te hoog is om aan te kunnen. Dit wordt gelezen door de ATmega328p (Lees meer over Wat is ATmega) chip op Arduino Uno. Deze metingen zullen worden gebruikt om te bepalen of alle magnetkleppen in het systeem Aan of Uit moeten zijn.

Meer componentendetails kunnen in het PDF-bestand (hieronder) worden gevonden.

Hardware-ontwerp

Sensor Schema

De onderstaande figuur toont het schema van de sensorcircuit. Aangezien alle sensoren zijn aangesloten op de Arduino analoge pinnen A0-A3. Pin A0 was gereserveerd voor de temperatuur- en vochtigheidsensor, terwijl pinnen A1-A3 gereserveerd waren voor vochtsensoren. Alle sensoren hebben gemeenschappelijke voeding 5V en Grond zoals getoond in het schema.

LCD Schema:

De onderstaande figuur toont het schema van de LCD. Digitale pin 8 – 13 was gereserveerd voor de LCD zoals getoond in het schema. Pin 1 en Pin 3 zijn de voeding en grond, terwijl pin 2 de contrastpin is op de LCD die het contrast regelt en verbonden is met de potentiometer. Het moet in gedachten worden gehouden tijdens het aansluiten van de LCD dat digitale pinnen van Arduino en datapinnen van LCD in de juiste volgorde moeten worden verbonden, anders zal de LCD alleen rommel op het scherm weergeven.

Magnetklep Schema

Diagram onder in figuur hieronder toont het schakelingsschema van de magnetklep-circuit. Digitale pin 4 – 7 was gereserveerd voor de magnetkleppen. Aangezien het circuit bestaat uit relais, transistoren, weerstanden, en LEDs in plaats van de magnetklep (CadStar heeft geen magnetklep symbool). In het schema gebruiken relais 5V. Waarbij 5V ook in het NO-kanaal van de relais gaat, dit is omdat in het schema LEDs de magnetklep vervangen die op (5V) werken gevolgd door 220-ohm weerstand.

• Gerelateerd project: Spraakherkenning gebaseerd huisautomatiseringssysteem

Dus, wanneer spanning wordt toegepast op de basis van de transistoren. Transistor schakelt naar grond waardoor de spoel van het relais gemagnetiseerd raakt en zichzelf schakelt naar Normaal gesloten kanaal, waardoor de LED die met dat specifieke relais is verbonden aan gaat en wanneer de spanning die op de transistorbasis wordt toegepast daalt, schakelt de transistor zichzelf terug naar normaal en de spoel van het relais wordt gedemagnetiseerd en het relais schakelt weer naar NO-kanaal, waardoor de LED weer uitgaat.

Na het afronden van alle schema's van het circuit, is de volgende stap om ze op de Veroboard te bouwen. Het is belangrijk om het circuit op een stripboard layout planning sheet van tevoren te ontwerpen omdat er bepaalde principes zijn voor het ontwerpen van een circuit op Veroboard wat als volgt is:

1. Markeer de Vs en GND voedingslijnen eerst rechtsboven op het stripboard layout planning sheet.
2. Onthoud om de baan tussen de pennen van een IC te snijden. Markeer de snijden op het diagram met een X.
3. Probeer om weerstanden en axiale condensatoren plat op de stripboard te leggen. Weerstanden vereisen meestal een gat van 4 gaten, condensator een gat van 8 gaten.
4. Nummer indien mogelijk de pennen van de IC's. De onderzijde van de Veroboard bestaat uit de koperen banen waarin spanning horizontaal stroomt. Verschillende Veroboard ontwerpen van de schema's hierboven worden hieronder getoond:

Software-ontwerp

Na het krijgen van de hardware, is het tijd om de hardware met de software te testen. In deze sectie zal de implementatie van het software-ontwerp in detail worden beschreven voor elk van de verschillende automatiserings-/technologieën die binnen het systeem worden gebruikt. Dit omvat de Arduino-code die is geschreven en geüpload naar de Arduino.

Het eerste wat werd gedaan was om de magnetklep-circuit werkend te krijgen en hoe de magnetklep zou reageren vanuit het perspectief van de microcontroller. Hiervoor werd een klein flowchart gedaan wat te zien is onder software flow sectie in bovenstaande figuur.

Arduino IDE werd gebruikt om de software op de Arduino te uploaden. Voor de basale magnetklep-circuit werd een eenvoudig programma geschreven dat eigenlijk de LED elke 1 sec laat knipperen. Digitale pin 4, 5, 6 en 7 werd initieel gedefinieerd wat het programma en het circuit test. Dus, wanneer het programma draait, maakt het alle basale initialisaties, definieert alle uitgangspinnen in void setup() en springt dan in de void loop() waar het constant draait en LEDs elke 1 sec laat knipperen.

Daarna werd een klein programma geschreven en geüpload naar de Arduino dat de metingen van de verschillende sensoren ophaalt en ze op de LCD print. Hiervoor werd ook een klein flowchart gedaan wat ook te zien is onder software flow sectie in de gegeven figuur. Wanneer het programma in de void loop() gaat, haalt het de metingen van de sensor op en doet alle basale berekeningen en print ze op LCD.

Het volgende is om de software voor GSM-module naar de Arduino te uploaden, waardoor GSM kan communiceren met de microcontroller. Modemtest werd initieel gedaan wat alle basale initialisaties en bibliotheken voor de GSM doet en het IMEI-nummer ophaalt en kijkt of de modem goed functioneert zodra hij begint te communiceren met Arduino. De volgende stap is netwerkverbindingstest wat eigenlijk de GSM initialiseert en alle andere netwerken weergeeft die de GSM-module kan ondersteunen.

Eenmaal de GSM-module getest en goed functionerend is, is het tijd om de GSM-module te gebruiken om te communiceren met de ontvanger, wat betekent SMS sturen naar de ontvanger en SMS ontvangen van hen. Om dat te doen, werd een ander eenvoudig Arduino wiring programma geschreven en geüpload naar de Arduino. Het programma initialiseerde de GSM en stuurt SMS naar de ontvanger, in tegenstelling een ander Arduino programma werd geschreven waarin GSM de SMS ontvangt van de eindgebruiker.

Ten slotte, zodra alle software-ontwerp gedaan was, is het tijd om alle software-ontwerpen samen te voegen en een definitieve werkende software voor het systeem te bouwen. Verschillende algoritmische benaderingen werden toegepast wat te zien is onder software flow sectie om de definitieve software werkend te krijgen en te laten doen wat het moet doen. De bovenstaande figuur toont de werking van de definitieve software waar het een meting neemt, SMS stuurt, SMS ontvangt en begint met wat het eerder deed.

Let op: Alle softwarecode kan in de bijlage hieronder worden gezien.

LET OP: alle softwarecode kan in de bijlage bekeken worden. De uitvoer van de modemtest en netwerkverbindingstest was niet opgenomen in het rapport omdat het daadwerkelijke rapport na de inlevering van de hardware werd gedaan.

Projectconstructie en softwaretesten

Na het succesvol krijgen van alle hardware- en software-ontwerpen is het tijd voor de projectconstructie en testen. In deze sectie van het rapport zullen details worden gegeven over hoe de verschillende hardware-ontwerpen geïmplementeerd en getest worden. Deze sectie praat ook over of er verborgen problemen waren binnen de softwarecode die belangrijk waren om op te lossen en te verwijderen en om het project succesvol te bouwen. De stapsgewijze procedure kan in het volledige projectrapport in PDF-bestand hieronder worden gezien zoals constructie en testprocedure.

Softwaretesten

Softwaretestfase is ook een belangrijk aspect van de projectontwikkeling. Softwaretesten is een procedure van het uitvoeren van een programma of applicatie met het doel om softwarebugs te vinden. Het kan ook worden uitgedrukt als het proces van valideren en verifiëren dat een softwareprogramma of applicatie voldoet aan zijn technische eisen, werkt zoals geaccepteerd en kan worden uitgevoerd met een vergelijkbaar kenmerk. Om de softwaretesten te doen, werden verschillende benaderingen aangenomen. Een software requirement specification (SRS) document werd geschreven dat het verwachte gedrag van een softwaresysteem volledig adresseerde.

Na het schrijven van het SRS-document ging het software-ontwerp over in de statische testfase wat het nakijken van het document omvat. Dit is waar de verificatie van de eisen plaatsvindt. Er zijn vier diverse typen verificatiemethoden gedefinieerd hieronder:

1. Inspectie (I): controle of visuele verificatie
2. Analyse (A): verificatie gebaseerd op analytische bewijzen
3. Demonstratie (D): verificatie van operationele kenmerken, zonder kwantitatieve meting.
4. Test (T): verificatie van kwantitatieve kenmerken met kwantitatieve meting. Voor elke eis van het SRS-document wordt een verificatiemethode gedefinieerd met afkorting van I, A, D en T.

Verificatie:

Resultaten

Alle testen zijn met bevredigende resultaten uitgevoerd. Aangezien er geen specifiek resultaat is dat gedocumenteerd hoeft te worden. Aangezien het systeem werkt met vochtigheids- en DHT11 (temperatuur en vochtigheid) sensor die metingen neemt volgens de huidige kamertemperatuur en vochtigheid. Metingen van de vochtigheidssensor in het circuit hangen ook af van wat het huidige vochtgehalte is voor de plant. Anders was het algehele resultaat dat uit het circuit kwam in termen van functionaliteit goed voor motivatie.

Definitieve en volledige softwarecode voor automatische watering planten & irrigatiesystemen

Let op: Meer codes gerelateerd aan het project kunnen in het PDF-bestand worden gevonden zoals voorbeeldcode om magnetklep te testen, code voor het testen van systeemsensoren, GSM Modem Test Code, GSM Netwerk Verbinding Code, GSM stuurt SMS alert Code, GSM Ontvang SMS code,

Definitieve Auto Watering Planten Project Code

#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); 
}

Volledig projectverslag Automatisch wateren planten systeem (PDF) Gratis download

• Titel: Geautomatiseerd plantenwateringssysteem
• Formaat: PDF
• Grootte: 4.18MB
• Pagina's: 77
• Download: Hier

Gerelateerd bericht: Hoe een PCB te ontwerpen (Stap voor stap & Picturale weergaven)

Over de auteur

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