Dron Acuático

// Dron acuático — Nivel inicial: recorrido programado.
// El dron barre un área cerrada de la superficie del lago siguiendo una
// trayectoria fija cargada de antemano en la placa (no usa sensores).
// Dos motores DC mueven las paletas; se conducen con un módulo ULN2003.
//
// CÓMO GIRA (dirección diferencial, estilo "tanque"): el ULN2003 es un
// driver UNIDIRECCIONAL de encendido/apagado — puede prender un motor pero
// NO invertir su giro. Por eso el dron no tiene marcha atrás ni giro en el
// lugar: avanza con los dos motores andando y GIRA frenando uno y dejando
// andar el otro (el motor que sigue empujando arrastra al dron hacia el
// lado del motor frenado). Para giro en el lugar o marcha atrás haría falta
// un puente H (p. ej. L298N), como sugiere el cierre del proyecto original.
//
// SEGURIDAD (agua + electrónica): los motores son de baja tensión (5 V,
// alimentados con 6 pilas AA) y trabajan en la SUPERFICIE del agua, no
// sumergidos. Aun así, agua y electricidad no se llevan bien: la placa, el
// ULN2003, las pilas y el cableado van sobre la cubierta del dron, POR
// ENCIMA de la línea de flotación y protegidos de salpicaduras. No hay 220 V
// en ningún punto del proyecto.
//
// Plataforma: Arduino UNO.
// Conexión: entrada IN del ULN2003 del motor IZQUIERDO → pin 5,
//           entrada IN del motor DERECHO → pin 6.
//
// Basado en: Fragmento de código "Programar el movimiento del dron acuático"
// (Paso 9) — Dron Acuático, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop,
// angle_rad/deg, motores prendidos "a mano" con digitalWrite sueltos) por
// C++ idiomático con constantes nombradas y funciones de movimiento
// (avanzar / girarDerecha / girarIzquierda / frenar). El recorrido se
// ejecuta UNA vez en setup() y el dron queda detenido: es una trayectoria
// de barrido de un área cerrada, repetirla lo sacaría del área.

// Entradas del módulo ULN2003 que gobiernan cada motor.
const int PIN_MOTOR_IZQ = 5;
const int PIN_MOTOR_DER = 6;

// El ULN2003 es on/off: HIGH pone el motor a andar, LOW lo frena.
const int MOTOR_ANDANDO = HIGH;
const int MOTOR_FRENADO = LOW;

// Tiempos del recorrido (calibrar en la maqueta: dependen de la potencia de
// los motores y del rozamiento del agua). AVANCE = tramo recto entre giros;
// GIRO = cuánto dura el frenado de un motor para describir ~90°.
const unsigned long TIEMPO_AVANCE_MS = 3000;
const unsigned long TIEMPO_GIRO_MS   = 700;

// Avanzar: los dos motores andando, el dron va derecho hacia adelante.
void avanzar(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_ANDANDO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_ANDANDO);
  delay(ms);
}

// Girar a la derecha: frena el motor derecho y deja andar el izquierdo.
// El empuje del lado izquierdo hace pivotar el dron hacia la derecha.
void girarDerecha(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_ANDANDO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_FRENADO);
  delay(ms);
}

// Girar a la izquierda: el accionar exactamente opuesto al giro a derecha.
void girarIzquierda(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_FRENADO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_ANDANDO);
  delay(ms);
}

// Frenar: los dos motores apagados, el dron se detiene.
void frenar() {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_FRENADO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_FRENADO);
}

void setup() {
  pinMode(PIN_MOTOR_IZQ, OUTPUT);
  pinMode(PIN_MOTOR_DER, OUTPUT);
  frenar(); // arrancamos detenidos hasta empezar el recorrido

  // Recorrido de barrido en "S" (boustrofedón) que cubre un área cerrada:
  // avanzar, dos giros a la derecha, avanzar, dos giros a la izquierda...
  // Es la secuencia de 14 pasos del croquis del original, ya coherente.
  avanzar(TIEMPO_AVANCE_MS);       // 1. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 2. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 3. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 4. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 5. Avanzar
  girarIzquierda(TIEMPO_GIRO_MS);  // 6. Girar a la izquierda
  avanzar(TIEMPO_AVANCE_MS);       // 7. Avanzar
  girarIzquierda(TIEMPO_GIRO_MS);  // 8. Girar a la izquierda
  avanzar(TIEMPO_AVANCE_MS);       // 9. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 10. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 11. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 12. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 13. Avanzar
  frenar();                        // 14. Frenar
}

