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.

Video
Schakelschema

Broncode
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)
260Veelgestelde 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.
