Programmieren mit Arduino

Was du lernst

• Sketches, serieller Monitor, Variablen, Schleifen und Entscheidungen
• Display mit Adafruit ST7789/GFX, RGB-LED mit Adafruit NeoPixel
• Beschleunigungssensor mit einer eigenen Bibliothek für den STK8BA58
• flimmerfreie Grafik, Sprites, Kollisionen und ein ganzes Spiel
• hinter die Kulissen: Zeiger, Klassen, eigene Bibliotheken, PWM, ADC, I²C, SPI, Interrupts, zweiter Kern, Speichern
• zum Schluss: Programmieren mit KI

Das Buch setzt keine Vorkenntnisse voraus. Jedes Kapitel hat dieselbe Form: Worum geht’s, Erklärung mit kurzen Sketches, Ausprobieren, Übungsaufgaben in drei Stufen und „Das Wichtigste in Kürze“. Die Lösungen stehen im Anhang.

Was du brauchst

• einen PBC+ – mit zwei AAA-Batterien oder über USB-C versorgt
• ein USB-C-Kabel mit Datenleitungen (ein reines Ladekabel reicht nicht)
• einen Computer mit Windows, macOS oder Linux
• die kostenlose Arduino IDE 2
• etwa eine halbe Stunde fürs erste Einrichten – danach ist alles mit einem Klick erledigt

Der Schalter BAT/USB unten auf der Rückseite wählt, woher der Strom kommt: BAT von den Batterien, USB vom Kabel. Steht er auf USB und steckt kein Kabel, ist der PBC+ aus.

Die Arduino IDE einrichten

So steht es in Kapitel 2 des Buchs. Du machst das nur einmal; die IDE merkt sich alles.

1. Arduino IDE 2 installieren. Von arduino.cc (Bereich Software). Unter Windows das Installationsprogramm oder die ZIP-Datei nehmen, nicht die Fassung aus dem Microsoft Store – mit ihr erkennt die IDE den PBC+ nicht zuverlässig.
2. Boardverwalter-URL eintragen. Datei → Einstellungen… öffnen und in das Feld Zusätzliche Boardverwalter-URLs die Adresse unten eintragen. Steht dort schon eine, bekommt jede Adresse eine eigene Zeile.
3. Kern installieren. Werkzeuge → Board → Board-Verwaltung… öffnen, nach pico suchen und Raspberry Pi Pico/RP2040/RP2350 von Earle F. Philhower, III installieren. Das sind einige hundert Megabyte. Die Sketches im Buch sind mit Version 6.3.0 geprüft, neuere 6.x passen ebenso.
4. Board wählen. Werkzeuge → Board → Raspberry Pi Pico/RP2040/RP2350 → Generic RP2350.
5. Flash-Größe einstellen. Werkzeuge → Flash Size → 16MB (Sketch: 8MB, FS: 8MB). Alle anderen Punkte im Menü Werkzeuge bleiben, wie sie sind.
6. Bibliotheken installieren. Im Bibliotheksverwalter (Werkzeuge → Bibliotheken verwalten…) Adafruit ST7735 and ST7789 Library installieren und bei der Frage nach den Abhängigkeiten Alle installieren wählen – so kommen Adafruit GFX und Adafruit BusIO mit. Danach Adafruit NeoPixel.
7. Sensor-Bibliothek hinzufügen. STK8BA58.zip herunterladen, nicht entpacken, dann Sketch → Bibliothek einbinden → .ZIP-Bibliothek hinzufügen… und die Datei wählen.

Die Boardverwalter-URL für Schritt 2:

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Warum „Generic RP2350“?

Im Raspberry Pi Pico 2 steckt derselbe Chip, er hat aber nur 4 MB Flash. Der PBC+ hat 16 MB. Mit „Generic RP2350“ wählst du die Größe selbst – ohne deine Wahl würde der Kern mit 2 MB rechnen. Die Einstellung „Sketch: 8MB, FS: 8MB“ teilt den Flash: 8 MB für deinen Sketch, 8 MB für ein Dateisystem, in das dein Sketch selbst Dateien schreiben kann, etwa einen Punkterekord.

