Bauen Sie einen Himbeer-Pi-Feuchtigkeitssensor, um Ihre Pflanzen zu überwachen

In diesem Tutorial werde ich die Großartigkeit von Raspberry Pi nutzen, um einen Feuchtigkeitssensor für einen Blumentopf zu bauen. Sie können den Sensor lokal auf dem LCD oder remote über ControlMyPi.com überwachen und tägliche E-Mails erhalten, wenn die Feuchtigkeit unter einen bestimmten Wert fällt.

Unterwegs werde ich:

• Verdrahten Sie und lesen Sie einen Wert von einem analogen Sensor über SPI mit einem Steckbrett
• Formatieren Sie die Sensoranzeige gut in der Konsole
• Zeigen Sie den Sensorwert auf einem RGB-LCD-Display an
• Lassen Sie den Raspberry Pi eine E-Mail mit dem Sensor lesen
• Überwachen Sie einfach den Sensor und einige historische Messwerte im Internet

Hardware-Zubehör

Um dieses Tutorial optimal nutzen zu können, wird empfohlen, Folgendes zu erwerben:

• Himbeer-Pi-Modell B ($40)
• Kabelgebundene oder drahtlose Internetverbindung
• Halbgroßes Steckbrett (5 US-Dollar)
• Sechs Überbrückungsdrähte von Buchse zu Stecker
• Überbrückungsdrähte von Stecker zu Stecker (verschiedene Längen)
• MCP3008 (3,75 USD) - 8-Kanal-10-Bit-A/D-Wandler mit serieller SPI-Schnittstelle
• Octopus Bodenfeuchtesensor Ziegel ($4.50)
• Adafruit RGB Negative 16x2 LCD+Tastatur-Kit für Raspberry Pi (25 USD) zusammen mit dem Stapelkopf für Raspberry Pi - 2x13 Extra groß (2 USD)

Einige alternative Komponenten

• Anstelle des Bodenfeuchtesensors können Sie zum Testen jede Art von Analogsensor mit variierender Spannung oder auch nur einen variablen Widerstand verwenden.
• Wenn Sie möchten, können Sie einen kleineren MCP3004 (4-Kanal-ADC-SPI) verwenden, die Verkabelung ist jedoch unterschiedlich.
• Sie können das RGB-LCD überspringen oder durch einen alternativen Bildschirm ersetzen. In diesem Fall müssen Sie einige Zeilen im endgültigen Skript entfernen oder ändern.

Die Kosten

Nach dem Hinzufügen einiger Dollar für die Überbrückungskabel belaufen sich die Gesamtkosten des Projekts auf ungefähr 55 USD ohne LCD und 82 USD mit. Denken Sie jedoch daran, dass Sie Ihr Elektronik-Kit auf Lager haben - alle diese Teile können wieder für andere Projekte verwendet werden.

1. Verkabelung

Wenn Sie das LCD mit dem Stapelkopf verwenden, schließen Sie es jetzt an den Raspberry Pi an. In den ersten beiden Phasen der Software wird das LCD nicht verwendet, aber Sie sparen später einige Zeit für die Neuverkabelung, wenn Sie es jetzt anschließen.

Warnung: Eine falsche Verkabelung kann Ihren Raspberry Pi beschädigen. Überprüfen Sie alle Verbindungen sorgfältig, bevor Sie das Gerät einschalten.

Schritt 1: Strom- und Erdungsschienen

Links auf dem Foto sehen Sie die roten und schwarzen Jumper, die zu den + und - Schienen auf dem Steckbrett gehen. Informationen zur Beschreibung der Verbindungen aus der Kopfzeile finden Sie in dieser Drahtfarbtabelle. Jede Zelle in der Tabelle bezieht sich auf einen Pin im Raspberry Pi-Header. Die Farbe der Zelle entspricht der Farbe des Überbrückungskabels, wie auf dem Foto zu sehen:

Verbinden Sie Pin 1 mit der Plusschiene und Pin 6 mit der Erdungsschiene.

Schritt 2: MCP3008

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 bei der Verkabelung dieses Chips auf diese Drahtfarbtabelle und das Datenblatt:

Alle Verbindungen von den Schienen und dem Header zum MCP3008-Chip verlaufen in dieser Ausrichtung sauber entlang der unteren Reihe des Chips. Verbinden Sie zuerst Strom und Masse wie auf dem Foto oben gezeigt:

• Erdungsschiene zur DGND
• Erdungsschiene nach AGND
• Stromschiene nach VREF
• Stromschiene zum VDD

Verbinden Sie als Nächstes die Raspberry Pi SPI-Header-Pins mit dem Chip:

• Header 26 zu CS
• Kopfzeile 19 nach DIN
• Header 21 zu DOUT
• Header 23 zu CLK

Schritt 3: Sensor

Die Sensorverkabelung ist einfach; Es gibt drei Verbindungen herzustellen:

• Sensor gelb bis CH5
• Sensor rot zur Stromschiene
• Sensor schwarz zur Erdungsschiene

Wenn Sie Ihren Blumentopf zur Hand haben, können Sie die Sonde jetzt in den Boden einführen. Achten Sie darauf, dass Sie es nicht zu tief drücken. Decken Sie einfach die Zinken ab:

2. Vorbereiten der Softwareumgebung

Schritt 1: Betriebssystem

Dieses Projekt wurde mit Occidentalis v0.2 von Adafruit erstellt, das mit dem sofort einsatzbereiten Hardware-SPI-Treiber geliefert wird. Befolgen Sie die Anweisungen auf der Adafruit-Website, um es auf Ihrem Raspberry Pi zu installieren.

Schritt 2: Erforderliche Dienstprogramme

git - Sie sollten dies bereits haben (versuchen Sie, git einzugeben), wenn nicht, dann installieren Sie es mit: sudo apt-get install git pip - installiere dies mit: sudo apt-get install python-pip

Schritt 3: SPI Python Wrapper

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 vom Sensor über SPI lesen können:

1

cd ~

2

git clone git://github.com/doceme/py-spidev

3

cd py-spidev/

4

sudo python setup.py install

Schritt 4: Adafruit Python Library

Sie haben die Adafruit-Bibliothek bereits beim Zusammenbau und Testen Ihres LCD installiert. Stellen Sie sicher, dass Sie den Speicherort der Bibliothek kennen, da dies vom Projektcode benötigt wird.

Schritt 5: ControlMyPi-Bibliothek

ControlMyPi ist ein Dienst, mit dem Sie schnell und einfach Control Panels im Internet aus Ihren Raspberry Pi Python-Skripten erstellen können. Verwenden Sie pip, um es zu installieren:

1

sudo pip install controlmypi

Schritt 6: Projektcode

Der gesamte Code aus diesem Tutorial kann folgendermaßen heruntergeladen werden:

1

cd ~

2

mkdir py

3

cd py

4

git clone 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.

3. Lesen eines Wertes vom Sensor

Der MCP3008 wandelt die Eingangsspannung in eine Zahl von 0 bis 1023 (10 Bit) um. Sie können diesen Wert dann über SPI lesen (die grünen und weißen Verbindungen zum Header auf dem Pi). Das py-spidev-Paket ermöglicht es uns, dies von Python aus zu tun.

Es gibt einige subtile Komplikationen beim Lesen einer 10-Bit-Zahl in einem 8-Bit-System. Der SPI-Treiber gibt zwei 8-Bit-Wörter zurück und wir interessieren uns für die letzten 2 Bits des ersten Wortes, 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 vom ersten Wort maskieren und dann um 8 nach links verschieben, bevor wir das zweite Wort hinzufügen.

Sie müssen sich jedoch keine Gedanken über das Codieren machen, da ich im Download das Modul mcp3008.py beigefügt habe, um dies zu beheben. Sie können eine interaktive Python-Shell verwenden, um Ihr SPI-Setup und Ihre Verkabelung wie folgt zu testen:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python

2

Python 2.7.3 (default, Jan 13 2013, 11:20:46)

3

[GCC 4.6.3] on linux2

4

Type "help", "copyright", "credits" or "license" for more information.

5

>>> import mcp3008

6

>>> mcp3008.readadc(5)

7

444

