Raspberry Pi Sense Hut ist eine Add-On-Platte, die mit Raspberry PI-Single-Board-Computern verwendet werden kann. Der Raspberry Pi Sense Hat hat ein 8 × 8-LED-Display und einen 5-Knopf-Joystick und ist mit den folgenden Sensoren ausgestattet:

1. Gyroskop
2. Beschleunigungsmesser
3. Magnetometer
4. Temperatur
5. Luftdruck
6. Feuchtigkeit

In diesem Artikel werde ich Ihnen zeigen, wie Sie eine Python -API -basierte Wetterstation -Webanwendung erstellen, indem Sie die verwenden Temperatur, Luftdruck, Und Feuchtigkeit Sensoren des Raspberry Pi Sense Hut. Um diesem Artikel zu folgen, benötigen Sie Folgendes:

1. Ein Raspberry Pi 3 oder Raspberry Pi 4 mit Netzwerkkonnektivität.
2. Ein Raspberry Pi Sense Hat -Modul.
3. Ein Micro-USB (Raspberry PI 3) oder USB Typ-C (Raspberry Pi 4) Power-Adapter.
4. Eine 16 GB oder 32 GB microSD -Karte mit Raspberry Pi OS.
5. Ein Laptop oder ein Desktop -Computer für VNC Remote -Desktop -Zugriff oder SSH -Zugriff auf den Raspberry PI.

NOTIZ: In diesem Artikel werden wir über VNC oder SSH mit dem Kopfless -Setup des Raspberry Pi eine Verbindung zum Raspberry Pi herstellen. Wenn Sie nicht über SSH oder VNC auf Ihr Raspberry Pi zugreifen möchten, müssen Sie einen Monitor, eine Tastatur und eine Maus mit Ihrem Raspberry Pi anschließen.

Um zu erfahren, wie Sie das Raspberry Pi OS -Bild auf eine microSD -Karte blinken, verweisen Sie bitte, wie Sie Raspberry PI Imagator installieren und verwenden können. Wenn Sie Hilfe bei der Installation von Raspberry Pi OS auf Ihrem Raspberry Pi benötigen. Wenn Sie Hilfe bei der kopierlosen Einrichtung von Raspberry Pi benötigen.

Anschließen

Raspberry Pi Sense Hat Kit ist mit dem Raspberry Pi Sense Hut-Add-On-Board, einem 40-poligen Header für Mann zu Frauen und einigen Schrauben und Abstandshaltern geliefert.

Bevor Sie das Sense-Hutbrett dem Raspberry Pi anbringen können, müssen Sie den 40-poligen Header mit dem Sense-Hut verbinden. Verbinden Sie die männlichen Stifte des 40-poligen männlichen Kopfballs mit dem Sinneshut, wie in den folgenden Bildern gezeigt.

Raspberry PI-Single-Board-Computer verfügen über 4 Löcher, mit denen Add-On-Boards oder ein Gehäuse angeschlossen werden können. Um die Add-On-Platine anzubringen, setzen Sie Schrauben von der Rückseite des Raspberry PI ein, wie in den folgenden Bildern gezeigt.

Schließen Sie dann einen Abstandshalter an die Schraube an.

Sobald Sie alle vier Schrauben und Abstandshalter hinzugefügt haben, sollte Ihr Himbeer -Pi wie das im Bild unten gezeigten Aussehen aussehen.

Verbinden Sie den Raspberry Pi Sense-Hut mit dem 40-poligen GPIO-männlichen Header des Himbeer-Pi, wie in den folgenden Bildern gezeigt.

NOTIZ: Seien Sie vorsichtig, während Sie den Himbeer-Sense-Hut vom Himbeer-GPIO-Header trennen, um zu vermeiden.

Befestigen.

Auf dem Raspberry Pi einschalten

Wenn der Raspberry Pi Sense -Hut mit dem Raspberry PI verbunden ist, setzen Sie die microSD -Karte mit Raspberry PI OS in den microSD -Kartensteck.

