Button piano gamit ang Raspberry Pi Pico (5 button + buzzer + melody recorder)
Mini piano na may limang key na tumatanda sa tinugtog mo! Tinutugtog ng Raspberry Pi Pico ang DO, RE, MI, FA at SOL sa passive buzzer mula sa limang button, at tumatagal ang nota hangga't pinipindot mo ang key nito. Pindutin nang 1 segundo ang DO, tugtugin ang himig, saka pindutin ulit ang DO: patutugtugin ito ng Pico, at iniikli sa 1.5 s ang mas mahahabang katahimikan. Ang LED sa board ang record indicator, walang dagdag na piyesa. PWM na nota, debounce at non-blocking timing sa iisang project.

Video
Circuit diagram

Source code
1# ─────────────────────────────────────────
2# BlueGrays · bluegrays.com
3# Raspberry Pi Pico Button Piano (5 Buttons + Buzzer + Melody Recorder)
4# ─────────────────────────────────────────
5# Five-button mini piano: DO, RE, MI, FA, SOL. A note plays while its key
6# is held. Hold DO for 1 s: recording starts and the notes are stored with
7# their timing. Hold DO for 1 s again: recording stops and the melody is
8# played back in rhythm.
9#
10# Pins:
11# GP7 -> DO button (other leg to GND)
12# GP8 -> RE button (other leg to GND)
13# GP9 -> MI button (other leg to GND)
14# GP10 -> FA button (other leg to GND)
15# GP11 -> SOL button (other leg to GND)
16# GP17 -> Buzzer (+), other leg to GND
17# LED -> Onboard LED: record / play
18
19from machine import Pin, PWM
20import time
21
22# ============ SETTINGS ============
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 # Record key: DO
29LONG_PRESS_MS = 1000 # Hold time for record
30DEBOUNCE_MS = 20 # Button debounce
31MAX_NOTES = 64 # Max notes in a recording
32MAX_GAP_MS = 1500 # Longest silence in playback
33PLAY_DELAY_MS = 500 # Pause before playback
34REC_BLINK_MS = 500 # LED blink while recording
35LOOP_MS = 2 # Main loop step
36
37FREE, REC, PLAY = 0, 1, 2 # Modes
38
39# ============ HARDWARE ============
40buzzer = PWM(Pin(17))
41buzzer.duty_u16(0)
42try:
43 led = Pin("LED", Pin.OUT) # onboard LED
44except (TypeError, ValueError):
45 led = Pin(25, Pin.OUT) # Older firmware
46led.value(0)
47
48
49class Key:
50 # Debounced button; update() returns +1 on press, -1 on release
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 # Consumed by a command
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# ============ SOUND ============
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 # Short signal sound: (Hz, ms) pairs; 0 Hz = silence
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# ============ STATE ============
102mode = FREE
103held = [] # Held notes, latest last
104rec_notes = [] # Recording: [key, start ms, length ms]
105rec_t0 = 0
106play_list = [] # Playback: (time ms, key, length ms)
107play_index = 0
108play_start = 0
109play_end = 0
110play_sounding = False
111
112
113def update_sound():
114 # The buzzer plays one note: the latest pressed key wins
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)) # Rising signal
127 print("Recording started (max %d notes)" % MAX_NOTES)
128
129
130def build_play_list():
131 # Sort notes by start, shift the first to 0, shorten long silences
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)) # Falling signal
147 if not rec_notes:
148 mode = FREE
149 print("Recording is empty")
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("Recording stopped: %d notes" % len(play_list))
155 print("Melody:", 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("Playback...")
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 # Non-blocking playback: start notes when due, silence them when they end
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 lights with the note
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("Done. DO 1 s = new recording")
191
192
193def on_press(k, now):
194 if mode == PLAY:
195 # Any key stops the playback
196 keys[k].used = True
197 finish_playback("Stopped")
198 return
199 held.append(k)
200 update_sound()
201 tag = "[REC] " if mode == REC else ""
202 print("%sNote: %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("Recording full")
216 stop_recording(now)
217
218
219def on_long_press(k, now):
220 # Long press on DO: start or stop recording. The held DO note is not recorded.
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# ============ MAIN LOOP ============
232print("== BlueGrays · bluegrays.com ==")
233print("Pico Button Piano")
234print("Keys: DO RE MI FA SOL")
235print("Hold DO 1 s = start / stop recording + play back")
236print("Any key stops the playback")
237chirp((NOTE_HZ[0], 90), (NOTE_HZ[2], 90), (NOTE_HZ[4], 90), (1047, 180)) # Startup
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 blinks while recording
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)
260FAQ
Paano ako magre-record ng melody at patutugtugin ito ulit?
Pindutin nang isang segundo ang DO: nangangahulugan ang dalawang tumataas na beep na nagsimula na ang recording. Tugtugin ang himig mo, saka pindutin ulit nang isang segundo ang DO. Pagkatapos ng dalawang bumababang beep, tutugtog ulit ang melody; pinapaikli sa 1.5 segundo ang mga katahimikang mas mahaba sa 1.5 segundo sa pagitan ng mga nota. Humihinto ang playback kapag pumindot ng kahit anong key.
Kailangan ko bang magdagdag ng hiwalay na LED para sa record indicator?
Hindi. Pinapagana ng code ang LED sa board sa pamamagitan ng `Pin("LED")`, na GP25 sa Pico at gumagana rin sa Pico W. Kumikislap ito bawat kalahating segundo habang nagre-record at sumisindi sa bawat nota habang nagpe-playback.
Paano ko papalitan ang mga nota o ang octave?
Nasa `NOTE_HZ` ang mga frequency: 523, 587, 659, 698 at 784 Hz. Hatiin sa dalawa ang lahat para sa isang octave na mas mababa o doblehin para sa isang mas mataas. Para magdagdag ng ikaanim na key, idagdag ang bagong pin, pangalan at frequency (880 para sa LA) sa `NOTE_PINS`, `NOTE_NAMES` at `NOTE_HZ`.
Paano ko tutugtugin ang piano sa Wokwi?
Simulan ang simulation at i-click nang isang beses ang circuit. Tinutugtog ng mga key na 1 hanggang 5 sa keyboard mo ang DO hanggang SOL, at humahaba ang nota kapag pinindot nang matagal ang key. Para mag-record, pindutin ang 1 nang mga isang segundo; lalabas sa serial monitor ang mga notang tinugtog mo at ang na-record na melody.
