Schlagwort-Archive: Raspberry PI

NES Classic Mini : Aus mit Wucherpreisen

Loading

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 ausgepackt
Bedienelemente 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…

NESPIE mit NES-Nachbau „ChinaController“

 

Ein alter NES „Klassiker“

 

Raspberry PI – OS tuning

Loading

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

Interfaces Disable
cmd: raspi-config Menü -> Interfaced -> Alle Interfaces disablen

Entfernen nicht benötigter Kernelmodule
Bringt: Mehr Speicher für Userspace.
Schnellerer Boot.

Kernel module werden unter:
/etc/modprobe.d/{files}
ge-Blacklistet.

IPV6 disable

File: ipv6.conf
alias net-pf-10 off
alias ipv6 off

File: raspi-blacklist.conf
blacklist ipv6

Sound disable

File: raspi-blacklist.conf

blacklist snd_bcm2835
blacklist snd_soc_bcm2708_i2s
blacklist snd_soc_core
blacklist snd_compress
blacklist snd_pcm
blacklist snd_page_alloc
blacklist snd_seq
blacklist snd_seq_device
blacklist snd_timer
blacklist snd

Bluetooth disable

File: raspi-blacklist.conf
blacklist btbcm
blacklist hci_uart

File: /boot/config
dtoverlay=pi3-disable-bt

cmd: systemctl disable hciuart

UIO disable

File: raspi-blacklist.conf
blacklist uio_pdrv_genirq
blacklist uio

Verschieben von /Temp /Log ins Ram
Bringt: Die SD hält um einiges länger Schnellerer Boot

File: /etc/fstab
tmpfs /tmp tmpfs defaults,size=8M 0 0
tmpfs /var/tmp tmpfs defaults,size=8M 0 0
tmpfs /var/log tmpfs defaults,size=8M 0 0

Log anpassen
Bis auf Kernel/Daemon können alle Logs abgeschalten werden.
File: /etc/rsyslog
#cron.* /var/log/cron.log
daemon.* -/var/log/daemon.log
kern.* -/var/log/kern.log
#lpr.* -/var/log/lpr.log
#mail.* -/var/log/mail.log
#user.* -/var/log/user.log
#mail.info -/var/log/mail.info
#mail.warn -/var/log/mail.warn
#mail.err /var/log/mail.err

Log-Rotating
Da der tmpfs Space klein ist -> logrotate auf 1 bzw daliy
File: /etc/logrotate -> /etc/logrotate.d/{files}

Raspberry als Datenlogger – Teil.3 Arduino nano als I²C Converter

Loading

DSC_4790
Raspberry PI als Datenlogger

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.

dsc_2872
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:


// I2C Slave
#include
int address = 8;           //i2c busaddresse
float wert = 1.3321;       // testwert .... kommt zb aus sensorberechnung

char tmp[6];
void setup() {

Wire.begin(address);           // i2c adresse 0x08
Wire.onRequest(requestEvent);  // register event
}

void loop() {}

void requestEvent() {
dtostrf(wert,1,3,tmp);      // float "wert" in char array umwandeln
Wire.write(tmp);            // char array senden
}

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.

blockschaltbild
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.

dsc_2873
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.

Fernsehen mit Aufnahme über IPTV mit Raspberry und A1

Loading

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.kodiiptvclient

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. kodiiptvclient1

Die .m3u – Datei beinhaltet die IP-Adressen mit den Streaming-Links und Sendernamen und sieht für die Basissender von A1 so aus:

#EXTM3U

## A1TV_Basis, Stand: Nov. 2015
## KODI