Installation der Raspberry Pi Sense Hat Python Library

Um Raspberry Pi Sense Hut auf dem Raspberry Pi zu verwenden, die Sinneshut Die Python -Bibliothek muss auf dem Raspberry Pi OS installiert werden. Der Sinneshut Die Bibliothek ist im offiziellen Paketrepository von Raspberry Pi OS erhältlich.

So installieren Sie den Raspberry Pi Sinneshut Python Library auf dem Raspberry Pi -Betriebssystem aktualisieren Sie zuerst den APT -Paket -Repository -Cache mit dem folgenden Befehl:

$ sudo APT Update

Führen Sie dann den folgenden Befehl aus:

$ sudo apt installieren

Installation der Python -Bibliothek von Flask Micro Web Framework

Wir werden das Flask Python Framework verwenden, um unsere Wetteranwendung zu erstellen. Sie können den Kolben aus dem offiziellen Paket -Repository von Raspberry Pi OS mit dem folgenden Befehl installieren:

$ sudo apt installieren Sie Python3 -Flask -y -y

Erstellen eines Projektverzeichnisses

Es ist eine gute Idee, ein Projektverzeichnis zu erstellen, um Ihre Projektdateien zu organisieren. Ein Projektverzeichnis erstellen ~/Arbeit, Verwenden Sie den folgenden Befehl:

$ mkdir ~/Arbeit

Sobald das Projektverzeichnis erstellt wurde, navigieren Sie wie folgt zum Projektverzeichnis:

$ CD ~/Arbeit

Testen Sie den Raspberry Pi Sense Hut

Um zu testen, ob der Raspberry Pi Sense -Hut funktioniert, können wir ein einfaches Testpython -Skript schreiben. Sie können ein neues Python -Skript namens erstellen prüfen.py mit dem Nano Texteditor wie folgt:

$ nano test.py

Geben Sie den folgenden Code in den ein prüfen.py Datei. Zeile 1 Importe Sensehat von dem Sense_hat Modul, Zeile 3 erstellt a Sensehat Objekt und speichert eine Referenz in der Sinn Variable und Zeilen 5-6 setzen die Farbe aller 8 × 8 LEDs auf rot. Sobald Sie fertig sind, drücken Sie + X gefolgt von Y Und .

Sie können die ausführen prüfen.py Python -Skript mit dem folgenden Befehl:

$ python3 Test.py

Die 8 × 8 -LED -Matrix sollte in roter Farbe leuchten, wie im Bild unten gezeigt.

Um die LEDs des Sense -Huts auszuschalten, laufen Sie die klar() Methode ohne Farbwert in der prüfen.py Python -Skript, wie im Screenshot unten gezeigt, und führen Sie die aus prüfen.py Python Drehbuch wieder.

Die LEDs des Sense -Hutes sollten nun ausgeschaltet werden, wie im Bild unten gezeigt.

Wenn der Sense -Hut richtig funktioniert, fahren Sie mit dem nächsten Abschnitt fort.

Wetterdaten aus Sense Hut erhalten

Sie können Sensordaten aus dem Sense -Hut sehr leicht erhalten, indem Sie die verwenden Sinneshut Python Library. Um Sensordaten aus dem Sense -Hut abzurufen, können Sie ein neues Python -Skript erstellen read_sensor_data.py folgendermaßen:

$ nano read_sensor_data.py

Geben Sie den folgenden Code in den ein read_sensor_data.py Python -Datei.

von Sense_hat Import Sensehat
Zum Zeitpunkt des Imports
Sense = sensehat ()
Sinn.klar()
während wahr:
tempc = Sinn.get_temperature ()
tempf = tempc * (9/5) + 32
Druck = Sinn.get_pressure ()
Luftfeuchtigkeit = Sinn.Get_Heuchtung ()
Druck ("Temperatur: %.2f ° C/%.2f ° F \ n " % (tempc, tempf))
drucken ("Druck: %.2f mb \ n " % (Druck))
drucken ("Luftfeuchtigkeit: %.2f %% \ n \ n "%(Feuchtigkeit))
Schlaf (5)