void loop() {
  // Recorrido terminado: el dron queda quieto con los motores apagados.
}

// Dron acuático — Nivel inicial: recorrido programado.
// El dron barre un área cerrada de la superficie del lago siguiendo una
// trayectoria fija cargada de antemano en la placa (no usa sensores).
// Dos motores DC mueven las paletas; se conducen con un módulo ULN2003.
//
// CÓMO GIRA (dirección diferencial, estilo "tanque"): el ULN2003 es un
// driver UNIDIRECCIONAL de encendido/apagado — puede prender un motor pero
// NO invertir su giro. Por eso el dron no tiene marcha atrás ni giro en el
// lugar: avanza con los dos motores andando y GIRA frenando uno y dejando
// andar el otro (el motor que sigue empujando arrastra al dron hacia el
// lado del motor frenado). Para giro en el lugar o marcha atrás haría falta
// un puente H (p. ej. L298N), como sugiere el cierre del proyecto original.
//
// SEGURIDAD (agua + electrónica): los motores son de baja tensión (5 V,
// alimentados con 6 pilas AA) y trabajan en la SUPERFICIE del agua, no
// sumergidos. Aun así, agua y electricidad no se llevan bien: la placa, el
// ULN2003, las pilas y el cableado van sobre la cubierta del dron, POR
// ENCIMA de la línea de flotación y protegidos de salpicaduras. No hay 220 V
// en ningún punto del proyecto.
//
// NOTA DE ALIMENTACIÓN (ESP32): el ESP32 trabaja a 3,3 V, pero sus salidas
// digitales alcanzan de sobra para excitar las entradas IN del ULN2003 (el
// driver es el que maneja los 5 V de los motores). Alimentá el ULN2003 y los
// motores desde las 6 pilas AA (5 V), NO desde el pin 3V3 de la placa, y uní
// las masas (GND del ESP32 con GND de las pilas).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: entrada IN del ULN2003 del motor IZQUIERDO → GPIO 26,
//           entrada IN del motor DERECHO → GPIO 27.
//
// Basado en: Fragmento de código "Programar el movimiento del dron acuático"
// (Paso 9) — Dron Acuático, Saberes Digitales (INET/EDUCAR 2019).
// Modernización: se reemplazó el código generado por mBlock3 (_delay, _loop,
// angle_rad/deg, motores prendidos "a mano" con digitalWrite sueltos) por
// C++ idiomático con constantes nombradas y funciones de movimiento
// (avanzar / girarDerecha / girarIzquierda / frenar). El recorrido se
// ejecuta UNA vez en setup() y el dron queda detenido: es una trayectoria
// de barrido de un área cerrada, repetirla lo sacaría del área. Se portó del
// UNO (pines 5/6) al ESP32 (GPIO 26/27).

// Entradas del módulo ULN2003 que gobiernan cada motor.
const int PIN_MOTOR_IZQ = 26;
const int PIN_MOTOR_DER = 27;

// El ULN2003 es on/off: HIGH pone el motor a andar, LOW lo frena.
const int MOTOR_ANDANDO = HIGH;
const int MOTOR_FRENADO = LOW;

// Tiempos del recorrido (calibrar en la maqueta: dependen de la potencia de
// los motores y del rozamiento del agua). AVANCE = tramo recto entre giros;
// GIRO = cuánto dura el frenado de un motor para describir ~90°.
const unsigned long TIEMPO_AVANCE_MS = 3000;
const unsigned long TIEMPO_GIRO_MS   = 700;

// Avanzar: los dos motores andando, el dron va derecho hacia adelante.
void avanzar(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_ANDANDO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_ANDANDO);
  delay(ms);
}

// Girar a la derecha: frena el motor derecho y deja andar el izquierdo.
// El empuje del lado izquierdo hace pivotar el dron hacia la derecha.
void girarDerecha(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_ANDANDO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_FRENADO);
  delay(ms);
}

