Share
In diesem Tutorial werde ich die Faszination von Raspberry Pi nutzen, um einen Feuchtigkeitssensor für einen Blumentopf zu bauen. Sie können den Sensor lokal auf dem LCD oder ferngesteuert über ControlMyPi.com überwachen und täglich E-Mails erhalten, wenn die Feuchtigkeit unter einen bestimmten Wert fällt.
Auf dem Weg werde ich:
Um dieses Tutorial optimal nutzen zu können, sollten Sie Folgendes erwerben:
Nach dem Hinzufügen von ein paar Dollar für die Überbrückungskabel werden die Gesamtprojektkosten in etwa auf 55 USD ohne LCD und 82 USD mit geschätzt. Denken Sie jedoch daran, dass Sie Ihr Elektronik-Kit vorrätig haben - all diese Teile können wieder für andere Projekte verwendet werden.
Wenn Sie das LCD mit dem Stapelkopf verwenden, verbinden Sie es jetzt mit dem Raspberry Pi. In den ersten beiden Phasen der Software wird das LCD zwar nicht verwendet, aber Sie sparen später etwas Zeit für die Verkabelung, wenn Sie es jetzt anschließen.
Warnung: Eine falsche Verdrahtung kann zu Schäden am Raspberry Pi führen. Vergewissern Sie sich, dass alle Verbindungen sorgfältig geprüft wurden, bevor Sie das Gerät einschalten.
Links im Foto sehen Sie die roten und schwarzen Jumper, die zu den + und - Schienen auf dem Steckbrett gehen. Um die Verbindungen aus der Kopfzeile zu beschreiben, beziehen Sie sich bitte auf diese Drahtfarbentabelle. Jede Zelle in der Tabelle bezieht sich auf einen Pin in der Raspberry Pi-Kopfzeile. Die Farbe der Zelle entspricht der Farbe des Überbrückungskabels, wie auf dem Foto zu sehen:
Verbinden Sie Pin 1 mit der positiven Schiene und Pin 6 mit der Erdungsschiene.
Wichtig: Der Chip muss sich über dem Tal im Steckbrett befinden, mit der Pin 1-Anzeige, der Vertiefung oben rechts wie auf dem Foto.
Beziehen Sie sich beim Verdrahten dieses Chips auf diese Drahtfarbentabelle und das Datenblatt:
Alle Verbindungen von den Schienen und dem Header zum MCP3008-Chip gehen in dieser Ausrichtung sauber entlang der unteren Reihe des Chips. Verbinden Sie zuerst Strom und Masse wie auf dem Foto oben gezeigt:
Als nächstes verbinden Sie die Raspberry Pi SPI-Header-Pins mit dem Chip:
Die Sensorverkabelung ist einfach. Es sind drei Verbindungen herzustellen:
Wenn Sie Ihren Pflanztopf zur Hand haben, können Sie die Sonde jetzt in den Boden einsetzen. Stellen Sie sicher, dass Sie ihn nicht zu tief drücken, nur die Zinken bedecken:
Dieses Projekt wurde mit Occidentalis v0.2 von Adafruit erstellt, das mit dem Hardware-SPI-Treiber einsatzbereit ist. Befolgen Sie die Anweisungen auf der Adafruit-Site, um sie auf Ihrem Raspberry Pi zu installieren.
Spitze: Wenn Sie den Wheezy-Download von der Raspberry Pi-Site verwenden, müssen Sie einige Schritte finden und befolgen, um den SPI-Treiber selbst zu aktivieren.
git - Sie sollten dies bereits haben (versuchen Sie es mit der Eingabe gitwenn nicht, dann installiere es mit: sudo apt-get install git
pip - installiere dies mit: sudo apt-get install python-pip
Der gesamte Code für dieses Projekt ist in Python geschrieben. Wir benötigen einen Python-Wrapper für den SPI-Treiber, damit wir die Werte über SPI vom Sensor lesen können:
cd ~ git clone git: //github.com/doceme/py-spidev cd py-spidev / sudo python setup.py installieren
Sie haben die Adafruit-Bibliothek bereits installiert, wenn Sie Ihr LCD zusammenbauen und testen. Stellen Sie sicher, dass Sie den Speicherort der Bibliothek kennen, da dies vom Projektcode benötigt wird.
ControlMyPi ist ein Dienst, mit dem Sie aus Ihren Raspberry Pi Python-Skripts schnell und einfach Kontrollfelder im Internet erstellen können. Verwenden Sie pip, um es zu installieren:
sudo pip install controlmypi
Der gesamte Code aus diesem Tutorial kann wie folgt heruntergeladen werden:
cd ~ mkdir py cd py git klon git: //github.com/jerbly/tutorials
Sie müssen einige dieser Dateien bearbeiten, um Benutzernamen, Kennwörter und Dateipfade anzugeben. Dies wird erklärt, während wir gehen.
Der MCP3008 konvertiert die Eingangsspannung in eine Zahl von 0 bis 1023 (10 Bit). Sie können diesen Wert dann über SPI (die grüne und weiße Verbindung zum Header des Pi) lesen. Mit dem py-spidev-Paket können wir dies von Python aus tun.
Das Lesen einer 10-Bit-Zahl in einem 8-Bit-System ist etwas komplizierter. Der SPI-Treiber gibt zwei 8-Bit-Wörter zurück, und wir sind an den letzten 2 Bits des ersten Wortes interessiert, gefolgt von allen 8 Bits des nächsten Wortes. Um daraus eine Zahl zu machen, mit der wir arbeiten können, müssen wir die 2 Bits des ersten Wortes maskieren und dann um 8 nach links verschieben, bevor das zweite Wort hinzugefügt wird.
Sie müssen sich jedoch keine Gedanken über das Codieren machen, denn im Download habe ich das Modul mcp3008.py integriert, um sich darum zu kümmern. Sie können eine interaktive Python-Shell verwenden, um Ihr SPI-Setup und Ihre Verkabelung wie folgt zu testen:
pi @ raspberrypi ~ / py / Tutorials / feuchte $ sudo python Python 2.7.3 (Standardeinstellung: 13. Januar 2013, 11:20:46) [GCC 4.6.3] on linux2 Geben Sie "help", "copyright", "credits" ein. oder "Lizenz" für weitere Informationen. >>> mcp3008 importieren >>> mcp3008.readadc (5) 444
Wichtig: Sie müssen Python mit sudo ausführen, damit Sie auf den SPI-Gerätetreiber zugreifen können.
Wenn Sie Probleme haben, überprüfen Sie zunächst die Verdrahtung. Überprüfen Sie anschließend die obigen Schritte zur Softwareinstallation. Wenn Sie den Octopus-Feuchtesensor verwenden, halten Sie die Stifte fest, um eine Verbindung mit Ihrer Hand herzustellen. Andernfalls wird es wahrscheinlich nur Null anzeigen.
Sie können den Sensor hier aus der Gleichung herausnehmen, indem Sie einen Jumper von der Stromschiene an CH1 anschließen und dann readadc (1) verwenden. Dies sollte 1023 (oder nahe daran) zurückgeben. Ebenso sollte eine Verbindung von der Bodenschiene 0 zurückgeben.
Das erste Programm erweitert das, was wir in der interaktiven Konsole geübt haben, um eine Schleife, sodass der Wert des Sensors kontinuierlich ausgedruckt wird:
aus dem Zeitimport Schlaf importieren mcp3008 während Wahr: m = mcp3008.readadc (5) print "Feuchtigkeitsgrad: :> 5" .format (m) sleep (.5)
Beachten Sie, dass sich in der Schleife eine halbe Sekunde Schlaf befindet. Dies ist so, dass das Programm nachgibt; es gibt Platz für andere Prozesse. Andernfalls würde dies viel CPU-Zeit in Anspruch nehmen, und andere Prozesse, die Sie ausführen, funktionieren nicht so gut. Ein zweimaliges Ablesen pro Sekunde ist wahrscheinlich sowieso viel zu viel, sicherlich für einen Feuchtesensor.
Die Ausgabe sollte so sein:
pi @ raspberrypi ~ / py / Tutorials / Feuchte $ sudo python feucht_cmd.py Feuchtigkeitsgrad: 452 Feuchtigkeitsgrad: 486 Feuchtigkeitsgrad: 485 Feuchtigkeitsgrad: 483 Feuchtigkeitsgrad: 489 Feuchtigkeitsgrad: 490 Feuchtigkeitsgrad: 490 ^ CTraceback (letzter Anruf) last): Datei "moist_cmd.py", Zeile 7, insleep (.5) KeyboardInterrupt pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $
Einfach drücken Steuerung-C Wenn Sie fertig sind, wird das Programm wie oben beschrieben beendet.
Dieses Programm verbessert die Anzeige auf der Konsole. Anstatt den Wert in einem Bildlauffenster auf dem Bildschirm auszudrucken, erstellt dieses Skript einen Dashboard-Effekt. Jeder Sensormesswert wird über den letzten geschrieben, so dass Ihr Fenster nicht blättert.
Auch rote, gelbe und grüne Hintergründe werden als Ampelhöhepunkte verwendet. Wenn der Boden gut bewässert ist, ist der Hintergrund grün. Wenn es zu trocken ist, wird es rot angezeigt.
Um diese Farbgebung zu erreichen, werden spezielle ANSI-Escape-Codes verwendet, um Befehle an die Konsole zu senden. Jede Escape-Code-Sequenz beginnt mit \ x1b [gefolgt von den Befehlscodes, um einen Effekt zu erzeugen.
Schlafimport importieren 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" # Löschen Sie den Bildschirm und setzen Sie den Cursor auf den oberen Druckbereich '\ x1b [2J \ x1b [H' '' 'Feuchtigkeitssensor' drucken '================== \ n 'solange wahr: m = mcp3008.readadc (5), wenn 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 sleep (.5)
Das Programm löscht den Bildschirm und zeigt einen Titel an. Dann geht es wieder in die Perpetual-Schleife, diesmal werden jedoch Schwellenwerte verwendet, um die Hintergrundfarbe zu bestimmen. Schließlich werden die Escape-Sequenzen und der Text gedruckt, gefolgt von einem RESET Reihenfolge, um die Färbung auszuschalten. Das PREVIOUS_LINE Der Escape-Code wird verwendet, um den Cursor eine Zeile nach oben zu bewegen, so dass wir jedes Mal über den vorherigen Wert schreiben.
Führen Sie dieses Beispiel so aus:
pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $ sudo python feucht_ansi.py
Die Ausgabe sollte ungefähr so aussehen:
Wir gehen jetzt von der Konsole weg und zeigen stattdessen die Sensordaten auf dem LCD an. Bevor Sie mit diesem Lernprogramm fortfahren, vergewissern Sie sich, dass Sie Ihr Adafruit LCD mit dem Stacking-Header erstellt haben und es anhand des Adafruit-Lernprogramms getestet haben.
Unser Programm wird die Adafruit-Bibliothek verwenden, so dass wir den vollständigen Pfad zur Adafruit_CharLCDPlate Verzeichnis. Ich lege einfach ein py-Verzeichnis unter der Heimat des pi-Benutzers an, um den gesamten Python-Code an einem Ort zu halten. Auf meinem Raspberry Pi lautet der Pfad:
/ home / pi / py / Adafruit-Himbeer-Pi-Python-Code / Adafruit_CharLCDPlate
Möglicherweise müssen Sie das folgende Skript anpassen, wenn sich der Pfad unterscheidet.
Accentsconagua
import sys.path.append ('/ home / pi / py / Adafruit-Himbeer-Pi-Python-Code / Adafruit_CharLCDPlate') aus der Zeit importieren Sie den Schlaf von Adafruit_CharLCDPlate importieren Sie Adafruit_CharLCDPlate import mcp3008 lcd = Adafruit_CharLCLCat .readadc (5) try: lcd.home () lcd.message ("Feuchtigkeitsgrad: \ n% d"% m), wenn 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) Führen Sie das Programm wie folgt aus:
pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $ sudo python feucht_lcd.py
Sie sollten die LCD-Version des Farbkonsolenprogramms sehen. Die roten, gelben und grünen Schwellenwertanzeigen verwenden diesmal die RGB-Hintergrundbeleuchtung.
In diesem Abschnitt verwenden wir ControlMyPi, um ein Dashboard im Internet zu erstellen. So wird der Dienst anhand der FAQ beschrieben:
ControlMyPi bietet einen webbasierten Dienst, mit dem einfache Python-Skripts von einem Panel aus über das Internet gesteuert werden können. Ihr Python-Skript definiert ein Widget-Layout mit Beschriftungen, Schaltflächen, Statusanzeigen und mehr, die ControlMyPi anzeigen soll. Wenn Sie auf eine Schaltfläche klicken, erhält Ihr Skript eine Nachricht. Wenn Sie Status haben, über den Sie berichten können, kann Ihr Skript das jederzeit an ControlMyPi senden, und es wird an Ihren Webbrowser weitergeleitet.
Wenn Sie das Python-Paket noch nicht installiert haben, tun Sie es jetzt. Sie benötigen außerdem ein XMPP-Konto. Ich würde ein Google Gmail-Konto empfehlen, da dies gut funktioniert und auch später verwendet wird, wenn unser Skript eine E-Mail senden soll. Folgen Sie den Anweisungen auf der ControlMyPi-Website, um zu beginnen und Ihre Verbindung zu testen.
Bei der ersten Iteration des Armaturenbretts wird einfach eine einzige Anzeige mit dem Sensorwert angezeigt. Wir werden alle 30 Sekunden einen neuen Wert auf ControlMyPi setzen, um dies zu produzieren:
Das Skript, um dies zu erstellen, ist noch relativ unkompliziert:
mcp3008 aus timemimport import mcp3008 aus controlmypi importieren ControlMyPi importieren protokollieren def on_msg (conn, key, value): übergeben Sie logging.basicConfig (level = logging.INFO) p = [[['' ',' feucht ',' level ', 0,0,1023]],] conn = ControlMyPi ('[email protected]', 'password', 'feuchtigkeit', 'feuchtigkeitsüberwachung', p, on_msg) if conn.start_control (): try: while True: m = mcp3008.readadc (5) conn.update_status ('wet': m) sleep (30) schließlich: conn.stop_control () Ganz oben importieren wir nun die ControlMyPi-Klasse und das Protokollierungsmodul. Wenn Sie Probleme mit der XMPP-Verbindung debuggen müssen, ändern Sie die Protokollebene in DEBUGGEN.
Das Funktion on_msg Dies wäre, wenn wir Schaltflächen oder andere Eingaben in unserem Widget-Layout definieren würden. Da wir nur ein Messgerät haben, gibt es keine Eingaben und diese Funktion bewirkt also nichts.
In der Liste p ist das Widget-Layout definiert. Jeder Eintrag in der Liste definiert eine Reihe von Widgets, die im Dashboard angezeigt werden. Wir haben eine einzige Zeile mit einem einzigen Widget, der Anzeige. Feucht ist der Name des Widgets, Stufe ist die Bezeichnung, die auf der Anzeige angezeigt wird, 0 ist die Ausgangsebene, 0 ist das Mindestniveau und 1023 ist das Maximum.
Das Skript erstellt dann ein ControlMyPi-Objekt und startet. Hier müssen Sie Ihre eigene Google Mail-Adresse und Ihr Passwort angeben.
Spitze: Dies ist eine sichere Verbindung zu den Servern von Google. Das Passwort wird nicht mit anderen Diensten geteilt. Wenn Sie überhaupt betroffen sind, richten Sie einfach ein anderes Konto ein. In der Tat ist ein separates Konto sehr praktisch, vor allem wenn Sie automatisierte E-Mails von Ihrem Raspberry Pi erhalten möchten.
Schließlich nimmt die Hauptschleife den Sensor wie üblich an, aber anstatt ihn auf der Konsole oder auf dem LCD-Display zu drucken, wird der neue Wert an ControlMyPi übergeben. Updates werden in einer Karte von gesendet Name / Wert des Widgets.
Führen Sie das Skript wie gewohnt mit sudo aus:
pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $ sudo python feucht_cmp.py
Einige Verbindungsinformationen werden auf die Konsole gedruckt, gefolgt von "Registered with controlmypi". Gehen Sie jetzt zu ControlMyPi.com und geben Sie Ihre Gmail-Adresse in das Formular ein:
Klicken Suchtafeln So zeigen Sie eine Liste der Control Panels an, die Ihrer Google Mail-Adresse zugeordnet sind. Es sollte einen in der Liste geben, Feuchtigkeitsmonitor. Klicken Sie hier, um Ihr Panel zu starten und die Live-Daten zu sehen, die von Ihrem Raspberry Pi übertragen werden.
Alle 30 Sekunden, wenn ein neuer Sensor abgelesen wird, wird dieser Wert über die XMPP-Verbindung zu ControlMyPi übertragen. Diese Daten werden dann an alle Betrachter Ihres Panels weitergeleitet (im Moment nur Sie). Sie werden die Anzeige vor Ihren Augen sehen! Wenn Sie möchten, können Sie die lange URL kopieren / einfügen und an einen Freund senden, um Ihren Feuchtigkeitsmonitor vorzuführen. Jetzt werden Updates an Sie und Ihren Freund weitergeleitet.
ControlMyPi verfügt über eine Reihe von Widgets, die Sie in Ihrem Dashboard verwenden können. Eine der nützlichsten Datenvisualisierungen ist das Liniendiagramm. Das Programm in diesem Abschnitt fügt ein einfaches Liniendiagramm hinzu, um die Änderungen des Feuchtigkeitsniveaus über die Zeit aufzuzeichnen. Zu Beginn zeichnen wir einfach alle dreißig Sekunden einen neuen Punkt in der Grafik, wenn wir eine Messung vornehmen.
from time import sleep mcp3008 aus controlmypi import importieren ControlMyPi import logging import datetime def on_msg (conn, key, value): pass def append_chart_point (chart, point): wenn len (chart)> = 10: diagramm löschen [0] chart.append (Punkt) Rückgabe des Diagramms logging.basicConfig (level = logging.INFO) p = [[[['[G],' feucht ','% level ', 0,0,100], [' LC ',' chart1 ',' Time ' , 'Value', 0,100]],] c1 = [] conn = ControlMyPi ('[email protected]', 'password', 'moistcmp2', 'Moisture monitor 2', p, on_msg), wenn 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 ('feucht': m, 'chart1': c1) sleep (30) schließlich: conn.stop_control () Im Widget-Layout, p, Sie können die Definition des Liniendiagramm-Widget nach der Anzeige sehen. Der Widget-Name lautet chart1, das x-Achse ist die Zeit, die y-Achse ist Wert und die max und Mindest Werte sind auf 0 und 100 eingestellt.
Spitze: Ich habe die Skala vom Rohsensorbereich (0 bis 1023) in einen aussagekräftigeren Prozentwert geändert. Das Modul mcp3008 stellt eine Funktion read_pct () bereit, um anstelle des Rohwerts einen ganzzahligen Prozentpunkt zurückzugeben.
Um das Diagramm im Dashboard zu aktualisieren, senden Sie einfach eine Liste von Datenpunkten an ControlMyPi. Die Datenpunkte werden in der Liste c1 im Programm gespeichert und jeder Punkt besteht aus einer Zeit und einem Wert. Die Funktion append_chart_point () wird verwendet, um eine fortlaufende Liste der letzten zehn Punkte zu verwalten, so dass bei jedem neuen Wert der älteste gelöscht wird. Ohne das würde das Diagramm für immer wachsen.
Führen Sie das Skript wie gewohnt mit sudo aus:
pi @ raspberrypi ~ / py / tutorials / feuchtigkeit $ sudo python feucht_cmp2.py
Dieses Skript verbessert die vorherige Version um:
import sys.path.append ('/ home / pi / py / Adafruit-Himbeer-Pi-Python-Code / Adafruit_CharLCDPlate') aus der Zeit importieren Sie den Schlaf von Adafruit_CharLCDPlate importieren Sie Adafruit_CharLCDPlate import mcp300 importieren Sie importieren importieren Genericpath-Import ist vorhanden. lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, key, value): def def append_chart_point (chart, point): if len (chart)> = 48: del chart [0] chart.append (point) return chart def save (Daten): output = open (PICKLE_FILE, 'wb') pickle.dump (data, output) output.close () def load (Standardeinstellung): Wenn nicht vorhanden (PICKLE_FILE): Standardwert zurückgeben pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () Rückgabedaten def update_lcd (m): try: lcd.home () lcd.message ("Feuchtigkeitsgrad: \ n% d %%"% m) wenn 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: # Nimm den Durchschnitt aus der Messwertliste, um den Graphen etwas zu glätten. avg = int (round (summe (lesungen) / len (lesungen))) lesungen = [] c1 = append_chart_point (c1, [dt.strftime ('% H:% M '), avg]) save (c1) next_time = dt + delta to_update [' chart1 '] = c1 conn.update_status (to_update) sleep (30) Schließlich: conn.stop_control () Sie sollten den Inhalt des erkennen update_lcd () Funktion aus dem früheren Programm. Diese Funktion wird jetzt aus der Hauptschleife aufgerufen, um das LCD bei jeder Wiederholung zu aktualisieren.
Spitze: Wenn Sie nicht über das LCD verfügen, löschen Sie einfach diese Funktion und die aufrufende Leitung. Entferne auch den Pfad und importiere von oben und von der Linie lcd = Adafruit_CharLCDPlate ().
Um 24 Stunden Daten auf dem Liniendiagramm aufzuzeichnen, nehmen wir alle 30 Minuten eine Messung vor und zeigen 48 Punkte auf dem Diagramm. Das append_chart_point () Funktion wurde aktualisiert, um 48 Datenpunkte zu speichern. In der Hauptschleife halten wir jetzt in der Variablen eine Zeit von 30 Minuten in der Zukunft nächstes Mal.
In jeder Schleife überprüfen wir die aktuelle Uhrzeit mit der nächstes Mal. Wenn wir bestanden haben nächstes Mal Ein Datenpunkt wird an das Diagramm angehängt und nächstes Mal wird erneut um 30 Minuten nach vorne verschoben. Mit der Uhr können Sie Aktionen zu verschiedenen Zeitgranularitäten ausführen, ohne dass mehrere Zähler Schleifen usw. zählen müssen. Wir werden diese Technik im letzten Programm erneut verwenden, um eine tägliche E-Mail zu senden.
Wie Sie vielleicht bemerkt haben, schwankt der Messwert des Sensors ziemlich stark. Andere Arten von Sensoren tun dies nicht unbedingt, aber dieser tut dies. Anstatt also jede halbe Stunde eine einzige Ablesung vorzunehmen und dies in der Grafik aufzuzeichnen, zeichnen wir den Durchschnitt aller in der letzten halben Stunde gemessenen Ablesungen. In der Messwertliste werden alle Messwerte gespeichert, int (runde (summe (lesungen) / len (lesungen))) berechnet den Durchschnitt auf die nächste ganze Zahl. Dies wird dann in der Grafik dargestellt.
Das Pickle-Modul von Python wird zum Speichern und Laden der Diagrammdaten in eine Datei verwendet. Dies speichert einfach die c1-Liste, falls das Programm angehalten und erneut gestartet werden muss. Ein Neustart zum Beispiel für einen Batteriewechsel. Das sparen() Die Funktion wird jedes Mal aufgerufen, wenn wir das Diagramm und das Update aktualisieren Belastung() Die Funktion wird bei jedem Programmstart aufgerufen.
Führen Sie das Skript wie gewohnt mit sudo aus:
pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $ sudo python feuchte_cmp3_lcd.py
Der Screenshot zeigt jetzt ein viel glatteres Diagramm:
Um dieses Projekt abzuschließen, fügen wir einen letzten Schritt hinzu: E-Mail. Wir können den Sensor vom LCD aus überwachen und die aktuellen Messwerte und den Verlauf im Web anzeigen. Möglicherweise vergessen wir jedoch, dies nach einiger Zeit zu überprüfen. Um dies zu behandeln, werden wir das Programm so einrichten, dass es einmal am Tag eine E-Mail sendet, sobald der Sensor einen bestimmten Wert unterschreitet.
import sys.path.append ('/ home / pi / py / Adafruit-Himbeer-Pi-Python-Code / Adafruit_CharLCDPlate') aus der Zeit importieren Sie den Schlaf von Adafruit_CharLCDPlate importieren Sie Adafruit_CharLCDPlate import mcp300 importieren Sie importieren importieren Genericpath-Import existiert. Import smtplib lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, key, value): def defendendendchart_point (chart, point): wenn len (chart) > = 48: Diagramm löschen [0] chart.append (Punkt) Rückgabe Diagramm def speichern (Daten): Ausgabe = offen (PICKLE_FILE, 'wb') pickle.dump (Daten, Ausgabe) output.close () def load (Standardeinstellung) ): Wenn nicht vorhanden (PICKLE_FILE): Standardwert zurückgeben pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () Rückgabedaten def update_lcd (m): try: lcd.home () lcd .message ("Feuchtigkeitsgrad: \ n% d %%"% m), wenn 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 \ nSo:% s \ r \ nSubject:% s \ r \ nX-Mailer: My-Mail \ r \ n \ r \ n "% (senddate, from_name, Absender, Empfänger, Betreff) server = smtplib.SMTP ('smtp.gmail.com:587') server.starttls () server.login (Sender, Kennwort) server.sendmail (Sender, Empfänger, msg + body) server.quit () logging.basicConfig (level = logging.INFO) ) p = [[[['' G ',' feucht ',' Niveau ', 0,0,100], [' LC ',' Diagramm1 ',' Zeit ',' Wert ', 0,100]],] c1 = Last ([ ]) readings = [] conn = ControlMyPi ('[email protected]', 'Passwort', 'Feuchtigkeit', 'Feuchtigkeitsmonitor', p, on_msg) delta = datetime.timedelta (Minuten = 30) next_time = datetime.datetime .now () delta_email = datetime.timedelta (days = 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 = 'feucht': m # Aktualisieren Sie das Diagramm, wenn dt> next_time: # Nehmen Sie den Durchschnitt aus der Messwertliste, um den Graphen etwas zu glätten (summe (lesungen) / len (lesungen))) lesungen = [] c1 = append_chart_po int (c1, [dt.strftime ('% H:% M'), avg]) save (c1) next_time = dt + delta to_update ['chart1'] = c1 conn.update_status (an_update) #Sende eine E-Mail? wenn dt> next_email_time: next_email_time = dt + delta_email wenn 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() Das send_gmail () Funktion kümmert sich um das Versenden der E-Mail. In der Hauptschleife verwenden wir die Technik zur Überprüfung der Uhrzeit, um festzustellen, ob seit dem letzten Versand einer E-Mail ein Tag vergangen ist. Wenn dies der Fall ist, stoßen wir diesmal um einen Tag für die nächste Überprüfung an. Wenn der Feuchtigkeitswert unter 40 liegt, senden wir die E-Mail.
Das ist das Programm! Führen Sie es mit aus Sudo wie gewöhnlich:
pi @ raspberrypi ~ / py / Tutorials / feuchtigkeit $ sudo python feucht_final.py
Als letztes müssen Sie das Programm beim Start automatisch ausführen. Dadurch können Sie Ihren Raspberry Pi ohne Kopfhörer betreiben. Bearbeiten Sie dazu das /etc/rc.local/ Datei wie folgt:
pi @ raspberrypi ~ $ sudo pico /etc/rc.local
Fügen Sie der Datei diese Zeile hinzu und speichern Sie sie:
python /home/pi/py/tutorials/moisture/moist_final.py &
Jetzt können Sie Ihren Raspberry Pi herunterfahren, in die überwachte Anlage verschieben, einschalten und das Programm wird für Sie gestartet.
In diesem Lernprogramm haben Sie gelernt, wie Sie SPI auf Ihrem Raspberry Pi für die Verwendung mit einem Analog-Digital-Wandler einrichten und verwenden. Sie haben dann einen Sensor verwendet, um den Feuchtigkeitsgehalt des Bodens in einem Pflanztopf zu überwachen. Die Software ermöglicht es uns, diesen Sensor auf der Konsole, auf einem LCD-Display, auf einem Messgerät und einem Diagramm über das Internet und über e