Sobald Sie fertig sind, drücken Sie + X gefolgt von Y Und .

Im obigen Code importieren Zeilen 1 und 2 alle erforderlichen Bibliotheken, Zeile 4 erstellt a Sensehat Objekt und Zeile 5 schaltet alle LEDs des Sense -Hutes aus, die mit dem klar() Methode. Die while-Schleife in Zeile 7 ist eine unendliche Schleife, die den Code in den Zeilen 8-16 für immer ausführt.

In Zeile 8 die get_temperature () Die Methode wird verwendet, um die Temperaturdaten (in Grad Celsius) aus dem Feuchtigkeitssensor des Sinneshuts zu lesen. In Zeile 9 werden die Temperaturdaten von Grad Celsius in Grad Fahrenheit umgewandelt. In Zeile 10 die get_pressure () Die Methode wird verwendet, um die Luftdruckdaten (in Millibar) aus dem Drucksensor des Sense -Hutes zu lesen. In Zeile 11 die Get_Heuchtung () Die Methode wird verwendet, um die Feuchtigkeitsdaten (in %) aus dem Feuchtigkeitssensor des Sinneshuts zu lesen.

Zeilen 13-15 werden verwendet, um die Sensordaten in die Konsole zu drucken.

Sie können die ausführen read_sensor_data.py Python -Skript wie folgt:

$ python3 read_sensor_data.py

Sobald das Skript ausgeführt wird, werden Sensordaten in die Konsole gedruckt.

Nachdem wir die Sensordaten aus dem Sense -Hut lesen können, drücken Sie + C das Programm stoppen.

Erstellen einer Wetterstation Web App

In diesem Abschnitt zeigen wir Ihnen, wie Sie das Web -Framework von Python Flask verwenden, um eine Wetter -API und eine Wetteranwendung zu erstellen. Die Wetteranwendung greift auf die Wetterdaten -API zu und zeigt die Wetterdaten in Echtzeit an. Der gesamte in diesem Abschnitt erörterte Code ist in GitHub unter Shovon8/Himbeer-Pi-Sensse-Hut-Weather-App verfügbar.

Erstellen Sie zunächst a Server.py Python -Skript im Projektverzeichnis wie folgt:

$ nano Server.py

Geben Sie den folgenden Code in den ein Server.py Python -Datei.

aus Flask -Importkolben
Aus Flask Import Jsonify
Aus Flask Import Render_Template
Aus Flask Import URL_FOR
von Sense_hat Import Sensehat
app = Flask (__ Name__)
App.config ['send_file_max_age_default'] = 0
Sense = sensehat ()
Sinn.klar()
mit App.test_request_context ():
url_for ('static', Dateiname = 'Stil.CSS ')
url_for ('static', Dateiname = 'App.JS ')
@app.Route ('/api')
Def api ():
tempc = Sinn.get_temperature ()
tempf = tempc * (9/5) + 32
Druck = Sinn.get_pressure ()
druckpsi = druck * 0.0145038
druckp = druck * 100
Luftfeuchtigkeit = Sinn.Get_Heuchtung ()
Gibt JSonify zurück (
"Temperatur": "C": tempc, "f": tempf,
"Druck": "Mb": Druck, "HPA": Druck,
"psi": druckpsi, "p": druckp,
"Feuchtigkeit": Feuchtigkeit
)
@app.Route('/')
Def Home ():
return render_template ('./heim.html ')

Dann drücken + X gefolgt von Y Und um die zu retten Server.py Python -Skript.

Im obigen Code, Zeilen 1-5 importieren alle erforderlichen Bibliotheken, Zeile 7 erstellt eine Flask-App, Zeile 11 erstellt ein SinneHat-Objekt, und Zeile 12 schaltet alle LEDs des Sinneshut. Zeile 8 deaktiviert das Web -Caching für die Flask -App. Da diese App leicht ist, ist kein Zwischenspeichern erforderlich. Wenn Sie die App ändern möchten, erleichtert das Unterlagern von Web -Caching die Tests erheblich.

