LCD Zeichen Displays sind eine einfache und kostengünstige Art einen Text anzeigen zu lassen. Dank dem HD44780 Controller ist das Ansteuern der Module sehr einfach geworden. Allerdings muss man viele GPIOs dafür belegen. Eine Alternative stellt hier der I2C Datenbus dar, womit nur noch zwei GPIOs belegt werden.
In diesem Tutorial wird ein 20×04 HD44780 Zeichen Display mit Hilfe eines I2C Display Adapters angesteuert. Um den Spannungspegel für das Modul herzustellen, ohne dabei die GPIOs zu gefährden wird ein Logik Konverter benutzt.
Zubehör
Um ein HD47780 Display per I²C ansprechen zu können, habe ich folgendes Zubehör verwendet:
- HD44780 Display (20×04 oder 16×02 Zeichen)
- I2C Display Adapter
- I2C Logik Level Konverter
- Breadboard
- Jumper Kabel
Aufbau
Auf dem Raspberry Pi dürfen GPIOs nicht mehr als 3.3V Spannung abbekommen, allerdings gibt es einige Module (wie dieses Display), welche 5V Signale benötigen und senden. Dafür kann ein Logic Level Converter benutzt werden, welcher 2 Seiten hat. Auf einer Seite werden jene Anschlüsse, die auf 3.3V laufen angeschlossen und auf der anderen jene mit 5V. Erkennen kannst du das an verschiedenen Merkmalen (LV – HV), wie du im folgenden Bild siehst:
Angeschlossen werden die Pins dann folgendermaßen:
| Raspberry Pi | 3.3V Level Konverter | 5V Level Konverter | I2C LCD Adapter |
|---|---|---|---|
| 3.3V (Pin 1) | LV | — | — |
| 5V (Pin 2) | — | HV | VCC |
| GND (Pin 6) | GND | GND | GND |
| GPIO2 / SDA (Pin 3) | TX1 (unten) | — | — |
| GPIO3 / SCL (Pin 5) | TX1 (oben) | — | — |
| — | — | TX0 (unten) | SDA |
| — | — | TX0 (oben) | SCL |
Hier noch als Zeichnung:
Dabei kann jeder beliebige Masse Pin genommen werden. Der Übersicht zuliebe habe ich Pin 20 statt Pin 6 auf der schematischen Abbildung gewählt.
Dieser Aufbau ist im Übrigen auch mit anderen Modulen, welche Signale mit einer höheren Spannung als 3.3V (in diesem Fall 5V) brauchen (Real Time Clock, etc.) verwendbar.
Software
Bevor wir starten können, werden zwei I²C Tools benötigt, welche wir installieren:
sudo apt-get install python-smbus i2c-tools
Danach schalten wir I2C frei (falls du es bereits aus vorherigen Tutorials freigeschaltet hast, kannst du dies überspringen):
sudo raspi-config
Unter „8. Advanced Options“ > „A7 I2C“ aktivieren wir es. Nun fügen wir der modules-Datei noch die entsprechenden Einträge hinzu:
sudo nano /etc/modules
Diese beiden Zeilen kommen ans Ende:
|
1 2 |
i2c-bcm2708 i2c-dev |
Anschließend muss noch neugestartet werden, damit alle Änderungen in Kraft treten.
sudo reboot
Hast du das Display bereits angeschlossen, kann nun getestet werden, ob es erkannt wurde (solltest du eines der aller ersten Raspberry Pi’s [Rev.1] haben, musst du eine 0 statt 1 übergeben):
sudo i2cdetect -y 1
Die Ausgabe sollte so aussehen:
pi@raspberrypi ~ $ sudo i2cdetect -y 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- --
Falls du hier eine andere Zahl als 27 angezeigt bekommst, musst du dies gleich in der lcddriver.py Datei ändern (ADDRESS = 0x27).
Laden wir aber erst einmal den Code:
mkdir hd44780 && cd hd44780 wget http://tutorials-raspberrypi.de/wp-content/uploads/scripts/hd44780_i2c.zip unzip hd44780_i2c.zip
Mit Hilfe der beiden enthaltenen Skripts kann das Display nun angesprochen werden. Dazu öffnen wir die Python Konsole und geben folgenden Code ein:
sudo python
|
1 2 3 4 5 6 7 8 9 10 |
import lcddriver from time import * lcd = lcddriver.lcd() lcd.lcd_clear() lcd.lcd_display_string("Tutorials-", 1) lcd.lcd_display_string(" RaspberryPi.de", 2) lcd.lcd_display_string("", 3) lcd.lcd_display_string("HD44780 I2C Tutorial", 4) |
Der erste Parameter der lcd_display_string Funktion steht dabei für den Text und der zweite für die Zeile. Es müssen nicht alle Zeilen auf einmal geändert werden, allerdings können nicht ohne weiteres einzelne Zeichen ersetzt werden. Dafür müsste der gesamte Text (mit geändertem Zeichen an der gewünschten Position) erneut gesendet werden.
Bei meinem I2C Adapter war der Kontrast am Anfang sehr niedrig eingestellt. Falls nichts angezeigt werden sollte, teste das Rädchen auf der Rückseite und schaue schräg auf das Display.
173 Kommentare
guter Beitrag
als Alternative für den Pegelwandler würde natürlich auch ein von der Anschlussbelegung besser verständliches Modul funktionieren
nur als Beispiel !!!
http://www.amazon.de/dp/B00JQ0DITU/ref=pe_386171_38075861_TE_item
aber ich finde es gut das ein Beitrag sich mit i2c befasst was es bei der reichlichen Auswahl von i2c (smb) Bausteine lögisch ist und sich diese ohne umständliche Umprogrammierung von GPIOS anschliessen lassen und damit einen einheitlichen Bus haben und viel Möglichkeiten des Programmieren lassen (bash, Python usw)
Da hast du recht, der ist natürlich auch geeignet. Ich hatte den von mir verwendeten noch rumliegen und daher diesen benutzt.
Ein Logic Level Shifter ist schon das beste, was man benutzen kann, und die Belegung ist bei allen diesen Modulen gleich, das aus deinem Link macht den Job auch nicht besser und wird genauso angeschlossen, wie das hier.
Im Übrigen sei an alle folgenden Leser gesagt, dass der Raspberry Pi 2 aus diesem Tutorial vlt. einen Logic-Level-Shifter braucht, aber Raspberry 3 und 4er Modelle 5V gpio Pins besitzen
Hallo Felix,
ich hätte ein paar Fragen.
* Kann dein „Driver“mehr als nur Text ausgeben? (blinken oder sowas ähnliches)
* Wie kann man variablen ausgeben? Wenn ja, so (lcd.lcd_display_string(„%s-„, 1) %Text)
* Braucht man einen Potenziometer um den Kontrast einstellen zu können?
* Kann man Symbole wiedergeben z. B. ein Termometer? (Wenn ja, wie?)
ich denke das reicht fürs erste. 🙂
Mach weiter so.
Hallo Stefan,
kurz und knackig:
1. Nein, ist nur für Zeichen gedacht. Blinken ist aber ziemlich einfach zu erstellen (Schleife: halbe Sekunde Text anzeigen, Text speichern und Display leeren, halbe Sekunde später wieder vorherigen Text anzeigen lassen).
2. Fast Richtig:
lcd.lcd_display_string("String: %s" % string_var, 1)3. Wenn du es einstellen und justieren willst – ja. Du kannst aber auch einfach verschiedene Widerstände ausprobieren und die Größe nehmen, bei der der Kontrast dir gefällt.
4. Was meinst du mit Symbolen? Du kannst ASCII Zeichen anzeigen lassen, aber keine Bilder. Ist ja auch keine Graphik- sondern ein Zeichendisplay 🙂
LG Felix
Hallo Felix,
ich habe mich leider missverständlich ausgedrückt. Ich dachte mit meinem Beispiel“ blinken“ daran, ob es noch andere Methoden in dem von dir zur Verfügung gestellten Treiber gibt.
Mir würde da jetzt spontan einfallen, dass der Cursor angezeigt wird, der Cursor blinkt, die Hintergrundbeleuchtung ausgeschaltet werden kann, der Text im Display von rechts nach links gescrollt werden kann usw.
Ich hatte es in einem YouTube Video gesehen. Dieser verwendet einen Treiber von Adafruit. Der ist aber so viel ich gesehen habe nicht per I2C-Verbindung gedacht und wird deshalb wahrscheinlich nicht funktionieren. (Link: https://www.youtube.com/watch?v=cVdSc8VYVBM)
Mal eine andere doofe Frage. Für was ist denn das Rädchen hinten auf dem I2C-Controller gedacht, ist das nicht für den Kontrast?
Mit Symbolen hatte ich gemeint, ich könnte mir ein Temperatursymbol wie es die meisten 3D-Drucker verwenden anzeigen lassen. (Link: http://nicklievendag.com/wp-content/uploads/cyrus_3d_printer_review_display-1024×530.jpg)
Was du beschreibst ist zwar bei meiner Lösung nicht dabei, aber es sollte sehr einfach sein das zu erstellen.
Beispiel Text von rechts nach links scrollen:
Du kopierst den String mehrfach hintereinander („StringStrinString…“) und startest eine Schleife. Bei jedem Durchlauf wird der erste Buchstabe entfernt und die nächsten 16. bzw. 20 Zeichen ausgegeben (per Befehl wie im Tutorial gezeigt). Danach wird eine halbe Sekunde/o.ä. gewartet, bis die Schleife erneut ausgeführt wird.
Einen Cursor kannst du genauso bauen: Einfach die Position X des String im Sekunden/o.ä. Takt einmal mit einem anderen Zeichen (Unterstrich z.B.) ersetzen. Warten und dann die normale Zeichenkette anzeigen und das ganze eben wiederholen.
Hallo Felix,
auch wenn ich vielleicht nerve und vom Programmieren wenig verstehe, habe ich mir die Treiber-Datei nochmal angesehen. Am Anfang stehen meine sogar einige Funktionen, die ich auch im Video gesehen hatte….
Allerdings denke ich, dass in der Treiberdatei dafür keine Funktionen definiert sind. Sehe ich das soweit richtig? Wenn ja, könnte man doch auch über den Treiber eine Definition entwickeln, die man in seinem Programm dann nur noch aufrufen müsste oder? Verdammt ich habe doch das falsche studiert….
Dennoch könnte ich mir sowas vorstellen. Was meinst du dazu?
def lcd_blinkon (self): self.lcd_write(LCD_BLINKON)Hallo Stefan,
klar, das ist möglich. Das meinte ich auch damit, dass man es sehr einfach erstellen kann. Was du mit
self.lcd_write(LCD_BLINKON)meinst, verstehe ich allerdings nicht (ist LCD_BLINKON ein String?).Hallo Felix,
ich weiß eben nicht ob ich richtig liege. Wenn ich mir die Treiber-Datei ansehe z. B. die Funktion LCD_CLEAR, dann ist die Funktion genauso aufgebaut. Im Prinzip ruft er auch in der Funktion (Definition) auch nur einen Befehl auf, der vorher auch einem HEX-Wert versehen wurde. Ich dachte mir deshalb, dass es mit den anderen Befehlen die oben einen HEX-Wert bekommen haben genauso laufen würde. Was meinst du dazu?
Hallo Stefan,
die Hex Werte die am Anfang der Datei definiert wurden, sind alle aus dem Datenblatt. Das sind bestimmte Bytekombinationen, die bestimmte Funktionen (wie z.B: CLEAR) auf dem Display ausführen. Da das Display aber keine Blink Funktion hat, gibt es dafür auch keinen Code, den du senden könntest.
Allerdings ist das auch nicht nötig, da alle benötigten Funktionen (welche Bytes senden) bereits definiert sind. Du kannst also diese Funktionen verwenden und in gewisser Weise aufrufen (zum Blinken wie ich beschrieben hatte).
LG Felix
Doch, das funktioniert. Die Befehle funktionieren nur ein bisschen unterschiedlich.
https://www.sprut.de/electronic/lcd/#befehle
Hier steht dazu etwas. Das Display arbeitet über I2C im 4-Bit Modus (muss natürlich initialisiert werden, wie im PY-Script geschehen), jedes gesendete Byte setzt sich also so zusammen (D: Datenbit):
D/D/D/D/Backlight Bit/Enable Bit/ReadWrite Bit/Register Bit
Um die BLINK-Funktion zu verwenden, sendet man also einmal den „DISPLAY“-Befehl mit dem Befehls-Byte (im PY-Script lcd_write(cmd, 0); 0 als Mode steht für Befehls-Register):
000011CB
C: Cursor: an /aus
B: Cursor blinkt: an /aus
Hallo zusammen,
ich habe ein wenig an den Libarys herumgebastelt. Ich kann jetzt mit oder ohne Hintergrundbeleuchtung schreiben. Weiterhin gibt es die Möglichkeit eigene Zeichen zu bauen und auf das Display zu schreiben. Würde Sie posten, aber ich habe keine Möglichkeit hier „Code“ zu posten.
Gruß
Blackbox
Hallo Blackbox,
du kannst deinen Code gerne auf http://pastebin.com/ posten und hier verlinken. Danke für deine Mühe!
LG Felix
Hat zwar etwas gedauert, aber hier ist mein lcd_driver.py:
http://pastebin.com/c6VHZx7i
Funktion:
lcd.lcd_display_string0(„string“, 1) -> schreibt ohne Hintergrundbeleuchtung
lcd.lcd_display_string1(„string“, 1) -> schreibt mit Hintergrundbeleuchtung
hallo, habe den code mal instaliert auf meinem raspi mit jessie, bekomme aber beim start immer die meldung
Traceback (most recent call last):
File „/home/pi/i2c lcd.py“, line 1, in
import lcddriver
ImportError: No module named lcddriver
woran kann das liegen ?
danke im voraus
Anscheinend liegt die Datei nicht im selben Verzeichnis wie dein Skript.
Hallo in die Runde, ich bin recht neu auf dem Raspberry Gebiet. Habe die Waage ans laufen bekommen, in dem anderen tutorial das Display ans laufen bekommen, wie kann ich aber nun den Gewichtswert auf dem Display ausgeben? Und kann ich das programmieren das beim einschalten des Raspberrys automatisch die Waage gestartet wird und der Wert auf dem Display ausgegeben wird? Viele Grüße und danke für die Hilfe. Dennis
Hallo,
bei mir leuchtet zwar der Display, aber er wird nicht in der i2cdetect-Tabelle angezeigt. Ich habe auch mehrmals die Lötkontakte und die Kontakte untereinander kontrolliert.
Woran kann das liegen, dass bei mir nichts angezeigt wird.
Danke im vorraus
Hallo Vincent,
wenn über die I2C Suche nichts angezeigt wird, so wurde das Display nicht gefunden. Es leuchtet nur, weil VCC und GND richtig angeschlossen sind und es Strom bekommt.
LG Felix
Hallo Vincent,
vertausch mal SDL und SCL am Pi. Hatte das gleiche Problem danach ging es.
Grüße Martin
Hallo Martin,
sorry, aber ich habe laut der Tabelle oben auf der Seite keinen SDL-Anschluss?
Das Display leuchtet, aber erkannt wird es nicht bei der Suche.
Was kann ich tun?
Hast du schon versucht den Kontrast zu verändern?
Hallo Felix,
dein script läuft super. Allerdings kann ich mir Uhrzeit und Datum über „time.strftime“ nicht anzeigen lassen bekomme dann immer eine Fehlermeldung wie kann ich das anzeigen lassen?
Vielen Dank im Vorraus
hallo
super anleitung, hat auf anhieb geklappt.
hab aber noch 2 fragen.
ich möchte 2 oder mehr variablen in einer zeile darstellen, wie mache ich das?
lcd.lcd_display_string("%s" % var1 % var2, 1)funktioniert leider nicht.2 frage was bedeutet das %s in der klammer.
vielen dank im voraus
lcd.lcd_display_string("%s %s" % (var1, var2), 1)hallo
kann ich mit dem script auch die hintergrundbeleuchtug steuern?
wenn ja wie mache ich das?
über den jumper auf der i2c platiene funktioniert es nicht
danke im voraus
Nein, die Hintergrundbeleichtung kannst du mit einem Poti einstellen.
Hallo Felix
war wohl missverständlich ich meinte ob man über ein script die hintergrundbeleuchtung ein bzw aus schalten kann durch drücken eines tasters
Danke im vorraus Martin
Hi Martin,
die Bibliothek hat doch eine Funktion zum ein bzw. ausschalten der Hintergrundbeleuchtung:
lcd.lcd_backlight("ON")Hallo Felix,
kann sein das ich blind bin aber finde keinen eintrag
lcd.lcd_backlight(„ON“)
weder in der i2c_lib noch in der lcddriver
muss ich das vieleicht noch ergänzen?
habs schon versucht mit lcd.lcd_backlight(„ON“)
aber bekomme immer eine fehlermeldung das es den eintrag nicht gibt.
danke schonmal im vorraus
Martin
In der Datei lcddriver.py ab Zeile 89 findest du die Funktion.
nachtrag
habs auch mit
LCD_BACKLIGHT = 0x08
LCD_NOBACKLIGHT = 0x00
aber auch das hilft nicht
Martin
hi felix
ich will ja nicht den klugscheißer raushängen lassen aber in der lcddriver.py die ich habe ist ab zeile 86 die definition für die text zeilen also der
def lcd display string
und der geht bis zeile 94
hast du vielleicht eine neuere lcddriver.py?
grüße Martin
Hey Martin,
sorry – du hast natürlich recht: Ich habe eben gesehen, dass ich die neuste Version nicht hochgeladen hatte (nun schon – danke für den Hinweis). Hier die Funktion, die du einfügen kannst:
#turn on/off the lcd backlight def lcd_backlight(self, state): if state in ("on","On","ON"): self.lcd_device.write_cmd(LCD_BACKLIGHT) elif state in ("off","Off","OFF"): self.lcd_device.write_cmd(LCD_NOBACKLIGHT) else: print "Unknown State!"LG, Felix
hallo felix
feedback jetzt funtzt es 😉
LG Martin
Hallo,
vielen Dank für das tutorial, hat wunderbar funktioniert, text etc. funst auch alles wunderbar, was ich jetzt noch gerne wüsste ist wie ich das Grad Zeichen (°) ausgeben kann. Hat da Jemand ne Idee?
Hallo Micha
das ° Zeichen bekommt du indem du +chr(233)+ vor dem Index eingibst
Grüße Martin
Hallo zusammen,
chr(223) ist hier wohl die korrekte Angabe
Gruß
Uli
Hallo das Problem habe ich auch. Was für einen Index meinst du?
Grüße Marcus
Ich erhalte beim ausführen von „i2cdetect -y 1″ als resultat:
“ 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: — — — — — — — — — — — — —
10: — — — — — — — — — — — — — — — —
20: — — — — — — — — — — — — — — — —
30: — — — — — — — — — — — — — — — —
40: — — — — — — — — — — — — — — — —
50: — — — — — — — — — — — — — — — —
60: — — — — — — — — — — — — — — — —
70: — — — — — — — –“
Das Display ist an und zeigt weiße und schwarze Rechtecke. Und wenn ich deinen Test-Code ausführe kriege ich einen IO-Fehler.
Das wird so nicht funktionieren, da dein Display nicht per I2C erkannt wurde. Überprüf nochmal die Verkabelung.
Ich musste SDA und SCL tauschen.
Moin,
Wenn ich „sudo i2cdetect -y 1“ eingebe, wird zwar die Tabelle angezeigt, jedoch leider keine einzige Adresse.
Kann mir jemand sagen was ich ggf. Falsch gemacht haben könnte?
ehm… jo… ist nun wieder obsolet… habe gestern bei n paar bier SDA und SCL am Raspi vertauscht… *glorreich*
Hallo,
habe mein HD44780 nun auch mal angeschlossen und wird auch erfolgreich mit Adresse 27 mit sudo i2cdetect -y 1 erkannt. Textausgabe funktioniert einwandfrei 🙂 Habe die Komponenten im Einsatz die oben beschrieben sind.
Nun mein Problem: Meine Displaybeleuchtung funktioniert nicht und ich kann mir nicht erklären warum. Am Poti habe ich auch schon rum gespielt – man sieht, dass die angezeigten Zeichen / Rechtecke sich dementsprechend ändern, jedoch tut sich an der Beleuchtung überhaupt nichts.
Bin über jeden Rat dankbar;
Viele Grüße
Tobias
Habe es gerade gefunden: Der Jumper hat auf dem Display Adapter gefehlt….
hallo,
eigentlich sehr schöne Tutorials, leider nur Python und kein C/C++, daher für mich dummerweise nicht verwertbar….
Such mal hier nach „wiringPi“, es gibt schon einige C++ Tutorials 🙂 Da aber Python für die meisten Einsteiger einfacher ist (und es generell eine einfach zu verstehende Sprache ist), habe ich hauptsächlich Python genutzt.
Python ist absolut nicht einfacher, C ist tausend mal klarer und strukturierter, tausend mal mächtiger und weitaus schneller (mit pthread thread priorities sogar nahezu echtzeitfähig!) , und WiringPi deckt mit seinen Tutorials nur ein winzig kleines Feld in dem riesigen Gebiet der Raspi-Programmierung ab. Daher wäre auch hier C-programmierbeispiele sehr begrüßenswert. Als IDE bietet Geany hierfür alles, was man zum einfachen Programmieren braucht.
Hallo,
habe seit heute das Display. Funktioniert auch soweit, jetzt hab ich folgendes Problem. Per Cronjob wird jede Minute ein Python Script gestartet das einige Relais ansteuern und weitere Hardware zu schalten.
Das Display soll pro Zeile „Relais ein“ oder „Relais aus“ anzeigen.
Das klappt auch, allerdings wird das Display immer geleert und dann die entsprechende Zeile z.b. 2 oder 4 angezeigt, die anderen sind geleert, ich habe in meinem Script allerdings keinen Clear befehl. Kann es sein das jedesmal wenn mein Script aufgerufen wird und die Lib geladen wird, das Display geleert wird ?
Kannst du den Zustand aller Relais nicht speichern und alle auf einmal ausgeben?
Hallo zusammen, gibt es hierfür eine Lösung? Ich habe exakt das gleiche Problem. Danke
Hey Felix,
ja im Grunde schon. Nur wurmt es mich, das der Inhalt des Displays gelöscht wird wenn ich an anderer Stelle eine andere Zeile schreibe…. Es scheint so, als wenn der Treiber das gesamte Display löscht um eine Zeile zu schreiben obwohl dein Clear befehl gesetzt wurde. Das muß ka irgendwie gehen.
Nach Start des Raspi startet ein PythonScript das dauernd was am Display anzeigen soll. Zur Zeit habe ich das Problem das das Display nach dem Booten einfach nur Müll darstellt. Es kommt nix sinnvolles, nur wirre Zeichen. Auch nach einem Reboot oder wenn der Raspi vom Strom getrennt war.
Habt ihr da eine Idee?
Scheinbar wird auch das im Script hinterlegte Clear des Displays nicht ausgeführt.
Hallo
Vielen Dank für das tolle Tutorial! Hat alles wunderbar funktioniert.
Was muss ich bei „data“ im strobe Befehl eingeben?
Servus, wer das Display nur beschreiben und nicht den Status auslesen will (was der lcddriver.py ja gar nicht unterstützt), kann sich den TTL Wandler sparen.
Hallo,
mit meinem aus China stammenden Modul (HD44780 Display 20×04
I2C Display Adapter), das so aussieht wie das auf den Bildern hier. Konnte ich leider nicht so wie hier beschrieben in Betrieb nehem.
sudo i2cdetect -y 1 gab mir keine Adresse zurück. Backlight war an und die LED leuchtete.
Nach dem ich Logik Level Konverter raus genommen habe und der Betrib nur mit 3,3 V erfolgte. Konnte ich das Modul über die 0x3F Adresse ansprechen.
Da der Kontrast nicht so Prall war wollte ich auf 5V zurück und nahm einen anderen Konverter. Und nun ist Backlight und Power LED aus bei 5 und 3,3 V. Die Adresse 0x3F wird weiter hin nur bei 3,3 V angezeigt und lasse ich deine String ausgabe durch laufen zeigt kein LCD an.
Habe ich das Modul zerschossen oder noch schlimmer die GIPOs des Pis? Oder kann ich noch was retten?
Die GPIOs kannst du mit einem einfachen LED Test testen. Das Display sollte eigentlich 5V vertragen.
Habe ein 16×2 Display und das gleiche Problem wie Du gehabt. Habe den Logik-Konverter entfernt und das Display direkt mit 5v angeschlossen. Mein Raspi „lebt“ noch und die Anzeige funktioniert jetzt endlich.
Hallo,
erstmal vielen Dank für dieses super Tutorial. Funktioniert perfekt. Du schreibst aber oben es kann ein 4×20 oder auch 2×16 Zeichen Display sein. Mit einem 4×20 Display funktioniert es bei mir, jedoch nicht mit einem 2×16 Zeichen Display. Hast du das selber mal ausprobiert? Auf dem kleinen Display kommen bei einzeiliger Ausgabe die richtigen Zeichen, bei zweizeiliger Ausgabe nur komischeZeichen raus.
Ok Danke hat sich erledigt beim „Rumdrücken“ auf dem Display hat sich gerade herausgestellt das wohl das Display nicht richtig auf der Platine sitzt…. 🙂
Hallo Felix,
tolles Tutorial.
Ich baue mir gerade ein Wlan Radio und versuche schon seit mehreren Tagen die Radio angaben auf dem Display auszugeben doch ich verstehe das Skript leider nicht.
Wie lauten die Befehle damit ich den Sender und das gerade gespielte Lied auf dem Display angezeigt bekomme. Und wie aktualisiert er sich automatisch, wenn ein neues Lied gespielt wird?
Ich habe ein sainsmart lcd2004.
Danke schon mal im voraus.
Gruß Pierino
lcd.lcd_display_string("Text", Zeile)Einfach bei jeder Aktualisierung den Befehl wieder aufrufen.
Ich dachte das läuft über den „mpd current“ Befehl?!
Doch lcd.lcd_display_string(mpd current, 1) funktioniert nicht und lcd.lcd_display_string(os.system(„mpd current“), 1) auch nicht 🙁
Was soll der Befehl machen? Wenn du damit einen String zurück bekommst, kannst du es natürlich damit auch anzeigen lassen.
Der Befehl heißt natürlich mpc current und nicht mpd…
Der Befehl gibt den aktuellen Sender und das gespielte Lied aus, z.B.:
SAW – 70er: ELECTRIC LIGHT ORCHESTRA – LIVIN THING
Ich habe auch so probiert…
lcd.lcd_display_string(„%s“ %os.system(„mpc current“), 1)
jedoch bekomme ich nur eine null auf dem Display angezeigt wäred er auf Putty mir die Radiosender-Daten ausgibt.
Achso, ja das wird nicht funktionieren. Du musst einen eindeutigen String haben. Wenn ich dich richtig verstehe, ist das eine Art Stream. Du müsstest z.B. jede halbe Sekunde den eindeutigen String abfragen und diesen anzeigen lassen.
…und wie mache ich das? Kannst du mir ein Beispiel Code geben?
Habe leider keine Ahnung vom Programmieren, habe versucht die Scripts zu verstehen, doch bis auf die einfache Textausgabe habe ich weiter nichts verstanden.
Müsste mir dazu dein Programm näher anschauen, aber gehe nun ins Bett (muss morgen früh raus).
Als Tipp: Google doch mal sowas wie „python os.system static outut string“, das sollte nicht all zu schwer sein 🙂
Gute Nacht
Habe das Problem lösen können. Es ist wie du sagtest man muss einer Variabel einen eindeutigen String zuteilen und diesen dann auslesen. Bei mir sieht es jetzt so aus:
var = os.popen(‚mpc current‘).read()
lcd.lcd_display_string(var, 1)
Doch nun hab ich ein neues Problem. Kann ich den Text auch formatieren also den Sender in Zeile 1, Den Interpret in Zeile 2 und das Lied in Zeile 3? Jetzt ist es so, dass er den Text in Zeile 1 anfängt, in Zeile 3 fortsetzt und dann in Zeile 2 weiter schreibt.
Du kannst einen String z.B. in ein Array per split aufteilen. Wenn du bspw. den String „Komponent X – Titelname Y“ hast, dann könntest du den Bindestrich als Trennzeichen nehmen und würdest ein Array mit zwei Einträgen bekommen. Danach einfach per
arrayname[indexNr](indexNr=0,1) aufrufen und den Zeilen zuweisen.Super, vielen Dank!
Das waren genau die richtigen Stichworte. Was nutzt ein Google, wenn man nicht die richtigen Fragen stellt. Ich bin meinem Ziel ein großes Stück näher gekommen.
Danke für die Hilfe.
Vielen Dank für die Anleitung,
habe mir diese einmal durchgelesen und schon dabei war mir aufgefallen, dass du in der Tabelle Schreibst, dass SDL (Pin 3) unten an TX1 angeschlossen wird (also Chan 2 des Wandlers), die Fritzing Grafik zeigt dann aber SCL an TX0 von Chan2.
Als ich die Schaltung dann nachgebaut habe wurde dies auch noch einmal bestätigt.
Ich schließe mich also meinen Vorrednern an und weise darauf hin, dass SDL und SCL zu tauschen sind, dann taucht auch 0x27 im i2cdetect auf 🙂
Danke für den Hinweis, ich habe nun in der Grafik SDA und SCL geatuscht 🙂
Hallo Felix,
danke für das Tutorial, ich habe mein Display am laufen und kann über ein kleines Python-Script Text ausgeben und die Hintergrundbeleuchtung steuern.
Nun möchte ich das Display über ein Python3 Script einbinden. Leider kommt mein Python3 Script nicht mit dem import aus den python2.. zurecht. Was kann ich ändern?
Möchte mit 3.. arbeiten!
Gruß Ralf
Hallo Ralf,
Bin heute erst auf diese gute Anleitung für Python 2 gestoßen. Da ich mit Python 3.4.2 arbeite verursachte das Beispiel-Script auch bei mir einen Fehler.
Ich nutze übrigens Raspbian Jessie Pixel in der aktuellen Version.
python3-smbus
python3-dev
usw.
waren schon vorinstalliert.
Die benötigten Schnittstellen (SPI, I2C) lassen sich inzwischen komfortabel über:
Start > Einstellungen > Raspberry -Pi-Konfiguration >
Reiter: „Schnittstellen“ aktivieren.
Danach den Raspi neu starten.
Nun muss man nur noch eine kleine Änderung in lcddriver.py vornehmen.
Die Print-Anweisung in Zeile 95 verursacht die Fehlermeldung!
Lösung:
print „Unknow State!“
durch
print(„Unknow State!“)
ersetzen.
Nach dieser kleinen Änderung läuft es auch unter Python 3.
Falls du zwischenzeitlich schon eine Lösung gefunden hast, erspart die kleine Info vielleicht anderen
Usern das weitere Googeln
Gruß
Reinhard
Hallo Rheinhard,
ich habe die Änderung ins Archiv aufgenommen, sodass nun kein Anpassen mehr nötig sein sollte.
Hallo,
ich hätte da mal ein Anliegen weil die Programmierkenntnisse meinen Horizont (noch) übersteigen:
Ich benutze das Beispielskript aus dem Beitrag. Nun möchte ich dass danach 5 Sekunden gewartet wird und dann in der ersten Zeile das Datum, in der zweiten die Uhrzeit, in der dritten die IP-Adresse (eth0) und in der vierten die CPU-Temperatur ausgegeben wird. Habe mich schon Stunden dran versucht aber werde noch nicht schlau aus dieser Programmiersprache.Wäre da jemand so nett und könnte helfen?
Danke!
Ich bin auch auf der Suche nach einer solchen Lösung 🙂
Hi Patrick,
sorry für die verspätete Antwort, hier ein Beispiel:
# -*- coding: utf-8 -*- import lcddriver import os, datetime lcd = lcddriver.lcd() lcd.lcd_clear() sleep(5) datum = datetime.datetime.now().strftime("%d.%m.%Y") uhrzeit = datetime.datetime.now().strftime("%H:%M:%S") ip = os.system("/sbin/ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'") cpu = str( float(os.popen('cat /sys/class/thermal/thermal_zone0/temp').read()) / 1000.0 ) + "°" lcd.lcd_display_string(datum, 1) lcd.lcd_display_string(uhrzeit, 2) lcd.lcd_display_string(ip, 3) lcd.lcd_display_string(cpu, 4)Hallo, wie bewege ich den script dazu, dass dieser in einer schleife läuft? – Cronjob ?
danke über ein Hilfanstoß
Stoffl
habe was gefunden. Warum wird mir
while 1:
^
IndentationError: expected an indented block
zurückgewiesen?
#!/usr/bin/python # -*- coding: utf-8 -*- import I2C_LCD_driver import os, datetime from time import sleep, time if __name__ == '__main__': while 1: name = "Wetterstation" version = "V1.1 Ready" lcd = I2C_LCD_driver.lcd() datum = datetime.datetime.now().strftime("%d.%m.%Y") uhrzeit = datetime.datetime.now().strftime("%H:%M:%S") lcd.lcd_clear() lcd.lcd_display_string(uhrzeit, 1) lcd.lcd_display_string(datum, 2) sleep(5) lcd.lcd_clear() lcd.lcd_display_string(name, 1) lcd.lcd_display_string(version, 2) sleep(2) lcd.lcd_clear()Dir fehlen Einrückungen nach der While Schleife, da es bei Python keine Klammern gibt. Schaue dir am besten dieses Tutorial dazu an: Programmieren lernen am Raspberry Pi – Teil 1: Einführung
Hallo Felix ich habe leider das Problem das ich keine Adresse per „sudo i2cdetect -y 1“ bekomme ich habe bereits die SDA und SCL Pins getauscht funktionier aber leider gar nix ….. habe dein Tutorial mit dem 16×2 ohne I2C gemacht und das hat Wunderbar funktioniert.
Hast du ne idee woran es liegen kann? bin Rat los.
Könnte es sein, dass du dich „verlötet“ hast? Eventuell sind die Pins nicht richtig miteinander verbunden.
LG, Felix
Nein es ist ein vorgelötetes Display in den Maßen 20×4 wie oben beschrieben und I2C Konverter hinten dran. Leuchten tut es schon mal 😀 was mir schonmal zeigt das es stom bekommt aber die Verbindung mit SDA und SCL klappt leider nicht 🙁 zummindest bekomme ich keine Adresse….
Hallo Leute
wenn nix angezeigt wird, liegt es normal daran,
dass auf dem ersten Bild „SCL = gelber Draht“
und auf dem dritten Bild „SCL = brauner Draht“
also vorsicht.
sudo i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20: 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50: 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60: 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70: 70 71 72 73 74 75 76 77
Das kommt bei mir wenn ich das Teil richtig anschließe. Woran kann das liegen?
Achja wenn ich SDA SCL vertausche kommen nur die oben bereits angesprochenen Striche.
Ich bin Rat los?
Hab das gleiche Problem. Was hat geholfen? Oder hat jemand eine Idee?
Hi bei mir kommt manchmal das gleiche und manchmal nur 3f aber Display zeigt nichts an hat einer eine Idee woran das liegen kann?
den Effekt habe ich auch, dagegen hilft „gpio -g mode 2 alt0“
Hi,
Danke, prima Anleitung und tolle Python Lib!! Das Display kann man auch ohne Pegelwandler an den Raspi anschliessen. Läuft bei mir problemlos. Der Master bestimmt auf dem I2C Bus den Spannungspegel, und das ist der Raspi. Die I2C Clients sind in der OpenCollector Devices. Die logische 1 vom Raspi mit 3.3V Bus wird vom Display zuverlässig als 1 erkannt (obwohl die Spec 3.5 fordert). Ich sage trotzdem mal: auf eigene Gefahr.
Diver
Es gibt die Displays (und andere Module) anscheinend in verschiedenen Ausführungen. Habe das schon bei Relais gesehen, da liesen sich auch manche mit 3.3V ansteuern und manche wiederum nicht.
Ich habe ebenfalls ein solches Display, definitiv in 5 Volt Ausführung, denn mit 3,3 Volt ist der Kontrast nahe null. Da ich was erkennen können möchte, habe ich das Display an einen 5 Volt Pin vom Pi angeschlossen und – da ich mir selber nicht sicher war, ob ich gerade meinen Pi grille – gemessen, welche Stromstärke auf den I²C Leitungen anliegt. Es sind 3,3 Volt und dank @DiverHans habe ich nun auch die Erklärung, warum das so ist. 🙂
Vielen Dank für die tolle Anleitung.
Bevor mich ein Kumpel gebeten hat sein Display lauffähig zu machen, habe ich mich noch nie mit Python beschäftigt. Ich bin somit totaler Neuling.
Das Display ist angeschlossen und funktioniert.
Ich habe mir nun ein Script zusammengestückelt. Welches auch teils funktioniert. Um es perfekt zu haben, müssten aber noch Anpassungen gemacht werden. Eventuell kann mir hier jemand helfen.
Hier erst mal das Script:
#!/usr/bin/env python # -*- coding: utf-8 -*- import lcddriver import os from time import time from time import sleep from datetime import datetime lcd = lcddriver.lcd() var = os.popen('mpc current').read() dateString = datetime.now().strftime('%b %d %y') timeString = datetime.now().strftime('%H:%M') while True: longtext = ' ' * 16 + var for i in range(0,len(longtext)): lcd.lcd_display_string(longtext[i:(i+16)],1) lcd.lcd_display_string("%s %s" % (dateString, timeString), 2) sleep(1)Derzeit rast die Info zum Sender in der ersten Zeile ohne das man es wirklich lesen kann.
In der zweiten Zeile wird das Datum und die Uhrzeit angezeigt so wie es sein soll.
Mein Ziel ist, dass die Programminfo zum Sender gut lesbar in der ersten Zeile immer wieder durchläuft und bei einem Senderwechsel, aktualisiert wird.
Eventuell hat jemand so etwas bereits realisiert. Ich habe immer wieder Probleme mit den Absätzen, dass der Python weiß was im Code zusammen gehört. Das habe ich irgendwie noch nicht verstanden.
Zu dem habe ich in der Variable vom Sender teils komische Zeichen, obwohl bei der Ausgabe im Terminal bei „mpc current“ alles korrekt dargestellt wird. Auf dem Display kommt z.B. der Name des Senders und direkt danach irgend ein Zeichen das ich nicht beschreiben kann (ohne Zusammenhang).
Vielen Dank für eure Hilfe
Ich glaube, du solltest das
sleep(1)auf die selbe Ebene stellen, dann wird nach dem Beschreiben eine Sekunde gewartet. So wird sofort nach dem Beschreiben wieder beschrieben.Moin Moin aus dem Norden.
Habt ihr das mit dem langsameren Lauftext hin bekommen?
MFG Steffen
Oh vielen Dank schon mal für deine schnelle Antwort.
Damit sieht es schon mal besser aus und die Sender lassen sich umschalten. Gibt es noch eine Möglichkeit die Laufschrift langsamer laufen zu lassen?
Dann habe ich noch keine Idee mit was für komischen Zeichen die Zeile mit der Senderinfo aufgefüllt werden.
Wenn du da noch eine Idee hast?
Vielen vielen Dank
Was meinst du mit Senderinfo? Umso größer die Wartezeit ist, umso langsamer ist das Scrollen.
Hallo, ich habe diese Schaltung jetzt aufgebaut, ich habe einen anderen Logic Level Converter benutzt (SparkFun 120009). Ich habe ihn folgendermaßen angeschlossen:
HV1 – SCL Display
HV2 – SDA Display
LV1 – SCL Raspberry Pi
LV2 – SDA Raspeberry Pi
HV – 5V Raspberry Pi – VCC Display
LV – 3V3 Raspberry Pi
Die beiden GND-Pins des Converters habe ich verbunden und sowohl GND des Displays als auch GND des Raspberry Pi’s daran angeschlossen.
Jetzt passiert folgendes: wenn ich das gesamte Gerät anschließe, sieht es so aus, als ob der Raspberry Schwierigkeiten mit der Stromversorgung hätte: die Status-LEDs flackern, und der Pi schaltet sich aus (wenn ich es an den ausgeschalteten Pi anschließe, fährt er gar nicht erst hoch). Zusätzliche Info: Ich benutze einen Raspberry Pi 1. Generation Model B (Rev 2) mit aktuellem Raspbian Jessie).
Meine Frage: habe ich mir die Beschaltung des Converters richti zusammengewürfelt? Wenn
ja, muss ich dem Display vielleicht irgendwie eine externe Stromversorgung besorgen? Wenn ja, wie? Wenn nicht, gibt es in meiner Schaltung noch irgendeinen Fehler? Ich habe schon versucht, das Verbindungskabel zwischen den beiden GND und das Kabel RPi 5V – VCC Display – HV Converter zu entfernen, es hat nichts geholfen (ich hattte gedacht, dass diese Probleme vielleicht daran liegen könnten).
Ich werde vorerst das Projekt auf sich beruhen lasse, bis ich genaueres weiß, da ich meinen Raspberry Pi nur ungern grillen würde. 🙂
Vielen Dank schonmal im Voraus
Hallo Francesco,
hast du mal mit einem Multimeter die ausgehende Spannung des Logic Level Converter gemessen? Ich habe kein Sparkfun Modul da, aber die üblichen TTL’s kosten ja sehr wenig, weshalb du es ggf. noch einmal damit probieren könntest?
LG, Felix
Also, erstmal vielen Dank für die schnelle Antwort. Ich habe die Spannung noch nicht nachgemessen, bei mir wird das aber schwierig, weil ich wie gesagt das Display nicht wirklich anschließen kann, da mir ja dann sofort der Pi abschmiert… Außerdem, was meinst du mit TTL’s? Und hast du evtl Vorschläge zu „den üblichen“? LG, Francesco
Miss die Spannung am Konverter, solange das Display nicht angeschlossen ist. Den Link zu „den üblichen“ findest du oben im Artikel unter Zubehör -> I2C Logik Level Konverter.
Also, ich weiß nicht genau was passiert ist, allerdings bin ich zuerst auf sehr seltsame Werte gekommen (die Spannung hat irgendwie bei 15-20V geschwankt). Als ich dann aber nochmal nachgemessen habe, bin ich zu meiner Verwunderung auf 5V gekommen. Ich habe deshalb einfach mal ausprobiert, das Display wieder anzuschließen, und siehe da, es funktioniert einwandfrei. Danke trotzdem für deine Hilfe. LG, Francesco
Hallo zusammen,
Auch wenn ich jetzt allenfalls ausgelacht werde trotzdem noch einmal die Frage : Brauche ich den Wandler 3.3V zu 5V wirklich ? Habe lange gegoogelt und viele Projekte angeschaut, die Hälfte baut einen ein, die andere nicht. Selbst Sunfounder nimmt keinen für ihre Beispielprojekte für RPi Einsteiger…..
Wäre dankbar wenn jemand eine schlüssige „elektronische“ Erklärung geben könnte.
Vielen Dank im voraus.
Gruss Daniel
Hallo Daniel,
ausgelacht wird hier keiner 🙂
Das Problem, was bei vielen elektronischen Bauteilen besteht, ist, dass diese nicht immer absolut baugleich sind (ähnliches ist bei Relais und Ultraschallsensoren der Fall).
Wenn sich das Display auch mit 3.3V Signalen steuern lässt, ist alles in Ordnung und der Wandler ist nicht benötigt. Da aber 5V Signale in jedem Fall funktionieren, machst du nichts falsch, wenn du einen solchen verwendest.
LG, Felix
Hallo, eine Frage…ich habe ein Display angeschlossen, doch finde ich es NICHT unter i2cdetect -y 1 sondern i2cdetect -y 2:
root@bananapi ~/hd44780 # i2cdetect -y 2
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: — — — — — — — — — — — — —
10: — — — — — — — — — — — — — — — —
20: — — — — — — — 27 — — — — — — — —
30: — — — — — — — — — — — — — — — —
40: — — — — — — — — — — — — — — — —
50: — — — — — — — — — — — — — — — —
60: — — — — — — — — — — — — — — — —
70: — — — — — — — —
root@bananapi ~/hd44780 #
Wie kann ich das nun schreiben, dass er mir das Display da anspricht?
Ist ein vorgelöteter Baustein, und es sind keine Jumper vorhanden, um Adresse zu ändern.
Was für ein Pi Model hast du denn?
„Leider“ immernoch einen Bananapi, sowie einen Bananapi M2+, bei beiden das gleiche Spiel. Ich blicke leider bei Programmierung gar nicht wirklich durch^^
Hallo zusammen,
ist es möglich, sich den Status von bestimmten gpio pins anzeigen zu lassen?
ich habe vor mit dem raspberry pi ein relais anzusteuern und möchte mir deshalb den Status der gpios in eine Zeile anzeigen lassen.
Leider verstehe ich so ziemlich gar nichts von python.
Ich hoffe ihr könnt mir helfen.
gibt es dafür nicht irgendwie eine Möglichkeit, ich habe auch im Internet nichts gefunden, allerdings weiß ich auch nicht so wirklich wonach ich da googlen muss :C
Willst du den Input Status auslesen oder ob der Pin aus Input/Output deklariert wurde?
Raspberry Pi GPIO Erklärung für Beginner + Programmierung (Teil 2)
Nein, ich möchte wissen ob der output low oder high ist.
Hallo zusammen,
erstmal großes Lob für diese Seite!
Ich bekomme einfach das Display nicht richtig zum laufen.
i2cdetect -y 1 liefert mir eine Adresse von 3F diese habe ich auch in lcddriver.py angepasst. Die Hintergrundbeleuchtung lässt sich danach auch mittels backlight (on, off) schalten. 5V mit Konverter und 3,3V habe ich auch getestet. Es ergibt immer das gleiche Ergebnis.
Es scheint als ob die Adressen für die Zeichenausgabe sich irgendwie unterscheiden.
Das Display (ohne i2c) funktioniert, ich habe das Tutorial mit der direkten GPIO Anbindung erfolgreich durchgeführt.
Habt ihr noch eine Idee?
Sind alle Pins richtig verlötet und an den richtigen Stellen? Normalerweise haben die Module immer die gleichen Adressen, wie im Tutorial. Ggf. kannst du einen anderen Controller verwenden.
Hi Felix,
Könntest du mal hier drüber schauen ob das so IO ist oder ob man was besser machen kann.
# -*- coding: utf-8 -*- import lcddriver import os from time import * import subprocess lcd = lcddriver.lcd() lcd.lcd_clear() lcd.lcd_backlight('ON') laut = os.popen("sudo mpc volume").read() def scroll_up(): f=os.popen("sudo mpc current") station = "" for i in f.readlines(): station += i str_pad = " " * 20 station = str_pad + station for i in range (0, len(station)): lcd_text = station[i:(i+20)] lcd.lcd_display_string(lcd_text,2) #Siehe hier und unten. sleep(0.3) #Geschwindigkeit des Textes lcd.lcd_display_string(str_pad,3) lcd.lcd_display_string("Lautst"+chr(225)+"rke @", 1) lcd.lcd_display_string("%s" % (laut), 2) sleep(2.5) lcd.lcd_clear() lcd.lcd_display_string(''+str(scroll_up()), 4) # Zeilenangabe egal. Siehe oben. lcd.lcd_clear() lcd.lcd_backlight('OFF')Hallo,
ich möchte dieses LCD-Modul mit Scratch benutzen. Leider ist das nicht ganz einfach.
In Scratch 1 muss man Mesh aktivieren (https://wiki.scratch.mit.edu/wiki/Mesh), was aber nur in der 1.4 beta funktioniert, die nicht mehr verteilt wird. In Scratch 2 über Flash geht das vermutlich gar nicht mehr.
Hast Du eine Idee?
Viele Grüße
Kai
Guten Tag,
kannst du mir erklären warum mein Skript nicht läuft?
Ich verstehe es nicht.
import lcddriver
import wiringpi
lcd = lcddriver.lcd()
lcd.lcd_clear()
var1 = gpio -g read 4
lcd.lcd_display_string(var1, 1)
Nach der Zeile: var1 = gpio -g read 4
kommt bei mir immer SyntaxError: invalid syntax
aber wenn ich den Command normal in die Konsole eingebe (also gpio -g read 4)
gibt er mir immer 0 oder 1 aus, je nachdem auf was der gpio halt grad steht.
Was soll denn die Zeile
var1 = gpio -g read 4tun? Python Syntax ist das jedenfalls nicht…gpio -g read 4
ist ein wiring pi command, und der gibt halt aus ob der Zustand des gpios null (also low) oder 1 (also high) ist.
ich hab mir das halt so vorgestellt, das dann die variable den wert 0 oder 1, je nach Zustand des gpios annimt
Ja gut, aber es ist ein Shell Befehl. Dann musst du ihn auch entsprechend (mit os.system bspw.) ausführen. Wieso nutzt du nicht einfach die Python GPIO Bibliothek?
Raspberry Pi GPIO Erklärung für Beginner + Programmierung (Teil 2)
Würde ich ja sehr gerne machen, aber ich weiß nicht wie dort der Command dafür heißt, bzw wie das funktioniert
Deshalb habe ich dir das Tutorial verlinkt 😉
Hi!
Was muss ich am Treiber ändern, damit dieser auch mit einem 16×4 Display läuft.
Ich habe nämlich das Problem, dass die Zeilen 3 und 4 links immer 4 Zeichen eingerückt werden.
Vergleich mal die Adressen aus dem Datenblatt mit denen der Bibliothek.
Ah, okay… meine Lösung ist die folgende Änderung am Code.
An den Anfang:
# Define the columns (16 or 20) LCD_COLUMNS = 16 # This is the address of the first line FIRST_LINE_MEM_ADDR = 0x8 [...] # put string function def lcd_display_string(self, string, line): if line == 1: self.lcd_write(FIRST_LINE_MEM_ADDR ) if line == 2: self.lcd_write(FIRST_LINE_MEM_ADDR + 64) if line == 3: self.lcd_write(FIRST_LINE_MEM_ADDR + LCD_COLUMNS) if line == 4: self.lcd_write(FIRST_LINE_MEM_ADDR + 64 + LCD_COLUMNS)Hallöle, bei mir wird (egal wie ich die Jumper setze) das I2C Modul nicht under detect -Y 1 sondern unter -Y 2 erkannt. Was kann ich da machen? PS. SDA/SDL hab ich jeweils schon umgekehrt getestet
PS. anbei der Screenshot, damit man weiss, was ich meine
http://www.bilder-upload.eu/show.php?file=62a729-1509414208.png
Bzw. falls die Seite mir das Bild mal wieder löscht:
http://fs5.directupload.net/images/171031/4dc9xl4m.png
Ist es möglich nur eine Zeile zu löschen oder muss ich immer das komplette Display leeren ?
Du kannst eine Zeile des Displays mit „Leerzeichen“ überschreiben.
Moin Felix,
vielen Dank für die gelungene Beschreibung.
Ich habe das Display 16×2 bereits mit dem Arduino unter c++ benutzt und dort gibt es die setCursor-Methode (siehe Code-Auszug). Man kann damit unter Angabe von Spalte und Zeile den Cursor setzen und ab dort Zeichen oder Texte schreiben.
Hast Du auch schon einmal versucht das in Python zu realisieren?
c++:————->
void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){ int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 }; if ( row > _numlines ) { row = _numlines-1; // we count rows starting w/0 } command(LCD_SETDDRAMADDR | (col + row_offsets[row])); }<————–
Hallo Rasp-Fans, möchte mein 2 zeiliges Display über I2C ansteuern, es wird auch erkannt, es wird die Zahl 27 angezeigt, aber beim Laden des Codes über wget…erhalte ich folgende Fehlermeldung:
Fehlermeldung
Verbindungsaufbau zu tutorials-raspberrypi.de (zu tutorials-raspberrypi.de) I89.163.139.94I:443…verbunden.
http-Anforderung gesendet, warte auf Antwort…404 Not Found.
Auflösen des Hostnamen >>hd44780_i2c.zip<>hd44780_i2c.zip<< nicht auflösen
Wo liegt der Fehler, bin Anfänger. Wer kann mir einen Tip geben.
Heinz
Habe den Fehler gefunden!
Hallo Felix,
dein script läuft super. Bin leider Python-Anfänger und möchte eine Zeile mit 2 Textsegmenten und 2 Variablen anzeigen:
text1=“u1=“
text2=“u2=“
var1 z.B. 4.78
var2 z.B. 7.81
zeile=1
lcd.lcd_display_string(„text1″,var1,“text2“,var2, zeile)
Wie sieht die programmzeile aus?
Danke!
lcd.lcd_display_string("text1" + str(var1) + "text2" + str(var2), zeile)Danke Felix, super!
Hallo Felix, meine Temperaturmessung läuft, nun möchte ich den Messwert auf mein Display anzeigen. Die Anzeige läuft, aber ich mache wohl einen Umwandlungsfehler.
def aktuelleTemperatur1(): # 1-wire Slave Datei lesen file = open('/sys/bus/w1/devices/10-0008032e37f1/w1_slave') fileinhalt = file.read() file.close() # Temperaturwerte auslesen und konvertieren stringvalue = fileinhalt.split("n")[1].split(" ")[9] temperature = float(stringvalue[2:]) / 1000 # Temperatur ausgeben Rueckgabewert1 = '%6.2f' % temperature return(rueckgabewert1) messdaten1 = aktuelleTemperatur1() lcd.lcd_display_string("T1 " + str(messdaten1), 2)Wo liegt der Fehler? Für Deine Hilfe schon mal ein Dankeschön vorab.
Was gibt es denn zurück?
Danke Felix! Der print-Befehl zeigt an: 22.81
Die Fehlermeldung lautet: UnboundLocalError:Local variable „messdaten1“ referenced before assigment.
Du greifst auf eine Variable (messdaten1) zu, die noch nicht definiert wurde.
Hallo,
ich habe folgendes Display 20×4
http://www.farnell.com/datasheets/2566411.pdf?_ga=2.186788456.1129287909.1519284546-1756637393.1518878926
Anfangs wollte es nicht laufen was es jetzt aber tut, leider wird alles durcheinander angezeigt.
Lines = getGas()
print(Lines[0] +’n’+ Lines[1]+ ’n’+ Lines[2]+ ’n’+ Lines[3])
lcd = lcddriver.lcd()
lcd.lcd_clear()
lcd.lcd_display_string(Lines[0],1)
lcd.lcd_display_string(Lines[1],2)
lcd.lcd_display_string(Lines[2],3)
lcd.lcd_display_string(Lines[3],4)
time.sleep(5)
Die Daten die ich Anzeigen möchte sind schon auf 19 Zeichen begrenzt. Daran kann es wohl nicht liegen, lcd.clear() hat scheinbar keine funktion das Display bleibt unverändert.
Hat einer eine Idee woran das liegen kann?
Vielen Dank vorab
gruss
Hast du evtl. die Pins vertauscht?
Bei meinem Display funktioniert alles einwandfrei, bis auf das, dass manche Zeichenfehler auftreten, so steht im Display „ese“, wenn ich „es“ schreiben will.
Bitte um Hilfe
Hast du das Display vorher „geleert“ (alte Zeichen werden nicht gelöscht)?
Ich habe auf meinem 20×4 Display nur 2 weiße Balken drauf. Die Schrift, wie sie vorgegeben ist, erscheint nicht. Eine Fehlermeldung bekomme ich aber auch nicht. Display wird ebenfalls an der 27 angezeigt.
Keiner eine Antwort drauf? *verweifel*
Hat sich erledigt. Ein neues Display hats getan. Scheinbar war das erste defekt
Funktioniert auf Anhieb – danke 🙂
Welche Anpassungen müsste man vornehmen um mehrere Displays zu betreiben, entweder gespiegelt (gleiche Inhalte) oder völlig unabhängig?
Was ist zu tun, wenn auf dem Raspberry PI 3 eine Hifiberry Amp 2 draufsteckt und die beiden Pins
GPIO 2 bzw GPIO 3 nicht benutzt werden können. Wie kann ich dann den lcddriver anpassen, wenn andere Pins benutzt werden ?
Hallo hab einähnliches Problem, sodas beim mir die GPIO 2 und 3 belegt sind. hast du diesbezüglich schon eine Antwort bzw. Lösung.
Gruss Svenomatt
Hallo, super Tutorial hat mir geholfen das Display in Betrieb zu bekommen. Nur den Pegelwandler kann oder sollte man sich sogar sparen. Warum, die I2C Schnittstelle läuft mit eine Pulluphardware.
Das bedeutet wenn ein Teilnehmer aktiv (Lowpegel) wird, dann zieht er die Spannung gegen 0V. Pullupwiederstände sorgen für den Highpegel. Beim Raspberry haben diese Wiederstände 50kOhm. Das Display (zumindest meins) hat keine (komischerweise). Die Pegel für High und Low sind bei beiden Bauteilen (Raspi und Display) fast gleich (Raspi Low1,8V ; Display Low2V) und verstehen sich deshalb sehr gut auch ohne Pegelwandler. Dieser macht die immer wieder beschriebenen Probleme bei „i2Cdetect“, da er (je nach Ausführung) beim Lesen die Spannung zu weit runter holt.
Hallo, sobald ich sudo python eingebe und Enter drücke erscheint:
Python 2.7.13 (default, Nov 24 2017, 17:33:09)
[GCC 6.3.0 20170516] on linux2
Typ „help“, „copyright“, „credits“ or „license“ for more information.
Hallo, ich habe diesen Skript für den HX711 und dem HD44780 im I-net gefunden und einen Test gestartet.
https://pastebin.com/2SDHttgf
Doch leider kommt dann dieser Fehler in Shell:
Warning (from warnings module):
File „/home/pi/hd44780/hx711.py“, line 11
GPIO.setup(self.PD_SCK, GPIO.OUT)
RuntimeWarning: This channel is already in use, continuing anyway. Use GPIO.setwarnings(False) to disable warnings.
Traceback (most recent call last):
File „/home/pi/hd44780/WaageVolk1.py“, line 18, in
hx = HX711 (5, 6)
File „/home/pi/hd44780/hx711.py“, line 18, in __init__
self.lastVal = long(0)
NameError: name ‚long‘ is not defined
https://pastebin.com/RPFtFf9Y Das ist jetzt der richtige Skript, beim Post zuvor habe ich was vergessen.
Hallo,
ich bekomme leider eine Fehlermeldung beim ausführen des Testskriptes. Verkabelung habe ich schon gecheckt. Habe es am RPI 3 B laufen. Woran kann das liegen?
Traceback (most recent call last):
File „/home/pi/hd44780/testlcd.py“, line 4, in
lcd = lcddriver.lcd()
File „/home/pi/hd44780/lcddriver.py“, line 61, in __init__
self.lcd_write(0x03)
File „/home/pi/hd44780/lcddriver.py“, line 85, in lcd_write
self.lcd_write_four_bits(mode | (cmd & 0xF0))
File „/home/pi/hd44780/lcddriver.py“, line 80, in lcd_write_four_bits
self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
File „/home/pi/hd44780/i2c_lib.py“, line 11, in write_cmd
self.bus.write_byte(self.addr, cmd)
OSError: [Errno 121] Remote I/O error
>>> %Run testlcd.py
Traceback (most recent call last):
File „/home/pi/hd44780/testlcd.py“, line 4, in
lcd = lcddriver.lcd()
File „/home/pi/hd44780/lcddriver.py“, line 61, in __init__
self.lcd_write(0x03)
File „/home/pi/hd44780/lcddriver.py“, line 85, in lcd_write
self.lcd_write_four_bits(mode | (cmd & 0xF0))
File „/home/pi/hd44780/lcddriver.py“, line 80, in lcd_write_four_bits
self.lcd_device.write_cmd(data | LCD_BACKLIGHT)
File „/home/pi/hd44780/i2c_lib.py“, line 11, in write_cmd
self.bus.write_byte(self.addr, cmd)
OSError: [Errno 121] Remote I/O error
>>>
Ausgabe i2cdetect:
pi@raspberrypi:~ $ sudo i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: — — — — — — — — — — — — —
10: — — — — — — — — — — — — — — — —
20: — — — — — — — — — — — — — — — —
30: — — — — — — — — — — — — — — — —
40: — — — — — — — — — — — — — — — —
50: — — — — — — — — — — — — — — — —
60: — — — — — — — — — — — — — — — —
70: — — — — — — — —
Gibt es hierzu eine Lösung, ich habe selbiges Problem.
Gibtes hierzu eine Lösung? Ich habe das gleiche Problem
Hi
habe das display angeschlossen und bekomme über den Befehl:
pi@raspberrypi:~ $ sudo i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
10: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
20: 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
30: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
40: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
50: 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
60: 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
70: 70 71 72 73 74 75 76 77
direkt das angezeigt…. was mach ich falsch??
Hast du es mittlerweile hinbekommen? Ich habe das gleiche Verhalten- an mein Raspberry Pi 3B angeschlossen (Direkt via 5V Pin zu VCC) und er findet keine Geräte mit „sudo i2cdetect -y 1″…Bei mir kommen aber nur Striche, nicht wie bei dir die Zahlen.
Zur Diskussion aus 2016 (Stefan)
siehe https://de.wikipedia.org/wiki/HD44780
einschließlich der weblinks
Man kann bis zu 8 Zeichen selbst definieren (Beispiel Batterie-Füllstand)
Es wird gelegentlich auf das Datenblatt zum I2C-Controller hingewiesen; ich habe es bisher nicht finden können. Gibt es einen Link?
Nachklapp: Meine 16×2 LCDs arbeiten wunderbar mit 3,3 Volt. Also keine Pegelwandler erforderlich.
Ich hab mir über Amazon dieses LCD gekauft, ein Datenblatt dazu findet man auch hier: http://wiki.sunfounder.cc/index.php?title=I2C_LCD2004 (unten unter Resources).
Im Datenblatt sieht man zwei Dinge:
1. Dieser I2C-Controller arbeitet zwischen 2,5 und 7V, den Pegelwandler kann man sich daher in dem Fall wirklich schenken.
2. Der Controller zieht über die Spannungsversorgung bis zu 400mA. Da der GPIO aber insgesamt nur mit maximal 50mA belastet werden darf, halte ich es für keine sehr gute Idee, wenn man die Spannungsversorgung direkt über den GPIO macht. Besser wäre hier wahrscheinlich eine externe Spannungsversorgung. Kann mir hierbei jemand beratend zur Seite stehen, wie man das am besten bewerkstelligt?
Zusatz: Wobei ich den Strom, der in meinem Fall fließt, noch nicht gemessen habe, werde ich aber noch nachholen.
Ich betreibe auf zwei RASPI 3B+ je ein HD44780-4×20 LCD mit I2C-Controller. Da ich den Standard-I2C-Bus (GIO-Pin 2 und 3 = Steckerleisten-PIN 3 und 5) auf beiden Systemen andersweitig verwende, habe ich den I2C-Bus Nr. 3 mit den GIO-PINs 23 und 24 (Steckerleisten-PIN 16 und 18) definiert. Zwischen dem RASPI und dem I2C-Controller des Displays ist ein 3.3/5V-Pegelwandler eingesetzt. Die Anzeige, die via CRON-Job im Minutentakt beschrieben wird, funktioniert einwandfrei. Nur kommt es in undefinierbaren Zeitabständen dazu, dass nichts angezeigt wird. Erst mit dem nächsten oder übernächsten Refresh der Anzeige werden wieder Daten angezeigt. Es treten auch keine falschen Zeichen auf.
Anfänglich dachte ich, dass vielleicht die 1k8 Ohm Pullup-Widerstände, die standardmäßig den GPIO-PIN 2 und 3 hochziehen, fehlen. Ich habe die auf den von mir verwendeten GPIOs nachgerüstet. Eine Verbesserung des Verhaltens blieb aus.
Hat jemand vielleicht ähnliche Erfahrungen gemacht und vielleicht sogar eine Lösung gefunden?
Übrigens:
beide Raspberry Pi 3 B+ mit Original RASPI-Netzteil
ein RASPI läuft mit RASPIAN buster, der andere mit stretch
Vielen Dank für Hilfestellungen im Voraus.
Peter
Das Problem konnte ich bereits selbst lösen. Nachdem auf meinem Testsystem, ein RASPI B+ (kein 3B+ !) das Display mit dem gleichen Programm ohne Probleme lief, kam ich auf die Idee, dass es sich um ein Timingproblem handeln könnte. Ich änderte daher die sleep(0.0001) – Anweisung in der Library i2c_lib.py auf sleep(0.0002) und schon lief es auch auf den schnelleren RASPI 3B+.
Liebe Grüße
Peter
Hi zusammen,
ich habe mir optisch den selben I2C Display Adapter mit LCD Display HD44780 bestellt, nun habe ich mir vorweg schon Tutorials angeschaut und bin etwas unschlüssig. Würde gerne auf den Logic Konverter aus Platzgründen verzichten. Die einen benutzen das Teil direkt an den 5V vom Raspi, die anderen Löten die Pullups von SCL u. SDA aus. Hat jemand Erfahrung mit dem auslöten der Pullups und kann das bestätigen?
Display erhalten! Mit den Pullups gemessen. Es liegen ca 4,6V an SDA und SCL an. Ohne Pullups keine nennenswerte Spannung. Funktioniert so einwandfrei.
Hallo,
ich habe folgendes Problem das wo ich nicht weiter komme.
Habe das Display so wie im Tutorial angeschlossen. Wird anscheinend auch erkannt.
Nur ich kann nix ausgeben. Wenn ich am Regler für den Kontrast drehe erscheinen 2
Durchgehende Balken in Reihe 1 und 3. das ist das einzige.
Danke schon mal für die Hilfe.
Ach ja, die Hintergrundbeleuchtung an und ausschalten funktioniert mit lcd.lcd_backlight(„on“) bzw „off“
Gleiches problem Hier! konntest du es lösen?
Hallo Felix,
der 5V Konverter wird doch nur benötigt, wenn man ein Breadbord verwendet, oder?
Schließt man das Display für direkt am 5V-Augang bei den Pins an, wird das Display doch sowieso mit 5V versorgt?
Lg Michael
Hallo,
ich habe gerade angefangen auf dem pi dinge zu Code, und habe keine Ahnung wie ich Sonderzeichen z.b. ä oder ° anzeigen kann. (Ich habe ein I2C 16×2 Display und einen Raspberry Pi 4 Model B)
Es wäre echt total freundlich wen jemand der es weiß mir helfen könnte!
schon einmal danke im voraus
LG Mattis