// Girar a la izquierda: el accionar exactamente opuesto al giro a derecha.
void girarIzquierda(unsigned long ms) {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_FRENADO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_ANDANDO);
  delay(ms);
}

// Frenar: los dos motores apagados, el dron se detiene.
void frenar() {
  digitalWrite(PIN_MOTOR_IZQ, MOTOR_FRENADO);
  digitalWrite(PIN_MOTOR_DER, MOTOR_FRENADO);
}

void setup() {
  pinMode(PIN_MOTOR_IZQ, OUTPUT);
  pinMode(PIN_MOTOR_DER, OUTPUT);
  frenar(); // arrancamos detenidos hasta empezar el recorrido

  // Recorrido de barrido en "S" (boustrofedón) que cubre un área cerrada:
  // avanzar, dos giros a la derecha, avanzar, dos giros a la izquierda...
  // Es la secuencia de 14 pasos del croquis del original, ya coherente.
  avanzar(TIEMPO_AVANCE_MS);       // 1. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 2. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 3. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 4. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 5. Avanzar
  girarIzquierda(TIEMPO_GIRO_MS);  // 6. Girar a la izquierda
  avanzar(TIEMPO_AVANCE_MS);       // 7. Avanzar
  girarIzquierda(TIEMPO_GIRO_MS);  // 8. Girar a la izquierda
  avanzar(TIEMPO_AVANCE_MS);       // 9. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 10. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 11. Avanzar
  girarDerecha(TIEMPO_GIRO_MS);    // 12. Girar a la derecha
  avanzar(TIEMPO_AVANCE_MS);       // 13. Avanzar
  frenar();                        // 14. Frenar
}

void loop() {
  // Recorrido terminado: el dron queda quieto con los motores apagados.
}

// Dron acuático — Nivel avanzado: esquiva de obstáculos (boyas).
// El dron avanza y usa TRES sensores ultrasónicos (izquierda, frente,
// derecha) para detectar boyas a menos de 40 cm y esquivarlas girando hacia
// el lado que tenga más espacio libre. Cuando el camino se despeja, retoma
// la marcha. Dos motores DC (vía ULN2003) con dirección diferencial.
//
// CÓMO ESQUIVA: mientras avanza, mide los tres sensores. Si alguno detecta
// una boya a menos de 40 cm, entra en un giro TEMPORIZADO no bloqueante hacia
// el lado despejado (frenando un motor) y luego vuelve a avanzar. El giro
// dura un tiempo fijo; se resuelve con millis() (máquina de estados), sin
// delay(), para no quedar "ciego" durante la maniobra.
//
// CÓMO GIRA (dirección diferencial, estilo "tanque"): el ULN2003 es un
// driver UNIDIRECCIONAL on/off — no invierte el giro del motor. El dron no
// tiene marcha atrás ni giro en el lugar: gira frenando un motor y dejando
// andar el otro. Giro en el lugar / marcha atrás requerirían un puente H
// (p. ej. L298N), como sugiere el cierre del proyecto original.
//
// LECTURA 0 = FUERA DE RANGO: el HC-SR04 devuelve 0 cuando el eco no vuelve
// (nada dentro de su alcance, ~400 cm) o por timeout. 0 NO significa "boya
// pegada": significa "camino despejado". Por eso solo tratamos como
// obstáculo las lecturas mayores que 0 y menores que el umbral, y para
// comparar qué lado tiene más lugar, una lectura 0 cuenta como "muy lejos".
//
// SEGURIDAD (agua + electrónica): motores de baja tensión (5 V, 6 pilas AA)
// trabajando en la SUPERFICIE del agua, no sumergidos. Placa, ULN2003, pilas
// y cableado sobre la cubierta, por encima de la línea de flotación y
// protegidos de salpicaduras. No hay 220 V en el proyecto.
//
// Plataforma: Arduino UNO.
// Conexión: motor IZQUIERDO (IN ULN2003) → pin 5, motor DERECHO → pin 6.
//   Sensor IZQUIERDA  TRIG/ECHO → 2 / 3
//   Sensor FRENTE     TRIG/ECHO → 8 / 9
//   Sensor DERECHA    TRIG/ECHO → 10 / 11
//
// Basado en: Fragmentos de código de los pasos "Programar el movimiento" e
// "Incorporar/Programar los tres sensores" — Dron Acuático, Saberes
// Digitales (INET/EDUCAR 2019).
// DESVÍOS respecto del original (estaba muy buggeado):
//   1. BUG CORREGIDO: el original leía getDistance(2,3) para los TRES
//      sensores (copy-paste) — el sensor 2 y el 3 nunca se leían de verdad.
//      Acá cada sensor lee SU par de pines (2/3, 8/9, 10/11).
//   2. El texto del original asignaba el sensor 2 a los pines 6/7, pero el
//      pin 6 es de un motor: chocaban. Se usa 8/9 (lo que el propio código
//      del original ya cableaba).
//   3. Navegación reescrita: el original "esquivaba" con una coreografía de
//      giros a ciegas dentro de setup() (se movía SIEMPRE igual sin importar
//      qué sensor detectaba). Acá la maniobra depende de dónde está la boya
//      y de qué lado hay más espacio.
//   4. Sin cruft de mBlock3 (_delay, _loop, angle_rad/deg); no bloqueante.