Zeilen 18-31 Lesen Sie die Sensordaten aus dem Sense Hut und geben Sie die API-Daten im JSON-Format auf HTTP GET-Anforderung in den zurück /API Endpunkt des Webservers. Zeilen 37-39 geben die Weather Web-App-Homepage auf dem / Endpunkt des Webservers. Die Homepage wird von der gerendert heim.html Datei, die in der sein sollte Vorlagen/ Verzeichnis des Projektverzeichnisses.

Zeilen 14-16 werden verwendet, um den Zugriff auf die zu ermöglichen Stil.CSS Und App.JS Statische Dateien. Diese Dateien sollten in der sein statisch/ Verzeichnis des Projektverzeichnisses. Der Stil.CSS Datei wird verwendet, um die zu stylen heim.html Homepage und die App.JS Die Datei wird verwendet, um die API -Daten aus dem anzufordern /API Endpunkt und aktualisieren Sie die Wetterdaten auf der heim.html Seite alle 5 Sekunden.

Erstellen die statisch/ Und Vorlagen/ Verzeichnis im Projektverzeichnis wie folgt:

$ mkdir -v static, templates

Ein ... kreieren heim.html Datei in der Vorlagen/ Verzeichnis wie folgt:

$ nano Vorlagen/Zuhause.html

Geben Sie den folgenden Code in den ein heim.html Datei.

href = "url_for ('static', Dateiname =" Stil.CSS ")"/>

Himbeer -Pi -Wetterstation

Temperatur

…


…

Druck

…


…




…


…

Feuchtigkeit

…

Dann drücken + X gefolgt von Y Und um die zu retten heim.html Datei.

Ein ... kreieren Stil.CSS Datei in der statisch/ Verzeichnis wie folgt:

$ nano statisch/stil.CSS

Geben Sie die folgenden Codes in die ein Stil.CSS Datei.

@import URL ('https: // Schriftarten.googleapis.com/css2?family = Roboto & display = Swap ');
*
Polsterung: 0;
Rand: 0;
Schriftfamilie: 'Roboto', sans-serif;

Körper
Hintergrund: #737373;

H1
Bildschirmsperre;
Farbe: #79dc7b;
Text-Align: Mitte;
Schriftgewicht: 400;
Hintergrund: #000;
Polsterung: 0.5em 0;

H2
Bildschirmsperre;
Hintergrund: #000;
Farbe: #fff;
Text-Align: Mitte;
Schriftgewicht: 400;
Schriftgröße: 1EM;

.Datenbekämpfung
Rand: 10px;
Grenze: 2px solide Schwarz;
Border-Radius: 5px;
Hintergrundfarbe: #79dc7b;

.Datenreihe
Anzeige: Flex;
Flex-Richtung: Reihe;

.Datenzell
Breite: 100%;
Höhe: 80px;
Anzeige: Flex;
Ausrichtung: Zentrum;
Justify-Content: Center;
Schriftdicke: fett;
Schriftgröße: 1.5em;
Farbe: #006902;

.Datenzell: Hover
Hintergrund: #ffe891;
Farbe: #AA8600;
Cursor: Zeiger;

Dann drücken + X gefolgt von Y Und um die zu retten Stil.CSS Datei.

Erstelle ein App.JS Datei in der statisch/ Verzeichnis wie folgt:

$ nano static/App.JS

Geben Sie den folgenden Code in den ein App.JS Datei.

Fenster.AddEventListener ('Load', Main);
Funktion main ()
Funktion getAapidata ()
var http = new xmlhttprequest ();
http.onReadyStatechange = function ()
if (das.ReadyState === 4 && dies.Status === 200)
Update (JSON.analysieren (das.Responsext));


