Guías · 12 min de lectura

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.

Sensor ultrasónico de distancia HC-SR04
HC-SR04: uno de los cilindros emite una onda de sonido de 40 kHz y el otro escucha el eco. Estos dos cilindros son los ojos del sensor de estacionamiento.

¿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ísticaValor
Alimentación5 V, unos 15 mA
Frecuencia del sonido40 kHz
Rango de medición2–400 cm (rango confiable para estacionarse: 3–250 cm)
Ángulo de detecciónUn cono de unos 15°
Pulso de disparoAl menos 10 µs en HIGH en TRIG
Frecuencia de mediciónAl menos 60 ms entre dos mediciones
ResoluciónUnos 3 mm

Lista de materiales

MaterialCantidadNota
Arduino Uno o Nano1La versión ESP32 está más abajo
Sensor ultrasónico HC-SR041Fuera del auto, mejor el JSN-SR04T a prueba de agua
Buzzer activo1En la versión ESP32, buzzer pasivo
LEDs (2 verdes, 2 amarillos, 1 rojo)5En fila, como barra de LEDs
Resistencia de 220 Ω5Una por LED
Pantalla OLED I2C de 0,96 pulgadas1Indicador opcional
Protoboard y cables jumper (dupont)1 juegoUsa cables cortos
Resistencias de 1 kΩ y 2 kΩUna de cada unaSolo 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:

ZonaDistanciaIntervalo de pitidoLEDs encendidosSignificado
SeguraMás de 150 cmSilencioNingunoVía libre
1101–150 cm800 ms1 verdeObstáculo detectado
271–100 cm500 ms2 verdesMás despacio
346–70 cm300 ms2 verdes + 1 amarilloAtención
426–45 cm150 ms2 verdes + 2 amarillosMuy cerca
525 cm o menosTono continuoLos 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 pinArduino UnoESP32Nota
HC-SR04 VCC5VVIN (5V)El sensor necesita 5 V
HC-SR04 GNDGNDGNDTierra común
HC-SR04 TRIGD9GPIO 4Salida de disparo
HC-SR04 ECHOD10GPIO 18En el ESP32, con divisor de 1 kΩ + 2 kΩ
Buzzer (+)D8GPIO 19Activo en el Uno, pasivo en el ESP32
LED 1 y 2 (verdes)D2, D3GPIO 25, 26Resistencia de 220 Ω en serie con cada LED
LED 3 y 4 (amarillos)D4, D5GPIO 27, 32Resistencia de 220 Ω en serie con cada LED
LED 5 (rojo)D6GPIO 33Se enciende en la zona de alto
OLED SDA / SCLA4 / A5GPIO 21 / 22Opcional
OLED VCC5V3V3Revisa el orden de pines del módulo
El pin ECHO del HC-SR04 entrega 5 V. Para el Arduino Uno no hay problema, pero los pines del ESP32 solo toleran 3,3 V. Pon una resistencia de 1 kΩ entre ECHO y GPIO 18 y otra de 2 kΩ entre GPIO 18 y GND: 5 V × 2 / 3 ≈ 3,3 V. Puedes comprobar los valores con la herramienta Divisor de voltaje. Tampoco olvides las resistencias en serie de los LEDs: 220 Ω dan unos 13 mA a 5 V; para tus propios LEDs puedes usar la herramienta Resistencia para LED.

¿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

  1. Coloca el HC-SR04 en un extremo de la protoboard con los cilindros hacia afuera; conecta VCC a 5V y GND a GND.
  2. Conecta TRIG a D9 y ECHO a D10. Usa cables cortos; un jumper flojo arruina las lecturas al azar.
  3. 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.
  4. 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.
  5. 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.
  6. 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():

