Texte mit unterschiedlichen Fonts darstellen

Ich habe im Internet die folgenden Links zum obigen Thema gefunden:

[[1]] [[2]] [[3]] [[4]] [[5]] [[6]] [[7]] [[8]]

Grundsätzlich handelt es sich wohl um das Modulpaket micropython-oled mit dem verschiedene Fonts auf dem Oled-Display dargestellt werden können.

Erster Versuch mit micropython-oled

[micropython-oled] Die hier beschriebene Espesso-IDE gibt es nicht mehr! (12.03.2024)

Bei der Espresso-IDE handelt es sich wohl um eine IDE, die über Websockets mit dem ESP32 kommuniziert. Das ist aber letztlich egal, weil ich ohnehin Thonny benutze. Mir geht es hier nur um die Beispiele. Da gab es einige Fehlermeldungen aud dem Raspberry Pi Pico, die aber in der Hardware begründet waren. So mus beim Raspi Pico noch die ID der I2C-Hardware angegeben werden, weil dieser 2 davon hat. Außerdem musste die Zeile 'Pin(16, Pin.OUT, value=1)' gelöscht werden. Deren Sinn erschließt sich mir nicht. Beim Raspi Pico liegt auf Pin 16 sda, so dass es nur Probleme geben kann. Hier der erste Versuch:

example1.py - Original

 >>> from machine import Pin, I2C
 >>> from oled import Write, GFX, SSD1306_I2C
 >>> from oled.fonts import ubuntu_mono_15, ubuntu_mono_20
 >>> scl = Pin(17)
     sda = Pin(16)
 >>> i2c = I2C(scl=scl, sda=sda)
     Pin(16, Pin.OUT, value=1)
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: 'id' argument required
 >>> i2c = I2C(0, scl=scl, sda=sda)
     Pin(16, Pin.OUT, value=1)
 Pin(16, mode=OUT)
 >>> oled = SSD1306_I2C(128, 64, i2c)
     gfx = GFX(128, 64, oled.pixel)

Hier hängt sich die REPL auf.

Nun das korregierte sample1.py:

from machine import Pin, I2C
from oled import Write, GFX, SSD1306_I2C
from oled.fonts import ubuntu_mono_15, ubuntu_mono_20

scl = Pin(17)
sda = Pin(16)

i2c = I2C(0, scl=scl, sda=sda)

oled = SSD1306_I2C(128, 64, i2c)
gfx = GFX(128, 64, oled.pixel)

write15 = Write(oled, ubuntu_mono_15)
write20 = Write(oled, ubuntu_mono_20)

write15.text("Espresso IDE", 0, 0)
write15.text("micropython-oled", 0, 15)

gfx.line(0, 32, 127, 32, 1)
gfx.line(0, 33, 127, 33, 1)

write20.text("1234567890", 0, 35)
write15.text("Ubuntu Mono font", 0, 52)

oled.show()

Hurra, es spielt. Nun will ich mir ansehen was dieses Modul zu bieten hat.

Das Modulpaket micropython-oled

Nun mal sehen wie das Modul angewendet wird:

from machine import Pin, I2C
from oled import Write, GFX, SSD1306_I2C
from oled.fonts import ubuntu_mono_15, ubuntu_mono_20

Zuerst die Importe. Aus oled werden Write, GFX und SSD1306_I2C importiert. Write und GFX sind neu. Mal sehen wofür die gut sind. Außerdem werden noch Fonts importiert.

scl = Pin(17)
sda = Pin(16)
i2c = I2C(0, scl=scl, sda=sda)

Wie schon bekannt wird eine Instanz der I2C-Schnittstelle erzeugt.

oled = SSD1306_I2C(128, 64, i2c)

Mit oled entsteht eine Instanz des Displays. Das ist wie beim einfachen SSD1306 Modul.

gfx = GFX(128, 64, oled.pixel)

Die Instanz gfx ist neu. Sie dürfte für die Grafik zuständig sein.

Einschub:

Die Textausgabe mit:

>>> oled.text('Hallo',0,0,1)
>>> oled.show()

Funktioniert wie vorher auch.

Nun geht's im Programmtext weiter:

Nun kommen aber neue Anweisungen:

write15 = Write(oled, ubuntu_mono_15)
write20 = Write(oled, ubuntu_mono_20)

Mit Write() werden nun neue Ausgabeinstanzen erzeugt, die den Text in einem bestimmten Font ausgeben. Für jeden gewünschten Font muss eine eigene Instanz erzeugt werden.