#EXTINF:-1 tvg-num="1" tvg-logo="609",ORF eins
rtp://@239.2.16.1:8208
#EXTINF:-1 tvg-num="2" tvg-logo="625",ORF 2-W
rtp://@239.2.16.2:8208
#EXTINF:-1 tvg-num="3" tvg-logo="671",ATV
rtp://@239.2.16.3:8208
#EXTINF:-1 tvg-num="4" tvg-logo="4",PULS 4
rtp://@239.2.16.4:8208
#EXTINF:-1 tvg-num="5" tvg-logo="227",Servus TV
rtp://@239.2.16.11:8208
#EXTINF:-1 tvg-num="6" tvg-logo="5",SAT.1 Austria
rtp://@239.2.16.5:8208
#EXTINF:-1 tvg-num="7" tvg-logo="7",ProSieben Austria
rtp://@239.2.16.7:8208
#EXTINF:-1 tvg-num="9" tvg-logo="6",RTL Austria
rtp://@239.2.16.6:8208
#EXTINF:-1 tvg-num="10" tvg-logo="75",A1 TV Plus-Info
rtp://@239.2.16.10:8208
#EXTINF:-1 tvg-num="14" tvg-logo="672",ATV 2
rtp://@239.2.16.91:8208
#EXTINF:-1 tvg-num="18" tvg-logo="574",Das Erste
rtp://@239.2.16.16:8208
#EXTINF:-1 tvg-num="19" tvg-logo="642",ZDF
rtp://@239.2.16.17:8208
#EXTINF:-1 tvg-num="22" tvg-logo="611",ORF III
rtp://@239.2.16.29:8208
#EXTINF:-1 tvg-num="23" tvg-logo="578",3sat
rtp://@239.2.16.21:8208
#EXTINF:-1 tvg-num="27" tvg-logo="612",ORF SPORT +
rtp://@239.2.16.78:8208
#EXTINF:-1 tvg-num="34" tvg-logo="709",gotv
rtp://@239.2.16.36:8208
#EXTINF:-1 tvg-num="66" tvg-logo="617",ORF 2-B
rtp://@239.2.16.65:8208
#EXTINF:-1 tvg-num="67" tvg-logo="618",ORF 2-K
rtp://@239.2.16.66:8208
#EXTINF:-1 tvg-num="68" tvg-logo="619",ORF 2-NÖ
rtp://@239.2.16.67:8208
#EXTINF:-1 tvg-num="69" tvg-logo="620",ORF 2-OÖ
rtp://@239.2.16.68:8208
#EXTINF:-1 tvg-num="70" tvg-logo="621",ORF 2-S
rtp://@239.2.16.69:8208
#EXTINF:-1 tvg-num="71" tvg-logo="622",ORF 2-St
rtp://@239.2.16.70:8208
#EXTINF:-1 tvg-num="72" tvg-logo="623",ORF 2-T
rtp://@239.2.16.71:8208
#EXTINF:-1 tvg-num="73" tvg-logo="624",ORF 2-V
rtp://@239.2.16.72:8208
#EXTINF:-1 tvg-num="92" tvg-logo="724",Melodie TV
rtp://@239.2.16.37:8208
#EXTINF:-1 tvg-num="94" tvg-logo="738",Bibel TV
rtp://@239.2.16.81:8208
#EXTINF:-1 tvg-num="95" tvg-logo="725",K-TV
rtp://@239.2.16.82:8208
#EXTINF:-1 tvg-num="105" tvg-logo="726",RTS Sat
rtp://@239.2.16.63:8208
#EXTINF:-1 tvg-num="120" tvg-logo="719",Okto
rtp://@239.2.16.34:8208
#EXTINF:-1 tvg-num="121" tvg-logo="85",Schau TV
rtp://@239.2.16.83:8208
#EXTINF:-1 tvg-num="122" tvg-logo="86",RT24
rtp://@239.2.16.84:8208
#EXTINF:-1 tvg-num="123" tvg-logo="87",P3 TV
rtp://@239.2.16.85:8208
#EXTINF:-1 tvg-num="124" tvg-logo="88",WNTV
rtp://@239.2.16.86:8208
#EXTINF:-1 tvg-num="125" tvg-logo="89",LT1
rtp://@239.2.16.87:8208
#EXTINF:-1 tvg-num="127" tvg-logo="91",KT1
rtp://@239.2.16.89:8208
#EXTINF:-1 tvg-num="128" tvg-logo="92",N1
rtp://@239.2.16.90:8208
#EXTINF:-1 tvg-num="129" tvg-logo="142",Kärnten TV
rtp://@239.2.16.112:8208
#EXTINF:-1 tvg-num="130" tvg-logo="143",Tirol TV
rtp://@239.2.16.109:8208
#EXTINF:-1 tvg-num="132" tvg-logo="141",HT1
rtp://@239.2.16.114:8208
#EXTINF:-1 tvg-num="133" tvg-logo="211",Mühlviertel TV
rtp://@239.2.16.113:8208

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.
DSC_2660Folgende 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
  • das Softwareimage XBIAN und einen Imageextractor
  • (für den Mac gibt´s diese Version: ApplePi-Baker)

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:

xbianconfig1Zunächst wählt man „Packages“ aus und bestätigt.

xbianconfig2dann scrollt man bis zur Kategorie „video“ und bestätigt wiederum.

xbianconfig3hier 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:

ifconfigWie 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:

headen1Wir 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:

headen2Nach 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.

headen3Mit „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.

headen4

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)

headen5In 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.headen6Im 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.

headen7Danach 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.

headen8Links 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.

epg1Hier 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 ruby ruby-dev
sudo gem install rest-client

Als nächstes benötigt man xmltv:

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 all auswä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.

epg2Die 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.

epg3Jetzt 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.

tvh1In 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:

recIch 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:

sudo /etc/init.d/networking restart

 

 

 

 

 

 

Raspberry als Datenlogger Teil2…Die Sensoren und Python

Loading

DSC_4789
Raspberry PI samt Powerbank im Gehäuse

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.
DSC_4790
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

DSC_4792
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.2015

import os
from time import *
import time
import threading
import 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 ist
GPIO.output(18, GPIO.HIGH)

#gpsd = None #seting the global variable
address = [0x2a, 0x29] 
#hyt939 = [0, 0]
hum = [0, 0]
temphyt = [0, 0]
loopon = True         #set variable for loop
i=1             #counter for address selection
os.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 whatever

GPIO.output(18, GPIO.LOW) # gruene Led ausschalten

print "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

# Initialize sensor to acquire measurements
def MeasurementRequest():
        void = bus.write_quick(address)
    time.sleep(0.1)

# Read Humidiy and Temperature to 14 bit accuracy
def ReadMeasurement():
    void= bus.write_quick(address)

    time.sleep(0.1)    
        # Acquire 4 byte from sensor
        #time.sleep(0.1)
    Readout = bus.read_i2c_block_data(address,0,4)

    # 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.)

temperature_3sensoren

Raspberry als Datenlogger Teil1…Das Betriebssystem einrichten

Loading

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…

DSC_4789Wir 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

Zuerst laden und installieren wir das Filesystem:

sudo apt-get -y install ntfs-3g hfsutils hfsprogs exfat-fuse

dann legen wir folgendes Verzeichnis an:

sudo mkdir /media/usbstick (usbstick dient hier als beispielname…)

sudo blkid -o list -w /dev/null

(listet die IDs der Datenträger auf -> unser Stick sollte in der Liste als vfat mit einer ID in dem Format XXXX-XXXX erscheinen)

sudo mount -t vfat -o utf8,uid=pi,gid=pi,noatime /dev/sda /media/usbstick

nun öffnen wir folgende Datei mit dem Editor:

sudo nano -w /etc/fstab

die ID des USB-Sticks von vorher tragen wir nun samt folgender Zeile ein und speichern dann wieder ab:

UUID=XXXX-XXXX /media/usbstick/ vfat utf8,uid=pi,gid=pi,noatime 0

weiter geht’s mit der Einrichtung der GPIOs und den Python libraries:

sudo apt-get install python-dev
sudo apt-get install python-rpi.gpio

Noch ein paar allgemeine Einstellungen:

sudo nano /etc/networks/interfaces  (Wir wollen eine fixe IP Adresse vergeben, um später einfach per SSH auf den PI zugreifen zu können)

folgende Zeile ersetzen:

iface eth0 inet dhcp

durch:

iface eth0 inet static
address xxx.xxx.xxx.xxx
netmask yyy.yyy.yyy.yyy
gateway zzz.zzz.zzz.zzz

und wieder speichern:

Das zu Anfang gestartete Setup Script lässt sich immer über folgenden Befehl aufrufen:

sudo raspi-config

Die Systemzeit des Raspi (für meine Anwendung benötige ich auch einen Zeitstempel) lässt sich mit folgendem Befehl stellen:

sudo date „MMTThhmmJJ“

Das war´s für den Anfang. Im zweiten Teil beschreibe ich dann die Sensorhardware und die Python-Scripts, die die Sensoren dann auslesen…