// --- Motores (entradas IN del ULN2003) ---
const int PIN_MOTOR_IZQ = 5;
const int PIN_MOTOR_DER = 6;

// El ULN2003 es on/off: HIGH = motor andando, LOW = motor frenado.
const int MOTOR_ANDANDO = HIGH;
const int MOTOR_FRENADO = LOW;

// --- Sensores ultrasónicos (cada uno con SU par TRIG/ECHO) ---
const int PIN_TRIG_IZQ = 2;
const int PIN_ECHO_IZQ = 3;
const int PIN_TRIG_FRENTE = 8;
const int PIN_ECHO_FRENTE = 9;
const int PIN_TRIG_DER = 10;
const int PIN_ECHO_DER = 11;

// Distancia a la que consideramos que una boya está "en el camino" (cm).
const float UMBRAL_OBSTACULO_CM = 40.0;

// Cuando una lectura es 0 (fuera de rango), la contamos como "muy lejos"
// para las comparaciones de qué lado está más despejado.
const float DISTANCIA_MUY_LEJOS_CM = 9999.0;

// El eco tarda 58 microsegundos por cm (ida y vuelta del sonido a ~343 m/s).
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Ritmo de medición mientras avanza y duración del giro de esquive.
const unsigned long INTERVALO_MEDICION_MS = 100;
const unsigned long TIEMPO_GIRO_MS = 700;

// Máquina de estados no bloqueante.
enum Estado { AVANZANDO, GIRANDO };
Estado estado = AVANZANDO;
unsigned long finGiro = 0;        // instante en que termina el giro actual
unsigned long ultimaMedicion = 0; // última vez que medimos los sensores

// Mide la distancia en cm de un sensor. Devuelve 0 si no llega el eco
// (fuera de rango o sensor desconectado): el llamador interpreta ese 0.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

// ¿Esta lectura corresponde a una boya en el camino? Solo si es mayor que 0
// (dentro de rango) y menor que el umbral. El 0 NO cuenta como obstáculo.
bool hayObstaculo(float distancia) {
  return distancia > 0.0 && distancia < UMBRAL_OBSTACULO_CM;
}

// Espacio libre "efectivo" de un lado: una lectura 0 (fuera de rango) se
// trata como muy lejos, así el dron elige girar hacia el lado despejado.
float espacioLibre(float distancia) {
  return distancia <= 0.0 ? DISTANCIA_MUY_LEJOS_CM : distancia;
}

void setMotores(int estadoIzq, int estadoDer) {
  digitalWrite(PIN_MOTOR_IZQ, estadoIzq);
  digitalWrite(PIN_MOTOR_DER, estadoDer);
}

// Inicia un giro temporizado (no bloqueante) hacia la derecha o la izquierda.
// Girar a la derecha = frenar el motor derecho; a la izquierda = frenar el
// izquierdo.
void iniciarGiro(bool haciaDerecha) {
  if (haciaDerecha) {
    setMotores(MOTOR_ANDANDO, MOTOR_FRENADO);
  } else {
    setMotores(MOTOR_FRENADO, MOTOR_ANDANDO);
  }
  finGiro = millis() + TIEMPO_GIRO_MS;
  estado = GIRANDO;
}

