Gidsen · 11 min leestijd

Raspberry Pi Pico PIO en dual-core: _thread, setup1, WS2812B

Raspberry Pi Pico PIO-gids: state machines, een blokgolf en een WS2812B-voorbeeld, beide kernen met MicroPython _thread en Arduino setup1/loop1, wat de Pico 2 verandert.

Het Raspberry Pi Pico PIO-blok en de twee kernen zijn de twee functies waarmee dit kleine board zich onderscheidt van de meeste microcontrollers in zijn prijsklasse. De RP2040-chip in het hart van de Pico heeft twee aparte processorkernen en 8 PIO state machines. Dankzij de kernen kun je aan de ene kant sensoren uitlezen terwijl aan de andere kant een display of ledanimatie soepel blijft draaien. PIO is daarentegen een verzameling kleine timingmotoren die onafhankelijk van de processor werken: ze maken het nanoseconde-nauwkeurige signaal dat WS2812B-leds nodig hebben, een extra UART of een blokgolf, zonder de CPU te belasten.

In deze gids laat je eerst beide kernen draaien met de _thread-module in MicroPython, daarna met setup1() en loop1() in de Arduino IDE. Vervolgens leer je hoe PIO werkt, hoeveel state machines er zijn en welke instructies ze begrijpen, en schrijf je twee echte programma's: een blokgolfgenerator die noten afspeelt op een buzzer en een WS2812B-regenboog. In de laatste delen kijken we naar wat de Pico 2 (RP2350) verandert en wanneer je deze functies echt nodig hebt. Ben je nieuw met de Pico, lees dan eerst Wat is de Raspberry Pi Pico? en Wat is MicroPython?.

Raspberry Pi Pico-ontwikkelboard
Raspberry Pi Pico: de RP2040-chip in het midden bevat twee Cortex-M0+-kernen en twee PIO-blokken. Alle 26 GPIO-pinnen kunnen met PIO worden verbonden.

Wat zijn de twee kernen en PIO van de Raspberry Pi Pico?

De RP2040 heeft twee identieke Cortex-M0+-processors, core 0 en core 1 genoemd. Als je programma start, draait alleen core 0; core 1 slaapt tot jij hem start. Beide kernen delen dezelfde 264 KB RAM en dezelfde pinnen, dus gegevens uitwisselen is eenvoudig, maar ze mogen niet op hetzelfde moment dezelfde variabele schrijven. Daarvoor heeft de chip een kleine hardwarewachtrij in twee richtingen (FIFO, 8 woorden per richting) en 32 hardwarelocks (spinlocks). PIO is een heel aparte wereld: elk van de twee PIO-blokken heeft 4 state machines, een gedeeld programmageheugen van 32 instructies en directe toegang tot de pinnen. Zodra een state machine is gestart, voert hij zijn eigen programma cyclus voor cyclus uit, ook als de processor met iets anders bezig is.

OnderdeelRP2040 (Pico, Pico W)Waarvoor dient het?
Processorkern2 x Cortex-M0+, 133 MHz (tot 200 MHz in actuele documenten)Twee aparte programma's echt tegelijk laten draaien
FIFO tussen de kernen8 x 32 bit per richtingGetallen en commando's tussen de kernen versturen
Hardwarelock (spinlock)32Om de beurt gedeelde gegevens gebruiken
PIO-blok2 (PIO0, PIO1)Timingkritisch pinwerk bij de processor weghalen
State machine4 per blok, 8 in totaalElk draait zijn eigen PIO-programma
PIO-programmageheugen32 instructies per blokGedeeld door de 4 state machines in dat blok
PIO FIFOTX 4 + RX 4 woorden per machine (8 als ze zijn samengevoegd)Gegevens tussen de processor en een state machine

De tweede kern in MicroPython: de _thread-module

In MicroPython gebruik je core 1 met de aanroep _thread.start_new_thread(function, args). Op de Pico start dit de functie op de tweede kern, terwijl je hoofdprogramma op core 0 doorgaat. Er kan maar één extra thread tegelijk draaien, want er is geen derde kern. In het voorbeeld hieronder leest core 0 een potmeter op GP26 uit en print het resultaat, terwijl core 1 de ingebouwde led laat knipperen met de snelheid die de potmeter bepaalt. De sleep_ms()-wachttijd op core 1 heeft geen enkele invloed op core 0; op één kern had je daar een timer of asyncio voor nodig.

