PI-18Beginner

Raspberry Pi Pico-parkeersensor (HC-SR04 + 3 leds + buzzer)

Haal de achteruitrijsensor van je auto naar je bureau! De Raspberry Pi Pico meet met een HC-SR04-ultrasoonsensor ongeveer 16 keer per seconde de afstand tot een obstakel. Naarmate het dichterbij komt, gaan de groene, gele en rode led om de beurt branden en piept de buzzer sneller; onder 10 cm wordt de toon continu en knippert de rode led. Ultrasone afstandsmeting, PWM-geluid en niet-blokkerende timing in één project.

0.0(0)
1 voltooid
Raspberry Pi Pico-parkeersensor (HC-SR04 + 3 leds + buzzer)
Een bureauversie van de parkeersensor in een auto. De HC-SR04 zendt een geluid uit dat te hoog is voor je oren en luistert naar de echo om te meten hoe ver een obstakel weg is; zodra iets binnen een meter komt, gaat de groene led branden en piept de buzzer langzaam. Als het dichterbij komt, doen de gele en rode led mee en worden de piepjes sneller en hoger. Onder 10 centimeter stopt de toon niet meer en knippert het rode licht.

Video

Schakelschema

Raspberry Pi Pico-parkeersensor (HC-SR04 + 3 leds + buzzer) - Schakelschema

Broncode

MicroPython
1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Raspberry Pi Pico-parkeersensor (HC-SR04 + 3 leds + buzzer)
4# ─────────────────────────────────────────
5# Parkeersensor voor auto's. De HC-SR04 meet de afstand tot een obstakel;
6# naarmate je dichterbij komt gaan de groene, gele en rode led na elkaar
7# branden en volgen de pieptonen sneller op elkaar. Heel dichtbij wordt de
8# toon continu en knippert de rode led.
9#
10# Pinnen:
11#   GP27 -> TRIG van de HC-SR04
12#   GP26 -> HC-SR04 ECHO (1k + 2k spanningsdeler bij echte hardware)
13#   VBUS -> HC-SR04 VCC (5V), GND.6 -> HC-SR04 GND
14#   GP4  -> 220 ohm -> rode led (kathode naar GND)
15#   GP8  -> 220 ohm -> gele led (kathode naar GND)
16#   GP12 -> 220 ohm -> groene led (kathode naar GND)
17#   GP17 -> Buzzer (+), ander pootje naar GND
18
19from machine import Pin, PWM, time_pulse_us
20import time
21
22# ============ INSTELLINGEN ============
23GREEN_CM = 100         # Groen aan, piepen begint
24YELLOW_CM = 50         # Geel gaat mee branden
25RED_CM = 25            # Rood gaat mee branden
26STOP_CM = 10           # Continue toon + knipperend rood
27
28BEEP_MS = 60           # Duur van één piep
29SLOW_GAP_MS = 700      # Pauze tussen pieptonen bij GREEN_CM
30FAST_GAP_MS = 50       # Pauze tussen pieptonen bij STOP_CM
31VOLUME = 32768         # PWM-duty, 32768 = 50%
32FLASH_MS = 120         # Knipperperiode rood in STOP-zone
33
34MEASURE_MS = 60        # Meetinterval, min 60 ms
35PRINT_MS = 250         # Serial-printinterval
36ECHO_TIMEOUT_US = 12000  # voorbij ~2 m = geen obstakel
37SOUND_CM_PER_US = 0.0343  # Geluidssnelheid (20 C)
38LOOP_MS = 5            # Stap van de hoofdlus
39
40# Zones van dichtbij naar ver: (naam, bovengrens cm, (groen, geel, rood), toon Hz)
41ZONES = (
42    ("STOP", STOP_CM, (1, 1, 1), 1900),
43    ("ROOD", RED_CM, (1, 1, 1), 1900),
44    ("GEEL", YELLOW_CM, (1, 1, 0), 1500),
45    ("GROEN", GREEN_CM, (1, 0, 0), 1200),
46)
47CLEAR = len(ZONES)     # Zone zonder obstakel
48STOP = 0               # Index van de 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# ============ METING ============
61def measure_cm():
62    # Stuur een TRIG-puls van 10 us, meet hoe lang ECHO HIGH blijft
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    # Geen echo of te ver
71    # Geluid reist heen en terug: de helft
72    return pulse * SOUND_CM_PER_US / 2
73
74
75def median3(values):
76    # Mediaan van de laatste 3 metingen: één foute meting laat de leds niet flikkeren
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    # Tussen STOP_CM en GREEN_CM groeit de pauze lineair van FAST naar 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# ============ GELUID ============
98tone_on = False
99tone_hz = 0
100
101
102def tone(hz):
103    # Laat PWM met rust als de toon al aan staat
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    # Korte opstarttest van leds en buzzer: groen -> geel -> rood
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# ============ HOOFDLUS ============
138print("== BlueGrays · bluegrays.com ==")
139print("Parkeersensor")
140print("Leds: groen <= %d cm, geel <= %d cm, rood <= %d cm, continue toon <= %d cm"
141      % (GREEN_CM, YELLOW_CM, RED_CM, STOP_CM))
142print("Piep: begint bij %d cm, hogere toon bij %d cm en %d cm, continu bij %d cm"
143      % (GREEN_CM, YELLOW_CM, RED_CM, STOP_CM))
144self_test()
145
146FAR = 999.0                       # Plaatshouder voor geen obstakel
147history = [FAR, FAR, FAR]         # Laatste 3 metingen
148distance = None                   # Gefilterde afstand (cm)
149zone = CLEAR
150last_zone = -1
151now = time.ticks_ms()
152next_measure = now
153next_print = now
154last_beep = time.ticks_add(now, -10000)   # Eerste piep klinkt meteen
155beep_end = now
156
157while True:
158    now = time.ticks_ms()
159
160    # 1) Meting: elke MEASURE_MS, met mediaanfilter
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 = "VRIJ" if zone == CLEAR else ZONES[zone][0]
170            print("Zone ->", name)
171            last_zone = zone
172
173    # 2) Leds: balkgrafiek, rood knippert in de 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) Geluid: niet-blokkerende pieptimer
183    if zone == CLEAR:
184        silence()
185    elif zone == STOP:
186        tone(ZONES[STOP][3])          # Heel dichtbij: continue toon
187    else:
188        if tone_on and time.ticks_diff(now, beep_end) >= 0:
189            silence()
190        # De pauze wordt elke ronde opnieuw berekend: de volgende piep gaat sneller zodra je
191        # dichterbij komt
192        period = BEEP_MS + beep_gap_ms(distance)
193        if not tone_on and time.ticks_diff(now, last_beep) >= period:
194            tone(ZONES[zone][3])
195            last_beep = now
196            beep_end = time.ticks_add(now, BEEP_MS)
197
198    # 4) Serial Monitor: afstand in cm
199    if time.ticks_diff(now, next_print) >= 0:
200        next_print = time.ticks_add(now, PRINT_MS)
201        if distance is None:
202            print("Afstand: --- (geen obstakel)")
203        else:
204            print("Afstand: %5.1f cm" % distance)
205
206    time.sleep_ms(LOOP_MS)
207

