Sensor de estacionamiento con Arduino: HC-SR04, buzzer y LEDs
Haz un sensor de estacionamiento con Arduino y HC-SR04: tabla distancia-pitido, código con millis() sin bloqueos, barra de LEDs, pantalla OLED y versión ESP32.
Un sensor de estacionamiento con Arduino es una pequeña ayuda para manejar: mide con un sensor ultrasónico HC-SR04 la distancia al obstáculo que tienes detrás, pita cada vez más rápido a medida que te acercas, llena una barra de LEDs de verde a rojo y, si quieres, muestra la distancia en centímetros en una pantalla OLED. Los sensores de reversa de los autos reales funcionan con el mismo principio: un sensor en la defensa (el parachoques) emite una onda de sonido, calcula la distancia a partir del tiempo que tarda el eco en volver y avisa al conductor con un pitido. Con un Arduino Uno, un HC-SR04, un buzzer (zumbador) y cinco LEDs puedes armar lo mismo en una tarde sobre la protoboard.
En esta guía primero definiremos en una tabla las zonas de distancia y el intervalo de pitido de cada una. Luego escribiremos un código que funciona con millis() en lugar de delay(), para que el pitido nunca detenga la medición. Después le agregaremos una pantalla OLED, reduciremos los errores de medición con un filtro de mediana y una corrección por temperatura, escribiremos una versión para ESP32 con buzzer pasivo e histéresis y, al final, veremos cómo instalar el sensor en el auto o en la pared de la cochera.

