Wärmebildkamera mit dem Raspberry Pi (4): WLAN, autonomer Betrieb und mehr

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

---

Zur Motivation ein Video mit dem ersten Prototypen.

 Das fertige Gerät kann folgendes:

• Smartphones können sich mit dem System per WLAN verbinden
• Das System lässt sich per Smartphone bedienen
• arbeitet auch ohne Netzteil völlig autonom (mit Akku)

Das heißt: man kann das Gerät auch draußen betreiben und mit einem Smartphone oder Tablett bedienen.

Daemonen

Damit das Perl-Script für den Sensor, das Python-Script für die Servo-Steuerung und das UI automatisch im Hintergrund (als Daemon) gestartet werden wird je ein Script im /etc/init.d-Verzeichnis benötigt. Das sind die Files mlx90614 und thermopi aus dem github-Repository:

https://github.com/hermann-kurz/thermography-raspberrypi/tree/master/init.d

Diese Files werden ins Verzeichnis /etc/init.d kopiert und (als Benutzer root) mit

update-rc.d mlx90614 defaults
update-rc.d thermopi defaults

aktiviert.

Nach  einem Neustart des Raspberry Pi müssen beide Daemons laufen und sind mit einem Browser erreichbar:

unter

http://[ADRESSE DES RASPI]:8080/c

sieht man die aktuelle Temperatur (das ist der Daemon für den Sensor), unter

http://[ADRESSE DES RASPI]/

erreicht man das UI der Thermographie-Kamera.

WLAN

Für autonomen Betrieb kann der Raspberry Pi als WLAN-Accesspoint betrieben werden. Mit einem Smartphone, das damit verbunden ist, wird die Thermographie-Kamera dann bedient.

Für Accesspoint-Betrieb braucht man einen WLAN-USB-Dongle, der Master-fähig ist. Ich verwende einen TP-LINK TL-WN721N, der ohne zusätzliche Treiber erkannt wird, aber auch andere Dongles sind möglich.

hostapd

Die Accesspoint-Verwaltung übernimmt ein weiterer Daemon, hostapd.

Konfiguration WLAN-Interface

Die statische IP-Adresse kommt über einen Eintrag in /etc/network/interfaces, bei mir sieht das so aus:

auto wlan0
iface wlan0 inet static
address 192.168.1.1
netmask 255.255.255.0

Wichtig ist hier, daß das WLAN-Interface eine statische Adresse erhält.

hostapd-Installation/Konfiguration

weiter geht es mit

aptitude install hostapd hostap-utils iw isc-dhcp-server

damit wird die hostapd-Software für den Accesspointbetrieb und ein DHCP-Server (für das zugreifende Smartphone)  installiert.

In

/etc/default/hostapd 

wird die Zeile

#DAEMON_CONF=""

nach:

DAEMON_CONF="/etc/hostapd/hostapd.conf"

geändert. Danach wird der Accesspoint über

/etc/hostapd/hostapd.conf

konfiguriert. Bei mir sieht sie die Datei so aus:

interface=wlan0
###############################
# Basic Config
###############################
macaddr_acl=0 auth_algs=1
# Most modern wireless drivers in the kernel need driver=nl80211
driver=nl80211
##########################
# Local configuration...
##########################
interface=wlan0
ssid=ThermoPI
hw_mode=g
ieee80211n=1
channel=1
auth_algs=1
wmm_enabled=0
own_ip_addr=192.168.1.1

Mit dieser Konfiguration wird ein WLAN namens "ThermoPi" aufgespannt. Ein Passwort ist nicht nötig, was im Standalone-Betrieb auch nicht weiter schlimm ist.

DHCP

Geräte (Smartphones), die sich mit dem WLAN verbinden, brauchen ebenfalls eine IP-Adresse. Die wird von einem DHCP-Server geliefert, der auf dem RasPi läuft.

Konfiguration über die Datei

/etc/dhcp/dhcpd.conf

Dieser Eintrag

#
subnet 192.168.1.0 netmask 255.255.255.0 {
  range 192.168.1.2 192.168.1.254;
}

sagt dem DHCP-Server, daß er IP-Adressen im Bereich 192.168.178.2 bis 192.168.178.254 an die WLAN-Teilnehmer ausgeben soll.

