14.07.2014

Neuer Raspberry Pi, Model B+

Ein neues Modell des Raspberry Pi scheint fertig zu sein. Bei einzelnen Händlern ist es schon bestellbar! RS-Online listet ihn mit einem Preis von 29,50€ (ohne MWst).

Unterschiede zum alten Raspberry Pi, Model B
  • Vier (statt zwei) USB-Ports
  • Keine extra Analog-Video-Buchse
  • Platinenlayout nicht so zerklüftet
  • Mehr I/O-Pins
  • Bisherige Gehäuse und Shields passen nicht mehr

Was ist gleich geblieben?
  • CPU & Taktfrequenz
  • Speicher 512MB
Ein Schritt in die richtige Richtung (finde ich). Mehr Speicher und eine schnellere CPU ständen einem neuen RasPi sehr zu gute..

Update: inzwischen gibt es auch eine offizielle Ankündigung von der Raspberry Pi Foundation.

Links

21.06.2014

Verkehrsflugzeuge Live-Tracking per ADS-B mit dem Raspberry Pi

Am Himmel sieht man eigentlich immer Kondensstreifen. Es wäre doch nett zu wissen, was für ein Flugzeug da jeweisl dahintersteckt.

Mit einem Raspberry Pi und einem billigen DVB-T-Dongle und ein bischen Software ist das kein Problem.

dump1090 - Ausgabe als Karte


Zutaten

  • Raspberry Pi
  • DVB-T-Dongle
  • RTL_SDR-Software zum Ansprechen des DVB-T-Dongles
  • dump1090 - Software zum Auswerten / Anzeigen der ADS-B-Information

Zeitaufwand

ca 2-3h

Kosten

Ca 20 € für das DVB-T-Dongle + vorhandener Raspberry Pi

ADS-B zur Positionsbestimmung

Die meisten Verkehrsflugzeuge haben einen Automatic dependent surveillance-broadcast (ADS-B)-Transponder an Bord, der die aktuelle Position, Geschwindigkeit, Höhe und ID des Flugzeugs in einem standardisierten Datenformat auf 1090 MHz ausstrahlt. Wenn man diese Information empfängt und dekodiert, kann man Position, Kurs und Flugnummer live auf einer Karte anzeigen.

DVB-T-Dongle

Spezialisierte Empfänger-Hardware ist teuer. Man kann aber auch Billig-Hardware, die eigentlich für einen anderen Zweck gedacht war, verwenden.

Möglich wird dies durch die Entdeckung, daß preisgünstige (ab 10€!) DVB-T-USB-Dongles als Software Defined Radio (SDR) betrieben werden können. Voraussetzung ist der  Realtek RTL2832U-Chip, der in vielen  Dongles verwendet wird.  Dabei geht der Empfangsbereich von etwa 25 MHz bis hinauf zu 1,7 GHz!

Dazu braucht man noch Software: RTL-SDR zum Ansprechen des Dongles und darauf aufsetzend dump1090 zum Auswerten und Anzeigen der Flugzeugpositionen - beides ist als Open source-Software frei verfügbar.

Nicht jeder Dongle ist geeignet, ich habe mir einen über Amazon.com in Amerika bestellt. Vorteil hier war, daß der Anbieter die Funktion mit RTL-SDR-Software garantiert. Kostenpunkt war knapp 20€ (mit Versand). Der Dongle zieht einiges an Strom, deshalb ist ein etwas stärkeres Netzteil wichtig (bei mir funktioniert ein 1A-Steckernetzteil). Evtl. muß man den Dongle über einen Powered USB-Hub betreiben.

Low-Level-Software: RTL-SDR

Die Software zum Ansprechen von DVB-Dongles heißt RTL-SDR. Neben der librtlsdr-Library enthält sie auch noch einige Kommandozeilenprogramme für Basisfunktionen. Sehr viele Programme, unter anderem dump1090, benutzt librtlsdr als API zum Dongle. RTL-SDR muß zunächst auf dem Raspberry Pi übersetzt werden.

Vorbereitung

Auf dem Raspberry Pi ist Raspbian (Debian wheezy) installiert. Als Benutzer pi werden die zum Bau benötigten Packages installiert: auf der Kommandozeile:

sudo apt-get install git cmake libusb-1.0-0-dev build-essential

Bauen der RTL-SDR-Software

Anschließend kann die RTL-SDR-Library gebaut werden:

cd
git clone git://git.osmocom.org/rtl-sdr.git
cd rtl-sdr/
mkdir build
cd build/
cmake ../ -DINSTALL_UDEV_RULES=ON
sudo make install
sudo ldconfig
cd ~
sudo  cp ./rtl-sdr/rtl-sdr.rules /etc/udev/rules.d/
sudo reboot


dump1090 - Software für ADS-B

Zum Dekodieren und Anzeigen der ADS-B-Information hat Salvatore Sanfilippo das Programm dump1090 geschrieben. Diese Software hat u.a. einen eingebauten Webserver, mit der die Daten live in einer Karte angezeigt werden könnnen (siehe oben)!

Bauen der Software ist sehr einfach. Ich verwende die verbesserte Version von Malcolm Robb:

git  clone  git://github.com/MalcolmRobb/dump1090.git
cd dump1090/
make


Anschließend kann man das Programm starten, es hat einige Kommandozeilen-Optionen. Mit

nohup ./dump1090 --net&

läuft es im Hintergrund und startet auf Port 8080 einen Webserver. Geht man mit einem Browser drauf sieht man eine Karte mit (hoffentlich) vielen eingeblendeten Flugzeugen (siehe oben)! Die Karte wird in Echtzeit upgedated - zusätzlich werden weitere Informationen über die Flugzeuge angezeigt, der Kurs wird mitgeloggt, etc.

Antenne

Mit der mitgelieferten Antenne zum DVB-T-Stick sehe ich Flugzeuge bis etwa 40 km Entfernung. Eine einfache selbsgebaute Antennen für 1090 MHz kommt da wesentlich weiter, ein einfache Möglichkeit siehe http://antirez.com/news/46. Im README zu dump1090 sind dazu noch weitere Links. 

Links

21.02.2014

iBeacon mit dem Raspberry Pi (Apples Bluetooth-Low-Energy indoor-Navigation)

Apple hat mit IOS 7 die iBeacon-Technologie eingeführt. Die zugehörige Empfänger-Hardware ist auf dem iPhone (ab iPhone 4s) und iPad (ab 3. Generation + iPad mini) vefügbar.

Ältere Geräte haben kein Bluetooth Low Energy und funktionieren nicht mit iBeacons! Das Gegenstück - die iBeacon selbst - kann man entweder fertig kaufen, oder mit einem Raspberry Pi selbst bauen.

Schnellstart : iBeacon mit dem Raspberry Pi

  1. auf dem Raspberry Pi: Image installieren: 2014-01-07-wheezy-raspbian 
  2. BLE-Dongle in RasPi stecken
  3. bluetooth-Software installieren (als root):

apt-get install libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev
wget www.kernel.org/pub/linux/bluetooth/bluez-5.14.tar.xz
unxz bluez-5.14.tar.xz
tar xvf bluez-5.14.tar
cd bluez-5.14/
./configure --disable-systemd
make
make install

4. Beacon starten
hciconfig hci0 up
hciconfig hci0 leadv 3 
hcitool -i hci0 cmd 0x08 0x0008 1E 02 01 1A 1A FF 4C 00 02 15 91 2E 23 A0 97 1E 11 E3 A5 E2 08 00 20 0C 9A 66 00 00 00 00 C5 00

5. iBeacon-App auf iPhone installieren (iBeacon locate (Radius Networks) oder AirLocate (Apple))

6. App für UUID 912E23A0-971E-11E3-A5E2-0800200C9A66 konfigurieren
7. fertig



Details/Erläuterung

Was ist eine iBeacon?

Eine iBeacon ist zunächst einmal ein Sender, der der per Bluetooth Low Energy (BLE) eine UUID und ein bischen Zusatzinformation sendet. Kommunikation geht also nur von der iBeacon in Richtung mobiles Endgerät, in die andere Richtung wird nichts übertragen. Auf Bluetooth-Ebene sind das Bluetooth-Low-Energy-Advertisement-Packets, die  im Sekundenrhytmus ausgestrahlt werden.

App wird in der Nähe einer iBeacon aktiv

Das Mobilgerät empfängt nun diese Advertisement-Pakete. Ist eine UUID dabei, die in einer installierten App zugeordnet ist, wird diese App angezeigt und sogar gestartet, falls sie gerade nicht aktiv ist.  Die App weiß nun, daß jetzt eine zugeordnete iBeacon in der Nähe ist und kann entsprechende Aktionen ausführen. Sind mehrere iBeacons im Empfangsbereich, kann durch Triangulation sogar der Standort genauer bestimmt werden. Reichweite eines iBeacons sind nominal etwa 50m, in Gebäuden deutlich weniger, je nach Situation.

