Guías · 11 min de lectura

Sistema de Estacionamiento con Arduino: Barrera y Plazas Libres

Cómo hacer un sistema de estacionamiento con Arduino: sensores HC-SR04 e infrarrojos, barrera con servo SG90, plazas libres en LCD I2C y código para Uno y ESP32.

Un sistema de estacionamiento con Arduino es una maqueta que detecta con sensores si las plazas están ocupadas o libres, abre y cierra la barrera de entrada con un servomotor y muestra en una pantalla LCD cuántas plazas quedan. Construyes sobre tu mesa una pequeña copia de esos carteles de "Plazas libres: 12" que ves en los parkings de los centros comerciales. El proyecto reúne medición de distancia, lectura de entradas digitales, control de servo y uso de pantalla en un solo circuito, así que sirve tanto como primer proyecto grande como para una presentación escolar o una feria de ciencias.

En esta guía montarás de principio a fin una maqueta con cuatro plazas: un sensor infrarrojo en cada plaza, un sensor ultrasónico HC-SR04 en la entrada que abre la barrera cuando se acerca un coche, otro sensor en la salida, una barrera con servo SG90 y un LCD I2C de 16x2. Primero analizaremos el código para Arduino Uno línea a línea, después pasaremos el mismo sistema al ESP32 con un panel web que puedes ver desde el móvil y, por último, escribiremos la versión MicroPython para Raspberry Pi Pico. Al final encontrarás las medidas de la maqueta y consejos para presentarla.

Sensor de distancia ultrasónico HC-SR04
El HC-SR04 detecta un coche que se acerca a la entrada en un rango de 2 a 400 cm; para la maqueta basta un umbral de 8 cm.

¿Qué es un sistema de estacionamiento con Arduino y cómo funciona?

El sistema hace tres tareas a la vez. La primera es el control de ocupación: el sensor colocado junto a cada plaza o en su suelo informa continuamente de si hay un coche; Arduino cuenta las plazas ocupadas y las resta del total. La segunda es el control de la barrera: cuando el sensor de la entrada ve un coche y hay plazas libres, la barrera sube 90 grados y baja unos segundos después de que el coche pase; si el parking está lleno, la barrera se queda cerrada y se enciende el LED rojo. Para un coche que sale, la barrera siempre se abre. La tercera es la información: en la primera línea del LCD aparece "Bos yer: 3/4" y en la segunda el estado de cada plaza. Como calculamos las plazas libres directamente con los sensores de cada plaza y no contando entradas y salidas, aunque un sensor se pierda un coche el contador no se desajusta de forma permanente; es un método mucho más fiable que los proyectos sencillos basados en contar entradas y salidas.

TareaComponenteQué hace
Ocupación de plazas4 sensores infrarrojos de obstáculos (módulo FC-51 o TCRT5000)Si hay un coche, el pin OUT pasa a LOW
Detección en la entradaSensor ultrasónico HC-SR04Mide la distancia al coche en cm
Detección en la salida1 sensor infrarrojo de obstáculosDetecta el coche que sale
BarreraServomotor SG90 + palo de helado0° cerrada, 90° abierta
Pantalla de informaciónLCD I2C de 16x2Plazas libres y estado de cada plaza
Luz de estadoLED verde y rojoHay sitio / parking lleno

Lista de materiales

MaterialCantidadNota
Arduino Uno (o Nano)1Las versiones ESP32 y Pico van más abajo
Sensor de distancia HC-SR041Funciona a 5 V
Sensor infrarrojo de obstáculos (módulo FC-51 / TCRT5000)54 plazas + 1 salida
Servomotor SG901Para el brazo de la barrera
LCD 16x2 + módulo I2C1La dirección suele ser 0x27 o 0x3F
LED verde y rojo2Resistencia de 220 Ω para cada uno
Protoboard y cables jumper1 juegoLos cables macho-hembra son prácticos para los sensores
Adaptador externo de 5 V (2 A)1Recomendado para el servo y los sensores
Material para la maqueta-Cartón pluma, cartulina, coches de juguete, cinta de colores

¿HC-SR04 o sensor infrarrojo?