Akkubetrieb

Wenn man das Gerät ohne Stromanschluß betreiben will, kann man eine "USB-Powerbank", einen Akku mit USB-Anschluß benutzen.

Betrieb

Nach Reboot des Raspberry Pi sieht man das WLAN "ThermoPi".

Nachdem man sich mit einem Smartphone verbunden hat, erhält man mit dem Browser über die URL http://192.168.178.1 die Benutzeroberfläche der Thermographie-Kamera!

Die URL kann man sich als Shortcut im Smartphone speichern und kommt dann direkt auf die Thermographie-Kamera

Über den Browser startet man am besten erstmal eine Aufnahme mit grober Auflösung, das geht schneller. Hat man den richtigen Bildausschnitt, erhöht man die Auflösung. Wenn das Bild fertig ist, gibt es einen Reload, das neueste Bild ist sichtbar. Man kann es nun auf dem Smartphone speichern.

Verbesserungsmöglichkeiten

Bei jedem Projekt gibt es Verbesserungsmöglichkeiten. Hier ein paar Vprschläge

• Der MLX90614 ist relativ träge, d.h. nach jedem Messen muß etwas gewartet werden. Damit braucht ein komplettes Thermographiebild mit höherer Auflösung recht lange, etwa 5 Minuten für ein 48x48 Pixel grosses Bild. Die Meßzeit kann aber verändert werden, Einzelheiten im Datenblatt des Sensors.
• Höhere Auflösung: Script erweitern. Nachteil: längere Scan-Zeit
• Bilder freigeben über Samba
• erfasste Bilder browsen über Smartphone

Der Code liegt auf github zur Verwendung

https://github.com/hermann-kurz/thermography-raspberrypi

jede Rückmeldung ist willkommen!

Links:

• hostapd
• Making scripts run at boot time with Debian
• Datenblatt MLX90614 
• https://github.com/hermann-kurz/thermography-raspberrypi

---

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

Wärmebildkamera mit dem RasPi (3): Ansteuerung der Servos / Auswertung mit Python

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung (dieser Teil) 4. Zusammenfassung, WLAN und  Batteriebetrieb

---

Code: 

• komplettes Projekt auf github:
• Python-Script (hier besprochen)

---

Montage des Sensors

Der MLX90614-Sensor muß in zwei Achsen bewegt werden, um ein Bild abzuscannen. Für jede Achse wird ein RC-Servo verwendet, die beiden Servos wurden mit Sekundenkleber aufeinander geklebt. Der Sensor wurde per Kabelbinder an einem Servo befestigt. Die Servos sind für etwa 5-10€ erhältlich, es genügt die "Micro"-Ausführung, da sie wenig Platz und Strom braucht.

Ansteuerung eines RC-Servos

RC-Servos (Modellbauservos) werden über Pulsweitenmodulation (PWM) angesteuert. Die Breite des Impulses bestimmt die Stellung des Servos. Üblicherweise entspricht die eine Endstellung einer Impulsbreite von 1ms, die andere einer Breite von 2ms. In Mittelstellung ist das Servo bei einem Impuls von 1,5ms.

Genauer ist das hier erklärt:

• http://wiki.rc-network.de/index.php/PWM
• http://en.wikipedia.org/wiki/Servo_control

Die PWM-Eingänge der Servos sind direkt an GPIO 24 und 25 (Pins 18 und 22 der GPIO-Kontaktleiste) angeschlossen. Zusätzlich brauchen die Servos noch Masse und +5V, das sind Pin 25 bzw Pin 2 der Kontaktleiste. Obwohl die GPIO-Pins nur 3,3V liefern, klappt bei mir die Servoansteuerung ohne weitere Zusatzschaltung. Wichtig ist, daß das Netzteil genügend Leistung hat, sonst hängt sich der Raspberry Pi auch schon mal auf.

RC-PWM und der Raspberry Pi

Der Raspberry Pi hat zwar Hardware-Unterstützung für PWM, aber leider nur für einen GPIO-Pin. Wir brauchen aber zwei Servos..

Wenn man per Software und Pythons sleep() versucht, PWM-Signale zu erzeugen, stellt man fest, daß die Pulsweite variiert und die Servos ziemlich zittern. Das passiert, weil unter Linux viele Prozesse laufen und damit die Zeitzuteilung für den Python-Prozess variiert und ungenau ist.