¿Cómo funciona un sensor de estacionamiento?
Cuando le das al pin TRIG del HC-SR04 un pulso de 10 microsegundos, el sensor emite ocho ráfagas de sonido a 40 kHz, una frecuencia que el oído humano no percibe, y pone el pin ECHO en HIGH. Cuando el sonido choca con un obstáculo y regresa, el pin ECHO pasa a LOW. El tiempo que ECHO permanece en HIGH es el tiempo de ida y vuelta del sonido. A 20 °C el sonido recorre en el aire unos 343 metros por segundo, es decir, avanza un centímetro en unos 29 microsegundos. Si tomas en cuenta la ida y la vuelta, la fórmula queda muy sencilla: distancia (cm) = tiempo (µs) / 58. Por ejemplo, el eco de una pared a 1 metro tarda unos 5800 µs.
El sensor de estacionamiento repite esta medición entre 15 y 20 veces por segundo y convierte el resultado en una zona. Al cambiar la zona cambian también la cantidad de LEDs encendidos y el ritmo del pitido. Estos son los datos del HC-SR04 que importan para este proyecto:
| Característica | Valor |
|---|---|
| Alimentación | 5 V, unos 15 mA |
| Frecuencia del sonido | 40 kHz |
| Rango de medición | 2–400 cm (rango confiable para estacionarse: 3–250 cm) |
| Ángulo de detección | Un cono de unos 15° |
| Pulso de disparo | Al menos 10 µs en HIGH en TRIG |
| Frecuencia de medición | Al menos 60 ms entre dos mediciones |
| Resolución | Unos 3 mm |
Lista de materiales
| Material | Cantidad | Nota |
|---|---|---|
| Arduino Uno o Nano | 1 | La versión ESP32 está más abajo |
| Sensor ultrasónico HC-SR04 | 1 | Fuera del auto, mejor el JSN-SR04T a prueba de agua |
| Buzzer activo | 1 | En la versión ESP32, buzzer pasivo |
| LEDs (2 verdes, 2 amarillos, 1 rojo) | 5 | En fila, como barra de LEDs |
| Resistencia de 220 Ω | 5 | Una por LED |
| Pantalla OLED I2C de 0,96 pulgadas | 1 | Indicador opcional |
| Protoboard y cables jumper (dupont) | 1 juego | Usa cables cortos |
| Resistencias de 1 kΩ y 2 kΩ | Una de cada una | Solo para ESP32, divisor de voltaje en ECHO |
Tabla de distancia e intervalo de pitido
Los sensores de reversa de los autos suelen empezar con un pitido lento a partir de 1,5 metros, aceleran el ritmo a medida que el obstáculo se acerca y pasan a un tono continuo en los últimos 25–30 centímetros. El conductor sabe cuánto espacio le queda solo por el ritmo, sin mirar ninguna pantalla. Nuestro diseño tiene cinco zonas de aviso y una zona segura. Cada pitido dura 50 ms; el intervalo de la tabla es el tiempo entre el inicio de dos pitidos:
| Zona | Distancia | Intervalo de pitido | LEDs encendidos | Significado |
|---|---|---|---|---|
| Segura | Más de 150 cm | Silencio | Ninguno | Vía libre |
| 1 | 101–150 cm | 800 ms | 1 verde | Obstáculo detectado |
| 2 | 71–100 cm | 500 ms | 2 verdes | Más despacio |
| 3 | 46–70 cm | 300 ms | 2 verdes + 1 amarillo | Atención |
| 4 | 26–45 cm | 150 ms | 2 verdes + 2 amarillos | Muy cerca |
| 5 | 25 cm o menos | Tono continuo | Los cinco (incluido el rojo) | Alto |
Puedes ajustar estos valores a tu auto: en una camioneta con la parte trasera larga, o en una cochera estrecha, es más seguro llevar la zona de alto a 35–40 cm. Si prefieres que el ritmo del pitido cambie de forma continua y no por escalones, puedes reemplazar la tabla de zonas con una conversión como intervalo = map(distancia, 25, 150, 100, 800) usando la función map(). Aun así, la tabla por escalones se distingue mejor de oído: el conductor nota en seguida el cambio de sonido al pasar de la zona tres a la cuatro.
Diagrama de conexión: HC-SR04, buzzer y barra de LEDs
| Pieza y pin | Arduino Uno | ESP32 | Nota |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5V) | El sensor necesita 5 V |
| HC-SR04 GND | GND | GND | Tierra común |
| HC-SR04 TRIG | D9 | GPIO 4 | Salida de disparo |
| HC-SR04 ECHO | D10 | GPIO 18 | En el ESP32, con divisor de 1 kΩ + 2 kΩ |
| Buzzer (+) | D8 | GPIO 19 | Activo en el Uno, pasivo en el ESP32 |
| LED 1 y 2 (verdes) | D2, D3 | GPIO 25, 26 | Resistencia de 220 Ω en serie con cada LED |
| LED 3 y 4 (amarillos) | D4, D5 | GPIO 27, 32 | Resistencia de 220 Ω en serie con cada LED |
| LED 5 (rojo) | D6 | GPIO 33 | Se enciende en la zona de alto |
| OLED SDA / SCL | A4 / A5 | GPIO 21 / 22 | Opcional |
| OLED VCC | 5V | 3V3 | Revisa el orden de pines del módulo |
¿Por qué millis() y no delay()?
La mayoría de los códigos de sensor de estacionamiento que circulan en internet hacen el pitido así: buzzer encendido, delay(50), apagado, delay(intervalo). En una zona de 800 ms eso deja al Arduino ciego casi un segundo en cada vuelta del loop. Un auto que va en reversa a 2 km/h recorre unos 45 cm en ese tiempo; los LEDs y el sonido siempre van atrasados respecto a la distancia real y, lo peor, la medición queda congelada justo cuando entras en la zona de alto. Lo correcto es separar las dos tareas: medir cada 60 ms y, en cada vuelta del loop, decidir con millis() si el buzzer debe estar encendido o apagado. Explicamos la idea con detalle en millis() vs delay().
Armado paso a paso
- Coloca el HC-SR04 en un extremo de la protoboard con los cilindros hacia afuera; conecta VCC a 5V y GND a GND.
- Conecta TRIG a D9 y ECHO a D10. Usa cables cortos; un jumper flojo arruina las lecturas al azar.
- Pon los cinco LEDs en fila: de izquierda a derecha dos verdes, dos amarillos y uno rojo. Conecta la pata larga (ánodo) de cada LED a los pines D2–D6 a través de una resistencia de 220 Ω y la pata corta a la línea de GND.
- Conecta la pata + del buzzer activo a D8 y la otra a GND. Los buzzers activos suelen tener una marca + arriba y suenan solos al recibir 5 V.
- Sube el código, abre el Monitor Serie a 115200 baudios y acerca la mano lentamente al sensor. Cada 60 ms debería aparecer la distancia y el número de zona.
- Pon una caja de cartón en el piso, marca 150, 100, 70, 45 y 25 cm con una cinta métrica y mueve la caja a esos puntos para comprobar que las zonas cambian correctamente.
Código del sensor de estacionamiento con Arduino (barra de LEDs + buzzer)
El siguiente código aplica al pie de la letra las zonas de la tabla. Mide cada 60 ms, toma la mediana de las tres últimas lecturas y genera el pitido con millis(), sin depender de la medición. No tiene ni un solo delay():
1// Arduino park sensörü: HC-SR04 + 5 LED bar + aktif buzzer / Arduino parking sensor: HC-SR04 + 5-LED bar + active buzzer
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const int BUZZER_PIN = 8;
5const int LED_PINS[5] = {2, 3, 4, 5, 6}; // yeşil, yeşil, sarı, sarı, kırmızı / green, green, yellow, yellow, red
6
7// Bölge sınırları (cm) ve bip aralıkları (ms), tablodaki değerler / zone limits (cm) and beep periods (ms) from the table
8const int ZONE_CM[5] = {150, 100, 70, 45, 25};
9const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0}; // 0 = sürekli ses / 0 = continuous tone
10const unsigned int BEEP_ON_MS = 50; // her bipin süresi / length of each beep
11const unsigned long MEASURE_MS = 60; // HC-SR04 için en az 60 ms / at least 60 ms for the HC-SR04
12
13unsigned long lastMeasure = 0;
14unsigned long lastBeep = 0;
15int samples[3] = {999, 999, 999}; // son 3 ölçüm / last 3 readings
16int sampleIndex = 0;
17int distanceCm = 999;
18int zone = 0; // 0 = güvenli, 5 = dur / 0 = safe, 5 = stop
19
20long readDistanceCm() {
21 digitalWrite(TRIG_PIN, LOW);
22 delayMicroseconds(2);
23 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
24 delayMicroseconds(10);
25 digitalWrite(TRIG_PIN, LOW);
26 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL); // 25 ms zaman aşımı, yaklaşık 4,3 m / 25 ms timeout, about 4.3 m
27 if (us == 0) return 999; // yankı yok: engel uzakta / no echo: obstacle far away
28 return us / 58; // µs / 58 = cm (gidiş-dönüş / round trip)
29}
30
31int median3(int a, int b, int c) { // üçün ortancası, ani sıçramaları atar / median of three, drops spikes
32 return max(min(a, b), min(max(a, b), c));
33}
34
35int zoneFor(int d) {
36 int z = 0;
37 for (int i = 0; i < 5; i++) {
38 if (d <= ZONE_CM[i]) z = i + 1;
39 }
40 return z;
41}
42
43void updateLeds() {
44 for (int i = 0; i < 5; i++) {
45 digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW); // bölge kadar LED yak / light as many LEDs as the zone
46 }
47}
48
49void updateBuzzer(unsigned long now) {
50 if (zone == 0) { // güvenli bölge: sessiz / safe zone: silent
51 digitalWrite(BUZZER_PIN, LOW);
52 return;
53 }
54 unsigned int period = BEEP_MS[zone - 1];
55 if (period == 0) { // dur bölgesi: sürekli ses / stop zone: continuous tone
56 digitalWrite(BUZZER_PIN, HIGH);
57 return;
58 }
59 if (now - lastBeep >= period) lastBeep = now; // yeni bip zamanı / time for a new beep
60 digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
61}
62
63void setup() {
64 pinMode(TRIG_PIN, OUTPUT);
65 pinMode(ECHO_PIN, INPUT);
66 pinMode(BUZZER_PIN, OUTPUT);
67 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
68 Serial.begin(115200);
69}
70
71void loop() {
72 unsigned long now = millis();
73 if (now - lastMeasure >= MEASURE_MS) { // 60 ms'de bir ölç / measure every 60 ms
74 lastMeasure = now;
75 samples[sampleIndex] = readDistanceCm();
76 sampleIndex = (sampleIndex + 1) % 3;
77 distanceCm = median3(samples[0], samples[1], samples[2]);
78 zone = zoneFor(distanceCm);
79 updateLeds();
80 Serial.print(F("Mesafe / Distance: "));
81 Serial.print(distanceCm);
82 Serial.print(F(" cm Bolge / Zone: "));
83 Serial.println(zone);
84 }
85 updateBuzzer(millis()); // bip, ölçümden bağımsız akar / beeping runs independently of measuring
86}| Parte del código | Qué hace |
|---|---|
| ZONE_CM y BEEP_MS | Guardan los límites de zona y los intervalos de pitido en un solo lugar; para cambiar la tabla solo editas estas dos líneas. |
| pulseIn(..., 25000UL) | Espera el eco como máximo 25 ms (unos 4,3 m). Si no llega, devuelve 0 y el código lo interpreta como 999, es decir, sin obstáculo. |
| us / 58 | Convierte el tiempo de ida y vuelta en centímetros. |
| median3() | Toma la mediana de las tres últimas lecturas; una sola lectura errónea no altera los LEDs ni el sonido. |
| now - lastBeep >= period | Revisa si ya toca un nuevo pitido; el buzzer está encendido los primeros 50 ms de cada pitido y apagado el resto. |
| MEASURE_MS = 60 | El ciclo de medición más corto recomendado para el HC-SR04; si mides más rápido, puedes confundir un eco tardío de la medición anterior con uno nuevo. |
Precisión de la medición: efecto de la temperatura y la superficie
El número 58 del código supone que la velocidad del sonido es de unos 345 m/s, o sea, que el aire está a unos 22 °C. Pero la velocidad del sonido cambia con la temperatura: v = 331,3 + 0,606 × T (m/s, T en °C). En invierno, a 0 °C, el sonido es más lento, el eco vuelve más tarde y el sensor cree que el obstáculo está un poco más lejos de lo que está. Con una distancia real de 100 cm, las lecturas son aproximadamente:
| Temperatura del aire | Velocidad del sonido | Lectura (tiempo ÷ 58) |
|---|---|---|
| -10 °C | 325 m/s | Unos 106 cm |
| 0 °C | 331 m/s | Unos 104 cm |
| 10 °C | 337 m/s | Unos 102 cm |
| 20 °C | 343 m/s | Unos 100 cm |
| 30 °C | 350 m/s | Unos 99 cm |
| 40 °C | 356 m/s | Unos 97 cm |
Al estacionarte, unos pocos centímetros no importan. Aun así, si quieres el mismo punto de alto en una cochera a 40 °C en verano y bajo cero en invierno, puedes medir la temperatura con un DHT11 o un DS18B20 y calcular la distancia con tiempo × (331,3 + 0,606 × T) / 20000. La superficie influye mucho más que la temperatura: una pared lisa, un portón o la defensa de otro auto reflejan bien el sonido, mientras que un poste delgado, una malla de alambre, un arbusto o superficies blandas como la tela debilitan el eco o no lo devuelven. Una superficie inclinada respecto al sensor además desvía el sonido hacia otro lado. Por eso un sensor de estacionamiento ultrasónico nunca debe ser tu única medida de seguridad.
Mostrar la distancia en una pantalla OLED
Para un indicador que el conductor pueda ver, la pantalla OLED de 0,96 pulgadas es ideal: muestra la distancia con números grandes y debajo dibuja una barra que se llena a medida que el obstáculo se acerca. Explicamos con detalle la conexión I2C de la pantalla y la instalación de las librerías Adafruit SSD1306 y Adafruit GFX en pantalla OLED SSD1306. La pantalla se actualiza cinco veces por segundo; cada actualización tarda unos 25–30 ms, así que dibujar más seguido arruinaría la medición y el ritmo del pitido.
1// Park sensörü + 0,96" OLED: büyük rakamla mesafe ve doluluk çubuğu / parking sensor + 0.96" OLED: big distance digits and a fill bar
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1); // 128x64, reset pini yok / 128x64, no reset pin
7
8const int TRIG_PIN = 9;
9const int ECHO_PIN = 10;
10const int BUZZER_PIN = 8;
11const int LED_PINS[5] = {2, 3, 4, 5, 6};
12const int ZONE_CM[5] = {150, 100, 70, 45, 25};
13const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
14const unsigned int BEEP_ON_MS = 50;
15const int MAX_SHOW_CM = 200; // çubuğun boş olduğu mesafe / distance where the bar is empty
16
17unsigned long lastMeasure = 0, lastBeep = 0, lastDraw = 0;
18int samples[3] = {999, 999, 999};
19int sampleIndex = 0;
20int distanceCm = 999;
21int zone = 0;
22
23long readDistanceCm() {
24 digitalWrite(TRIG_PIN, LOW);
25 delayMicroseconds(2);
26 digitalWrite(TRIG_PIN, HIGH);
27 delayMicroseconds(10);
28 digitalWrite(TRIG_PIN, LOW);
29 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
30 return us == 0 ? 999 : us / 58;
31}
32
33int median3(int a, int b, int c) {
34 return max(min(a, b), min(max(a, b), c));
35}
36
37void drawScreen() {
38 display.clearDisplay();
39 display.setTextSize(1);
40 display.setCursor(0, 0);
41 if (zone == 5) display.print(F("DUR / STOP"));
42 else if (zone == 0) display.print(F("Yol acik / Clear"));
43 else display.print(F("Yaklasiyor / Closer"));
44
45 display.setTextSize(3); // büyük rakamlar / big digits
46 display.setCursor(0, 18);
47 if (distanceCm >= 999) display.print(F("---"));
48 else display.print(distanceCm);
49 display.setTextSize(2);
50 display.print(F(" cm"));
51
52 // Yaklaştıkça dolan çubuk / a bar that fills as you get closer
53 int d = constrain(distanceCm, 0, MAX_SHOW_CM);
54 int fill = map(d, MAX_SHOW_CM, 0, 0, 124);
55 display.drawRect(0, 50, 128, 12, SSD1306_WHITE);
56 display.fillRect(2, 52, fill, 8, SSD1306_WHITE);
57 display.display();
58}
59
60void setup() {
61 pinMode(TRIG_PIN, OUTPUT);
62 pinMode(ECHO_PIN, INPUT);
63 pinMode(BUZZER_PIN, OUTPUT);
64 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
65 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // OLED adresi genelde 0x3C / OLED address is usually 0x3C
66 for (;;); // ekran yoksa dur / stop if no display
67 }
68 display.setTextColor(SSD1306_WHITE);
69}
70
71void loop() {
72 unsigned long now = millis();
73 if (now - lastMeasure >= 60) {
74 lastMeasure = now;
75 samples[sampleIndex] = readDistanceCm();
76 sampleIndex = (sampleIndex + 1) % 3;
77 distanceCm = median3(samples[0], samples[1], samples[2]);
78 zone = 0;
79 for (int i = 0; i < 5; i++) if (distanceCm <= ZONE_CM[i]) zone = i + 1;
80 for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
81 }
82 if (now - lastDraw >= 200) { // ekranı saniyede 5 kez yenile / refresh the screen 5 times a second
83 lastDraw = now;
84 drawScreen();
85 }
86 now = millis();
87 if (zone == 0) {
88 digitalWrite(BUZZER_PIN, LOW);
89 } else if (BEEP_MS[zone - 1] == 0) {
90 digitalWrite(BUZZER_PIN, HIGH);
91 } else {
92 if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
93 digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
94 }
95}Según la zona, la línea superior muestra Yol acik / Clear, Yaklasiyor / Closer o DUR / STOP. Los textos son bilingües (turco / inglés) y van sin tildes ni ñ, porque la fuente por defecto de la librería OLED solo trae caracteres ASCII básicos. Cerca de 1 KB de los 2 KB de RAM del Uno se va al búfer de la pantalla; cuando amplíes el código, sigue poniendo los textos fijos dentro de F(), o la pantalla podría no arrancar.
Sensor de estacionamiento con ESP32
La versión para ESP32 tiene tres diferencias. Primero, el sensor se sigue alimentando con 5 V, pero el pin ECHO pasa por el divisor de voltaje. Segundo, usamos un buzzer pasivo en lugar de uno activo y generamos el sonido como un tono de 2,5 kHz con el hardware LEDC del ESP32; cambiando la frecuencia eliges tú el sonido. Tercero, agregamos 3 cm de histéresis para que los LEDs no parpadeen en el límite de una zona: cuando el auto se aleja, la distancia tiene que superar el límite por 3 cm antes de bajar de zona. Como las funciones LEDC cambiaron en la versión 3.x del core de Arduino para ESP32, el código revisa ESP_ARDUINO_VERSION_MAJOR y compila tanto en 2.x como en 3.x.
1// ESP32 park sensörü: HC-SR04 + 5 LED + pasif buzzer (LEDC), çekirdek 2.x ve 3.x / ESP32 parking sensor: HC-SR04 + 5 LEDs + passive buzzer (LEDC), core 2.x and 3.x
2const int TRIG_PIN = 4;
3const int ECHO_PIN = 18; // 1 kΩ + 2 kΩ gerilim bölücüyle / through a 1 kΩ + 2 kΩ divider
4const int BUZZER_PIN = 19;
5const int LED_PINS[5] = {25, 26, 27, 32, 33};
6const int ZONE_CM[5] = {150, 100, 70, 45, 25};
7const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
8const unsigned int BEEP_ON_MS = 50;
9const unsigned int TONE_HZ = 2500; // pasif buzzerın en yüksek sesi genelde 2–4 kHz / passive buzzers are loudest around 2–4 kHz
10const int HYST_CM = 3; // bölge sınırında titremeyi önler / stops flicker at zone limits
11const int BUZZER_CH = 0; // yalnız 2.x için LEDC kanalı / LEDC channel, 2.x only
12
13unsigned long lastMeasure = 0, lastBeep = 0;
14int samples[3] = {999, 999, 999};
15int sampleIndex = 0;
16int distanceCm = 999;
17int zone = 0;
18bool buzzerOn = false;
19
20void buzzer(bool on) {
21 if (on == buzzerOn) return; // yalnız değişince yaz / write only on change
22 buzzerOn = on;
23#if ESP_ARDUINO_VERSION_MAJOR >= 3
24 ledcWriteTone(BUZZER_PIN, on ? TONE_HZ : 0); // 3.x: pin numarasıyla / 3.x: by pin number
25#else
26 ledcWriteTone(BUZZER_CH, on ? TONE_HZ : 0); // 2.x: kanal numarasıyla / 2.x: by channel number
27#endif
28}
29
30long readDistanceCm() {
31 digitalWrite(TRIG_PIN, LOW);
32 delayMicroseconds(2);
33 digitalWrite(TRIG_PIN, HIGH);
34 delayMicroseconds(10);
35 digitalWrite(TRIG_PIN, LOW);
36 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
37 return us == 0 ? 999 : us / 58;
38}
39
40int median3(int a, int b, int c) {
41 return max(min(a, b), min(max(a, b), c));
42}
43
44int zoneFor(int d, int current) {
45 int z = 0;
46 for (int i = 0; i < 5; i++) if (d <= ZONE_CM[i]) z = i + 1;
47 if (current > 0 && z < current && d <= ZONE_CM[current - 1] + HYST_CM) z = current; // uzaklaşırken 3 cm pay / 3 cm margin when moving away
48 return z;
49}
50
51void setup() {
52 Serial.begin(115200);
53 pinMode(TRIG_PIN, OUTPUT);
54 pinMode(ECHO_PIN, INPUT);
55 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
56#if ESP_ARDUINO_VERSION_MAJOR >= 3
57 ledcAttach(BUZZER_PIN, TONE_HZ, 8); // 3.x: pin, frekans, çözünürlük / 3.x: pin, frequency, resolution
58#else
59 ledcSetup(BUZZER_CH, TONE_HZ, 8); // 2.x: kanal kur, sonra pine bağla / 2.x: set up a channel, then attach the pin
60 ledcAttachPin(BUZZER_PIN, BUZZER_CH);
61#endif
62 buzzerOn = true;
63 buzzer(false); // sessiz başla / start silent
64}
65
66void loop() {
67 unsigned long now = millis();
68 if (now - lastMeasure >= 60) {
69 lastMeasure = now;
70 samples[sampleIndex] = readDistanceCm();
71 sampleIndex = (sampleIndex + 1) % 3;
72 distanceCm = median3(samples[0], samples[1], samples[2]);
73 zone = zoneFor(distanceCm, zone);
74 for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
75 Serial.printf("Mesafe / Distance: %d cm Bolge / Zone: %d\n", distanceCm, zone);
76 }
77 now = millis();
78 if (zone == 0) {
79 buzzer(false);
80 } else if (BEEP_MS[zone - 1] == 0) {
81 buzzer(true);
82 } else {
83 if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
84 buzzer(now - lastBeep < BEEP_ON_MS);
85 }
86}Consejos para instalarlo en el auto o en la cochera
- Altura y ángulo: Coloca el sensor a 50–70 cm del piso, paralelo a él e inclinado 3–5 grados hacia arriba. Un sensor que apunta hacia abajo confunde los topes y la orilla de la banqueta con obstáculos.
- Agua y polvo: El HC-SR04 no es a prueba de agua; la lluvia, el lodo y el autolavado lo dañan en poco tiempo. Para un sistema montado en la defensa usa una sonda ultrasónica impermeable como el JSN-SR04T. Estas sondas miden a partir de 20–25 cm, así que tendrás que llevar la zona de alto a 30–35 cm.
- Alimentación: El sistema eléctrico del auto sube a 13,8–14,4 V con el motor encendido, cae de golpe al dar marcha y tiene picos cuando se desconecta una carga. No alimentes el Arduino directo de 12 V: baja el voltaje a 5 V con un regulador reductor como el LM2596 y protégelo con un fusible de 1 A. Si tomas la alimentación del circuito de la luz de reversa, el sistema solo funcionará con la reversa metida.
- Cables: Puedes poner el sensor en la defensa, el Arduino en la cajuela (maletero) y el buzzer y la barra de LEDs donde el conductor los vea. Para cables de TRIG y ECHO de más de 3–4 metros usa cable trenzado y agrega un capacitor de 100 nF entre VCC y GND del sensor.
- Varios sensores: Los autos reales suelen llevar 3–4 sensores en la defensa trasera. Si disparas dos HC-SR04 al mismo tiempo, uno escucha el eco del otro; mídelos uno tras otro con al menos 30–60 ms entre ellos y avisa al conductor la distancia más corta.
- Versión para la pared de la cochera: Si no quieres tocar el auto, monta el sensor en la pared del fondo de la cochera, a la altura de la defensa. Al entrar, la barra de LEDs pasa de verde a rojo como un semáforo; es la ayuda para estacionarse más fácil y segura de todas.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| La distancia siempre es 999 o no cambia | TRIG y ECHO invertidos, VCC no es de 5 V o un cable está flojo | Compara los pines con la tabla de conexión y alimenta el sensor desde 5V |
| Los valores brincan al azar | Superficie blanda o inclinada, protoboard floja, mediciones demasiado seguidas | Usa el filtro de mediana y deja al menos 60 ms entre mediciones |
| La distancia se congela mientras pita | Hay un delay() en el código | Genera el pitido con millis() y usa el código de este artículo |
| El buzzer chisporrotea o no suena | Código para buzzer activo usado con uno pasivo, o al revés | Usa buzzer activo con el código del Uno y pasivo con el del ESP32 |
| Los LEDs parpadean en el límite de una zona | La distancia oscila justo en el límite | Agrega también al código del Uno la histéresis de 3 cm del código ESP32 |
| El ESP32 no lee ninguna distancia | Sensor alimentado con 3,3 V o divisor conectado al revés | Conecta VCC a VIN y verifica que la resistencia de 2 kΩ esté del lado de GND |
| En la mesa funciona, en el auto da falsas alarmas | El sensor ve el piso, la placa o el enganche de remolque | Sube el sensor e inclínalo 3–5 grados hacia arriba |
| El buzzer suena muy bajito | El pin no da suficiente corriente | Maneja el buzzer con un transistor NPN como el BC547 |
Proyectos para después del sensor de estacionamiento
- Indicador de colores para la cochera: Usa un anillo WS2812B NeoPixel en lugar de la barra de LEDs, que se llene de verde a rojo a medida que el auto se acerca.
- Sistema de ocupación de estacionamiento: Arma un estacionamiento inteligente con Arduino que ponga un sensor en cada cajón y cuente los lugares libres.
- Radar ultrasónico: Haz un radar con Arduino que gire el sensor sobre un servo para escanear los alrededores.
- Robot que esquiva obstáculos: Combina la misma medición de distancia con el control de motores para hacer un robot que esquiva obstáculos.
- Medición precisa a corta distancia: Para ajustar el punto de alto al milímetro, prueba el sensor láser de distancia VL53L0X; las diferencias están en nuestra comparativa de sensores de distancia.
Como un sensor de estacionamiento con Arduino junta sonido, luz y medición en un solo proyecto, es una gran opción tanto para tu primer proyecto serio como para una feria de ciencias. Ajusta la tabla de zonas a tu auto, prueba primero el sistema en la cochera y luego da un paso más con los consejos de instalación. En la app BlueGrays encontrarás el diagrama de conexión paso a paso y el código listo de este mismo circuito en los proyectos de sensor de estacionamiento con HC-SR04 y con ESP32.
Preguntas frecuentes
¿Cómo hacer un sensor de estacionamiento con Arduino?
Necesitas un sensor ultrasónico HC-SR04, un buzzer y algunos LEDs. El Arduino mide el tiempo del eco cada 60 ms, lo convierte a centímetros con tiempo / 58 y, según la distancia, elige una zona que define el ritmo del pitido y cuántos LEDs se encienden. Usar millis() en lugar de delay() hace que la medición siga corriendo mientras pita.
¿Qué alcance tiene el sensor ultrasónico HC-SR04?
Según su hoja de datos mide de 2 a 400 cm, pero sobre una superficie plana y grande el rango confiable ronda los 3–250 cm. Para estacionarse basta con empezar a avisar a 150 cm. Los postes delgados y las superficies blandas pueden pasar desapercibidos incluso a menor distancia.
¿El HC-SR04 es a prueba de agua? ¿Lo puedo poner en la defensa?
No, el HC-SR04 no resiste el agua ni el polvo y dura poco con la lluvia y el autolavado. Para instalarlo por fuera del auto conviene una sonda impermeable como el JSN-SR04T, que mide desde unos 20–25 cm. Si solo lo necesitas en la cochera, lo más fácil es montarlo en la pared.
¿Qué buzzer uso, activo o pasivo?
El buzzer activo tiene su propio oscilador: suena al recibir 5 V y se maneja con digitalWrite, por eso el código del Uno está hecho para él. El pasivo necesita una frecuencia con tone() o, en el ESP32, con LEDC, pero te deja elegir el tono. Para saber cuál tienes, conéctalo a 5 V: el que suena solo es el activo.
¿Cómo alimento el Arduino con los 12 V del auto?
El sistema eléctrico del auto llega a 14,4 V con el motor encendido y tiene picos de voltaje, así que lo más seguro es bajarlo a 5 V con un regulador reductor como el LM2596. Agrega un fusible de 1 A. Si lo conectas a la luz de reversa, el sensor solo funcionará cuando metas la reversa.
¿Puedo usar varios sensores ultrasónicos al mismo tiempo?
Sí, pero si disparan en el mismo instante pueden escuchar el eco de los otros. Mide los sensores uno tras otro, con al menos 30–60 ms entre ellos, y muestra la distancia más corta. Cada sensor solo necesita sus propios pines TRIG y ECHO.
Proyectos para hacer después de leer esto
Ver todos los proyectos
HC-SR04 Medición de distancia (pantalla en serie)
El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Sensor de aparcamiento con HC-SR04
Una versión en miniatura del sensor de aparcamiento de los coches: cuanto más se acerca algo, más rápidos son los pitidos.

Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)
¡La versión ESP32 de un sensor de aparcamiento! El sensor ultrasónico HC-SR04 mide la distancia al objeto que tiene delante. Cuanto más cerca está, más se llena una barra de 5 LED (verde → amarillo → rojo) y más rápido pita el zumbador. Muy cerca (por debajo de 10 cm) suena una alarma continua y se encienden todos los LED. La OLED SSD1306 muestra los cm en tiempo real con letra grande y un texto de estado.

ESP32 HC-SR04 Medidor de distancia por ultrasonidos
El sensor ultrasónico HC-SR04 mide la distancia según el tiempo que tarda su pulso de sonido en rebotar en un objeto y volver (tiempo de vuelo). El ESP32 envía un pulso de 10 microsegundos al pin TRIG y lee el tiempo del eco en ECHO con pulseIn(). La distancia se muestra en cm en una LCD I2C de 16x2. El HC-SR04 funciona a 5 V, así que ECHO necesita un divisor de tensión; si no, el GPIO de 3,3 V del ESP32 se daña.

Medición de distancias mediante pantalla LCD
Un aparato que mide distancias sin regla: mueve la mano delante del sensor y mira cómo cambia el número.

Robot para evitar obstáculos
¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

Proyecto de medición de la altura
Un medidor de altura que se cuelga del marco de la puerta y te dice en centímetros cuánto mide quien está debajo.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