Puedes detectar la ocupación de una plaza de dos formas. El HC-SR04 mide el coche con ondas de sonido; si pones uno en cada plaza, gastas dos pines por sensor (TRIG y ECHO) y cuatro plazas consumen ocho pines. Además, si los sensores miden a la vez pueden captar el eco de los demás, por lo que hay que dispararlos por turnos. Los sensores infrarrojos de obstáculos, en cambio, dan una sola salida digital, son baratos y la distancia de detección se ajusta con el pequeño potenciómetro de la placa. Por eso la solución más equilibrada es usar sensores infrarrojos en las plazas y el HC-SR04 en la entrada, que da la distancia como número. Encontrarás más diferencias entre tipos de sensores en la comparativa de sensores de distancia.

CaracterísticaHC-SR04Sensor de obstáculos FC-51Módulo TCRT5000
Rango de detección2–400 cmAprox. 2–30 cm (ajustable)Aprox. 1–25 mm
SalidaDuración de pulso (se mide)Digital (LOW = obstáculo)Digital + analógica
Pines usados211
Alimentación5 V3,3–5 V3,3–5 V
Punto débilSuperficies blandas e inclinadasLuz solar, superficie negraAlcance muy corto, superficie negra
Mejor lugar en el parkingBarrera de entradaBorde trasero de la plazaSuelo de la plaza
Servomotor SG90
Pegando un palo de helado en su brazo, el servo SG90 se convierte en la barrera del parking de maqueta.

Esquema de conexión y tabla de pines

ConexiónArduino UnoESP32Raspberry Pi Pico
Sensores de plazas 1–4 (OUT)D2, D3, D4, D5GPIO 32, 33, 25, 26GP2, GP3, GP4, GP5
Sensor de salida (OUT)D6GPIO 27GP6
HC-SR04 TRIGD7GPIO 23GP16
HC-SR04 ECHOD8GPIO 18 (con divisor de tensión)GP17 (con divisor de tensión)
Señal del servo (cable naranja)D9GPIO 13GP15
LED verde / rojo (con 220 Ω)D10 / D11No se usaNo se usa
LCD I2C SDA / SCLA4 / A5No se usaNo se usa
AlimentaciónSensores a 5V, servo con 5 V externosHC-SR04 y servo a 5V/VIN, sensores IR a 3V3HC-SR04 y servo a VBUS, sensores IR a 3V3(OUT)
Alimentar a la vez el servo, los cinco sensores y el LCD desde el pin 5V de Arduino es el error más habitual. El SG90 puede consumir cerca de 500 mA de golpe cuando mueve el brazo; la tensión del USB cae, el LCD se apaga y Arduino se reinicia. Alimenta el servo con un adaptador externo de 5 V y conecta siempre el GND del adaptador al GND de Arduino; sin masa común la señal del servo no tiene sentido.

Ajusta el potenciómetro azul de los sensores infrarrojos para que el LED del sensor se encienda cuando el coche de juguete esté en la plaza y se apague cuando lo retires. En Arduino Uno basta una resistencia de 220 Ω para los LED; si usas un LED de otro color o con otra tensión, calcula el valor con la calculadora de resistencia para LED. Puedes consultar rápido la distribución de pines de las placas en la herramienta de pinout. Los detalles de conexión del LCD I2C y el código para escanear direcciones están en el artículo sobre la pantalla LCD I2C.

Construcción de la maqueta paso a paso

  1. Coge un cartón pluma o una cartulina gruesa de unos 40×30 cm; ese tamaño basta para cuatro plazas, el camino de entrada y el compartimento de la electrónica.
  2. Mide tu coche de juguete y dibuja cada plaza con un ancho de unas 1,5 veces el del coche; para un coche a escala 1:43 sirven espacios de 6×11 cm. Marca las líneas con cinta blanca o amarilla.
  3. En el borde trasero de cada plaza coloca el sensor FC-51 mirando hacia el coche, o haz un pequeño agujero en el suelo y encaja el TCRT5000 mirando hacia arriba. Pasa los cables por debajo del cartón.
  4. Junto al camino de entrada coloca el HC-SR04 apuntando al centro del camino, de 5 a 10 cm antes de la barrera. En el carril de salida pon el quinto sensor infrarrojo.
  5. Fija el SG90 con silicona caliente dentro de una pequeña caseta recortada en espuma y pega un palo de helado pintado en el brazo del servo. Antes de montar el brazo, lleva el servo a 0 grados y coloca después el palo en horizontal.
  6. Coloca el LCD y los LED en un panel de señalización que el conductor vea desde la entrada; esconde Arduino y la protoboard en el compartimento de detrás o de debajo del cartón.
  7. Compara cada conexión con la tabla de pines; primero prueba solo los sensores en el Monitor Serie y después añade el servo y el LCD.