Wenn Sie Probleme haben, überprüfen Sie zuerst Ihre Verkabelung. Überprüfen Sie dann die obigen Schritte zur Softwareinstallation. Wenn Sie den Octopus-Feuchtigkeitssensor verwenden, halten Sie die Zinken fest, um eine Verbindung mit Ihrer Hand herzustellen. Andernfalls wird wahrscheinlich nur Null angezeigt.

Sie können den Sensor hier aus der Gleichung herausnehmen, indem Sie einen Jumper von der Stromschiene beispielsweise an CH1 anschließen und dann readadc(1) verwenden. Dies sollte 1023 (oder in der Nähe davon) zurückgeben. Ebenso sollte eine Verbindung von der Erdungsschiene 0 zurückgeben.

Programme

Programm 1: Überwachung in der Konsole

Das erste Programm erweitert einfach das, was wir in der interaktiven Konsole geübt haben, um eine Schleife, sodass der Wert vom Sensor kontinuierlich ausgedruckt wird:

1

from time import sleep

2

import mcp3008

3

4

while True:

5

    m = mcp3008.readadc(5)

6

    print "Moisture level: {:>5} ".format(m)

7

    sleep(.5)

Beachten Sie, dass sich in der Schleife eine halbe Sekunde Schlaf befindet. Dies ist so, dass das Programm nachgibt; es weicht anderen Prozessen. Andernfalls würde viel CPU-Zeit verbraucht und andere Prozesse, die Sie ausführen, würden nicht so gut funktionieren. Ein Messwert zweimal pro Sekunde ist wahrscheinlich sowieso viel zu viel, sicherlich für einen Feuchtigkeitssensor.

Die Ausgabe sollte folgendermaßen aussehen:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_cmd.py

2

Moisture level:   452

3

Moisture level:   486

4

Moisture level:   485

5

Moisture level:   483

6

Moisture level:   489

7

Moisture level:   491

8

Moisture level:   490

9

^CTraceback (most recent call last):

10

    File "moist_cmd.py", line 7, in <module>

11

            sleep(.5)

12

KeyboardInterrupt

13

pi@raspberrypi ~/py/tutorials/moisture $

Drücken Sie einfach Strg-C, wenn Sie fertig sind, und das Programm wird wie oben beendet.

Programm 2: Bessere Konsolenüberwachung

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 Sensorwert wird über den letzten geschrieben, damit Ihr Fenster nicht scrollt.

Auch rote, gelbe und grüne Hintergründe werden als Ampel-Highlights verwendet. Wenn der Boden gut bewässert ist, ist der Hintergrund grün. Wenn es zu trocken ist, wird es rot angezeigt.

Um diese Färbung 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 erzielen.

1

from time import sleep

2

import mcp3008

3

4

# ANSI escape codes

5

PREVIOUS_LINE="\x1b[1F"

6

RED_BACK="\x1b[41;37m"

7

GREEN_BACK="\x1b[42;30m"

8

YELLOW_BACK="\x1b[43;30m"

9

RESET="\x1b[0m"

10

11

# Clear the screen and put the cursor at the top

12

print '\x1b[2J\x1b[H'

13

print 'Moisture sensor'

14

print '===============\n'

15

16

while True:

17

    m = mcp3008.readadc(5)

18

    if m < 150:

19

        background = RED_BACK

20

     elif m < 500:

21

        background = YELLOW_BACK

22

     else:

23

        background = GREEN_BACK

24

     print PREVIOUS_LINE + background + "Moisture level: {:>5} ".format(m) + RESET

25

     sleep(.5)

Das Programm löscht den Bildschirm und zeigt einen Titel an. Es geht dann wieder in die Perpetual-Schleife, aber dieses Mal werden Schwellenwerte verwendet, um die Hintergrundfarbe zu bestimmen. Schließlich werden die Escape-Sequenzen und der Text ausgedruckt, gefolgt von einer RESET-Sequenz, um die Färbung auszuschalten. Der Escape-Code PREVIOUS_LINE wird verwendet, um den Cursor eine Zeile nach oben zu bewegen, sodass wir jedes Mal über den vorherigen Wert schreiben.

Führen Sie dieses Beispiel folgendermaßen aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_ansi.py

Die Ausgabe sollte ungefähr so aussehen:

Programm 3: LCD-Überwachung

