Contrôlons la série SO1602A d'écrans de caractères EL organiques vendus dans Akizuki en utilisant Raspberry Pi et Python. Module d'affichage de caractères EL organique 16x2 lignes blanches J'ai utilisé du blanc cette fois, mais le vert et le jaune sont également vendus au même prix.

câblage

La connexion entre RasPi et SO1602A est très simple, avec un total de 4 alimentations (3,3 V), GND, I2C SCL et SDA. De plus, plusieurs câblages sont nécessaires du côté SO1602.

Code PIN	une fonction
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

Le tableau ci-dessus est un extrait de la page 7 de la fiche technique. Les points à noter lors du câblage sont les suivants.

La broche 3 (CS) est connectée à GND.
La broche 4 est connectée à VDD ou GND. L'adresse de l'esclave I2C change en fonction de celui auquel vous vous connectez.
Les broches 8 et 9 sont utilisées ensemble comme SDA.
Les pull-ups SCL et SDA ne sont pas nécessaires car ils sont effectués à l'intérieur de RasPi.

Préparation RasPi

Les préparatifs pour l'utilisation d'I2C avec RasPi sont omis ici. [Cet article](http://make.bcde.jp/raspberry-pi/i2c%E3%82%92%E4%BD%BF%E3%81%86%EF%BC%88%E8%A8% Réglez en vous référant à AD% E5% AE% 9A% E7% B7% A8% EF% BC% 89 /).

Préparation Python

Utilisez SMBus pour manipuler I2C à partir de Python. Il peut être installé avec apt-get.

$ sudo apt-get install python-smbus

Contrôle d'affichage

Connexion et initialisation

L'adresse esclave de SO1602A est 0x3C (SA0 = Low) ou 0x3D (SA0 = High). Cette fois, j'ai écrit le constructeur comme suit. SA0 peut maintenant sélectionner Low / High et l'état d'affichage du curseur dans l'état initial.

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()

Exécution de la commande

SO1602A a plusieurs commandes. ClearDisplay et returnHome dans le constructeur ci-dessus sont des méthodes correspondant à ces commandes. Pour exécuter la commande

Envoyez les données (0x00) qui disent "Je vais envoyer une commande".
Envoyez une commande.

Il est nécessaire de suivre la procédure. Quand j'écris ceci en Python, cela ressemble à ce qui suit.

    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)

Il existe diverses autres options de commande, mais pour le moment, vous pouvez l'utiliser comme un écran.

Envoyer une chaîne

Enfin, affichons les caractères à l'écran. Pour envoyer une chaîne

Utilisez la commande pour déplacer la position du curseur vers n'importe quel emplacement
Envoyez les données (0x40) qui disent "Je vais envoyer une chaîne de caractères".
Envoyez la chaîne.

Il est nécessaire de suivre la procédure. De même, lorsque je l'ai écrit en Python, cela ressemblait à ce qui suit.

def writeLine(self, str = '', line = 0, align = 'left'):
    #Si la chaîne contient moins de 16 caractères, remplissez-la de blancs
    while (len(str) < 16):
        if (align == 'right'):
            str = ' ' + str
        else:
            str = str + ' '

    #Aligner la position du curseur
    if (line == 1):
        self.bus.write_byte_data(self.addr, 0x00, (0x80 + 0x20))
    else:
        self.bus.write_byte_data(self.addr, 0x00, 0x80)

    #Envoyez un caractère à la fois
    for i in range(len(str)):
        self.bus.write_byte_data(self.addr, 0x40, ord(str[i]))

La chaîne de caractères est écrite sous une forme qui écrase la mémoire bloc par bloc, donc Si vous écrivez "ABC" à l'endroit où "Hello" était affiché, l'affichage sera "ABClo". C'est pourquoi si la chaîne comporte moins de 16 caractères, elle est remplie de blancs.

C'est aussi une commande pour déplacer la position du curseur, Cela se fait en envoyant 0x80 plus la valeur du compteur d'adresses. La valeur du compteur d'adresses est 0x00 au début de la première ligne, suivie de 0x01, 0x02 ,,, 0x0F. Le début de la deuxième ligne est 0x20, puis 0x21 et ainsi de suite. Ici, writeLine est implémenté comme une méthode qui réécrit complètement la première ou la deuxième ligne.

Après cela, le code ASCII des caractères sera envoyé dans l'ordre. Il semble y avoir une méthode appelée write_block_data qui envoie des données en masse, Pour une raison quelconque, cela n'a pas fonctionné, donc j'envoie un caractère à la fois avec write_byte_data.

J'ai donc pu afficher les caractères sur l'écran en toute sécurité. L'écran EL organique a un très bon développement des couleurs et une très haute visibilité. L'angle de vue n'est pas aussi étroit que l'écran LCD. La carte d'expérimentation sur la photo a d'autres commutateurs connectés, donc le câblage est foiré, mais si vous ne voulez déplacer l'écran, vous n'en avez besoin que de quatre.

De plus, la chaîne de caractères peut être affichée en sélectionnant justifiée à droite ou justifiée à gauche. The'g'est un peu maladroit, mais c'est le charme de l'affichage des personnages.

à la fin

J'ai téléchargé le code que j'ai écrit cette fois sur gist. Puisque Python est un débutant, cela peut être disgracieux, mais pardonnez-moi s'il vous plaît.

Contrôlez l'écran EL organique connecté I2C d'Akizuki à partir de Raspberry Pi