void setup() {
  pinMode(PIN_MOTOR_IZQ, OUTPUT);
  pinMode(PIN_MOTOR_DER, OUTPUT);
  pinMode(PIN_TRIG_IZQ, OUTPUT);
  pinMode(PIN_ECHO_IZQ, INPUT);
  pinMode(PIN_TRIG_FRENTE, OUTPUT);
  pinMode(PIN_ECHO_FRENTE, INPUT);
  pinMode(PIN_TRIG_DER, OUTPUT);
  pinMode(PIN_ECHO_DER, INPUT);

  // Arranca avanzando con los dos motores.
  setMotores(MOTOR_ANDANDO, MOTOR_ANDANDO);
  estado = AVANZANDO;
}

void loop() {
  unsigned long ahora = millis();

  if (estado == GIRANDO) {
    // Maniobra de esquive en curso: al terminar el tiempo, volver a avanzar.
    if (ahora >= finGiro) {
      setMotores(MOTOR_ANDANDO, MOTOR_ANDANDO);
      estado = AVANZANDO;
    }
    return;
  }

  // estado == AVANZANDO: medimos a intervalos y decidimos si esquivar.
  if (ahora - ultimaMedicion < INTERVALO_MEDICION_MS) {
    return;
  }
  ultimaMedicion = ahora;

  float dIzq = medirDistanciaCm(PIN_TRIG_IZQ, PIN_ECHO_IZQ);
  float dFrente = medirDistanciaCm(PIN_TRIG_FRENTE, PIN_ECHO_FRENTE);
  float dDer = medirDistanciaCm(PIN_TRIG_DER, PIN_ECHO_DER);

  if (hayObstaculo(dFrente)) {
    // Boya al frente: girar hacia el lado con más espacio libre.
    bool haciaDerecha = espacioLibre(dDer) >= espacioLibre(dIzq);
    iniciarGiro(haciaDerecha);
  } else if (hayObstaculo(dIzq)) {
    // Boya a la izquierda: esquivar girando a la derecha.
    iniciarGiro(true);
  } else if (hayObstaculo(dDer)) {
    // Boya a la derecha: esquivar girando a la izquierda.
    iniciarGiro(false);
  }
  // Sin obstáculos: seguimos avanzando (los motores ya están andando).
}

