Guias · 11 min de leitura

Estacionamento com Arduino: cancela automática e contador de vagas no LCD

Como fazer um estacionamento com Arduino? Sensores HC-SR04 e infravermelhos detectam as vagas, um servo SG90 faz a cancela e um LCD I2C mostra as vagas livres. Com código para Uno, ESP32 e Pico.

Um estacionamento com Arduino é um projeto de maquete que usa sensores para saber se cada vaga está ocupada ou livre, abre e fecha a cancela da entrada com um servo motor e mostra no LCD quantas vagas ainda restam. É uma pequena cópia, em cima da mesa, das placas “Vagas livres: 12” que você vê nos estacionamentos de shopping. Como junta medição de distância, entradas digitais, controle de servo e display em um só circuito, é ótimo como primeiro projeto grande e também para apresentar na escola ou em uma feira de ciências.

Neste guia você vai montar do começo ao fim uma maquete com quatro vagas: um sensor infravermelho em cada vaga, um sensor ultrassônico HC-SR04 na entrada que abre a cancela quando um carro se aproxima, um sensor separado na saída, uma cancela com servo SG90 e um LCD I2C 16x2. Primeiro vamos analisar o código do Arduino Uno linha por linha, depois levar o mesmo sistema para o ESP32 com um painel web que você acompanha pelo celular e, por fim, escrever uma versão em MicroPython para o Raspberry Pi Pico. No final há medidas para a maquete e dicas de apresentação.

Sensor de distância ultrassônico HC-SR04
O HC-SR04 detecta o carro que se aproxima da entrada na faixa de 2–400 cm; para a maquete, um limite de 8 cm é suficiente.

O que é um estacionamento com Arduino e como funciona?

O sistema faz três coisas ao mesmo tempo. A primeira é o controle de ocupação: um sensor colocado no piso ou ao lado de cada vaga informa o tempo todo se há um carro ali; o Arduino conta as vagas ocupadas e subtrai do total. A segunda é o controle da cancela: quando o sensor da entrada vê um carro e há vaga livre, a cancela sobe 90 graus e desce alguns segundos depois que o carro passa; se o estacionamento estiver lotado, a cancela fica fechada e o LED vermelho acende. Para um carro vindo da saída, a cancela sempre abre. A terceira é a informação: a primeira linha do LCD mostra “Free: 3/4” (vagas livres) e a segunda mostra o estado de cada vaga. Como calculamos as vagas livres direto pelos sensores das vagas, e não contando entradas e saídas, o contador não fica desajustado para sempre mesmo que um sensor deixe passar um carro; isso é muito mais confiável do que os projetos simples baseados em contagem de entrada e saída.

FunçãoComponenteO que faz
Ocupação das vagas4 sensores infravermelhos de obstáculo (módulo FC-51 ou TCRT5000)O pino OUT vai para LOW quando há um carro
Detectar carro na entradaSensor ultrassônico HC-SR04Mede a distância do carro em cm
Detectar carro na saída1 sensor infravermelho de obstáculoVê o carro que vem de dentro
CancelaServo motor SG90 + palito de picolé0° fechada, 90° aberta
Display de informaçõesLCD I2C 16x2Número de vagas livres e estado das vagas
Luz de statusLED verde e vermelhoHá vaga / estacionamento lotado

Lista de materiais

MaterialQtd.Observação
Arduino Uno (ou Nano)1Versões para ESP32 e Pico mais abaixo
Sensor de distância HC-SR041Funciona com 5 V
Sensor infravermelho de obstáculo (módulo FC-51 / TCRT5000)54 vagas + 1 saída
Servo motor SG901Para o braço da cancela
LCD 16x2 + módulo I2C1O endereço costuma ser 0x27 ou 0x3F
LED verde e vermelho2Um resistor de 220 Ω para cada
Protoboard e jumpers1 conjuntoJumpers macho-fêmea são práticos para os sensores
Fonte externa de 5 V (2 A)1Recomendada para o servo e os sensores
Materiais da maquete-Placa de espuma (foam board), papelão, carrinhos de brinquedo, fita colorida

