# Rädda växterna när du är borta med en temperaturstyrd fläkt
Axel Gunnarsson AG223TR
I denna guide ska vi gå igenom alla steg för att kunna logga temperaturen i växthuset på pybytes.com. Vi ska även göra det möjligt att se hur mycket fläkten behöver arbeta genom ett relä för att hålla temperaturen där du vill ha den.
Guidens sträckning är ca 3 timmar.
## Mål
I detta projekt ska vi arbeta fram ett system för att kunna hålla temperaturen i växthuset på en rimlig nivå. Speciellt nu när vårvädret blir varmare och varmare och sommrarna längre och längre. Genom att mäta temperaturen och från denna styra en fläkt som skickar ut den varma luften kan temperaturen hållas på en satt nivå. Förhoppningsvis ser vi att växterna mår bättre och att det går åt mindre vatten.
Genom att skapa grafer över datat kan yttligare åtgärder tas om det skulle visa sig att det skulle behövas. Om fläkten ej klarar att hålla temperaturen på en rimlig nivå eller att den är för kraftig så att tiden den är igång kan minskas för att spara energi.
## Material
För att kunna utföra detta projekt så behövs det ett antal delar och sensorer. Jag beställde mina från Electrokit.com som ett komplett kitt med sensorer och kort. En LoPy4 med expansionskort och några sensorer går på ca 1000kr och är ett utmärkt startpaket för den nyfikne.
| Del som användes | Kommentar
| -------- | -------- |-----|
| Fläkt | En datorfläkt eller liknande med passande elförsörjning för att transportera ut värmen. 
| Relä KY-019 | Ett relä som kan slå på och av fläkten. Viktigt att denna klarar motsvarande Volt och Ampere som fläkten. Tänk på att dem klarar olika mycket beroende på AC / DC. 
| Sensor Temperatursensor 18B20 | Valfri sensor som kan mäta minst 0-60c så vi får data att starta fläkten med. 
| Pycom LoPy4 med Expansionsbräda | Krävs för att läsa data från sensorerna och sända detta till dashboarden. 
| 10~ Kablar och breadboard | Det krävs ett antal kablar för att koppla ihop delarna och det är rekommderat att köpa ett breadboard vilket underlättar inkopplandet. Ett breadboard hjäper till att strukturera upp kablarna till och från sensorerna. 
## Installation av program och LoPy4
LoPy4 och expansionskortet kan behöva uppgraderad programmvara beroende på när de tillverkades. Bäst är att gå till tillverkarens hemsida för din modell och kontrollera de senaste tillvägagångsätten för uppgradering. Det senaste för [Expansionskortet](https://docs.pycom.io/gettingstarted/connection/lopy4/) och så tar vi LoPy4 när den är ansluten till WiFi.
När uppdateringen av expansionskortet är gjort kan vi ansluta LoPy4 genom att lätt trycka ihop dem med LED lampan på samma sida som USB-kontakten. Sedan kan vi ansluta expansionskortet och LoPy4 till datorn med en micro-usb-kabel och börja installera programmen.
Visual Studio Code är det verktyg som använts för att göra detta projekt men det kräver två tillägg, PyMakr och Python. Dessa går att enkelt installera i VSCode genom att söka efter dem i Extensions-fliken, de fyra vita kuberna till vänster i fönstret.
Python behöver läggas till för att VSCode ska kunna hjälpa dig formatera koden och att hjälpa dig hitta fel.
PyMaker används får att få tillgång till REPL consolen och verktyg för att ladda upp kod till LoPyn. REPL consolen är en direktlänk till LoPy4 där man kan skriva kod som exekveras direkt. Det är även här texten från print-funktionen kommer att visas.
Det kan krävas att VSCode startas om några gånger under installationerna av tilläggen. När installationen av PyMakr är klar så kommer det upp en ruta i nedre delen av fönstret och i underkant en blå rad. Här kan vi se några viktiga funktioner:
* Run : Kör den fil du har framme just nu i VSCode.
* Upload : Laddar upp hela mappen du valt och sparar den på LoPy4. Detta behöver göras om man ska köra kod via batteri eller liknande utan en ansluten dator.
* Download : Laddar ner de filer och mappar som finns på enheten.
När båda tilläggen är installerade och klara kan vi välja att skapa ett nytt projekt genom att trycka på File -> Open Folder och välja en tom mapp för detta projekt. Skapa sedan en fil som heter main.py, detta är huvudfilen som kommer användas av LoPy4 efter den startat. Det är i denna vi kommer arbeta till en början.
Vi kan testa så att allt fungerar som tänkt genom att skriva `print("Hello World")` i main.py och sedan trycka run på menyn längst ner. Vi kan även skriva samma sak direkt i REPL consolen, detta ska ge likadant resultat. Rekommenderar att ställa in 'safeboot on upload' för att lättare komma ur fastnade loopar eller liknande problem.
Detta gör du genom att välja `All commands -> Global settings`, då visas filen pymakr.json, ändra raden med safe_boot_on_upload till true.
Fungerar allt ovan så kan vi fortsätta genom att gå till https://pybytes.pycom.io/ för att ansluta LoPy4 till Pybytes hemsida och ställa in WiFi på ett enkelt sätt.
Gå till `ADD DEVICE` och välj sedan rätt modell. Sedan behöver vi skriva in namnet på vårt lokala WiFi och lösenord till detta. Detta behöver göras för att enkelt kunna lägga till LoPy4 till det egna WiFi-nätverket.
Gå till `PROVISIONING` via menyn och kopiera sedan texten under `ACTIVATE YOUR DEVICE WITH PYMAKR PLUGIN`. Denna text ska kopieras in i VSCode som nedan. Detta ska reslutera i att enheten ansluter till ditt WiFi när du trycker enter.
Det går enkelt att testa om detta fungerade genom att skriva `pybytes.send_signal(1,100)`. Antingen i main.py och trycka run eller så kan det skrivas direkt i REPL-consolen. Kontrollera att signalen kom ända fram till pybytes hemsida genom att gå in på menyn `SIGNALS`
Nu när enheten är ansluten kan vi gå till 'Configuration' och kontrollera så att LoPy4 har den senaste firmware-versionen. Om den inte har det så välj den senaste i menyn och tryck updatera och följ instruktionerna.
## Koppla samman allt
Vi börjar med att ansluta alla komponenter till varandra enligt diagrammet nedan. Använd ström direkt från LoPy4 då det inte är några större laster. Det är viktigt att tänka på om det handlar om stora laster vilka då kan kräva mer ström än LoPy kan leverera. Då måste extern ström användas för att inte skada LoPy4. Det underlättar att använda ett breadboard för att få en bättre översikt över kopplingarna mellan sensorer och kretskort. Uppe till vänster i bild ser vi reläet där den svarta kabeln är från laddaren, den röda är till fläkten. Brun och röd ger ström till reläet och ljusblå ställer om det är aktivt genom att ge ström eller inte. Kontrollera vad reläet klarar då det kan gå illa om detta överskrids. Reläet ansluts till `P10` på LoPy4.
Uppe till höger i bilden kan vi se temperatursensorn. Den anväder ett protokoll där man bara behöver en data kabel. Kontrollera alltid tillverkarens datablad där det ofta står vilken anslutning som ska användas. Ofta finns ett PIN in/out diagram som visar hur anslutningen till sensorn ska ske då den annars kan ta skada. Här ger brun och röd ström till sensorn och lila läser datat genom att först notifiera om att läsning kommer ske för att sedan läsa värdet. Sensorn ansluts till `P11` där vi använder det externa paketet OneWire för att läsa datat digitalt. OneWire är en samling av hjälpklasser som är till för att användaren lätt ska komma igång med en eller fler sensorer.
## Plattform
För att representera datan har Pycoms egna plattform Pybytes använts. Projektet presenterar datat som sensorn skickar ut för användaren. Detta för att användaren ska kunna kontrollera om det behövs tas några extra åtgärder för att växthuset ska hålla en bra temperatur. Det underlättar att se en graf över temperaturen och hur mycket fläkten arbetat för att gradvis kunna göra justeringar.
Det är möjligt att skapa en dashboard, en visningsyta där man kan placera passande grafer med data från sensorerna. Det går att visa flera grafer samtidigt vilket gör det enkelt att se sambandet mellan temperatur och till exempel hur länge fläkten arbetat. Det som fattas på Pybytes är egna notiser baserat på datat som skickas upp. Det som finns tillgängligt just nu är att man kan få notiser om enheten tappar anslutning, enheten har lågt batteri eller använder för mycket data.
## Programmet
LoPy4 sätts i en evig loop där den var 15e sekund läser av temperaturen från sensorn och tar ett beslut om den ska starta fläkten. Sensorn kan ge felaktig data så dessa hopp i temperatur sorteras bort genom att mäta skillnaden från den förra mätningen. Är skillnaden mer än 2 grader över eller under förra mätningen så mäter LoPy4 igen för att se om vi får ett reelt värde.
```
# Läser sensorvärde och beroende på värde startar fläkten
# Skickar även sensorvärdet till pybytes och om fläkten går eller inte.
import time
from machine import Pin
import _thread
from onewire import DS18X20
from onewire import OneWire
import pycom
pycom.heartbeat(False) # Stänger av std-blinkande LED
start_fan_temp = 30 # Sätter ovanför vilken nivå vi vill att fläkten ska köra.
def send_env_data(): # Huvudmetoden som körs i en separat tråd.
global error_count
error_count = 0 # För att hantera att sensorn ibland felaktigt skickar -170 & 200+
old_result = 25
temp.start_conversion() # Berättar för sensorn att vi tänker läsa.
time.sleep(1)
old_result = temp.read_temp_async() # Läser sensorvärdet för att få något att jämföra mot
time.sleep(1)
while True: # Vi gör detta förevigt
pycom.rgbled(0x002200)
temp.start_conversion()
time.sleep(1)
pycom.rgbled(0x00)
result = temp.read_temp_async()
diff = result - old_result # Räknar ut skillnaden mot förra läsningen för att hitta felaktiga värden.
if (result < -10 or result > 70) or ((diff >= 2 or diff <= -2) and error_count < 3): # Ta bort så mycket feldata som möjligt.
pycom.rgbled(0x220000)
time.sleep(.3)
global error_count
error_count = error_count + 1 # Om vi mot förmodan skulle ha +2c på 5sek så måste vi komma ur denna efter 3 'felaktiga fel'
print('error_count:', error_count)
time.sleep(.5)
else:
pycom.rgbled(0x000022)
time.sleep(.3)
old_result = result
if result > start_fan_temp: # Om temperaturen är mer än den satta startar vi fläkten
pin_fan.value(1)
pybytes.send_signal(2,1) # Vi skickar en signal till pybytes att fläkten är igång så vi ser det i vår graf
else:
pin_fan.value(0)
pybytes.send_signal(2,0)
print('Temp sent:', old_result)
pybytes.send_signal(1,round(result,1))# Är inte signalen felaktig så skickar vi den till pybytes
global error_count
error_count = 0 # Resetar felräknaren så vi fortsatt max får 3 'felaktiga fel'
pycom.rgbled(0x00)
time.sleep(5)
pin_fan = Pin('P10', mode=Pin.OUT) # Sätter vilken PIN reläet ska vara på
pin_fan.value(0) # Sätter den till 0 för att säkra att det inte kommer någon ström
oneWire = OneWire(Pin('P11')) # Sätter vilken PIN temperatursensorn ska vara på
temp = DS18X20(oneWire) # Använder hjälpklassen onwires funktioner för att hanter onewire protokollet.
_thread.start_new_thread(send_env_data, ()) # Startar en separat tråd för detta möjligen onödigt då vi bara har en uppgift just nu.
```
## Sändning av data
Infomationen skickas till pybytes med pycoms egna implementation av MQTT som är med bundlat i LoPy4 med MicroPython. Informationen skickas var 15~sek för att fläkten inte ska gå för korta stunder. Växthuset i fråga är inom WiFi avstånd och det finns el indraget vilket underlättade installationen av detta system. Noterat att vid dåligt väder kan vissa sändningar via den interna WiFi-antennen inte nå routern så vissa datapunkter försvinner.
## Presentation
Informationen sparas i databasen som en enkel datapunkt med värde och tidsstämpel. Dessa sparas i 30-dagar och sedan tas de bort automatiskt. Till vänster kan man se grafen över temperaturen i växthuset och hur den förändrats över tid. Grafen till höger visar när fläktarna har kört under dagen med samma tidsram för att göra det enkelt att jämföra och dra slutsatser. Det märks tydligt när solen tittar fram mellan molnen och fläkten börja arbeta.
## Slutlig design
Resultatet blev bra, projektet blev som förväntat av en prototyp, det finns förbättringsmöjligheter. Temperaturen håller sig vid satt värde men det ser ut som att fläkten som valts är för liten riktigt varma dagar. Temperatursensorn är väldigt känslig för direkt solljus och värmestrålning. Så under tiden den varit placerad i växthuset har extra skydd behövts placeras ut för att skydda sensorn.
Den slutliga lådan kan ses nedan där temperatursensorn sticker ut för att inte påverkas av temperaturen i lådan. Man kan även se kabeln som försörjer LoPy4 med ström och kabeln som driver fläkten.
Om mer tid skulle läggas i projektet är ett av stegen framåt en bättre plattform för att lagra och hantera datat. Detta eftersom notiser när det är för varmt vore en bra framtida funktion. Att sedan utveckla ett enklare system för att kunna justera vilken temperatur man vill ha i växthuset från denna plattform. Möjligheten till att kunna göra en kombinerad graf så det blir enklare att se hur effektiv fläkten är vore också av intresse. En framtida produkt bör ha en större antenn eller sända data via ett annat system då mottagningen regniga dagar var skakig.
Sign in with Wallet
Connect another wallet