Raspberry Pi: SenseHat
Der SenseHat ist ein Erweiterungsboard für den Raspberry Pi, das sowohl mit dem Model B als auch mit dem Pi Zero kompatibel ist. Der SenseHat lässt sich dabei direkt auf die GPIO-Leiste aufstecken oder mit einem 40 Pin Flachbandkabel extern betreiben. Das Board besitzt eine 8×8 LED-Matrix, ein Gyroscope, einen Beschleunigungs-, Temperatur-, Feuchtigkeits-, Luftdruck- und Magnetsensor. Damit lassen sich viele kleine nützliche Projekte realisieren.
In diesem Beitrag zeige ich dir wie du Temperatur-, Luftfeuchtigkeits-, und Luftdruckwerte ausliest und diese auf der LED-Matrix einblendest. Der Gyroscope-Sensor kann dabei genutzt werden, um den Text immer lesbar auf dem Display anzuzeigen. Der Magnetsensor wird in diesem Beitrag nicht behandelt.
Inhaltsverzeichnis
Voraussetzung
Dieser Beitrag befasst sich mit dem SenseHat auf einem Raspberry Pi. Es wird davon ausgegangen, dass Raspbian bereits installiert ist und auf den Pi entweder direkt mit Monitor und Maus oder mittels SSH über Netzwerk zugegriffen werden kann.
Außerdem ist es sinnvoll, wenn du dich bereits etwas mit Python auskennst, da wir die Sensoren des SenseHat in einem Python-Skript auslesen. Dazu stellt uns der Hersteller eine eigene Bibliothek zur Verfügung.
SenseHat
Der SenseHat ist ein Experimentierboard, der viele Sensoren und eine LED-Matrix bildet. Damit lässt sich auf sehr einfache Weise (dank der fertigen Python Bibliothek) mit Sensoren arbeiten und du lernst schnell mit den Werten umzugehen. Das Board soll offiziell nicht bei negativen Temperaturen betrieben werden. Daher eignet es sich nur bedingt für den Außeneinsatz. Solltest du eine kleine Wetterstation damit planen, musst du außerdem dafür sorgen, dass es nicht nass wird. Ich selbst hatte es ohne weiteres Gehäuse unter einem Dach einige Monate auf der Nordseite des Hauses in Betrieb.
Wenn du das Board mit einem Kabel an den Raspberry Pi anschließt so wie ich oben im Bild, achte auf die richtige Orientierung des Steckers. Sollte das Board falsch herum angeschlossen werden (die Position des Steckers also um 180° gedreht sein), leuchtet die LED-Matrix dauerhaft bunt und das Board ist nicht benutzbar.
Außerdem musst du das Board in der Bootdatei aktiveren. Öffne dafür folgende Datei mit dem vorinstallierten Editor nano. Du kannst bei Bedarf auch einen anderen installierten Editor nutzen.
sudo nano /boot/config.txtErgänze ganz unten folgende Zeile, damit der SenseHat vom System erkannt wird.
dtoverlay=rpi-senseAnschließend starte den Raspberry Pi neu.
sudo reboot nowPython Bibliothek
Die vom Hersteller zur Verfügung gestellte Bibliothek, ermöglicht ein sehr einfaches Auslesen aller verbauten Sensoren. Ich gebe im folgenden Listing zunächst einen Überblick über die wichtigsten Funktionen, die wir anschließend in einem Skript verwenden werden.
#Sensehat Bibliothek einbinden
from sense_hat import SenseHat
#Sensehat initialisieren. Der Aufruf der Funktionen
#erfolgt dann nach dem Schema: sense.Funktion()
sense = SenseHat()
#LED-Matrix ausschalten
sense.clear()
#Lese Temperatur aus
sense.get_temperature()
#Lese Temperatursensor des Luftfeuchtigkeitssensors aus
sense.get_temperature_from_humidity()
#Lese Temperatursensor des Luftdrucksensors aus
sense.get_temperature_from_pressure()
#Lese Luftfeuchtigkeitssensor aus
sense.get_humidity()
#Lese Luftdrucksensor aus
sense.get_pressure()
#Lese Magnetsensor aus. Achtung, dieser muss zuerst kalibriert werden
sense.get_compass()
#Warte auf ein Joystick event
sense.stick.wait_for_event()
#Lese Eventliste aus seit letzer Ausführung dieser Funktion
sense.stick.get_events()
#Reagiere auf den nach oben gedrückten Joystick
event.direction == 'up'
#Reagiere auf den gedrückten Joystick
event.action == 'pressed'
#Setze die gesamte LED-Matrix. Diese Funktion erwartet
#das LED-Muster als array
sense.set_pixels(LEDpattern)
#LED links oben rot setzen. Diese Funktion erwartet die Koordinaten
#und die Farbe als RGB Werte
sense.set_pixel(x, y, 255, 0, 0)
#Zeige eine Laufschrift von rechts nach links auf der LED-Matrix
sense.show_message("Hello, Sense HAT!")
#Lese x-Achse des Gyrosensors aus und runde das Ergebnis auf
#0 Stellen nach dem Komma
sense.get_accelerometer_raw()['x'], 0)
#Rotiere die LED-Anzeige um den Winkel angle. Angabe des Winkels
#erfolgt in Grad
sense.set_rotation(angle)
Python Skript anlegen
Zunächst legen wir im Homeverzeichnis ein neues Pythonscript an und nennen es sensehat.py.
sudo nano sensehat.pyDarin schreiben wir jetzt unseren Pythoncode. Zunächst importieren wir dazu ein paar Bibliotheken, die wir später noch benötigen werden. Der SenseHat muss anschließend initialisiert werden. Zusätzlich löschen wir die LED-Matrix, sodass sie beim Start des Skripts immer ausgeschaltet wird.
#############################################################
#Initialisation##############################################
#############################################################
#!/usr/bin/python
# -*- coding: utf-8 -*-
from sense_hat import SenseHat #Sensehat Bibliothek
import time #to get system time
import os #to get cpu temperature
#Connect to SenseHat
sense = SenseHat()
#Clear LEDs
sense.clear()
Anschließend ergänzen wir einen Block, in dem wir alle Funktionen definieren, die beim Ausführen des Skripts ausgeführt werden. Es ist auch möglich ohne Funktionen zu arbeiten. Funktionen erhöhen jedoch die Übersichtlichkeit eines Skripts erheblich.
Wir legen zunächst nur eine Funktion an, um die Temperatur vom SenseHat abzufragen.
Temperatur
Tatsächlich hat der Sensehat zwei Temperatursensoren – einen beim Feuchtigkeits- und einem beim Drucksensor. Aus diesem Grund lesen wir einfach beide Sensoren aus und ermitteln daraus den Mittelwert. Anschließend gibt die Funktion den ermittelten Temperaturwert zurück. Die Funktionen geben einen Wert in der Einheit °C an.
#############################################################
#define functions############################################
#############################################################
#Get sensehat temperature as average from humidity and pressure sensor
def get_sensehat_temperature():
temp_humidity = float(sense.get_temperature_from_humidity() ) #in degree C
temp_pressure = float(sense.get_temperature_from_pressure() ) #in degree C
temperature_sensehat = (temp_humidity+temp_pressure)/2
return(temperature_sensehat)
Nun können wir eine while-Schleife erstellen, die unendlich ausgeführt wird und alle 5 Sekunden eine Ausgabe im Terminal macht.
#############################################################
#main loop###################################################
#############################################################
while True:
#Get temperature from sensehat
temperature_sensehat = get_sensehat_temperature()
#Print values in the command line
print("Temperatur: ",temperature_sensehat,"C")
#Clear LED-matrix and wait 5 seconds for the next cycle
sense.clear()
time.sleep(5)
Speichere und schließe die Datei mit [STRG+X], bestätige mit [Y] und dann mit [Enter].
Als nächstes machen wir die Datei noch ausführbar.
sudo chmod +x /home/pi/sensehat.pyNun können wir das Skript bereits ausführen und uns die aktuellen Messwerte anzeigen lassen. Rufe dazu das Skript folgendermaßen auf.
sudo python /home/pi/sensehat.pyWenn du den Sensehat direkt auf dem Pi montiert hast, wird dir jetzt auffallen, dass der Temperaturwert deutlich zu hoch ist. Der Grund ist die CPU des Raspberry Pi, die unterhalb des SenseHat liegt und Wärme abstrahlt. Die CPU wird je nach Last zwischen 38 °C und im Extremfall über 60 °C heiß. Dies ist auch abhängig vom verwendeten Pi. In meinem Fall ist das ein Raspberry Pi 3 Model B.
Den Einfluss der Prozessorwärme kannst du umgehen, wenn du das Board mit einem Kabel anschließt, andernfalls musst du einen Faktor ermitteln, um die Temperatur zu korrigieren wie ich nachfolgend zeige.
Temperatur korrigieren
Mit der Folgenden Formel kann eine korrigierte Temperatur berechnet werden, indem der Einfluss der CPU-Wärme berücksichtigt wird. Der Korrekturfaktor F ist bei mir etwa 1,5. In anderen Foren und Tutorials findest du mitunter andere Werte. Am besten ist es, wenn du ein zweites Thermometer neben den SenseHat legst und verschiedene Korrekturwerte ausprobierst bis einer einigermaßen passt.
T_{Korrigiert} = T_{Sense} - \frac{T_{CPU}-T_{Sense}}{F_{Korrektur}}Beachte, dass die Korrektur nur eine Annäherung an die eigentliche Temperatur ist, da hier von einer linearen Abhängigkeit ausgegangen wird. Genauer ist es sicherlich, wenn du den SenseHat nicht direkt auf dem Pi betreibst.
Damit wir den Temperaturwert korrigieren können, müssen wir die Temperatur der CPU des Pi auslesen. Dazu legen wir eine weiterr Funktion an. Dort lesen wir mit der importierten Bibliothek „os“ den Wert aus. Der Wert wird innerhalb eines Strings ausgegeben, sodass wir den überflüssigen Text entfernen und den Wert in einen float() umwandeln müssen.
#Get CPU temperature
def get_cpu_temperature():
temp_cpu = os.popen("vcgencmd measure_temp").readline() #in Celsius degree
temperature_cpu = float(temp_cpu.replace("temp=","").replace("'C","") )
return(temperature_cpu)
In der Schleife unten im Skript können wir jetzt die Temperatur der CPU abfragen und mit der obigen Formel den korrigierten Temperaturwert berechnen. Wir runden den berechneten Wert noch auf eine Stelle nach dem Komma.
#############################################################
#main loop###################################################
#############################################################
while True:
#Get temperature from sensehat
temperature_sensehat = get_sensehat_temperature()
#Get temperature from the cpu
temperature_cpu = get_cpu_temperature()
#Calculate corrected temperature
temperature_corrected = round(temperature_sensehat - ( (temperature_cpu - temperature_sensehat)/1.50),1)
#Print values in the command line
print("Temperatur: ",temperature_corrected,"C")
#Clear LED-matrix and wait 5 seconds for the next cycle
sense.clear()
time.sleep(5)
Luftfeuchtigkeit und Luftdruck
Für die Abfrage des Feuchtigkeitssensors legen wir ebenfalls eine Funktion an.
Der Luftfeuchtigkeitssensor gibt bei der ersten Abfrage manchmal den Wert 0 zurück. Daher wird dieser hier zwei mal angesprochen, um auf jeden Fall einen Wert zu erhalten. Den Feuchtigkeitswert musst du außerdem ebenfalls korrigieren, wenn du den SenseHat auf dem Pi aufgesteckt hast. Die Wärme der CPU führt nämlich zu einer Verdunstung der in der Luft gebundenen Feuchtigkeit. Den Korrekturwert von 15% habe ich selbst nicht nachgemessen, sondern aus einem Forenbeitrag entnommen.
#Get corrected humidity
def get_humidity():
humidity = round(sense.get_humidity(),1) #returns sometimes 0
time.sleep(1)
humidity = round(sense.get_humidity(),1) #in percent
humidity_corrected = humidity+15 #correction for CPU temperature
return(humidity_corrected)
Um den Luftdrucksensor abzufragen, müssen wir hingegen keine Funktionen anlegen. Entsprechend erweitern wir die Schleife folgendermaßen.
#############################################################
#main loop###################################################
#############################################################
while True:
#Get temperature from sensehat
temperature_sensehat = get_sensehat_temperature()
#Get temperature from the cpu
temperature_cpu = get_cpu_temperature()
#Calculate corrected temperature
temperature_corrected = round(temperature_sensehat - ( (temperature_cpu - temperature_sensehat)/1.50),1)
#Get humidity
humidity_corrected = get_humidity()
#Get airpressure
airpressure = round(sense.get_pressure(),1) #in hPa
#Print values in the command line
print("Temperatur: ",temperature_corrected,"C")
print("Luftfeuchtigkeit: ",humidity_corrected,"%")
print("Luftdruck: ",airpressure,"hPa")
#Clear LED-matrix and wait 5 seconds for the next cycle
sense.clear()
time.sleep(5)
LED-Matrix
Die Ausgabe auf der Konsole ist natürlich nicht besonders praktisch. Schließlich soll der Pi zusammen mit dem SenseHat ohne angeschlossenen Monitor funktionieren und besonders ansehnlich und übersichtlich ist die Konsole auch nicht.
Daher werden wir uns jetzt darum kümmern, die ausgelesenen Werte auf der LED-Matrix anzuzeigen. Dies ist natürlich nur sehr bedingt möglich und wir werden nur Zahlen anzeigen. Damit die angezeigten Werte auch den richtigen Sensoren zugeordnet werden können, stellen wir die Messwerte in unterschiedlichen Farben dar. So könnte die Temperatur etwa in rot, die Luftfeuchtigkeit in blau und der Luftdruck in gelb dargestellt werden. Theoretisch kannst du die Farben auch abhängig vom Messwert machen, sodass hohe Temperaturen in rot und niedrigere Temperaturen in violett oder blau dargestellt werden.
Dazu definieren wir neue Variablen ganz oben unter Initialisation. Wir müssen für alle Ziffern von 0 bis 9 das Bitmuster angeben, so wie die Zahlen auf der LED-Matrix angezeigt werden sollen. Außerdem müssen wir die Matrix selbst als 8×8-Bitmuster definieren. Zuletzt müssen schließlich die Farben als RGB-Werte angegeben werden.
#Define LED patterns
#Define the appearing of the digits
led_numbers = [
0,1,1,1, # Zero
0,1,0,1,
0,1,0,1,
0,1,1,1,
0,0,1,0, # One
0,1,1,0,
0,0,1,0,
0,1,1,1,
0,1,1,1, # Two
0,0,1,1,
0,1,1,0,
0,1,1,1,
0,1,1,1, # Three
0,0,1,1,
0,0,1,1,
0,1,1,1,
0,1,0,1, # Four
0,1,1,1,
0,0,0,1,
0,0,0,1,
0,1,1,1, # Five
0,1,1,0,
0,0,1,1,
0,1,1,1,
0,1,0,0, # Six
0,1,1,1,
0,1,0,1,
0,1,1,1,
0,1,1,1, # Seven
0,0,0,1,
0,0,1,0,
0,1,0,0,
0,1,1,1, # Eight
0,1,1,1,
0,1,1,1,
0,1,1,1,
0,1,1,1, # Nine
0,1,0,1,
0,1,1,1,
0,0,0,1
]
# Definition of the LED-matrix pattern. The Sensehat has 8x8 matrix
led_image = [
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0
]
#Definition of digit colors
red = [255,0,0] # Red
green = [0,255,0] # Green
yellow = [255,255,0] # Yellow
cyan = [0,255,255] # Cyan
empty = [0,0,0] # LEDs turned off
Außerdem müssen wir weitere Funktionen definieren. Zunächst eine Funktion, die den Gyrosensor ausliest und anschließend die Anzeige rotiert, sodass später die Zahlen für den Betrachter immer richtig herum angezeigt werden.
#Rotate the display according to orientation to the viewer
def auto_rotate_display():
# read sensors data to detect orientation
x = round(sense.get_accelerometer_raw()['x'], 0)
y = round(sense.get_accelerometer_raw()['y'], 0)
# Set rotation angle in degree according to x and y value
rot = 0
if x == -1:
rot = 90
elif y == -1:
rot = 180
elif x == 1:
rot = 270
#rotate the display according to the orientation
sense.set_rotation(rot)
Die nächste Funktion berechnet das LED-Bild. Es werden immer genau vier Ziffern dargestellt – zwei in der oberen und zwei in der unteren Zeile. Der Luftdruck von 1013 hPa wird daher aufgeteilt, sodass 10 in der oberen und 13 in der unteren Zeile steht. Dies ist sicherlich nicht ideal, da die Temperatur nur zwei Ziffern benötigt und wir der Funktion entweder eine 0 oder den Temperaturwert doppelt übergeben müssen. Die Funktion kann daher sicherlich noch verbessert werden.
Die Funktion erwartet als Übergabewert die Zahlen jeder Zeile und das 8×8-LED-Image, das wir oben bereits definiert haben.
#calculates the led image for 2 numbers each with 2 digits to display them on the led screen
#show_led_digits(int upper_number,int lower_number,defined_led_digits,8x8 array defined_led_image)
def show_led_digits(line_one,line_two,defined_digits,image):
# Map digits to the clock_image array
pixel_offset = 0
index = 0
for index_loop in range(0, 4):
for counter_loop in range(0, 4):
if (number_one >= 10):
image[index] = defined_digits[int(number_one/10)*16+pixel_offset]
image[index+4] = defined_digits[int(number_one%10)*16+pixel_offset]
image[index+32] = defined_digits[int(number_two/10)*16+pixel_offset]
image[index+36] = defined_digits[int(number_two%10)*16+pixel_offset]
pixel_offset = pixel_offset + 1
index = index + 1
index = index + 4
return image
Als nächstes legen wir noch eine Funktion an, um die Zahlen in der richtigen Farbe darzustellen. Die Zeilen können dabei jeweils separat eingefärbt werden. Als Eingabe erwartet die Funktion das image aus der obigen Funktion und ein array mit drei Farben: Farbe für alle nicht gesetzten LEDs, Farbe der Ziffern in Zeile 1 und Farbe der Ziffern in Zeile 2.
#Defines the colors for each pixel on the led screen
def get_colors(image,colors):
# Color the hours and minutes
for index in range(0,64):
if (clock_image[index]):
if index < 32:
clock_image[index] = colors[1]
else:
clock_image[index] = colors[2]
else:
clock_image[index] = colors[0]
return clock_image
Zuletzt definieren wir noch eine Funktion, die die Anzeige der Messwerte steuert und die obigen Funktionen aufruft. In meinem Beispiel wird die Anzeige nach 5 Sekunden beendet. Diese Funktion liefert keinen Rückgabewert und dient nur der Anzeige auf der LED-Matrix.
def show_values(led_numbers,led_image,colors,value_line1,value_line2):
for i in range(0,5):
auto_rotate_display()
#Get the image for the leds
image = show_led_digits(value_line1,value_line2,led_numbers,led_image)
#Colors the digits on the led screen
image_colored = get_colors(image,colors)
#Display values
sense.low_light = True # Optional: dimmt die LEDs
sense.set_pixels(image_colored)
time.sleep(1)
#leave function
if i == 5:
return
Die Schleife ergänzen wir wie nachfolgend markiert. Die Zeilen für die Ausgabe auf der Konsole kommentieren wir aus, da wir diese nicht mehr benötigen.
Zunächst definieren wir für jeden Wert Temperatur, Luftfeuchtigkeit und Luftdruck einen eigenen Farbarray. Danach rufen wir die Anzeigefunktion show_values() auf und übergeben ihr das jeweilige Farbarray und die Messwerte aus den Sensoren. Die Werte für Temperatur und Luftfeuchtigkeit werden sowohl in der obersten als auch in der untersten Zeile dargestellt – also doppelt angezeigt, da sie ohne Komma nur zweistellig sind. Denkbar wäre auch einen Platzhalterwert für eine der beiden Zeilen zu übergeben. Der Wert für den Luftdruck hingegen ist vierstellig und wird daher auf die obere und die untere Zeile aufgeteilt.
#############################################################
#main loop###################################################
#############################################################
while True:
#Get temperature from sensehat
temperature_sensehat = get_sensehat_temperature()
#Get temperature from the cpu
temperature_cpu = get_cpu_temperature()
#Calculate corrected temperature
temperature_corrected = round(temperature_sensehat - ( (temperature_cpu - temperature_sensehat)/1.50),1)
#Get humidity
humidity_corrected = get_humidity()
#Get airpressure
airpressure = round(sense.get_pressure(),1) #in hPa
#Print values in the command line
#print("Temperatur: ",temperature_corrected,"C")
#print("Luftfeuchtigkeit: ",humidity_corrected,"%")
#print("Luftdruck: ",airpressure,"hPa")
#Define color for each value to make them more unique
temperature_color = [empty,red,red]
humidity_color = [empty,blue,blue]
airpressure_color = [empty,yellow,yellow]
#Show Temperature, humidity and airpressure on row.
#Each for 5 seconds
show_values(led_numbers,led_image,temperature_color,temperature_corrected,temperature_corrected)
show_values(led_numbers,led_image,humidity_color,humidity,humidity)
show_values(led_numbers,led_image,airpressure_color,int(airpressure[0:2]),int(airpressure[2:4]) )
#Clear LED-matrix and wait 5 seconds for the next cycle
sense.clear()
#time.sleep(5)
Joystick Eingaben
Anstatt die Messwerte hintereinander auszugeben, könnte man die Anzeige auf der LED-Matrix mit dem kleinen 5-Wege-Joystick auf dem SenseHat steuern. Nach oben gedrückt, erscheint so z. B. der Temperaturwert für 5 Sekunden, anschließend verschwindet die Anzeige wieder. Nach unten könnten wir den Luftfeuchtigkeitswert anzeigen und nach rechts den Wert des Luftdrucks.
Dazu müssen wir keine weiteren Funktionen anlegen, sondern die Ausgabe auf der LED-Matrix in der Schleife nur abhängig von Joystick-Eingaben anzeigen. Beim Luftdruck prüfen wir ob der Wert dreistellig ist (also Werte <1000 hPa). Ist die Bedingung erfüllt ergänzen wir eine führende Null, da immer genau vier Ziffern dargestellt werden müssen und die Methode sonst an falscher Stelle eine Null einfügt.
#############################################################
#main loop###################################################
#############################################################
while True:
....
#Wait for a joystick event
event = sense.stick.wait_for_event()
#Joystick events to show data on the led screen
if event.direction == 'up' and event.action == 'pressed':
show_values(led_numbers,led_image,temperature_color,temperature_corrected,temperature_corrected)
elif event.direction == 'down' and event.action == 'pressed':
show_values(led_numbers,led_image,humidity_color,humidity,humidity)
elif event.direction == 'right' and event.action == 'pressed':
airpressure = str(int(airpressure) ).replace(".","")
if len(str(airpressure) ) == 3:
airpressure = str("0")+airpressure
show_values(led_numbers,led_image,airpressure_color,int(airpressure[0:2]),int(airpressure[2:4]) )
#Erase led screen to save power
sense.clear()
#time.sleep(5)
Digitale Uhr
Zuletzt zeige ich dir noch wie du auf der Matrix eine digitale Uhr einblendest. So könnte die ganze Zeit die Uhrzeit angezeigt werden bis der Joystick betätigt wird, um einen der Messwerte einzublenden.
Dazu definieren wir zunächst ein eigenes Farbarray für die Uhr. Die Stunden werden in rot, die Minuten in blau angezeigt. Die Funktion zum Warten auf Joystick-Events muss geändert werden. Bei der bisher verwendeten Funktion stick.wait_for_event() bleibt die Schleife stehen bis eine Eingabe am Joystick erfolgt. Bei einer Uhr muss die Schleife jedoch dauerhaft ausgeführt werden. Daher verwenden wir die Funktion get_events(), die einfach eine leere Liste zurück gibt, wenn keine Eingabe erfolgt. Die leere Liste müssen wir anschließend abfangen, damit die Schleife in keinen Fehler läuft.
Unten fragen wir dir aktuelle Zeit ab und übergeben diese statt der Messwerte an die Funktion zum Anzeigen der Ziffern. Für die digitale Uhr muss daher keine weitere Funktion erstellt werden. Zum Schluss muss das sense.clear() auskommentiert werden, da die Uhr sonst alle fünf Sekunden kurz ausgeschaltet wird.
#############################################################
#main loop###################################################
#############################################################
while True:
....
#Define color for each value to make them more unique
temperature_color = (empty,red,red)
humidity_color = [empty,cyan,cyan]
airpressure_color = [empty,yellow,yellow]
clock_color = [empty,red,cyan]
#Wait for a joystick event
event = sense.stick.get_events()
if event != []
event = event[0]
#Joystick events to show data on the led screen
if event.direction == 'up' and event.action == 'pressed':
show_values(led_numbers,led_image,temperature_color,temperature_corrected,temperature_corrected)
elif event.direction == 'down' and event.action == 'pressed':
show_values(led_numbers,led_image,humidity_color,humidity,humidity)
elif event.direction == 'right' and event.action == 'pressed':
airpressure = str(int(airpressure) ).replace(".","")
if len(str(airpressure) ) == 3:
airpressure = str("0")+airpressure
show_values(led_numbers,led_image,airpressure_color,int(airpressure[0:2]),int(airpressure[2:4]) )
#Get the time and display it on the led matrix
hour = time.localtime().tm_hour
minute = time.localtime().tm_min
show_values(led_numbers,led_image,clock_color,hour,minute)
#Erase led screen to save power
#sense.clear()
#time.sleep(5)
Python-Skript Kopiervorlage
Zum Schluss stelle ich nochmal das gesamte Skript zur Verfügung. Du solltest dieses Skript hier kopieren, damit es keine Fehler mit Leerzeichen gibt (was bei Python sehr schnell passieren kann).
#############################################################
#Initialisation##############################################
#############################################################
#!/usr/bin/python
# -*- coding: utf-8 -*-
#import SenseHat, time, os and sys library
from sense_hat import SenseHat
import time
import sys
import os #
#Connect to SenseHat
sense = SenseHat()
#Clear LEDs
sense.clear()
#Define LED patterns
#Define the appearing of the digits
led_numbers = [
0,1,1,1, # Zero
0,1,0,1,
0,1,0,1,
0,1,1,1,
0,0,1,0, # One
0,1,1,0,
0,0,1,0,
0,1,1,1,
0,1,1,1, # Two
0,0,1,1,
0,1,1,0,
0,1,1,1,
0,1,1,1, # Three
0,0,1,1,
0,0,1,1,
0,1,1,1,
0,1,0,1, # Four
0,1,1,1,
0,0,0,1,
0,0,0,1,
0,1,1,1, # Five
0,1,1,0,
0,0,1,1,
0,1,1,1,
0,1,0,0, # Six
0,1,1,1,
0,1,0,1,
0,1,1,1,
0,1,1,1, # Seven
0,0,0,1,
0,0,1,0,
0,1,0,0,
0,1,1,1, # Eight
0,1,1,1,
0,1,1,1,
0,1,1,1,
0,1,1,1, # Nine
0,1,0,1,
0,1,1,1,
0,0,0,1
]
# Definition of the LED-matrix pattern. The Sensehat has 8x8 matrix
led_image = [
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0
]
#Definition of digit colors
red = [255,0,0] # Red
green = [0,255,0] # Green
yellow = [255,255,0] # Yellow
cyan = [0,255,255] # Cyan
empty = [0,0,0] # LEDs turned off
#############################################################
#define functions############################################
#############################################################
#Get sensehat temperature as average from humidity and pressure sensor
def get_sensehat_temperature():
temp_humidity = float(sense.get_temperature_from_humidity() ) #in Celsius degree
temp_pressure = float(sense.get_temperature_from_pressure() ) #in Celsius degree
temperature_sensehat = (temp_humidity+temp_pressure)/2
return(temperature_sensehat)
#Get CPU temperature
def get_cpu_temperature():
temp_cpu = os.popen("vcgencmd measure_temp").readline() #in Celsius degree
temperature_cpu = float(temp_cpu.replace("temp=","").replace("'C","") )
return(temperature_cpu)
#Get corrected humidity
def get_humidity():
humidity = round(sense.get_humidity(),1) #returns sometimes 0
time.sleep(1)
humidity = round(sense.get_humidity(),1) #in percent
humidity_corrected = humidity+15 #correction for CPU temperature
return(humidity_corrected)
#Rotate the display according to orientation to the viewer
def auto_rotate_display():
# read sensors data to detect orientation
x = round(sense.get_accelerometer_raw()['x'], 0)
y = round(sense.get_accelerometer_raw()['y'], 0)
# Set rotation angle in degree according to x and y value
rot = 0
if x == -1:
rot = 90
elif y == -1:
rot = 180
elif x == 1:
rot = 270
#rotate the display according to the orientation
sense.set_rotation(rot)
#calculates the led image for 2 numbers each with 2 digits to display them on the led screen
#show_led_digits(int upper_number,int lower_number,defined_led_digits,8x8 array defined_led_image)
def show_led_digits(line_one,line_two,defined_digits,image):
# Map digits to the clock_image array
pixel_offset = 0
index = 0
for index_loop in range(0, 4):
for counter_loop in range(0, 4):
if (line_one >= 10):
image[index] = defined_digits[int(line_one/10)*16+pixel_offset]
image[index+4] = defined_digits[int(line_one%10)*16+pixel_offset]
image[index+32] = defined_digits[int(line_two/10)*16+pixel_offset]
image[index+36] = defined_digits[int(line_two%10)*16+pixel_offset]
pixel_offset = pixel_offset + 1
index = index + 1
index = index + 4
return image
#Defines the colors for each pixel on the led screen
def get_colors(clock_image,colors):
# Color the hours and minutes
for index in range(0,64):
if (clock_image[index]):
if index < 32:
clock_image[index] = colors[1]
else:
clock_image[index] = colors[2]
else:
clock_image[index] = colors[0]
return clock_image
def show_values(led_numbers,led_image,colors,value_line1,value_line2):
for i in range(0,5):
auto_rotate_display()
#Get the image for the leds
image = show_led_digits(value_line1,value_line2,led_numbers,led_image)
#Colors the digits on the led screen
image_colored = get_colors(image,colors)
#Display values
sense.low_light = True # Optional: dimmt die LEDs
sense.set_pixels(image_colored)
time.sleep(1)
#leave function
if i == 5:
return
#############################################################
#main loop###################################################
#############################################################
while True:
#Get temperature from sensehat
temperature_sensehat = get_sensehat_temperature()
#Get temperature from the cpu
temperature_cpu = get_cpu_temperature()
#Calculate corrected temperature
temperature_corrected = round(temperature_sensehat - ( (temperature_cpu - temperature_sensehat)/1.50),1)
#Calculate calibrated humidity
humidity = get_humidity()
#Get airpressure
airpressure = round(sense.get_pressure(),0) #in hPa
#Print values in the command line
#print("Temperatur: ",temperature_corrected,"C")
#print("Luftfeuchtigkeit: ",humidity_corrected,"%")
#print("Luftdruck: ",airpressure,"hPa")
#Define color for each value to make them more unique
temperature_color = (empty,red,red)
humidity_color = [empty,cyan,cyan]
airpressure_color = [empty,yellow,yellow]
clock_color = [empty,red,cyan]
#Wait for a joystick event
event = sense.stick.get_events()
if event != []:
event = event[0]
#Joystick events to show data on the led screen
if event.direction == 'up' and event.action == 'pressed':
show_values(led_numbers,led_image,temperature_color,temperature_corrected,temperature_corrected)
elif event.direction == 'down' and event.action == 'pressed':
show_values(led_numbers,led_image,humidity_color,humidity,humidity)
elif event.direction == 'right' and event.action == 'pressed':
airpressure = str(int(airpressure) ).replace(".","")
if len(str(airpressure) ) == 3:
airpressure = str("0")+airpressure
show_values(led_numbers,led_image,airpressure_color,int(airpressure[0:2]),int(airpressure[2:4]) )
hour = time.localtime().tm_hour
minute = time.localtime().tm_min
show_values(led_numbers,led_image,clock_color,hour,minute)
#Erase led screen to save power
#sense.clear()
#time.sleep(5)
No Comment