Los sensores infrarrojos no ven bien las superficies negras porque la pintura negra absorbe la luz infrarroja. Si tienes un coche de juguete negro, pega un trocito de cinta blanca debajo o en la cara que mira al sensor; la detección mejora al instante. Evita también usar la maqueta junto a una ventana: la luz del sol engaña a los sensores infrarrojos.

Código de Arduino Uno para el parking

Para el código solo necesitas instalar la biblioteca LiquidCrystal I2C (Frank de Brabander) desde el Gestor de bibliotecas; Servo y Wire vienen con el Arduino IDE. Si el LCD no muestra nada, cambia la dirección 0x27 del código por 0x3F. El programa no usa un delay largo para mantener la barrera abierta, sino que cuenta el tiempo con millis; así sigue leyendo los sensores aunque la barrera esté levantada. Como la biblioteca Servo usa el Timer1 en el Uno, analogWrite no funciona en D9 y D10; como los LED solo se encienden y se apagan, no supone ningún problema.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Servo.h>
4
5const byte SPOT_COUNT = 4;
6const byte SPOT_PINS[SPOT_COUNT] = {2, 3, 4, 5};  // park yeri sensörleri / parking spot sensors
7const byte EXIT_PIN  = 6;    // çıkış sensörü / exit sensor
8const byte TRIG_PIN  = 7;    // HC-SR04 TRIG
9const byte ECHO_PIN  = 8;    // HC-SR04 ECHO
10const byte SERVO_PIN = 9;    // bariyer servosu / barrier servo
11const byte GREEN_LED = 10;   // yer var / space available
12const byte RED_LED   = 11;   // otopark dolu / car park full
13
14const int GATE_CLOSED = 0;                // kapalı açı / closed angle
15const int GATE_OPEN   = 90;               // açık açı / open angle
16const long CAR_DISTANCE_CM = 8;           // bu mesafeden yakınsa araç var / car present if closer
17const unsigned long GATE_HOLD_MS = 3000;  // son algılamadan sonra bekleme / wait after last detection
18
19LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
20Servo gate;
21
22bool gateOpen = false;
23unsigned long lastSeen = 0;
24byte lastMask = 0xFF;                     // ilk çizimi zorlar / forces the first redraw
25
26byte readSpots() {
27  byte mask = 0;
28  for (byte i = 0; i < SPOT_COUNT; i++) {
29    if (digitalRead(SPOT_PINS[i]) == LOW) {   // LOW = araç var / LOW = car present
30      mask |= (1 << i);
31    }
32  }
33  return mask;
34}
35
36byte freeSpots(byte mask) {
37  byte count = 0;
38  for (byte i = 0; i < SPOT_COUNT; i++) {
39    if (!(mask & (1 << i))) count++;
40  }
41  return count;
42}
43
44long readDistanceCm() {
45  digitalWrite(TRIG_PIN, LOW);
46  delayMicroseconds(2);
47  digitalWrite(TRIG_PIN, HIGH);
48  delayMicroseconds(10);                  // 10 µs tetik darbesi / 10 µs trigger pulse
49  digitalWrite(TRIG_PIN, LOW);
50  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı / 25 ms timeout
51  if (us == 0) return 999;                // yankı yok / no echo
52  return us / 58;                         // µs -> cm
53}
54
55void showLcd(byte mask, byte freeCount) {
56  lcd.setCursor(0, 0);
57  lcd.print(F("Bos yer: "));
58  lcd.print(freeCount);
59  lcd.print('/');
60  lcd.print(SPOT_COUNT);
61  lcd.print(F("    "));
62  lcd.setCursor(0, 1);
63  for (byte i = 0; i < SPOT_COUNT; i++) {
64    lcd.print(i + 1);
65    lcd.print((mask & (1 << i)) ? 'X' : '-');   // X = dolu, - = boş / X = occupied, - = free
66    lcd.print(' ');
67  }
68  if (freeCount == 0) {
69    lcd.print(F("DOLU"));                 // otopark dolu / car park full
70  } else {
71    lcd.print(F("    "));
72  }
73}
74
75void setup() {
76  for (byte i = 0; i < SPOT_COUNT; i++) pinMode(SPOT_PINS[i], INPUT);
77  pinMode(EXIT_PIN, INPUT);
78  pinMode(TRIG_PIN, OUTPUT);
79  pinMode(ECHO_PIN, INPUT);
80  pinMode(GREEN_LED, OUTPUT);
81  pinMode(RED_LED, OUTPUT);
82
83  gate.attach(SERVO_PIN);
84  gate.write(GATE_CLOSED);                // bariyer kapalı başlar / barrier starts closed
85
86  lcd.init();
87  lcd.backlight();
88  lcd.setCursor(0, 0);
89  lcd.print(F("Akilli Otopark"));
90  lcd.setCursor(0, 1);
91  lcd.print(F("BlueGrays"));
92  delay(1500);
93  lcd.clear();
94}
95
96void loop() {
97  byte mask = readSpots();
98  byte freeCount = freeSpots(mask);
99
100  if (mask != lastMask) {                 // yalnız değişince yaz / redraw only on change
101    showLcd(mask, freeCount);
102    lastMask = mask;
103  }
104  digitalWrite(GREEN_LED, freeCount > 0 ? HIGH : LOW);
105  digitalWrite(RED_LED, freeCount == 0 ? HIGH : LOW);
106
107  bool carAtEntry = readDistanceCm() < CAR_DISTANCE_CM;
108  bool carAtExit  = digitalRead(EXIT_PIN) == LOW;
109  bool wantOpen   = (carAtEntry && freeCount > 0) || carAtExit;
110
111  if (wantOpen) {
112    lastSeen = millis();
113    if (!gateOpen) {
114      gate.write(GATE_OPEN);
115      gateOpen = true;
116    }
117  } else if (gateOpen && millis() - lastSeen > GATE_HOLD_MS) {
118    gate.write(GATE_CLOSED);
119    gateOpen = false;
120  }
121  delay(60);                              // HC-SR04 ölçüm aralığı / HC-SR04 measurement interval
122}

