Raspberry Pi Pico PIO und zwei Kerne: _thread, setup1, WS2812B

Der Raspberry Pi Pico PIO-Block und die zwei Kerne sind die beiden Merkmale, die dieses kleine Board von den meisten Mikrocontrollern seiner Preisklasse abheben. Im RP2040, dem Herz des Pico, stecken zwei getrennte Prozessorkerne und 8 PIO-State-Machines. Dank der Kerne kannst du auf der einen Seite Sensoren auslesen, während auf der anderen ein Display oder eine LED-Animation ohne Ruckeln weiterläuft. PIO dagegen sind winzige Timing-Maschinen, die unabhängig vom Prozessor arbeiten: Sie erzeugen das nanosekundengenaue Signal für WS2812B-LEDs, einen zusätzlichen UART oder ein Rechtecksignal, ohne die CPU zu belasten.

In dieser Anleitung startest du beide Kerne zuerst mit dem Modul _thread in MicroPython und dann mit setup1() und loop1() in der Arduino IDE. Danach lernst du, wie PIO funktioniert, wie viele State Machines es gibt und welche Befehle sie kennen, und schreibst zwei echte Programme: einen Rechteckgenerator, der Töne auf einem Buzzer spielt, und einen WS2812B-Regenbogen. Zum Schluss schauen wir uns an, was der Pico 2 (RP2350) ändert und wann du diese Funktionen wirklich brauchst. Wenn der Pico neu für dich ist, lies vorher Was ist der Raspberry Pi Pico? und Was ist MicroPython?.

Was sind die zwei Kerne und die PIO des Raspberry Pi Pico?

Der RP2040 besitzt zwei identische Cortex-M0+-Prozessoren namens Core 0 und Core 1. Beim Programmstart läuft nur Core 0; Core 1 schläft, bis du ihn startest. Beide Kerne teilen sich dieselben 264 KB RAM und dieselben Pins. Daten auszutauschen ist daher einfach, aber sie dürfen nicht gleichzeitig dieselbe Variable beschreiben. Dafür hat der Chip eine kleine Hardware-Warteschlange in beide Richtungen (FIFO, je 8 Wörter) und 32 Hardware-Sperren (Spinlocks). PIO ist eine völlig getrennte Welt: Jeder der zwei PIO-Blöcke hat 4 State Machines, einen gemeinsamen Programmspeicher für 32 Befehle und direkten Zugriff auf die Pins. Einmal gestartet, arbeitet eine State Machine ihr Programm Takt für Takt ab, auch wenn der Prozessor gerade etwas anderes erledigt.

Der zweite Kern in MicroPython: das Modul _thread

In MicroPython nutzt du Core 1 mit dem Aufruf _thread.start_new_thread(funktion, argumente). Auf dem Pico startet dieser Aufruf die Funktion auf dem zweiten Kern, während dein Hauptprogramm auf Core 0 weiterläuft. Es kann immer nur ein zusätzlicher Thread laufen, denn einen dritten Kern gibt es nicht. Im folgenden Beispiel liest Core 0 ein Potentiometer an GP26 und gibt den Wert aus, Core 1 lässt die Onboard-LED in dem Tempo blinken, das das Potentiometer vorgibt. Das sleep_ms() auf Core 1 bremst Core 0 überhaupt nicht; auf einem einzigen Kern bräuchtest du dafür einen Timer oder asyncio.

1# Pico - iki çekirdek (MicroPython _thread) / two cores (MicroPython _thread)
2import _thread
3import time
4from machine import Pin, ADC
5
6led = Pin("LED", Pin.OUT)          # Pico ve Pico W dahili LED / onboard LED on Pico and Pico W
7pot = ADC(26)                      # GP26 = ADC0, potansiyometre / potentiometer
8
9lock = _thread.allocate_lock()     # ortak veri kilidi / shared data lock
10blink_ms = 500                     # çekirdek 0 yazar, çekirdek 1 okur / core 0 writes, core 1 reads
11running = True                     # durdurma bayrağı / stop flag
12
13
14def core1_task():
15    # Çekirdek 1: LED'i kendi hızında yakıp söndürür / Core 1: blinks the LED at its own pace
16    while running:
17        with lock:
18            period = blink_ms
19        led.toggle()
20        time.sleep_ms(period)
21    led.off()
22
23
24_thread.start_new_thread(core1_task, ())   # ikinci çekirdekte başlat / start on the second core
25
26try:
27    while True:
28        # Çekirdek 0: sensörü okur ve hızı ayarlar / Core 0: reads the sensor and sets the speed
29        raw = pot.read_u16()                     # 0-65535
30        with lock:
31            blink_ms = 50 + raw * 950 // 65535   # 50-1000 ms
32        print("ham / raw:", raw, "ms:", blink_ms)
33        time.sleep_ms(200)
34except KeyboardInterrupt:
35    running = False                              # çekirdek 1'e dur de / tell core 1 to stop
36    time.sleep_ms(1100)

