Šio projekto tikslas - sukurti visiškai automatizuotą „Arduino“ pagrindu pagamintą pomidorų namų ūkį. Bendroji idėja yra surinkti informaciją iš pomidorų plantacijos, nes temperatūra, santykinis oro drėgnumas, šviesumas ir dirvožemio drėgmė, remiantis šiais duomenimis, lemia tinkamą kiekį (ir kada), kad plantacija turėtų gauti šilumą ir vandenį. Projektas taip pat turėtų leisti rankiniu būdu įsikišti operatoriui, kad būtų galima valdyti vandens siurblį ir elektros lempą, kad būtų sukurta šiluma sodinimui. Rankinis įsikišimas turi būti tiek vietinis, tiek nuotolinis per internetą.

Trumpai tariant, sistema turėtų gauti kaip įvestį:

• Jutikliai (analoginiai duomenys):
  • Temperatūra
  • Drėgmė
  • Šviesumas
  • Dirvožemio drėgmė
• Mygtukai:
  • Siurblys įjungtas / išjungtas
  • Lemputė įjungta / išjungta

Sistema turėtų pateikti kaip produkciją:

• Pavaros:
  • Siurblio valdymo relė
  • Lempos valdymo relė
• Signalizavimas (skaitmeniniai duomenys):
  • Vizuali ir garsinė būsena / klaidos indikacija
  • Vizuali, kai siurblio būsena
  • Lempos būsenos vizualinis vaizdas
• Duomenų rodymas
  • Visi analoginiai ir skaitmeniniai duomenys turėtų būti prieinami momentiniam vertinimui
• Duomenų saugykla
  • Istoriniai duomenys turėtų būti saugomi nuotoliniu būdu ir pasirinktinai taip pat vietoje (LOG failas).

Pirmiau pateiktoje schemoje parodyti pagrindiniai projekto komponentai.

Vaizdo klipas apibūdina pirmąjį bandymui naudojamą laboratorinį prototipą:

Ir tai rodo, kaip komandos veiks lokaliai ir nuotoliniu būdu per tinklalapį:

Projektas bus suskirstytas į 3 dalis:

1. Vietinė stotis
2. Nuotolinė stotis (IoT)
3. Taikymas ir priežiūra ūkyje

Pirmoje dalyje ištirsime vietinę stotį, pasirūpinsime jutikliais, pavaromis, mokomės rodyti duomenis ir pan. ArduFarmBot - 2 dalyje: „Nuotolinė stotis“ - „IoT“ įgyvendinimas, kaip paaiškinta pavadinime. mes įgyvendinsime DI požiūrį, jei ši „rankinė intervencija“ taip pat bus įmanoma nuotoliniu būdu per internetą.

Prekės:

1 žingsnis

Vietos stoties pagrindiniai komponentai yra:

Bendrieji elementai (apie $ 37.00):

• Arduino Nano - ($ 7.50)
• Temperatūros ir drėgmės jutiklis DHT22 - ($ 3.66)
• Šviesos jutiklis - AD-018 foto rezistorius. arba bet koks lygiavertis - ($ 0,71)
• Dirvožemio drėgmės jutiklis - (1,99 $) (pasirinktinai, gali būti DIY)
• LCD I2C 20X4 ($ 13,99)
• Mygtukai (2X) - ($ 0.90)
• Šviesos diodai (3X) ($ 0.20)
• Esp8266 serijinis bevielis bevielis siųstuvas-modulis Esp-01 - ($ 5.96) - (naudojamas antroje dalyje)
• Aktyvus garsinis garsiakalbis - Ky-12 arba lygiavertis ($ 0.60) - (naudojamas antroje dalyje)
• 2 X 5v relės modulis ($ 11,60)
• Peršokimo laidai (S1.00)
• 10KOhms rezistorius - ($ 0.03)
• 2.2K Oms rezistorius - ($ 0.03)
• 1,0K Ohm rezistorius - ($ 0.03)
• 220 omų rezistorius - ($ 0.03)

1 variantas su „Nano Shield“ (apie $ 15.00):

• „Arduino Nano Shield“ („Funduino“) - ($ 7.28)
• Membraninė klaviatūra (4 raktai) - ($ 6.65)
• „Breadboard Mini“ ($ 1.00) (naudojama antroje dalyje)

2 variantas - nano-skydas (apie 4,00 USD):

• 3.3V įtampos reguliatorius LD33V arba lygiavertis ($ 1.20) (naudojamas antroje dalyje)
• Kondensatorius - elektrolitinis 10uF (2X), naudojamas su 7803 - ($ 0.10)
• „BreadBoard“ terpė - ($ 2.50)

Laboratoriniams tyrimams ESP8266 gali būti naudojamas ir 3,3V / 5V (5,99 $) Breadboard maitinimo modulis. (Naudojama antroje dalyje)

2 veiksmas: jutiklių diegimas, programavimas ir testavimas

DHT 22 (arba DHT11)

Pirmasis montuojamas ir išbandomas jutiklis yra DHT 22, skaitmeninis santykinis drėgmės ir temperatūros jutiklis. Jis naudoja talpinį oro drėgmės jutiklį ir termistorių, kad matuotų aplinkinį orą, ir iškelia skaitmeninį signalą ant duomenų kaiščio (nereikia analoginių įvesties kaiščių).

Pagal savo duomenų lapą, jutiklis turi būti maitinamas tarp 3.3V ir 5V (kai kurių duomenų lapų, pvz., 6V maks.), Ir dirbs nuo -40oC iki + 80oC (kai kurie duomenų lapai sako + 125oC) +/- 0,5oC tikslumu temperatūrai ir + / -2% santykinei drėgmei. Taip pat svarbu turėti omenyje, kad jos aptikimo laikotarpis yra vidutiniškai 2 sekundės (minimalus laikas tarp rodmenų).

„Adafruit“ svetainė suteikia daug informacijos apie DHT22 ir jo brolį DHT11. Norėdami gauti daugiau informacijos, apsilankykite: DHT22 / 11 „Tutorial“ puslapyje.

DHT22 turi 4 kaiščius (priešais jutiklį, 1 kaištis yra kairėje):

1. VCC (3–5 V galia)
2. Išsami duomenys
3. Neprisijungęs
4. Žemė

