erste schritte

Als dieser Beitrag zuerst erschien, gab es von "Waveshare das runde 1.28-Zoll-IPS-LCD-Display auf der Basis des RP2040". Es wurde und wird in den verschiedenen Elektronikshops unter der Produktnummer: WS-22668 angeboten. In der Zwischenzeit ist aber der neuere Pico 2 mit dem Mikrokontroller RP 2350 auf dem Markt. Deshalb hat Waveshare folgerichtig auch ein weiterentwickeltes Entwicklerboard mit der Bezeichnung "Waveshare RP2350 MCU Board, with 1.28inch Round LCD, Dual-core & Dual-Architecture Design, 240x240 Pixels, 65K Color, IPS Panel, USB Type-C Port, Without Case" im Angebot. Die Produktnummer dafür lautet: WS-28986. Zu den wichtigsten Unterschieden gehören ein schnellerer Systemtakt, mehr RAM, mehr Flash-Speicher, neue Sicherheitsfunktionen und alternative RISC-V-Kerne.

Die nachfolgenden Anleitungen wurden für den RP2040 entwickelt, sind aber auch ohne Änderungen mit dem RP2350 kompatibel. Um den doppelt so großen RAM und den größeren Flash-Speicher des Nachfolgemodells zu nutzen, wurden einige Anleitungen von mir erweitert bzw. neu hinzugefügt. Diese sind jeweils gekennzeichnet.

Anleitung getestet mit CircuitPython 10.0.0-beta


Bildbox 1 (klick hier)



Hardware

- Rundes 1,28-Zoll-IPS-LCD-Display
- RP Pico 2040 (inclusive)
- USB-A zu USB-C Kabel

Firmware

- CircuitPython 10.0.0

Beachten Sie, dass Sie die Bibliotheken im Lib-Ordner aus dem 10-er Bundle verwenden. Um in das Thema erfolgreich einzusteigen, können Sie die folgende zip-Datei bei mir herunterladen, entpacken und später auf den Pico übertragen, wenn es um die Beispiele geht. Enthalten sind alle notwendigen Bibliotheken einschließlich des angepassten Displaytreibers gc9a01.py. Diese Bibliotheken müssen im lib-Ordner vorhanden sein.

Andere Themen zum runden 1.28 LCD-Display von Waveshare finden Sie bei mir hier:

Grundlagen ACC- und Gyroskop Sensor QMI8658

Die zweiten Schritte mit dem runden Display

Mathematische Grundlagen zum runden Display

Digitaluhr mit Schrittzähler (nutzt ACC Sensor)

Analog-Digital Uhr mit rundem Display

echte Analoguhr mit Stunden-, Minuten- und Sekundenzeiger

verbesserte Analoguhr mit dem WS-28986 (RP 2350)


Sie haben sich also für das runde LCD-Display von Waveshare entschieden und wollen es nun in Betrieb nehmen. Sehen Sie hier die ersten Schritte dazu.

Los gehts

Das Display ist fest auf der Platine mit dem Mikrokontroller installiert. Es versteht sich, dass bisher keine Spannung angelegt ist! Als erstes wird die Firmeware für den Pico benötigt.

1. Bevor Sie das Board erstmalig an die Stromversorgung anschließen, muss zunächst die CircuitPython-Firmware mit der Ansteuerung für das runde Pico Display übertragen werden. Ich nutze dazu die Seite von CircuitPython und lade die uf2-Datei für das runde Display von hier herunter:
https://circuitpython.org/board/waveshare_rp2040_lcd_1_28/

2. Nach dem Download der uf2-Datei muss diese auf das Displayboard übertragen werden. Im ersten Schritt nehmen Sie das Board im ausgeschalteten Zustand zur Hand und drücken die Boot-Taste (siehe Beschriftung auf der Platinenrückseite). Die wird gehalten und das Board erst dann (!!) über das USB-A zu USB-C Kabel mit dem Rechner verbunden. Nach dem Verbinden kann die Boot Taste losgelassen werden. Es öffnet sich im Filesystem ein Explorer-Fenster mit einem neuen Massenspeicher RPI-RP2. Öffnen Sie jetzt auf dem Rechner den Download-Ordner und ziehen die uf2-Datei mit der CircuitPython Firmware auf den Massenspeicher RPI-RP2. Sobald die Firmware-Datei auf das Board kopiert ist, wird die Firmware ausgeführt und ein neuer Massenspeicher 'CIRCUITPY' im Explorerfenster angezeigt. Damit ist die Programmiersprache CircuitPython für die Ansteuerung des runden Displayboards installiert und die Programmierung kann über Thonny beginnen.

3. Falls bei der ersten Benutzung von Thonny kein Board erkannt wird, muss in den Interpreter-Einstellungen die Port-Auswahl überprüft werden und ggf. auf CircuitPython (generic) eingestellt werden. Auch wenn Sie mehrere Displays benutzen, wird der Com-Port nicht immer richtig erkannt. Klicken Sie dann ganz unten rechts auf den 'Button'. Das Fenster sollte jetzt so aussehen:

In der unteren Kommandozeile wird der Controller z.B. mit "Adafruit CircuitPython 9.0.5 on 2024-05-22; Waveshare RP2040-LCD-1.28 with rp2040" angezeigt.

 Jetzt öffnen Sie über das Thonny-Menü die Datei 'display_mit_text.py' und können sie ausführen. Wenn Sie die noch nicht heruntergeladen haben (siehe oben), sollten Sie das jetzt tun oder Sie kopieren den Code aus dem Kasten in die Zwischenablage indem Sie auf den Button 'Code kopieren' klicken und in Thonny einsetzen.