MicroPython
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)
  • De lock die je maakt met allocate_lock() zorgt ervoor dat binnen een with lock:-blok maar één kern de gedeelde variabele aanraakt.
  • De vlag running vertelt core 1 dat hij zijn lus moet verlaten als je het programma stopt met Ctrl+C; anders blijft de led knipperen.
  • Met Pin("LED") vind je de ingebouwde led op zowel de Pico als de Pico W; op de Pico W zit de led aan de draadloze chip, dus Pin(25) werkt niet.
  • Een goede verdeling is om lange berekeningen, het tekenen op het display of nauwkeurige timing op core 1 te houden, en Wi-Fi, menu's en gebruikersinteractie op core 0.
De knop Stop in Thonny onderbreekt alleen het programma op core 0. Als er een eindeloze lus op core 1 blijft draaien, lijkt het board bezig en kan er geen nieuwe code worden geüpload. Haal in dat geval de USB-kabel eruit en steek hem er weer in, of reset het board door de RUN-pin met GND te verbinden. Gebruik altijd een stopvlag zoals in het voorbeeld en vermijd zware geheugenallocatie (grote lijsten, lange string-joins) in de extra thread; multicore-ondersteuning in MicroPython wordt nog steeds als experimenteel beschouwd.

Twee kernen in de Arduino IDE: setup1() en loop1()

Het meest gebruikte Pico-pakket voor de Arduino IDE is de Raspberry Pi Pico/RP2040/RP2350-core van Earle Philhower (arduino-pico). Met dit pakket beide kernen gebruiken is verrassend eenvoudig: de bekende setup() en loop() draaien op core 0; voeg je setup1() en loop1() toe aan de sketch, dan start core 1 automatisch en voert die twee functies uit. Gegevens tussen de kernen verstuur je met het object rp2040.fifo. Het officiële pakket "Arduino Mbed OS RP2040" van Arduino ondersteunt setup1() niet, dus kies in de Boards Manager het juiste pakket.

C++ (Arduino IDE)
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}
FunctieWat het doet
rp2040.fifo.push(x)Stuurt een 32-bitwaarde naar de andere kern; wacht op ruimte als de wachtrij vol is
rp2040.fifo.push_nb(x)Probeert te versturen zonder te wachten; geeft false terug als de wachtrij vol is
rp2040.fifo.pop()Leest een waarde van de andere kern; wacht als de wachtrij leeg is
rp2040.fifo.pop_nb(&x)Schrijft een waarde naar x en geeft true terug als er een is, anders meteen false
rp2040.fifo.available()Geeft terug hoeveel waarden er klaarstaan om te worden gelezen
rp2040.idleOtherCore() / resumeOtherCore()Pauzeert de andere kern kort en laat hem daarna weer doorgaan (bijvoorbeeld tijdens schrijven naar flash)
Gebruik één stuk hardware, zoals de seriële poort, een display of een SPI-bus, nooit tegelijk vanaf beide kernen. Geef elk randapparaat aan één kern, zoals in het voorbeeld, en laat de andere kern er getallen naartoe sturen via de FIFO. Zo voorkom je door elkaar lopende tekst en kapotte schermen zonder locks.

Wat is PIO? Zo werkt programmeerbare I/O

Op de meeste microcontrollers zijn communicatie- en signaalblokken zoals UART, SPI, I2C en PWM vast in silicium gegoten; heb je een protocol nodig dat niet op de lijst staat, dan regelt de processor dat door pinnen één voor één aan en uit te zetten (bit-banging). Dat houdt de processor bezig en de timing raakt verstoord zodra er een interrupt tussenkomt. PIO (Programmable Input/Output) lost dit bij de wortel op: elke state machine is een kleine processor met negen instructies die alleen voor pinwerk zijn ontworpen. Elke instructie duurt precies één klokcyclus, en aan het einde kun je een vertraging van 0 tot 31 cycli toevoegen. Zo weet je precies hoeveel nanoseconden elke flank van een signaal duurt, gewoon door cycli te tellen. De snelheid van de state machine stel je in door de systeemklok te delen met een deler tussen 1 en 65536.