¿Cómo funciona el código?

ParteFunción
readSpots()Lee los cuatro sensores de plaza y devuelve una máscara que pone a 1 el bit de cada plaza ocupada; por ejemplo, 0b0101 significa que la 1 y la 3 están ocupadas.
freeSpots()Cuenta los bits a 0 de la máscara para obtener las plazas libres.
readDistanceCm()Envía al HC-SR04 un pulso de disparo de 10 µs, mide con pulseIn la duración del eco y la divide entre 58 para pasarla a cm. Si no llega eco en 25 ms, devuelve 999.
showLcd()Actualiza el LCD solo cuando cambia el estado de las plazas; así la pantalla no parpadea.
wantOpenIndica que la barrera debe abrirse si hay un coche en la entrada y plazas libres, o si hay un coche en la salida.
GATE_HOLD_MSLa barrera baja 3 segundos después de la última detección; para que el brazo no baje con el coche debajo, puedes aumentar este tiempo según tu maqueta.
delay(60)Deja al menos 60 ms entre mediciones del HC-SR04 para que el eco de la medición anterior no estropee la nueva.

Esta lógica sencilla tiene un límite: el coche que pasa por la entrada aún no ha llegado a su plaza, así que durante unos segundos el número de plazas libres no cambia. Si llegan dos coches seguidos para la última plaza, los dos pueden entrar. Para solucionarlo, puedes guardar los coches que han pasado por la entrada en un contador "en camino" y restarlo de las plazas libres, reduciéndolo cuando el coche se coloque en su plaza. La forma ordenada de escribir este tipo de comportamientos paso a paso es el enfoque de máquina de estados; y por qué el tiempo se gestiona con millis lo puedes leer en el artículo sobre la diferencia entre millis y delay.

Sistema de estacionamiento con panel web en ESP32