Bibliothek	Wofür	Woher
Adafruit ST7735 and ST7789 (mit Adafruit GFX und BusIO)	Display: Text, Linien, Kreise, Schriften, Canvas	Bibliotheksverwalter
Adafruit NeoPixel	die RGB-LED	Bibliotheksverwalter
STK8BA58	den Beschleunigungssensor – für das Buch geschrieben, es gab keine	STK8BA58.zip

Alles andere – Tasten, LEDs, Töne, Batteriespannung – geht mit den Bordmitteln von Arduino: digitalRead, digitalWrite, tone, analogRead.

Hochladen und Bootmodus

Zum Aufspielen muss der PBC+ im Bootmodus sein. Dann meldet er sich am Computer wie ein USB-Stick. Die beiden Knöpfe dafür sitzen auf der Rückseite, direkt über dem Schalter BAT/USB.

Beim ersten Mal: über den Bootmodus

1. Den PBC+ mit dem USB-Kabel an den Computer anschließen.
2. BOOT gedrückt halten, kurz RES tippen, BOOT loslassen. Ein neues Laufwerk erscheint.
3. Werkzeuge → Port → UF2 Board wählen. So nennt der Kern einen RP2350 im Bootmodus.
4. Auf Hochladen klicken (Pfeil, Strg + U). Die IDE kompiliert und kopiert das Programm auf das Laufwerk.
5. Das Laufwerk verschwindet von selbst, der PBC+ startet neu und führt deinen Sketch aus.

Danach: mit einem Klick

Läuft ein Arduino-Sketch, meldet sich der PBC+ als serieller Port – unter Windows COM und eine Nummer, unter macOS /dev/cu.usbmodem…, unter Linux /dev/ttyACM0. Wähle ihn unter Werkzeuge → Port. Ab jetzt genügt Hochladen: Die IDE schickt dem laufenden Sketch ein verabredetes Signal (sie öffnet den Port kurz mit 1200 Baud), und der PBC+ schaltet sich selbst in den Bootmodus.

Das Signal versteht nur ein Arduino-Sketch. Läuft MicroPython oder ein Spiel, oder ist ein Sketch abgestürzt, nimmst du wieder den Weg über BOOT und RES. Kaputt machen kannst du dabei nichts: Der Bootmodus steckt fest im Chip.

Der erste Sketch

Mit diesem Sketch aus Kapitel 2 und 3 prüfst du, ob alles klappt. Er schaltet das Display und das Hintergrundlicht ein und schreibt „Hallo!“.

#include <Adafruit_ST7789.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);

void setup() {
    tft.init(240, 280);
    tft.fillScreen(ST77XX_BLACK);
    pinMode(TFT_LICHT, OUTPUT);
    digitalWrite(TFT_LICHT, HIGH);

    tft.setCursor(66, 128);
    tft.setTextColor(ST77XX_WHITE);
    tft.setTextSize(3);
    tft.print("Hallo!");
}

void loop() {
}

Die Pins im Buch

Der Kern kennt den PBC+ nicht beim Namen. Deshalb stehen die Pins oben in jedem Sketch als #define mit deutschen Namen. Die Zahlen sind die GPIO-Nummern des RP2350.