Sehen wir uns das Programm an und erklären die Details, die für unsere eigenen Anwendungen später wichtig sind. 

  
  
1   # SPDX-FileCopyrightText : 2023 Detlef Gebhardt, written for CircuitPython
2   # SPDX-FileCopyrightText : Copyright (c) 2023 Detlef Gebhardt
3   # SPDX-Filename          :
4   # SPDX-License-Identifier: GEBMEDIA
5   import time
6   import board
7   import busio
8   import displayio
9   import terminalio
10  from adafruit_display_text import label
11  import gc9a01
12  import my_qmi8658
13
14  # Alle verwendeten Ressourcen freigeben
15  displayio.release_displays()
16  # Display initialisieren
17  spi = busio.SPI(clock=board.GP10, MOSI=board.GP11)
18  display_bus = displayio.FourWire(spi, command=board.GP8, chip_select=board.GP9, reset=board.GP12)
19  display = gc9a01.GC9A01(display_bus, width=240, height=240, backlight_pin=board.GP25)
20  group1 = displayio.Group()
21  display.rotation = 90
22  display.brightness = 0.8
23
24  # display.show(group1)
25  # ab CircuitPython 9.0.x ersetzen durch
26  display.root_group = group1
27
28  # Sensor initialisieren
29  sensor=my_qmi8658.QMI8658()
30
31  # Hintergrundpalette
32  color_bitmap = displayio.Bitmap(240, 240, 1)
33  color_palette = displayio.Palette(1)
34  color_palette[0] = 0x800000
35  bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
36  group1.append(bg_sprite)
37
38  # Textausgabe
39  text1 = " rundes Display\n\n" + "1.28-Zoll-IPS-LCD\n\n" + "  240x240 Pixel"
40  updating_label1 = label.Label(font=terminalio.FONT, text=text1, scale=2, color=0xffffff, line_spacing=1)
41  updating_label1.anchor_point = (0, 0)
42  updating_label1.anchored_position = (20, 70)
43  group1.append(updating_label1)
44
45  while True:
46      pass

In den Zeilen 5 bis 12 werden alle benötigten Bibliotheken importiert. Wichtig ist, dass sich 'adafruit_display_text' und 'gc9a01' (Treiber für das runde Display) und 'my_qmi8658' (mein angepasster Treiber für den ACC-Sensor unter CircuitPython) im lib-Ordner befinden, sonst kommt später eine Fehlermeldung. Die Zeilen 14 bis 20 initialisieren das Display und kommen in der Form in jedem späteren Programm vor. In der Zeile 21 wird die Drehung des Displays in 90 Grad Schritten festgelegt und in Zeile 22 die Displayhelligkeit. Hier sind Werte zwischen 0 (Display aus) und 1 (volle Helligkeit) möglich. Beim Messen des Stroms habe ich festgestellt, dass bei voller Helligkeit ca. 65 mA fließen und im ausgeschalteten Zustand ca. 30 mA. Das spielt z.B. eine Rolle, wenn man das Display mit einem kleinen Akku versorgt. Zeile 26 macht das Display für die Anzeige bereit.

Da wir auch gleich den Acc-Sensor nutzen wollen, muss dieser ebenfalls initialisiert werden. Das geschieht in Zeile 29.

Die Zeilen 31 bis 36 erzeugen das farbige Bitmap als Hintergrund und fügen es der Gruppe 'group1' hinzu. Jedes Objekt, welches auf dem Display dargestellt werden soll, wird also zunächst defieniert und im Speicher abgelegt.

In gleicher Weise bin ich mit dem Text verfahren (Zeilen 38 bis 43).

Da in unserem Fall noch nichts weiter passiert, steht in der 'while' Schleife die Anweisung 'pass', damit kein Fehler erzeugt wird. Später erfolgen hier weitere Befehle.

Z.B. könnten wir den Sensor lesen und je nach Richtung, wie wir das Display halten, den Bildschirm drehen. Man kennt das vom Smartphone. 

  
  
45  while True:
46      #read QMI8658
47      reading=sensor.Read_XYZ()
48      # Display wird gekippt
49      wert_y = (10)*reading[0]
50      wert_x = (10)*reading[1]
51      updating_label1.text = "\nwert_x: {:.3}\n\nwert_y: {:.3}".format(wert_x, wert_y)
52      if wert_y < -6:
53          display.rotation = 0
54      if wert_y >= -6 and wert_y <= 6 and wert_x < -6:
55          display.rotation = 90
56      if wert_y >= -6 and wert_y <= 6 and wert_x > 6:
57          display.rotation = 270
58      if wert_y > 6:
59          display.rotation = 180
60
61      time.sleep(0.1)

Dazu ändern wir die 'while'-Schleife wie folgt ab. Vom Acc-Sensor lassen sich in x-, y- und z-Richtung Werte lesen (reading[0], reading[1] und reading[2]). Wir nutzen in den Zeilen 49 und 50 den y- und den x-Wert. Die Werte werden mit 10 multipliziert. So sind die Unterschiede in den verschiedenen Positionen größer und die Werte lassen sich besser vergleichen.In Zeile 51 schauen wir uns zunächst die angezeigten Werte an und erkennen, dass wir als Intervall für die jeweilige Position wert_y < -6, wert_y >= -6 and wert_y <= 6 und wert_y > 6 nehmen können. Um zwischen -6 und +6 die Richtung unterscheiden zu können, nehmen wir zusätzlich den x-Wert hinzu, der entweder kleiner -6 oder größer als +6 sein sollte.



Viel Spass und Erfolg beim Ausprobieren.