// Dron acuático — Nivel avanzado: esquiva de obstáculos (boyas).
// El dron avanza y usa TRES sensores ultrasónicos (izquierda, frente,
// derecha) para detectar boyas a menos de 40 cm y esquivarlas girando hacia
// el lado que tenga más espacio libre. Cuando el camino se despeja, retoma
// la marcha. Dos motores DC (vía ULN2003) con dirección diferencial.
//
// CÓMO ESQUIVA: mientras avanza, mide los tres sensores. Si alguno detecta
// una boya a menos de 40 cm, entra en un giro TEMPORIZADO no bloqueante hacia
// el lado despejado (frenando un motor) y luego vuelve a avanzar. El giro
// dura un tiempo fijo; se resuelve con millis() (máquina de estados), sin
// delay(), para no quedar "ciego" durante la maniobra.
//
// CÓMO GIRA (dirección diferencial, estilo "tanque"): el ULN2003 es un
// driver UNIDIRECCIONAL on/off — no invierte el giro del motor. El dron no
// tiene marcha atrás ni giro en el lugar: gira frenando un motor y dejando
// andar el otro. Giro en el lugar / marcha atrás requerirían un puente H
// (p. ej. L298N), como sugiere el cierre del proyecto original.
//
// LECTURA 0 = FUERA DE RANGO: el HC-SR04 devuelve 0 cuando el eco no vuelve
// (nada dentro de su alcance, ~400 cm) o por timeout. 0 NO significa "boya
// pegada": significa "camino despejado". Por eso solo tratamos como
// obstáculo las lecturas mayores que 0 y menores que el umbral, y para
// comparar qué lado tiene más lugar, una lectura 0 cuenta como "muy lejos".
//
// SEGURIDAD (agua + electrónica): motores de baja tensión (5 V, 6 pilas AA)
// trabajando en la SUPERFICIE del agua, no sumergidos. Placa, ULN2003, pilas
// y cableado sobre la cubierta, por encima de la línea de flotación y
// protegidos de salpicaduras. No hay 220 V en el proyecto.
//
// NOTA ELÉCTRICA (ESP32, ¡importante!): el ESP32 trabaja a 3,3 V. El HC-SR04
// clásico se alimenta con 5 V y su pin ECHO devuelve el eco a 5 V: eso
// dañaría el GPIO. Es OBLIGATORIO un divisor de tensión en CADA ECHO
// (ECHO —1 kΩ— GPIO —2 kΩ— GND), que baja los 5 V a ~3,3 V. TRIG no necesita
// divisor: los 3,3 V del GPIO alcanzan para dispararlo. Alternativa sin
// divisores: el modelo HC-SR04P, alimentable a 3,3 V. Las salidas del ESP32
// sí alcanzan para las entradas IN del ULN2003; alimentá driver y motores
// desde las pilas (5 V), no desde 3V3, y uní las masas.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: motor IZQUIERDO (IN ULN2003) → GPIO 26, motor DERECHO → GPIO 27.
//   Sensor IZQUIERDA  TRIG/ECHO → GPIO 5 / 18   (ECHO con divisor)
//   Sensor FRENTE     TRIG/ECHO → GPIO 19 / 21  (ECHO con divisor)
//   Sensor DERECHA    TRIG/ECHO → GPIO 22 / 23  (ECHO con divisor)
//
// Basado en: Fragmentos de código de los pasos "Programar el movimiento" e
// "Incorporar/Programar los tres sensores" — Dron Acuático, Saberes
// Digitales (INET/EDUCAR 2019).
// DESVÍOS respecto del original (estaba muy buggeado):
//   1. BUG CORREGIDO: el original leía getDistance(2,3) para los TRES
//      sensores (copy-paste) — el sensor 2 y el 3 nunca se leían de verdad.
//      Acá cada sensor lee SU par de pines.
//   2. El texto del original asignaba el sensor 2 a los pines 6/7, que en el
//      UNO chocan con un motor; en ESP32 se usan GPIO propios sin conflicto.
//   3. Navegación reescrita: el original "esquivaba" con una coreografía de
//      giros a ciegas dentro de setup() (se movía SIEMPRE igual sin importar
//      qué sensor detectaba). Acá la maniobra depende de dónde está la boya
//      y de qué lado hay más espacio.
//   4. Sin cruft de mBlock3 (_delay, _loop, angle_rad/deg); no bloqueante.
//      Se portó del UNO al ESP32 (GPIO seguros + divisor en cada ECHO).

// --- Motores (entradas IN del ULN2003) ---
const int PIN_MOTOR_IZQ = 26;
const int PIN_MOTOR_DER = 27;

// El ULN2003 es on/off: HIGH = motor andando, LOW = motor frenado.
const int MOTOR_ANDANDO = HIGH;
const int MOTOR_FRENADO = LOW;

// --- Sensores ultrasónicos (cada uno con SU par TRIG/ECHO) ---
const int PIN_TRIG_IZQ = 5;
const int PIN_ECHO_IZQ = 18; // con divisor de tensión 1 kΩ / 2 kΩ
const int PIN_TRIG_FRENTE = 19;
const int PIN_ECHO_FRENTE = 21; // con divisor de tensión 1 kΩ / 2 kΩ
const int PIN_TRIG_DER = 22;
const int PIN_ECHO_DER = 23; // con divisor de tensión 1 kΩ / 2 kΩ

// Distancia a la que consideramos que una boya está "en el camino" (cm).
const float UMBRAL_OBSTACULO_CM = 40.0;

// Cuando una lectura es 0 (fuera de rango), la contamos como "muy lejos"
// para las comparaciones de qué lado está más despejado.
const float DISTANCIA_MUY_LEJOS_CM = 9999.0;

// El eco tarda 58 microsegundos por cm (ida y vuelta del sonido a ~343 m/s).
const float MICROSEGUNDOS_POR_CM = 58.0;
const unsigned long TIMEOUT_ECO_US = 30000;

// Ritmo de medición mientras avanza y duración del giro de esquive.
const unsigned long INTERVALO_MEDICION_MS = 100;
const unsigned long TIEMPO_GIRO_MS = 700;

