Raspberry Pi Pico पार्किंग सेंसर (HC-SR04 + 3 LED + बज़र)
कार का रिवर्स पार्किंग सेंसर अपनी मेज़ पर लाएँ! Raspberry Pi Pico, HC-SR04 अल्ट्रासोनिक सेंसर से सेकंड में लगभग 16 बार रुकावट तक की दूरी मापता है। पास आने पर हरा, पीला और लाल LED बारी-बारी से जलते हैं और बज़र तेज़ बीप करता है; 10 cm से कम पर आवाज़ लगातार हो जाती है और लाल LED चमकता है। अल्ट्रासोनिक दूरी माप, PWM आवाज़ और नॉन-ब्लॉकिंग टाइमिंग, सब एक प्रोजेक्ट में।

वीडियो
सर्किट डायग्राम

सोर्स कोड
1# ─────────────────────────────────────────
2# BlueGrays · bluegrays.com
3# Raspberry Pi Pico Parking Sensor (HC-SR04 + 3 LEDs + Buzzer)
4# ─────────────────────────────────────────
5# Car parking sensor. The HC-SR04 measures the distance to an obstacle; as
6# it gets closer the green, yellow and red LEDs light up in turn and the
7# beeps speed up. Very close, the tone becomes continuous and the red LED
8# flashes.
9#
10# Pins:
11# GP27 -> HC-SR04 TRIG
12# GP26 -> HC-SR04 ECHO (1k + 2k divider on real hardware)
13# VBUS -> HC-SR04 VCC (5V), GND.6 -> HC-SR04 GND
14# GP4 -> 220 ohm -> Red LED (cathode to GND)
15# GP8 -> 220 ohm -> Yellow LED (cathode to GND)
16# GP12 -> 220 ohm -> Green LED (cathode to GND)
17# GP17 -> Buzzer (+), other leg to GND
18
19from machine import Pin, PWM, time_pulse_us
20import time
21
22# ============ SETTINGS ============
23GREEN_CM = 100 # Green on, beeping starts
24YELLOW_CM = 50 # Yellow joins in
25RED_CM = 25 # Red joins in
26STOP_CM = 10 # Continuous tone + flashing red
27
28BEEP_MS = 60 # Length of one beep
29SLOW_GAP_MS = 700 # Gap between beeps at GREEN_CM
30FAST_GAP_MS = 50 # Gap between beeps near STOP_CM
31VOLUME = 32768 # PWM duty, 32768 = 50%
32FLASH_MS = 120 # Red flash period in STOP zone
33
34MEASURE_MS = 60 # Measure interval, min 60 ms
35PRINT_MS = 250 # Serial print interval
36ECHO_TIMEOUT_US = 12000 # beyond ~2 m = no obstacle
37SOUND_CM_PER_US = 0.0343 # Speed of sound (20 C)
38LOOP_MS = 5 # Main loop step
39
40# Zones from near to far: (name, upper limit cm, (green, yellow, red), tone Hz)
41ZONES = (
42 ("STOP", STOP_CM, (1, 1, 1), 1900),
43 ("RED", RED_CM, (1, 1, 1), 1900),
44 ("YELLOW", YELLOW_CM, (1, 1, 0), 1500),
45 ("GREEN", GREEN_CM, (1, 0, 0), 1200),
46)
47CLEAR = len(ZONES) # No obstacle zone
48STOP = 0 # Index of the STOP zone
49
50# ============ HARDWARE ============
51trig = Pin(27, Pin.OUT, value=0)
52echo = Pin(26, Pin.IN)
53led_green = Pin(12, Pin.OUT, value=0)
54led_yellow = Pin(8, Pin.OUT, value=0)
55led_red = Pin(4, Pin.OUT, value=0)
56buzzer = PWM(Pin(17))
57buzzer.duty_u16(0)
58
59
60# ============ MEASUREMENT ============
61def measure_cm():
62 # Send a 10 us TRIG pulse, time how long ECHO stays HIGH
63 trig.value(0)
64 time.sleep_us(2)
65 trig.value(1)
66 time.sleep_us(10)
67 trig.value(0)
68 pulse = time_pulse_us(echo, 1, ECHO_TIMEOUT_US)
69 if pulse < 0:
70 return None # No echo or too far
71 # Sound travels there and back: half
72 return pulse * SOUND_CM_PER_US / 2
73
74
75def median3(values):
76 # Median of the last 3 readings: one bad reading does not flicker the LEDs
77 a, b, c = values
78 return max(min(a, b), min(max(a, b), c))
79
80
81def zone_of(dist):
82 if dist is None:
83 return CLEAR
84 for i, zone in enumerate(ZONES):
85 if dist <= zone[1]:
86 return i
87 return CLEAR
88
89
90def beep_gap_ms(dist):
91 # Between STOP_CM and GREEN_CM the beep gap grows linearly from FAST to SLOW
92 ratio = (dist - STOP_CM) / (GREEN_CM - STOP_CM)
93 ratio = min(1.0, max(0.0, ratio))
94 return int(FAST_GAP_MS + ratio * (SLOW_GAP_MS - FAST_GAP_MS))
95
96
97# ============ SOUND ============
98tone_on = False
99tone_hz = 0
100
101
102def tone(hz):
103 # Leave PWM alone if the tone is already on
104 global tone_on, tone_hz
105 if tone_on and tone_hz == hz:
106 return
107 buzzer.freq(hz)
108 buzzer.duty_u16(VOLUME)
109 tone_on = True
110 tone_hz = hz
111
112
113def silence():
114 global tone_on
115 if tone_on:
116 buzzer.duty_u16(0)
117 tone_on = False
118
119
120def set_leds(green, yellow, red):
121 led_green.value(green)
122 led_yellow.value(yellow)
123 led_red.value(red)
124
125
126def self_test():
127 # Short power-on test of LEDs and buzzer: green -> yellow -> red
128 for leds, hz in (((1, 0, 0), 1200), ((1, 1, 0), 1500), ((1, 1, 1), 1900)):
129 set_leds(*leds)
130 tone(hz)
131 time.sleep_ms(90)
132 silence()
133 time.sleep_ms(160)
134 set_leds(0, 0, 0)
135
136
137# ============ MAIN LOOP ============
138print("== BlueGrays · bluegrays.com ==")
139print("Parking Sensor")
140print("LEDs: green <= %d cm, yellow <= %d cm, red <= %d cm, continuous tone <= %d cm"
141 % (GREEN_CM, YELLOW_CM, RED_CM, STOP_CM))
142print("Beep: starts at %d cm, higher pitch at %d cm and %d cm, continuous at %d cm"
143 % (GREEN_CM, YELLOW_CM, RED_CM, STOP_CM))
144self_test()
145
146FAR = 999.0 # Placeholder for no obstacle
147history = [FAR, FAR, FAR] # Last 3 readings
148distance = None # Filtered distance (cm)
149zone = CLEAR
150last_zone = -1
151now = time.ticks_ms()
152next_measure = now
153next_print = now
154last_beep = time.ticks_add(now, -10000) # First beep plays at once
155beep_end = now
156
157while True:
158 now = time.ticks_ms()
159
160 # 1) Measurement: every MEASURE_MS, with a median filter
161 if time.ticks_diff(now, next_measure) >= 0:
162 next_measure = time.ticks_add(now, MEASURE_MS)
163 reading = measure_cm()
164 history = history[1:] + [reading if reading is not None else FAR]
165 filtered = median3(history)
166 distance = None if filtered >= FAR else filtered
167 zone = zone_of(distance)
168 if zone != last_zone:
169 name = "CLEAR" if zone == CLEAR else ZONES[zone][0]
170 print("Zone ->", name)
171 last_zone = zone
172
173 # 2) LEDs: bar graph, red flashes in the STOP zone
174 if zone == CLEAR:
175 set_leds(0, 0, 0)
176 elif zone == STOP:
177 flash_on = (now // FLASH_MS) % 2 == 0
178 set_leds(1, 1, 1 if flash_on else 0)
179 else:
180 set_leds(*ZONES[zone][2])
181
182 # 3) Sound: non-blocking beep timer
183 if zone == CLEAR:
184 silence()
185 elif zone == STOP:
186 tone(ZONES[STOP][3]) # Very close: continuous tone
187 else:
188 if tone_on and time.ticks_diff(now, beep_end) >= 0:
189 silence()
190 # The gap is recalculated every pass: the next beep speeds up as soon as you get closer
191 period = BEEP_MS + beep_gap_ms(distance)
192 if not tone_on and time.ticks_diff(now, last_beep) >= period:
193 tone(ZONES[zone][3])
194 last_beep = now
195 beep_end = time.ticks_add(now, BEEP_MS)
196
197 # 4) Serial monitor: distance in cm
198 if time.ticks_diff(now, next_print) >= 0:
199 next_print = time.ticks_add(now, PRINT_MS)
200 if distance is None:
201 print("Distance: --- (no obstacle)")
202 else:
203 print("Distance: %5.1f cm" % distance)
204
205 time.sleep_ms(LOOP_MS)
206FAQ
असली सर्किट में ECHO पर वोल्टेज डिवाइडर क्यों चाहिए?
HC-SR04, 5V पर चलता है और उसका ECHO आउटपुट 5V है, लेकिन Pico के पिन ज़्यादा से ज़्यादा 3.3V लेते हैं। ECHO को 1 kΩ से GP26 पर और GP26 को 2 kΩ से GND पर जोड़ें, ताकि पिन पर लगभग 3.3V आए। Wokwi में डिवाइडर की ज़रूरत नहीं।
चेतावनी की दूरियाँ कैसे बदलें?
कोड की शुरुआत में `GREEN_CM`, `YELLOW_CM`, `RED_CM` और `STOP_CM` कॉन्स्टेंट बदलें। थ्रेशोल्ड का क्रम `STOP_CM < RED_CM < YELLOW_CM < GREEN_CM` बनाए रखें; जैसे `STOP_CM = 30`, `RED_CM = 50`, `YELLOW_CM = 100` और `GREEN_CM = 150` इस्तेमाल करें। LED और बीप नए थ्रेशोल्ड के हिसाब से अपने-आप चलते हैं।
बीप ज़ोन-दर-ज़ोन नहीं, बल्कि धीरे-धीरे तेज़ क्यों होती है?
`beep_gap_ms()` अंतराल को दूरी के साथ सीधे अनुपात में बदलता है: 100 cm पर 700 ms, 10 cm पर 50 ms। यह मुख्य लूप के हर चक्कर में फिर से निकाला जाता है, इसलिए रुकावट पास आते ही अगली बीप जल्दी आती है। ज़ोन सिर्फ़ LED और सुर बदलते हैं।
क्या कोई लाइब्रेरी इंस्टॉल करनी होगी?
नहीं। माप के लिए इस्तेमाल होने वाला `time_pulse_us()` फ़ंक्शन बिल्ट-इन `machine` मॉड्यूल का हिस्सा है। Pico पर MicroPython फ़्लैश करें और Thonny में कोड को उस पर `main.py` नाम से सेव करें; सेंसर LED टेस्ट और तीन बीप के साथ अपने-आप शुरू होता है।
