Robot evasor de obstáculos con HC‑SR04 y DRV8833 Y NANO V3— Tutorial paso a paso Deja un comentario

Proyectos DIY

Este proyecto muestra cómo construir un robot evasor de obstáculos usando un sensor ultrasónico HC‑SR04, un driver de motores DRV8833 y una placa Arduino. El comportamiento del robot es sencillo y robusto: avanza en micro‑bursts, detecta obstáculos, retrocede, gira (alternando derecha/izquierda) y continúa.

Materiales necesarios

  • 1 × Arduino (Uno, Nano o similar)
  • 1 × Sensor ultrasónico HC‑SR04
  • 1 × Driver de motor DC (ej. DRV8833 o similar)
  • 2 × Motores DC con ruedas (tensión según motores; 3–7 V típico)
  • 1 × Chasis para robots (o base casera)
  • 1 × Batería o pack de baterías para los motores (asegúrate de la tensión adecuada)
  • Cables macho‑macho / macho‑hembra
  • Protoboard (opcional)
  • Tornillos, soportes y herramientas básicas
  • Ordenador con el IDE de Arduino para subir el código

Nota: alimenta la placa Arduino y los motores de manera adecuada. Es habitual usar una fuente separada para los motores (battery pack) y compartir la masa (GND) con el Arduino.

Mapeo de pines y recomendaciones

El código de ejemplo usa estos pines (puedes adaptarlos según tu placa):

  • trigPin → D2 (Trigger del HC‑SR04)
  • echoPin → D3 (Echo del HC‑SR04)
  • motorA1 → D10
  • motorA2 → D9
  • motorB1 → D6
  • motorB2 → D5

Advertencia importante (PWM): el código usa analogWrite() para controlar velocidad. En una Arduino Uno analogWrite() solo funciona en pines PWM: 3, 5, 6, 9, 10, 11. considera usar alguno de esos pines sino usas el mapeo original.

Conexiones (esquema general)

  1. HC‑SR04
    • VCC → 5V (o 3.3V según tu placa/sensor)
    • GND → GND común
    • TRIG → trigPin (D2)
    • ECHO → echoPin (D3)
  2. DRV8833 (o driver equivalente)
    • IN1 (motor A) → motorA1 (D10)
    • IN2 (motor A) → motorA2 (D9)
    • IN3 (motor B) → motorB1 (D6)
    • IN4 (motor B) → motorB2 (D5)
    • VMotor → alimentación de motores (batería)
    • GND → GND común con Arduino
  3. Motores
    • Motor A → salidas motor A del driver
    • Motor B → salidas motor B del driver

Asegúrate de que todas las masas estén conectadas (Arduino, driver y batería). Si el driver tiene pines EN / nSLEEP / FAULT, revisa la hoja de datos del módulo y conéctalos según las indicaciones (por ejemplo poner nSLEEP a HIGH si es necesario).

HC-SR04 PinOut

DRV8833 PinOut

Conexiones Necesarias Para Armar el Robot Evasor de Objetos

Montaje paso a paso

  1. Fija los motores al chasis y coloca las ruedas.
  2. Monta el driver de motores en el chasis o protoboard.
  3. Conecta cada motor a las salidas del driver (observa polaridad para probar dirección).
  4. Coloca el HC‑SR04 en la parte frontal del chasis (alineado horizontalmente al suelo).
  5. Conecta los pines de control entre Arduino y driver / sensor siguiendo el mapeo.
  6. Conecta la alimentación de los motores a la entrada VM del driver (cuidado con la polaridad). No olvides compartir GND.
  7. Conecta Arduino al ordenador y sube el sketch (código) que aparece al final de la entrada.
  8. Quita las hélices/ruedas del suelo y prueba en el aire o con el robot elevado la primera vez para verificar direcciones de motor. Si un motor gira al revés, invierte sus cables en el driver o intercambia INx/INy.