Bauteil	Name im Sketch	Pin
Display CS / DC / Reset	TFT_CS / TFT_DC / TFT_RST	10 / 8 / 9
Hintergrundlicht	TFT_LICHT	26
Display SCK / MOSI	– (belegt die Bibliothek)	18 / 19
Lautsprecher	LAUTSPRECHER	15
LED rot / gelb / grün	LED_ROT / LED_GELB / LED_GRUEN	14 / 13 / 12
RGB-LED	RGB_LED	11
Joystick hoch / runter / links / rechts	TASTE_HOCH / TASTE_RUNTER / TASTE_LINKS / TASTE_RECHTS	4 / 2 / 3 / 1
Joystick Mitte	TASTE_MITTE	0
Taste A / B	TASTE_A / TASTE_B	27 / 28
Batteriespannung	BATTERIE	A3 (GP29)
Beschleunigungssensor SDA / SCL	– (sensor.begin(20, 21))	20 / 21

• Tasten mit pinMode(…, INPUT_PULLUP); gedrückt ist LOW. Entprellen ist nicht eingebaut.
• Display immer mit tft.init(240, 280); starten und das Hintergrundlicht mit digitalWrite(TFT_LICHT, HIGH); einschalten.
• RGB-LED: Adafruit_NeoPixel rgb(1, RGB_LED, NEO_GRB + NEO_KHZ800);
• Sensor: sensor.begin(20, 21); und sensor.setOrientation(STK8BA58::PICOBOY_COLOR_PLUS); – der Sensor ist auf der Platine um 90° gedreht eingebaut.

Beispiele aus dem Buch

Vier kurze Sketches, so wie sie im Buch stehen. Die Bilder zeigen, was das Display dabei anzeigt.

Eine Wetteranzeige (Kapitel 6)

Formen und Farben aus Adafruit GFX, dazu zwei der FreeFonts. getTextBounds misst einen Text aus, damit er genau in der Mitte steht.

// Eine Wetteranzeige aus Formen, Farben und FreeFonts
#include <Adafruit_ST7789.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSans12pt7b.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);

void setup() {
    tft.init(240, 280);
    tft.fillScreen(ST77XX_BLACK);
    pinMode(TFT_LICHT, OUTPUT);
    digitalWrite(TFT_LICHT, HIGH);

    tft.fillScreen(tft.color565(70, 150, 230));     // Himmel

    // Sonne mit acht Strahlen
    tft.fillCircle(150, 80, 30, ST77XX_YELLOW);
    tft.drawLine(150, 44, 150, 32, ST77XX_YELLOW);
    tft.drawLine(150, 116, 150, 128, ST77XX_YELLOW);
    tft.drawLine(114, 80, 102, 80, ST77XX_YELLOW);
    tft.drawLine(186, 80, 198, 80, ST77XX_YELLOW);
    tft.drawLine(175, 55, 184, 46, ST77XX_YELLOW);
    tft.drawLine(125, 55, 116, 46, ST77XX_YELLOW);
    tft.drawLine(175, 105, 184, 114, ST77XX_YELLOW);
    tft.drawLine(125, 105, 116, 114, ST77XX_YELLOW);

    // Wolke vor der Sonne: drei Kreise und ein Rechteck mit runden Ecken
    uint16_t wolke = tft.color565(240, 240, 240);
    tft.fillCircle(80, 120, 22, wolke);
    tft.fillCircle(110, 106, 28, wolke);
    tft.fillCircle(142, 120, 20, wolke);
    tft.fillRoundRect(58, 118, 106, 24, 12, wolke);

    // Texte, waagerecht in der Mitte
    int16_t x1, y1;
    uint16_t w, h;
    tft.setTextColor(ST77XX_WHITE);
    tft.setFont(&FreeSansBold18pt7b);
    tft.getTextBounds("Heiter", 0, 0, &x1, &y1, &w, &h);
    tft.setCursor((240 - w) / 2 - x1, 200);
    tft.print("Heiter");

    tft.setFont(&FreeSans12pt7b);
    tft.getTextBounds("24 Grad", 0, 0, &x1, &y1, &w, &h);
    tft.setCursor((240 - w) / 2 - x1, 235);
    tft.print("24 Grad");
}

void loop() {
}

Ein Punkt mit dem Joystick (Kapitel 9)