InstructieDoel
set(pins, v)Schrijft een constante 0-31 naar pinnen of naar de registers X/Y
out(dest, n)Verplaatst n bits van het uitgangsschuifregister (OSR) naar pinnen of X/Y
in_(src, n)Schuift n bits van pinnen of registers in het ingangsschuifregister (ISR)
pull() / push()Haalt een woord uit de TX FIFO naar de OSR, duwt het ISR-woord in de RX FIFO
jmp(cond, label)Springt bij een voorwaarde (X nul, pin hoog, X-- enzovoort)
wait(polarity, src, idx)Wacht tot een pin of IRQ-vlag het gewenste niveau bereikt
mov(dest, src)Kopieert tussen registers, eventueel met omgekeerde bits
irq(idx)Stuurt een interruptvlag naar de CPU of een andere state machine
nop() en .side(v)Lege instructie; side-set verandert een pin in dezelfde cyclus als een willekeurige instructie

In MicroPython zijn PIO-programma's Python-functies die je schrijft met de decorator @rp2.asm_pio; de functie wordt niet aangeroepen, MicroPython assembleert hem tot machinecode. Daarna laad je hem in een state machine met rp2.StateMachine(id, program, freq=..., set_base=...). Op de Pico horen machinenummers 0-3 bij PIO0 en 4-7 bij PIO1. De waarde freq is het aantal instructiecycli per seconde en mag niet lager zijn dan 1/65536 van de systeemklok; bij 125 MHz is dat ongeveer 1,9 kHz, bij 150 MHz ongeveer 2,3 kHz. Heb je een langzamer signaal nodig, gebruik dan vertragingen of lussen met de X/Y-tellers.

Een blokgolf met PIO: je eerste state machine-programma

In het eerste voorbeeld spelen we een toonladder af op een passieve buzzer die op GP15 is aangesloten en laten we daarna een continue blokgolf van 1 kHz draaien. Het programma heeft maar twee instructies: zet de pin HIGH en wacht 9 cycli, zet de pin LOW en wacht 9 cycli. Omdat elke instructie zelf 1 cyclus duurt, is één periode 20 cycli, dus je geeft de state machine gewoon 20 keer de gewenste toonfrequentie. Sluit de plusdraad van de buzzer aan op GP15 en de minpool op GND. In plaats van een buzzer kun je ook een oscilloscoop gebruiken of een led met een weerstand van 220 ohm; kies de weerstand met de ledweerstandcalculator.

MicroPython
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")

De formule is hier eenvoudig: toonfrequentie = frequentie van de state machine / aantal cycli. Voor 1000 Hz draait de machine op 20.000 Hz, ruim boven de ondergrens. Haal je de vertragingen weg en houd je alleen de twee set()-instructies, dan daalt één periode naar 2 cycli; met de machine op 125 MHz krijg je dan een blokgolf van 62,5 MHz op de pin. Bedenk dat hardware-PWM hetzelfde kan: voor een eenvoudige toon of ledhelderheid is PWM genoeg. Wat PIO anders maakt, is dat jij de exacte vorm van het signaal bepaalt; met een paar regels maak je pulsen met variabele breedte, een exact aantal pulsen of uitgangen die op een ingang reageren.

WS2812B-leds (NeoPixel) aansturen met PIO

WS2812B RGB-ring met 24 leds
Een WS2812B-ring met 24 leds: elke led heeft zijn eigen controller en krijgt zijn kleur als 24 bits over één datalijn.

WS2812B-leds verwachten per bit een puls van ongeveer 1,25 microseconde; of een bit 1 of 0 is, hangt af van hoe lang de puls HIGH blijft. Dat is een schoolvoorbeeld voor PIO. Het onderstaande programma is gebaseerd op het officiële MicroPython-voorbeeld van Raspberry Pi: de state machine draait op 8 MHz en elke bit duurt precies 10 cycli, dus er worden 800.000 bits per seconde verstuurd. Dankzij autopull haalt de machine elke 24 bits een nieuwe kleur uit de FIFO; de processor zet de array met sm.put() gewoon in de FIFO. Pas het aantal leds aan op jouw strip; hoe de WS2812B werkt en wat de kleurvolgorde is, lees je in de WS2812B NeoPixel-gids.

WS2812B-pinPico-pinOpmerking
DIN (data in)GP16 (fysieke pin 21)Een serieweerstand van 330 ohm beschermt het signaal
5V / VCCVBUS (pin 40)5 V via USB; gebruik een externe 5 V-voeding voor veel leds
GNDGND (bijv. pin 38)De GND van de externe voeding moet hier ook op worden aangesloten
MicroPython
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