Si montas el mismo sistema con un ESP32, puedes ver el estado del parking desde el móvil o el ordenador conectados a la misma red Wi-Fi. El código siguiente ejecuta un pequeño servidor web dentro del ESP32: en la página principal aparecen las plazas libres, cada plaza se muestra como una caja verde o roja, la página se actualiza cada dos segundos y con el enlace "Bariyeri ac" puedes levantar la barrera a distancia. Además, la dirección /api devuelve el estado en JSON, que puedes usar más adelante en una app móvil o en otra placa. Para el servo instala la biblioteca ESP32Servo desde el Gestor de bibliotecas; WiFi y WebServer vienen con el core de ESP32 para Arduino y funcionan igual en las versiones 2.x y 3.x.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "WIFI_ADIN";      // kendi ağ adın / your network name
6const char* WIFI_PASS = "WIFI_SIFREN";    // kendi şifren / your password
7
8const int SPOT_COUNT = 4;
9const int SPOT_PINS[SPOT_COUNT] = {32, 33, 25, 26};  // park yeri sensörleri / parking spot sensors
10const int EXIT_PIN  = 27;    // çıkış sensörü / exit sensor
11const int TRIG_PIN  = 23;    // HC-SR04 TRIG
12const int ECHO_PIN  = 18;    // HC-SR04 ECHO (gerilim bölücüyle / via voltage divider)
13const int SERVO_PIN = 13;    // bariyer servosu / barrier servo
14
15const int GATE_CLOSED = 0;
16const int GATE_OPEN   = 90;
17const long CAR_DISTANCE_CM = 8;
18const unsigned long GATE_HOLD_MS = 3000;
19
20WebServer server(80);
21Servo gate;
22bool gateOpen = false;
23unsigned long lastSeen = 0;
24
25bool spotFull(int i) {
26  return digitalRead(SPOT_PINS[i]) == LOW;   // LOW = araç var / LOW = car present
27}
28
29int freeSpots() {
30  int count = 0;
31  for (int i = 0; i < SPOT_COUNT; i++) {
32    if (!spotFull(i)) count++;
33  }
34  return count;
35}
36
37long readDistanceCm() {
38  digitalWrite(TRIG_PIN, LOW);
39  delayMicroseconds(2);
40  digitalWrite(TRIG_PIN, HIGH);
41  delayMicroseconds(10);                  // 10 µs tetik darbesi / 10 µs trigger pulse
42  digitalWrite(TRIG_PIN, LOW);
43  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı / 25 ms timeout
44  if (us == 0) return 999;                // yankı yok / no echo
45  return us / 58;
46}
47
48void openGate() {
49  lastSeen = millis();
50  if (!gateOpen) {
51    gate.write(GATE_OPEN);
52    gateOpen = true;
53  }
54}
55
56void handleRoot() {
57  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
58  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
59  html += "<meta http-equiv='refresh' content='2'><title>Otopark</title></head>";
60  html += "<body style='font-family:sans-serif;text-align:center'>";
61  html += "<h1>Akilli Otopark</h1>";
62  html += "<h2>Bos yer: " + String(freeSpots()) + " / " + String(SPOT_COUNT) + "</h2>";
63  for (int i = 0; i < SPOT_COUNT; i++) {
64    html += "<div style='display:inline-block;width:70px;height:90px;line-height:90px;margin:6px;";
65    html += "border-radius:8px;color:#fff;font-size:24px;background:";
66    html += spotFull(i) ? "#c62828'>" : "#2e7d32'>";   // kırmızı = dolu, yeşil = boş / red = full, green = free
67    html += "P" + String(i + 1) + "</div>";
68  }
69  html += "<p>Bariyer: ";
70  html += gateOpen ? "ACIK" : "KAPALI";
71  html += "</p><p><a href='/open'>Bariyeri ac</a></p></body></html>";
72  server.send(200, "text/html", html);
73}
74
75void handleApi() {
76  String json = "{\"free\":" + String(freeSpots()) + ",\"spots\":[";
77  for (int i = 0; i < SPOT_COUNT; i++) {
78    json += spotFull(i) ? "1" : "0";
79    if (i < SPOT_COUNT - 1) json += ",";
80  }
81  json += "],\"gate\":";
82  json += gateOpen ? "true" : "false";
83  json += "}";
84  server.send(200, "application/json", json);
85}
86
87void handleOpen() {
88  openGate();                              // görevli bariyeri elle açar / operator opens the gate manually
89  server.sendHeader("Location", "/");
90  server.send(303, "text/plain", "");
91}
92
93void setup() {
94  Serial.begin(115200);
95  for (int i = 0; i < SPOT_COUNT; i++) pinMode(SPOT_PINS[i], INPUT);
96  pinMode(EXIT_PIN, INPUT);
97  pinMode(TRIG_PIN, OUTPUT);
98  pinMode(ECHO_PIN, INPUT);
99
100  gate.setPeriodHertz(50);                 // standart servo frekansı / standard servo frequency
101  gate.attach(SERVO_PIN, 500, 2400);       // darbe aralığı µs / pulse range in µs
102  gate.write(GATE_CLOSED);
103
104  WiFi.mode(WIFI_STA);
105  WiFi.begin(WIFI_SSID, WIFI_PASS);
106  Serial.print("Wi-Fi baglaniyor");
107  while (WiFi.status() != WL_CONNECTED) {
108    delay(500);
109    Serial.print('.');
110  }
111  Serial.println();
112  Serial.print("Panel IP: ");
113  Serial.println(WiFi.localIP());          // bu adresi tarayıcıya yaz / type this address in the browser
114
115  server.on("/", handleRoot);
116  server.on("/open", handleOpen);
117  server.on("/api", handleApi);
118  server.begin();
119}
120
121void loop() {
122  server.handleClient();
123
124  static unsigned long lastCheck = 0;
125  if (millis() - lastCheck < 60) return;   // 60 ms'de bir ölç / measure every 60 ms
126  lastCheck = millis();
127
128  bool carAtEntry = readDistanceCm() < CAR_DISTANCE_CM;
129  bool carAtExit  = digitalRead(EXIT_PIN) == LOW;
130
131  if ((carAtEntry && freeSpots() > 0) || carAtExit) {
132    openGate();
133  } else if (gateOpen && millis() - lastSeen > GATE_HOLD_MS) {
134    gate.write(GATE_CLOSED);
135    gateOpen = false;
136  }
137}