Wir werden uns jetzt von der Konsole entfernen und stattdessen die Sensordaten auf dem LCD anzeigen. Bevor Sie mit diesem Tutorial fortfahren, stellen Sie sicher, dass Sie Ihr Adafruit-LCD mit dem Stapelkopf erstellt haben und es getestet haben, indem Sie dem Adafruit-Tutorial folgen.

Unser Programm wird die Adafruit-Bibliothek verwenden, daher müssen wir den vollständigen Pfad zum Adafruit_CharLCDPlate-Verzeichnis kennen. Ich erstelle einfach ein py-Verzeichnis unter der Startseite des pi-Benutzers, um den gesamten Python-Code an einem Ort zu speichern. Auf meinem Raspberry Pi lautet der Pfad also:

1

/home/pi/py/Adafruit-Raspberry-Pi-Python-Code/Adafruit_CharLCDPlate

Möglicherweise müssen Sie das folgende Skript anpassen, wenn Ihr Pfad anders ist.

1

import sys

2

sys.path.append('/home/pi/py/Adafruit-Raspberry-Pi-Python-Code/Adafruit_CharLCDPlate')

3

4

from time import sleep

5

from Adafruit_CharLCDPlate import Adafruit_CharLCDPlate

6

import mcp3008

7

8

lcd = Adafruit_CharLCDPlate()

9

10

while True:

11

    m = mcp3008.readadc(5)

12

    try:

13

        lcd.home()

14

        lcd.message("Moisture level:\n%d    " % m)

15

        if m < 150:

16

            lcd.backlight(lcd.RED)

17

        elif m < 500:

18

            lcd.backlight(lcd.YELLOW)

19

        else:

20

            lcd.backlight(lcd.GREEN)

21

        except IOError as e:

22

            print e

23

        sleep(.5)

Führen Sie das Programm folgendermaßen aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_lcd.py

Sie sollten die LCD-Version des Farbkonsolenprogramms sehen. Diesmal nutzen die roten, gelben und grünen Schwellenwertanzeigen die RGB-Hintergrundbeleuchtung.

Programm 4: Fernüberwachung mit ControlMyPi

In diesem Abschnitt verwenden wir ControlMyPi, um ein Dashboard im Internet zu erstellen. So wird der Service in den FAQ beschrieben:

ControlMyPi bietet einen webbasierten Dienst, mit dem einfache Python-Skripte 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, das ControlMyPi anzeigen soll. Wenn Sie auf eine Schaltfläche klicken, erhält Ihr Skript eine Nachricht. Wenn Sie einen Status zu melden haben, kann Ihr Skript diesen jederzeit an ControlMyPi senden und er wird an Ihren Webbrowser gesendet.

Wenn Sie das Python-Paket noch nicht installiert haben, tun Sie dies jetzt. Sie benötigen außerdem ein XMPP-Konto. Ich würde ein Google Mail-Konto empfehlen, da dies gut funktioniert und auch später verwendet wird, wenn unser Skript eine E-Mail senden soll. Befolgen Sie die Anweisungen auf der ControlMyPi-Website, um loszulegen und Ihre Verbindung zu testen.

Die erste Iteration des Dashboards zeigt einfach eine einzelne Anzeige mit dem Sensorwert an. Wir werden alle 30 Sekunden einen neuen Messwert an ControlMyPi senden, um dies zu erreichen:

Das Skript, um dies zu produzieren, ist noch relativ einfach:

1

from time import sleep

2

import mcp3008

3

from controlmypi import ControlMyPi

4

import logging

5

6

def on_msg(conn, key, value):

7

    pass

8

9

logging.basicConfig(level=logging.INFO)

10

11

p = [ 

12

    [ ['G','moist','level',0,0,1023] ], 

13

    ]

14

15

conn = ControlMyPi('you@gmail.com', 'password', 'moisture', 'Moisture monitor', p, on_msg)

16

if conn.start_control():

17

        try:

18

            while True:

19

                    m = mcp3008.readadc(5)

20

                    conn.update_status({'moist':m})

21

                    sleep(30)

22

    finally:

23

conn.stop_control()

Oben importieren wir jetzt die ControlMyPi-Klasse und das Protokollierungsmodul. Wenn Sie Probleme mit der XMPP-Verbindung beheben müssen, ändern Sie die Protokollebene in DEBUG.

