PI-16Gemiddeld

Raspberry Pi Pico-ledtouwtrekspel (NeoPixel-strip + 2 knoppen + buzzer)

Een knoppenduel voor twee spelers! De Raspberry Pi Pico maakt van een WS2812B NeoPixel-strip met 30 leds een touw: rode speler links, blauwe speler rechts. Elke druk duwt jouw kleur één led vooruit; vul de hele strip om de ronde te winnen en win 3 rondes voor de wedstrijd. Te vroeg drukken tijdens het aftellen kost je terrein, de passieve buzzer geeft elke speler een andere klik en de wedstrijd eindigt in een regenboog. neopixel, contactdender en niet-blokkerend geluid in MicroPython.

0.0(0)
2 voltooid
Raspberry Pi Pico-ledtouwtrekspel (NeoPixel-strip + 2 knoppen + buzzer)
Een gloeiend touwtrekspel waarin jij en een vriend strijden wiens vingers sneller zijn. De ene kant van de ledstrip met 30 leds is rood en de andere blauw; wie sneller op zijn knop drukt, trekt de knoop in het midden naar zijn kant, en wie als eerste de hele strip in zijn kleur verft, wint de ronde. Te vroeg starten kost je, wie als eerste drie rondes wint, pakt de wedstrijd, en daarna volgt een regenboogshow met een overwinningsdeuntje.

Video

Schakelschema

Raspberry Pi Pico-ledtouwtrekspel (NeoPixel-strip + 2 knoppen + buzzer) - Schakelschema

Broncode