C++ (Arduino IDE)
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ódigoQué hace
ZONE_CM y BEEP_MSGuardan 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 / 58Convierte 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 >= periodRevisa si ya toca un nuevo pitido; el buzzer está encendido los primeros 50 ms de cada pitido y apagado el resto.
MEASURE_MS = 60El 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.
¿Por qué un filtro de mediana es mejor que un promedio? Si tres lecturas dan 82, 83 y 3 cm, el promedio es 56 cm y el sistema salta por error a la zona tres. La mediana es 82 cm; un valor absurdo aislado simplemente se ignora. Puedes comparar distintos tipos de filtro en filtrar datos de sensores.

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 aireVelocidad del sonidoLectura (tiempo ÷ 58)
-10 °C325 m/sUnos 106 cm
0 °C331 m/sUnos 104 cm
10 °C337 m/sUnos 102 cm
20 °C343 m/sUnos 100 cm
30 °C350 m/sUnos 99 cm
40 °C356 m/sUnos 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
Los pines GPIO 34–39 del ESP32 son solo de entrada; si conectas ahí TRIG o los LEDs no pasará nada, aunque sí sirven para ECHO. Si el sonido no es lo bastante fuerte, prueba valores de TONE_HZ entre 2000 y 4000; cada buzzer pasivo tiene una frecuencia en la que suena más fuerte. Si apenas conoces el ESP32, ¿Qué es el ESP32? es un buen punto de partida.

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.
Este proyecto es para aprender y experimentar, no reemplaza los sistemas de seguridad del auto. Antes de trabajar en la instalación eléctrica del vehículo, desconecta el borne negativo de la batería y mantén los cables lejos de las piezas móviles y del escape. Sigue usando los espejos y voltea a ver hacia atrás por si hay obstáculos que el sensor no detecta, como postes delgados, niños o mascotas.

Errores comunes y soluciones

SíntomaCausa probableSolución
La distancia siempre es 999 o no cambiaTRIG y ECHO invertidos, VCC no es de 5 V o un cable está flojoCompara los pines con la tabla de conexión y alimenta el sensor desde 5V
Los valores brincan al azarSuperficie blanda o inclinada, protoboard floja, mediciones demasiado seguidasUsa el filtro de mediana y deja al menos 60 ms entre mediciones
La distancia se congela mientras pitaHay un delay() en el códigoGenera el pitido con millis() y usa el código de este artículo
El buzzer chisporrotea o no suenaCódigo para buzzer activo usado con uno pasivo, o al revésUsa buzzer activo con el código del Uno y pasivo con el del ESP32
Los LEDs parpadean en el límite de una zonaLa distancia oscila justo en el límiteAgrega también al código del Uno la histéresis de 3 cm del código ESP32
El ESP32 no lee ninguna distanciaSensor alimentado con 3,3 V o divisor conectado al revésConecta 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 alarmasEl sensor ve el piso, la placa o el enganche de remolqueSube el sensor e inclínalo 3–5 grados hacia arriba
El buzzer suena muy bajitoEl pin no da suficiente corrienteManeja el buzzer con un transistor NPN como el BC547
Después de cada cambio, haz siempre la misma prueba: mueve la caja a las marcas de 150, 100, 70, 45 y 25 cm y compara el número de zona del Monitor Serie con la tabla. Si coincide en todos los puntos, tu sistema está listo. Encontrarás los detalles del sensor y un primer código de distancia en sensor de distancia HC-SR04, y los tipos de buzzer en ¿Qué es un buzzer?.

Proyectos para después del sensor de estacionamiento

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.

Ver todos los proyectos
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

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.

4.6(50)
82
Uso del zumbador
AR-13Principiante

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.

4.7(92)
170
Sensor de aparcamiento con HC-SR04
AR-28Intermedio
Premium

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.

4.8(64)
86
Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)
ES-38Avanzado
Premium

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.

14
ESP32 HC-SR04 Medidor de distancia por ultrasonidos
ES-14Intermedio

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.

4.9(29)
48
Medición de distancias mediante pantalla LCD
AR-31Avanzado
Premium

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.

4.6(45)
59
Robot para evitar obstáculos
AR-81Avanzado
Premium

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.

5.0(38)
49
Proyecto de medición de la altura
AR-33Intermedio
Premium

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.

4.5(25)
34