Antes de subir el código, sustituye WIFI_ADIN y WIFI_SIFREN por los datos de tu red. Tras subirlo, abre el Monitor Serie a 115200 baudios; cuando el ESP32 se conecte a la red escribirá su dirección IP, y solo tienes que introducirla en el navegador del móvil. Los pines del ESP32 funcionan a 3,3 V y no toleran 5 V; como el pin ECHO del HC-SR04 da pulsos de 5 V, intercala un divisor de tensión con resistencias de 1 kΩ y 2 kΩ: 5 V × 2 / (1 + 2) = 3,33 V. Puedes comprobar el resultado con otros valores en la calculadora de divisor de tensión. Alimenta los sensores infrarrojos desde el pin 3V3 para que sus salidas también sean de 3,3 V. Si prefieres una actualización instantánea en lugar de recargar la página entera, usa el método del artículo sobre WebSocket en ESP32.

Versión MicroPython con Raspberry Pi Pico

Si usas una Raspberry Pi Pico, no necesitas ninguna biblioteca extra para el servo; el PWM por hardware de la Pico genera directamente la señal de servo de 50 Hz. El ángulo del servo se convierte en ancho de pulso: 0,5 ms para 0° y 2,4 ms para 180°; en un periodo de 20 ms, este valor se escala al rango 0–65535 con duty_u16. machine.time_pulse_us mide la duración del eco del HC-SR04. El código siguiente escribe las plazas libres en la consola de Thonny; igual que en el ESP32, no olvides poner un divisor de tensión en la línea ECHO.