Die on_msg function wird aufgerufen, wenn wir Schaltflächen oder andere Eingaben in unserem Widget-Layout definieren. Da wir nur ein Messgerät haben, gibt es keine Eingabe und diese Funktion bewirkt nichts.

In der Liste p wird das Widget-Layout definiert. Jeder Eintrag in der Liste definiert eine Reihe von Widgets, die im Dashboard angezeigt werden sollen. Wir haben eine einzelne Zeile mit einem einzelnen Widget, dem Messgerät. Moist ist der Name des Widgets, Stufe ist die Beschriftung, die auf dem Messgerät angezeigt werden soll, 0 ist die Anfangsstufe, 0 ist die Mindeststufe und 1023 ist die Höchststufe.

Das Skript erstellt dann ein ControlMyPi-Objekt und startet. Hier müssen Sie Ihre eigene Google Mail-Adresse und Ihr Passwort eingeben.

Schließlich nimmt die Hauptschleife den Sensor wie gewohnt auf, aber anstatt ihn auf die Konsole oder das LCD zu drucken, überträgt sie den neuen Wert an ControlMyPi. Aktualisierungen werden in einer Karte mit dem widget name / value gesendet.

Führen Sie das Skript wie gewohnt mit sudo aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_cmp.py

Einige Verbindungsinformationen werden auf der Konsole gedruckt, gefolgt von "Registriert bei controlmypi". Gehen Sie nun zu ControlMyPi.com und geben Sie Ihre Google Mail-Adresse in das folgende Formular ein:

Klicken Sie auf Bedienfelder suchen, um eine Liste der Kontrollfelder anzuzeigen, 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 anzuzeigen, die von Ihrem Raspberry Pi übertragen wurden.

Wenn alle 30 Sekunden ein neuer Sensorwert erfasst wird, wird dieser Wert über die XMPP-Verbindung zu ControlMyPi übertragen. Diese Daten werden dann an alle Betrachter Ihres Panels weitergeleitet (im Moment nur an Sie). Sie werden sehen, wie sich das Messgerät vor Ihren Augen bewegt! 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 gesendet.

Programm 5: Hinzufügen eines Liniendiagramms

ControlMyPi verfügt über eine Reihe von Widgets, die Sie in Ihrem Dashboard verwenden können. Eines der nützlichsten Elemente zur Visualisierung von Daten ist das Liniendiagramm. Das Programm in diesem Abschnitt fügt ein einfaches Liniendiagramm hinzu, um die Änderungen des Feuchtigkeitsgehalts über die Zeit aufzuzeichnen. Zu Beginn zeichnen wir alle dreißig Sekunden einen neuen Punkt auf dem Diagramm, wenn wir eine Messung durchführen.

1

from time import sleep

2

import mcp3008

3

from controlmypi import ControlMyPi

4

import logging

5

import datetime

6

7

def on_msg(conn, key, value):

8

    pass

9

10

def append_chart_point(chart, point):

11

    if len(chart) >= 10:

12

        del chart[0]

13

    chart.append(point)

14

    return chart

15

16

logging.basicConfig(level=logging.INFO)

17

18

p = [ 

19

    [ ['G','moist','% level',0,0,100], ['LC','chart1','Time','Value',0,100] ], 

20

    ]

21

22

c1 = []

23

24

conn = ControlMyPi('you@gmail.com', 'password', 'moistcmp2', 'Moisture monitor 2', p, on_msg)

25

if conn.start_control():

26

    try:

27

        while True:

28

            dt = datetime.datetime.now().strftime('%H:%M:%S')

29

            m = mcp3008.read_pct(5)                

30

            c1 = append_chart_point(c1, [dt, m])

31

            conn.update_status({'moist':m,'chart1':c1})

32

            sleep(30)

33

    finally:

34

        conn.stop_control()

Im Widget-Layout p sehen Sie die Definition des Liniendiagramm-Widgets nach dem Messgerät. Der Widget-Name lautet chart1, die x axis ist Time, die y axis ist Value und die max- und min-Werte sind auf 0 und 100 festgelegt.

