Da sich das Raspberry PI immer mehr durchsetzt, habe ich mir gedacht ein paar Anleitungen zu schreiben um euch ein paar Möglichkeiten mit dem RPi zu zeigen. Grunderfahrung mit dem RPi und Linux ist notwendig. Verwendet wird Raspbian, ein zubereitetes Debian für's RPi.
In dieser Anleitung werde ich euch zeigen, wie ihr einen kleinen LCD mit einem Raspberry PI verbinden und auch nutzen könnt. Am Ende werdet Ihr eine kleine Textausgabe auf eurem LCD sehen können.
Ich verwende einen 2,6 Zoll Display (maximal 2 Zeilen).
Als erstes müssen wir den Display mit der GPIO-Schnittstelle des Raspberry PI verbinden.
Folgende Anschlüsse müssen wir verbinden:
GND (Grund)
VCC (5V)
SDA
SCL
Wir schließen die Kabel nun wie folgt an:
GND (Grund) [GPIO PIN 6] (ist der dritte Pin von rechts)
VCC (5V) [GPIO PIN 2] (ist der erste von rechts)
SDA [GPIO PIN 3] (ist der zweite von links)
SDC [GPIO PIN 5] (ist der dritte von links)
Nun können wir unseren Raspberry PI starten.
Als nächstes müssen wir überprüfen, ob er den Display auch erkennt.
Nun gibt es zwei Unterschiede zwischen Model A und Model B.
Bevor wir soweit sind, müssen wir nun die notwendigen Tools auf unserem
Raspberry PI installieren. Wir installieren nun auch direkt Python mit, damit
wir später direkt unseren Raspberry PI mit einem Python Script ansteuern können.
Folgende Tools können wir nun mithilfe der Konsole installieren:
apt-get install python-smbus
apt-get install i2c-tools
Außerdem müssen wir nun die Module für unseren Display laden.
Dazu öffnen wir die Datei /etc/modules und fügen folgende Module hinzu:
i2c-bcm2708
i2c-dev
Nun sind alle nötigen Module geladen und wir können prüfen ob unser
Raspberry PI erkannt wird.
Das funktioniert mit folgendem Befehl:
i2cdetect -y 0 #FÜR MODEL A
i2cdetect -y 1 #FÜR MODEL B
Hier müssen wir beachten, dass wir für Model A die “0″ und für Model B die “1″ verwenden.
Nun sollte das ganze ungefähr so aussehen:
Jetzt können wir unser LCD ansprechen. Dafür nutze ich ein fertiges Python Script.
Nun können wir im Verzeichnis eurer Wahl eine neue Datei erstellen.
Als erstes der Script der die I2C-Schnittstelle erkennt und das Display ansprechen kann.
Diese muss später auch kompiliert werden.
Name der Datei: “i2c_lib.py”
import smbus
from time import *
class i2c_device:
def __init__(self, addr, port=0):
self.addr = addr
self.bus = smbus.SMBus(port)
# Write a single command
def write_cmd(self, cmd):
self.bus.write_byte(self.addr, cmd)
sleep(0.0001)
# Write a command and argument
def write_cmd_arg(self, cmd, data):
self.bus.write_byte_data(self.addr, cmd, data)
sleep(0.0001)
# Write a block of data
def write_block_data(self, cmd, data):
self.bus.write_block_data(self.addr, cmd, data)
sleep(0.0001)
# Read a single byte
def read(self):
return self.bus.read_byte(self.addr)
# Read
def read_data(self, cmd):
return self.bus.read_byte_data(self.addr, cmd)
# Read a block of data
def read_block_data(self, cmd):
return self.bus.read_block_data(self.addr, cmd)Diesen Code müssen wir nun mit folgendem Befehl ausführen.
python i2c_lib.pyNun erstellt sich eine Datei Namens “i2c_lib.pyc
Als nächstes müssen wir unseren Display direkt ansprechen. Dazu müssen
wir die Ausgabe von “i2cdetect” beachten. Bei mir 27. Also 0×27. Diese
müsst ihr ggf. ersetzen.
Name des Script “lcd_display.py”. Den Namen solltet Ihr übernehmen, weil
wir im Testscript auf diesen Namen zurückgreifen da wir ein Modul des
Scripts importieren müssen.
import i2c_lib
from time import sleep
# LCD Address
ADDRESS = 0x27 #FALLS ANDERS, ERSETZEN!
# commands
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80
# flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00
# flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00
# flags for display/cursor shift
LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00
# flags for function set
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00
# flags for backlight control
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00
En = 0b00000100 # Enable bit
Rw = 0b00000010 # Read/Write bit
Rs = 0b00000001 # Register select bit
class lcd:
"""
Class to control the 16x2 I2C LCD display from sainsmart from the Raspberry Pi
"""
def __init__(self):
"""Setup the display, turn on backlight and text display + ...?"""
self.device = i2c_lib.i2c_device(ADDRESS,1)
self.write(0x03)
self.write(0x03)
self.write(0x03)
self.write(0x02)
self.write(LCD_FUNCTIONSET | LCD_2LINE | LCD_5x8DOTS | LCD_4BITMODE)
self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
self.write(LCD_CLEARDISPLAY)
self.write(LCD_ENTRYMODESET | LCD_ENTRYLEFT)
sleep(0.2)
def strobe(self, data):
"""clocks EN to latch command"""
self.device.write_cmd(data | En | LCD_BACKLIGHT)
sleep(0.0005)
self.device.write_cmd(((data & ~En) | LCD_BACKLIGHT))
sleep(0.001)
def write_four_bits(self, data):
self.device.write_cmd(data | LCD_BACKLIGHT)
self.strobe(data)
def write(self, cmd, mode=0):
"""write a command to lcd"""
self.write_four_bits(mode | (cmd & 0xF0))
self.write_four_bits(mode | ((cmd << 4) & 0xF0))
def display_string(self, string, line):
"""display a string on the given line of the display, 1 or 2, string is truncated to 16 chars and centred"""
centered_string = string.center(16)
if line == 1:
self.write(0x80)
if line == 2:
self.write(0xC0)
for char in centered_string:
self.write(ord(char), Rs)
def clear(self):
"""clear lcd and set to home"""
self.write(LCD_CLEARDISPLAY)
self.write(LCD_RETURNHOME)
def backlight_off(self):
"""turn off backlight, anything that calls write turns it on again"""
self.device.write_cmd(LCD_NOBACKLIGHT)
def display_off(self):
"""turn off the text display"""
self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYOFF)
def display_on(self):
"""turn on the text display"""
self.write(LCD_DISPLAYCONTROL | LCD_DISPLAYON)
Auch hier müssen wir das python Script wieder ausführen.
python lcd_display.pyNun hat sich wie eben eine Datei Namens “lcd_display.pyc” erstellt.
Jetzt sind wir soweit fertig und können ein Testscript schreiben,
welches ein “Hallo Welt” auf unserem LCD ausgibt. Wir erstellen nun ein
Python Script. Bei mir heißt es “test.py”.
In diesem Pythonscript müssen wir jetzt die notwendigen Includes importieren.
from lcd_display import lcd #Laedt aus lcd_display lcd
#LCD STARTEN#
my_lcd = lcd()
my_lcd.display_string("HALLO WELT",1) #ZEILE 1 DES LCD
my_lcd.display_string("HALLO RPI",2) #ZEILE 2 DES LCD
Den Script führen wir wieder mit folgendem Befehl aus:
python test.pyDas ganze sieht Live dann so aus:
Nun könnt Ihr ein Raspberry PI mit einem LCD vorkonfigurieren und einen
kleinen Text ausgeben lassen. Zu beachten ist, dass bei diesem Display
maximal nur 2 Zeilen je 16 Zeichen möglich sind.
Viel Spaß beim Testen 
Display und Kabel kann man in vielen Shops kaufen. Unteranderem bei dx.com, kostenloser Versand nach Deutschland!
Die ganzen Scripts findet man natürlich auch im Internet, meistens Free ohne weiteren Copyrighthinweise.
