Lassen Sie uns die SO1602A-Serie von in Akizuki verkauften organischen EL-Zeichenanzeigen mit Raspberry Pi und Python steuern. Organisches EL-Zeichenanzeigemodul 16x2 Zeilen weiß Ich habe diesmal Weiß verwendet, aber Grün und Gelb werden auch zum gleichen Preis verkauft.

Verdrahtung

Die Verbindung zwischen RasPi und SO1602A ist mit insgesamt 4 Netzteilen (3,3 V), GND, I2C SCL und SDA sehr einfach. Darüber hinaus sind auf der SO1602-Seite mehrere Verkabelungen erforderlich.

PIN Nummer	Funktion
1	GND
2	VDD (3.3V)
3	/CS (Chip Select, Low)
4	SA0 (Slave Address)
5, 6	No Connect
7	SCL
8	SDA_in
9	SDA_out
10-14	No Connect

Die obige Tabelle ist ein Auszug aus S.7 des Datenblattes. Bei der Verkabelung sind folgende Punkte zu beachten.

Pin 3 (CS) ist mit GND verbunden.
Pin 4 ist entweder mit VDD oder GND verbunden. Die I2C-Slave-Adresse ändert sich je nachdem, mit welcher Sie sich verbinden.
Die Pins 8 und 9 werden zusammen als SDA verwendet.
SCL- und SDA-Klimmzüge sind nicht erforderlich, da sie in RasPi ausgeführt werden.

RasPi-Vorbereitung

Vorbereitungen für die Verwendung von I2C mit RasPi werden hier weggelassen. [Dieser Artikel](http://make.bcde.jp/raspberry-pi/i2c%E3%82%92%E4%BD%BF%E3%81%86%EF%BC%88%E8%A8% Wird unter Bezugnahme auf AD% E5% AE% 9A% E7% B7% A8% EF% BC% 89 /) festgelegt.

Python-Vorbereitung

Verwenden Sie SMBus, um I2C von Python aus zu bearbeiten. Es kann mit apt-get installiert werden.

$ sudo apt-get install python-smbus

Anzeigesteuerung

Verbindung und Initialisierung

Die Slave-Adresse von SO1602A lautet entweder 0x3C (SA0 = Niedrig) oder 0x3D (SA0 = Hoch). Diesmal habe ich den Konstruktor wie folgt geschrieben. SA0 kann nun Low / High und den Anzeigezustand des Cursors im Ausgangszustand auswählen.

class SO1602A():
    def __init__(self, sa0 = 0, cursor = False, blink = False):
        self.bus = smbus.SMBus(1)
        if (sa0 == 0):
            self.addr = 0x3c
        else:
            self.addr = 0x3d
        self.clearDisplay()
        self.returnHome()
        self.displayOn(cursor, blink)
        self.clearDisplay()

Befehlsausführung

SO1602A verfügt über mehrere Befehle. ClearDisplay und returnHome im obigen Konstruktor sind Methoden, die diesen Befehlen entsprechen. Befehl ausführen

Senden Sie die Daten (0x00) mit der Aufschrift "Ich werde einen Befehl senden".
Senden Sie einen Befehl.

Es ist notwendig, das Verfahren durchzuführen. Wenn ich dies in Python schreibe, sieht es wie folgt aus.

    def clearDisplay(self):
        self.bus.write_byte_data(self.addr, 0x00, 0x01)
    
    def returnHome(self):
        self.bus.write_byte_data(self.addr, 0x00, 0x02)

    def displayOn(self, cursor = False, blink = False):
        cmd = 0x0c
        if (cursor):
            cmd += 0x02
        if (blink):
            cmd += 0x01
        self.bus.write_byte_data(self.addr, 0x00, cmd)

    def displayOff(self):
        self.bus.write_byte_data(self.addr, 0x00, 0x08)

Es gibt verschiedene andere Befehlsoptionen, die Sie jedoch vorerst als Anzeige verwenden können.

Senden Sie eine Zeichenfolge

Lassen Sie uns abschließend die Zeichen auf dem Display anzeigen. Eine Zeichenfolge senden

Bewegen Sie die Cursorposition mit dem Befehl an eine beliebige Stelle
Senden Sie die Daten (0x40) mit der Aufschrift "Ich werde eine Zeichenfolge senden".
Senden Sie die Zeichenfolge.

Es ist notwendig, das Verfahren durchzuführen. Als ich es in Python schrieb, sah es ähnlich aus.

def writeLine(self, str = '', line = 0, align = 'left'):
    #Wenn die Zeichenfolge weniger als 16 Zeichen enthält, füllen Sie sie mit Leerzeichen
    while (len(str) < 16):
        if (align == 'right'):
            str = ' ' + str
        else:
            str = str + ' '

    #Richten Sie die Cursorposition aus
    if (line == 1):
        self.bus.write_byte_data(self.addr, 0x00, (0x80 + 0x20))
    else:
        self.bus.write_byte_data(self.addr, 0x00, 0x80)

    #Senden Sie jeweils ein Zeichen
    for i in range(len(str)):
        self.bus.write_byte_data(self.addr, 0x40, ord(str[i]))

Die Zeichenfolge ist in einer Form geschrieben, die den Speicher Block für Block überschreibt Wenn Sie an der Stelle, an der "Hallo" angezeigt wurde, "ABC" schreiben, lautet die Anzeige "ABClo". Wenn die Zeichenfolge weniger als 16 Zeichen enthält, wird sie daher mit Leerzeichen aufgefüllt.

Es ist auch ein Befehl zum Verschieben der Cursorposition. Dies erfolgt durch Senden von 0x80 plus dem Wert des Adresszählers. Der Wert des Adresszählers ist 0x00 am Anfang der ersten Zeile, gefolgt von 0x01, 0x02 ,,, 0x0F. Der Anfang der zweiten Zeile ist 0x20, dann 0x21 und so weiter. Hier wird writeLine als eine Methode implementiert, die die erste oder zweite Zeile vollständig neu schreibt.

Danach wird der ASCII-Code der Zeichen der Reihe nach gesendet. Es scheint eine Methode namens write_block_data zu geben, die Daten in großen Mengen sendet. Aus irgendeinem Grund hat es nicht funktioniert, daher sende ich jeweils ein Zeichen mit write_byte_data.

So konnte ich die Zeichen auf dem Display sicher anzeigen. Das organische EL-Display weist eine sehr gute Farbentwicklung und eine sehr hohe Sichtbarkeit auf. Der Betrachtungswinkel ist nicht so eng wie beim LCD. Auf dem Steckbrett auf dem Foto sind andere Schalter angeschlossen, sodass die Verkabelung durcheinander ist. Wenn Sie jedoch nur das Display bewegen möchten, benötigen Sie nur vier.

Sie können auch rechtsbündig oder linksbündig auswählen, um die Zeichenfolge anzuzeigen. Das ist ein wenig klobig, aber es ist der Charme der Charakteranzeige.

schließlich

Ich habe den Code, den ich dieses Mal geschrieben habe, auf [gist] hochgeladen (https://gist.github.com/uhey22e/2a4d676363722d59428a937ac729def0). Da Python ein Anfänger ist, mag es unansehnlich sein, aber bitte vergib mir.

[PYTHON] Steuern Sie Akizukis I2C-verbundenes organisches EL-Display von Raspberry Pi