Share
I denne opplæringen skal jeg utnytte Raspberry Pi's awesomeness for å bygge en fuktighetssensor for en plantepotte. Du vil kunne overvåke sensoren lokalt på LCD eller eksternt, via ControlMyPi.com, og motta daglig e-post hvis fuktigheten faller under et spesifisert nivå.
Underveis vil jeg:
For å få mest mulig ut av denne opplæringen anbefales det at du skaffer deg følgende:
Etter å ha lagt på noen få dollar til jumpertrådene, koster det totale prosjektkostnaden omtrent $ 55 uten LCD og $ 82 med. Husk at du lager din elektronikkpakke - alle disse delene kan brukes igjen til andre prosjekter.
Hvis du bruker LCD-skjermen med stablingshodet, kobler du det til Raspberry Pi nå. De to første stadiene av programvaren bruker ikke LCD-skjermen, men det vil spare deg for litt omkoblingstid senere hvis du legger den til nå.
Advarsel: Feil kabling kan forårsake skade på Raspberry Pi. Pass på at du kontrollerer alle forbindelsene nøye før du slår på.
På venstre side i bildet kan du se de røde og svarte hopperne går til + og - skinner på brødbrettet. For å beskrive forbindelsene fra overskriften, vennligst se dette fargebordet. Hver celle i tabellen refererer til en pinne på Raspberry Pi header. Fargene til cellen svarer til fargene på jumperkabelen som vist på bildet:
Koble pin 1 til positiv skinne og pinne 6 til bakken.
Viktig: Brikken må være plassert over dalen i breadboard med pin 1-indikatoren, innrykket, øverst til høyre som på bildet.
Se dette trådfargebordet og databladet når du kobler opp denne brikken:
Alle forbindelsene fra skinnene og toppteksten til MCP3008-brikken går pent langs bunnlinjen i brikken i denne retningen. Koble først strømmen og bakken som vist på bildet ovenfor:
Deretter kobler du Raspberry Pi SPI header pins til brikken:
Sensorkablingen er enkel; det er tre tilkoblinger å lage:
Til slutt, hvis du har plantekaret til hånden, kan du sette sonden i jorda nå. Pass på at du ikke skyver den for dyp
Dette prosjektet ble bygget med Occidentalis v0.2 fra Adafruit, som følger med SPI-driveren for maskinvare klar til å gå. Følg instruksjonene på Adafruit-siden for å installere den på Raspberry Pi.
Tips: Hvis du bruker Wheezy-nedlastingen fra Raspberry Pi-siden, må du finne og følge noen skritt for å aktivere SPI-driveren selv ...
git - Du burde allerede ha dette (prøv å skrive git) Hvis ikke, installer du det med: sudo apt-get install git
pip - installer dette med: sudo apt-get install python-pip
Alle koden for dette prosjektet er skrevet i Python. Vi trenger en Python wrapper for SPI driveren, slik at vi kan lese verdiene fra sensoren over SPI:
cd ~ git klon git: //github.com/doceme/py-spidev cd py-spidev / sudo python setup.py installasjon
Du vil allerede ha installert Adafruit-biblioteket når du monterer og tester LCD-skjermen. Sørg for at du vet plasseringen av biblioteket da dette vil være nødvendig av prosjektkoden.
ControlMyPi er en tjeneste for å raskt og enkelt lage kontrollpaneler på Internett fra Raspberry Pi Python-skriptene. Bruk pip for å installere den:
sudo pip installere kontrollmypi
Alle koden fra denne opplæringen kan lastes ned slik:
cd ~ mkdir py cd py git klon git: //github.com/jerbly/tutorials
Du må redigere noen av disse filene for å levere brukernavn, passord og filbaner. Dette forklares som vi går.
MCP3008 konverterer inngangsspenningen til et tall fra 0 til 1023 (10 bits). Du kan da lese denne verdien over SPI (de grønne og hvite tilkoblingene til toppteksten på Pi). Py-spidev-pakken lar oss gjøre dette fra Python.
Det er litt subtil komplikasjon med å lese et 10-bits nummer i et 8-bits system. SPI-driveren returnerer to 8-biters ord og vi er interessert i de siste 2 bitene i det første ordet etterfulgt av alle 8 bitene av det neste ordet. For å gjøre dette til et nummer vi kan jobbe med, må vi maske og deretter skifte til venstre av 8 de 2 bitene fra det første ordet før du legger til det andre ordet.
Du trenger ikke å bekymre deg for koding dette skjønt, som i nedlastingen har jeg tatt med mcp3008.py-modulen for å ta vare på den. Du kan bruke et interaktivt Python-skall for å teste ditt SPI-oppsett og ledningsnettverket ditt slik:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python Python 2.7.3 (standard, Jan 13 2013, 11:20:46) [GCC 4.6.3] på linux2 Type "hjelp", "copyright", "credits" eller "lisens" for mer informasjon. >>> import mcp3008 >>> mcp3008.readadc (5) 444
Viktig: Du må kjøre Python med sudo, slik at du kan få tilgang til SPI-enhetsdriveren.
Hvis du har problemer, må du først dobbeltsjekke ledningen. Dobbeltklikk deretter installasjonstrinnene for programvare ovenfor. Hvis du bruker blekksprut fuktighetssensoren, må du holde tappene for å få en forbindelse med hånden. Ellers vil det sannsynligvis bare lese null.
Du kan ta sensoren ut av ligningen her ved å koble en jumper fra strømskinnen til, si, CH1 og deretter bruke readadc (1). Dette burde returnere 1023 (eller i nærheten av det). På samme måte skal en tilkobling fra bakken skinne returnere 0.
Det første programmet utvider bare det vi trente i den interaktive konsollen for å inkludere en sløyfe, slik at verdien fra sensoren skrives ut kontinuerlig:
fra tid import import søvn importere mcp3008 mens True: m = mcp3008.readadc (5) print "Fuktighetsnivå: :> 5" .format (m) søvn (.5)
Legg merke til at det er en halv sekund i sløyfen. Dette er så programmet gir; det gir vei til andre prosesser. Ellers ville det bruke mye CPU-tid, og andre prosesser du kjører ville ikke fungere så bra. En lesning to ganger per sekund er trolig altfor mye uansett, absolutt for en fuktighetssensor.
Utgangen skal være slik:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_cmd.py Fuktnivå: 452 Fuktnivå: 486 Fuktnivå: 485 Fuktnivå: 483 Fuktnivå: 489 Fuktnivå: 491 Fuktnivå: 490 ^ CTraceback sist): Fil "moist_cmd.py", linje 7, innsove (.5) KeyboardInterrupt pi @ raspberrypi ~ / py / tutorials / moisture $
Bare trykk Kontroll-C når du er ferdig og programmet avsluttes som ovenfor.
Dette programmet forbedrer skjermen til konsollen. I stedet for å skrive ut verdien til skjermen i et rullevindu, vil dette skriptet opprette en dashbord-effekt. Hver sensoravlesning er skrevet over toppen av sist slik at vinduet ditt ikke rulle.
Også rød, gul og grønn bakgrunn brukes som trafikklys høydepunkter. Når jorden er godt vannet, blir bakgrunnen grønn. Når den er for tørr, vil den vise rødt.
For å oppnå denne fargingen, brukes spesielle ANSI escape-koder til å sende kommandoer til konsollen. Hver escape code sekvens starter med \ x1b [etterfulgt av kommando koder for å produsere en effekt.
fra tid import import søvn import mcp3008 # ANSI rømningskoder PREVIOUS_LINE = "\ x1b [1F" RED_BACK = "\ x1b [41; 37m" GREEN_BACK = "\ x1b [42; 30m" YELLOW_BACK = "\ x1b [43; 30m" RESET = "\ x1b [0m" # Slett skjermen og legg markøren øverst utskrift '\ x1b [2J \ x1b [H' print 'Fuktsensor' print '================ \ n 'mens sant: m = mcp3008.readadc (5) hvis m < 150: background = RED_BACK elif m < 500: background = YELLOW_BACK else: background = GREEN_BACK print PREVIOUS_LINE + background + "Moisture level: :>5 ".format (m) + RESET søvn (.5)
Programmet rydder skjermen og viser en tittel. Det går så inn i evig loop igjen, men denne gangen bruker terskler for å bestemme bakgrunnsfargen. Til slutt skrives utgangssekvensene og teksten ut etterfulgt av a TILBAKESTILLE sekvens for å slå av fargen. De PREVIOUS_LINE escape code brukes til å flytte markøren tilbake en linje slik at vi skriver over toppen av forrige verdi hver gang.
Kjør dette eksempelet slik:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_ansi.py
Utgangen bør være noe slikt:
Vi skal nå flytte fra konsollen og vise sensordataene på LCD-skjermen i stedet. Før du fortsetter med denne opplæringen, må du sørge for at du har bygget din Adafruit LCD med stablingshodet og du har testet det ved å følge Adafruit-veiledningen.
Vårt program skal bruke Adafruit biblioteket, slik at vi trenger å vite hele veien til Adafruit_CharLCDPlate katalogen. Jeg lager ganske enkelt en py-katalog under pi-brukerens hjem for å holde Python-koden på ett sted, så på min Raspberry Pi er banen:
/ Home / pi / py / Adafruit-Raspberry-Pi-Python-kode / Adafruit_CharLCDPlate
Du må kanskje justere følgende skript hvis banen din er annerledes.
Accentsconagua
importer sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-kode / Adafruit_CharLCDPlate') fra tid import søvn fra Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 lcd = Adafruit_CharLCDPlate () mens True: m = mcp3008 .readadc (5) prøv: lcd.home () lcd.message ("Fuktighetsnivå: \ n% d"% m) hvis m < 150: lcd.backlight(lcd.RED) elif m < 500: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e sleep(.5) Kjør programmet slik:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_lcd.py
Du bør se LCD-versjonen av fargekonsollprogrammet. Denne gangen bruker de røde, gule og grønne terskelindikatorene RGB-bakgrunnsbelysningen.
I denne delen skal vi bruke ControlMyPi til å produsere et dashbord på Internett. Slik beskrives tjenesten fra FAQ:
ControlMyPi tilbyr en web-basert tjeneste for å tillate enkle Python-skript å bli styrt fra et panel over Internett. Ditt Python-skript definerer en widgetoppsett av etiketter, knapper, statusindikatorer og mer for ControlMyPi å vise. Når en knapp klikkes vil skriptet få en melding. Hvis du har status for å rapportere, kan skriptet ditt sende det til ControlMyPi når som helst, og det vil bli presset ut i nettleseren din.
Hvis du ikke allerede har installert Python-pakken, gjør du det nå. Du trenger også en XMPP-konto. Jeg vil anbefale en Google Gmail-konto siden dette fungerer bra, og vil også bli brukt senere når vi vil at vårt skript skal sende en e-post. Følg instruksjonene på ControlMyPi-nettstedet for å komme i gang og teste forbindelsen.
Den første iterasjonen på instrumentbrettet vil bare vise en enkelt måler med sensoravlesningen. Vi vil presse en ny lesing opp til ControlMyPi hvert 30. sekund for å produsere dette:
Skriptet for å produsere dette er fortsatt relativt rett frem:
fra tid import import søvn import mcp3008 fra controlmypi import ControlMyPi import logging def on_msg (conn, nøkkel, verdi): pass logging.basicConfig (level = logging.INFO) p = [[['G', 'fuktig', 'nivå' 0,0,1023]],] conn = ControlMyPi ('[email protected] ',' passord ',' fuktighet ',' fuktighetsmonitor ', p, on_msg) hvis conn.start_control (): prøv: mens True: m = mcp3008.readadc (5) conn.update_status ('fuktig': m) sove (30) til slutt: conn.stop_control () På toppen importerer vi nå ControlMyPi-klassen og loggmodulen. Hvis du trenger å feilsøke eventuelle problemer med XMPP-tilkobling, endrer du loggnivået til DEBUG.
De on_msg funksjon er det som ville bli kalt hvis vi definerte noen knapper eller andre innganger i vårt widgetoppsett. Siden vi bare har en måler er det ingen inngang og så gjør denne funksjonen ingenting.
Listen, p, er hvor widgetoppsettet er definert. Hver oppføring i listen definerer en rekke widgets som skal vises på dashbordet. Vi har en enkelt rad med en enkelt widget på den, måleren. Fuktig er navnet på widgeten, nivået er at etiketten skal vises på måleren, 0 er startnivået, 0 er minimumsnivået og 1023 er maksimumet.
Skriptet oppretter deretter et ControlMyPi-objekt og starter opp. Her må du angi din egen Gmail-adresse og passord.
Tips: Dette er en sikker forbindelse til Googles servere; passordet deles ikke med noen annen tjeneste. Hvis du er i det hele tatt bekymret, sett ganske enkelt opp en annen konto. Faktisk er en egen konto ganske nyttig, spesielt når du vil ha automatiserte e-postmeldinger sendt fra Raspberry Pi.
Til slutt tar hovedsløyfen sensoravlesningen som vanlig, men i stedet for å skrive den til konsollen eller LCD-skjermen, skyver den den nye verdien til ControlMyPi. Oppdateringer sendes i et kart over widgetnavn / verdi.
Kjør skriptet med sudo som vanlig:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_cmp.py
Enkelte tilkoblingsinformasjon vil bli skrevet til konsollen etterfulgt av "Registrert med kontrollmypi". Gå nå til ControlMyPi.com og skriv inn Gmail-adressen din i skjemaet:
Klikk Finn paneler for å vise en liste over kontrollpaneler knyttet til Gmail-adressen din. Det skal være en i listen, Fuktighetsmonitor. Klikk på dette for å starte panelet ditt og se levedataene du har trykket på fra Raspberry Pi.
Hvert 30. sekund, når en ny sensorlesning er tatt, skyves denne verdien gjennom XMPP-tilkoblingen til ControlMyPi. Den skyver deretter disse dataene til alle seerne på panelet ditt (bare i øyeblikket). Du vil se måleren flytte for øynene dine! Hvis du vil, kan du kopiere / lime inn den lange nettadressen og sende den til en venn for å vise frem fuktighetsmonitoren din. Nå oppdateres oppdateringer til deg og din venn.
ControlMyPi har en rekke widgets tilgjengelig for deg å bruke på dashbordet. En av de mest nyttige for å visualisere data er linjediagrammet. Programmet i denne delen legger til et enkelt linjediagram for å plotte endringene i fuktighetsnivå over tid. For å begynne, vil vi bare plotte et nytt punkt på diagrammet hvert 30. sekund når vi leser.
fra tid import import søvn import mcp3008 fra controlmypi import ControlMyPi import logging import datetime def on_msg (conn, nøkkel, verdi): pass def append_chart_point (diagram, punkt): hvis len (diagram)> = 10: del diagram [0] chart.append (punkt) returdiagram logging.basicConfig (level = logging.INFO) p = [[['G', 'fuktig', '% nivå', 0,0,100], ['LC', 'diagram1', 'Tid' , 'Verdi', 0,100]],] c1 = [] conn = ControlMyPi ('[email protected] ',' passord ',' moistcmp2 ',' fuktighetsmonitor 2 ', p, on_msg) hvis conn.start_control : Prøv: mens True: dt = datetime.datetime.now (). strftime ('% H:% M:% S') m = mcp3008.read_pct (5) c1 = append_chart_point (c1, [dt, m]) conn .update_status ('fuktig': m, 'chart1': c1) sove (30) til slutt: conn.stop_control () I widgetoppsettet, p, Du kan se definisjonen av linjediagramm widgeten etter måleren. Widgetnavnet er chart1, de x-akse er tid, den y-aksen er Verdi og max og min verdiene er satt til 0 og 100.
Tips: Jeg har endret skalaen fra det rå sensorområdet (0 til 1023) til en mer meningsfull prosentverdi. Modulen mcp3008 gir en funksjon read_pct () for å returnere et heltall prosentpoeng i stedet for råverdien.
For å oppdatere diagrammet på dashbordet, sender du bare en liste over datapunkter til ControlMyPi. Datapunktene holdes i listen c1 i programmet og hvert punkt består av en tid og en verdi. Funksjonen append_chart_point () brukes til å opprettholde en rulleliste over de siste ti punktene, slik at hver ny verdi kommer til den eldste, slettes. Uten dette ville diagrammet vokse for alltid.
Kjør skriptet med sudo som vanlig:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_cmp2.py
Dette skriptet forbedres på den forrige versjonen av:
importer sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-kode / Adafruit_CharLCDPlate') fra tid import søvn fra Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 fra controlmypi import ControlMyPi import logging importere datetime import pickle fra genericpath import eksisterer lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, nøkkel, verdi): pass def append_chart_point (diagram, punkt): hvis len (diagram)> = 48: deldiagram [0] chart.append (punkt) returdiagram def save (data): output = åpen (PICKLE_FILE, 'wb') pickle.dump (data, output) output.close () def load hvis ikke eksisterer (PICKLE_FILE): returner standard pkl_file = åpen (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () returnere data def update_lcd (m): prøv: lcd.home () lcd.message ("Fuktighetsnivå: \ n% d %%"% m) hvis m < 15: lcd.backlight(lcd.RED) elif m < 50: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e logging.basicConfig(level=logging.INFO) p = [ [ ['G','moist','% level',0,0,100], ['LC','chart1','Time','Value',0,100] ], ] c1 = load([]) readings = [] conn = ControlMyPi('[email protected]', 'password', 'moisture3', 'Moisture monitor 3', p, on_msg) delta = datetime.timedelta(minutes=30) next_time = datetime.datetime.now() if conn.start_control(): try: while True: dt = datetime.datetime.now() m = mcp3008.read_pct(5) readings.append(m) update_lcd(m) to_update = 'moist':m if dt > next_time: # Ta gjennomsnittet fra leselisten for å glatte grafen litt avg = int (runde (sum) (lesninger) / len (avlesninger))) lesninger = [] c1 = append_chart_point (c1, [dt.strftime ('% H:% M ', avg]) lagre (c1) next_time = dt + delta til_update [' chart1 '] = c1 conn.update_status (to_update) søvn (30) til slutt: conn.stop_control Du bør gjenkjenne innholdet i update_lcd () funksjon fra det tidligere programmet. Denne funksjonen kalles nå fra hovedløkken for å oppdatere LCD-skjermen på hver iterasjon.
Tips: Hvis du ikke har LCD-skjermen, slettes du bare denne funksjonen og linjen som kaller den. Fjern også banen og importer fra toppen og linjen lcd = Adafruit_CharLCDPlate ().
For å ta opp 24 timers data på linjediagrammet, tar vi en lesing hvert 30. minutt og viser 48 poeng på diagrammet. De append_chart_point () funksjonen er oppdatert for å beholde 48 datapunkter. I hovedløkken holder vi nå en tid på 30 minutter fremover i variabelen neste gang.
Hver løkke vi sjekker gjeldende tid mot neste gang. Hvis vi har passert neste gang et datapunkt er lagt til diagrammet og neste gang flyttes fremover med 30 minutter igjen. Å bruke klokken er en fin måte å utføre handlinger på forskjellige tidspunkter, uten å måtte flere tellere telle sløyfer og så videre. Vi bruker denne teknikken igjen i det endelige programmet for å sende en daglig e-post.
Som du kanskje har lagt merke til, svinger lesingen fra sensoren ganske mye. Andre typer sensorer vil ikke nødvendigvis gjøre dette, men dette gjør det. Så, i stedet for å ta en enkelt lesing og plotte det på grafen hver halve time, skal vi plotte gjennomsnittet av alle avlesningene tatt i den siste halvannen time. Leselisten brukes til å holde alle lesingene, int (round (sum (opplesninger) / len (målinger))) beregner gjennomsnittet til nærmeste hele tall. Dette er så plottet på diagrammet.
Pythons pickle-modul brukes til å lagre og laste diagramdataene til en fil. Dette lagrer bare c1-listen hvis vi må stoppe programmet og starte det på nytt. En omstart for en batteribyte for eksempel. De lagre() funksjon kalles hver gang vi oppdaterer diagrammet og laste() funksjonen kalles når programmet starter.
Kjør skriptet med sudo som vanlig:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_cmp3_lcd.py
Skjermbildet viser et mye jevnere diagram nå:
For å fullføre dette prosjektet, legger vi til et siste trinn: e-post. Vi kan overvåke sensoren fra LCD-skjermen og se på gjeldende lesing og historie på nettet, men vi kan glemme å sjekke det etter en stund. For å dekke dette, skal vi få programmet til å sende en epost en gang om dagen når sensoravlesningen er under en spesifisert verdi.
importer sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-kode / Adafruit_CharLCDPlate') fra tid import søvn fra Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 fra controlmypi import ControlMyPi import logging importere datetime import pickle fra genericpath import eksisterer import smtplib lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, nøkkel, verdi): pass def append_chart_point (diagram, punkt): hvis len > = 48: deldiagram [0] chart.append (punkt) returdiagram def save (data): output = åpen (PICKLE_FILE, 'wb') pickle.dump (data, output) output.close () def load ): Hvis ikke eksisterer (PICKLE_FILE): returner standard pkl_file = åpen (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () returnere data def update_lcd (m): prøv: lcd.home () lcd .message ("Fuktighetsnivå: \ n% d %%"% m) hvis m < 15: lcd.backlight(lcd.RED) elif m < 50: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e def send_gmail(from_name, sender, password, recipient, subject, body):"Send an email using a GMail account."senddate=datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d') msg="Date: %s\r\nFrom: %s <%s>\ r \ nTo:% s \ r \ nSubject:% s \ r \ nX-Mailer: Min post \ r \ n \ r \ n "% (sendingsdato, franavn, avsender, mottaker, emne) server = smtplib.SMTP ('smtp.gmail.com:587') server.starttls () server.login (sender, passord) server.sendmail (sender, mottaker, msg + kropp) server.quit () logging.basicConfig (level = logging.INFO ), p = [[['G', 'fuktig', 'nivå', 0,0,100], ['LC', 'diagram1', 'Tid', 'Verdi', 0,100]],] c1 = ]) lesninger = [] conn = ControlMyPi ('[email protected] ',' passord ',' fuktighet ',' fuktighetsmonitor ', p, on_msg) delta = datetime.timedelta (minutter = 30) next_time = datetime.datetime .now () delta_email = datetime.timedelta (days = 1) next_email_time = datetime.datetime.now () hvis conn.start_control (): prøv: mens True: dt = datetime.datetime.now () m = mcp3008.read_pct 5) readings.append (m) update_lcd (m) to_update = 'fuktig': m # Oppdater diagrammet? Hvis dt> next_time: # Ta gjennomsnittet fra leselisten for å glatte grafen litt avg = int (sum (lesninger) / len (avlesninger))) lesninger = [] c1 = append_chart_po int (c1, [dt.strftime ('% H:% M', avg]) lagre (c1) next_time = dt + delta til_update ['chart1'] = c1 conn.update_status (to_update) #Send en e-post? hvis dt> next_email_time: next_email_time = dt + delta_email hvis m < 40: send_gmail('Your Name', '[email protected]', 'password', '[email protected]', 'Moisture sensor level', 'The level is now: %s' % m) sleep(30) finally: conn.stop_control() De send_gmail () funksjonen tar seg av å sende e-posten. I hovedløkken bruker vi klokkekontrollteknikken for å avgjøre om en dag har gått siden siste gang vi sendte ut en e-post. Hvis den har så støter vi denne gangen på en dag for neste sjekk. Deretter, hvis fuktighetsverdien er under 40, sender vi e-posten.
Det er programmet fullført! Kjør det med sudo som vanlig:
pi @ raspberrypi ~ / py / tutorials / fuktighet $ sudo python moist_final.py
Det er en siste ting å gjøre: automatisk kjøre programmet ved oppstart. Dette vil tillate deg å kjøre din Raspberry Pi headless. For å gjøre dette, redigerer du /etc/rc.local/ filen som denne:
pi @ raspberrypi ~ $ sudo pico /etc/rc.local
Legg til denne linjen i filen og lagre den:
python /home/pi/py/tutorials/moisture/moist_final.py &
Nå kan du stenge din Raspberry Pi, flytte den til anlegget du overvåker, slå på det og programmet vil starte for deg.
I denne opplæringen lærte du hvordan du konfigurerer og bruker SPI på Raspberry Pi til bruk med en analog-til-digital-omformer. Deretter brukte du en sensor for å overvåke fuktighetsnivået i jorda i en plantekrukke. Programvaren lar oss se denne sensoren leser på konsollen, på en LCD, på en måler og et diagram over Internett og gjennom en daglig epost.
Det var mye å lære, men nå kan du bruke disse teknikkene for alle slags forskjellige sensorer for å måle temperatur, fuktighet, lysintensitet og så videre. Du kan koble den til en akselerometer eller infrarød avstandssensor også. Ha det gøy!
