HD44780 LCD Display per I2C mit dem Raspberry Pi ansteuern

29. Januar 2016
115 Comments

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 i2c display

Die Pins des I2C LCD Adapters passen perfekt auf das Display und können aufgelötet werden. Manche Displays werden bereits mit aufgelötetem I²C Adapter geliefert.

 

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:

647241639_842

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:

 

Raspberry Pi HD44780 I2C Display Controller

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:

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

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.

20160115_212307

 

 

Code Referenz: https://github.com/CaptainStouf/raspberry_lcd4x20_I2C

115 Kommentare

  1. 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)

    Antworten
  2. 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.

    Antworten
    • 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

      Antworten
  3. 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)

    Antworten
    • 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.

      Antworten
    • 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)
      Antworten
      • 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?

      Antworten
      • 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

    • 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

      Antworten
    • 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

      Antworten
  4. 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

    Antworten
  5. 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

    Antworten
    • 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

      Antworten
  6. 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

    Antworten
  7. 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

    Antworten
  8. 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

    Antworten
    • 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

      Antworten
      • 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

      Antworten
    • 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

      Antworten
      • 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

  9. 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?

    Antworten
  10. 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.

    Antworten
  11. 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?

    Antworten
    • ehm… jo… ist nun wieder obsolet… habe gestern bei n paar bier SDA und SCL am Raspi vertauscht… *glorreich*

      Antworten
  12. 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

    Antworten
  13. hallo,
    eigentlich sehr schöne Tutorials, leider nur Python und kein C/C++, daher für mich dummerweise nicht verwertbar….

    Antworten
    • 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.

      Antworten
    • 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.

      Antworten
  14. 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 ?

    Antworten
  15. 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.

    Antworten
  16. 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.

    Antworten
  17. Hallo
    Vielen Dank für das tolle Tutorial! Hat alles wunderbar funktioniert.
    Was muss ich bei „data“ im strobe Befehl eingeben?

    Antworten
  18. 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.

    Antworten
  19. 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?

    Antworten
  20. 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.

    Antworten
  21. 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…. 🙂

    Antworten
  22. 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

    Antworten
  23. 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 🙁

    Antworten
  24. 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.

    Antworten
    • 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.

      Antworten
  25. …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.

    Antworten
    • 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

      Antworten
  26. 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.

    Antworten
    • 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.

      Antworten
  27. 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.

    Antworten
  28. 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 🙂

    Antworten
  29. 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

    Antworten
    • 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

      Antworten
      • Hallo Rheinhard,
        ich habe die Änderung ins Archiv aufgenommen, sodass nun kein Anpassen mehr nötig sein sollte.

  30. 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!

    Antworten
    • 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)
      Antworten
  31. 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.

    Antworten
    • 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….

      Antworten
  32. 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.

    Antworten
  33. 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?

    Antworten
  34. 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

    Antworten
    • 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.

      Antworten
    • 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. 🙂

      Antworten
  35. 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

    Antworten
    • 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.

      Antworten
      • 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

      Antworten
  36. 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

    Antworten
    • 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

      Antworten
    • 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

      Antworten
      • 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

      Antworten
  37. 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

    Antworten
    • 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

      Antworten
  38. 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.

    Antworten
  39. 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.

    Antworten
  40. 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?

    Antworten
    • 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.

      Antworten
  41. 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')
    Antworten
  42. 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

    Antworten
  43. 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.

    Antworten
  44. 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.

    Antworten
      • 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)

Hinterlasse einen Kommentar

Deine Email Adresse wird nicht veröffentlicht.

Blog abonnieren

Abonniere Tutorials-RaspberryPi, um kein Tutorial mehr zu verpassen!