Pruebas y puesta en marcha

  1. Antes de conectar la batería, revisa conexiones y masas.
  2. Sube el código y observa el monitor serie (si añadieras Serial.print para debug) o prueba con el robot sobre una superficie segura.
  3. Si los motores no responden, verifica que los pines PWM estén bien asignados.
  4. Ajusta motorSpeed en el código si necesitas más o menos potencia (0–255).
  5. Si las lecturas del HC‑SR04 son erráticas, comprueba: alimentación, cables y que el sensor no reciba reflejos laterales.

Explicación del código (líneas clave)

A continuación se explica el comportamiento y las funciones más importantes del sketch.

Pines y configuración inicial

  • Se definen pines para el trig y echo del sensor ultrasónico y cuatro pines de control para los dos motores.
  • Variables de configuración:
    • obstacleDistance — distancia umbral en cm a la que se considera que hay un obstáculo.
    • motorSpeed — velocidad usada en analogWrite() (0–255).
    • backTime, turnTime, stepDelay, forwardStep — tiempos en milisegundos que controlan las rutinas de movimiento.

readDistance()

Esta función genera el pulso de trigger (10 µs) y mide la duración del pulso en echo con pulseIn(). La fórmula usada convierte la duración en centímetros:

long d = duration * 0.034 / 2;

  • duration está en microsegundos (µs).
  • 0.034 es una aproximación de la velocidad del sonido en cm/µs (≈ 0.0343 cm/µs). Se divide entre 2 porque el pulso recorre la distancia de ida y vuelta.

La función también protege contra lecturas erróneas (si d == 0 o d > 300 se fija en 300 cm).

Helpers de motor

Hay funciones cortas que abstraen el movimiento:

  • motorForward() — avanza usando analogWrite en los pines “hacia adelante”.
  • motorBackward() — invierte las señales para retroceder.
  • motorLeft() / motorRight() — hacen un giro diferencial (un motor adelante, otro atrás) para girar sobre sí.
  • motorStop() — pone todo a LOW y detiene los motores.

Importante: estas funciones asumen que al aplicar analogWrite(pin, motorSpeed) el pin es PWM. Si tu pin no es PWM, la velocidad no variará correctamente.

loop() — lógica principal

  1. El robot hace pausas micro (stepDelay) y lee la distancia antes de moverse.
  2. Si detecta un obstáculo (distance < obstacleDistance) hace:
    • Retroceso breve (backTime) comprobando si el obstáculo se despeja.
    • Giro por turnTime (la dirección del giro alterna entre derecha/izquierda usando turnRightNext). Durante el giro también se vuelve a comprobar la distancia para salir antes si está despejado.
    • Avanza un breve tramo tras el giro (forwardStep).
    • Invierte la variable turnRightNext para alternar la próxima vez.
  3. Si no hay obstáculo, avanza en micro‑bursts controlados por forwardStep y stepDelay, leyendo la distancia en cada paso.

Este enfoque (micro‑bursts + comprobaciones continuas) da un movimiento más controlado y permite reaccionar rápidamente ante nuevos obstáculos.

Ajustes recomendados y consejos

  • PWM y pines: asegúrate de usar pines PWM para analogWrite. Si usas Arduino Uno, utiliza 3, 5, 6, 9, 10, 11.
  • Velocidad: motorSpeed admite 0–255. Empieza con valores bajos (100–160) y sube según convenga.
  • Sensibilidad: ajusta obstacleDistance para que el robot tenga suficiente tiempo para reaccionar según la velocidad de tus motores.
  • Alimentación: usa una batería con suficiente corriente. Los drivers pequeños pueden calentarse; evita sobrecargas.
  • Filtro de lecturas: si el HC‑SR04 da lecturas inestables, puedes implementar un filtro (media móvil) o descartar valores extremos antes de tomar decisiones.

Deja una respuesta

Marcas De Carrusel