http.offen ("get", "/api", wahr);
http.schicken();

Funktion update (apidata)
var tempc = dokument.GetElementById ("tempc");
var tempf = dokument.GetElementById ("tempf");
var druckeneMb = Dokument.GetElementById ("Pressuremb");
var druckpsi = dokument.GetElementById ("druckpsi");
var druckhpa = dokument.GetElementById ("druckHPA");
var druckp = dokument.GetElementById ("druckp");
var feuchtigkeit = dokument.GetElementById ("Feuchtigkeit");
tempc.Innerhtml = Parsefloat (Apidata.Temperatur.C).tofixiert (2) + "° C";
tempf.Innerhtml = Parsefloat (Apidata.Temperatur.F).tofixiert (2) + "° F";
Druckung.Innerhtml = Parsefloat (Apidata.Druck.mb).tofixiert (2) + "mb";
Druckspsi.Innerhtml = Parsefloat (Apidata.Druck.psi).tofixiert (2) + "psi";
DruckHPA.Innerhtml = Parsefloat (Apidata.Druck.HPA).tofixiert (2) + "HPA";
Druck.Innerhtml = Parsefloat (Apidata.Druck.P).tofixiert (2) + "P";
Feuchtigkeit.Innerhtml = Parsefloat (Apidata.Feuchtigkeit).tofixiert (2) + " %";

Funktion App ()
Fenster.setInterval (function ()
Getapidata ();
, 5000);

app ();

Dann drücken + X gefolgt von Y Und um die zu retten App.JS Datei.

Hier leitet Zeile 1 die hauptsächlich() Funktion, wenn die Webseite das Laden beendet. Im hauptsächlich() Funktion, die Getapidata () Funktion holt die Wetter -API -Daten mit AJAX ab und ruft die auf aktualisieren() Funktion (in Zeile 10), sobald die Daten erfolgreich abgerufen wurden. Der aktualisieren() Funktion aktualisiert das Webseitenelement mit den API -Daten.

In Zeile 20 die dokumentieren.GetElementById () Die Methode wird verwendet, um die Referenz des Webseitenelements mit der ID zu erhalten tempc. Zeile 28 wird verwendet, um den Inhalt des Webseitenelements mit der ID zu ersetzen tempc mit der Temperatur (in Celsius) der API. Auf die gleiche Weise werden der Inhalt aller Webelemente (Zeilen 21-26) durch ihre jeweiligen API-Daten ersetzt.

Im app () Funktion, die Getapidata () wird alle 5 Sekunden (5000 Millisekunden) bezeichnet, um die Wetterdaten in der Wetter -App auf dem neuesten Stand zu halten. Schließlich in Zeile 46 die app () Funktion wird ausgeführt.

Geben Sie den folgenden Befehl ein, um die Web -App zu testen:

$ Flask_app = server.Py Flask Run -Host = 0.0.0.0

Die Wetter -App sollte auf Port 5000 ausgeführt werden (standardmäßig).

Um zu testen, ob die Wetter -API funktioniert, führen Sie den folgenden Befehl aus:

$ curl -s http: // localhost: 5000/api | JSON_PP

Wie Sie sehen können, werden die Wetter -API -Daten in die Konsole gedruckt. Daher funktioniert die API.

Um die Wetter -App zu testen, besuchen Sie http: // localhost: 5000 aus einem Chromium -Webbrowser. Die Wetter -App sollte im Webbrowser geladen werden, aber zunächst sollten keine Wetterdaten angezeigt werden.

Nach einigen Sekunden sollte die Wetter -App die Wetterdaten von der API abrufen und sie anzeigen.

Zu jedem Zeitpunkt können Sie drücken + C So stoppen Sie den Webserver.

Erstellen des Systemd -Dienstes für die Weather Web App

In diesem Abschnitt zeigen wir Ihnen, wie Sie eine Systemd -Dienstdatei für die Wetter -App erstellen, damit sie automatisch mit dem Booten beginnen.