HC-SR04 ou sensor infravermelho?

Dá para detectar a ocupação das vagas de duas formas. O HC-SR04 mede o carro com ondas sonoras; se você colocar um em cada vaga, cada um usa dois pinos (TRIG e ECHO), então quatro vagas consomem oito pinos. Além disso, se os sensores medirem ao mesmo tempo, um pode ouvir o eco do outro, por isso precisam ser disparados um depois do outro. Já os sensores infravermelhos de obstáculo têm uma única saída digital, são baratos e a distância de detecção é ajustada no pequeno potenciômetro da placa. Por isso, o melhor equilíbrio é usar sensores infravermelhos nas vagas e, na entrada, o HC-SR04, que dá a distância como número. Você encontra as diferenças entre os tipos de sensor com mais detalhes no artigo comparação de sensores de distância.

CaracterísticaHC-SR04Sensor de obstáculo FC-51Módulo TCRT5000
Faixa de detecção2–400 cmCerca de 2–30 cm (ajustável)Cerca de 1–25 mm
SaídaDuração do pulso (medida)Digital (LOW = obstáculo)Digital + analógica
Pinos usados211
Alimentação5 V3,3–5 V3,3–5 V
Ponto fracoSuperfícies macias e inclinadasLuz do sol, superfícies pretasAlcance muito curto, superfícies pretas
Melhor lugar no estacionamentoCancela da entradaBorda do fundo da vagaPiso da vaga
Servo motor SG90
Com um palito de picolé colado no braço, o servo SG90 vira a cancela da maquete do estacionamento.

Diagrama de ligação e tabela de pinos

LigaçãoArduino UnoESP32Raspberry Pi Pico
Sensores das vagas 1–4 (OUT)D2, D3, D4, D5GPIO 32, 33, 25, 26GP2, GP3, GP4, GP5
Sensor da saída (OUT)D6GPIO 27GP6
HC-SR04 TRIGD7GPIO 23GP16
HC-SR04 ECHOD8GPIO 18 (com divisor de tensão)GP17 (com divisor de tensão)
Sinal do servo (fio laranja)D9GPIO 13GP15
LED verde / vermelho (com 220 Ω)D10 / D11Não usadoNão usado
LCD I2C SDA / SCLA4 / A5Não usadoNão usado
AlimentaçãoSensores no 5V, servo em 5 V externoHC-SR04 e servo no 5V/VIN, sensores IR no 3V3HC-SR04 e servo no VBUS, sensores IR no 3V3(OUT)
Alimentar o servo, os cinco sensores e o LCD ao mesmo tempo pelo pino 5V do Arduino é o erro mais comum. Enquanto o braço se move, um SG90 pode puxar por um instante perto de 500 mA; a tensão da USB cai, o LCD fica apagado e o Arduino reinicia sozinho. Alimente o servo com uma fonte externa de 5 V e sempre ligue o GND da fonte ao GND do Arduino; sem um GND comum, o sinal do servo perde o sentido.

Ajuste o potenciômetro azul de cada sensor infravermelho para que o LED do sensor acenda quando o carrinho estiver na vaga e apague quando você tirar o carrinho. No Arduino Uno, um resistor de 220 Ω serve bem para os LEDs; se for usar outra cor ou outra tensão, descubra o valor com a calculadora Resistor para LED. Você pode conferir rapidinho a disposição dos pinos das placas na ferramenta Pinagem. Os detalhes de ligação do LCD I2C e o código scanner de endereço estão no artigo display LCD I2C.