Use cases

Use-cases können z.B. Läden sein, die einen Kunden auf ein Sonderangebot hinweisen, oder Museen, die Zusatzinformationen zu bestimmten Kunstwerken liefern, Lenken von Besuchern in Stadien, etc. Wichtig ist, daß dem Mobilgerät nur der Standort bekannt gemacht wird, eine App muß darauf entsprechend reagieren und die eigentliche Information an den Benutzer liefern.

Die iBeacon-Technologie wird oft als Apples Antwort auf NFC gesehen - das trifft aber nicht den Kern der Sache, NFC hat nur eine Reichweite von wenigen cm, eine iBeacon reicht wesentlich weiter.

iBeacon-Hardware

Verschiedene Hersteller bieten fertige iBeacons an, oder haben die Lieferung angekündigt. Das sind meist Knopfzellen-betriebene Geräte, die z.B. an ein Regal geklebt werden können.

Raspberry Pi als iBeacon

Mit einem Raspberry Pi und einem Bluetooth-Low-Energy (BLE) -Dongle geht das auch und man kann damit viel leichter (per Software) die UUID und andere Parameter ändern. Nachteil ist natürlich der höhere Energieverbrauch.

Im Internet gibt es dazu Anleitungen, es sind allerdings einige Stolperfallen zu überwinden (wenn man Pech hat)

http://learn.adafruit.com/pibeacon-ibeacon-with-a-raspberry-pi/overview
http://developer.radiusnetworks.com/ibeacon/virtual.html

Hardware: Bluetooth Low-Energy-Dongle.

Ein normales USB-Dongle funktioniert nicht! Das Dongle muß Bluetooth Low Energy (BLE) unterstützen - wenn "Bluetooth V4.0", "Bluetooth smart" oder "Bluetooth smart ready"  auf der Packung steht, ist das meist der Fall.

Ich habe mit zwei verschiedenen Dongles Erfolg gehabt.

1. LogiLink USB Bluetooth V4.0 Dongle.
Die USB-ID dieses Dongle ist 0a12:0001. Gekauft bei Pollin.de - es kommt in so einer Packung:

2. Plugable USB-BT4LE Bluetooth 4.0 USB Adapter for Windows and Linux PCs
http://plugable.com/products/usb-bt4l.
USB-ID ist 0a5c:21e8. Gekauft habe ich dieses Dongle bei Amazon.de

Software:

Als OS-Image für den Raspberry Pi (Model B) verwende ich 2014-01-07-wheezy-raspbian.zip. Zusätzlich müssen einige Software-Packages installiert und dann die aktuelle BlueZ-Software (Bluetooth-Stack) gebaut werden. Dazu loggt man sich als root auf dem RasPi ein und führt folgendes aus (make dauert etwa 30 Minuten):

apt-get install libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev
wget www.kernel.org/pub/linux/bluetooth/bluez-5.14.tar.xz
unxz bluez-5.14.tar.xz
tar xvf bluez-5.14.tar
cd bluez-5.14/
./configure --disable-systemd
make
make install

