Raspberry PI Pico #7: geometrische Figuren am OLED Display

In diesem Beitrag möchte ich dir zeigen, wie du geometrische Figuren auf einem OLED Display am Raspberry Pi Pico programmieren und anzeigen lassen kannst.

Raspberry Pi Pico - geometrische Figuren zeichnen — Raspberry Pi Pico – geometrische Figuren zeichnen

Im letzten Beitrag Raspberry PI Pico #6: OLED Display betreiben habe ich dir bereits gezeigt, wie man das Display anschließt, den Mikrocontroller für CircuitPython einrichtest und einen Text auf dem Display mit der Adafruit_SSD1306 Bibliothek anzeigen kannst.

Für diesen Beitrag verwende ich jedoch ein 0,96 Zoll (2,44 cm) OLED Display, welches etwas größer und somit für einen Beitrag besser geeignet ist.

0,96" OLED Display - Rückseite — 0,96″ OLED Display

Vorsicht: Dieses Display gibt es mit dem Treiberchip SH1106 & SSD1306, für diesen Beitrag verwende ich das Display mit dem SSD1306 Chip.

Inhaltsverzeichnis

1 Benötigte Ressourcen für dieses Projekt
2 Aufbau der Schaltung
3 Programmieren von geometrischen Figuren am Raspberry Pi Pico mit CircuitPython

Benötigte Ressourcen für dieses Projekt

Wenn du das Beispiel aus diesem Beitrag nachbauen möchtest, dann benötigst du:

einen Raspberry Pi Pico,
- ein Micro USB Datenkabel,
ein OLED Display,
vier Breadboardkabel, weiblich-weiblich, 20 cm

Das OLED Display kannst du entweder direkt an den Pi Pico über die Breadboardkabel anschließen oder aber wie ich es mache über ein 170 Pin Breadboard, dazu benötigst du jedoch vier Breadboardkabel mit männlich-weiblichen Anschlüssen.

Des Weiteren verwende ich für Aufbauten rund um den Pi Pico ein selbst erstelltes Expansionsboard welches ich dir im Beitrag DIY Expansion Board für Raspberry PI Pico mit Grove Adapter vorgestellt habe.

DIY Expansion Board für den Raspberry PI Pico mit Grove Adapter

Expansion Board fertig aufgebaut — DIY Expansion Board für den Raspberry PI Pico mit Grove Adapter

Aber natürlich funktioniert der Aufbau auch ohne ein solches Board!

Aufbau der Schaltung

Zunächst einmal einen kurzen Rückblick auf den vorherigen Beitrag wo ich dir bereits gezeigt habe wie ein OLED Display an ein Pi Pico über I2C angeschlossen wird.

OLED Display	Raspberry Pi Pico
VCC	Pin 36, 3.3 V
GND	Pin 38, GND
SCL	Pin 4, GP2, SCL
SDA	Pin 5, GP3, SDA

Hier nun die Grafik wie ich das OLED Display an den Pi Pico angeschlossen habe.

Aufbau der Schaltung - Raspberry Pi Pico mit OLED Display — Aufbau der Schaltung – Raspberry Pi Pico mit OLED Display

Programmieren von geometrischen Figuren am Raspberry Pi Pico mit CircuitPython

Bevor wir mit der Programmierung von geometrischen Figuren kommen, müssen wir zunächst die benötigten Bibliotheken installieren.

Für diesen Beitrag benötigst du die beiden Bibliotheken:

Adafruit_SSD1306
Adafruit_framebuff

Diese findest du im Adafruit CircuitPython Bundle unter https://circuitpython.org/libraries. Die Bibliotheken werden in den Ordner „lib“ kopiert welcher sich auf deim Pico befindet.

ein Rechteck / Quadrat zeichnen

Zeichnen wir zunächst ein Quadrat bzw. ein Rechteck. Ein Quadrat ist ja lediglich ein Rechteck, bei welchem alle Seiten gleich lang sind.

Ein Rechteck wird mit der Funktion „rect“ gezeichnet wobei als Parameter die Werte:

X Position begin
Y Position begin
X Position ende
Y Position ende
Farbe

import board
import busio
import adafruit_ssd1306
from time import sleep

SDA = board.GP2
SCL = board.GP3
i2c = busio.I2C(SCL, SDA)

oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=60)
oled.fill(0)

startX = 0
startY = 0
endX = 128
endY = 64
color = 1 # white = 1, black = 0
oled.rect(startX, startY, endX, endY, color) 
sleep(0.1)
oled.show()

Als Ausgabe haben wir nun ein Rechteck um die Ecken unseres OLED Displays gezeichnet.