Montando a maquete do estacionamento passo a passo

  1. Pegue uma placa de espuma ou um papelão grosso de cerca de 40×30 cm; esse tamanho é suficiente para quatro vagas, uma pista de entrada e um compartimento para a eletrônica.
  2. Meça seu carrinho de brinquedo e desenhe cada vaga com cerca de 1,5 vez a largura dele; áreas de 6×11 cm servem para um carro em escala 1:43. Destaque as linhas com fita branca ou amarela.
  3. Coloque um sensor FC-51 na borda do fundo de cada vaga, virado para o carro, ou faça um pequeno furo no piso e embuta um TCRT5000 virado para cima. Passe os fios por baixo da placa.
  4. Ao lado da pista de entrada, coloque o HC-SR04 virado para o meio da pista, 5–10 cm antes da cancela. Na pista de saída, coloque o quinto sensor infravermelho.
  5. Fixe o SG90 com cola quente dentro de uma pequena guarita recortada de espuma e cole um palito de picolé pintado no braço do servo. Antes de encaixar o braço, leve o servo a 0 grau e então encaixe o palito de modo que fique na horizontal.
  6. Coloque o LCD e os LEDs em uma placa de aviso que o motorista veja na entrada; esconda o Arduino e a protoboard no compartimento atrás ou embaixo da placa.
  7. Confira cada ligação com a tabela de pinos; primeiro teste só os sensores no Monitor Serial, depois acrescente o servo e o LCD.
Sensores infravermelhos não enxergam bem superfícies pretas, porque a tinta preta absorve a luz infravermelha. Se você tiver um carrinho preto, cole um pedacinho de fita branca embaixo dele ou no lado virado para o sensor; a detecção melhora na hora. Evite também usar a maquete perto da janela, pois a luz do sol engana os sensores infravermelhos.

Código do estacionamento para Arduino Uno

Para este código, basta instalar a biblioteca LiquidCrystal I2C (de Frank de Brabander) pelo Gerenciador de Bibliotecas; as bibliotecas Servo e Wire já vêm com a Arduino IDE. Se o LCD não mostrar nada, troque o endereço 0x27 no código por 0x3F. O programa não usa um delay longo para segurar a cancela; ele conta o tempo com millis, então continua lendo os sensores enquanto a cancela está aberta. Como a biblioteca Servo usa o Timer1 no Uno, o analogWrite não funciona em D9 e D10; como só ligamos e desligamos os LEDs, isso não é 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}

Como o código funciona?

ParteFunção
readSpots() (leitura das vagas)Lê os quatro sensores das vagas e devolve uma máscara com o bit em 1 para as vagas ocupadas; por exemplo, 0b0101 quer dizer que as vagas 1 e 3 estão ocupadas.
freeSpots() (vagas livres)Conta os bits 0 da máscara para descobrir o número de vagas livres.
readDistanceCm() (distância em cm)Envia um pulso de disparo de 10 µs ao HC-SR04, mede o tempo do eco com pulseIn e divide por 58 para obter cm. Se nenhum eco chegar em 25 ms, devolve 999.
showLcd() (atualiza o LCD)Atualiza o LCD só quando o estado das vagas muda, assim a tela não pisca.
wantOpen (pedido de abertura)Indica que a cancela deve abrir se houver um carro na entrada e uma vaga livre, ou um carro na saída.
GATE_HOLD_MS (tempo da cancela aberta)A cancela desce 3 segundos depois da última detecção; você pode aumentar esse tempo de acordo com sua maquete para o braço não descer enquanto o carro estiver embaixo da cancela.
delay(60) (pausa entre medições)Deixa pelo menos 60 ms entre as medições do HC-SR04 para que o eco da anterior não atrapalhe a próxima.

Essa lógica simples tem um limite: o carro que acabou de passar pela entrada ainda não chegou à vaga, então por alguns segundos o número de vagas livres não muda. Se dois carros chegarem um atrás do outro para a última vaga, os dois podem entrar. Para resolver isso, você pode guardar os carros que passaram pela entrada em um contador “a caminho” e subtraí-lo das vagas livres, diminuindo o contador quando o carro estaciona na vaga. O jeito organizado de escrever esse tipo de comportamento passo a passo é a abordagem de máquina de estados; e você pode ler por que o tempo é contado com millis no artigo millis ou delay.