Veelgestelde vragen

Waarom heeft ECHO op een echte schakeling een spanningsdeler nodig?

De HC-SR04 werkt op 5V en de ECHO-uitgang geeft 5V, maar de pins van de Pico accepteren maximaal 3,3V. Verbind ECHO via 1 kΩ met GP26 en GP26 via 2 kΩ met GND, zodat de pin ongeveer 3,3V ziet. In Wokwi is de spanningsdeler niet nodig.

Hoe verander ik de waarschuwingsafstanden?

Pas de constanten `GREEN_CM`, `YELLOW_CM`, `RED_CM` en `STOP_CM` bovenaan de code aan. Houd de drempels in de volgorde `STOP_CM < RED_CM < YELLOW_CM < GREEN_CM`; gebruik bijvoorbeeld `STOP_CM = 30`, `RED_CM = 50`, `YELLOW_CM = 100` en `GREEN_CM = 150`. De leds en piepjes volgen de nieuwe drempels automatisch.

Waarom worden de piepjes geleidelijk sneller in plaats van zone voor zone?

`beep_gap_ms()` schaalt de pauze lineair met de afstand: 700 ms bij 100 cm, 50 ms bij 10 cm. Dit wordt bij elke ronde van de hoofdlus opnieuw berekend, dus de volgende piep komt eerder zodra het obstakel dichterbij komt. De zones veranderen alleen de leds en de toonhoogte.

Moet ik bibliotheken installeren?

Nee. De functie `time_pulse_us()` voor de meting zit in de ingebouwde module `machine`. Flash MicroPython op de Pico en sla de code in Thonny op de Pico op als `main.py`; de sensor start vanzelf met een ledtest en drie piepjes.