Pollin-Touchdisplay für den Pi konfigurieren

Das günstige Touch-Display ist für Projekte mit dem Pi quasi wie geschaffen. Allerdings muss man ein paar Handgriffe vornehmen, damit beides auch gut miteinander funktioniert. Wir zeigen Schritt für Schritt, wie es geht.

Lesezeit: 8 Min.
In Pocket speichern
vorlesen Druckansicht Kommentare lesen 16 Beiträge
Von
  • Daniel Bachfeld
Inhaltsverzeichnis

Für mobile Einsätze ist ein Raspberry Pi eigentlich prima geeignet. Was ihm fehlt, ist ein günstiges Display, das sich ebenfalls für unterwegs oder zum Einbau in kleine Gehäuse eignet. Pollin hat seit wenigen Monaten ein 7"-Display mit einer Auflösung von 1024 × 600 Pixel für schlappe 40 Euro im Programm, das sogar einen HDMI-Eingang bietet. Für 10 Euro mehr legt Pollin noch einen resistiven Touchscreen mit USB-Controller drauf. Wir haben uns das Bundle näher angeschaut und zeigen ein paar Tricks, wie man es richtig konfiguriert.

Aus dem Make-Testlabor

Die Make-Redaktion probiert viel mehr aus, als ins alle zwei Monate erscheinende Heft passt. Deshalb veröffentlichen wir auf unserer Webseite in loser Folge weitere Testberichte.

Für einen Schnellstart genügt es, das Folienkabel des Displays an den Controller anzuschließen. Den Controller verbindet man per HDMI-Kabel mit dem Pi. Der Controller bietet daneben Anschlüsse für DVI, VGA und Composite an, womit er so ziemlich für jeden anderen Einsatzweck gerüstet ist. Zur Versorgung erwartet der Controller eine Spannung zwischen 9 und 18 Volt mit maximal 500 mA.

Der Display-Controller liefert auf Anfrage leider fehlerhafte EDID-Daten bezüglich seiner Auflösung zurück: 1280 x 720 und 1920 x 540. Der Pi stellt sich deshalb beim Booten fälschlicherweise auf erstere Auflösung ein, womit in der Textkonsole Texte nur schwer zu erkennen sind und in der grafischen Oberfläche alles matschig aussieht. Abhilfe bringt es, dem Pi die richtige Auflösung manuell mitzuteilen. Standardmäßig kennt der Pi das Auflösungspaar 1024 x 600 für HDMI jedoch nicht, weshalb man es ihm beibringen muss. Dazu genügt es, in der Datei /boot/config.txt (mit sudo nano öffnen!) folgende Zeilen einzufügen:

framebuffer_width=1024
framebuffer_height=600

hdmi_force_hotplug=1
hdmi_cvt=1024 600 60 3 0 0 0

hdmi_group=2
hdmi_mode=87

Das Display spiegelt stark und es zieht den Staub an, wie Speck Mäuse. Die Textdarstellung ist aber scharf genug.

und die Datei zu speichern. Nach einem Neustart erscheint die Schrift klar und die Grafik scharf. Zwar sollte man Textverarbeitung mit diesem Konglomerat vermeiden, für Wartungszwecke oder zur Anzeige von Daten oder Zuständen reicht es allemal.

Etwas aufwendiger als die Anpassung der Auflösung ist die Integration des Touch-Controllers. Der liefert zwar per USB die Daten an den Raspberry, im Standardkernel ist das Modul für diesen Controller (eGalaxy) jedoch nicht enthalten. Fortgeschrittene Anwender ahnen, was nun kommt: Einmal Kernel kompilieren bitte! Das kann man zwar direkt auf dem Pi erledigen, allerdings dauert das epische 22 Stunden...

Alternativ baut man einen neuen Wheezy-Kernel einfach auf dem PC, was eigentlich gar nicht schwierig ist. Eine aktuelle Ubuntu-Distribution drängt sich dafür quasi auf, wir haben es mit Version 14.04 ausprobiert. Wer nur Windows auf seinem Rechner installiert hat und das auch nicht ändern will, bootet von eine Live-CD, die beispielsweise dem c't Special "Umstieg auf Linux" oder dem aktuellen Linux-Sonderheft beliegt.

Zum Kernelübersetzen sind diverse Werkzeuge erforderlich, die man mit

sudo apt-get install git libncurses5 libncurses5-dev qt4-dev-tools qt4-qmake pkg-config build-essential gcc-arm-linux-gnueabi bc

nachinstalliert. Anschließend legt man für sein Projekt einen Ordner an

mkdir raspberry

und wechselt mit

cd raspberry

hinein. Nun besorgt man sich weitere Tools von der Raspberry Foundation

git clone https://github.com/raspberrypi/tools.git
git clone https://github.com/raspberrypi/linux.git
cd linux
Zunächst estellt man die Konfigurationsdatei
make ARCH=arm CROSS_COMPILE=/usr/bin/arm-linux-gnueabi- bcmrpi_defconfig
die man nun seinen Bedürfnissen anpasst:

make ARCH=arm CROSS_COMPILE=/usr/bin/arm-linux-gnueabi- menuconfig

Mit der grafischen Oberfläche fällt die Spiegelung nicht mehr so stark ins Gewicht.

Unter Device Drivers/Input Device Support/ setzt man bei Touch Screens mit der Leertaste das Häkchen und wechselt mit Return in das Menü zur Auswahl. Dort wählt man "USB Touchscreen Driver" aus, in dem man die Leertaste drückt. Mit der ESC-Taste oder Exit verlässt man die Konfiguration – am Ende muss man die Nachfrage zum Speichern bestätigen.

Alsdann kann man mit dem Übersetzen loslegen:

make ARCH=arm CROSS_COMPILE=/usr/bin/arm-linux-gnueabi- -k -j3

Sobald der Vorgang abgeschlossen ist, erzeugt man die Kernel-Module

mkdir ../modules
make modules_install ARCH=arm CROSS_COMPILE=/usr/bin/arm-linux-gnueabi-INSTALL_MOD_PATH=../modules/

Nun erzeugt man die Kernel_Datei

cd ../tools/mkimage/
./imagetool-uncompressed.py ../../linux/arch/arm/boot/Image


und kopiert sie auf die SD-Karte (Pfadangaben für Ubuntu 14.04).

sudo rm /media/username/boot/kernel.img
sudo mv kernel.img /media/username/boot/


wobei username der eigene Nutzername ist. Boot bezeichnet die Boot-Partition, die in der Regel auch genauso heißt, unter Umständen kann es auch eine kryptische alphanumerische Zeichenfolge sein.

Anschließend löscht man die alten Modul- und Firmware-Ordner auf der Karte (oder benennt sie um, falls man doch wieder zum alten Kernel zurückkehren will)

sudo rm -rf /media/username/rootfs-partition-uuid/lib/modules/
sudo rm -rf /media/username/rootfs-partition-uuid/lib/firmware/


Nun wechselt man in den Modul-Ordner

cd ../../modules/

und kopiert den Modul- und Firmware-Ordner

sudo cp -a lib/modules/ /media/username/rootfs-partition-uuid/lib/
sudo cp -a lib/firmware/ /media/username/rootfs-partition-uuid/lib/


Vor dem Unmounten der SD-Karte muss man die Volumes unbedingt synchronsieren:

sync

Ist der Touch-Controller an den Pi angeschlossen, kann es losgehen: Karte einstecken und booten.

Grundsätzlich funktioniert die Eingabe über das Touchdisplay, leider "tippt" man ohne vorherige Kalibrierung meist daneben. Die Kalibierung ist aber schnell erledigt. Auf dem Pi (per SSH-Verbindung) installiert man folgende Pakete nach:

sudo apt-get install libx11-dev libxext-dev libxi-dev x11proto-input-dev

anschließend lädt man sich die Kalibrierungssoftware auf den Pi herunter, entpackt sie und wechselt in das Quellverzeichnis

wget http://github.com/downloads/tias/xinput_calibrator/xinput_calibrator-0.7.5.tar.gz
tar -xvzf xinput_calibrator-0.7.5.tar.gz
cd xinput_calibrator-0.7.5


Der klassische Compiler-Dreisatz baut dann die ausführbare Datei:

./configure
make
sudo make install


In der grafischen Oberfläche LXDE öffnet man ein Terminalfenster und startet die Software

xinput_calibrator

Nach der Kalibrierung kann man beispielsweise die Python-Games prima über das Touch-Display bedienen.

Das Tool blendet nacheinander in den Bildschirmecken Kreuze ein, die man antippen muss. Ist das erledigt (manchmal meckert das Tool, man hätte nicht richtig getippt), ist der Bildschirm kalibriert und der Cursor bewegt sich dahin, wo der Finger ist. Um das ganze permanent zu machen, muss man die vom Tool angezeigten Daten respektive den Abschnitt in eine Konfigurationsdatei speichern. Standardmäßig existiert sie unter Wheezy nicht, weshalb man zunächst einen Unterordner

sudo mkdir /etc/X11/xorg.conf.d

und dann die Datei anlegen muss:

sudo nano /etc/X11/xorg.conf.d/01-input.conf

Darin speichern man den Abschnitt. (Section .. End Section).

Mit den richtigen Einstellungen lässt sich der Bildschirm kurzzeitig auch für das produktive Arbeiten auf dem Pi einsetzen. Normales Anklicken per Finger funktioniert gut; was nicht gut funktioniert, sind Doppelklicks über die Toucheingabe. In unserem Test gelang es eher zufällig, Doppelklicks zu produzieren – was eher dem Touch-Controller als dem Screen selbst anzulasten ist. Dessen resistive Arbeitsweise verlangt nebenbei einen deutlichen Fingerdruck; man wird daher für präzise Eingaben auf den guten alten PDA-Griffel zurückgreifen. Zusammen mit Pygame oder anderen GUIs ist das Touchdisplay zur Bedienung aber durchaus brauchbar. (dab)