write15.text("Espresso IDE", 0, 0)
write15.text("micropython-oled", 0, 15)

Die Ausgabe erfolgt nun mit der zum gewünschten Font gehörenden Instanz. D.h. auch hier wird der Text erst in den Framebuffer geschrieben.

gfx.line(0, 32, 127, 32, 1)
gfx.line(0, 33, 127, 33, 1)

Wie vermutet ermöglicht die gfx Instanz die Darstellung von grafischen Elementen.

write20.text("1234567890", 0, 35)
write15.text("Ubuntu Mono font", 0, 52)

Nun noch weiteren Text in den Frambuffer und mit

oled.show()

zur Anzeige bringen.

Ein Blick in die Innereien

Nachdem das erste Programm einen Eindruck von der Anwendung vermittelt hat, möchte ich sehen, was in den neuen Klassen enthalten ist

Zuerst ein Blick in die Klasse SSD1306_I2C:

>>> dir(SSD1306_I2C)
['__class__', '__init__', '__module__', '__name__', '__qualname__', '__bases__', '__dict__', 'fill', 'invert', 'pixel', 'scroll', 'text', 'show', 'poweron', 'init_display', 'write_cmd', 'poweroff', 'contrast', 'write_framebuf']

Hier finden wir die schon bekannten Methoden

fill()

invert()

pixel()

scroll()

text()

show()

poweron()

poweroff()

contrast()

Die übrigen Methoden dürften für Erweiterungen interessant sein.

Mal sehen was die Klasse Write zu bieten hat:

>>> dir(Write)
['__class__', '__init__', '__module__', '__name__', '__qualname__', '__bases__', '__dict__', 'text', 'char']

Hier finden wir nur die Methoden

text()

char()

Auf GFX bin ich besonders gespannt:

>>> dir(GFX)
['__class__', '__init__', '__module__', '__name__', '__qualname__', '__bases__', '__dict__', 'fill_rect', 'line', 'rect', '_slow_hline', '_slow_vline',  'circle', 'fill_circle', 'triangle', 'fill_triangle']

Wie schon vermutet gibt es hier eine Reihe von Methoden zur Darstellung grafischer Elemente

line()

rect()

fill_rect()

circle()

fill_circle()

triangle()

fill_triangle()

Weitere Versuche

Nun möchte ich mit dem Neuen Wissen ein bischen herum spielen.

Die Grafik ausprobieren

Hier nehme ich mal das Programm example2.py von der Website von der auch sample1.py stammte. Ich habe es gleich korrigiert.

from machine import Pin, I2C
from oled import Write, GFX, SSD1306_I2C
from oled.fonts import ubuntu_mono_15, ubuntu_mono_20

scl = Pin(17)
sda = Pin(16)

i2c = I2C(0, scl=scl, sda=sda)

oled = SSD1306_I2C(128, 64, i2c)

gfx = GFX(128, 64, oled.pixel)

gfx.rect(5, 5, 10, 15, 1)
gfx.fill_rect(20, 5, 10, 15, 1)

gfx.circle(50, 15, 10, 1)
gfx.fill_circle(75, 15, 10, 1)

gfx.triangle(50, 40, 10, 50, 15, 25, 1)
gfx.fill_triangle(50 + 70, 40, 10 + 70, 50, 15 + 70, 25, 1)

oled.show()

Ein Versuch der nicht stattfand

Ich hätte sehr gerne auch das dritte Sample von obiger Website ausprobiert. Leider befindet sich unter sample3.py der selbe Text wie unter sample2.py. Das Ergebnis von sample3.py sieht sehr interessant aus:

Glücklicherweise ist das exampl3.py im Lib-Verzeichnis vorhanden. Mit den für den Raspberry Pi erforderlichen Anpassungen sieht es so aus:

from machine import Pin, I2C
from oled import Write, GFX, SSD1306_I2C
from oled.fonts import ubuntu_mono_15, ubuntu_mono_20
 
scl = Pin(17)
sda = Pin(16)

i2c = I2C(0, scl=scl, sda=sda)
# Pin(16, Pin.OUT, value=1)

oled = SSD1306_I2C(128, 64, i2c)
gfx = GFX(128, 64, oled.pixel)

write15 = Write(oled, ubuntu_mono_15)
write20 = Write(oled, ubuntu_mono_20)