RPIO.PWM als Abhilfe

Chris Hager (chris@linuxuser.at) hat ein Python-Modul geschrieben, das DMA zum Erzeugen von PWM-Impulsen benutzt und so die Einschränkungen von Hardware- oder Software-PWM umgeht. Damit kann man ohne CPU-Belastung stabile PWM-Impulse erzeugen. Als Bonus gibt es noch High-Level-Funktionen zum direkten Ansteuern von Servos. Was will man mehr..

Installation von RPIO.PWM

Um das Modul zu installieren, führt man auf der Kommandozeile (eingeloggt als root  per ssh) folgende Befehle aus:

apt-get install python-dev
apt-get install python-setuptools
git clone https://github.com/metachris/RPIO.git
cd RPIO
python setup.py install

und weil wir schon dabei sind, wird gleich auch noch matplotlib für Python installiert:

apt-get install python-matplotlib

Dann noch das bottle-Framework (für den Webserver, siehe unten)

easy_install -U bottle

Damit ist unsere Python-Umgebung auf dem Raspberry Pi fertig.

Start des python-Scripts

als Benutzer root

python web.py

Aufgaben des Python-Scripts

Das Python-Script ist die zentrale Software der Thermographie-Kamera, es erledigt folgende Aufgaben:

• Webserver mit Bedienoberfläche
• Setup der Hardware
• Steuerung der Servos
• Abholen der Sensordaten
• Erzeugen des Thermographiebildes

Webserver mit Bedienoberfläche

Die Bedienung der Thermographie-Kamera erfolgt über eine Weboberfläche. Das bedeutet, daß auf dem Raspberry Pi ein Webserver laufen muß. Dazu gibt es für Python das Bottle-Web-Framework, das einen minimalen Webserver bereitstellt.

Für die Thermographie-Kamera besteht die Oberfläche aus einer einzigen index.html-Datei, die das neueste Image anzeigt. Drei Links werden vom Python-Script erkannt und erzeugen Wärmebilder mit verschiedener Auflösung, indem Parameter für den Scan-Vorgang gesetzt werden.

 

Setup der Hardware

Je nach Auflösung (small, standard und big) wird die Schrittweite der Servos berechnet und damit der Scanvorgang gestartet.

Steuerung der Servos / Erfassung der Daten

Die Datenerfassung erfolgt in einer verschachtelten Schleife für X- und Y-Koordinaten. Dazu muß vorher das Perl-Script für den Sensor gestartet sein, damit die Temperaturwerte geholt werden können.

• Jede Position wird angefahren (servo.set_servo)
• kurz gewartet (time.sleep(), der Sensor ist etwas träge). 
• Dann wird der aktuelle Temperaturwert vom Sensor-Daemon per http gelesen (mit urlopen(), response.read()) 
• und in ein Array geschrieben.

# Sweep thru one frame
  for x in range(step_count):
    servo.set_servo(servo_x, start_pos + x * step_size)
    servo.set_servo(servo_y, start_pos)
    time.sleep(pause_line)
    for y in range(step_count):
      servo.set_servo(servo_y, start_pos + y * step_size)
      time.sleep(pause)
      response=urllib2.urlopen(mlx_url)
      temperature=response.read()
      data[x,y]=temperature

Erzeugung des heatmap-Bildes

Die gemessenen Temperaturwerte befinden sich nun in einem Array. Das Array wird über die matplotlib-Library in ein .png-Image verwandelt und beschriftet. Hier das Codeschnipsel dazu:

# Generate heatmap from data array
  cmap = cm.get_cmap('jet')
  plt.clf()
  plt.imshow(data, interpolation="nearest", cmap=cmap)
  plt.axis('off')
# add temp colorbar
  cb = plt.colorbar()
  date_disp = datetime.now().strftime("%Y-%m-%d  %H:%M")
  cb.set_label('Temp (in C)  ' + date_disp)
  plt.savefig('/root/thermo/scripts/images/heatmap.png')

# save again with datecoded filename
  date_string = datetime.now().strftime("%Y-%m-%d--%H-%M")
  plt.savefig('/root/thermo/scripts/images/heatmap' + date_string + '.png')

  redirect("/html/index.html")