Anschließend braucht man eine UUID (die man sich z.B. bei http://www.famkruithof.net/uuid/uuidgen generieren kann oder man erfindet selbst eine) als Identifikation des iBeacon.

Zusätzlich wird eine MAJOR-Nummer (16 Bit, Gruppe von iBeacons) und eine MINOR-Nummer (16 Bit, individuelle iBeacon) mitgesendet. Als letzter Wert kommt noch die RSSI (Received Signal Strength Indicator) hinzu, das ist ein Wert für die Sendeleistung. Aus der RSSI und der tatsächlich empfangenen Signalstärke kann der Empfänger die Entfernung zum Sender abschätzen.

Eine App horcht auf eine festgelegte UUID, MINOR und MAJOR sind dabei beliebig. Ein guter Anfangswert für RSSI ist -59, das entspricht 0xC5 (hex).

Hier die von mir verwendeten Werte:

iBeacon prefix: 02 01 06 1A FF 4C 00 02 15 (fix)
UUID: 912E23A0-971E-11E3-A5E2-0800200C9A66
MAJOR: 0000
MINOR: 0000
RSSI:  C5

mit diesem Shell-Script wird die iBeacon gestartet, wichtig war bei mir, daß die Reihenfolge der Befehle  eingehalten wird:

#!/bin/bash
#
# Start interface
hciconfig hci0 up
#
# Set adapter to "Low Energy Advertise"
hciconfig hci0 leadv 3
#
# start advertising with 
# UUID: 912E23A0-971E-11E3-A5E2-0800200C9A66
# MAJOR: 0000
# MINOR: 0000
# RSSI:  C5
#
# next command is *one* line
hcitool -i hci0 cmd 0x08 0x0008 1E 02 01 1A 1A FF 4C 00 02 15 91 2E 23 A0 97 1E 11 E3 A5 E2 08 00 20 0C 9A 66 00 00 00 00 C5 00

App auf dem iPhone

Zum Lokalisieren und Testen von iBeacons habe ich drei iPhone-Apps gefunden, aber nicht alle funktionieren bei mir. Wichtig ist, daß die UUID richtig eingegeben wird. Hier eine Übersicht der Apps die ich getestet habe:
  • iBeacon Locate (Radius Networks) http://www.radiusnetworks.com/ibeacon-services.html
  • AirLocate (Apple): funktioniert, Sourcen verfügbar
  • Beacon Tool: funktioniert bei mir nicht (iPhone 4S, es wird keine iBeacon gefunden)
Am besten gefallen hat mir iBeacon Locate. AirLocate liegt als Beispiel von Apple im Quelltext vor, kann also gut als Ausgangspunkt für eine eigene App dienen.

iBeacon-Technologie für Android

Seit Android 4.3 gibt es auch auf dieser Plattform Bluetooth Low-Energy-Unterstützung. Allerdings habe erst wenig Android-Geräte BLE-Hardware eingebaut. Die Situation ist aber gerade stark im Fluß.

Stolperfallen

  • Es ist Bluetooth Low-Energy-Dongle nötig: o.g. Logilink oder plugable-Dongle funktionieren bei mir
  • Die Reihenfolge der hcitool-Befehle ist kritisch
  • Gerät (iPhone/Android) muß BLE unterstützen
  • Nicht alle Apps funktionieren

App-Entwicklung


Links



18.01.2014

Internet of things, Sensordata in the cloud: eine Bluetooth-Low-Energy-Wetterstation mit dem Raspberry Pi

Mal ein Wochenendprojekt ohne Löten

In den letzten Jahren gibt es interessante Entwicklungen im Bereich Sensoren (MEMS-Sensoren), Computer (Raspberry Pi!), Services (Cloudservices) und Datenübertragung per Funk (Bluetooth Low Energy).

Mit einem Raspberry Pi, einem Sensorträger von Texas Instruments und etwas Code kann man das ganz einfach selbst mal anwenden! Und zwar ganz ohne löten.

Code:

https://github.com/hermann-kurz/weatherstation-sensortag

Sensoren! Texas Instruments Sensor Tag

Bei Texas Instruments gibt es für 25$, das sind keine 20 € (inklusive extrem schnellem Versand!) das TI Sensor Tag, das gleich sechs Sensoren für folgende Meßgrößen enthält:
  • Luftfeuchtigkeit
  • Luftdruck
  • Magnetfeld
  • Gyroskop
  • Beschleunigung
  • diverse Thermometer
  • kontaktloses Infrarot-Thermometer
Die Sensoren hängen an einem I2C-Bus, der von einem CC2541-System-on-Chip gesteuert wird. Der CC2541 hat Bluetooth-Low-Energy an Bord, über das das Sensortag angesprochen werden kann. Die Firmware kann über Bluetooth upgedated werden, das Sensor Tag ist eine Demo-Anwendung für TIs Bluetooth-Technologie.


Bluetooth Low Energy

Bluetooth Low Energy (BLE) ist auf geringen Energieverbrauch getrimmt, ein Ziel ist der jahrelange Betrieb von Sensoren mit einer Knopfzelle. Das TI Sensor Tag schafft das zwar nicht ganz, ist aber dennoch ziemlich beeindruckend.

BLE ist noch nicht besonders weit verbreitet. Neuere iPhones/iPads und einige wenige Android-Geräte beherrschen es aber schon. Dafür gibt es von Texas Instruments Apps, die direkt mit dem Sensor Tag kommunizieren können. Quellcode ist ebenfalls verfügbar.

Auslesen der Daten mit dem Raspberry Pi

Um die Daten mit einem Raspberry Pi auszulesen, braucht man ein BLE-fähiges USB-Dongle. Ich bin nach der Anleitung von Michael Saunby vorgegangen und habe das Plugable usb-bt4le verwendet. Dazu muß man eine neuere Version des Bluez-Bluetooth-Stacks für Linux compilieren um BLE-Support zu erhalten.

Ian Harvey hat darauf basierend eine Python-Library geschrieben, die er auf GitHub zum Download bereitstellt. Wenn man die Library gebaut hat (etwas Fummelei nötig) kann man das TI Sensor Tag direkt von Python aus ansprechen und die Messwerte auslesen!

Wetterhäuschen

Zählt man man die Sensoren so durch, sieht man, daß das Sensor Tag eigentlich eine verkleidete Wetterstation ist - drahtlose Anbindung inklusive!

Da der Sensor im Freien hängen soll, aber nicht direkt der Witterung ausgesetzt sein darf, haben meine Tochter und ich (danke Johanna!) ein Wetterhäuschen ganz grob nach dieser Anleitung gebaut.

Das Wetterhäuschen haben wir aus ein paar Holzleisten und Lamellenelementen aus dem Baumarkt zusammengeschraubt und geleimt. Dann mit wetterfestem weissem Lack angemalt.


Sieht total professionell aus. Den Deckel kann man aufklappen, dort ist ein Metallwinkel verschraubt, an dem das Sensortag per Kabelbinder befestigt ist, so daß es ziemlich mittig im Wetterhäuschen hängt.

Tempo-DB: Daten in der Cloud

Nächster Schritt ist das Speichern der Daten. Normalerweise stopft man die  in eine Datenbank und kann dann später schöne Graphen damit zeichnen. Das geht auch wunderbar auf dem Raspberry Pi, ist aber langweilig (kann ja jeder). Viel interessanter ist es, das mal einem darauf spezialisierten Anbieter zu überlassen.

Tempo-DB ist ein solcher Anbieter. Dessen Datenbank ist für Sensordaten optimiert, die pro Messung eine Timestamp/Messwert-Paar umfassen. Dafür sind es extrem viele Daten, die mit der Zeit anfallen können. Tempo-DB sorgt für Verfügbarkeit, Backups, Betriebssicherheit. Das lässt sich Tempo-DB normalerweise bezahlen, aber es gibt einen kostenlosen Plan, mit dem man bis zu 5 Millionen Datensätze speichern darf. Wenn jede Minute ein Datensatz anfällt, reicht das für knapp zehn Jahre, ist also für eine einzelne Wetterstation erstmal OK.

Einzige Voraussetzung ist ein Internetanschluss. Tempo-DB hat ein nettes REST-API, das man über Libraries benutzen kann, die in verschiedenen Script-Sprachen vorliegen.

Ich benutze in diesem Fall Python, da die Sensoren ja ebenfalls mit Python ausgelesen werden. Dazu habe ich Ian Harveys Beispiel-Script ein bischen angepasst, es steht auf Github zum Download bereit. Das Script rechnet auch noch gleich den gemessenen lokalen Luftdruck in den äquivalenten Luftdruck auf Meereshöhe um (mit der barometrischen Höhenformel, YEAH SCIENCE!!).

Tempo-DB hat ein schönes Backoffice, in dem man sich die erfassten Daten anschauen kann. Das sieht dann so aus:



Probleme, To-Dos, Workarounds

Batterielaufzeit

Mit einer CR2032-Knopfzelle habe ich bis jetzt leider nur eine Laufzeit von etwa zehn Tagen erreicht, obwohl die Sensoren nur alle fünf Minuten eingeschaltet und abgefragt werden. Eine CR2032-Zelle hat etwa 220 mAh, d.h. das Tag braucht etwa 1 mA - das ist zu viel. Mir ist noch nicht klar, warum.

Als Workaround werde ich zwei Monozellen als Energiequelle nehmen, dort passen 22 Ah rein, also etwa hundert mal soviel

Reichweite

Die Bluetooth-Reichweite beträgt nur wenige Meter, durch eine Holzwand nach draussen ging erstmal nichts. Ich musste mit dem Bluetooth-Adapter am USB-Kabel rumhantieren, jetzt komme ich auf fünf Meter.

Code

Der Code ist nicht sehr schön :-)
https://github.com/hermann-kurz/weatherstation-sensortag

Start

Bevor das Python-Script Kontakt zum Sensor aufnimmt, muß das Sensor-Tag erst mit einem

hcitool lescan

erkannt worden sien.


TI Sensor Tag
User Guide auf dem Sensortag-Wiki
Plugable usb-bt4le
Bluez-Bluetooth-Stack
https://github.com/IanHarvey/bluepy


12.12.2013

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:



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

15.08.2013

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: 




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




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

12.08.2013

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




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