Laten we het programma regel voor regel volgen. out(x, 1) haalt één bit uit de OSR naar het X-register terwijl side-set de lijn LOW houdt (3 cycli). Daarna gaat de lijn HIGH en wordt X gecontroleerd (2 cycli). Is de bit 1, dan blijft de lijn nog 5 cycli HIGH; is hij 0, dan wordt de lijn LOW getrokken en wacht de machine 5 cycli. Beide paden tellen op tot 10 cycli, dat is 1,25 µs. pull_thresh=24 zegt tegen de machine dat hij van elk woord maar 24 bits gebruikt, en daarom wordt de kleur aan de Python-kant naar links geschoven (sm.put(pixels, 8)). De kleurvolgorde is GRB, niet RGB; als rood en groen verwisseld zijn, is dat de reden. Omdat 24 leds op volledig wit tot 1,4 A kunnen trekken, is de helderheid in het voorbeeld beperkt tot 20%.

Wil je alleen leds laten branden, dan doet de ingebouwde neopixel-module van MicroPython het ook: np = neopixel.NeoPixel(Pin(16), 24), np[0] = (255, 0, 0), np.write(). Het voordeel van de PIO-versie schrijven is dat de processor tijdens het versturen vrij blijft en dat je dezelfde techniek kunt aanpassen voor andere protocollen.

Wat is er veranderd met de Pico 2 (RP2350)?

De Raspberry Pi Pico 2 is de nieuwe generatie met hetzelfde formaat en dezelfde pinout, maar met een RP2350-chip erin. Er zijn nog steeds twee kernen, maar nu kies je bij het opstarten tussen twee Arm Cortex-M33-kernen of twee Hazard3 RISC-V-kernen. Alle code in dit artikel draait ongewijzigd op de Pico 2: _thread is hetzelfde in MicroPython, en in de Arduino-Pico-core houden setup1()/loop1() en rp2040.fifo dezelfde namen. Aan de PIO-kant is een derde blok toegevoegd, dus er zijn 12 state machines (0-11 in MicroPython), plus enkele nieuwe instructieopties.

KenmerkPico (RP2040)Pico 2 (RP2350)
Kernen2 x Cortex-M0+2 x Cortex-M33 of 2 x Hazard3 RISC-V
Kloksnelheid133 MHz150 MHz
RAM264 KB520 KB
Ingebouwd flashgeheugen2 MB4 MB
PIO2 blokken, 8 state machines3 blokken, 12 state machines
KommagetallenIn software (snelle ROM-routines)Hardware-FPU (enkele precisie) + coprocessor voor dubbele precisie
BeveiligingGeenTrustZone, secure boot, 8 KB OTP
MicroPython-bestandRPI_PICO (.uf2)RPI_PICO2 (.uf2)

In de praktijk is het meest opvallende verschil van de Pico 2 de snelheid: dankzij de hardware-FPU draait werk met veel kommagetallen (filters, sensorfusie, audioverwerking) meerdere keren sneller, en twee keer zoveel RAM geeft ruimte voor grote displaybuffers. Let er alleen op dat je het juiste UF2-bestand voor het board flasht; het Pico-bestand draait niet op de Pico 2. Vroege RP2350-versies hadden een bekend hardwareprobleem (E9) met ingangen die de interne pull-down gebruiken, dat in revisie A4 is opgelost; een externe weerstand gebruiken bij het bedraden van knoppen is hoe dan ook de veilige keuze.

Wanneer heb je twee kernen nodig en wanneer PIO?

Wat je nodig hebtBeste keuzeWaarom?
Ledhelderheid, servo, eenvoudige toonHardware-PWMKant-en-klaar blok, één regel code
Een paar sensoren + display + knopEén kern, millis() of asyncioGeen extra complexiteit nodig
Vloeiende animatie tijdens lange berekeningenTwee kernenDe berekening op core 1 laat het display niet vastlopen
Continu meten naast Wi-FiTwee kernenNetwerkvertragingen verstoren het meetinterval niet
WS2812B, extra UART, IR-zender, encoderPIONanoseconde-nauwkeurigheid, CPU blijft vrij
VGA/DVI-video, I2S-audio, zeer snelle signalenPIO + DMADatasnelheden waar de CPU niet bij zou kunnen

Kortom: denk aan de tweede kern als taken in software met elkaar botsen, en aan PIO als de pinnen nauwkeurigheid onder de microseconde nodig hebben. De meeste hobbyprojecten hebben geen van beide nodig; maar als je WS2812B-animatie op een dag gaat haperen tijdens een Wi-Fi-verzoek, of het board geen UART's meer heeft, staat de oplossing al klaar in de Pico.