Paprastai jutiklį naudosite mažesniu nei 20 m atstumu, tarp duomenų ir VCC kaiščių turi būti prijungtas 10K rezistorius. Išvesties kaištis turi būti prijungtas prie Arduino kaiščio 5 (žr. Aukščiau pateiktą diagramą).

Kai jutiklis yra įdiegtas „Arduino“, atsisiųskite „DHT“ biblioteką iš „Adafruit github“ saugyklos ir įdiekite ją į „Arduino“ bibliotekos failą.

Atnaujinus „Arduino IDE“, reikia įdiegti „DHT jutiklio biblioteką“. Paleiskite DHT jutiklio kodą ir patikrinkite, ar viskas veikia gerai:

/ ************************************************* *************** * DHT jutiklis - sąranka ir testas * Remiantis originaliu „ladyada“ parašytu kodu, vieša „MJRoBot 21Aug16 ************* ************************************************** * / // Įtraukti DHT biblioteką #include // Jutiklių apibrėžtys #define DHTPIN 5 // DHT duomenų kontaktas, prijungtas prie Arduino kaiščio 5 #define DHTTYPE DHT22 // DHT 22 (jei jūsų jutiklis yra DHT 11, pakeiskite šią eilutę: #define DHTTYPE DHT11) // Kintamieji naudojamas jutiklio plūdės tempDHT; // dėl paskutinės programos, kurią mes naudosime plūduriu. Nereikia didelio tikslumo matavimų plūduriuojančių; float hic; // naudojami tik testavimo tikslais // Inicijuoti DHT jutiklį DHT dht (DHTPIN, DHTTYPE); void setup () {Serial.begin (9600); Serial.println („DHT 22 sąranka ir testas“); dht.begin (); } void loop () {// Palaukite kelias sekundes tarp matavimų. vėlavimas (2000 m.); // Skaityti temperatūros ir drėgmės reikšmes iš DHT jutiklio: tempDHT = dht.readTemperature (); humDHT = dht.readHumidity (); // Patikrinkite, ar nepavyko skaityti ir išeiti anksčiau (bandykite dar kartą). jei (isnan (humDHT) || isnan (tempDHT)) {Serial.println ("Nepavyko skaityti iš DHT jutiklio!"); sugrįžimas; } // Apskaičiuokite šilumos indeksą Celsijaus (isFahreheit = false) plūduriu hic = dht.computeHeatIndex (tempDHT, humDHT, false); // Rodyti matavimus serijiniame monitoriuje: Serial.print („Temp DHT ==>“); Serial.print (tempDHT); Serial.print („oC Hum DHT ==>“); Serial.print (humDHT); Serial.print ("% šilumos indeksas"); Serial.print (hic); Serial.println ("oC"); } Šviesumo jutiklis

Įdiegus ir išbandžius DHT, atėjo laikas šviesos jutikliui. Tam gali būti naudojamas paprastas LDR (šviesos priklausomas rezistorius). Iš esmės tai, ką turėtume padaryti, yra turėti įtampos skirstytuvą, kur vienas iš rezistorių yra LDR, o vidutinis skirstytuvo taškas turėtų būti naudojamas kaip analoginis įėjimas į Arduino. Tokiu būdu, keičiant šviesą, LDR pasipriešinimas skiriasi ir taip, proporcingai pasikeis ir dalytuvo vidurio taško įtampa.

Bandymui atlikti naudosime pigų LDR modulį (KY18), kuriame yra integruotas įtampos skirstytuvas. Modulyje yra 3 smeigtukai („S“ duomenims; „+“ VCC ir „-“ GND). Kaištis „S“ bus prijungtas prie „Arduino Pin Analog 0“. „+“ Ir „-“ kaiščiai turi būti prijungti atitinkamai prie 5V ir GND. Jei energijos suvartojimas kelia susirūpinimą, „+“ gali būti prijungtas prie vieno iš „Arduino“ skaitmeninių išėjimų, o prieš kelis milisekundes turėtų būti „HIGH“ (aukštas), prieš skaitant įtampą PIN kode, po to grįžus į „žemą“.

Funkcija getLumen (LDR_PIN); skaityti keletą kartų jutiklio išvestį (gali būti 3, 10 ar daugiau, jūs nuspręsite, kas geriausiai tinka jūsų atveju) apskaičiuojant šių rodmenų vidurkį. Be to, kai „Arduino“ analoginio skaitmeninio konverterio (ADC) išvesties išvestis yra nuo 0 iki 1023, turėtume „rodyti žemėlapį“, kad gautume šiuos rezultatus:

• „Full Dark“: ADC išvestis: 1023 ==> 0%
• „Visa šviesa“: ADC išvestis: 0 ==> 100%