matplotlib ist sehr mächtig - es reichen10 Zeilen Code aus, um aus den Rohdaten ein Bild zu erzeugen!

Der Dateiname wird um das Datum ergänzt und in einem extra Verzeichnis abgespeichert. Anschließend erhält der Browser einen redirect auf die Startseite, das gerade generierte Image wird angezeigt.

Was wurde erreicht?

Nach Start von zwei Skripten mit

perl mlx.pl
python web.py

haben wir

• Eine Weboberfläche, die das neueste Wärmebild anzeigt
• Die Möglichkeit, neue Wärmebilder mit drei Auflösungen (10x10, 32x32 und 48x48 Pixel) zu erzeugen
• Bedienung über Browser via PC und Handy möglich

Links

• http://wiki.rc-network.de/index.php/PWM
• http://en.wikipedia.org/wiki/Servo_control
• RPIO.PWM, PWM via DMA for the Raspberry Pi
• Bottle-Web-Framework
• http://matplotlib.org/ 

---

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung (dieser Teil) 4. Zusammenfassung, WLAN und  Batteriebetrieb

Wärmebildkamera mit dem RasPi (2): Ansteuerung des Sensors mit Perl

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl (dieser Teil) 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

---

Schwierigkeiten..

I2C-Bus am Raspberry Pi und repeated start

Der MLX90614 hat eine I2C-Schittstelle, der Raspberry Pi ebenso und außerdem ist I2C in den Linux-Kernel der verwendeten Raspbian-Distribution integriert.

So weit, so gut! Eigentlich sollte also eine Integration ohne Klimmzüge funktionieren. Leider steckt der Teufel im Detail: der MLX90614 benutzt zum Auslesen der Temperatur die Repeated-Start-Condition, die im I2C-Standard definiert ist. Dummerweise kennt der I2C-Kernel-Treiber für den Raspberry Pi genau diesen Befehl nicht! Damit kann man den Sensor nicht per I2C-Kernel-Modul auslesen - eine andere Lösung muss her!

 

Lösung mit Perl-Modul

Glücklicherweise hat Mark Dootson ein Perl-Modul geschrieben, das die repeated-start-Funktion für den I2C-Bus nachrüstet. Auslesen des MLX90614 ist damit  mit einem Perl-Script möglich.

Er beschreibt das in seinem Blog:

• I2C Repeated Start for All

I2C-Zugriff und andere Befehle hat er in seinem HiPi-Perl-Modul zusammengefasst. Damit ist der Sensor direkt mit einer Scriptprache auslesbar.

 

HiPi-Modul für Perl installieren

Zunächst muß das Perl-Modul installiert werden. Die nachfolgende Anleitung setzt voraus, daß der Raspberry Pi unter Raspbian läuft. Andere Distributionen sind sicherlich auch geeignet, ich habe das aber nicht getestet.
Dazu muß man in einer Shell auf dem Raspberry Pi eingeloggt sein (per ssh oder direkt) und folgende Befehle auf der Kommandozeile ausführen:

wget http://raspberry.znix.com/hipifiles/hipi-install

perl hipi-install (dauert ca 15 Minuten)

Zusätzlich habe ich noch das HTTP::Server::Simple-Modul per Kommandozeile installiert:

sudo perl -MCPAN -e 'install HTTP::Server::Simple' (Fragen mit yes beantworten)

Nun ist das HiPi-Modul und das HTTP-Server-Modul installiert und man kann direkt aus Perl auf den I2C-Bus und damit auf den Thermo-Sensor zugreifen.

Die vom Sensor gemessenene Temperatur  wird über den I2C-Bus aus zwei Registern abgeholt. Dort befindet sich der Rohwert, der noch nach Grad Celsius (bzw Fahrenheit) umgerechnet werden muß.

Das Codeschnipsel zum Lesen des Rohwertes sieht folgendermassen aus:


do {
         eval {
             @reg_val = $dev->i2c_read_register_rs($register, 0x02);
         };
# an error occured, set reg_val to an invalid value
         if ($@) {
             @reg_val = (255, 255);
         }
         $raw = @reg_val[1] * 256 + @reg_val[0];
         $diff = abs($raw - $last_raw);
         $last_raw = $raw;
    } while(($diff > $max_diff) or ($raw > 32000));