Projectideeën met Pico PIO en twee kernen

  • Muziekgevoelige ledring: core 1 verwerkt microfoonsamples, PIO stuurt de WS2812B-ring aan en core 0 luistert naar de knoppen.
  • Pulsgenerator met acht kanalen: elke state machine maakt een blokgolf met een andere frequentie om stappenmotordrivers of testopstellingen aan te sturen.
  • Datalogger zonder gaten: core 1 leest elke 10 ms de ADC uit terwijl core 0 de gegevens via Wi-Fi verstuurt; een traag netwerk kost je nooit een meting.
  • Extra seriële poorten: open met PIO een derde en vierde UART en sluit tegelijk een gps- en een Bluetooth-module aan.
  • Teller voor draaiencoder: PIO telt encoderpulsen zonder er één te missen; de processor leest alleen het resultaat.
  • Ademend nachtlampje: geef de vloeiende PWM-fades aan core 1 en de lichtsensor aan core 0.

Veelgemaakte fouten en hoe je ze oplost

VerschijnselOorzaakOplossing
Board reageert niet na het stoppenDe lus op core 1 draait nogGebruik een stopvlag; haal zo nodig de USB-kabel eruit en steek hem er weer in
start_new_thread faalt de tweede keerDe Pico staat maar één extra thread toeStart geen nieuwe voordat de vorige is afgelopen
Variabelen krijgen soms onzinwaardenBeide kernen schrijven gedeelde gegevens zonder lockGebruik allocate_lock() of de FIFO
StateMachine geeft ValueErrorfreq ligt onder systeemklok / 65536Verhoog de frequentie en vertraag met delays
PIOASMError: delay too largeSide-set-bits hebben het delay-veld kleiner gemaaktSplits de vertraging of voeg een nop() toe
Rood en groen verwisseld op de WS2812BDe kleurvolgorde is GRBGebruik het formaat (g << 16) | (r << 8) | b
setup1() wordt nooit uitgevoerdHet pakket Arduino Mbed RP2040 is geselecteerdInstalleer het pakket Raspberry Pi Pico/RP2040 van Earle Philhower
Noteer bij het schrijven van een PIO-programma het aantal cycli van elke instructie en controleer of het totaal overeenkomt met de gewenste tijd. Heb je een oscilloscoop of een goedkope logic analyzer, prima; zo niet, verlaag dan tijdelijk de frequentie van de state machine naar 2-3 kHz en bekijk de pin met een led, zodat je fouten met je eigen ogen ziet.

Twee kernen en PIO maken van de Pico een serieus embedded systeem in plaats van een simpele ledknipperaar, maar ze bouwen allemaal op dezelfde basis: je pinnen, je timing en je leds goed kennen. In de BlueGrays-app vind je Raspberry Pi Pico-projecten zoals een knipperende led, een looplicht, een Knight Rider-scanner, een state machine met knoppen en een PWM-ademeffect, elk met schakelschema en MicroPython-code, stap voor stap, klaar om de technieken uit dit artikel aan toe te voegen.

Veelgestelde vragen

Wat is PIO op de Raspberry Pi Pico?

PIO (programmable I/O) is een verzameling kleine state machines in de RP2040- en RP2350-chips die onafhankelijk van de processor draaien. Elk voert een programma uit dat in een eenvoudige taal van negen instructies is geschreven, met cyclusnauwkeurige timing. Het regelt timingkritische taken zoals WS2812B-leds, extra UART's, IR-verzending of het uitlezen van encoders zonder de CPU bezig te houden.

Hoeveel kernen heeft de Raspberry Pi Pico?

De RP2040-chip op de Pico en Pico W heeft twee Cortex-M0+-kernen. De RP2350 op de Pico 2 heeft ook twee kernen, en bij het opstarten kun je kiezen tussen Cortex-M33- en Hazard3 RISC-V-kernen. Als je programma start, draait alleen core 0; core 1 start je zelf.

Hoeveel PIO state machines heeft de Pico?

De RP2040 heeft twee PIO-blokken met elk 4 state machines, dus 8 state machines in totaal. Het programmageheugen van 32 instructies van elk blok wordt gedeeld door de machines in dat blok. De RP2350 op de Pico 2 heeft drie PIO-blokken, dus 12 state machines.

Kan MicroPython beide kernen van de Pico gebruiken?