int getLumen (int anaPin) {int anaValue = 0; už (int i = 0; i <10; i ++) // skaityti jutiklį 10X ang gauti vidutinį {anaValue + = analogRead (anaPin); vėlavimas (50); } anaValue = anaValue / 10; // Šviesa iki 300; Tamsus virš 800 anaValue = žemėlapis (anaValue, 1023, 0, 0, 100); // LDRDark: 0 ==> šviesa 100% grąžina anaValue; } Dirvožemio drėgmės jutiklis

Labai paprasta nustatyti dirvožemio drėgmės jutiklį. Jis turi tą patį principą kaip ir šviesumo jutiklis. Įtampos skirstytuvas, naudojamas kaip „Arduino“ analoginio kaiščio įvestis, bet vietoj „šviesos priklausomybės rezistorius“, turėsime „Atsparumą dirvožemio drėgmei“. Pagrindinė grandinė yra labai paprasta ir gali būti matoma aukščiau.

Deja, realybė yra šiek tiek sudėtingesnė nei tai (bet ne daug). Paprastas jutiklis, kaip aprašyta anksčiau, veiktų gerai, bet ne ilgai. Problema yra ta, kad pastovios srovės, tekančios per elektrodus vienoje kryptyje, susidarymas sukels koroziją dėl elektrolizės poveikio. Vienas iš būdų jį išspręsti yra prijungti elektrodus ne VCC ir Ground, bet Arduino Digital uostuose. Tai padarius, pirmiausia jutiklis bus „įjungtas“ tik tada, kai skaitymas tikrai įvyktų, o esama kryptis virš zondų gali būti vykdoma abiem kryptimis, pašalinant elektrolizės poveikį.

Paprastas bandymo kodas buvo pagrįstas įrašu „Kaip: dirvožemio drėgmės matavimas?“.:

/ ************************************************* *** Dirvožemio drėgmės jutiklio testas ******************************************* ********* / #define SOIL_MOIST_PIN 1 // naudojamas dirvožemio drėgmės jutiklio įvestyje #define SMS_VCC 7 #define SMS_GND 6 int soilMoist; // analoginė vertė, gauta iš jutiklio void setup () {Serial.begin (9600); pinMode (SMS_VCC, OUTPUT); pinMode (SMS_GND, OUTPUT); } void loop (void) {soilMoist = getSoilMoisture (); Serial.print ("Dirvožemio drėgmė:") Serial.print (soilMoist) Serial.println ("%")} / ************************ *************************** * Dirvožemio surinkimas Drėgmės duomenys ****************** ********************************** / int getSoilMoisture () {int anaValue; „DigitalWrite“ (SMS_VCC, LOW); // valdyti srovę per daliklį į vieną kryptį skaitmeninio rašymo (SMS_GND, HIGH); vėlavimas (1000); // palaukite momento, kai talpos efektai nusistovi anaValue = analogRead (SOIL_MOIST_PIN); skaitmeninis raštas (SMS_VCC, HIGH); // pakeisti dabartinį skaitmeninį įrašą (SMS_GND, LOW); vėlavimas (1000); // suteikti tiek daug laiko „atvirkštinėje“, kaip „skaitmeninio„ pirmyn “(SMS_VCC, LOW); // sustabdyti dabartinį anaValue = žemėlapį (anaValue, 1023, 0, 0, 100); grąžinti anaValue; }

Mano preliminariems bandymams, susijusiems su SW kūrimu, aš naudoju 10K ohmos potenciometrą tarp + 5V ir GND, kad galėčiau pateikti išvestį, kad būtų imituotas dirvožemio drėgmės jutiklio išėjimas. Dabar pakanka, kai 5 žingsnyje aptarsime šį jutiklį.

Dabar, kai visi jutikliai yra paruošti ir išbandyti atskirai, sukursime konkrečią funkciją, kad galėtume vienu metu skaityti visus jutiklius.

void readSensors (void) {tempDHT = dht.readTemperature (); // Skaityti temperatūros ir drėgmės reikšmes iš DHT jutiklio: humDHT = dht.readHumidity (); lumen = getLumen (LDR_PIN); soilMoist = getSoilMoist (); }

Kai kodas veikia, atlikite kai kuriuos testus su jutikliais, pvz., Pvz., Apimant LDR, ir pažiūrėkite, ar duomenys pereina nuo didelės vertės iki 0 (žr. Aukščiau esantį serijos monitoriaus spausdinimo ekraną). Atlikite tą patį temperatūros ir drėgmės atžvilgiu (dirvožemio drėgmės jutiklis bus aptariamas 5 veiksme.

Užpildykite visą kodą:

3 žingsnis: LCD monitoriaus įtraukimas į vietinę stebėseną

Žinoma, mes neturėsime visada serijinio monitoriaus, kad ištirtume mūsų jutiklių išvestį. Taigi, vietos stebėsenai prie projekto bus pridėtas LCD. Pasirinkimas buvo skirtas aukštos kokybės 4 eilutės 20 simbolių LCD moduliui, kuris ne tik leidžia nustatyti kontrastą per potenciometrą, įrengtą jo gale, bet ir turi apšvietimo ir IIC ryšio sąsają.

LCD ekrane yra 4 kaiščiai:

• GND
• VCC
• SDA
• SCL

SDA kaištis mūsų atveju bus prijungtas prie Arduino kaiščio A4 ir SCL prie A5, kaip parodyta aukščiau esančioje diagramoje.

Prijungus 4 laidus, kitas dalykas, kurį reikia padaryti, yra atsisiųsti ir įdiegti „I2C“ biblioteką savo LCD ekranui (jis gali būti naudojamas tiek „20X4“, tiek „16X2 LCD“):

http: //github.com/fdebrabander/Arduino-LiquidCrys …

Atidarykite ir įkelkite į „Arduino“ „Hello World“ pavyzdį, kuris yra įtrauktas į biblioteką, keičiant numatytąjį nustatymą (16x2) mūsų 20X4. Mano atveju adresas 0x27:

#include #include // Nustatykite LCD adresą į 0x27, jei naudojate 20 simbolių ir 4 eilutės ekraną LiquidCrystal_I2C lcd (0x27, 20, 4); void setup () {// inicijuoja LCD lcd.begin (); // Įjunkite šviesą ir spausdinkite pranešimą. lcd.backlight (); lcd.print („Sveiki, pasaulis!“); } void loop () {// Nieko nedarykite čia …}

Pastaba: Jei nesate tikri dėl savo LCD I2C adreso, paprastas I2C nuskaitymas jūsų HW parodys, ar yra tinkamai veikiančių I2C įrenginių ir jo adresas. Kodą galima rasti čia:

Mano atveju, paleidžiu programą ir gavau Serial Monitor:

Įtrauksime LCD ekraną į paskutinį kodą, kad galėtume matyti jutiklių rodmenis LCD:

4 žingsnis. Vietos valdymo pavaros ir mygtukai

Pavaros

Iki šiol mes galime skaityti duomenis iš jutiklių ir parodyti juos serijiniame monitoriuje ir LCD. Atėjo laikas kažką daryti su tokiais duomenimis. Pagalvokite apie pavarą!

Kaip aptarta įvade, galutinis mūsų tikslas - rūpintis, pavyzdžiui, pomidorų plantacija. Su duomenimis, kuriuos pateikia jutikliai, žinosime oro temperatūrą ir drėgmę, šviesumą ir svarbiausią, kaip „sausas“ dirvožemį, kuriame yra plantacija. Naudodamiesi šiais duomenimis, mūsų programa turėtų apskaičiuoti, ar reikės laistyti plantaciją, įjungti vandens siurblį arba įjungti elektros lempą, kad būtų užtikrinta tinkama šiluma. tam naudosime mažus 5V relės modulius siurblio ir lempos aktyvavimui. Relių modulio schema gali būti matoma aukščiau.

Kai kuriuose moduliuose yra „G“, „V“, „S“ arba „S“, „-“, „+“ arba „In“, „Vcc“, „GND“ ir kt.

Žiūrėdami į diagramą, priklausomai nuo jūsų relės modulio, turite prisijungti:

• Arduino 5V ==> "V" arba "+" arba "Vcc"
• Arduino GND ==> "G" arba "-" arba "GND"
• Arduino OUT ==> "S" arba "In" (mūsų atveju turėtų būti D10 siurbliui ir D8 lempai)

Paprastai matysite kaip išvestį, 3 smeigtukai: "NE", "Ref", NC ", kurie yra:" Normal Open ", Reference ir" Normal Closed ". Naudosime porą: NO ir Ref (centre). pirmiau pateiktoje schemoje „NO“ yra terminalas, jungiantis prie „Live Mains“ arba „Live“ maitinimo šaltinio (12VDC siurbliui ir 220VAC lempai). „Ref“ bus prijungtas prie siurblio arba lempos, kaip parodyta aukščiau Norėdami sužinoti daugiau apie reles, apsilankykite: „Valdymo jėga su„ Arduino “.

Kartu su relėmis, pasirinktinai galima naudoti 2 šviesos diodus, kad parodytų, ar relės yra įjungtos arba išjungtos:

• LED raudona: siurblys
• LED žalias: lempa

Norint išbandyti, puikiai dera jūsų BreadBord šviesos diodai, bet galutiniam projektui galite juos išgelbėti taupyti energiją arba galbūt naudoti skirtingus skaitmeninius išėjimus šviesos diodams ir relėms. Jie dirbo kartu, tačiau iš „Arduino“ važiuos pagrįstą kiekį srovės (LCD ekrane pamatysite ryškumo sumažėjimą). Bet kokiu atveju galutinis surinkimas ir bandymai aptars daug energijos taupymo aspektų.

Mygtukai

Remiantis jutiklių rodmenimis, operatorius taip pat gali nuspręsti rankiniu būdu valdyti siurblį ir (arba) lempą. Tuo tikslu į projektą bus įtraukti du mygtukai. Jie veiks „perjungimo“ režimu: jei pavara yra „ĮJUNGTA“, mygtuko paspaudimas „išjungs“ ir atvirkščiai. Mygtuko logika bus „paprastai uždaryta“, o tai reiškia, kad „Arduino“ įvestis bus nuolat „HIGH“. Paspaudus mygtuką, „Arduino“ kaištyje bus naudojamas „LOW“ (žr. Aukščiau pateiktą blokavimo schemą).

Tą patį mes darėme su jutikliais, bet kuriuo metu, kai veiksime kilpa () , funkcija readLocalCmd () bus vykdoma. Ši funkcija perskaitys kiekvieną mygtuką, atnaujindama pavarų kintamųjų būseną (pumpSatus ir lemputė). Atkreipkite dėmesį, kad funkcijos tipas debeap (pin) yra vadinamas tiesioginiu digitalRead (PIN). Taip užkertamas kelias klaidingiems rodmenų rodmenims. Jei norite sužinoti daugiau apie debitavimą, žr. Šią diskusiją.

/ ************************************************* *************** * Skaitykite vietines komandas (siurblio ir lempos mygtukai paprastai yra „HIGH“): ******************* ********************************************* / void readLocalCmd () {int digiValue = debounce (PUMP_ON); jei (! digiValue) {pumpStatus =! pumpStatus; showDataLCD (); aplyCmd (); } digiValue = debounce (LAMP_ON); jei (! digiValue) {lampStatus =! lempa; showDataLCD (); aplyCmd (); }}

Jei paspaudžiamas mygtukas, bus vadinama kita funkcija: aplyCmd () . Ir kaip sako pavadinimas, taikys atitinkamą komandą, sukant pavarą ON arba OFF:

/ ************************************************* ** * Gauti komandas ir elgtis su aktuatoriais ***************************************** *********** / void aplyCmd () {if (pumpStatus == 1) skaitmeninis rašymas (PUMP_PIN, HIGH); jei (pumpStatus == 0) digitalWrite (PUMP_PIN, LOW); jei (lampStatus == 1) skaitmeninis raštas (LAMP_PIN, HIGH); jei (lampStatus == 0) digitalWrite (LAMP_PIN, LOW); } Kodo svarstymai

Kai galvojame apie 4 didelę „užduočių grupę“:

1. Skaitykite jutiklius
2. skaitymo mygtukai (vietinė komanda)
3. Aktas dėl siurblio / lempos
4. Rodyti visus duomenis

Mes suprasime, kad laikas, kada turėtume atlikti tokias užduotis, nebūtinai yra tas pats. Pavyzdžiui, norėdami perskaityti DHT 22 temperatūros ir drėgmės duomenis, tarp matmenų reikės palaukti mažiausiai 2 sekundes, tačiau minutės yra gerai. Dirvožemio drėgmės jutikliui, nes mažiau matavimų mes darome, geriau (dėl zondo korozijos generuojant elektrolizuojant) ir paskutinį, bet ne mažiau svarbų, dienos šviesa iš karto nesikeis. Bet kai mes galvojame apie pavarą, kai tik paspaudžiame mygtuką, norėtume (ir galbūt) greitai reaguoti.

Taigi, paskutinis nurodymas iki sąranka () bus laikmačio inicijavimas naudojant „ millis () „funkcija, o ne platinti daug vėlavimų visame kode:

Kontūro metu () pirmasis nurodymas bus padidinti kintamąjį pradžia su realiu laiku.

praėjęs laikas = milis () - startTiming ;

Po to nuskaitome mygtuko būseną, naudodami šią funkciją readLocalCmd (). Šis skaitymas įvyks bet kuriuo metu, kai programa atliks kilpą ().

Kalbant apie jutiklius, mes atliksime nuskaitymą, pvz., 5 sekundes, o ne kiekviename kontūre:

jei (praėjęs laikas> (5000))

{

skaitikliai ();

printData ();

startTiming = milis ();

}

Mes matome visą kodą, kad galėtume išbandyti „vietinę stotį“

5 veiksmas: kodo keitimas, kad būtų galima laikytis realių matavimų ir galutinis HW

Kaip matėme paskutiniame etape, reikės laukti ilgų ciklų tarp „Soil Moisture Sensor“ matavimų. Mūsų automatiniai poreikiai yra gerai, bet rankiniu režimu nenorime „laukti“ 10, 15 ar daugiau jutiklių matavimų. Taigi, mes pristatysime trečiąjį mygtuką mūsų projektui, kuriame bus rodomi tikrieji jutiklio duomenys bet kuriuo metu, nepriklausomai nuo automatinių rodmenų laiko. Paskutinis galimas skaitmeninis kaištis yra D17 (tas pats kaip ir A3). Taigi mes jį panaudosime. Taip pat pristatysime „įspėjamąjį šviesos diodą“ (geltoną nuotrauką), kuris bus prijungtas prie kištuko 13 ir bus „šviesus įjungtas“, kai jutikliai bus perskaityti. Pakeiskite pakeistą skaitymo lokalę funkciją:

/ ************************************************* *************** * Skaitykite vietines komandas (siurblio ir lempos mygtukai paprastai yra „HIGH“): ******************* ********************************************* / void readLocalCmd () {int digiValue = debounce (PUMP_ON); jei (! digiValue) {pumpStatus =! pumpStatus; showDataLCD (); aplyCmd (); } digiValue = debounce (LAMP_ON); jei (! digiValue) {lampStatus =! lempa; showDataLCD (); aplyCmd (); } digiValue = debounce (SENSORS_READ); jei (! digiValue) {digitalWrite (YELLOW_LED, HIGH); lcd.setCursor (0,0); lcd.print ("<Atnaujinti jutiklius>"); skaitikliai (); „DigitalWrite“ (YELLOW_LED, LOW); }}

Kitas aspektas yra antrojo dirvožemio drėgmės jutiklio įvedimas. Mūsų galutiniame projekte, jei iš tiesų mes naudosime 2 jutikliais sodinimo zonoje, kad galėtume gauti 2 dirvožemio drėgmės rodmenis skirtingose ​​vietose. Norime nuspręsti, kada įjungti siurblį, naudosime galutinio kodo rodmenų vidurkį.

Jutiklis „VCC ir GND“ bus toks pat (atitinkamai D7 ir D6), o antrąjį jutiklį - A2. Paprastumo dėlei, jei naudojamas tik vienas jutiklis, numatytasis yra A1, o kodas turėtų ignoruoti A2 rodmenį (kintamasis turi būti nustatomas nustatymo metu). Kiekvieno ciklo mėginių skaičius bus apibrėžtas kintamuoju „numSamplesSMS“. Iš esmės čia pakanka tik vieno, atsižvelgiant į tai, kad tiek daug skaitymo, kurį mes atlikome per trumpą laiką, sukels klaidas dėl talpos poveikio. Jei pradėsite matyti klaidas skaitymo metu, galbūt reikia imtis papildomų sampleas.

Palaukite naują dirvožemio drėgmės jutiklio funkciją:

/ ************************************************* ** * Užfiksuoti dirvožemį Drėgmės duomenys ******************************************* ********* / int getSoilMoist () {int i = 0; int anaValue1 = 0; int anaValue2 = 0; (i = 0; i <numSamplesSMS; i ++) // // "numSamplesSMS" apibrėžia kiekvieno skaitymo ciklo mėginių skaičių {digitalWrite (SMS_VCC, LOW); // valdyti srovę per daliklį į vieną kryptį skaitmeninio rašymo (SMS_GND, HIGH); vėlavimas (500); // palaukite momento, kai talpinimo efektai išsprendžia anaValue1 + = analogRead (SOIL_MOIST_1_PIN); vėlavimas (500); // palaukite momento, kol ADC atsiskaito anaValue2 + = analogRead (SOIL_MOIST_2_PIN); skaitmeninis raštas (SMS_VCC, HIGH); // pakeisti dabartinį skaitmeninį įrašą (SMS_GND, LOW); vėlavimas (1000); // suteikti tiek daug laiko „atvirkštinėje“, kaip „skaitmeninio„ pirmyn “(SMS_VCC, LOW); // sustabdyti dabartinį // vėlavimą (3000); } anaValue1 = anaValue1 / (i); anaValue2 = anaValue2 / (i); jei (numSM == 2) anaValue1 = (anaValue1 + anaValue2) / 2; // "numSM" kintamasis, apibrėžiamas prijungtų drėgmės jutiklių skaičius anaValue1 = žemėlapis (anaValue1, 1015, 3, 0, 100); // 1015: 0 (en el air) ==> 003: 100% (poniendo un "trumpasis jungimas) Serial.println (anaValue1), grįžti anaValue1;}

Pirmiau pateiktose diagramose parodyti visi vietinės valdymo stoties HW jungtys

6 žingsnis: žaisti su realaus dirvožemio drėgmės jutikliu

Jūs galite praleisti šį žingsnį, jei norite, bet manau, kad tai būtų įdomu šiek tiek giliau su šiuo paprastu, bet pagrindiniu jutikliu. Kaip trumpai paaiškinta anksčiau, dirvožemio drėgmės jutiklis yra paprastas „varžos įtampos daliklis“.

Sakydami, kad galime sukurti labai paprastą jutiklį, naudojant du metalinius zondus, tokius kaip cinkuoti nagai, kaiščiai ar varžtai. Viršuje galite pamatyti tą, kurį sukuriu naudojant paprastą medžiagą. Pirmasis jutiklis buvo pastatytas tik su dviem varžtais, sujungtais dviem laidais (juoda / raudona). Kaip aprašyta 2 žingsnyje, "R1" yra "dirvožemio atsparumas" (ne geriausias mokslinis terminas, bet tai gerai). Analizei imant 3 ėminio dirvožemio drėgmės mėginius, mes galime matuoti R1 vertę naudojant multimetrą, kaip parodyta aukščiau esančioje nuotraukoje:

• Sausas: R1 => 20 Kohm (aprox)
• Drėgnas: R1 = 4K - 6Kohm (aprox.)
• Drėgnas: R1 => 1Kohm (aprox)

R2 yra fizinis rezistorius, prie kurio prijungsime, kad užbaigtume įtampos skirstytuvą (pradėsime su 10K potenciometru nustatymui). Apskaičiuojant Viną Arduino A1, proporcingai VCC, gautume lygtį:

Vin = R2 / (R1 + R2) * VCC arba Vin / VCC = 10K / (R1 + 10K) * 100 %

Naudodamiesi realiomis vertėmis, matuojamomis su multimetru, galime tikėtis, kad rezultatai turėtų būti:

• Sausas: 10K / 30K * 100 ==> <30%
• Drėgnas: 10K / 15K * 100 ==> ~ 67%
• Šlapias: 10K / 11K * 100 ==>> 90%

Sujungus „Arduino“ ir vykdydami iki šiol sukurtą kodą, mes pasiekėme:

• Sausas: 13%
• Drėgnas: 62%
• Šlapias: 85%

Žinoma, todėl, kad persikėlė jutiklių padėtį, R1 pakeitė, bet kas iš tikrųjų svarbu, yra svyravimo intervalas, o ne absoliuti vertė. Jutiklis bus naudojamas 3 būsenoms:

• Šlapias: daugiau nei 60% (visai ne laistyti)
• Tikslinė drėgmė: nuo 40 iki 60% (kur norime dirbti) ir
• Sausas: 30% (reikia įjungti siurblį, kad padidėtų drėgmė)

Kaip matote, naudojant R2 kaip 10K dirbo gerai, todėl galime išimti potenciometrą ir pridėti fiksuotą rezistorių į mūsų dirvožemio drėgmės jutiklį.

Vienas dalykas, kurį supratau testuojant jutiklius, yra tai, kad dažnai atliekant matavimus bus rodoma klaida, nes jutiklis taip pat veikia kaip „kondensatorius“. Kai „įjungsime“ jutiklį, kad gautume vieną duomenų surinkimą, mums reikia palaukti tinkamo laiko, net ir tada, kai išjungėme jutiklio maitinimą, kad „iškrautume jutiklį“. Dabartinės grįžimas padės, bet to nepakanka. Pirmiau pateiktos grafikos rodo du matavimų rinkinius:

1. Mėlyna linija: 10 matavimų ciklas su 1 sekunde tarp mėginių ir 1 minutė tarp ciklų
2. „Orange Line“: 10 matavimų ciklas su 1 sekunde tarp mėginių ir 5 minutės tarp ciklų

Po 1 sekundės kiekvienas naujas mėginys gerokai padidės. Laukimas 1 minutę po išjungimo sumažins „saugojimo įtampos efektą“, tačiau jo nepašalins ir likutinė vertė bus pridėta prie kito matavimo. Pavyzdžiui, didinant ciklų intervalą iki 5 min., Dauguma klaidų bus pašalinta.

Remiantis pirmiau nurodytais rezultatais, galutiniame kode neturėtų būti imami mažiau nei 10 min.

Vaizdo įraše rodomi bandymai su jutikliu:

7 žingsnis: parodo laiką!

Šiuo metu mes turime visus HW ir beveik visus SW. Trūksta „logikos“, leidžiančios mūsų sistemai automatiškai atlikti drėkinimo darbus! Į smegenis turime įtraukti kai kuriuos „neuronus“!

Kaip aptarta anksčiau, nustatykite pradinį diapazoną, kuriame jutikliai veiks. Šios vertybės turėtų būti pakeistos, naudojant geresnes praktines vertes, kurios vėliau bus pagrįstos tikrajame plantacijoje:

Dirvožemio drėgmė:

• „WET“: virš 60% (visai ne laistyti)
• "Target Humid": nuo 40% iki 60% (kur norime dirbti) ir
• "DRY": 40% (reikia įjungti siurblį, kad padidėtų drėgmė)

Temperatūra:

• ŠALTIS: 15 ° C žemyn (apšvietimas / apšvietimas *)
• Optimalus: nuo 20oC iki 25oC
• KARŠTAS: virš 25 ° C (neįjunkite šviesos / šilumos)

Šviesa:

• DARK (naktis): 40% (neužsukite siurblio)
• ŠVIESA (diena): daugiau nei 40%

(*) Galite pasirinktinai išbandyti specialią hidroponinių augalų auginimo LED šviesų sistemą. Šios LED lempos gali būti naudojamos abiem, kad būtų galima greičiau augti dėl savo ypatingo šviesos dažnio ir taip pat šilumos, esant žemai temperatūrai.

Turite turėti omenyje, kad kiekviena sėklų rūšis turi optimalų temperatūros intervalą, kur jis augs greičiau. Pavyzdžiui, pomidorams minimalus sėklų daigėjimo laikas yra 6 dienos, kai temperatūra yra nuo 20 iki 25 oC, o temperatūra mažesnė arba didesnė nei:

• Temperatūra: laipsniai (oC): 10 15 20 25 30 35
• Žindymo laikas (dienos): 43 14 8 6 6 9

Daugiau informacijos apie šį ryšį (Temp / Germination days) galite patikrinti čia: dirvožemio temperatūros poveikis sėklų daigumui

Turėdami šį 4 skaitymą (Temperatūra, Drėgmė, Dirvožemio drėgmė ir Šviesa), mes galime turėti matricą, apibrėžiančią, kur norime, kad mūsų pomidorai augtų:

Taigi, prisiminkime jutiklio kintamuosius ir nustatykime keletą naujų apibrėžimų:

Naudojamas DHT jutikliui

• int tempDHT;
• int HOT_TEMP = 25;
• int COLD_TEMP = 15;

Naudojamas LDR jutikliui

• int lumen;
• int DARK_LIGHT = 40;

Naudojamas SM jutikliui

• int soilMoist;
• int DRY_SOIL = 40;
• int WET_SOIL = 60;

Remdamiesi pirmiau pateiktais apibrėžimais, pagalvokime apie kai kurias pagrindines prielaidas:

1. Jei tai DRY ==> PUMP = ON ==> per dieną
2. Jei tai yra DRY ==> PUMP = OFF ==> naktį: DARK (pomidorai nemėgsta gauti vandens naktį)
3. Jei tai COLD ==> LAMP = ON
4. Jei tai COLD ==> LAMP = OFF ==> jei dirvožemis yra WET (apsaugoti šaknį)

Šioje pirmojoje projekto dalyje laikysimės paprastos ir neišnagrinėsime visų galimų kombinacijų ir oro drėgmės vaidmens lygtyje. Ištirsime sudėtingesnį jutiklių derinį pagal šio projekto trečiąją dalį, kai taikysime „ArduFarmBot“ tikrąja plantacija.

Kodas:

Kurkime naują funkciją, kuri, remiantis jutiklių skaitymu, automatiškai sujungs su pavaromis, įjungs / išjungs siurblį ir lempą: autoControlPlantation (). Ši funkcija, kaip parodyta žemiau, bus iškviesta kiekviename jutiklių ciklo cikle:

void loop () {// Pradėtas matuoti matavimo laikasTime = millis () - startTiming; readLocalCmd (); // Skaityti vietinio mygtuko būseną showDataLCD (); jei (praėjęs laikas> (sampleTimingSeconds * 1000)) {readSensors (); autoControlPlantation (); startTiming = milis (); }}

Funkcija turės dvi pagrindines užduotis:

• Siurblio valdymas
• Lempų valdymas

Siurblio valdymo segmente bus naudojamas naujas kintamasis: " dirvožemioAtk'.

--------------------------------- PUMP ------ // jei (dirvožemis <DRY_SOIL && lumen> DARK_LIGHT) {if (soilMoistAlert == HIGH) {soilMoistAlert = LOW; turnPumpOn (); } else soilMoistAlert = HIGH; } other soilMoistAlert = LOW;

Šis kintamasis bus naudojamas siekiant išvengti „neteisingo“. Taigi, jei bandymo metu iš tikrųjų gauname teisingumą: soilMoist <DRY_SOIL ir kad tai ne naktį (lumen> DARK_LIGHT), mes iš karto neįsijungsime siurblio, bet laukiame kito ciklo, kad patikrintume, ar „ dirvožemis yra tikrai sausas “. Jei rezultatas yra „taip“ (du kartus gauti atsakymą „tiesa“), funkcija turnPumpOn () bus vadinama:

/ ************************************************* ** * TurnPumOn ********************************************** ****** / void turnPumpOn () {digitalWrite (PUMP_PIN, HIGH); pumpStatus = 1; showDataLCD (); vėlavimas (timePumpOn * 1000); „DigitalWrite“ (PUMP_PIN, LOW); pumpStatus = 0; showDataLCD (); }

Siurblys turi būti įjungtas nustatytu laiku, kurį nustato kintamasis: ' timePumpOn " sekundėmis.

Atkreipkite dėmesį, kad mes taip pat pakeitėme funkciją, rodančią duomenis LCD, todėl siurblio būsena bus:

• "0": siurblys išjungtas (pumpStatus = 0; ir soilMoistAlert = 0;)
• „X“: įspėjamasis siurblys (pumpStatus = 0: ir soilMoistAlert = 1;)
• "1": siurblys įjungtas (pumpStatus = 1; ir soilMoistAlert = 0;)

lcd.print („Siurblys:“); jei (soilMoistAlert == 1) lcd.print („X“); kitaip lcd.print (pumpStatus);

Tas pats principas bus taikomas ir lempų valdymui, tačiau dabar „žemos temperatūros“ bus naudojama lempai, o ne „sausai dirvai“, ir jei ji nėra „pernelyg šlapi“. Užpildykite visą funkciją: autoControlPlantation ():

/ ************************************************* ** * Automatinis sodinimo valdymas pagal jutiklius skaityti *************************************** ************* / void autoControlPlantation () {// ----------------------------- ---- PUMP ------ // jei (soilMoist <DRY_SOIL & & lumen> DARK_LIGHT) {jei (soilMoistAlert == HIGH) {soilMoistAlert = LOW; turnPumpOn (); } else soilMoistAlert = HIGH; } other soilMoistAlert = LOW; // --------------------------------- HEAT ------ // jei (tempDHT <COLD_TEMP && soilMoist <WET_SOIL) {if (tempLowAlert == HIGH) {tempLowAlert = žemas; skaitmeninis raštas (LAMP_PIN, HIGH); lempaStatus = 1; } kitas tempLowAlert = HIGH; } else {tempLowAlert = LOW; digitalWrite (LAMP_PIN, LOW); lempaStatus = 0; }}

Šiuo metu „ArduFarmBot“ yra visiškai funkcionalus pagal HW ir SW. Visą kodą galima rasti:

8 veiksmas: perėjimas prie mažos formos faktoriaus

Kai turėsime funkcinį prototipą, suraskime ją geriau, naudodami „Funduino Nano Shield“ ir plastikinę dėžutę, padedančią atlikti išorinius bandymus. Didelis nano skydo privalumas yra tas, kad kiekvienas komponentas yra geriau surenkamas, mažinant blogus kontaktus ir triukšmą. Taip pat išoriniams bandymams lengva turėti visus pagrindinius komponentus ant mažos plastikinės dėžutės>

1. Jei naudojate atskirą DHT, turite pridėti 10K rezistorių tarp VCC ir signalo. Jei naudojate jutiklio modulį, rezistorius jau yra įtrauktas. Šiam naujam testui naudoju turimą DHT11 modulį. Mūsų tikslas yra tas pats (tik nepamirškite pakeisti kodo eilutės, kad nustatytumėte tinkamą jutiklį, kurį naudosite: #define DHTTYPE DHT11).
2. Padarykite 4 vaidmenis plastikinėje dėžutėje LCD įrengimui (paleidžiu jį dėžutės viduje).
3. Padarykite šonines skylutes dėžutėje, kad galėtumėte išjungti jutiklius ir turėti prieigą prie nano (maitinimas per išorinį maitinimo šaltinį arba SW atnaujinimus) ir pavaros (siurblio / lempos) prijungimas su relių išėjimais

Atkreipkite dėmesį, kad čia naudoju „1x4 raktų matricos membranos jungiklį“ kaip mūsų valdymo mygtukus.

Galite nuspręsti, kaip geriausiai pakoreguoti komponentus. Asmeniškai norėčiau, kad paprastas 3M dalykas būtų lengva nustatyti / pašalinti (žr. Aukščiau pateiktą nuotrauką).

9 žingsnis. Funkciniai bandymai

Kai viskas bus užfiksuota vietoje ir išsiųsta SW, atlikite keletą funkcinių testų, imituojančių įvairias jutiklio sąlygas, kad patikrintume, ar visi tinkamai surinkti:

1. Įprastoje šviesoje ir temperatūroje įpilkite dirvožemio drėgmės jutiklį ant puodelio su šlapiu dirvožemio mėginiu. Atkreipkite dėmesį į 1 nuotrauką (Temp yra 22 ° C; dirvožemio Hum. Yra 85%, o šviesa - 80%). Nieko neturi įvykti. PUMP ir LAMOP turi būti OFF ("0").
2. Laikydami tą pačią šviesą ir temperatūrą, perkelkite dirvožemio zondą į puodelį su sausu dirvožemio mėginiu. 2 paveiksle stebite, kad siurblys buvo įjungtas (pirmiausia kelias sekundes nuvyko į „X“ ir po to „1“, kaip apibrėžta apibrėžimuose).
3. Dabar, kaip parodyta 3 nuotraukoje, LDR buvo padengtas ir „Light%“ sumažėjo iki 19%. Šiuo atveju, nepaisant to, kad dirvožemis yra sausas, siurblys neįsijungs, nes mūsų valdiklis supranta, kad jis yra naktį.
4. 4 nuotraukoje įdėjome ledą mūsų dėžutės apačioje, netoli DHT jutiklio. Temperatūra sumažėjo iki 12 ° C, o lemputė buvo įjungta.
5. Ir paskutinis, bet ne mažiau svarbus dalykas, 5 nuotraukoje mes laikome ledą, bet vėl pakeisime zondą į drėgno dirvožemio mėginį. Šiuo atveju, nepaisant to, kad pagal mūsų matricą šaltas, lemputė išjungta

10 žingsnis: „Test Drive“: „ArduFarmBot“ pomidorų augalų laistymas

Bandymams prijungiau elektrinį siurblį, kurį turiu. Tai nebus galutinis, bet gali parodyti, kaip projektas veiks (Taigi, nerūpi tuos, kuriuos pamatysite vaizdo įraše).

11 veiksmas: „ArduFarmBot“ veiksmas

Pagal viską, ką sužinojome čia, Maurício įdėjo ArduFarmBot, kad iš tikrųjų kontroliuotų savo pomidorų plantaciją. Remiantis šia realiąja patirtimi turėtume geriau kalibruoti ir apibrėžti jutiklius ir projekto parametrus. Pirmiau pateiktose nuotraukose parodyta žemės paruošimo ir sėklų pristatymo seka.

Filmas rodo, kad „ArduFarmBot“ veikia:

Dabar tik viltis puikioms salotoms !!!! Salut!;-)

12 žingsnis. Išvada

Šiuo tikslu užbaigiame pirmąją „ArduFarmBot“ projekto dalį. Čia mes sukuriame a Vietinė valdymo stotis, užfiksuoti informaciją iš pomidorų plantacijos, kaip temperatūrą, santykinį oro drėgnumą, šviesumą ir dirvožemio drėgmę. Remiantis šiais duomenimis, „ArduFarmBot“ automatiškai nusprendė, kad reikiama suma (ir kada) turi gauti šilumą ir vandenį. Vietinė stotis taip pat leido rankiniu būdu įsikišti operatoriui, kad galėtų valdyti vandens siurblį ir elektros lempą.

Dabar atėjo laikas susieti mūsų mažąjį draugą su internetu. ArduFarmBot - 2 dalis: „Nuotolinė stotis“ - „IoT“ įgyvendinimas, mes įdiegsime „IoT“ metodą, kai „rankinis įsikišimas“ bus įmanoma ir nuotoliniu būdu per internetą. Antroje dalyje užfiksuoti duomenys bus siunčiami į „Cloud Storage“ paslaugą (mūsų atveju Thinkspeak.com). Be to, specialioje interneto svetainėje „Nuotolinio valdymo puslapis“ bus stebimi ir rodomi šie duomenys beveik realiuoju laiku. Šis puslapis taip pat leis siurblį ir lempos nuotolinį aktyvavimą. Pažvelkite ten ir mėgaukitės!

Pagrindines bylas galima rasti projekto depozitoriume: ArduFarmBot GitHub

Kaip visada, tikiuosi, kad šis projektas padės kitiems rasti kelią į įdomų elektronikos ir robotų pasaulį!

Jei norite gauti daugiau projektų, apsilankykite mano dienoraštyje (portugalų kalba): MJRoBot.org

Saludos iš pasaulio pietų!

Pažvelk į mano kitą pamokomą!

Ačiū

Marcelo ir Maurício

13 žingsnis: ArduFarmBot, knyga!

„ArduFarmBot, knyga“ taip pat yra „Amazon.com“! Ją galite gauti spustelėję skydelį:

Knyga naudoja elektroninį valdiklį ArduFarmBot kaip pagrindą mokyti, kaip dirbti HW ir SW, su: a) LCD ir OLED tipo ekranais; b) LED ir mygtukai; c) siurblių ir lempų aktyvinimas per reles ir d) jutikliai, tokie kaip: DHT22 (temperatūra ir santykinė oro drėgmė), DS18B20 (dirvos temperatūra), YL69 (dirvožemio drėgmė) ir LDR (šviesumas).

Visi pagrindiniai projekto etapai išsamiai aprašomi aiškinamaisiais tekstais, blokinėmis schemomis, aukštos rezoliucijos spalvomis, elektrinėmis diagramomis, naudojant Fritzing programoje, užpildyti visi kodai GitHub ir „YouTube“ vaizdo įrašai.

Dvi elektroninio valdiklio versijos ArduFarmBot išsamiai aprašytos knygoje. Nuo duomenų, gautų iš sodo, surinkimo, pavyzdžiui, oro ir dirvožemio temperatūros, santykinės drėgmės, dirvožemio drėgmės ir šviesumo, ArduFarmBot padeda kontroliuoti, kada pasėliai turėtų gauti šilumą ir vandenį. Kontrolė bus vykdoma automatiškai, vietoje ir nuotoliniu būdu internetu. Knyga yra padalinta į 3 dalis. Pirmojoje dalyje Arduino Nano yra vietos vietinės versijos kūrimo pradžia ArduFarmBot, kurią galima valdyti rankiniu būdu ir automatiškai.

Antroje dalyje knyga įsijungia į automatizavimo projektą, įvedant nuotolinį valdymą sukuriant tinklalapį. The ESP8266-01 yra naudojamas „Wi-Fi“ ryšiui, siunčiant duomenis į svarbią interneto paslaugą IoT srityje ThingSpeak.com.

Trečioje dalyje - antroji ArduFarmBot sukurtas, įvedant NodeMCU ESP8266-12E - galingas ir universalus „IoT“ įrenginys, kuris pakeičia tiek „ Arduino Nano ir ESP8266-01, naudojami ankstesnėse knygos dalyse.

Šioje paskutinėje knygos dalyje - naujoji DI interneto paslaugų platforma Blynk, taip pat tiriamas.

Atsisiųskite knygą, perskaitykite ją ir naudokite čia esančią pranešimų lentą, kad galėtumėte mums pateikti komentarus, pasiūlymus ar kritiką!

Labai ačiū

Saludos desde el sur del mundo !

Marcelo