PI-19Beginner

Raspberry Pi Pico-knoppenpiano (5 knoppen + buzzer + melodierecorder)

Een minipiano met vijf toetsen die onthoudt wat je speelt! De Raspberry Pi Pico speelt met vijf knoppen DO, RE, MI, FA en SOL af op een passieve buzzer. Houd DO een seconde ingedrukt, speel je melodie en houd DO weer ingedrukt: de Pico speelt het terug en kort stiltes langer dan 1,5 seconde in tot 1,5 seconde. De opname-indicator is de led op het board. PWM-noten, contactdender-onderdrukking en niet-blokkerende timing.

0.0(0)
Raspberry Pi Pico-knoppenpiano (5 knoppen + buzzer + melodierecorder)
Een kleine piano met vijf knoppen: elke knop speelt do, re, mi, fa of sol op de buzzer en de noot duurt zo lang als je hem inhoudt. Houd de do-toets een seconde ingedrukt en de opname start, terwijl de led op het board knippert; speel je melodie, houd do weer een seconde ingedrukt en de Raspberry Pi Pico speelt het met hetzelfde ritme terug. De makkelijkste manier om je eigen melodie op te nemen en terug te horen.

Video

Schakelschema

Raspberry Pi Pico-knoppenpiano (5 knoppen + buzzer + melodierecorder) - Schakelschema

Broncode