Erstellen Sie zunächst a Wetterstation.Service Datei in Ihrem Projektverzeichnis wie folgt:

$ nano Wetterstation.Service

Geben Sie die folgenden Codezeilen in die ein Wetterstation.Service Datei.

[Einheit]
Beschreibung = Raspberry Pi Wetterstation Web -App mit Raspberry Pi Sense Hut
Nach = Netzwerk.Ziel
[Service]
WorkingDirectory =/Home/Pi/Arbeit
Umgebung = Flask_app = Server.py
Umgebung = Flask_env = Produktion
Execstart =/usr/bin/flask run – -host = 0.0.0.0
StandardOutput = inherit
StandardError = Erben
Neu starten = immer
User = pi
[Installieren]
Wantby by = multi-user.Ziel

Dann drücken + X gefolgt von Y Und um die zu retten Wetterstation.Service Datei.

Kopiere das Wetterstation.Service Datei an der /etc/systemd/system/ Verzeichnis mit dem folgenden Befehl:

$ sudo cp -v Wetterstation.Service/etc/systemd/system/

Laden Sie die Systemd -Daemons neu, damit die Änderungen wie folgt wirksam werden:

$ sudo systemctl Daemon-Reload

Der Wetterstation Der Systemd -Service sollte momentan inaktiv sein, wie im Screenshot unten gezeigt.

$ sudo systemctl Status Wetterstation.Service

Starte das Wetterstation Service mit dem folgenden Befehl:

$ sudo systemctl starten wetterstation.Service

Wie Sie sehen können, die Wetterstation Der Service läuft jetzt.

$ sudo systemctl Status Wetterstation.Service

Jetzt, wo die Wetterstation Der Service funktioniert, Sie können ihn zum Systemstart von Raspberry Pi OS mit dem folgenden Befehl hinzufügen:

$ sudo systemCTL Aktivieren Sie die Wetterstation.Service

Starten Sie Ihren Raspberry Pi mit dem folgenden Befehl neu:

$ sudo Neustart

Sobald Ihre Raspberry Pi Stiefel, die Wetterstation Der Service sollte ausgeführt werden, wie im Screenshot unten gezeigt.

$ sudo systemctl Status Wetterstation.Service

Zugriff auf die Wetter -App von anderen Geräten aus

Um auf die Wetter -App von anderen Geräten in Ihrem Heimnetzwerk zuzugreifen, müssen Sie die IP -Adresse Ihres Raspberry Pi kennenlernen. Sie finden die IP -Adresse Ihres Raspberry Pi 4 von der Web -Management -Oberfläche Ihres Heimrouters. In unserem Fall ist die IP -Adresse 192.168.0.103, aber diese Adresse wird für Sie unterschiedlich sein. Ersetzen Sie diese Adresse daher in allen nachfolgenden Schritten durch Ihre Adresse.

Wenn Sie Zugriff auf die Raspberry PI -Konsole haben, können Sie den folgenden Befehl ausführen, um auch die IP -Adresse zu finden.

$ hostname -i

Sobald Sie die IP -Adresse Ihres Raspberry PI kennen, können Sie von jedem Gerät in Ihrem Heimnetzwerk darauf zugreifen. Wie im folgenden Screenshot gezeigt, haben wir auf die Wetter -App von einem Android -Smartphone zugegriffen.

Abschluss

In diesem Artikel haben wir Ihnen gezeigt, wie Sie mit dem Raspberry Pi Sense Hut eine Himbeer -Pi -Wetterstation bauen können. Wir haben die benutzt Sinneshut Python -Bibliothek zum Extrahieren von Wetterdaten aus dem Raspberry Pi Sense Hut. Dann haben wir das Flask Python Micro Web Framework verwendet, um eine Wetter -API und eine Webanwendung zu erstellen. Die Web -App erhält alle 5 Sekunden die Wetterdaten von der Wetter -API, um die Web -App mit den neuesten Wetterdaten auf dem Laufenden zu halten.