Tutorial 7: Obstáculos y RGB

¿Qué vamos a hacer?

Aprende a darle «ojos» a tu ESP32-C3 SuperMini. Con el Módulo de Evitación de Obstáculos y el LED RGB de tu kit, podrás detectar la presencia de objetos cercanos y mostrar diferentes alertas visuales.

Al final de este tutorial, serás capaz de:

• Conectar y leer el estado de un módulo de evitación de obstáculos.
• Usar un LED RGB para indicar diferentes estados de detección de forma visual.
• Implementar una lógica avanzada que cambie el color del LED RGB según la frecuencia y duración de la detección de obstáculos.

Requisitos Previos:

Antes de comenzar, asegúrate de tener lo siguiente:

• ESP32-C3 SuperMini (1 unidad)
• Módulo de Evitación de Obstáculos (1 unidad)
• LED RGB (1 unidad)
• 3 Resistencias de 220 Ohm (una para cada pin de color del LED RGB)
• Cables Dupont F-M y M-M
• Protoboard de 830 puntos (1 unidad)
• IDE de Arduino con la plataforma ESP32 instalada y configurada (Tutorial 0).

---

Actividad 1: Detectando Obstáculos y Mostrando en Monitor Serial

Dificultad: Baja

Objetivo: Conectar el sensor y mostrar «Obstáculo Detectado» o «Libre» en el Monitor Serial.

Descripción: Esta actividad te familiarizará con el sensor de evitación de obstáculos. Lo conectarás a tu ESP32-C3 y escribirás un código simple para saber cuándo se detecta un objeto en su camino, viendo el resultado en el Monitor Serial del IDE de Arduino.

Materiales que necesitas:

• ESP32-C3 SuperMini
• Módulo de Evitación de Obstáculos
• Cables Dupont

¿Qué es el Módulo de Evitación de Obstáculos?

El Módulo de Evitación de Obstáculos es un sensor infrarrojo (IR) que detecta la presencia de objetos cercanos. Funciona emitiendo una pequeña luz infrarroja y detectando si esta rebota en algo y regresa al sensor. Si la luz rebota, el sensor detecta el objeto y su pin de salida cambia de estado. Si no hay rebote, el pin se mantiene en su estado normal.

Este módulo tiene un potenciómetro (un tornillo pequeño) para ajustar la distancia o sensibilidad de detección. Generalmente, su pin de salida pasa a BAJO (LOW) cuando detecta un obstáculo y se mantiene en ALTO (HIGH) cuando no lo hay. Es una salida digital simple de «sí hay» o «no hay» obstáculo.

Conexión del circuito (Módulo de Evitación de Obstáculos):

¡Antes de conectar, asegúrate de que tu ESP32-C3 SuperMini esté desconectada del computador!

El módulo de evitación de obstáculos suele tener 3 pines:

• Pin VCC o + del módulo a 3.3V en tu ESP32-C3.
• Pin GND o - del módulo a GND en tu ESP32-C3.
• Pin OUT (Salida Digital) del módulo a GPIO 5 en tu ESP32-C3. (Puedes usar cualquier pin digital disponible).

---

Esquemático y Simulación en Wokwi:

Observa cómo se conecta el módulo de evitación de obstáculos a tu ESP32-C3 SuperMini. En Wokwi, podrás simular la presencia de un obstáculo y ver cómo cambia el estado del sensor en el Monitor Serial.

---

Código para la Actividad 1:

Para esta actividad, no necesitas librerías adicionales, ya que digitalRead() es una función nativa de Arduino.

#define OBSTACLE_SENSOR_PIN GPIO_NUM_5

int obstacleState = HIGH;      // Estado actual del sensor
int lastObstacleState = HIGH;  // Estado anterior para detectar cambios

void setup() {
  Serial.begin(115200);
  Serial.println(F("Iniciando Monitor de Deteccion de Obstaculos..."));
  pinMode(OBSTACLE_SENSOR_PIN, INPUT); // Configura el pin del sensor como entrada
}

void loop() {
  // Lee el estado actual del sensor (LOW si detecta obstáculo, HIGH si no)
  obstacleState = digitalRead(OBSTACLE_SENSOR_PIN);

  // Detecta un cambio en el estado del sensor
  if (obstacleState != lastObstacleState) {
    if (obstacleState == LOW) { // La mayoría de estos módulos envían LOW al detectar obstáculo
      Serial.println(F("¡OBSTACULO DETECTADO!"));
    } else {
      Serial.println(F("Obstaculo AUSENTE."));
    }
    delay(50); // Pequeña pausa para estabilizar la lectura después del cambio
    lastObstacleState = obstacleState; // Actualiza el estado anterior
  }

  delay(10); // Pequeña pausa entre lecturas para no sobrecargar el bucle
}

---

Actividad 2: Explorando el LED RGB