• Die mit allocate_lock() erzeugte Sperre sorgt dafür, dass innerhalb eines with lock:-Blocks nur ein Kern die gemeinsame Variable anfasst.
• Das Flag running sagt Core 1, dass er seine Schleife verlassen soll, wenn du das Programm mit Strg+C stoppst; sonst blinkt die LED weiter.
• Pin("LED") findet die Onboard-LED auf dem Pico und dem Pico W; beim Pico W hängt die LED am Funkchip, deshalb funktioniert Pin(25) dort nicht.
• Eine gute Aufteilung: lange Berechnungen, Display-Zeichnen oder genaues Timing auf Core 1, WLAN, Menüs und Bedienung auf Core 0.

Zwei Kerne in der Arduino IDE: setup1() und loop1()

Das meistgenutzte Pico-Paket für die Arduino IDE ist der Core Raspberry Pi Pico/RP2040/RP2350 von Earle Philhower (arduino-pico). Damit beide Kerne zu nutzen ist erstaunlich einfach: Die gewohnten Funktionen setup() und loop() laufen auf Core 0; fügst du dem Sketch setup1() und loop1() hinzu, startet Core 1 automatisch und führt diese beiden aus. Daten zwischen den Kernen schickst du mit dem Objekt rp2040.fifo. Das offizielle Paket "Arduino Mbed OS RP2040" kennt setup1() nicht, wähle im Boardverwalter also das richtige Paket.

1// Raspberry Pi Pico - iki çekirdek (Arduino-Pico çekirdeği) / two cores (Arduino-Pico core)
2const int POT_PIN = 26;        // GP26 = ADC0, potansiyometre / potentiometer
3
4// ---- Çekirdek 0 / Core 0 ----
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int raw = analogRead(POT_PIN);   // 0-1023 (varsayılan 10 bit / default 10-bit)
11  rp2040.fifo.push_nb(raw);        // FIFO doluysa bekleme, değeri atla / skip the value if the FIFO is full
12  Serial.print("pot: ");
13  Serial.println(raw);
14  delay(100);
15}
16
17// ---- Çekirdek 1 / Core 1 ----
18void setup1() {
19  pinMode(LED_BUILTIN, OUTPUT);
20}
21
22void loop1() {
23  static uint32_t periodMs = 500;
24  uint32_t value;
25  while (rp2040.fifo.pop_nb(&value)) {           // FIFO'yu boşalt, sonuncuyu kullan / drain the FIFO, keep the last one
26    periodMs = map(value, 0, 1023, 50, 1000);
27  }
28  digitalWrite(LED_BUILTIN, HIGH);
29  delay(periodMs);                               // yalnız çekirdek 1'i bekletir / only blocks core 1
30  digitalWrite(LED_BUILTIN, LOW);
31  delay(periodMs);
32}

Was ist PIO? So funktioniert programmierbare Ein-/Ausgabe

Bei den meisten Mikrocontrollern sind Kommunikations- und Signalblöcke wie UART, SPI, I2C und PWM fest im Chip verbaut; brauchst du ein Protokoll, das nicht auf der Liste steht, schaltet der Prozessor die Pins einzeln ein und aus (Bit-Banging). Das hält den Prozessor beschäftigt, und sobald ein Interrupt dazwischenkommt, stimmt das Timing nicht mehr. PIO (Programmable Input/Output) löst das grundsätzlich: Jede State Machine ist ein winziger Prozessor mit neun Befehlen, der nur für Pin-Arbeit gebaut ist. Jeder Befehl dauert genau einen Takt, und an sein Ende lässt sich eine Verzögerung von 0 bis 31 Takten hängen. So weißt du durch einfaches Takte-Zählen exakt, nach wie vielen Nanosekunden jede Flanke kommt. Das Tempo der State Machine stellst du ein, indem der Systemtakt durch einen Teiler zwischen 1 und 65536 geteilt wird.