In der Praxis hat sich gezeigt, daß das Auslesen nicht immer zuverlässig funktioniert, deshalb ist eine Fehlererkennung eingebaut, die bei zu großer Abweichung vom vorhergehenden Messwert (oder einem Hardware-Fehler) die Messung wiederholt (do/while-Schleife).

Das ist schonmal sehr schön, aber ich finde Python besser geeignet, um die gelesenen Daten auszuwerten und darzustellen.

Dazu müssen die gelesenen Temperaturwerte irgendwie vom Perl-Script an ein Python-Script übergeben werden. Die einfachste Methode dazu ist, das per HTTP zu tun.

 

Temperatur per HTTP auslesen

Damit man per HTTP auf die gemessenen Temperaturwerte zugreifen kann, ist ein Web-Server in das Perl-Script integriert. Das geht ganz einfach mit dem Perl-Modul HTTP::Server::Simple::CGI. Es hört auf verschiedene URLs, die den gelesenen Wert in Celsius, Fahrenheit und als Rohwert ausgeben. Das ermöglicht auch das Auslesen der Temperatur per Browser! Sehr schön zum Testen. Eine weitere URL liefert die Werte als JSON, ideal falls man den Sensor per Javascript befragen will.


Das Script liegt auf GitHub:

https://github.com/hermann-kurz/thermography-raspberrypi/blob/master/perl-sensor/mlx.pl

Gestartet wird es (als root) mit

perl mlx.pl

und läuft dann als Dämon auf Port 8080.

Wenn das Script läuft, kann man direkt im Browser den Sensor per URL aufrufen

http://ADRESSE-DES-RASPBERRY-PI:8080/c

Als JSON sieht das so aus:

und hat die Temperatur im Browser, die der Sensor gerade vor sich sieht!

Was wurde bis jetzt erreicht: Zusammenfassung

• Zugriff auf den MLX90614-Sensor via Perl
• Ein in Perl geschriebener HTTP-Server, der die gemessene Temperatur liefert
• Der Messwert kann in Celsius, Fahrenheit oder als Rohwert angezeigt werden
• Alle Werte zusammen gibt es als JSON

Nächste Schritte: Servoansteuerung, Auswertung der Messwerte in Python


Links:

• Software auf GitHub: https://github.com/hermann-kurz/thermography-raspberrypi
• https://github.com/hermann-kurz/thermography-raspberrypi/blob/master/perl-sensor/mlx.pl
• I2C Repeated Start for All
• Repeated-Start-Condition

---

1. Thermographie-Kamera mit dem Raspberry Pi 2. Ansteuerung des Sensors mit Perl (dieser Teil) 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

Wärmebild-(Thermographie)-Kamera mit dem Raspberry Pi (Teil 1: Übersicht)

Thermographie mit dem Raspberry Pi

1. Thermographie-Kamera mit dem Raspberry Pi (dieser Teil) 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

---

 

Kontaktlose Thermometer und entsprechende Sensoren sind sehr günstig erhältlich. Diese Sensoren messen pyroelektrisch die Temperatur an einem Punkt in ihrem Gesichtsfeld.

Die Idee ist es, einen solchen Sensor an einen Raspberry Pi anzuschließen, und von ihm die Daten weiterverarbeiten und anzeigen zu lassen um damit eine preiswerte Thermographie-Kamera zu bauen.

Die Bilder, die dabei rauskommen sind erstaunlich gut.

Scanmechanismus

Ein solcher einfacher Sensor misst die Temperatur nur in einen Punkt - Sensoren mit vielen Pixeln sind extrem teuer. Um ein komplettes Bild zu erhalten, muß der einpixelige Sensor das Sichtfeld mechanisch abscannen.

Für den Scan-Mechanismus lassen sich preiswerte RC-Servos einsetzen, die  direkt vom Raspberry Pi angesteuert werden können. Mit zwei Servos lässt sich dann bequem die Gegend in X- und Y-Achse abscannen.

Für eine hohe Auflösung ist ein möglichst kleines Sichtfeld ("Field of View", POV) des Sensors wichtig. Zusätzlich muß der Sensor eine Schnittstelle haben, die über den Raspberry Pi bedient werden kann. Der MLX90614 erfüllt diese Bedingungen.

