Share
In deze tutorial ga ik de grootsheid van Raspberry Pi gebruiken om een vochtigheidssensor voor een plantenpot te bouwen. U kunt de sensor lokaal op het LCD-scherm bekijken of op afstand, via ControlMyPi.com, en ontvangt dagelijks e-mails als het vocht onder een bepaald niveau daalt.
Onderweg zal ik:
Om het beste uit deze tutorial te halen, is het aan te bevelen om het volgende te verkrijgen:
Na het toevoegen van een paar dollars voor de draden van de springer werken de totale projectkosten ongeveer uit op $ 55 zonder het LCD-scherm en $ 82 mee. Vergeet echter niet dat u uw elektronicakit in voorraad hebt - al deze onderdelen kunnen opnieuw worden gebruikt voor andere projecten.
Als u het LCD-scherm met de stapelkop gebruikt, sluit u dit nu aan op de Raspberry Pi. De eerste twee fasen van de software maken geen gebruik van het LCD-scherm, maar het bespaart u enige tijd later opnieuw bedraden als u het nu bevestigt.
Waarschuwing: onjuiste bedrading kan schade aan uw Raspberry Pi veroorzaken. Zorg ervoor dat je al je verbindingen zorgvuldig controleert voordat je het apparaat opstart.
Links op de foto ziet u de rode en zwarte springers die naar de + en - rails op het breadboard gaan. Raadpleeg deze draadkleurentabel om de aansluitingen van de kop te beschrijven. Elke cel in de tabel verwijst naar een pin in de Raspberry Pi-header. De kleur van de cel komt overeen met de kleur van de doorverbindingsdraad zoals te zien op de foto:
Verbind pen 1 met de plusrail en pen 6 met de grondrail.
Belangrijk: de chip moet zich boven het dal in het breadboard bevinden met de pin 1-indicator, de inkeping, rechtsboven zoals op de foto.
Raadpleeg deze draadkleurentabel en de datasheet bij het bedraden van deze chip:
Alle verbindingen van de rails en de header naar de MCP3008-chip gaan netjes langs de onderste rij van de chip in deze richting. Verbind eerst de stroom en aarde zoals getoond in de foto hierboven:
Verbind vervolgens de headerpinnen van de Raspberry Pi SPI met de chip:
De sensorbedrading is eenvoudig; er zijn drie verbindingen om te maken:
Eindelijk, als u uw plantenpot bij de hand hebt, kunt u de sonde nu in de grond steken. Zorg ervoor dat je niet te diep duwt, bedek alleen de tanden:
Dit project is gebouwd met behulp van Occidentalis v0.2 van Adafruit, dat wordt geleverd met de SPI-driver voor de hardware, klaar voor gebruik. Volg de instructies op de Adafruit-site om het op uw Raspberry Pi te installeren.
Tip: Als u de Wheezy-download van de Raspberry Pi-site gebruikt, moet u enkele stappen vinden en volgen om de SPI-driver zelf in te schakelen ...
git - Je zou dit al moeten hebben (probeer te typen git) Zo niet, installeer het dan met: sudo apt-get install git
pip - installeer dit met: sudo apt-get install python-pip
Alle code voor dit project is geschreven in Python. We hebben een Python-wrapper voor de SPI-driver nodig, zodat we de waarden van de sensor via SPI kunnen lezen:
cd ~ git clone git: //github.com/doceme/py-spidev cd py-spidev / sudo python setup.py installeren
U hebt de Adafruit-bibliotheek al geïnstalleerd bij het samenstellen en testen van uw LCD-scherm. Zorg ervoor dat u de locatie van de bibliotheek kent, want dit is nodig door de projectcode.
ControlMyPi is een service waarmee u snel en eenvoudig bedieningspanelen op internet kunt maken met uw Raspberry Pi Python-scripts. Gebruik pip om het te installeren:
sudo pip install controlmypi
Alle code van deze tutorial kan als volgt worden gedownload:
cd ~ mkdir py cd py git clone git: //github.com/jerbly/tutorials
U moet enkele van deze bestanden bewerken om gebruikersnamen, wachtwoorden en bestandspaden op te geven. Dit wordt uitgelegd als we gaan.
De MCP3008 converteert de ingangsspanning naar een getal van 0 tot 1023 (10 bits). U kunt deze waarde vervolgens via SPI lezen (de groene en witte verbindingen met de koptekst op de Pi). Het py-spidev-pakket stelt ons in staat dit vanuit Python te doen.
Er is een subtiele complicatie bij het lezen van een 10-bits getal in een 8-bits systeem. De SPI-driver retourneert twee 8-bits woorden en we zijn geïnteresseerd in de laatste 2 bits van het eerste woord gevolgd door alle 8 bits van het volgende woord. Om dit in een nummer te veranderen waar we mee kunnen werken, moeten we het 2-bits van het eerste woord maskeren en dan links verschuiven voordat het tweede woord wordt toegevoegd.
U hoeft zich echter geen zorgen te maken over het coderen van dit, omdat ik in de download de module mcp3008.py heb opgenomen om ervoor te zorgen. Je kunt een interactieve Python-shell gebruiken om je SPI-installatie en je bedrading als volgt te testen:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python Python 2.7.3 (standaard, 13 jan 2013, 11:20:46) [GCC 4.6.3] op linux2 Type "help", "copyright", "credits" of "licentie" voor meer informatie. >>> import mcp3008 >>> mcp3008.readadc (5) 444
Belangrijk: Je moet Python uitvoeren met sudo, zodat je toegang hebt tot de SPI-apparaatdriver.
Als u problemen ondervindt, controleer dan eerst uw bedrading. Controleer vervolgens de stappen van de software-installatie hierboven. Als u de vochtigheidsensor van de Octopus gebruikt, houdt u de tanden vast om verbinding te maken met uw hand. Anders zal het waarschijnlijk alleen nul lezen.
U kunt de sensor hier uit de vergelijking halen door een jumper van de powerrail aan te sluiten op bijvoorbeeld CH1 en vervolgens readadc (1) te gebruiken. Dit zou 1023 (of in de buurt ervan) moeten retourneren. Op dezelfde manier moet een verbinding van de grondrail 0 opleveren.
Het eerste programma breidt eenvoudig uit wat we in de interactieve console hebben geoefend om een lus in te bouwen, zodat de waarde van de sensor continu wordt afgedrukt:
uit tijdimport slaap import mcp3008 while True: m = mcp3008.readadc (5) print "Vochtniveau: :> 5" .format (m) slaap (.5)
Merk op dat er een halve seconde slaap in de lus zit. Dit is het programma dat oplevert; het maakt plaats voor andere processen. Anders zou het veel CPU-tijd in beslag nemen en zouden andere processen die u uitvoert niet zo goed presteren. Een aflezing van twee keer per seconde is waarschijnlijk veel te veel, zeker voor een vochtsensor.
De uitvoer zou als volgt moeten zijn:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_cmd.py Vochtniveau: 452 Vochtniveau: 486 Vochtniveau: 485 Vochtniveau: 483 Vochtniveau: 489 Vochtniveau: 491 Vochtniveau: 490 ^ CTraceback (meest recente bel last): Bestand "moist_cmd.py", regel 7, inslaap (.5) KeyboardInterrupt pi @ raspberrypi ~ / py / tutorials / moisture $
Druk gewoon op Besturing C wanneer je klaar bent en het programma zal afsluiten zoals hierboven.
Dit programma verbetert de weergave naar de console. In plaats van de waarde op een scherm in een schuifvenster af te drukken, maakt dit script een dashboardeffect. Elke sensormeting wordt over de laatste heen geschreven, zodat uw venster niet schuift.
Ook worden rode, gele en groene achtergronden gebruikt als hoogtepunten van het verkeerslicht. Als de grond goed is bewaterd, is de achtergrond groen. Als het te droog is, wordt het rood weergegeven.
Om deze kleuring te bereiken, worden speciale ANSI-escape-codes gebruikt om opdrachten naar de console te verzenden. Elke escape-codesequentie begint met \ x1b [gevolgd door de opdrachtcodes om een effect te produceren.
uit tijdimport slaapimport mcp3008 # ANSI-escape-codes PREVIOUS_LINE = "\ x1b [1F" RED_BACK = "\ x1b [41; 37m" GREEN_BACK = "\ x1b [42; 30m" YELLOW_BACK = "\ x1b [43; 30m" RESET = "\ x1b [0m" # Wis het scherm en plaats de cursor bovenaan "\ x1b [2J \ x1b [H 'print' Vochtsensor 'print' =============== \ n 'while True: m = mcp3008.readadc (5) als 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 slaap (.5)
Het programma wist het scherm en geeft een titel weer. Het gaat dan weer in de eeuwige lus, maar deze keer gebruikt drempels om de achtergrondkleur te bepalen. Uiteindelijk worden de escape-sequences en tekst afgedrukt, gevolgd door een RESET volgorde om de kleur uit te schakelen. De PREVIOUS_LINE De escape-code wordt gebruikt om de cursor één regel omhoog te verplaatsen, zodat we elke keer over de vorige waarde schrijven.
Voer dit voorbeeld uit zoals:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_ansi.py
De uitvoer zou ongeveer zo moeten zijn:
We gaan nu weg van de console en geven in plaats daarvan de sensorgegevens op de LCD weer. Voordat je doorgaat met deze tutorial, moet je ervoor zorgen dat je je Adafruit LCD hebt gebouwd met de stapelheader en je hebt het getest door de zelfstudie van Adafruit te volgen..
Ons programma gaat de Adafruit-bibliotheek gebruiken, dus we moeten het volledige pad naar de Adafruit_CharLCDPlate directory. Ik maak gewoon een py-map onder de pi-gebruiker thuis om alle Python-code op één plaats te houden, dus op mijn Raspberry Pi is het pad:
/ Home / pi / py / Adafruit-Raspberry-Pi-Python-code / Adafruit_CharLCDPlate
Mogelijk moet u het volgende script aanpassen als uw pad anders is.
Accentsconagua
import sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') from time import sleep from Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 lcd = Adafruit_CharLCDPlate () while True: m = mcp3008 .readadc (5) probeer: lcd.home () lcd.message ("Vochtniveau: \ n% d"% m) als 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) Start het programma als volgt:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_lcd.py
U zou de LCD-versie van het kleurenconsoleprogramma moeten zien. Deze keer maken de rode, gele en groene drempelaanduidingen gebruik van de RGB-achtergrondverlichting.
In deze sectie gaan we ControlMyPi gebruiken om een dashboard op internet te produceren. Hier is hoe de service wordt beschreven in de FAQ:
ControlMyPi biedt een webgebaseerde service waarmee eenvoudige Python-scripts vanuit een paneel via internet kunnen worden beheerd. Uw Python-script definieert een widgetlay-out van labels, knoppen, statusindicatoren en meer voor weergave door ControlMyPi. Wanneer op een knop wordt geklikt ontvangt uw script een bericht. Als u enige status te melden hebt, kan uw script dit op elk gewenst moment naar ControlMyPi verzenden en wordt het naar uw webbrowser geduwd.
Als u het Python-pakket nog niet hebt geïnstalleerd, doe dit dan nu. U hebt ook een XMPP-account nodig. Ik zou een Google Gmail-account aanbevelen omdat dit goed werkt en ook later zal worden gebruikt als we willen dat ons script een e-mail verzendt. Volg de instructies op de ControlMyPi-website om aan de slag te gaan en om uw verbinding te testen.
De eerste iteratie van het dashboard toont eenvoudig een enkele meter met de sensorwaarde. We zullen elke 30 seconden een nieuwe aflezing naar ControlMyPi pushen om dit te produceren:
Het script om dit te produceren is nog steeds relatief eenvoudig:
van tijd importeren slaap importeren mcp3008 van controlmypi importeren ControlMyPi importeren loggen def on_msg (conn, key, value): pass logging.basicConfig (level = logging.INFO) p = [[['G', 'moist', 'level', 0,0,1023]],] conn = ControlMyPi ('[email protected] ',' password ',' moisture ',' Moisture monitor ', p, on_msg) if conn.start_control (): try: while True: m = mcp3008.readadc (5) conn.update_status ('moist': m) sleep (30) finally: conn.stop_control () Aan de bovenkant importeren we nu de klasse ControlMyPi en de loggingmodule. Als u problemen met XMPP-verbindingen moet oplossen, wijzigt u het logniveau naar DEBUG.
De on_msg-functie is wat zou worden genoemd als we knoppen of andere ingangen in onze widgetindeling definiëren. Omdat we alleen een meter hebben, is er geen invoer en dus doet deze functie niets.
De lijst, p, is waar de widgetlay-out is gedefinieerd. Elk item in de lijst definieert een rij met widgets die op het dashboard moet worden weergegeven. We hebben een enkele rij met een enkele widget erop, de meter. Vochtig is de naam van de widget, niveau is het label dat op de meter verschijnt, 0 is het beginniveau, 0 is het minimumniveau en 1023 is het maximum.
Het script maakt vervolgens een ControlMyPi-object en start het op. Hier moet je je eigen Gmail-adres en wachtwoord opgeven.
Tip: Dit is een beveiligde verbinding met de servers van Google; het wachtwoord wordt niet gedeeld met andere services. Als je je ergens zorgen over maakt, kun je gewoon een ander account instellen. In feite is een aparte account best handig, vooral als u geautomatiseerde e-mails wilt ontvangen die zijn verzonden vanaf uw Raspberry Pi.
Ten slotte neemt de hoofdlus de sensormeting zoals gewoonlijk, maar in plaats van deze af te drukken op de console of de LCD, wordt de nieuwe waarde naar ControlMyPi geduwd. Updates worden verzonden in een kaart van widget naam / waarde.
Voer het script uit met behulp van sudo zoals gewoonlijk:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_cmp.py
Sommige verbindingsinformatie wordt afgedrukt op de console gevolgd door "Geregistreerd met controlemypi". Ga nu naar ControlMyPi.com en voer je Gmail-adres in in de vorm:
Klik Zoek naar panels om een lijst met controlepanelen weer te geven die zijn gekoppeld aan uw Gmail-adres. Er hoort er een in de lijst te staan, Vochtmonitor. Klik hierop om uw paneel te starten en de livegegevens van uw Raspberry Pi te bekijken.
Elke 30 seconden, wanneer een nieuwe sensormeting wordt uitgevoerd, wordt deze waarde door de XMPP-verbinding naar ControlMyPi gepusht. Vervolgens worden deze gegevens doorgestuurd naar alle kijkers van je panel (alleen jij op dit moment). Je zult zien dat de meter voor je ogen beweegt! Als je wilt, kun je de lange URL kopiëren en plakken en naar een vriend sturen om te pronken met je vochtmonitor. Nu worden updates naar u en uw vriend doorgestuurd.
ControlMyPi heeft een aantal widgets die u op uw dashboard kunt gebruiken. Een van de meest bruikbare gegevens voor het visualiseren van gegevens is het lijndiagram. Het programma in deze sectie voegt een eenvoudig lijndiagram toe om de veranderingen in vochtniveau in de tijd weer te geven. Om te beginnen zullen we elke dertig seconden een nieuw punt in de grafiek plotten als we een meting doen.
uit tijdimport slaap import mcp3008 uit controlmypi import ControlMyPi import logging import datetime def on_msg (conn, key, value): pass def append_chart_point (grafiek, punt): if len (grafiek)> = 10: del chart [0] chart.append (punt) return chart logging.basicConfig (level = logging.INFO) p = [[['G', 'moist', '% level', 0,0,100], ['LC', 'chart1', 'Time' , 'Waarde', 0,100]],] c1 = [] conn = ControlMyPi ('[email protected] ',' password ',' moistcmp2 ',' Moisture monitor 2 ', p, on_msg) if conn.start_control () : try: while True: dt = datetime.datetime.now (). strftime ('% H:% M:% S') m = mcp3008.read_pct (5) c1 = append_chart_point (c1, [dt, m]) conn .update_status ('moist': m, 'chart1': c1) sleep (30) finally: conn.stop_control () In de widgetlay-out, p, je kunt de definitie van de lijndiagram-widget achter de meter zien. De naam van de widget is chart1, de x-as is Tijd, de y-as is Waarde en de max en min waarden zijn ingesteld op 0 en 100.
Tip: Ik heb de schaal van het onbewerkte sensorbereik (0 tot 1023) veranderd in een meer betekenisvolle procentuele waarde. De mcp3008-module biedt een functie read_pct () om een integer-percentagepunt te retourneren in plaats van de onbewerkte waarde.
Om het diagram in het dashboard bij te werken, stuurt u eenvoudigweg een lijst met datapunten naar ControlMyPi. De gegevenspunten worden in de lijst c1 in het programma opgeslagen en elk punt bestaat uit een tijd en een waarde. De functie append_chart_point () wordt gebruikt om een lijst van de laatste tien punten bij te houden, zodat elke nieuwe waarde wordt verwijderd en de oudste wordt gewist. Zonder dit zou de grafiek voor altijd groeien.
Voer het script uit met behulp van sudo zoals gewoonlijk:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_cmp2.py
Dit script verbetert de vorige versie door:
import sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') uit tijd importeren slaap uit Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 uit controlmypi import ControlMyPi import logging import datetime import pickle from genericpath import bestaat lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, key, value): pass def app__chart_point (diagram, punt): if len (diagram)> = 48: del chart [0] chart.append (punt) return chart def save (data): output = open (PICKLE_FILE, 'wb') pickle.dump (data, output) output.close () def load (standaard): indien niet bestaat (PICKLE_FILE): return default pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () return data def update_lcd (m): probeer: lcd.home () lcd.message ("Vochtniveau: \ n% d %%"% m) als 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: # Neem het gemiddelde van de meetlijst om de grafiek een beetje avg = int (ronde (som (lezingen) / len (lezingen)))) af te lezen = [] c1 = append_chart_point (c1, [dt.strftime ('% H:% M '), avg]) opslaan (c1) next_time = dt + delta to_update [' chart1 '] = c1 conn.update_status (to_update) slaap (30) tenslotte: conn.stop_control () Je zou de inhoud van de moeten herkennen update_lcd () functie van het eerdere programma. Deze functie wordt nu gebeld vanuit de hoofdlus om het LCD-scherm bij elke iteratie bij te werken.
Tip: Als u niet beschikt over het LCD-scherm, verwijdert u deze functie en de regel die ernaar verwijst. Verwijder ook het pad en importeer vanaf de bovenkant en de regel lcd = Adafruit_CharLCDPlate ().
Om 24 uur aan gegevens op het lijndiagram te registreren, zullen we elke 30 minuten een meting uitvoeren en 48 punten op de kaart weergeven. De append_chart_point () functie is bijgewerkt om 48 gegevenspunten te behouden. In de hoofdlus houden we nu een tijd van 30 minuten in de toekomst in de variabele de volgende keer.
Elke lus controleren we de huidige tijd tegen de de volgende keer. Als we geslaagd zijn de volgende keer een gegevenspunt is toegevoegd aan de grafiek en de volgende keer wordt weer 30 minuten vooruit bewogen. Het gebruik van de klok is een handige manier om acties uit te voeren op verschillende granulariteiten zonder dat je meerdere tellers hoeft te tellen, enzovoort. We zullen deze techniek opnieuw gebruiken in het definitieve programma om een dagelijkse e-mail te verzenden.
Zoals je misschien hebt gemerkt, schommelt de meetwaarde van de sensor behoorlijk. Andere soorten sensoren zullen dit niet noodzakelijk doen, maar deze doet dat wel. Dus in plaats van een enkele meting te nemen en dat om de half uur in de grafiek uit te zetten, gaan we het gemiddelde van alle metingen in het laatste half uur berekenen. De meetlijst wordt gebruikt om alle meetwaarden vast te houden, int (round (sum (waarden) / len (waarden))) berekent het gemiddelde tot het dichtstbijzijnde hele getal. Dit wordt vervolgens op de kaart uitgezet.
De augurkmodule van Python wordt gebruikt om de diagramgegevens in een bestand op te slaan en te laden. Dit slaat eenvoudig de c1-lijst op voor het geval we het programma moeten stoppen en opnieuw moeten starten. Een reboot voor bijvoorbeeld een batterijwisseling. De opslaan() functie wordt elke keer dat we de grafiek bijwerken en de laden() functie wordt aangeroepen wanneer het programma start.
Voer het script uit met behulp van sudo zoals gewoonlijk:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_cmp3_lcd.py
De schermafbeelding toont nu een veel vloeiendere grafiek:
Om dit project af te sluiten, voegen we nog een laatste stap toe: e-mail. We kunnen de sensor vanaf het LCD-scherm bekijken en naar de huidige lezing en geschiedenis op internet kijken, maar we kunnen het na een tijdje vergeten te controleren. Om dit te dekken, krijgen we het programma een keer per dag een e-mail te sturen wanneer de sensormeting onder een opgegeven waarde ligt.
import sys sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') uit tijd importeren slaap uit Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 uit controlmypi import ControlMyPi import logging import datetime import pickle from genericpath import bestaat import smtplib lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, key, value): pass def app__chart_point (diagram, punt): if len (grafiek) > = 48: del chart [0] chart.append (punt) return chart def save (data): output = open (PICKLE_FILE, 'wb') pickle.dump (data, output) output.close () def load (standaard ): indien niet aanwezig (PICKLE_FILE): standaardwaarde pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () retourgegevens def update_lcd (m): probeer: lcd.home () lcd .message ("Vochtniveau: \ n% d %%"% m) als 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 \ nAan:% s \ r \ nOnderwerp:% s \ r \ nX-Mailer: Mijn-mail \ r \ n \ r \ n "% (verzenddatum, naam, afzender, ontvanger, onderwerp) server = smtplib.SMTP ('smtp.gmail.com:587') server.starttls () server.login (afzender, wachtwoord) server.sendmail (afzender, ontvanger, msg + body) server.quit () logging.basicConfig (level = logging.INFO ) p = [[['G', 'vochtig', 'niveau', 0,0,100], ['LC', 'grafiek1', 'Tijd', 'Waarde', 0,100]],] c1 = belasting ([ ]) readings = [] conn = ControlMyPi ('[email protected] ',' password ',' moisture ',' Moisture monitor ', p, on_msg) delta = datetime.timedelta (minutes = 30) next_time = datetime.datetime .now () delta_email = datetime.timedelta (dagen = 1) next_email_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 # Update de grafiek? If dt> volgende_tijd: # Neem het gemiddelde van de meetlijst om de grafiek een beetje avg = int (rond te maken) (sum (readings) / len (readings))) readings = [] c1 = append_chart_po int (c1, [dt.strftime ('% H:% M'), avg]) save (c1) next_time = dt + delta to_update ['chart1'] = c1 conn.update_status (to_update) #Zend een e-mail? if dt> next_email_time: next_email_time = dt + delta_email als 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 () functie zorgt voor het verzenden van de e-mail. In de hoofdlus gebruiken we de klokcontroletechniek om te bepalen of een dag is verstreken sinds de laatste keer dat we een e-mail hebben verzonden. Als dit het geval is, worden we deze keer een dag extra gebagateerd voor de volgende controle. Als de vochtwaarde lager is dan 40, sturen we de e-mail.
Dat is het programma compleet! Voer het uit met sudo zoals gewoonlijk:
pi @ raspberrypi ~ / py / tutorials / moisture $ sudo python moist_final.py
Er is nog een laatste ding om te doen: voer het programma automatisch uit bij het opstarten. Hiermee kun je je Raspberry Pi zonder kop laten lopen. Om dit te doen, bewerk de /etc/rc.local/ bestand als dit:
pi @ raspberrypi ~ $ sudo pico /etc/rc.local
Voeg deze regel toe aan het bestand en sla het op:
python /home/pi/py/tutorials/moisture/moist_final.py &
Nu kun je je Raspberry Pi uitschakelen, verplaatsen naar de plant die je bewaakt, opstarten en het programma voor jou starten.
In deze zelfstudie hebt u geleerd SPI op uw Raspberry Pi in te stellen en te gebruiken voor gebruik met een analoog / digitaal-omzetter. Vervolgens hebt u een sensor gebruikt om het vochtgehalte van de grond in een plantpot te controleren. Met de software kunnen we deze sensorwaarde op de console, op een lcd-scherm, op een meter en in een grafiek via internet en via een dagelijkse e-mail bekijken..
Er was veel te leren, maar nu kunt u deze technieken gebruiken voor allerlei verschillende sensoren om temperatuur, vochtigheid, lichtintensiteit enzovoort te meten. Je zou het ook kunnen aansluiten op een accelerometer of infrarood afstandssensor. Veel plezier!