In MicroPython sind PIO-Programme Python-Funktionen mit dem Dekorator @rp2.asm_pio; die Funktion wird nicht aufgerufen, sondern von MicroPython in Maschinencode übersetzt. Anschließend lädst du sie mit rp2.StateMachine(nr, programm, freq=..., set_base=...) in eine State Machine. Beim Pico gehören die Nummern 0-3 zu PIO0 und 4-7 zu PIO1. freq ist die Anzahl der Befehlstakte pro Sekunde und darf nicht unter 1/65536 des Systemtakts liegen; bei 125 MHz sind das etwa 1,9 kHz, bei 150 MHz etwa 2,3 kHz. Brauchst du ein langsameres Signal, nimm Verzögerungen oder Schleifen mit den Zählern X/Y.

Rechtecksignal mit PIO: dein erstes State-Machine-Programm

Im ersten Beispiel spielen wir auf einem passiven Buzzer an GP15 eine Tonleiter und lassen danach ein dauerhaftes 1-kHz-Rechtecksignal laufen. Das Programm besteht aus nur zwei Befehlen: Pin auf HIGH setzen und 9 Takte warten, Pin auf LOW setzen und 9 Takte warten. Weil jeder Befehl selbst 1 Takt dauert, umfasst eine Periode 20 Takte; du gibst der State Machine also einfach das 20-Fache der gewünschten Tonfrequenz. Schließe den Pluspol des Buzzers an GP15 und den Minuspol an GND an. Statt des Buzzers kannst du auch ein Oszilloskop oder eine LED mit 220-Ohm-Widerstand nehmen; den Widerstand bestimmst du mit dem LED-Vorwiderstandsrechner.

1# PIO ile kare dalga ve buzzer notaları / square wave and buzzer notes with PIO
2import time
3import rp2
4from machine import Pin
5
6
7@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
8def square():
9    wrap_target()
10    set(pins, 1)   [9]     # 1 + 9 = 10 döngü HIGH / 10 cycles HIGH
11    set(pins, 0)   [9]     # 1 + 9 = 10 döngü LOW / 10 cycles LOW
12    wrap()                 # başa dön, işlemci karışmaz / loop back, no CPU involved
13
14
15def tone(freq_hz):
16    # Bir periyot 20 döngü: durum makinesi frekansı = 20 x ton
17    # One period is 20 cycles: state machine frequency = 20 x tone
18    sm = rp2.StateMachine(0, square, freq=freq_hz * 20, set_base=Pin(15))
19    sm.active(1)
20    return sm
21
22
23notes = [262, 294, 330, 349, 392, 440, 494, 523]   # Do-Re-Mi ... / C4 ... C5
24for n in notes:
25    sm = tone(n)
26    time.sleep_ms(300)        # işlemci boşta, ses PIO'dan / CPU is idle, PIO makes the sound
27    sm.active(0)
28
29sm = tone(1000)               # 1 kHz sürekli kare dalga / continuous 1 kHz square wave
30print("GP15: 1 kHz kare dalga / square wave")

Die Formel ist einfach: Tonfrequenz = Frequenz der State Machine / Anzahl der Takte. Für 1000 Hz läuft die Maschine mit 20.000 Hz, also deutlich über der Untergrenze. Entfernst du die Verzögerungen und lässt nur die zwei set()-Befehle stehen, schrumpft eine Periode auf 2 Takte; bei 125 MHz erhältst du dann ein 62,5-MHz-Rechtecksignal am Pin. Vergiss nicht, dass Hardware-PWM dasselbe kann: Für einen einfachen Ton oder die LED-Helligkeit reicht PWM. Der Unterschied bei PIO ist, dass du die Form des Signals komplett selbst bestimmst; mit wenigen Zeilen erzeugst du Impulse variabler Breite, eine genaue Anzahl von Impulsen oder Ausgänge, die auf einen Eingang reagieren.