MicroPython
1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Raspberry Pi Pico-knoppenpiano (5 knoppen + buzzer + melodierecorder)
4# ─────────────────────────────────────────
5# Minipiano met vijf knoppen: DO, RE, MI, FA, SOL. Een noot klinkt zolang
6# je de toets ingedrukt houdt. Houd DO 1 s ingedrukt: de opname start en
7# de noten worden met hun timing opgeslagen. Houd DO nogmaals 1 s
8# ingedrukt: de opname stopt en de melodie wordt in ritme afgespeeld.
9#
10# Pinnen:
11#   GP7  -> DO-knop (andere pootje naar GND)
12#   GP8  -> RE-knop (andere pootje naar GND)
13#   GP9  -> MI-knop (andere pootje naar GND)
14#   GP10 -> FA-knop (andere pootje naar GND)
15#   GP11 -> SOL-knop (andere pootje naar GND)
16#   GP17 -> Buzzer (+), ander pootje naar GND
17#   LED  -> Ingebouwde led: opnemen / afspelen
18
19from machine import Pin, PWM
20import time
21
22# ============ INSTELLINGEN ============
23NOTE_PINS = (7, 8, 9, 10, 11)
24NOTE_NAMES = ("DO", "RE", "MI", "FA", "SOL")
25NOTE_HZ = (523, 587, 659, 698, 784)   # C5 D5 E5 F5 G5 (Hz)
26VOLUME = 32768         # PWM-duty, 32768 = 50%
27
28REC_KEY = 0            # Opnametoets: DO
29LONG_PRESS_MS = 1000   # Vasthoudtijd voor opnemen
30DEBOUNCE_MS = 20       # Contactdender van knop
31MAX_NOTES = 64         # Max. noten in een opname
32MAX_GAP_MS = 1500      # Langste stilte bij afspelen
33PLAY_DELAY_MS = 500    # Pauze voor het afspelen
34REC_BLINK_MS = 500     # Led knippert tijdens opnemen
35LOOP_MS = 2            # Stap van de hoofdlus
36
37FREE, REC, PLAY = 0, 1, 2   # Modi
38
39# ============ HARDWARE ============
40buzzer = PWM(Pin(17))
41buzzer.duty_u16(0)
42try:
43    led = Pin("LED", Pin.OUT)      # ingebouwde led
44except (TypeError, ValueError):
45    led = Pin(25, Pin.OUT)         # Oudere firmware
46led.value(0)
47
48
49class Key:
50    # Knop met contactdenderfilter; update() geeft +1 bij indrukken, -1 bij loslaten
51    def __init__(self, gpio):
52        self.pin = Pin(gpio, Pin.IN, Pin.PULL_UP)
53        self.raw = 1
54        self.stable = 1
55        self.changed = time.ticks_ms()
56        self.down_at = 0
57        self.used = False      # Verbruikt door een commando
58
59    def update(self, now):
60        raw = self.pin.value()
61        if raw != self.raw:
62            self.raw = raw
63            self.changed = now
64        if raw != self.stable and time.ticks_diff(now, self.changed) >= DEBOUNCE_MS:
65            self.stable = raw
66            if raw == 0:
67                self.down_at = now
68                self.used = False
69                return 1
70            return -1
71        return 0
72
73    def held_ms(self, now):
74        return time.ticks_diff(now, self.down_at) if self.stable == 0 else 0
75
76
77keys = [Key(p) for p in NOTE_PINS]
78
79
80# ============ GELUID ============
81def tone(hz):
82    buzzer.freq(hz)
83    buzzer.duty_u16(VOLUME)
84
85
86def silence():
87    buzzer.duty_u16(0)
88
89
90def chirp(*steps):
91    # Kort signaalgeluid: paren (Hz, ms); 0 Hz = stilte
92    for hz, ms in steps:
93        if hz:
94            tone(hz)
95        else:
96            silence()
97        time.sleep_ms(ms)
98    silence()
99
100
101# ============ STATUS ============
102mode = FREE
103held = []          # Ingedrukte noten, laatste achteraan
104rec_notes = []     # Opname: [toets, start ms, duur ms]
105rec_t0 = 0
106play_list = []     # Afspelen: (tijd ms, toets, duur ms)
107play_index = 0
108play_start = 0
109play_end = 0
110play_sounding = False
111
112
113def update_sound():
114    # De buzzer speelt één noot: de laatst ingedrukte toets wint
115    if held:
116        tone(NOTE_HZ[held[-1]])
117    else:
118        silence()
119
120
121def start_recording(now):
122    global mode, rec_notes, rec_t0
123    mode = REC
124    rec_notes = []
125    rec_t0 = now
126    chirp((880, 70), (0, 40), (1319, 110))       # Stijgend signaal
127    print("Opname gestart (max %d noten)" % MAX_NOTES)
128
129
130def build_play_list():
131    # Sorteer noten op start, verschuif de eerste naar 0, kort lange stiltes in
132    notes = sorted(rec_notes, key=lambda n: n[1])
133    result = []
134    t = 0
135    for i, (k, start, length) in enumerate(notes):
136        if i > 0:
137            prev_k, prev_start, prev_len = notes[i - 1]
138            t += min(start - prev_start, prev_len + MAX_GAP_MS)
139        result.append((t, k, length))
140    return result
141
142
143def stop_recording(now):
144    global mode, play_list, play_index, play_start, play_end, play_sounding
145    led.value(0)
146    chirp((1319, 70), (0, 40), (880, 110))       # Dalend signaal
147    if not rec_notes:
148        mode = FREE
149        print("Opname is leeg")
150        chirp((220, 300))
151        return
152    play_list = build_play_list()
153    names = " ".join(NOTE_NAMES[n[1]] for n in play_list)
154    print("Opname gestopt: %d noten" % len(play_list))
155    print("Melodie:", names)
156    mode = PLAY
157    play_index = 0
158    play_end = 0
159    play_sounding = False
160    play_start = time.ticks_add(time.ticks_ms(), PLAY_DELAY_MS)
161    print("Afspelen...")
162
163
164def finish_playback(message):
165    global mode
166    mode = FREE
167    silence()
168    led.value(0)
169    print(message)
170
171
172def update_playback(now):
173    # Niet-blokkerend afspelen: start noten op tijd, zet ze stil als ze eindigen
174    global play_index, play_end, play_sounding
175    elapsed = time.ticks_diff(now, play_start)
176    if elapsed < 0:
177        return
178    while play_index < len(play_list) and elapsed >= play_list[play_index][0]:
179        t, k, length = play_list[play_index]
180        tone(NOTE_HZ[k])
181        led.value(1)                  # Led brandt met de noot
182        play_end = t + length
183        play_sounding = True
184        play_index += 1
185    if play_sounding and elapsed >= play_end:
186        silence()
187        led.value(0)
188        play_sounding = False
189    if not play_sounding and play_index >= len(play_list):
190        finish_playback("Klaar. DO 1 s = nieuwe opname")
191
192
193def on_press(k, now):
194    if mode == PLAY:
195        # Elke toets stopt het afspelen
196        keys[k].used = True
197        finish_playback("Gestopt")
198        return
199    held.append(k)
200    update_sound()
201    tag = "[REC] " if mode == REC else ""
202    print("%sNoot: %s (%d Hz)" % (tag, NOTE_NAMES[k], NOTE_HZ[k]))
203
204
205def on_release(k, now):
206    if k in held:
207        held.remove(k)
208        update_sound()
209    if keys[k].used or mode != REC:
210        return
211    start = time.ticks_diff(keys[k].down_at, rec_t0)
212    length = time.ticks_diff(now, keys[k].down_at)
213    rec_notes.append([k, start, length])
214    if len(rec_notes) >= MAX_NOTES:
215        print("Opname vol")
216        stop_recording(now)
217
218
219def on_long_press(k, now):
220    # Lange druk op DO: opname starten of stoppen. De ingedrukte DO-noot wordt niet opgenomen.
221    keys[k].used = True
222    if k in held:
223        held.remove(k)
224    update_sound()
225    if mode == FREE:
226        start_recording(now)
227    elif mode == REC:
228        stop_recording(now)
229
230
231# ============ HOOFDLUS ============
232print("== BlueGrays · bluegrays.com ==")
233print("Pico knoppenpiano")
234print("Toetsen: DO RE MI FA SOL")
235print("Houd DO 1 s = opname starten / stoppen + afspelen")
236print("Elke toets stopt het afspelen")
237chirp((NOTE_HZ[0], 90), (NOTE_HZ[2], 90), (NOTE_HZ[4], 90), (1047, 180))   # Opstarten
238
239while True:
240    now = time.ticks_ms()
241    for i, key in enumerate(keys):
242        event = key.update(now)
243        if event == 1:
244            on_press(i, now)
245        elif event == -1:
246            on_release(i, now)
247
248    rec_key = keys[REC_KEY]
249    if (mode != PLAY and not rec_key.used
250            and rec_key.held_ms(now) >= LONG_PRESS_MS):
251        on_long_press(REC_KEY, now)
252
253    if mode == PLAY:
254        update_playback(now)
255    elif mode == REC:
256        # Led knippert tijdens opnemen
257        led.value(1 if (time.ticks_diff(now, rec_t0) // REC_BLINK_MS) % 2 == 0 else 0)
258
259    time.sleep_ms(LOOP_MS)
260

Veelgestelde vragen

Hoe neem ik een melodie op en speel ik hem terug?

Houd DO één seconde ingedrukt: twee stijgende piepjes betekenen dat de opname is gestart. Speel je melodie en houd DO dan weer één seconde ingedrukt. Na twee dalende piepjes wordt de melodie afgespeeld; stiltes langer dan 1,5 seconde tussen noten worden ingekort tot 1,5 seconde. Een druk op een willekeurige toets tijdens het afspelen stopt het.

Moet ik een aparte led toevoegen als opname-indicator?

Nee. De code stuurt de led op het board aan via `Pin("LED")`, dat op de Pico GP25 is en ook op de Pico W werkt. Tijdens het opnemen knippert hij elke halve seconde en bij het terugspelen licht hij bij elke noot op.

Hoe verander ik de noten of het octaaf?

De frequenties staan in `NOTE_HZ`: 523, 587, 659, 698 en 784 Hz. Halveer ze allemaal voor een octaaf lager of verdubbel ze voor een octaaf hoger. Voor een zesde toets voeg je de nieuwe pin, naam en frequentie (880 voor LA) toe aan `NOTE_PINS`, `NOTE_NAMES` en `NOTE_HZ`.

Hoe speel ik de piano in Wokwi?

Start de simulatie en klik één keer op de schakeling. Toets 1 t/m 5 op je toetsenbord spelen DO tot SOL en een toets inhouden maakt de noot langer. Om op te nemen houd je 1 ongeveer een seconde ingedrukt; de noten die je speelt en de opgenomen melodie verschijnen in de Serial Monitor.