eine Linie zeichnen

Zeichen wir als nächstes eine Linie.

Auch für die Linie (wie auch beim Rechteck) benötigen wir die Parameter:

X Position begin
Y Position begin
X Position ende
Y Position ende
Farbe

import board
import busio
import adafruit_ssd1306
from time import sleep

SDA = board.GP2
SCL = board.GP3
i2c = busio.I2C(SCL, SDA)

oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=60)
oled.fill(0)

startX = 0
startY = 10
endX = 64
endY = 20
color = 1 # white = 1, black = 0
oled.line(startX, startY, endX, endY, color) 
sleep(0.1)
oled.show()

Die Linie startet an der Position X=0, Y=10 und endet an X=64, Y=20.

ein Pixel Zeichnen

Wir können auch beliebige Pixels an Positionen X & Y Zeichnen und somit zbsp. einen Kreis zeichnen.

Die Funktion „pixel“ benötigt lediglich 3 Parameter:

Position X,
Position Y,
Farbe

Wir können nun mit einer For-Schleife eine gestrichelte Linie auf dem Display zeichnen.

import board
import busio
import adafruit_ssd1306
from time import sleep

SDA = board.GP2
SCL = board.GP3
i2c = busio.I2C(SCL, SDA)

oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=60)
oled.fill(0)

for i in range(0,128,5):
    startX = i
    startY = 10
    color = 1 # white = 1, black = 0
    oled.pixel(startX, startY, color) 

sleep(0.1)
oled.show()

Auf dem Display wird nun die gepunktete Linie angezeigt.

einen Kreis zeichnen

Es fehlt der Bibliothek eine Funktion, welche dazu dient einen Kreis zu zeichnen. Aus den Beispielen zur Adafruit SSD1306 Bibliothek für CircuitPython findest du das Beispiel „ssd1306_bouncing_ball.py“ bei welchem ein Kreis auf dem Display springt. Hier wird der Kreis mit der zuvor gezeigten Funktion „pixel“ und einer Schleife gezeichnet.

Dieser Funktion wird der Mittelpunkt des Kreises sowie der Radius übergeben, als letzter Parameter wird die Farbe gesetzt, wobei diese per Default aus „weiß“ gesetzt ist.

def draw_circle(xpos0, ypos0, rad, col=1):
    x = rad - 1
    y = 0
    dx = 1
    dy = 1
    err = dx - (rad << 1)
    while x >= y:
        oled.pixel(xpos0 + x, ypos0 + y, col)
        oled.pixel(xpos0 + y, ypos0 + x, col)
        oled.pixel(xpos0 - y, ypos0 + x, col)
        oled.pixel(xpos0 - x, ypos0 + y, col)
        oled.pixel(xpos0 - x, ypos0 - y, col)
        oled.pixel(xpos0 - y, ypos0 - x, col)
        oled.pixel(xpos0 + y, ypos0 - x, col)
        oled.pixel(xpos0 + x, ypos0 - y, col)
        if err <= 0:
            y += 1
            err += dy
            dy += 2
        if err > 0:
            x -= 1
            dx += 2
            err += dx - (rad << 1)

Hier nun ein kleines Beispiel wie du mithilfe der Funktion „draw_circle“ einen Kreis zeichnen kannst.

import board
import busio
import adafruit_ssd1306
from time import sleep

def draw_circle(xpos0, ypos0, rad, col=1):
    x = rad - 1
    y = 0
    dx = 1
    dy = 1
    err = dx - (rad << 1)
    while x >= y:
        oled.pixel(xpos0 + x, ypos0 + y, col)
        oled.pixel(xpos0 + y, ypos0 + x, col)
        oled.pixel(xpos0 - y, ypos0 + x, col)
        oled.pixel(xpos0 - x, ypos0 + y, col)
        oled.pixel(xpos0 - x, ypos0 - y, col)
        oled.pixel(xpos0 - y, ypos0 - x, col)
        oled.pixel(xpos0 + y, ypos0 - x, col)
        oled.pixel(xpos0 + x, ypos0 - y, col)
        if err <= 0:
            y += 1
            err += dy
            dy += 2
        if err > 0:
            x -= 1
            dx += 2
            err += dx - (rad << 1)

SDA = board.GP2
SCL = board.GP3
i2c = busio.I2C(SCL, SDA)

oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=60)
oled.fill(0)

center_x =40
center_y = 40
radius = 20

draw_circle(center_x, center_y, radius)

sleep(0.1)
oled.show()

Auf dem Display wird nun ein Kreis angezeigt.

🍪 Privacy & Transparency