MicroPython
1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Raspberry Pi Pico-ledtouwtrekspel (NeoPixel-strip + 2 knoppen + buzzer)
4# ─────────────────────────────────────────
5# Duel met twee knoppen voor twee spelers. Elke druk duwt jouw kleur één
6# stap verder over de strip; wie als eerste het einde bereikt wint de
7# ronde, wie als eerste 3 rondes wint de wedstrijd. Te vroeg drukken
8# tijdens het aftellen kost je 2 stappen.
9#
10# Pinnen:
11#   GP2  -> strip DIN
12#   GP14 -> Knop speler 1 (ROOD), andere kant naar GND
13#   GP16 -> Knop speler 2 (BLAUW), andere kant naar GND
14#   GP15 -> Buzzer (+)
15
16from machine import Pin, PWM
17from neopixel import NeoPixel
18import time
19import math
20
21# ============ INSTELLINGEN ============
22NUM_LEDS = 30          # Leds op de strip
23BRIGHTNESS = 0.6       # ~0.4 A met kleuren, prima voor USB
24WIN_ROUNDS = 3         # Rondes om de wedstrijd te winnen
25FALSE_START_STEPS = 2  # Straf voor valse start
26SOUND_ON = True        # Geluidseffecten
27
28RED = (255, 0, 0)      # Speler 1
29BLUE = (0, 60, 255)    # Speler 2
30
31# Knoop = aantal rode leds (de grens tussen de kleuren). Beide spelers hebben evenveel stappen
32# nodig.
33START = NUM_LEDS // 2                   # Startgrens
34GOAL = min(START, NUM_LEDS - START)     # Benodigde stappen om te winnen
35
36# ============ HARDWARE ============
37strip = NeoPixel(Pin(2), NUM_LEDS)
38btn1 = Pin(14, Pin.IN, Pin.PULL_UP)   # Speler 1
39btn2 = Pin(16, Pin.IN, Pin.PULL_UP)   # Speler 2
40buzzer = PWM(Pin(15))
41buzzer.duty_u16(0)
42
43
44# ============ GELUID ============
45class Sound:
46    """Niet-blokkerende notenspeler: het spel blijft knoppen lezen terwijl er geluid speelt"""
47
48    def __init__(self, pwm):
49        self.pwm = pwm
50        self.queue = []
51        self.until = 0
52
53    def play(self, notes):
54        # notes = [(frequentie, ms), ...], frequentie 0 = rust
55        if SOUND_ON:
56            self.queue = list(notes)
57            self.until = 0
58
59    def update(self):
60        now = time.ticks_ms()
61        if self.until and time.ticks_diff(now, self.until) < 0:
62            return
63        if not self.queue:
64            if self.until:
65                self.pwm.duty_u16(0)
66                self.until = 0
67            return
68        freq, ms = self.queue.pop(0)
69        if freq:
70            self.pwm.freq(freq)
71            self.pwm.duty_u16(20000)
72        else:
73            self.pwm.duty_u16(0)
74        self.until = time.ticks_add(now, ms)
75
76
77sound = Sound(buzzer)
78
79
80# ============ KNOP ============
81class Button:
82    """Vangt nieuwe drukken op met 15 ms contactdender-filter"""
83
84    def __init__(self, pin):
85        self.pin = pin
86        self.state = 1
87        self.raw = 1
88        self.changed = time.ticks_ms()
89
90    def pressed(self):
91        now = time.ticks_ms()
92        raw = self.pin.value()
93        if raw != self.raw:
94            self.raw = raw
95            self.changed = now
96        if time.ticks_diff(now, self.changed) > 15 and raw != self.state:
97            self.state = raw
98            return raw == 0
99        return False
100
101    def sync(self):
102        # Vergeet oude drukken (een knop die tussen rondes ingedrukt blijft wordt niet bestraft)
103        self.state = self.raw = self.pin.value()
104        self.changed = time.ticks_ms()
105
106
107b1 = Button(btn1)
108b2 = Button(btn2)
109
110
111# ============ TEKENHULPEN ============
112def dim(color, k=1.0):
113    # Schaal een kleur met globale helderheid en k
114    s = BRIGHTNESS * k
115    return (int(color[0] * s), int(color[1] * s), int(color[2] * s))
116
117
118def fill(color, k=1.0):
119    c = dim(color, k)
120    for i in range(NUM_LEDS):
121        strip[i] = c
122    strip.write()
123
124
125def draw_rope(knot):
126    # `knot` leds zijn rood (links), de rest blauw (rechts); 2 leds aan elke kant van de grens
127    # vormen de felle "knoop"
128    for i in range(NUM_LEDS):
129        if i < knot:
130            k = 1.0 if knot - i <= 2 else 0.45   # Leds bij de knoop zijn feller
131            strip[i] = dim(RED, k)
132        else:
133            k = 1.0 if i - knot < 2 else 0.45
134            strip[i] = dim(BLUE, k)
135    strip.write()
136
137
138def wheel(pos):
139    # Zet 0-255 om naar een regenboogkleur
140    pos %= 256
141    if pos < 85:
142        return (255 - pos * 3, pos * 3, 0)
143    if pos < 170:
144        pos -= 85
145        return (0, 255 - pos * 3, pos * 3)
146    pos -= 170
147    return (pos * 3, 0, 255 - pos * 3)
148
149
150def wait_ms(ms):
151    # Wacht terwijl het geluid blijft doorlopen
152    end = time.ticks_add(time.ticks_ms(), ms)
153    while time.ticks_diff(end, time.ticks_ms()) > 0:
154        sound.update()
155        time.sleep_ms(5)
156
157
158# ============ SPELFASEN ============
159def attract():
160    # Wachten: beide kleuren ademen, elke knop start het spel
161    print("Druk op een knop om te starten")
162    b1.sync()
163    b2.sync()
164    t0 = time.ticks_ms()
165    while True:
166        sound.update()
167        t = time.ticks_diff(time.ticks_ms(), t0)
168        k = 0.25 + 0.75 * (math.sin(t / 400) + 1) / 2
169        for i in range(NUM_LEDS):
170            if i < START:
171                strip[i] = dim(RED, k)
172            else:
173                strip[i] = dim(BLUE, 1.25 - k)   # Ademt in tegenfase
174        strip.write()
175        if b1.pressed() or b2.pressed():
176            return
177        time.sleep_ms(15)
178
179
180def countdown():
181    # Aftellen 3-2-1; te vroeg drukken wordt bestraft. Geeft de startknoop terug
182    knot = START
183    b1.sync()
184    b2.sync()
185    colors = [(255, 0, 0), (255, 150, 0), (0, 255, 0)]   # Rood, geel, groen
186    for step in range(3):
187        fill(colors[step], 0.6)
188        if step == 2:
189            sound.play([(1200, 200)])   # GO!
190            break
191        sound.play([(600, 150)])
192        end = time.ticks_add(time.ticks_ms(), 800)
193        while time.ticks_diff(end, time.ticks_ms()) > 0:
194            sound.update()
195            if b1.pressed():
196                knot -= FALSE_START_STEPS
197                print("Speler 1 valse start!")
198                sound.play([(150, 200)])
199            if b2.pressed():
200                knot += FALSE_START_STEPS
201                print("Speler 2 valse start!")
202                sound.play([(150, 200)])
203            time.sleep_ms(5)
204    # Straffen mogen de knoop niet naar een uiteinde duwen
205    return max(START - GOAL + 2, min(START + GOAL - 2, knot))
206
207
208def play_round(knot):
209    # Knopduel; geeft de winnaar terug (1 of 2) als de knoop een uiteinde bereikt
210    draw_rope(knot)
211    while True:
212        sound.update()
213        moved = False
214        if b1.pressed():
215            knot += 1
216            sound.play([(440, 25)])
217            moved = True
218        if b2.pressed():
219            knot -= 1
220            sound.play([(660, 25)])
221            moved = True
222        if moved:
223            if knot >= START + GOAL:   # Strip helemaal rood
224                return 1
225            if knot <= START - GOAL:   # Strip helemaal blauw
226                return 2
227            draw_rope(knot)
228        time.sleep_ms(1)
229
230
231def celebrate_round(winner, scores):
232    # Winnaarskleur knippert 3 keer, daarna worden de scorepunten getoond
233    color = RED if winner == 1 else BLUE
234    print("Rondewinnaar: speler", winner, "| Score:", scores[0], "-", scores[1])
235    sound.play([(523, 120), (659, 120), (784, 120), (1047, 300)])
236    for _ in range(3):
237        fill(color)
238        wait_ms(180)
239        fill((0, 0, 0))
240        wait_ms(120)
241    # Score: rode punten van links, blauwe punten van rechts
242    for i in range(NUM_LEDS):
243        strip[i] = (0, 0, 0)
244    for s in range(scores[0]):
245        strip[s * 2] = dim(RED)
246    for s in range(scores[1]):
247        strip[NUM_LEDS - 1 - s * 2] = dim(BLUE)
248    strip.write()
249    wait_ms(1800)
250
251
252def celebrate_match(winner):
253    # Einde van de wedstrijd: regenbooggolf en overwinningsmelodie
254    print("WEDSTRIJDWINNAAR: speler", winner)
255    sound.play([(784, 150), (784, 150), (784, 150), (1047, 450), (0, 80), (988, 150), (1047, 500)])
256    t0 = time.ticks_ms()
257    while time.ticks_diff(time.ticks_ms(), t0) < 3500:
258        sound.update()
259        offset = time.ticks_diff(time.ticks_ms(), t0) // 8
260        for i in range(NUM_LEDS):
261            strip[i] = dim(wheel(i * 256 // NUM_LEDS + offset))
262        strip.write()
263        time.sleep_ms(15)
264    fill(RED if winner == 1 else BLUE)
265    wait_ms(1000)
266
267
268# ============ HOOFDLUS ============
269print("== BlueGrays · bluegrays.com ==")
270print("Pico LED-touwtrekken")
271
272scores = [0, 0]
273while True:
274    attract()
275    while max(scores) < WIN_ROUNDS:
276        start_knot = countdown()
277        winner = play_round(start_knot)
278        scores[winner - 1] += 1
279        celebrate_round(winner, scores)
280    celebrate_match(1 if scores[0] > scores[1] else 2)
281    scores = [0, 0]
282

Veelgestelde vragen

Mijn strip heeft geen 30 leds. Kan ik een andere lengte gebruiken?

Ja. Zet `NUM_LEDS` bovenaan de code op het aantal leds van je strip; het startpunt (`START`) en het aantal stappen om te winnen (`GOAL`) worden automatisch berekend. Bij een strip met 60 leds heeft elke speler 30 drukken nodig, dus de rondes duren langer.

Heb ik de weerstand van 330 Ω en de condensator van 470 µF echt nodig?

Niet in Wokwi, maar ze worden aanbevolen voor de echte schakeling. Plaats een weerstand van 330 Ω in serie tussen GP2 en de DIN van de strip, en een condensator van 470 µF tussen 5V en GND van de strip (lange pootje naar 5V). Ze beschermen de eerste led en voorkomen flikkeren en willekeurige kleuren.

Is de USB van de Pico genoeg om de strip te voeden?

Met 30 leds en `BRIGHTNESS = 0.6` trekt de strip hooguit ongeveer 0,4 A, wat USB aankan. VBUS levert alleen 5V zolang USB is aangesloten. Gebruik voor een langere strip of hogere helderheid een aparte 5V/2A-adapter en verbind de massa's.

Hoe verander ik het aantal rondes en de straf voor een valse start?

`WIN_ROUNDS` is het aantal rondes dat nodig is om de wedstrijd te winnen (standaard 3). `FALSE_START_STEPS` bepaalt hoeveel stappen iemand die te vroeg drukt terug wordt geduwd (standaard 2; zet op 0 om de straf uit te schakelen). Voor een stil spel zet je `SOUND_ON = False`.