// Máquina de estados no bloqueante.
enum Estado { AVANZANDO, GIRANDO };
Estado estado = AVANZANDO;
unsigned long finGiro = 0;        // instante en que termina el giro actual
unsigned long ultimaMedicion = 0; // última vez que medimos los sensores

// Mide la distancia en cm de un sensor. Devuelve 0 si no llega el eco
// (fuera de rango o sensor desconectado): el llamador interpreta ese 0.
float medirDistanciaCm(int pinTrig, int pinEcho) {
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinTrig, HIGH); // pulso de disparo de 10 microsegundos
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  return pulseIn(pinEcho, HIGH, TIMEOUT_ECO_US) / MICROSEGUNDOS_POR_CM;
}

// ¿Esta lectura corresponde a una boya en el camino? Solo si es mayor que 0
// (dentro de rango) y menor que el umbral. El 0 NO cuenta como obstáculo.
bool hayObstaculo(float distancia) {
  return distancia > 0.0 && distancia < UMBRAL_OBSTACULO_CM;
}

// Espacio libre "efectivo" de un lado: una lectura 0 (fuera de rango) se
// trata como muy lejos, así el dron elige girar hacia el lado despejado.
float espacioLibre(float distancia) {
  return distancia <= 0.0 ? DISTANCIA_MUY_LEJOS_CM : distancia;
}

void setMotores(int estadoIzq, int estadoDer) {
  digitalWrite(PIN_MOTOR_IZQ, estadoIzq);
  digitalWrite(PIN_MOTOR_DER, estadoDer);
}

// Inicia un giro temporizado (no bloqueante) hacia la derecha o la izquierda.
// Girar a la derecha = frenar el motor derecho; a la izquierda = frenar el
// izquierdo.
void iniciarGiro(bool haciaDerecha) {
  if (haciaDerecha) {
    setMotores(MOTOR_ANDANDO, MOTOR_FRENADO);
  } else {
    setMotores(MOTOR_FRENADO, MOTOR_ANDANDO);
  }
  finGiro = millis() + TIEMPO_GIRO_MS;
  estado = GIRANDO;
}

void setup() {
  pinMode(PIN_MOTOR_IZQ, OUTPUT);
  pinMode(PIN_MOTOR_DER, OUTPUT);
  pinMode(PIN_TRIG_IZQ, OUTPUT);
  pinMode(PIN_ECHO_IZQ, INPUT);
  pinMode(PIN_TRIG_FRENTE, OUTPUT);
  pinMode(PIN_ECHO_FRENTE, INPUT);
  pinMode(PIN_TRIG_DER, OUTPUT);
  pinMode(PIN_ECHO_DER, INPUT);

  // Arranca avanzando con los dos motores.
  setMotores(MOTOR_ANDANDO, MOTOR_ANDANDO);
  estado = AVANZANDO;
}

void loop() {
  unsigned long ahora = millis();

  if (estado == GIRANDO) {
    // Maniobra de esquive en curso: al terminar el tiempo, volver a avanzar.
    if (ahora >= finGiro) {
      setMotores(MOTOR_ANDANDO, MOTOR_ANDANDO);
      estado = AVANZANDO;
    }
    return;
  }

  // estado == AVANZANDO: medimos a intervalos y decidimos si esquivar.
  if (ahora - ultimaMedicion < INTERVALO_MEDICION_MS) {
    return;
  }
  ultimaMedicion = ahora;

  float dIzq = medirDistanciaCm(PIN_TRIG_IZQ, PIN_ECHO_IZQ);
  float dFrente = medirDistanciaCm(PIN_TRIG_FRENTE, PIN_ECHO_FRENTE);
  float dDer = medirDistanciaCm(PIN_TRIG_DER, PIN_ECHO_DER);

  if (hayObstaculo(dFrente)) {
    // Boya al frente: girar hacia el lado con más espacio libre.
    bool haciaDerecha = espacioLibre(dDer) >= espacioLibre(dIzq);
    iniciarGiro(haciaDerecha);
  } else if (hayObstaculo(dIzq)) {
    // Boya a la izquierda: esquivar girando a la derecha.
    iniciarGiro(true);
  } else if (hayObstaculo(dDer)) {
    // Boya a la derecha: esquivar girando a la izquierda.
    iniciarGiro(false);
  }
  // Sin obstáculos: seguimos avanzando (los motores ya están andando).
}