Solange du den Joystick drückst, wandert der Punkt. Ein Druck auf die Mitte wechselt die Farbe – aber nur einmal pro Druck. Dafür merkt sich der Sketch in mitte_vorher, ob die Taste vorher schon gedrückt war.

// Ein Punkt, der sich mit dem Joystick steuern laesst
#include <Adafruit_ST7789.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26
#define TASTE_HOCH 4
#define TASTE_RUNTER 2
#define TASTE_LINKS 3
#define TASTE_RECHTS 1
#define TASTE_MITTE 0
#define RADIUS 8

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);

int x = 120;
int y = 140;
uint16_t farbe = ST77XX_YELLOW;
bool mitte_vorher = false;

void setup() {
    tft.init(240, 280);
    pinMode(TFT_LICHT, OUTPUT);
    digitalWrite(TFT_LICHT, HIGH);
    tft.fillScreen(ST77XX_BLACK);
    pinMode(TASTE_HOCH, INPUT_PULLUP);
    pinMode(TASTE_RUNTER, INPUT_PULLUP);
    pinMode(TASTE_LINKS, INPUT_PULLUP);
    pinMode(TASTE_RECHTS, INPUT_PULLUP);
    pinMode(TASTE_MITTE, INPUT_PULLUP);
}

void loop() {
    tft.fillCircle(x, y, RADIUS, ST77XX_BLACK);     // alten Punkt loeschen

    // solange gedrueckt: bewegen
    if (digitalRead(TASTE_LINKS) == LOW && x > 30) {
        x = x - 2;
    }
    if (digitalRead(TASTE_RECHTS) == LOW && x < 210) {
        x = x + 2;
    }
    if (digitalRead(TASTE_HOCH) == LOW && y > 30) {
        y = y - 2;
    }
    if (digitalRead(TASTE_RUNTER) == LOW && y < 250) {
        y = y + 2;
    }

    // einmal pro Druck: Farbe wechseln
    bool mitte = digitalRead(TASTE_MITTE) == LOW;
    if (mitte && !mitte_vorher) {
        if (farbe == ST77XX_YELLOW) {
            farbe = ST77XX_CYAN;
        } else {
            farbe = ST77XX_YELLOW;
        }
    }
    mitte_vorher = mitte;

    tft.fillCircle(x, y, RADIUS, farbe);            // neuen Punkt zeichnen
    delay(10);
}

Flimmerfrei mit einem Canvas (Kapitel 14)

Zeichnet man direkt auf das Display, flackert eine Animation: Allein fillScreen braucht etwa 43 Millisekunden, und so lange ist der Ball weg. Die Lösung ist ein Bild im Arbeitsspeicher, ein GFXcanvas16. Du zeichnest unsichtbar hinein und schickst es dann mit einem einzigen Befehl zum Display. Ein Canvas in Bildschirmgröße braucht rund 134 KB – der RP2350 hat 520 KB.

// Derselbe Ball wie in k14_flackern, aber ohne Flackern
#include <Adafruit_ST7789.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);
GFXcanvas16 bild(240, 280);

int x = 30;

void setup() {
    tft.init(240, 280);
    pinMode(TFT_LICHT, OUTPUT);
    digitalWrite(TFT_LICHT, HIGH);
}

void loop() {
    bild.fillScreen(ST77XX_BLACK);
    bild.fillCircle(x, 140, 15, ST77XX_YELLOW);
    tft.drawRGBBitmap(0, 0, bild.getBuffer(), 240, 280);
    x = x + 4;
    if (x > 210) {
        x = 30;
    }
}

Eine Kugel, die durch Kippen rollt (Kapitel 17)

Der Beschleunigungssensor liefert, wie stark das Gerät in jede Richtung gekippt ist. Die Kugel rollt zur tieferen Seite, umso schneller, je schräger der PBC+ ist. Das Bild zeigt sie, nachdem das Gerät eine Sekunde nach rechts gekippt war.