Estacionamento com painel web no ESP32

Se você montar o mesmo sistema com um ESP32, pode acompanhar o estacionamento pelo celular ou pelo computador na mesma rede Wi-Fi. O código abaixo roda um pequeno servidor web no ESP32: a página inicial mostra o número de vagas livres, cada vaga aparece como um quadro verde ou vermelho, a página se atualiza sozinha a cada dois segundos e, com o link “Open barrier” (abrir cancela), você levanta a cancela à distância. O endereço /api também devolve o estado em JSON, que você pode usar depois em um app de celular ou em outra placa. Para o servo, instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas; as bibliotecas WiFi e WebServer vêm com o core do ESP32 para Arduino e funcionam do mesmo jeito nas versões 2.x e 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 carregar o código, troque WIFI_ADIN e WIFI_SIFREN pelos dados da sua rede. Depois de carregar, abra o Monitor Serial em 115200 baud; quando o ESP32 se conecta à rede, ele mostra o endereço IP, e basta digitar esse endereço no navegador do celular. Os pinos do ESP32 trabalham com 3,3 V e não toleram 5 V; como o pino ECHO do HC-SR04 envia um pulso de 5 V, coloque no meio um divisor de tensão de 1 kΩ e 2 kΩ: 5 V × 2 / (1 + 2) = 3,33 V. Você pode conferir o resultado com outros valores de resistor na calculadora Divisor de tensão. Alimente os sensores infravermelhos pelo pino 3V3 para que as saídas deles também fiquem em 3,3 V. Se quiser atualização instantânea em vez de a página recarregar do zero a cada atualização, use o método do artigo WebSocket no ESP32.

Versão em MicroPython com o Raspberry Pi Pico

Se você usa um Raspberry Pi Pico, não precisa de biblioteca extra para o servo; o PWM por hardware do Pico gera direto o sinal de 50 Hz do servo. O ângulo do servo é convertido em largura de pulso: 0,5 ms para 0° e 2,4 ms para 180°; dentro de um período de 20 ms, esse valor é escalonado para a faixa 0–65535 com duty_u16. O machine.time_pulse_us mede o tempo do eco do HC-SR04. O código abaixo mostra o número de vagas livres no console do Thonny; assim como no ESP32, não esqueça de colocar um divisor de tensão na linha 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

Ideias para ampliar o projeto do estacionamento

  • Entrada de assinantes com cartão: Coloque um leitor RFID RC522 na entrada; a cancela abre só para assinantes que aproximarem um cartão cadastrado.
  • Painel com números grandes: Mostre o número de vagas livres em um display de 7 segmentos para que possa ser lido da rua.
  • Aviso de lotação: Adicione um bot do Telegram à versão com ESP32 e envie uma mensagem para o seu celular quando o estacionamento lotar.
  • Tempo de permanência e tarifa: Registre com millis o momento em que cada vaga é ocupada e, quando o carro sair, calcule a tarifa pelo tempo decorrido e mostre no LCD.
  • Iluminação noturna: Use um LDR para acender automaticamente os LEDs da pista quando escurecer.
  • Aviso de vaga para pessoas com deficiência: Toque um aviso curto no buzzer quando um carro entrar na vaga reservada.

Dicas para projeto escolar e apresentação em feira de ciências

  • Comece pelo problema: Abra a apresentação com uma pergunta como “Quantos minutos os motoristas perdem procurando vaga?” e explique em uma frase qual problema real o seu projeto resolve.
  • Prepare um fluxograma: Um diagrama com os passos “Chegou um carro? Há vaga livre? Abrir a cancela” permite que os avaliadores entendam a lógica sem ler o código.
  • Planeje uma demonstração ao vivo: Leve tantos carrinhos quanto houver vagas para lotar o estacionamento e mostrar a mensagem “FULL” (lotado) e o LED vermelho.
  • Leve reservas: Tenha jumpers sobrando, um segundo cabo USB, um power bank e um notebook com o código; conexões que se soltam em feira são muito comuns.
  • Seja honesto sobre os limites: Dizer que os sensores infravermelhos podem ser enganados pela luz do sol e que estacionamentos reais usam sistemas magnéticos ou com câmeras conta pontos extras com os avaliadores.
  • Apresente um plano de evolução: Contar os próximos passos, como o painel web no ESP32, assinaturas com RFID ou cálculo de tarifa, mostra que o projeto pode crescer. Para mais dicas, veja o artigo apresentação de projeto em feira de ciências.