MicroPython
1from machine import Pin, PWM, time_pulse_us
2import time
3
4spots = [Pin(p, Pin.IN) for p in (2, 3, 4, 5)]   # park yeri sensörleri / parking spot sensors
5exit_ir = Pin(6, Pin.IN)                         # çıkış sensörü / exit sensor
6trig = Pin(16, Pin.OUT)                          # HC-SR04 TRIG
7echo = Pin(17, Pin.IN)                           # gerilim bölücüyle / via voltage divider
8servo = PWM(Pin(15))
9servo.freq(50)                                   # 20 ms periyot / 20 ms period
10
11GATE_CLOSED = 0
12GATE_OPEN = 90
13CAR_DISTANCE_CM = 8
14GATE_HOLD_MS = 3000
15
16def set_angle(angle):
17    us = 500 + angle * 1900 // 180               # 0,5-2,4 ms darbe / 0.5-2.4 ms pulse
18    servo.duty_u16(us * 65535 // 20000)
19
20def distance_cm():
21    trig.low()
22    time.sleep_us(2)
23    trig.high()
24    time.sleep_us(10)                            # 10 µs tetik / 10 µs trigger
25    trig.low()
26    t = time_pulse_us(echo, 1, 25000)            # 25 ms zaman aşımı / 25 ms timeout
27    if t < 0:
28        return 999                               # yankı yok / no echo
29    return t / 58
30
31def free_spots():
32    return sum(1 for s in spots if s.value() == 1)   # 1 = boş / 1 = free
33
34gate_open = False
35last_seen = 0
36last_free = -1
37set_angle(GATE_CLOSED)
38
39while True:
40    free = free_spots()
41    if free != last_free:                        # yalnız değişince yaz / print only on change
42        print("Bos yer:", free, "/", len(spots))
43        last_free = free
44    car_in = distance_cm() < CAR_DISTANCE_CM
45    car_out = exit_ir.value() == 0
46    now = time.ticks_ms()
47    if (car_in and free > 0) or car_out:
48        last_seen = now
49        if not gate_open:
50            set_angle(GATE_OPEN)
51            gate_open = True
52    elif gate_open and time.ticks_diff(now, last_seen) > GATE_HOLD_MS:
53        set_angle(GATE_CLOSED)
54        gate_open = False
55    time.sleep_ms(60)                            # ölçüm aralığı / measurement interval

Ideas para mejorar el proyecto del parking

  • Acceso de abonados con tarjeta: añade un lector RFID RC522 en la entrada para que la barrera solo se abra a los abonados que pasen su tarjeta registrada.
  • Cartel con números grandes: muestra las plazas libres con un display de 7 segmentos para que se lean también desde la calle.
  • Aviso de ocupación: añade un bot de Telegram a la versión ESP32 y envía un mensaje al móvil cuando el parking se llene.
  • Tiempo de estancia y tarifa: guarda con millis el momento en que se ocupa cada plaza y, cuando el coche salga, calcula la tarifa según el tiempo transcurrido y muéstrala en el LCD.
  • Iluminación nocturna: con una LDR, enciende automáticamente los LED del camino cuando oscurezca.
  • Aviso de plaza para discapacitados: haz sonar un breve aviso con un zumbador cuando un coche entre en una plaza reservada.

Consejos para presentar el proyecto en clase o en una feria de ciencias

  • Empieza con el problema: abre la presentación con una pregunta como "¿Cuántos minutos pierden los conductores buscando aparcamiento?" y explica en una frase qué problema real resuelve el proyecto.
  • Prepara un diagrama de flujo: un esquema con los pasos "¿Ha llegado un coche? ¿Hay plaza libre? Abrir barrera" permite al jurado entender la lógica sin leer el código.
  • Planifica una demostración en vivo: lleva tantos coches de juguete como plazas tengas para poder llenar el parking del todo y mostrar el mensaje "DOLU" y el LED rojo.
  • Lleva repuestos: ten a mano cables jumper de repuesto, un segundo cable USB, una batería externa y un portátil con el código cargado; en una feria es muy común que se aflojen las conexiones.
  • Cuenta honestamente las limitaciones: mencionar que los sensores infrarrojos pueden fallar con luz solar y que los parkings reales usan sistemas magnéticos o de cámaras suma puntos ante el jurado.
  • Presenta un plan de mejora: explicar los siguientes pasos, como el panel web ESP32, las suscripciones por RFID o el cálculo de tarifas, demuestra que el proyecto puede crecer. Para más consejos, mira el artículo sobre la presentación de proyectos en ferias de ciencias.

Errores comunes y cómo solucionarlos

ProblemaCausa probableSolución
El servo tiembla y Arduino se reiniciaEl servo se alimenta por USB y no hay corriente suficienteAlimenta el servo con 5 V externos, une los GND y añade un condensador de 470 µF a la alimentación
El LCD se enciende pero no muestra textoDirección I2C incorrecta o ajuste de contrastePrueba la dirección 0x3F y gira el potenciómetro de la parte trasera del módulo I2C
La plaza siempre aparece ocupadaLa sensibilidad del sensor es demasiado alta o ve el sueloReduce el alcance con el potenciómetro e inclina un poco el sensor hacia arriba
No se detecta el coche negroLa superficie negra absorbe la luz infrarrojaPega cinta blanca en la cara del coche que mira al sensor
El HC-SR04 da siempre 999 o valores aleatoriosTRIG y ECHO están al revés, las mediciones son demasiado seguidas o el coche está muy inclinadoRevisa los pines, espera al menos 60 ms entre mediciones y coloca el sensor perpendicular al coche
La barrera baja con el coche debajoEl tiempo GATE_HOLD_MS es demasiado cortoSúbelo a 4–5 segundos o pon un segundo sensor debajo de la barrera
La página del ESP32 no abreEl móvil está en otra red o la IP es incorrectaConecta el móvil a la misma red Wi-Fi y usa la IP del Monitor Serie
Monta el proyecto por partes: prueba primero solo los sensores de las plazas en el Monitor Serie, luego el HC-SR04, después el servo y por último el LCD. Conectarlo todo de golpe y buscar el fallo cuando no funciona lleva mucho más tiempo que avanzar paso a paso. Si tienes problemas con el servo, echa un vistazo a el problema de temblor del servo, y para reinicios inesperados a Arduino se reinicia.

Un sistema de estacionamiento con Arduino reúne lectura de sensores, toma de decisiones, control de motores y uso de pantalla en una sola maqueta divertida, por lo que es una de las mejores formas de combinar lo que has aprendido. Si quieres conocer los componentes uno a uno, mira también los artículos sobre el servomotor y el sensor infrarrojo TCRT5000. En la app de BlueGrays encontrarás paso a paso proyectos de medición de distancia con HC-SR04, sensor de aparcamiento, medidor de distancia con LCD, control de servo y servidor web ESP32, con esquemas y código, para que pruebes cada parte de este parking por separado.

Preguntas frecuentes

¿Qué sensor se usa para un proyecto de parking con Arduino?

Para la ocupación de las plazas, lo más práctico son los sensores infrarrojos de obstáculos como el FC-51 o el TCRT5000: usan un solo pin digital y son baratos. Para detectar el coche que se acerca a la entrada es mejor el HC-SR04, que da la distancia como número. También puedes poner un HC-SR04 en cada plaza, pero cada sensor gasta dos pines y hay que dispararlos por turnos.

¿Cómo se calculan las plazas libres de un parking con Arduino?

El método más fiable es poner un sensor en cada plaza, contar las ocupadas y restarlas del total. El método que cuenta los coches que entran y salen usa menos sensores, pero un solo coche no detectado desajusta el contador para siempre. El código de este artículo lee los cuatro sensores en cada ciclo y recalcula las plazas libres.

¿Por qué se reinicia Arduino cuando se abre la barrera con servo?

El SG90 puede consumir cerca de 500 mA de golpe al empezar a moverse y hace caer la tensión de la alimentación USB. Al caer la tensión, Arduino se reinicia y el LCD se apaga. Alimenta el servo con una fuente externa de 5 V, une los GND y añade un condensador de unos 470 µF a la alimentación del servo.

¿Cómo se hace una maqueta de parking y qué material se usa?

El cartón pluma o la cartulina gruesa se cortan con facilidad y se pueden perforar para esconder sensores y cables. Una base de unos 40×30 cm basta para cuatro plazas y el camino de entrada. Puedes usar cinta de colores para las líneas, un palo de helado para el brazo de la barrera y coches de juguete a escala 1:43.

¿Cuántos sensores de plaza se pueden conectar a un Arduino Uno?

El Uno tiene 20 pines, D0–D13 y A0–A5; tras reservar los del puerto serie, I2C, servo, HC-SR04, sensor de salida y LED, quedan unos 10 para las plazas. Los pines A0–A3 también se pueden usar como entradas digitales. Para más plazas puedes usar un registro de desplazamiento de entrada como el 74HC165 o un Arduino Mega.

¿Se puede controlar el parking desde el móvil?

Sí. En la versión con ESP32, la placa ejecuta su propio servidor web; escribiendo la IP del ESP32 en el navegador del móvil conectado a la misma red Wi-Fi ves las plazas libres y el estado de cada una. Para acceder desde fuera de casa se pueden añadir un bot de Telegram, MQTT o soluciones en la nube como Blynk.

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
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
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
Uso del servomotor
AR-35Principiante
Premium

Uso del servomotor

El brazo de un pequeño servomotor gira por turnos a tres posiciones: al principio del todo, justo al centro y al final del todo, esperando dos segundos en cada parada.

4.7(48)
67
Lectura de reflexión (proximidad) con TCRT5000
AR-77Intermedio
Premium

Lectura de reflexión (proximidad) con TCRT5000

Con un pequeño sensor que emite luz invisible y mide cuánta rebota, detectas la superficie que tiene delante.

4.6(33)
43
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
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
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