Dificultad: Media

Objetivo: Aprender a controlar un LED RGB para mostrar una secuencia de colores aleatorios.

Descripción: Esta actividad te permitirá experimentar con las posibilidades visuales del LED RGB de tu kit. Aprenderás a encender sus colores básicos y a generar combinaciones aleatorias para crear efectos de iluminación divertidos y dinámicos.

Materiales que necesitas:

• ESP32-C3 SuperMini
• LED RGB (el que viene en tu kit)
• 3 Resistencias de 220 Ohm (una para cada pin de color del LED RGB)
• Cables Dupont
• Protoboard

¿Qué es un LED RGB?

Conexión del circuito:

¡Asegúrate de que tu ESP32-C3 SuperMini esté desconectada del computador!

• Conexiones LED RGB (Cátodo Común):
  • La patilla más larga del LED RGB (Cátodo Común) a GND.
  • La patilla del color Rojo a una Resistencia de 220 Ohm, y el otro extremo de la resistencia a GPIO 3 en tu ESP32-C3.
  • La patilla del color Verde a una Resistencia de 220 Ohm, y el otro extremo de la resistencia a GPIO 9 en tu ESP32-C3.
  • La patilla del color Azul a una Resistencia de 220 Ohm, y el otro extremo de la resistencia a GPIO 1 en tu ESP32-C3.

---

Esquemático y Simulación en Wokwi:

Aquí verás cómo se conecta el LED RGB y cómo cambia de color aleatoriamente. Haz clic en la imagen para abrir la simulación en Wokwi y observa los efectos de luz.

---

Código para la Actividad 2:

#define RGB_RED_PIN   GPIO_NUM_3
#define RGB_GREEN_PIN GPIO_NUM_9
#define RGB_BLUE_PIN  GPIO_NUM_1

// Función para establecer el color del LED RGB (para LED de Cátodo Común)
void setRgbColor(bool red, bool green, bool blue) {
  digitalWrite(RGB_RED_PIN, red ? HIGH : LOW);
  digitalWrite(RGB_GREEN_PIN, green ? HIGH : LOW);
  digitalWrite(RGB_BLUE_PIN, blue ? HIGH : LOW);
}

void setup() {
  Serial.begin(115200);
  Serial.println(F("Iniciando show de luces RGB aleatorias..."));
  pinMode(RGB_RED_PIN, OUTPUT);
  pinMode(RGB_GREEN_PIN, OUTPUT);
  pinMode(RGB_BLUE_PIN, OUTPUT);

  // Inicializa el generador de números aleatorios.
  // Usamos analogRead(algún pin no conectado) para una mejor aleatoriedad.
  randomSeed(analogRead(GPIO_NUM_0)); // GPIO_NUM_0 es un pin analógico disponible
}

void loop() {
  // Genera tres números aleatorios (0 o 1) para cada color
  int randomRed = random(2);   // 0 o 1
  int randomGreen = random(2); // 0 o 1
  int randomBlue = random(2);  // 0 o 1

  // Establece el color del LED RGB
  setRgbColor(randomRed, randomGreen, randomBlue);

  // Muestra el color actual en el Monitor Serial
  Serial.print(F("Color aleatorio: R="));
  Serial.print(randomRed);
  Serial.print(F(", G="));
  Serial.print(randomGreen);
  Serial.print(F(", B="));
  Serial.println(randomBlue);

  delay(1000); // Cambia de color cada 1 segundo
}

---

Actividad 3: Alerta RGB Avanzada: Detecciones Múltiples y Duración

Dificultad: Alta

Objetivo: Controlar el LED RGB para mostrar diferentes colores y patrones según la cantidad de veces que se detecta un obstáculo y el tiempo que este permanece presente.

Descripción: Esta es la actividad más desafiante y visualmente rica. Tu LED RGB reaccionará de forma inteligente:

• «Todo Despejado»: LED RGB en VERDE.
• Primera Detección Corta: LED RGB en AMARILLO.
• Detecciones Múltiples y Rápidas (2 o más): LED RGB en MAGENTA.
• Obstáculo Presente por Mucho Tiempo (más de 3 segundos): LED RGB en ROJO parpadeante, indicando una situación persistente.

Materiales que necesitas:

• (Mismos que la Actividad 2)

Conexión del circuito:

(Misma que la Actividad 2)

Esquemático y Simulación en Wokwi:

Aquí verás cómo el LED RGB cambia de color y parpadea en respuesta a las diferentes situaciones de detección de obstáculos.

Código para la Actividad 3:

#define OBSTACLE_SENSOR_PIN GPIO_NUM_5
#define RGB_RED_PIN   GPIO_NUM_3
#define RGB_GREEN_PIN GPIO_NUM_9
#define RGB_BLUE_PIN  GPIO_NUM_1

