Robot Resolvedor de Laberintos con IA usando Arduino y Bluetooth

El proyecto se divide en dos pasos (o "passes"):

• Primer Paso: El robot encuentra la salida de un "perfect maze no conocido". No importa dónde lo coloques, hallará una "solución".
• Segundo Paso: Una vez encontrada una solución, la optimiza hallando el "camino más corto de inicio a fin".

En el primer recorrido, el robot pierde tiempo "pensando" en cada intersección, probando caminos equivocados y callejones sin salida, acumulando experiencia. En el segundo paso, va directo y rápido al final sin errores.

Paso 1: Lista de Materiales (Bill of Materials)

Básicamente la misma lista del Robot Seguidor de Línea, añadiendo 2 sensores extra para mejor detección de intersecciones IZQUIERDA y DERECHA. Coste total aprox. $85.

• Cuerpo: 2 cuadrados de madera (80x80mm), 3 clips de carpeta, 2 ruedas de madera (50mm), 1 rueda loca (ball caster), 9 gomas elásticas, tira 3M Command, uniones plásticas para sensores, protoboard y cableado
• 2 sets de 4 pilas Ni-MH (5V cada set)
• 2 Servos SM-S4303R de rotación continua 360°
• Arduino Nano
• Módulo Bluetooth HC-06
• 5 Sensores de línea (módulo TCRT5000 4CH + 1 sensor independiente)
• 2 Sensores ZX03 (salida analógica)
• 1 LED, 1 botón

Nota: Usé sensores analógicos por no tener digitales a mano. Lo ideal es que todos sean iguales. Funciona con solo los 5 originales, pero requiere ajustes más finos.

Paso 2: Cambios en el Cuerpo

Retira el conjunto original de 5 sensores y fija los nuevos sensores "Far LEFT" y "Far RIGHT" en cada extremo de la barra soporte. Procura alinear los 7 sensores lo mejor posible.

Paso 3: Instalación y prueba de los nuevos sensores

El nuevo array de 7 sensores se monta de forma que los 5 originales se usan exclusivamente para control PID (y detección de "línea continua") y los 2 nuevos exclusivamente para detección de intersecciones IZQUIERDA y DERECHA.

Funcionamiento de los 5 sensores digitales originales: Si uno está centrado sobre la línea negra, solo ese da HIGH. El espaciado permite que 2 sensores cubran el ancho completo simultáneamente.

Funcionamiento de los 2 nuevos sensores analógicos: Centrados sobre la línea negra dan valor ADC bajo (<100). En superficies claras dan valores altos (500-600). Debe definirse un THRESHOLD adecuado tras pruebas.

Definición de pines en el código:

const int lineFollowSensor0 = 12; // Entrada digital
const int lineFollowSensor1 = 18; // Pin analógico A4 como digital
const int lineFollowSensor2 = 17; // Pin analógico A3 como digital
const int lineFollowSensor3 = 16; // Pin analógico A2 como digital
const int lineFollowSensor4 = 19; // Pin analógico A5 como digital
const int farRightSensorPin = 0;  // Pin analógico A0
const int farLeftSensorPin  = 1;  // Pin analógico A1

Lógica de detección de intersecciones (modo y error) implementada en readLFSsensors(). Incluye función de prueba testSensorLogic() para depuración por puerto serie.

Paso 4: Resolviendo el Laberinto - La Regla de la Mano Izquierda

Como se discutió, la mayoría de mazes pueden resolverse manteniendo la mano izquierda en la pared. La regla:

1. Pon tu mano izquierda en la pared.
2. Camina hacia adelante.
3. Eventualmente llegarás al final (no necesariamente por el camino más corto).

Se identifican 8 tipos de intersecciones. Aplicando la Regla de la Mano Izquierda, las acciones se reducen a una por tipo:

• Cruce (Cross): Girar IZQUIERDA
• T: Girar IZQUIERDA
• Solo Derecha: Girar DERECHA
• Solo Izquierda: Girar IZQUIERDA
• Recto o Izquierda: Girar IZQUIERDA
• Recto o Derecha: Seguir RECTO
• Callejón sin salida (Dead End): Media vuelta (U-turn)
• Fin del Laberinto: PARAR