WS2812B-LEDs (NeoPixel) mit PIO ansteuern

WS2812B-LEDs erwarten pro Bit einen Impuls von etwa 1,25 Mikrosekunden; ob ein Bit 1 oder 0 ist, ergibt sich daraus, wie lange der Impuls HIGH bleibt. Ein Lehrbuchfall für PIO. Das folgende Programm basiert auf dem offiziellen MicroPython-Beispiel von Raspberry Pi: Die State Machine läuft mit 8 MHz, jedes Bit dauert genau 10 Takte, also werden 800.000 Bit pro Sekunde gesendet. Dank autopull holt die Maschine alle 24 Bit eine neue Farbe aus der FIFO; der Prozessor legt das Array nur mit sm.put() in die FIFO. Passe die LED-Anzahl an deinen Streifen an; wie der WS2812B funktioniert und welche Farbreihenfolge er nutzt, steht im WS2812B-NeoPixel-Ratgeber.

1# PIO ile WS2812B (NeoPixel) gökkuşağı / WS2812B (NeoPixel) rainbow with PIO
2import array
3import time
4import rp2
5from machine import Pin
6
7NUM_LEDS = 24          # halka ya da şeritteki LED sayısı / LEDs in the ring or strip
8LED_PIN = 16           # DIN bağlantısı / DIN connection
9BRIGHTNESS = 0.2       # 0.0-1.0, akımı düşük tutar / keeps current low
10
11
12@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT,
13             autopull=True, pull_thresh=24)
14def ws2812():
15    T1 = 2
16    T2 = 5
17    T3 = 3
18    wrap_target()
19    label("bitloop")
20    out(x, 1)               .side(0)    [T3 - 1]   # 1 biti al, hat LOW / take 1 bit, line LOW
21    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]   # hat HIGH / line HIGH
22    jmp("bitloop")          .side(1)    [T2 - 1]   # bit 1: uzun HIGH / long HIGH
23    label("do_zero")
24    nop()                   .side(0)    [T2 - 1]   # bit 0: kısa HIGH / short HIGH
25    wrap()
26
27
28# Bit başına 10 döngü x 8 MHz = 800 kHz / 10 cycles per bit x 8 MHz = 800 kHz
29sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(LED_PIN))
30sm.active(1)
31
32pixels = array.array("I", [0] * NUM_LEDS)
33
34
35def set_pixel(i, r, g, b):
36    r = int(r * BRIGHTNESS)
37    g = int(g * BRIGHTNESS)
38    b = int(b * BRIGHTNESS)
39    pixels[i] = (g << 16) | (r << 8) | b    # WS2812B sırası GRB / byte order is GRB
40
41
42def show():
43    sm.put(pixels, 8)      # 24 biti sola hizala / left-align the 24 bits
44
45
46def wheel(pos):
47    # 0-255 arası değeri renge çevir / turn 0-255 into a colour
48    pos %= 255
49    if pos < 85:
50        return 255 - pos * 3, pos * 3, 0
51    if pos < 170:
52        pos -= 85
53        return 0, 255 - pos * 3, pos * 3
54    pos -= 170
55    return pos * 3, 0, 255 - pos * 3
56
57
58step = 0
59while True:
60    for i in range(NUM_LEDS):
61        set_pixel(i, *wheel(i * 255 // NUM_LEDS + step))
62    show()
63    step = (step + 3) % 255
64    time.sleep_ms(30)      # kare arası bekleme, aynı zamanda reset / frame gap, also the reset time

Gehen wir das Programm Zeile für Zeile durch. out(x, 1) holt ein Bit aus dem OSR ins Register X, während Side-Set die Leitung LOW hält (3 Takte). Dann geht die Leitung auf HIGH und X wird geprüft (2 Takte). Ist das Bit 1, bleibt die Leitung 5 weitere Takte HIGH; ist es 0, wird sie auf LOW gezogen und die Maschine wartet 5 Takte. Beide Wege ergeben 10 Takte, also 1,25 µs. pull_thresh=24 sagt der Maschine, dass sie von jedem Wort nur 24 Bit verwendet; deshalb wird die Farbe auf der Python-Seite nach links geschoben (sm.put(pixels, 8)). Die Farbreihenfolge ist GRB, nicht RGB; sind Rot und Grün vertauscht, liegt es daran. Da 24 LEDs bei vollem Weiß bis zu 1,4 A ziehen können, ist die Helligkeit im Beispiel auf 20 % begrenzt.

Was ändert sich mit dem Pico 2 (RP2350)?

Der Raspberry Pi Pico 2 ist die neue Generation mit gleicher Größe und gleicher Pinbelegung, aber mit einem RP2350 im Inneren. Er hat weiterhin zwei Kerne, doch diesmal wählst du beim Start zwischen zwei Arm-Cortex-M33-Kernen und zwei Hazard3-RISC-V-Kernen. Der gesamte Code dieses Artikels läuft unverändert auf dem Pico 2: _thread ist in MicroPython gleich, im Arduino-Pico-Core heißen setup1()/loop1() und rp2040.fifo genauso. Bei PIO kommt ein dritter Block hinzu, es gibt also 12 State Machines (in MicroPython 0-11) sowie einige neue Befehlsoptionen.

In der Praxis ist der größte spürbare Unterschied des Pico 2 die Geschwindigkeit: Dank Hardware-FPU laufen gleitkommalastige Aufgaben (Filter, Sensorfusion, Audioverarbeitung) um ein Mehrfaches schneller, und der doppelte RAM bietet Platz für große Display-Puffer. Achte nur darauf, die passende UF2-Datei zu flashen; die Datei für den Pico läuft nicht auf dem Pico 2. Frühe RP2350-Versionen hatten ein bekanntes Hardwareproblem (E9) bei Eingängen mit internem Pull-down, das in der Revision A4 behoben wurde; ein externer Widerstand beim Anschließen von Tastern ist in jedem Fall die sichere Wahl.

Wann brauchst du zwei Kerne und wann PIO?

Kurz gesagt: Denk an den zweiten Kern, wenn sich Aufgaben in der Software in die Quere kommen, und an PIO, wenn die Pins Genauigkeit unter einer Mikrosekunde brauchen. Die meisten Hobbyprojekte kommen ohne beides aus; aber wenn deine WS2812B-Animation eines Tages während einer WLAN-Anfrage ruckelt oder dem Board die UARTs ausgehen, wartet die Lösung schon im Pico.

Projektideen mit Pico PIO und zwei Kernen

• Musikgesteuerter LED-Ring: Core 1 verarbeitet Mikrofonwerte, PIO steuert den WS2812B-Ring und Core 0 fragt die Taster ab.
• Achtkanaliger Pulsgenerator: Jede State Machine erzeugt ein Rechtecksignal mit eigener Frequenz für Schrittmotortreiber oder Prüfaufbauten.
• Lückenloser Datenlogger: Core 1 liest alle 10 ms den ADC, Core 0 sendet die Daten per WLAN; auch bei langsamem Netz geht kein Messwert verloren.
• Zusätzliche serielle Schnittstellen: Mit PIO einen dritten und vierten UART öffnen und GPS und Bluetooth-Modul gleichzeitig anschließen.
• Drehencoder-Zähler: PIO zählt Encoder-Impulse ohne einen einzigen zu verpassen; der Prozessor liest nur das Ergebnis.
• Atmendes Nachtlicht: Weiche PWM-Übergänge auf Core 1, den Lichtsensor auf Core 0.

Häufige Fehler und Lösungen

Zwei Kerne und PIO machen aus dem Pico mehr als einen LED-Blinker, nämlich ein ernstzunehmendes Embedded-System; doch alles baut auf derselben Grundlage auf: Pins, Timing und LEDs gut zu kennen. In der BlueGrays-App findest du Raspberry-Pi-Pico-Projekte wie LED-Blinken, Lauflicht, Knight-Rider-Effekt, eine tastergesteuerte State Machine und einen PWM-Atemeffekt, jeweils mit Schaltplan und MicroPython-Code Schritt für Schritt, und kannst die Techniken aus diesem Artikel darauf aufbauen.