Erros comuns e como resolver

ProblemaCausa provávelSolução
Servo treme, Arduino reiniciaServo alimentado pela USB, corrente insuficienteAlimente o servo com 5 V externo, una os GNDs, coloque um capacitor de 470 µF na alimentação
LCD acende, mas não mostra textoEndereço I2C errado ou ajuste de contrasteTeste o endereço 0x3F, gire o potenciômetro atrás do módulo I2C
Uma vaga aparece sempre ocupadaSensibilidade do sensor alta demais ou ele está vendo o pisoReduza o alcance no potenciômetro, incline o sensor um pouco para cima
Carro preto não é detectadoSuperfície preta absorve a luz infravermelhaCole fita branca no lado do carro virado para o sensor
HC-SR04 sempre dá 999 ou valores aleatóriosTRIG e ECHO trocados, medições frequentes demais ou carro muito inclinadoConfira os pinos, espere pelo menos 60 ms entre as medições, deixe o sensor de frente para o carro
Cancela desce com o carro embaixoGATE_HOLD_MS curto demaisAumente para 4–5 segundos ou coloque um segundo sensor embaixo da cancela
Página do ESP32 não abreCelular em outra rede ou IP erradoConecte o celular à mesma rede Wi-Fi, use o IP mostrado no Monitor Serial
Monte o projeto por partes: primeiro teste só os sensores das vagas no Monitor Serial, depois o HC-SR04, depois o servo e por último o LCD. Ligar tudo de uma vez e depois caçar o defeito quando não funciona leva muito mais tempo do que avançar passo a passo. Para problemas com o servo, veja servo tremendo, e para reinícios inesperados, veja Arduino reiniciando sozinho.

Um estacionamento com Arduino junta leitura de sensores, tomada de decisão, controle de motor e uso de display em um projeto de maquete divertido, por isso é uma das melhores formas de combinar o que você aprendeu. Se quiser conhecer os componentes um por um, dê uma olhada também nos artigos servo motor e sensor infravermelho TCRT5000. No app BlueGrays você encontra, passo a passo e com esquemas do circuito e código, projetos de medição de distância com HC-SR04, sensor de estacionamento, indicador de distância com LCD, controle de servo e servidor web no ESP32, para testar cada parte deste estacionamento separadamente.

Perguntas frequentes

Qual sensor usar em um projeto de estacionamento com Arduino?

Para a ocupação das vagas, a opção mais prática é um sensor infravermelho de obstáculo como o FC-51 ou o TCRT5000; cada um usa um único pino digital e eles são baratos. Para detectar o carro que se aproxima da entrada, o sensor ultrassônico HC-SR04, que dá a distância como número, é mais adequado. Você também pode colocar um HC-SR04 em cada vaga, mas cada sensor usa dois pinos e precisa ser disparado na sua vez.

Como calcular o número de vagas livres em um estacionamento com Arduino?

O método mais confiável é colocar um sensor em cada vaga, contar as ocupadas e subtrair do total. O método que conta os carros que passam pela entrada e pela saída usa menos sensores, mas um único carro não detectado desajusta o contador para sempre. O código deste artigo lê os quatro sensores a cada ciclo e recalcula o número de vagas livres.

Por que o Arduino reinicia quando a cancela com servo abre?