Da der Raspberry Pi ein vollwertiges Linux-System ist, stehen dort auch alle möglichen Scriptsprachen und Libraries zur Nachbearbeitung und Darstellung der Daten zur Verfügung.

Bedient wird das System über einen Browser, auf dem RasPi läuft ein Webserver. Es ist also keine weitere Hardware nötig. Der Raspberry Pi kann auch batteriebetrieben als WiFi-Accesspoint konfiguriert werden. Damit kann dann ein Smartphone mit Browser als Benutzerinterface dienen.

Übersicht

Diagramm TBD

Hardware

Raspberry Pi Model B

Als Plattfrom dient der Raspberry Pi, Model B. Der hat 512 MB RAM und zusätzlich zur USB-Schnittstelle noch einen Ethernet-Anschluß. Das ist sehr praktisch zum Entwickeln, man kann sich direkt per SSH einloggen (von Windows z.B. über putty) und zusätzlich noch einen WLAN-Dongle anschließen, falls man das Gerät standalone benutzen will.

Sensor

Als Sensor wurde der MLX90614 gewählt. Er hat eine I2C-Schnittstelle, über die man ihn an den Raspberry Pi anschließen kann. Den Sensor gibt es in verschiedenen Ausführungen, die sich in der Betriebsspannung und dem Gesichtsfeld (FOV) unterscheiden.

Ich habe die Variante MLX90614ESF-DCI genommen. Der hat eine nominale Betriebsspannung von 3,6 Volt und arbeitet gut mit den 3,3V, die der Raspberry Pi bereitstellt. Das ist der MLX90614 mit dem kleinsten FOV: 5 Grad! Es gibt auch billigere Ausführungen mit 10 oder gar 35 Grad FOV, aber die sind nicht gut für diese Anwendung geeignet - das Gesichtsfeld ist einfach zu groß!

Der Sensor wird über einen Perl-Daemon abgefragt und ist per HTTP erreichbar. Grund dafür: momentan gibt es nur für Perl eine Library, mit der der Sensor über I2C angesteuert werden kann. Näheres dazu im Teil 2.

Webserver

Das Hauptprogramm ist ein Webserver, der in Python geschrieben ist. Er steuert die Servos und holt sich die Daten des Sensors per HTTP. Ist der Scan fertig werden die gewonnen Daten per python-matplotlib als Image visualisiert und an den Browser geliefert (und im Filesystem gespeichert). Nähere dazu in Teil 3 und Teil 4.

Schaltung

 

 

Software

Repository auf GitHub

Die Software wird laufend verbessert und kann auf GitHub unter

https://github.com/hermann-kurz/thermography-raspberrypi

geholt werden. Sie steht unter einer Open-Source-Lizenz

1. Thermographie-Kamera mit dem Raspberry Pi (dieser Teil) 2. Ansteuerung des Sensors mit Perl 3. Ansteuerung der Servos / Auswertung 4. Zusammenfassung, WLAN und  Batteriebetrieb

Raspberry Pi auf Spiegel Online: TOR-Router zum Selbstbau

Ganz witzig: der Raspberry Pi ist Mittelpunkt einer überaus nützlichen Bastelanleitung auf Spiegel Online: ein Tor-Router zum selberbauen, genannt SpOnionPi. Der RasPi scheint also voll im Mainstream angekommen zu sein :-). Es ist eine abgewandelte Version des adafruit Onion Pi mit zwei WiFi-Schnittstellen. Der Code liegt auf github. Respekt!

• Tor-Router zum Selberbauen: Internet-Tarnkappe für 65 Euro
• SpOnionPi: So bauen Sie sich eine Internet-Tarnkappe
• adafruit Onion Pi
• SpOnionPi

I²C mit dem Raspberry Pi, Problem mit "repeated start"

I²C-Bus - wofür?