Um das Diagramm im Dashboard zu aktualisieren, senden Sie einfach eine Liste der Datenpunkte 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 führen. Wenn also jeder neue Wert eintrifft, wird der älteste gelöscht. Ohne dies würde das Diagramm für immer wachsen.

Führen Sie das Skript wie gewohnt mit sudo aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_cmp2.py

Programm 6: Verbesserung des Liniendiagramms

Dieses Skript verbessert die vorherige Version durch:

• Wiedereinführung des LCD, damit wir sowohl lokale als auch Online-Überwachung haben.
• Aufzeichnen von Datenpunkten auf dem Liniendiagramm über 24 Stunden.
• Glätten Sie die Schwankungen auf dem Chart, indem Sie einen Durchschnitt nehmen.
• Speichern Sie die Diagrammdaten in einer Datei, damit wir sie nicht verlieren, wenn wir das Programm neu starten müssen.

1

import sys

2

sys.path.append('/home/pi/py/Adafruit-Raspberry-Pi-Python-Code/Adafruit_CharLCDPlate')

3

4

from time import sleep

5

from Adafruit_CharLCDPlate import Adafruit_CharLCDPlate

6

import mcp3008

7

from controlmypi import ControlMyPi

8

import logging

9

import datetime

10

import pickle

11

from genericpath import exists

12

13

lcd = Adafruit_CharLCDPlate()

14

15

PICKLE_FILE = '/home/pi/py/moisture/moist.pkl'

16

17

def on_msg(conn, key, value):

18

    pass

19

20

def append_chart_point(chart, point):

21

    if len(chart) >= 48:

22

        del chart[0]

23

    chart.append(point)

24

    return chart

25

26

def save(data):

27

    output = open(PICKLE_FILE, 'wb')

28

    pickle.dump(data, output)

29

    output.close()

30

31

def load(default):

32

    if not exists(PICKLE_FILE):

33

        return default

34

    pkl_file = open(PICKLE_FILE, 'rb')

35

    data = pickle.load(pkl_file)

36

    pkl_file.close()

37

    return data

38

39

def update_lcd(m):

40

    try:

41

        lcd.home()

42

        lcd.message("Moisture level:\n%d%%   " % m)

43

        if m < 15:

44

            lcd.backlight(lcd.RED)

45

        elif m < 50:

46

            lcd.backlight(lcd.YELLOW)

47

        else:

48

            lcd.backlight(lcd.GREEN)

49

    except IOError as e:

50

        print e

51

52

logging.basicConfig(level=logging.INFO)

53

54

p = [ 

55

    [ ['G','moist','% level',0,0,100], ['LC','chart1','Time','Value',0,100] ], 

56

    ]

57

58

c1 = load([])

59

60

readings = []

61

62

conn = ControlMyPi('you@gmail.com', 'password', 'moisture3', 'Moisture monitor 3', p, on_msg)

63

64

delta = datetime.timedelta(minutes=30)

65

next_time = datetime.datetime.now()

66

67

if conn.start_control():

68

    try:

69

        while True:

70

            dt = datetime.datetime.now()

71

            m = mcp3008.read_pct(5)

72

            readings.append(m)

73

            update_lcd(m)

74

            to_update = {'moist':m}

75

            if dt > next_time:       

76

                # Take the average from the readings list to smooth the graph a little

77

                avg = int(round(sum(readings)/len(readings)))             

78

                readings = []   

79

                c1 = append_chart_point(c1, [dt.strftime('%H:%M'), avg])                         

80

                save(c1)

81

                next_time = dt + delta

82

                to_update['chart1'] = c1

83

            conn.update_status(to_update)

84

            sleep(30)

85

    finally:

86

        conn.stop_control()

Sie sollten den Inhalt der Funktion update_lcd() aus dem früheren Programm erkennen. Diese Funktion wird jetzt von der Hauptschleife aufgerufen, um das LCD bei jeder Iteration zu aktualisieren.

Daten aufzeichnen

Um 24 Stunden Daten auf dem Liniendiagramm aufzuzeichnen, nehmen wir alle 30 Minuten eine Messung vor und zeigen 48 Punkte auf dem Diagramm an. Die Funktion append_chart_point() wurde aktualisiert, um 48 Datenpunkte beizubehalten. In der Hauptschleife halten wir jetzt eine Zeit von 30 Minuten in der Zukunft in der Variablen next_time.