El reto está en distinguir intersecciones ambiguas (ej. una línea puede ser Cruce o T). Solución: el robot avanza un "pulgada extra" (runExtraInch) para ver qué hay después.

Paso 5: Implementando el Algoritmo "Mano Izquierda en la Pared" en Arduino

void loop() {
  readLFSsensors();
  switch (mode) {
    case NO_LINE:
      motorStop();
      goAndTurn(LEFT, 180);
      break;
    case CONT_LINE:
      runExtraInch();
      readLFSsensors();
      if (mode == CONT_LINE) mazeEnd();
      else goAndTurn(LEFT, 90); // T o Cross -> Izquierda
      break;
    case RIGHT_TURN:
      runExtraInch();
      readLFSsensors();
      if (mode == NO_LINE) goAndTurn(RIGHT, 90);
      break;
    case LEFT_TURN:
      goAndTurn(LEFT, 90);
      break;
    case FOLLOWING_LINE:
      followingLine();
      break;
  }
}

Funciones clave:

• followingLine(): Control PID estándar (calculatePID() + motorPIDcontrol()).
• runExtraInch(): Avanza un poco (delay(extraInch)) y para.
• goAndTurn(direction, angle): Avanza para alinear ejes con intersección (delay(adjGoAndTurn)) y gira.

Paso 6: Almacenando el Camino

Ejemplo: el robot encuentra 15 intersecciones antes de la salida. Secuencia: L, B, L, L, L, B, S, B, L, L, B, S, L, L, End.

Se guarda cada acción en array path[100] con índices pathLength y pathIndex. Resultado: path = [LBLLLBSBLLBSLL], pathLength = 14.

Paso 7: Simplificando (Optimizando) el Camino

Secuencias con "U-turn" (B) de 3 pasos (xBx) se reducen a uno. Reglas de simplificación:

• LBR = B
• LBS = R
• RBL = B
• SBL = R
• SBS = B
• LBL = S

Aplicando al ejemplo:

LBLLLBSBLLBSLL → LBL=S → SLLBSBLLBSLL → LBS=R → SLRBLLBSLL
→ RBL=B → SLBLBSLL → LBL=S → SSBSLL → SBS=B → SBLL
→ SBL=R → RL

¡Resultado optimizado: RL (Derecha, luego Izquierda)!

Función mazeSolve() consolida la primera pasada, almacenando y simplificando en tiempo real. Variable status indica fin (0=resolviendo, 1=llegó al final).

void mazeSolve(void) {
  while (!status) {
    readLFSsensors();
    switch (mode) {
      case NO_LINE:
        motorStop(); goAndTurn(LEFT, 180); recIntersection('B'); break;
      case CONT_LINE:
        runExtraInch(); readLFSsensors();
        if (mode != CONT_LINE) { goAndTurn(LEFT, 90); recIntersection('L'); }
        else mazeEnd(); break;
      case RIGHT_TURN:
        runExtraInch(); readLFSsensors();
        if (mode == NO_LINE) { goAndTurn(RIGHT, 90); recIntersection('R'); }
        else recIntersection('S'); break;
      case LEFT_TURN:
        goAndTurn(LEFT, 90); recIntersection('L'); break;
      case FOLLOWING_LINE:
        followingLine(); break;
    }
  }
}

Funciones auxiliares:

void recIntersection(char direction) {
  path[pathLength] = direction;
  pathLength++;
  simplifyPath();
}

void simplifyPath() {
  if (pathLength < 3 || path[pathLength-2] != 'B') return;
  int totalAngle = 0;
  for (int i=1; i<=3; i++) {
    switch(path[pathLength-i]) {
      case 'R': totalAngle += 90; break;
      case 'L': totalAngle += 270; break;
      case 'B': totalAngle += 180; break;
    }
  }
  totalAngle %= 360;
  switch(totalAngle) {
    case 0:   path[pathLength-3] = 'S'; break;
    case 90:  path[pathLength-3] = 'R'; break;
    case 180: path[pathLength-3] = 'B'; break;
    case 270: path[pathLength-3] = 'L'; break;
  }
  pathLength -= 2;
}