Der I²C-Bus (Inter-Integrated-Circuit) wurde von Philips zunächst entwickelt, um mit einem geringen Pin-Count ICs innerhalb von Geräten miteinander kommunizieren zu lassen. Später brachten auch andere Hersteller Chips mit I²C auf den Markt. Seit 2006 werden auch keine Lizenzgebühren mehr verlangt, so daß I²C inzwischen sehr verbreitet ist. Im PC wird er z.B. für Temperatursensoren auf dem Motherboard verwendet oder auch zur Identifikation von VGA-Monitoren oder SDRAM-Riegeln.

Sensoren

Ein sehr interessanter Anwendungsfall für den Raspberry Pi sind Auswertungen/Erfassung von physikalischen Größen. Dafür gibt es sehr viele Sensoren, die ebenfalls eine I²C-Schnittstelle haben. Darunter welche für Temperatur, Druck, Magnetfeld (Kompass), Luftfeuchte und vieles mehr. Wem das nicht ausreicht, kann Analog-Digital-Converter (ADCs) per I²C anschließen.

Hardware-Unterstützung

Der Raspberry Pi hat den Broadcom-BCM2835-Chip als Video-Prozessor an Bord, der auch die GPIO-Pins ansteuert, die dann über eine Stiftleiste zugänglich sind. Zusätzlich hat er direkte Hardware-Unterstützung für I²C, die auch direkt über den Linux-Kernel erschlossen ist (/dev/i2c).

Kernel-Modul für I²C

Um I2C via Kernel zu benutzen, braucht dieser das Modul i2c-bcm2708. Das ist bei Linux wheezy per Default disabled, deshalb muß in der Datei

/etc/modprobe.d/raspi-blacklist.conf

Der blacklist-Eintrag für das Modul entfernt oder auskommentiert werden.

Nach dem nächsten Reboot wird das Modul geladen.

Tools

Als nächstes installiert man am besten die i2c-tools mit

sudo apt-get update && apt-get install i2c-tools

wenn ein Gerät am Bus angeschlossen ist, sieht man es mit

i2cdetect -y 1 (RasPi mit 512MB RAM)
bzw
i2cdetect -y0 (für den alten 256MB-Raspi)

Mit i2cget und i2cdump kann man sich nun die Register der angeschlossenen Devices auf dem Bus ansehen, mit i2cset lassen sich Werte speichern.

So weit so gut, ich konnte einwandfrei ein EEPROM (Firmware eines Bluetooth-Keyboards) auslesen, aber ein Thermosensor MLX90614 zeigte sich sehr zickig:

Problem mit "Repeated Start"