In jeder Schleife prüfen wir die aktuelle Zeit gegen die next_time. Wenn wir next_time bestanden haben, wird ein Datenpunkt an das Diagramm angehängt und next_time erneut um 30 Minuten vorwärts verschoben. Die Verwendung der Uhr ist eine gute Möglichkeit, Aktionen zu unterschiedlichen Zeitpunkten auszuführen, ohne dass mehrere Zähler Schleifen zählen müssen und so weiter. Wir werden diese Technik im endgültigen Programm erneut verwenden, um eine tägliche E-Mail zu senden.

Wie Sie vielleicht bemerkt haben, schwankt der Messwert vom Sensor ziemlich stark. Andere Arten von Sensoren tun dies nicht unbedingt, aber dieser. Anstatt eine halbe Stunde lang eine einzelne Messung durchzuführen und diese in der Grafik darzustellen, zeichnen wir den Durchschnitt aller in der letzten halben Stunde gemessenen Messungen. Die Leseliste wird verwendet, um alle Messwerte zu speichern. int(round(sum(readings)/len(readings))) berechnet den Durchschnitt auf die nächste ganze Zahl. Dies wird dann in der Tabelle dargestellt.

Das Pickle-Modul von Python wird zum Speichern und Laden der Diagrammdaten in eine Datei verwendet. Dies speichert einfach die c1-Liste für den Fall, dass wir das Programm stoppen und erneut starten müssen. Zum Beispiel ein Neustart für einen Batteriewechsel. Die Funktion save() wird jedes Mal aufgerufen, wenn wir das Diagramm aktualisieren, und die Funktion load() wird jedes Mal aufgerufen, wenn das Programm gestartet wird.

Führen Sie das Skript wie gewohnt mit sudo aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_cmp3_lcd.py

Der Screenshot zeigt jetzt ein viel glatteres Diagramm:

Das endgültige Programm

Um dieses Projekt abzuschließen, fügen wir einen letzten Schritt hinzu: E-Mail. Wir können den Sensor vom LCD aus überwachen und den aktuellen Messwert und Verlauf im Internet anzeigen. Möglicherweise vergessen wir jedoch nach einer Weile, ihn zu überprüfen. Um dies zu decken, wird das Programm einmal täglich eine E-Mail senden, wenn der Sensorwert unter einem bestimmten Wert liegt.

1

import sys

2

sys.path.append('/home/pi/py/Adafruit-Raspberry-Pi-Python-Code/Adafruit_CharLCDPlate')

3

4

from time import sleep

5

from Adafruit_CharLCDPlate import Adafruit_CharLCDPlate

6

import mcp3008

7

from controlmypi import ControlMyPi

8

import logging

9

import datetime

10

import pickle

11

from genericpath import exists

12

import smtplib

13

14

lcd = Adafruit_CharLCDPlate()

15

16

PICKLE_FILE = '/home/pi/py/moisture/moist.pkl'

17

18

def on_msg(conn, key, value):

19

    pass

20

21

def append_chart_point(chart, point):

22

    if len(chart) >= 48:

23

        del chart[0]

24

    chart.append(point)

25

    return chart

26

27

def save(data):

28

    output = open(PICKLE_FILE, 'wb')

29

    pickle.dump(data, output)

30

    output.close()

31

32

def load(default):

33

    if not exists(PICKLE_FILE):

34

        return default

35

    pkl_file = open(PICKLE_FILE, 'rb')

36

    data = pickle.load(pkl_file)

37

    pkl_file.close()

38

    return data

39

40

def update_lcd(m):

41

    try:

42

        lcd.home()

43

        lcd.message("Moisture level:\n%d%%   " % m)

44

        if m < 15:

45

            lcd.backlight(lcd.RED)

46

        elif m < 50:

47

            lcd.backlight(lcd.YELLOW)

48

        else:

49

            lcd.backlight(lcd.GREEN)

50

    except IOError as e:

51

        print e

52

53

def send_gmail(from_name, sender, password, recipient, subject, body):

54

    '''Send an email using a GMail account.'''

55

    senddate=datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d')

