Das Unternehmen Nintendo hat im Jahr 2016 die Spielekonsole Nintendo Classic Mini aufgelegt und in den Verkauf gebracht. Sie ist ein Revival der 8-Bit Ur-Spielekonsole Nintendo Entertainment System aus dem Jahr 1983 (Veröffentlichung in Japan) bzw. 1986 (Veröffentlichung in Europa). Die Ur-NES Konsole hat sich ca. 61 Millionen mal verkauft und wurde 1992 von der SNES (Super Nintendo Entertainment System) einer 16Bit Konsole abgelöst. Die Beliebtheit der Nintendo Konsolen ist scheinbar so groß, dass die Neuauflage mit einem Verkaufspreis von ca. 60 Euro kurz nach der Veröffentlichung ausverkauft war. Hier witterten Geschäftemacher den großen Deal und boten die Geräte über Amazon, eBay und co zu teilweise horrenden Preisen an. Auch jetzt, knapp ein Jahr später sind sie noch nicht unter 100 Euro zu bekommen. Und Nintendo produziert auch keine weiteren Einheiten. Stattdessen hat dasselbe Spiel mit dem Revival der SNES Serie in einer Miniaturausgabe begonnen.
Der NESPI in seiner Verpackung
Es gibt aber auch andere Möglichkeiten, um mit viel weniger Geld in den Besitz einer miniaturisierten Version dieser Konsole zu gelangen. Um ein paar Euro bekommt man ein Gehäuse namens NESPI CASE, das der NES CLASSIC MINI entspricht, jedoch mit einem großen Unterschied: Den Rechner kann man in Form eines Raspberry PI selber einbauen. Damit eröffnen sich unzählige Möglichkeiten mit Emulator Software eigene Konsolen softwaremäße nachzubauen. Das NESPI-Case besitzt einen integrierten 4 Port – USB Hub sowie einen LAN Ethernet Connector, der die Anschlüsse des Raspberry PI nach außen führt. Hierbei sind zwei USB Ports so angeordnet, dass sie als Controller-Anschlüsse dienen. Die weiteren zwei USB Ports sowie der Ethernet Anschluss liegen unter der Geräteklappe, wo einst die Spielemodule eingesteckt wurden. Das Gerät ist mit einem Einschalter mit Power LED sowie einem Reset-Taster ausgestattet.
NESPI Case ausgepacktBedienelemente und Anschlüsse
Das Gehäuse wird mit bereits vormontierten Adapterplatinen geliefert. Auch die Schrauben für die Montage des Raspberry Pi, sowie für die Gehäuseschalen sind im Lieferumfang enthalten. Ein kleiner beiliegender Kreuzschraubendreher, sowie ein Zettel mit einer Montageanleitung machen die Sache noch einfacher.
Raspberry PI im NESPI-Gehäuse
Die Lan und USB- Ports des RaspberryPi werden über die, an den Adapterplatinen befindlichen Kabel samt Steckern nach außen geführt. Sind die Steckverbindungen hergestellt, so kann die RaspberryPI-Platine im Gehäuse verschraubt werden. Optional kann auch noch ein 5VDC Lüfter mit den Abmessungen 30x30x10mm im Gehäusedeckel per Rastnasen befestigt werden. Für die Stromversorgung des Lüfters steht auf der Platine ein zweipoliger Pinheader zur Verfügung. Ist alles eingebaut und angeschlossen, dann kann das Gehäuseoberteil angeschraubt werden.
Raspberry Pi eingebaut
Nun kann die Software eingerichtet werden. Ich bevorzuge hierbei die Images von retropie bzw. recalbox. Nähere Informatinen dazu findet man auf den entsprechenden Webseiten. Sind die gewünschten Emulatoren eingerichtet, so muss man nur mehr die Spieledateien, die sogenannten „Roms“, also binäre Kopien der Spielemodule der einstigen Originalhardware in einer .bin oder .rom oder .iso Datei etc. auf die SD-Karte oder einen USB-Stick kopieren und in die „EmulationStation“ einbinden. Und schon kanns losgehen. Auch die USB-Controller im NES – Look sind um ganz wenige Euro aus China zu bekommen…
Der Raspberry PI wird mittlerweile ja in vielen Anwendungen im Dauerbetrieb eingesetzt und hat dort unterschiedlichste Aufgaben zu erfüllen. Manchmal ist er ein Webserver, eine Wettersensorstation, ein NAS, oder eine Steuerung. Was auch immer. Doch meist hat ein Raspberry Board nur eine dieser Aufgaben zu erfüllen. Die Betriebssysteme bieten jedoch wesentlich mehr Funktionen und Features an, die nicht unbedingt für alle Anwendungen benötigt werden, aber trotzdem mitlaufen und Prozesszeit benötigen, oder die SD-Karte mit unnötigen Schreibzyklen belasten. Das lässt sich aber ändern.
Mein Kollege Mario Wehr hat eine Sammlung an Optimierungen zusammengestellt, die ich hier mit seiner Genehmigung veröffentlichen darf.
Xserver/Windomanager disablen cmd: raspi-config Menp -> Boot Optins -> Desltop/CLI -> Console only with Login
GPU Shared MEM auf 16MB cmd: raspi-config Menü -> Advanced Config -> Memory Split ->16MB
Im letzten Teil des Projektes „Raspberry Pi als Datenlogger“ habe ich einen Raspberry Pi als Datenlogger für unterschiedliche Sensoren konfiguriert. Als Schnittstelle dient der I²C Bus und die RS232 Leitungen, an denen die Sensoren angeschlossen sind. Die Sensoren waren ein HYT939 (Luftfeuchtigkeit und Temperatur), ein BME280 (Luftdruck, Luftfeuchte und Temperatur) sowie ein Ultimate GPS Board an der seriellen Schnittstelle. Der Raspberry Pi ist dabei in eine Box eingebaut, wird mit einer Powerbank, die sich ebenfalls in der Box befindet, versorgt und stellt als Schnittstelle eine 8 polige RJ45 Buchse mit I²C und RS232 nach außen zur Verfügung. An diese Buchse können dann die Sensoren angeschlossen werden. Will man die Sensorik nun ändern, bzw. erweitern, so können einfach weitere I²C Bus – Sensoren angeschlossen werden. Es muss lediglich noch die Software (in diesem Fall Python Skripten) angepasst werden und schon können die Daten des neuen Sensors empfangen und aufgezeichnet werden. Wie aber geht das System um, wenn der Sensor nicht über I²C spricht? Wenn zum Beispiel ein analoger Wert eingelesen werden soll? Ganz einfach: Soll die Hardware des Datenloggers nun nicht mehr modifiziert werden, so muss man einfach dafür sorgen, dass der neue Sensor, der beispielsweise analoge Spannungen ausgibt, diese an eine, nennen wir sie Black Box weitergibt, die wiederum an ihrem Ausgang ein I²C Bussignal bereit stellt. Das kann dann wieder in das bestehende System integriert werden.
Arduino Nano als I²C Converter
Und genau diese Aufgabe erfüllt ein Microcontroller. Praktischer Weise habe ich diesmal einen Arduino Nano dazu verwendet. Der Arduino Nano mit dem Atmega 328 besitzt ja mehrere analoge und Digitale Eingänge, sowie zwei Interrupts. Über entsprechende Libraries ist einfach das I²C Bus Protokoll zu realisieren. Somit ist das geeignete Black-Box Gerät gefunden.
Der folgende Arduino Code stellt einen einfachen I²C Bus Slave dar. Die Busadresse soll beispielsweise 0x08 sein, von einer Messung haben wir den Messwert 1.3321 erhalten. Dieser Wert soll bei Anfrage an diese Busadresse gesendet werden. Das Beispiel sieht wie folgt aus:
Im Skript ist eine Funktion „dtostrf“ zu sehen. Sie wandelt den Inhalt einer Variablen des Datentyps „floating point“ in ein Charakter Array um. Infos sind hier zu sehen. Im Python Interpreter des Raspberry können wir nun überprüfen, ob die Daten ankommen. Doch zuvor soll der gesamte Aufbau einmal schematisch dargestellt werden.
Schematische Darstellung des Systems
Sind alle Sensoren inklusive des Arduino angeschlossen, so kann das folgende Python-Skript aus der Linux Konsole des Raspberry aufgerufen werden:
# Reading data from arduino as sensor slave
# V0.1 by bihlo 09/2016
import smbus, time
bus = smbus.SMBus(1) # Raspberry Rev. 2
address = 0x08 # Fixed default address of Arduino
# Initialize sensor to acquire measurements
#def MeasurementRequest():
# void = bus.write_quick(address)
#time.sleep(0.1)
# Read from bus
def ReadMeasurement():
void= bus.write_quick(address)
time.sleep(0.1)
# Acquire 6 byte from sensor
Readout = bus.read_i2c_block_data(address,0,6)
out=''.join(chr(i) for i in Readout) #byte array von ascii in string wandeln
print "Antwort vom Arduino: ", Readout, " ."
print "Antwort als String: ", out
ReadMeasurement()
Wenn der Python Interpreter jetzt keinen Fehler meldet und der Inhalt der Variable „wert“ des Arduino in ASCII und im Klartext dargestellt wird, dann kann jetzt mit einem „richtigen“ Messwert eines Sensors weiter gearbeitet werden.
Partikeldetektor
Als Sensor soll an an den Arduino ein DSM501 Dust Sensor Module angeschlossen werden. Der DSM501A ist ein Staubsensor, der mit 5V bei einer Stromaufnahme von 90mA betrieben wird. Er erkennt Partikel ab einer durchschnittlichen Größe von 1µm bei einer Konzentration von 0 bis ca. 1.4mg pro Kubikmeter Raumluft. Laut Datenblatt und Herstellerinformationen wird die Luft im Bereich der Messkammer erhitzt, sodass eine Luftzirkulation entsteht. Die sich ständig bewegende Luft wird mit einem getakteten Lichtstrahl beleuchtet. Ein in einem Winkel zur Lichtquelle angebrachter Fotodetektor empfängt nun, im Falle dass sich Partikel im Licht befinden, dessen Streulicht. Die Intensität des Streulichtes ist von der Anzahl und Größe der Partikel abhängig und kann so erfasst werden. Als Ausgangssignal erzeugt der Sensor ein Puls/Pausensignal mit einer Periode von 100ms. Das Verhältnis von High- zu Lowtime stellt nun die Grundlage für die Berechnung der Partikelanzahl bzw. -dichte dar. Über einen Countereingang des Arduino werden die Impulse gemessen und der korrespondierende Partikelwert errechnet. Dieser Wert wird nun wie oben beschrieben als Busdatum für den I2C Bus herangezogen und bei Auslösen des Bus Events übertragen. Somit hat der Arduino die Aufgabe eines einfachen Protokollkonverters übernommen. Mit dieser Methode lassen sich alle möglichen Messwerte so aufbereiten, dass der Raspberry mit einer Schnittstelle damit umgehen kann.
Wie das im Detail funktioniert und wie der Code dazu aussieht, werde ich vielleicht später einmal posten.
Als Kunde des A1 IPTV – Angebotes bekommt man ein A1 DSL – Modem samt einer A1 TV-Box. Diese Kombination funktioniert natürlich einwandfrei. Möchte man den Funktionsumfang erweitern und beispielsweise eine MINIX NEO – Box als Streaming Client betreiben, so bietet sich hier die bekannte Software „KODI“ an, die für alle möglichen Hardwareplattformen und Betriebssysteme erhältlich ist.
TV-Variante ohne Server, ohne Aufnahme und Timeshift
Die A1 TV – Box kann man direkt gegen die MINIX Box ersetzen. Auf der Mini-Box läuft ein Android Betriebssystem. Unter kodi.tv kann man sich den Client herunterladen und auf der Mini Box installieren. Dann ist noch unter SYSTEM -> STETTINGS -> ADDONS -> PVR clients auszuwählen.
Dort findet man den PVR IPTV Simple Client der zu installieren ist. Unter Konfiguration ist der Pfad zu einer .m3u – Liste anzugeben. Die m3u Liste sollte einfacher weise in einem lokalen Ordner (z.Bsp. Downloads) abgelegt werden.
Die .m3u – Datei beinhaltet die IP-Adressen mit den Streaming-Links und Sendernamen und sieht für die Basissender von A1 so aus:
Jetzt muss nur mehr „Settings“ -> „TV“ der „Enabled“ Button gecheckt werden und die Wiedergabe der TV-Kanäle sollte funktionieren. Mit dieser Methode ist stellt die Android Box einen IPTV Client dar, der die Streaming Links direkt abspielt. Da kein Server im Hintergrund läuft, ist es auch nicht möglich Timeshift oder Aufnahmen von Sendungen zu realisieren.
TV – Variante mit Server, Timeshift, EPG und Aufnahme
Um diese Funktionen zu erhalten, muss ins heimische Netzwerk ein IPTV Server integriert werden. In meinem Fall habe ich einen Raspberry Pi2 für diesen Zweck konfiguriert. Folgende Komponenten benötigen wir dazu:
Raspberry Pi2 (an das heimische Netzwerk angeschlossen)
Micro SD Karte mit 8GB
eine externe Festplatte oder USB-Stick als Speicher für die Aufnahmen
Ist alles heruntergeladen, so beginnt man mit dem Extrahieren des Images auf die Speicherkarte. Dazu startet man die Software win32diskimager.exe und wählt den Pfad zur Image-Datei. (die nennt sich in diesem Fall: XBian_Latest_rpi2.img). Dann ist die Speicherkarte einzulegen und der zugeordnete Laufwerksbuchstabe auszuwählen. Danach kann der Schreibvorgang mit „Write“ gestartet werden. ACHTUNG: Das gewählte Laufwerk wird mit dem Image ausgestattet. Hier unbedingt sichergehen, dass nicht ein falsches Laufwerk ausgewählt wird. Nach ein paar Minuten ist die SD-Karte fertig beschrieben und kann in den Raspberry PI eingesteckt werden.
Jetzt kann man den Raspberry PI an einen Monitor, Keyboard, LAN und per Micro-USB an eine 5V/2A Versorgung anschließen. Er wird jetzt booten. Es startet das Script: raspi-config, das bequem mit dem Keyboard bedient werden kann. Hier wird als erstes der tvheadend – Server installiert:
Zunächst wählt man „Packages“ aus und bestätigt.
dann scrollt man bis zur Kategorie „video“ und bestätigt wiederum.
hier ist nun tvheadend auf „Yes“ zu setzen und wieder zu bestätigen. Jetzt beginnt der Download des Paketes und die anschließende Installation. Ist der Prozess beendet, so ist das raspi-config script zu beenden und in die bash zu gehen. Der default Login lautet: xbian und das Passwort: raspberry
Zunächst sind noch alle Updates und Upgrades durchzuführen:
sudo apt-get update sudo apt-get upgrade
Als nächstes macht es noch Sinn, die IP Adresse des Raspberry PI zu kennen, die er vom DHCP Server des Routers zugewiesen bekommen hat. Die müssen wir ja wissen, wenn wir auf den TV-Server Zugriff haben wollen. Dazu gibt man einfach folgendes ein:
ifconfig
Als Antwort erhält man dann folgende Infos zum Ethernet – Anschluss. In diesem Fall eth0:
Wie man sieht, ist in diesem Beispiel die Adresse 10.0.2.15 zugewiesen worden. Mit dieser Information können wir den Raspberry Pi nun neu starten und an einem Client-Computer mit dem Setup von TVHeadend fortfahren.
sudo reboot
Nach dem Neustart sollte der Raspberry tvheadend-Server jetzt auf einem Client-PC erreichbar sein. Dazu öffnet man einen Webbrowser und gibt in der Adresszeile folgende Adresse ein: https://10.0.2.15:9981
Jetzt muss folgendes zu sehen sein:
Wir suchen und klicken auf den TAB „Konfiguration“. Hier geben wir ein paar allgemeine Einstellungen ein: den Servernamen (bei mir hier einfach Tvheadend); den Ansichtsmodus stellt man auf „Experte“. Die restlichen Einstellungen belässt man auf default. Unter Spracheinstellungen ist „German“ zu wählen. (oder was auch immer gewünscht wird). Die Webbenutzeroberfläche ist im default Modus auch ganz schön. Wer auch noch Senderlogos haben will, der stellt unter „Picon“ wie folgt ein:
Nach all den Einstellungen nicht vergessen auf „Speichern“ zu klicken. Jetzt kommt die eigentliche Arbeit: Das Editieren der Senderliste. Hierzu erstellt man als erstes ein „Netzwerk“. Unter den Tabs: Konfiguration -> DVB-Inputs -> Netzwerke legen wir ein neues „Netzwerk“ (eigentlich TV-Netzwerk) an.
Mit „Hinzufügen“ öffnet sich ein Fenster in dem man „IPTV Network“ auswählt. Bestätigt man das so öffnet sich ein weiteres Fenster. Hier nimmt man ein paar wenige Einstellungen vor. Sinnvoller Weise benennen wir das Netzwerk A1TV.
Mit „Speichern“ werden die Einstellungen abgeschlossen. Jetzt klickt man auf den TAB „Muxes“. Hier müssen alle Sender angelegt werden. Diese Arbeit muss man sich einmal antun. (Es gibt dann aber die Möglichkeit, über die Konsole die config-Dateien vom Server zu sichern – dazu später aber mehr)
In dem Bild ist die fertige Mux-Tabelle zu sehen. Mit „Hinzufügen“ wird ein neuer „MUX“ (Signalquelle) hinzugefügt. Hier wählt man aus den verfügbaren Netzwerken A1TV (das, das wir vorher angelegt haben) aus.Im sich jetzt öffnenden Fenster ist unter URL die Streaming – Adresse vom jeweiligen Sender einzugeben (hier z. Bsp.: rtp://239.2.16.21:8202 für 3sat). In Mux-Name ist der Sendername einzugeben.
Danach auf „Speichern“ drücken und mit „Hinzufügen“ den nächsten Sender konfigurieren. Hat man die mühevolle Arbeit dann getan und alle Sender eingegeben, so müssen die Muxes einem Service/Kanal zugeordnet werden. Das ist die eigentliche Senderliste, die der Server dann den Clients zur Verfügung stellt. (Ein MUX muss jetzt nicht unbedingt eine IP-Streaming Adresse sein, sondern kann auch aus einem Sat-, oder DVB-T Empfänger kommen. Da hier in einer Signalfrequenz mehrere TV oder Radioprogramme per Multiplexverfahren (eben MUX) übertragen werden. Darum ist die Bezeichnung MUX für IP-Adressen hier vielleicht etwas verwirrend). Das Zuordnen der Services geschieht im TAB „Services„. Hier einfach auf „Services zuordnen“ -> „alle Services zuordnen“ klicken und warten bis der Prozess abgeschlossen ist. Nun kann ein erster Test erfolgen.
Links neben den Kanalnamen ist ein kleiner „Play-Button“ zu sehen. Ist das VLC-Player-Plugin im Browser installiert, so wird beim Anklicken des Buttons ein Wiedergabefenster geöffnet, das den aktuellen Stream anzeigt.
EPG und Senderlogos
Weiter geht´s beim Konfigurieren nun mit dem elektronischen Programm Guide (EPG). Hier muss ein wenig getrickst werden. Aus diversen Foren und Anleitungen im Web habe ich eine für mich funktionierende Konfiguration zusammengestellt. Wir beginnen im Tvheadend-Server unter Konfiguration -> Kanal/EPG -> EPG-Grabber Module mit den Einstellungen.
Hier ist der interne Grabber „XMLTV: Sweden (TVZon)“ zu aktivieren. Danach wieder auf Speichern drücken.
Danach müssen wir wieder auf den Raspberry PI in die Konsole. Man macht das entweder vom Client-PC aus über ein Terminal (z. Bsp. Putty) oder direkt am Raspberry PI, wenn dieser noch an Keyboard und Monitor angeschlossen ist. Die folgenden Anleitungen stammen von https://github.com/Bronkoknorb/a1tv-helpers
Ist die Konsole, am besten als root-admin geöffnet, so installiert man zuerst ruby und die dazugehörigen libraries.
sudo apt-get install xmltv-util
sudo su hts
tv_grab_se_tvzon --configure
Nach der letzten Eingabe fragt das Konfigurationsscript des Grabbers nach folgenden Informationen:
Root-URL for grabbing data (hier https://xmltv.xmltv.se/channels-Austria.xml.gz eingeben)
Directory to store the cache: /home/hts/.xmltv/cache
Select Channels : Hier allauswählen
Jetzt muss der TVheadend – Service neu gestartet werden:
sudo service tvheadend restart
Jetzt kann wieder auf das Webinterface von TVheadend gewechselt werden. Im EPG-Grabber TAB kann jetzt noch die Zeit zum Synchronisieren der EPG Datenbank ausgewählt werden.
Die Senderlogos werden weitgehend gefunden. Wo das Senderlogo fehlt, kann unter dem TAB Kanal/EPG -> Kanäle in der Spalte Benutzerlogo ein Link mit einem geeigneten Logo eingetragen werden.
Jetzt ist der Server soweit fertig konfiguriert und die Clients können eingerichtet werden. In meinem Fall habe ich auf der MINIX NEO X8 Android Box ein Kodi installiert. In der Liste Addons -> PVR-Addons ist unter vielen auch ein TVHEADEND Addon gelistet. Dieses wird installiert. Alle anderen PVR-Addons müssen deaktiviert werden.
In den Client Einstellungen ist lediglich noch die IP Adresse des Raspbery PI anzugeben. Die Ports sind default (9981). Wenn beim TVheadend Server kein eigener User angelegt ist, so brauchen wir auch im Client unter user und pass nichts einzutragen.
Jetzt fehlt nur mehr die Aufnahmefunktion am Server. Hierzu begeben wir uns wieder in das Webinterface vom Server. Unter Konfiguration -> Aufnahme sind die abgebildeten Einstellungen zu machen:
Ich habe hier das default profile editiert. Wichtig ist der Aufnahmedateipfad. Steckt am Raspberry PI ein externer USB-Datenträger, so kann dieser für die Aufnahme verwendet werden. (In der Xbian Konsole kann man sich den Datenträger entsprechend vorbereiten und Verzeichnisse erstellen). Die Einstellungen sind weitgehend selbsterklärend….
Edit: 09/2019…
Es muss natürlich nicht das XBIAN Image sein. Die aktuelle Version habe ich auf ein Raspbian Image installiert. Das bekommt man von der RaspberryPi Website. Ist das Image auf der SD-Karte, dann sollte man mit „raspi-config“ das Filesystem „expandieren“ und das SSH Service installieren. Danach ein:
sudo apt-get update sudo apt-get upgrade
durchführen und dann das tvheadend Paket installieren.
sudo apt-get install tvheadend
Während der Installation wird man nach einem einzurichtenden Username und Passwort für den TVheadend-Server gefragt. Hier ist natürlich auch was einzugeben. Ist die Installation fertig dann kann im Webbrowser über:
http://ip-adresse-des-raspi:9981
getestet werden, ob der Server läuft. Wenn jemand nicht weiß welche IP der Raspi vom DHCP bekommen hat, dann einfach in der Konsole mit
ifconfig
nachsehen. Soll der Raspi eine statische IP-Adresse bekommen (ist bei einem Server vielleicht keine schlechte Idee), dann mit einem Editor die folgende Datei editieren:
nano /etc/dhcp.conf (hier sind einige Static IP templates auskommentiert) diese einfach an die gewünschten Adressen anpassen. Mit dem folgenden Command dann den Service restarten:
In Teil1 dieses Projektes haben wir dem Raspberry ein Betriebssystem verpasst und das ein wenig für die Anwendung aufbereitet. Wir wollen ja an den PI mehrere Sensoren anschließen und diese dann zyklisch auslesen und die Daten in einer Datei auf einem USB-Stick speichern. Die Aufzeichnung soll so lange laufen, bis ein Taster gedrückt wird, der den Prozess beendet. Die einzige Anzeige des PI sind zwei Leuchtdioden, die, sowie auch der Taster, an die GPIOs des PI angeschlossen sind. Darum haben wir folgende Punkte bereits erledigt:
Die PI Platine gemeinsam mit einer USB Powerbank in ein Gehäuse eingebaut
Anschlüsse wie Ethernet, USB, HDMI durch Ausschnitte im Gehäuse nach außen geführt
Zwei Leuchtdioden und einen Taster ins Gehäuse eingebaut und auf die GPIOs geschaltet
Den I²C Bus des PI auf eine Buchse im Gehäuse geführt
Eine MicroSD Karte mit einem Raspi-Wheezy Image bespielt
Einen USB-Stick mit FAT32 formatiert
Das Betriebssystem soweit konfiguriert, dass das Filesystem für den Stick, alle Module für den I²C, sowie Python geladen werden.
Raspberry PI im Plastikgehäuse
Der Pi sieht fertig zusammengebaut nun so aus (siehe Bild rechts). Nun können die Sensoren angeschlossen werden. In diesem Fall handelt es sich um Luftfeuchtigkeits-/Temperatursensoren mit der Bezeichnung HYT939 des Herstellers Hygrochip. Hier ein Auszug der technischen Daten aus dem Datenblatt des Herstellers:
Ausführung: Feuchtesensor im TO39 Gehäuse, druckfest, mit Edelstahl-Sinterfilter
Genauigkeit: Feuchte ±1,8% rF, Temperatur ±0,2 °C Genauigkeit 0…10% rF (0 … 50°C): ±(0,1% rF + 17% aw) Messbereich: Feuchte 0 … 100% r.F. (max. dp = +80 °C), Temperatur – 40 … +125 °C Abmessungen: 5,2 x 9 mm Anschlüsse: TO 39 Footprint Auflösung Feuchte: 0,02% rF Hysterese bei 50% rF: < ±1% rF Linearitätsfehler: < ±1% rF Ansprechzeit t63: < 10 sec (Mit Edelstahl-Sinterfilter) Auflösung Temperatur: 0,015 °C Digitale Schnittstelle: I2C, Adresse 0x28 oder Alternativadresse Betriebsspannung: 2,7 … 5,5 V Stromaufnahme (typ): < 1µA in Bereitschaft < 22µA bei 1Hz Messrate 850 µA maximal
HYT939 Sensor
Eine kleine Platine dient als „Sensorboard“. Hier besteht die Möglichkeit, vier HYT´s anzustecken. Natürlich müssen auch die Adressen der Sensoren unterschliedlich sein. Der HYT939 ist per default auf hex 0x28 eingestellt. Will man diese Deviceadresse ändern, so muss der der HYT in den Command-Mode versetzt werden, um dann die Konfigurationsdaten empfangen und in sein EEprom schreiben zu können. Dazu muß der Sensor innerhalb der ersten 10ms nach seinem PowerUp in den Command-Mode gebootet werden. Das lässt sich am einfachsten mit einem ArduinoUno bewerkstelligen… Dabei wird der Powerpin des HYT über einen Digital Out Pin des Arduino versorgt. So ist es möglich, das Timing genau einzuhalten und den Command Mode zu erreichen.
Nachdem der Sensor nun an den Raspberry angeschlossen ist, fehlt nur mehr ein Programm, um ihn oder auch mehrere anzusteuern und auszulesen. Hier verwende ich den Python Interpreter. Damit lassen sich auf einfache Weise die Daten auslesen und auch auf Datenträgern speichern. Das „Programm“ besteht aus zwei Teilen:
Hauptscript: beinhaltet nur eine Endlosschleife, die die LEDs steuert, den Taster abfragt, die Sensorfunktion aufruft, deren ausgelesene Werte übergibt, aufbereitet und auf den Stick speichert.
Funktion Sensor auslesen: addressiert den I²C Bus, liest die Sensordaten aus, rechnet sie in lesbare Werte um und übergibt den Output an die Funktion
# /usr/bin/python# License: GPL 2.0# edited by Ingmar B. Aug.2015import osfrom time import *import timeimport threadingimport hyt939o import RPi.GPIO as GPIO# Setup LED Ports (pin12 = LED rot, pin18 = LED gruen)GPIO.setwarnings(False)GPIO.setmode(GPIO.BOARD)GPIO.setup(12, GPIO.OUT)GPIO.setup(18, GPIO.OUT)GPIO.setup(16, GPIO.IN)# LED Gruen einschalten sobald das Script gestartet istGPIO.output(18, GPIO.HIGH)#gpsd = None #seting the global variableaddress = [0x2a, 0x29] #hyt939 = [0, 0]hum = [0, 0]temphyt = [0, 0]loopon = True #set variable for loopi=1 #counter for address selectionos.system('clear') #clear the terminal (optional)while loopon: # bei beginn des auslesens aller daten die rote Led einschalten GPIO.output(12, GPIO.HIGH) if GPIO.input(16)== GPIO.HIGH: loopon = False os.system('clear') # Variablen fuer Sensor HYT 939 uebergeben for i in range(2): hyt939=hyt939o.ReadMeasurement(address[i]) time.sleep(0.1) hum[i]=hyt939[0] temphyt[i]=hyt939[1] print '--------------------------------------- ' print 'SENSORS reading Sensor Nr.:' , i print print 'humidity hyt939 ' , hum[i] print 'temperature hyt939 ' , temphyt[i] print '--------------------------------------- ' print print 'data to write:' , str(hum[0]), str(temphyt[0]), str(hum[1]), str(temphyt[1]) print ("date :" + time.strftime("%x")) print ("time :" + time.strftime("%X")) print date = time.strftime("%x") zeit = time.strftime("%X") ## write all data to usbstick fileout = open("/media/usbstick/wetterfrosch.txt", "a") time.sleep(0.1) fileout.write(date+";"+zeit+";"+str(hum[0])+";"+str(temphyt[0])+";"+str(hum[1])+";"+str(temphyt[1])+"\n") time.sleep(0.1) fileout.close() time.sleep(0.1) # nach schreiben bzw auslesen der daten rote LED wieder abschalten GPIO.output(12, GPIO.LOW) time.sleep(0.8) #set to whateverGPIO.output(18, GPIO.LOW) # gruene Led ausschaltenprint "Ende"
Das folgende Listing liest den Sensor aus:
# Reading mesaurements from HYT 939 humidity and temperature sensor # First Version by Caerandir May 2014 modified by i.bihlo 2015
import smbus, time bus = smbus.SMBus(1) # Raspberry Rev. 2 address = 0x28 # Fixed default address of HYT 939
# Calculiere die relLF in % aus den vier Bytes in "Readout" RelHum = Readout[0]<<8 | Readout[1] RelHum = RelHum & 0x3FFF RelativeHumidity = 100*RelHum/(2**14)
# Calculiere die Temperatur vom Sensor Readout[3] = Readout[3] & 0x3F temp = Readout[2]<<6 | Readout[3] Temperature = 165.0*temp/(2**14)-40 print "Hrel: ", RelativeHumidity, " %" print "T: ", Temperature, " C"
return RelativeHumidity, Temperature
MeasurementRequest() time.sleep(0.2)
ReadMeasurement()
Eine Versuchsmessung über einen Tag und eine Nacht mit drei Sensoren hat folgendes Ergebnis geliefert. Hier sind die Temperaturwerte der Sensoren dargestellt. (Die Daten vom USB-Stick wurden mit Matlab importiert und daraus ein Plot erstellt.)
Der Raspberry Pi ist ja mittlerweile ein bekannter und beliebter Scheckkartenplatinen-Computer mit dem sich allerlei anstellen lässt. Vom TV-Frontend mit Kodi, über Spielekonsolenemulatoren mit Retropi bis hin zum Bürorechner, ist damit fast alles möglich. In diesem Projekt möchte ich vorstellen, wie mit Hilfe des Raspberry Pi Model2 physikalische Größen wie Temperatur und Luftfeuchtigkeit gemessen und auf einem Speichermedium geloggt werden. Und zwar mit einem Feuchtesensor der Type HYT939 der am I²C Bus angeschlossen wird, genauer gesagt: mehrere I²C Feuchtesensoren am Bus…
Wir beginnen zuallererst mit der Versorgung des Raspberry PI. Im Bild ist ein Pi2 in ein einfaches Kunststoffgehäuse eingebaut und an eine 2Ah USB-Powerbank von RS-Components angeschlossen. Der Ladeanschluss der Powerbank ist vom Gehäuse nach aussen geführt. So kann der Pi wahlweise über die Powerbank (mit einer nicht rechenintensiven Anwendung bis zu 3h) oder über eine externe USB-Versorgung (z.Bsp. einem Handyladeadapter) betrieben werden. Der I²C Bus des PI (Pin 3 SDA und Pin 5 SCL sowie Pin 2,4 +5V und GND an Pin 6,14…) ist auf einen RJ Stecker im Gehäuse ausgeführt. Um später irgendwelche Statusmeldungen ausgeben zu können, sind zwei LEDs an die GPIOs 24 und 18 (an Pin18 und Pin12) angeschlossen. Ein weiterer GPIO wird über einen 22k Pulldown-Widerstand an einen Taster an 5V geschaltet. (GPIO23 an Pin16).
Für die USB Anschlüsse, Ethernet und HDMI wurden im Gehäuse passende Ausschnitte gemacht, an eine USB Schnittstelle ein Keyboard und an den HDMI Port ein Monitor angeschlossen. Die LAN Verbinung mit Internetzugang sollte auch hergestellt sein, um nach der Ersteinrichtung die benötigten Module und Updates laden zu können.
Jetzt fehlt nur noch das Speichermedium mit Betriebssystem. Der PI2 ist mit einem Micro-SD Slot ausgestattet. Ich habe hier eine 4GB Micro SD mit einem raspian-wheezy image bespielt. Um das Imagefile auf einfache Weise auf die SD-Karte zu bekommen, empfiehlt es sich, das Tool win32diskimager zu verwenden. Ist die Speicherkarte dann fertiggestellt, kann man beginnen.
Der Raspberry zeigt nach dem Einschalten kurz seinen Farbverlauf und dann beginnt auch schon der Bootprozess. Ist der dann beendet, so startet das OS am PI erstmal eine Setup-Routine.
Hier sind nun folgende Schritte durchzuführen:
im Menu internationalisation options unter I1 die entsprechenden locals einstellen -> DE_UTF_8
in advanced options unter A2… einen Hostname vergeben z.Bsp.:“raspisensor“, in A4… SSH enablen, in A7 …I²C enablen und „load per default“ und in A8 … „serial enable“ und „login shell“ aktivieren
dann noch expand filesystem wählen damit der Speicherplatz der gesamten SD-Karte genutzt wird
jetzt noch mit finish -> reboot neu starten
Jetzt fährt der PI wieder hoch und bleibt beim Login-Prompt stehen. Mit login: pi und dem passwort: raspberry loggt man sich nun ein. Mit den folgenden Kommandos werden Updates und benötigte Module installiert:
sudo apt-get update
sudo apt-get install python-smbus (installiert den system management bus) sudo modprobe i2c_bcm2708 (kernelmodule für I²C von Hand laden) sudo modprobe i2c_dev lsmod (geladene Module listen) sudo i2cdetect -y 1 (I²C ports scannen)
Es empfiehlt sich, die Kernelmodule per Autostart zu laden. Das geht wie folgt:
sudo nano /etc/modules (mit dem Nano-Editor die Datei modules öffnen …)
dann folgende Zeilen hinzufügen:
i2c_bcm2708 i2c_dev
dann mit STRG+X den Editor beenden und bei Speichern JA wählen.
danach mit:
sudo nano /etc/modprobe.d/raspi-blacklist.conf
überprüfen, ob hier bereits ein Eintrag „blacklist i2c-bcm 2708“ existiert.
Falls ja, ist der auszukommentieren oder zu löschen.
jetzt wieder neustarten mit:
sudo shutdown -r now
danach wieder einloggen und mit
lsmod
überprüfen ob die gwünschten Module korrekt geladen sind.
Da wir später die Daten von den Sensoren in eine Datei loggen wollen und diese Datei auf einem USB-Stick gespeichert werden soll, sind folgende Schritte notwendig:
einen USB-Sick mit FAT32 Filesystem auf einem Windowsrechner formatieren
auf dem PI das Filesystem FAT32 installieren
den Stick in den PI stecken und die Mountlist um den Stick erweitern