Symptom: i2cdetect erkennt den Sensor an Adresse 0x5a.
i2cdump liefert unsinnige Werte :-(

Andere haben das Problem auch, es liegt daran, daß das Kernelmodul bzw der BCM2835-Chip nicht die I²C-Repeated-Start-Sequenz unterstützt, die vom MLX90614 aber benötigt wird.

Somit fällt der Weg, diesen Sensor über das BCM-Kernelmodul anzusprechen, zunächst mal flach :-(

• http://en.wikipedia.org/wiki/I²C
• reading MLX90614 IR sensor

Raspberry Pi - Home Automation: 7. per Telefon schalten mit Tropo

1. Übersicht
2. Hardware - Interface vom Raspberry Pi zur Funksteckdose
3. Software auf dem Raspberry Pi Ansteuerung und Webserver
4. DynDNS, Siri & mehr
5. Schalten mit  Google Calendar und IFTTT
6. Lampe bei Sonnenaufgang einschalten
7. Raspberry Pi - Home Automation: per Telefon schalten mit Tropo (dieser Teil)

---

Funksteckdose mit Telefonnummer: Motivation und Ziel

Die Telekom hat seit neuestem ein API für telefonbasierte Dienste - das Telekom Tropo API.

Es funktioniert so, daß der Telekomserver bei einem Telefonanruf einen JSON-REST-Aufruf auf eine URL macht und von dort Befehle an den Server zurückgeschickt werden. Die Telefonnummer erhält man von der Telekom - es sind sogar Nummern in anderen Ländern möglich!

Ziel ist es, die in vorherigen Posts beschriebene internetbasierte Funksteckdosen-Steuerung mit dem Raspberry Pi über eine eigene Telefonnummer mit Sprachmenü anzusprechen:

1. man ruft die Telefonnummer der Funksteckdose an
2. es wird gefragt, ob die Steckdose ein oder ausgeschaltet werden soll
3. per Spracherkennung wird die Aktion erkannt und dann ausgeführt
4. es gibt eine Rückmeldung, fertig

Zunächst braucht man etwas Geduld, um sich die Accounts bei der Telekom zu besorgen:

• Zunächst wird ein Account beim Developercenter der Telekom benötigt: http://www.developercenter.telekom.com/
• Dann kann man dort eine Telefonnummer beantragen - das geht nur mit einem Nachweis, daß man in Deutschland lebt. Eine SIP-Adresse gibt es noch dazu.
• Zusätzlich braucht man einen Account beim Developergarden: http://www.developergarden.com/de/ dort gibt es Foren, API-Doku und einen Gutschein, mit dem man den Developercenter-Account aufladen kann
• Nun kann man eine Tropo-Anwendung im Developercenter anlegen, ein Parameter dabei ist die URL des Client-Rechners + Route: Das ist der Raspberry Pi, der die Funksteckdosen bedient.

Software auf dem Raspberry Pi

Für den Client gibt es Tropo-Libraries für PHP, Ruby, JavaScript und Python. Ich verwende das Python-API, da die bisherige Raspberry-Pi-Software ebenfalls in Python geschrieben ist und ich Tropo in den selben Webserver einbaue.

Hier die Erweiterungen des Python-Scripts aus Teil 3:

1. Import der library: Ins Verzeichnis des Scripts wird die tropo.py-Library gelegt, Zeile 2 importiert sie.

from bottle import route, run, post, request
from tropo import Tropo


2. Ansage des Sprachmenüs mit Auswahl. Das ist die URL der Tropo-Anwendung im Developercenter

@post('/homeswitch')
def index():
  tropo = Tropo()
  tropo.ask(choices = "1(1,ein),0(0,aus)", timeout=30, name="choice", say = "Sag
en sie. ein. oder. aus. um die Heizung zu schalten", recognizer = "de-de", voice
 = "Katrin")
  tropo.on(event = "continue", next ="/continue")
  json = tropo.RenderJson()
  print json
  return json

Dieser Code wird beim Anruf der Telefonnummer vom Telekom-Server auf dem Raspberry Pi aufgerufen. Der Anrufer hört den Text in "tropo.ask" (Text-To-Speech vom Telekomserver, die Punkte machen kleine Pausen). Als Stimme wird "Katrin" verwendet. Für die Spracherkennung wird deutsch genommen. Die Auswahl des "choice" erfolgt entweder über Spracheingabe ("ein", "aus") oder Tonwahl (0,1). Als nächsten Schritt wird der Telekom-Server die URL "/continue" aufrufen.

3. Auswertung und Schalten der Steckdose

@post("/continue")
def index():
  rjson = request.json
  answer = rjson['result']['actions']['value']
  interpretation = rjson['result']['actions']['interpretation']
  if answer == '0':
    setSwitch('A', 'OFF')
    print "A OFF"
  else:
    setSwitch('A', 'ON')
    print "A ON"
  print answer
  t = Tropo()
  t.voice = "Katrin"
  t.say("Heizung ist jetzt " + interpretation)
  return t.RenderJson()

Die benötigten Parameter werden aus dem hereinkommenden JSON-REST-Aufruf extrahiert ("answer" und "interpretation"). Je nach "answer" wird die Steckdose ein- oder ausgeschaltet. Anschließend kommt noch eine Ansage des neuen Zustandes und der Telekom-Server legt auf.

Mashup von Telefon- und Webdienst: Ziel erreicht!

Die Funksteckdose hat eine eigene Telefonnummer und kann per Spracherkennung ein- oder ausgeschaltet werden. Dazu wurden nur ungefähr 25 Zeilen Code benötigt!

Links

• Telekom Tropo API
• http://www.developercenter.telekom.com/
• http://www.developergarden.com/de/

---

1. Übersicht
2. Hardware - Interface vom Raspberry Pi zur Funksteckdose
3. Software auf dem Raspberry Pi Ansteuerung und Webserver
4. DynDNS, Siri & mehr
5. Schalten mit  Google Calendar und IFTTT
6. Lampe bei Sonnenaufgang einschalten
7. Raspberry Pi - Home Automation: per Telefon schalten mit Tropo (dieser Teil)