56

    msg="Date: %s\r\nFrom: %s <%s>\r\nTo: %s\r\nSubject: %s\r\nX-Mailer: My-Mail\r\n\r\n" % (senddate, from_name, sender, recipient, subject)

57

    server = smtplib.SMTP('smtp.gmail.com:587')

58

    server.starttls()

59

    server.login(sender, password)

60

    server.sendmail(sender, recipient, msg+body)

61

    server.quit()

62

63

logging.basicConfig(level=logging.INFO)

64

65

p = [ 

66

    [ ['G','moist','level',0,0,100], ['LC','chart1','Time','Value',0,100] ], 

67

    ]

68

69

c1 = load([])

70

71

readings = []

72

73

conn = ControlMyPi('you@gmail.com', 'password', 'moisture', 'Moisture monitor', p, on_msg)

74

75

delta = datetime.timedelta(minutes=30)

76

next_time = datetime.datetime.now()

77

78

delta_email = datetime.timedelta(days=1)

79

next_email_time = datetime.datetime.now()

80

81

if conn.start_control():

82

    try:

83

        while True:

84

            dt = datetime.datetime.now()

85

            m = mcp3008.read_pct(5)

86

            readings.append(m)

87

            update_lcd(m)

88

            to_update = {'moist':m}

89

90

            # Update the chart?

91

            if dt > next_time:

92

                # Take the average from the readings list to smooth the graph a little

93

                avg = int(round(sum(readings)/len(readings)))             

94

                readings = []   

95

                c1 = append_chart_point(c1, [dt.strftime('%H:%M'), avg])

96

                save(c1)

97

                next_time = dt + delta

98

                to_update['chart1'] = c1

99

            conn.update_status(to_update)

100

101

            #Send an email?

102

            if dt > next_email_time:

103

                next_email_time = dt + delta_email

104

                if m < 40:

105

                    send_gmail('Your Name', 'you@gmail.com', 'password', 'recipient@email.com', 'Moisture sensor level', 'The level is now: %s' % m)

106

107

            sleep(30)

108

    finally:

109

        conn.stop_control()

Die Funktion send_gmail() übernimmt das Senden der E-Mail. In der Hauptschleife verwenden wir die Uhrprüftechnik, um festzustellen, ob seit dem letzten Versenden einer E-Mail ein Tag vergangen ist. Wenn ja, erhöhen wir diese Zeit um einen Tag für die nächste Überprüfung. Wenn der Feuchtigkeitswert unter 40 liegt, senden wir die E-Mail.

Damit ist das Programm abgeschlossen! Führen Sie es wie gewohnt mit sudo aus:

1

pi@raspberrypi ~/py/tutorials/moisture $ sudo python moist_final.py

Es gibt noch eine letzte Sache: Führen Sie das Programm beim Start automatisch aus. Auf diese Weise können Sie Ihren Raspberry Pi kopflos ausführen. Bearbeiten Sie dazu die Datei /etc/rc.local/ wie folgt:

1

pi@raspberrypi ~ $ sudo pico /etc/rc.local

Fügen Sie diese Zeile der Datei hinzu und speichern Sie sie:

1

python /home/pi/py/tutorials/moisture/moist_final.py &

Jetzt können Sie Ihren Raspberry Pi herunterfahren, in die zu überwachende Anlage verschieben, ihn einschalten und das Programm für Sie starten.

Abschluss

In diesem Tutorial haben Sie gelernt, wie Sie SPI auf Ihrem Raspberry Pi für die Verwendung mit einem Analog-Digital-Wandler einrichten und verwenden. Anschließend haben Sie mit einem Sensor den Feuchtigkeitsgehalt des Bodens in einem Blumentopf überwacht. Mit der Software können wir diesen Sensor auf der Konsole, auf einem LCD, auf einem Messgerät und einer Tabelle über das Internet und per E-Mail anzeigen.

Es gab viel zu lernen, aber jetzt können Sie diese Techniken für alle Arten von Sensoren verwenden, um Temperatur, Luftfeuchtigkeit, Lichtintensität usw. zu messen. Sie können es auch an einen Beschleunigungsmesser oder einen Infrarot-Abstandssensor anschließen. Habe Spaß!