write15.text("Espresso IDE", 0, 0)
gfx.fill_rect(0, 15, 128, 15, 1)
write15.text("micropython-oled", 0, 15, bgcolor=1, color=0)
for i in range(10):
    if i % 2:
        color, bgcolor = 1, 0
    else:
        color, bgcolor = 0, 1

    write20.text("{}".format(i), i * 10, 35, bgcolor=bgcolor, color=color)

gfx.rect(0, 35, 1 + (i + 1) * 10, 20, 1)
oled.show()

Das Ergebnis entspricht dem Bild oben.

Eine Batterieanzeige gibt noch dazu

Hier das Script für ein Batteriesymbol (example5.py):

from machine import Pin, I2C
from oled import Write, SSD1306_I2C
import utime


class battery_status:
    _FONT = {
        'battery-empty': [20, 1099511627775, 1099511627775, 1099511627775, 824633720832, 824633720832, 17179869168, 17179869168, 68719476720, 68719476720, 17179869168, 17179869168, 824633720832, 824633720832, 1099511627775],
        'battery-quarter': [20, 1099511627775, 1099511627775, 1099511627775, 824633720832, 824633720832, 17179869168, 17179852848, 68719460400, 68719460400, 17179852848, 17179869168, 824633720832, 824633720832, 1099511627775],
        'battery-half': [20, 1099511627775, 1099511627775, 1099511627775, 824633720832, 824633720832, 17179869168, 17178820656, 68718428208, 68718428208, 17178820656, 17179869168, 824633720832, 824633720832, 1099511627775],
        'battery-three-quarters': [20, 1099511627775, 1099511627775, 1099511627775, 824633720832, 824633720832, 17179869168, 17112760368, 68652367920, 68652367920, 17112760368, 17179869168, 824633720832, 824633720832, 1099511627775],
        'battery-full': [20, 1099511627775, 1099511627775, 1099511627775, 824633720832, 824633720832, 17179869168, 12884901936, 64424509488, 64424509488, 12884901936, 17179869168, 824633720832, 824633720832, 1099511627775],
    }


scl = Pin(17)
sda = Pin(16)

i2c = I2C(0, scl=scl, sda=sda)
# Pin(16, Pin.OUT, value=1)

oled = SSD1306_I2C(128, 64, i2c)
battery = Write(oled, battery_status)

oled.fill(0)
battery.char('battery-empty', 108, 0)
oled.show()
utime.sleep(0.5)

oled.fill(0)
battery.char('battery-quarter', 108, 0)
oled.show()
utime.sleep(0.5)

oled.fill(0)
battery.char('battery-half', 108, 0)
oled.show()
utime.sleep(0.5)

oled.fill(0)
battery.char('battery-three-quarters', 108, 0)
oled.show()
utime.sleep(0.5)

oled.fill(0)
battery.char('battery-full', 108, 0)
oled.show()
utime.sleep(0.5)

Eigene Versuche

Hier ein weiterer Versuch:

Es soll eine Anzeige für Spannung und Strom 3 Stromversorgungslinien simuliert werden.

>>> oled.fill(0)
>>> oled.show()
>>> write20.text('12.236 Volt', 0, 0)
>>> oled.show()
>>> write20.text('1025 mA', 0, 20)
>>> oled.show()
>>> write20.text(12.236 * 1025 / 10000, ' Watt' , 0, 40)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/lib/oled/write.py", line 54, in text
TypeError: 'float' object isn't iterable
>>> watt = 12.236 * 1025 / 10000
>>> write20.text(watt, ' Watt' , 0, 40)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/lib/oled/write.py", line 54, in text
TypeError: 'float' object isn't iterable
>>> write20.text(watt, + ' Watt' , 0, 40)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported type for __pos__: 'str'
>>> write20.text(str(watt) + ' Watt' , 0, 40)
>>> oled.show()
>>> oled.fill(0)
>>> oled.show()
>>> write20.text(str(12.236 * 1025 / 10000) + ' Watt' , 0, 40)
>>> oled.show()
>>> oled.fill(0)
>>> oled.show()
>>> write20.text('%.3f Watt'%(12.236 * 1025 / 10000), 0, 40)
>>> oled.show()
>>> 

Die enthaltenen Fonts

Das Paket micropython-oled bringt die in der Liste enthaltenen Fonts mit:

Fonts selbst erstellen

Für diese Funktion müssen micropython-oled und die Zielschriftart auf einem Computer installiert sein, pygame wird ebenfalls benötigt.

Icons erstellen

Zurück