// Eine Kugel rollt zur tieferen Seite
#include <Adafruit_ST7789.h>
#include <STK8BA58.h>

#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26
#define RADIUS 10
#define TEMPO 8                     // Pixel pro Bild bei 1 g Neigung
#define TAKT 33

Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);
GFXcanvas16 bild(240, 280);
STK8BA58 sensor;

float kx = 120;
float ky = 140;
unsigned long letztes_bild = 0;

void setup() {
    tft.init(240, 280);
    tft.setSPISpeed(62500000);
    pinMode(TFT_LICHT, OUTPUT);
    digitalWrite(TFT_LICHT, HIGH);
    sensor.begin(20, 21);
    sensor.setOrientation(STK8BA58::PICOBOY_COLOR_PLUS);
}

void loop() {
    if (millis() - letztes_bild >= TAKT) {
        letztes_bild = millis();
        float x, y, z;
        sensor.readAcceleration(x, y, z);

        // tiefere Seite = negativer Messwert, also abziehen
        kx = kx - x * TEMPO;
        ky = ky - y * TEMPO;
        kx = constrain(kx, 20 + RADIUS, 220 - RADIUS);
        ky = constrain(ky, 20 + RADIUS, 260 - RADIUS);

        bild.fillScreen(tft.color565(90, 60, 30));
        bild.drawRect(20, 20, 200, 240, ST77XX_WHITE);
        bild.fillCircle(kx, ky, RADIUS, ST77XX_WHITE);
        tft.drawRGBBitmap(0, 0, bild.getBuffer(), 240, 280);
    }
}

Ein Blick ins Buch

27 Kapitel in vier Teilen, dazu fünf Anhänge. Alle Sketches liegen dem Buch bei.

Teil I – Los geht’s

Mikrocontroller und Arduino, die Arduino IDE einrichten, der erste Sketch mit Display und Text, Fehlermeldungen lesen, der serielle Monitor mit Serial.printf, Eingaben und dem seriellen Plotter.

Teil II – Grundlagen

Variablen und Datentypen, Zeichnen und Farben mit Adafruit GFX und schönen Schriften, Schleifen und Zeit mit millis, Entscheidungen, Tasten und Joystick mit Entprellen, LEDs, RGB-LED und Töne, Funktionen, Arrays und Texte, Strukturen und eine erste eigene Klasse.

Teil III – Spiele bauen

Flimmerfreie Grafik mit GFXcanvas16 und gemessener Bildrate, Bilder und Sprites mit durchsichtiger Farbe, Kollisionen, der Beschleunigungssensor – und zum Schluss das ganze Spiel „Sternenjäger“: Eine Rakete sammelt Sterne und weicht Meteoren aus, gesteuert mit Joystick oder durch Kippen.

Teil IV – Hinter die Kulissen

Zeiger und Speicher, eigene Bibliotheken mit einem Blick in STK8BA58, PWM und ADC (Hintergrundlicht dimmen, Batteriespannung messen), I²C mit Wire und der Sensor ohne Bibliothek, SPI und das Display, Interrupts und der zweite Kern mit setup1/loop1, Daten dauerhaft speichern mit LittleFS und EEPROM, dein eigenes Projekt und Programmieren mit KI.

Anhänge

Die wichtigsten Befehle, Fehlermeldungen beim Kompilieren und Hochladen, Lösungen zu allen Kapiteln, die Hardware-Referenz mit der Pinbelegung und die Installation im Detail für Windows, macOS und Linux, auch mit arduino-cli.

Typische Fallen

Der Kern nimmt mit „Generic RP2350“ die Belegung des Raspberry Pi Pico 2 an. Einige dieser Standard-Pins sind auf dem PBC+ schon belegt. Das Buch warnt vor diesen Stellen:

Falle	Was tun?
Schwarzer Bildschirm. Ohne Hintergrundlicht bleibt das Display schwarz, obwohl alles richtig gezeichnet wird.	pinMode(TFT_LICHT, OUTPUT); digitalWrite(TFT_LICHT, HIGH);
Wire auf den falschen Pins. Von sich aus liegt I²C auf GP4/GP5 – GP4 ist Joystick hoch. Der Sensor sitzt an GP20/GP21.	Wire.setSDA(20); Wire.setSCL(21); vor Wire.begin(), oder einfach sensor.begin(20, 21)
Serial1 und Serial2. Sie liegen auf GP0/GP1 (Joystick Mitte und rechts) und GP8/GP9 (Display).	nicht benutzen; Serial geht über USB
LED_BUILTIN, A0 bis A2. GP25 ist keine der LEDs; A0 bis A2 sind Hintergrundlicht, Taste A und Taste B.	LED_ROT, LED_GELB, LED_GRUEN; nur A3 (Batterie) ist ein Messeingang
Immer dieselben Zufallszahlen. random() liefert ohne randomSeed bei jedem Start dieselbe Folge. Das oft empfohlene randomSeed(analogRead(A0)) hilft hier nicht: An A0 hängt das Hintergrundlicht, es rauscht nicht.	randomSeed(rp2040.hwrand32()); einmal in setup()
Langsames Display. Ohne Angabe läuft SPI real mit 25 MHz, ein ganzes Bild dauert etwa 43 ms.	tft.setSPISpeed(62500000); nach tft.init: real 37,5 MHz, etwa 29 ms
Falsche Flash-Größe. Mit der Voreinstellung „2MB (no FS)“ gibt es kein Dateisystem. Eine andere Größe verschiebt Dateisystem und EEPROM; gespeicherte Daten sind dann nicht mehr zu finden.	immer 16MB (Sketch: 8MB, FS: 8MB)
Tasten prellen. Ein Druck kann mehrfach zählen.	entprellen wie in Kapitel 9
Code für andere Arduinos. PORTB, DDRB oder _delay_ms aus Anleitungen im Netz gibt es auf dem RP2350 nicht.	pinMode und digitalWrite mit den Pins des PBC+

Noch zwei Kleinigkeiten: tone(LAUTSPRECHER, frequenz, dauer) wartet nicht, bis der Ton vorbei ist. Und der Stack hat nur 8 KB – große Arrays gehören deshalb nicht als lokale Variablen in eine Funktion.

Wenn es nicht klappt

Was passiert?	Was hilft?
„Raspberry Pi Pico/RP2040/RP2350“ fehlt in der Board-Verwaltung.	Boardverwalter-URL prüfen (ein Tippfehler genügt), IDE neu starten.
fatal error: Adafruit_ST7789.h: No such file or directory	Die Bibliothek fehlt. Bei STK8BA58.h entsprechend die ZIP-Bibliothek.
Windows: cannot open linker script file	Der Windows-Benutzername enthält Umlaute oder Akzente. Ein zweites Benutzerkonto mit einfachem Namen anlegen und darin arbeiten.
Hochladen meldet No drive to deploy.	Der PBC+ war nicht im Bootmodus. BOOT halten, RES tippen, Port UF2 Board wählen.
Unter Werkzeuge → Port steht nichts.	Anderes Kabel (mit Datenleitungen) oder anderen USB-Anschluss probieren. Unter Windows nicht die Store-Fassung der IDE.
Das Laufwerk erscheint nicht.	BOOT wirklich festhalten, während du RES tippst.

Downloads und Quellcode

• STK8BA58.zip – Arduino-Bibliothek für den Beschleunigungssensor (in der IDE über „.ZIP-Bibliothek hinzufügen“)
• picoboygb-arduino – ein kompletter Game-Boy-Emulator als Arduino-Sketch, zum Nachlesen
• Hardware & Pins – Pinbelegung und Bauteile auf einen Blick