Ja. Op de Pico draait een functie die met _thread.start_new_thread() is gestart op de tweede kern. Er kan maar één extra thread tegelijk open zijn, en gedeelde gegevens beveilig je met een lock uit _thread.allocate_lock(). Multicore-ondersteuning is in MicroPython nog experimenteel, dus vermijd zwaar geheugenwerk in de extra thread.

Hoe gebruik ik de tweede kern van de Pico in de Arduino IDE?

Voeg na het installeren van het pakket Raspberry Pi Pico/RP2040/RP2350 van Earle Philhower gewoon de functies setup1() en loop1() toe aan je sketch; core 1 voert ze automatisch uit. 32-bitwaarden geef je door tussen de kernen met rp2040.fifo.push() en rp2040.fifo.pop(). Het op Mbed gebaseerde RP2040-pakket van Arduino heeft deze functie niet.

Moet ik PIO gebruiken voor WS2812B-leds?

Nee. De ingebouwde neopixel-module van MicroPython en de Adafruit NeoPixel-bibliotheek in Arduino werken allebei prima op de Pico. Het voordeel van zelf schrijven met PIO is dat de processor tijdens het versturen vrij blijft en dat je dezelfde techniek kunt toepassen op andere timingkritische protocollen.

Alle projecten bekijken
Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
PI-1Beginner

Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)

Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

5.0(1)
10
Raspberry Pi Pico: een externe led aansturen (breadboard)
PI-2Beginner

Raspberry Pi Pico: een externe led aansturen (breadboard)

De volgende stap na de ingebouwde led van de Pico: sluit een externe led aan op een breadboard en bestuur hem via pin GP14. Je leert hoe je elke GPIO-pin van de Pico als uitgang gebruikt, de polariteit van de led (lang pootje = anode/+, kort pootje = kathode/–) en waarom een stroombeperkende weerstand (220Ω) een must is. Zonder weerstand loopt er te veel stroom door de led en kan hij doorbranden.

4.5(2)
7
Raspberry Pi Pico-stoplicht (3 leds na elkaar)
PI-4Beginner

Raspberry Pi Pico-stoplicht (3 leds na elkaar)

We bouwen de logica van een echt stoplicht na met een rode, gele en groene led, het eerste Pico-project met 3 leds! Groen zegt 4 seconden "rijden", geel 1,5 seconde "maak je klaar", rood 3 seconden "stop" en rood+geel 1 seconde "optrekken" (het Europese stoplichtpatroon). Je leert functies definiëren (def all_off()), toestandsmachinelogica en het synchroniseren van meerdere GPIO's.

4.0(1)
12
Raspberry Pi Pico-looplicht (6 leds)
PI-7Beginner

Raspberry Pi Pico-looplicht (6 leds)

De klassieke "looplicht"-animatie met de Pico, versie met 6 leds! Zes leds gaan na elkaar aan van links naar rechts, alsof het licht langs de rij loopt. Je leert Python-lijsten (LED_PINS = [14, 13, 12, 11, 10, 9]), list comprehensions, pins aansturen met een for-lus en enumerate(). De zes leds komen op pin GP9-GP14, elk met een 220Ω-weerstand als stroombegrenzer.

5.0(1)
9
Raspberry Pi Pico Knight Rider-ledscanner (6 leds heen en weer)
PI-8Beginner

Raspberry Pi Pico Knight Rider-ledscanner (6 leds heen en weer)

Het klassieke "Knight Rider"-ledscannereffect met de Pico! 6 leds lopen van links naar rechts en dan terug, eindeloos, zoals de voorgrille van KITT uit de iconische tv-serie uit de jaren 80. Een upgrade van het looplichtproject: dezelfde schakeling met 6 leds (GP9-GP14), ander codepatroon. Je leert reversed() om een lijst om te draaien, twee for-lussen voor het heen-en-weer-patroon en meerdere animaties op dezelfde schakeling.

5.0(1)
14
Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)
PI-12Gemiddeld

Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)

4 stoplichtstanden met 1 knop! Elke druk schakelt de stand om: normale cyclus (rood → geel → groen), alleen rood (stop), knipperend geel (waarschuwing/nachtstand) en uit (onderhoud). Je leert de state machine (de variabele mode bepaalt welk gedrag draait) en het doorlopen van de standen met (mode + 1) % 4.

5.0(1)
16
Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
PI-13Gemiddeld
Premium

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling

Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

12
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4