// Variables para el estado del sensor y lógica avanzada
int obstacleState = HIGH;
int lastObstacleState = HIGH;
int detectionCount = 0;       // Contador de detecciones rápidas
unsigned long lastDetectionTime = 0; // Tiempo de la última detección
unsigned long obstaclePresentStartTime = 0; // Tiempo en que el obstáculo se detectó por primera vez y se mantiene
const long DETECTION_RESET_INTERVAL = 1000; // Si no hay detección por 1 segundo, resetear el contador de detecciones
const long LONG_PRESENCE_THRESHOLD = 3000; // 3 segundos para considerar "mucho tiempo"

void setRgbColor(bool red, bool green, bool blue) {
  digitalWrite(RGB_RED_PIN, red ? HIGH : LOW);
  digitalWrite(RGB_GREEN_PIN, green ? HIGH : LOW);
  digitalWrite(RGB_BLUE_PIN, blue ? HIGH : LOW);
}

void setup() {
  Serial.begin(115200);
  Serial.println(F("Sistema de Alerta RGB Avanzada de Obstaculos Iniciado."));
  pinMode(OBSTACLE_SENSOR_PIN, INPUT);
  pinMode(RGB_RED_PIN, OUTPUT);
  pinMode(RGB_GREEN_PIN, OUTPUT);
  pinMode(RGB_BLUE_PIN, OUTPUT);

  setRgbColor(LOW, HIGH, LOW); // Estado inicial: VERDE (Todo Despejado)
}

void loop() {
  obstacleState = digitalRead(OBSTACLE_SENSOR_PIN);
  unsigned long currentTime = millis();

  // Reiniciar contador de detecciones si ha pasado un tiempo sin detectar nada
  if (currentTime - lastDetectionTime > DETECTION_RESET_INTERVAL && detectionCount > 0) {
    detectionCount = 0;
    // Aseguramos que si vuelve a estar libre, el LED sea verde
    if (obstacleState == HIGH) {
      setRgbColor(LOW, HIGH, LOW); // Verde
      Serial.println("Reseteo de detecciones. Verde.");
    }
  }


  // Lógica principal de cambio de estado
  if (obstacleState != lastObstacleState) {
    if (obstacleState == LOW) { // ¡Obstáculo DETECTADO!
      detectionCount++;
      lastDetectionTime = currentTime; // Actualiza el tiempo de la última detección
      if (obstaclePresentStartTime == 0) { // Si es la primera detección continua
        obstaclePresentStartTime = currentTime;
      }

      if (detectionCount == 1) {
        setRgbColor(HIGH, HIGH, LOW); // AMARILLO (Primera Detección)
        Serial.println("¡OBSTACULO! (1ra Deteccion) --> AMARILLO.");
      } else if (detectionCount >= 2) {
        setRgbColor(HIGH, LOW, HIGH); // MAGENTA (Detecciones Multiples)
        Serial.println("¡OBSTACULO! (Detecciones Multiples) --> MAGENTA.");
      }
    } else { // Obstáculo AUSENTE (el camino está libre)
      setRgbColor(LOW, HIGH, LOW); // VERDE (Todo Despejado)
      Serial.println("Camino LIBRE --> VERDE.");
      detectionCount = 0;          // Resetea el contador al estar libre
      obstaclePresentStartTime = 0; // Resetea el tiempo de presencia
    }
    delay(50); // Pequeña pausa para estabilizar
    lastObstacleState = obstacleState; // Actualiza el estado anterior
  }

  // Lógica para Obstáculo Presente por Mucho Tiempo (parpadeo en Rojo)
  if (obstacleState == LOW && obstaclePresentStartTime != 0 &&
      (currentTime - obstaclePresentStartTime > LONG_PRESENCE_THRESHOLD)) {

    // Si ya está parpadeando, mantén el parpadeo
    if ((currentTime / 250) % 2 == 0) { // Parpadea cada 500ms (250ms ON, 250ms OFF)
      setRgbColor(HIGH, LOW, LOW); // ROJO
    } else {
      setRgbColor(LOW, LOW, LOW); // APAGADO
    }
    // Solo imprime una vez al inicio del parpadeo
    if (lastObstacleState != -1) { // Usamos -1 para indicar que ya está en este estado de parpadeo
      Serial.println("¡OBSTACULO PERSISTENTE! --> ROJO PARPADEANTE.");
      lastObstacleState = -1; // Marca un estado especial para el parpadeo
    }
  } else if (obstacleState == HIGH && lastObstacleState == -1) {
    // Si estaba parpadeando y se libera el camino, resetear el estado anterior
    lastObstacleState = HIGH;
    setRgbColor(LOW, HIGH, LOW); // Volver a VERDE
    Serial.println("Obstaculo persistente removido --> VERDE.");
  }


  delay(10); // Pequeña pausa en el bucle
}