Ao começar a se mover, um servo SG90 pode puxar por um instante perto de 500 mA e derrubar a tensão da alimentação USB. Quando a tensão cai, o Arduino reinicia e o LCD fica apagado. Alimente o servo com uma fonte externa de 5 V, una os GNDs e coloque um capacitor, como um de 470 µF, na alimentação do servo.

Como fazer uma maquete de estacionamento e quais materiais usar?

Placa de espuma ou papelão grosso é fácil de cortar e pode ser furado para esconder sensores e fios. Uma base de cerca de 40×30 cm é suficiente para quatro vagas e uma pista de entrada. Você pode usar fita colorida para as linhas das vagas, um palito de picolé para o braço da cancela e carrinhos de brinquedo em escala 1:43 como veículos.

Quantos sensores de vaga dá para ligar em um Arduino Uno?

O Uno tem 20 pinos, D0–D13 e A0–A5; depois de reservar os pinos para a serial, o I2C, o servo, o HC-SR04, o sensor da saída e os LEDs, sobram cerca de 10 pinos para as vagas. Os pinos A0–A3 também podem ser usados como entradas digitais. Para mais vagas, você pode usar um registrador de deslocamento de entrada como o 74HC165, ou um Arduino Mega.

Dá para acompanhar o estacionamento pelo celular?

Sim. Na versão com ESP32, a placa roda o próprio servidor web; digitando o endereço IP do ESP32 no navegador de um celular na mesma rede Wi-Fi, você vê o número de vagas livres e o estado de cada vaga. Para acessar de fora de casa, dá para acrescentar um bot do Telegram, MQTT ou uma solução em nuvem como o Blynk.

Ver todos os projetos
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

Medição de distância com HC-SR04 (Monitor Serial)

O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

4.6(50)
82
Sensor de estacionamento com HC-SR04
AR-28Intermediário
Premium

Sensor de estacionamento com HC-SR04

Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

4.8(64)
86
Medição de distância com display LCD
AR-31Avançado
Premium

Medição de distância com display LCD

Uma ferramenta que mede distâncias sem régua: aproxime e afaste a mão na frente do sensor e veja o número mudar.

4.6(45)
59
Uso de servo motor
AR-35Iniciante
Premium

Uso de servo motor

O braço de um pequeno servo motor gira para três posições em sequência: o início, o meio e o fim do percurso, esperando dois segundos em cada parada.

4.7(48)
67
Leitura de reflexão (proximidade) com TCRT5000
AR-77Intermediário
Premium

Leitura de reflexão (proximidade) com TCRT5000

Com um pequeno sensor que emite luz invisível e mede quanto dela é refletido, você detecta a superfície à frente dele.

4.6(33)
43
Medidor ultrassônico de distância HC-SR04 com ESP32
ES-14Intermediário

Medidor ultrassônico de distância HC-SR04 com ESP32

O sensor ultrassônico HC-SR04 calcula a distância medindo o tempo que a onda sonora emitida leva para atingir um objeto e retornar (tempo de voo). Neste projeto, enviaremos um pulso de 10 microssegundos do ESP32 ao pino TRIG do sensor e leremos a duração do eco no pino ECHO com pulseIn(). Exibiremos a distância calculada em centímetros em um LCD I2C 16x2. Como o HC-SR04 opera a 5V, é preciso usar um divisor de tensão no pino ECHO; caso contrário, o GPIO de 3,3V do ESP32 será danificado.

4.9(29)
48
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

Servidor web assíncrono com ESP32 (IP no LCD)

Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

4.8(16)
26
Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)
ES-38Avançado
Premium

Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)

A versão com ESP32 do sensor de estacionamento de carro! Usamos o sensor ultrassônico HC-SR04 para medir a distância até o objeto à sua frente. Conforme a distância diminui, a barra de 5 LEDs vai se preenchendo (verde → amarelo → vermelho) e o intervalo entre os bipes do buzzer diminui. Quando o objeto chega muito perto (menos de 10 cm), o alarme soa continuamente e todos os LEDs acendem.

14