Premios CAEV

Descripción: Los jóvenes programarán la placa para automatizar un estudio de crecimiento botánico a medio plazo (fototropismo y germinación). La cámara capturará imágenes fijas a intervalos regulares, gestionará el almacenamiento local físico en una tarjeta MicroSD y entrará en estados de hibernación profunda (Deep Sleep) para proteger los componentes del calor continuo.

1. Acondicionamiento del Medio de Almacenamiento

• El ESP32-CAM utiliza ranuras de conexión por bus MMC de un solo hilo que exigen tarjetas con formato antiguo. Consigue una MicroSD de entre 4GB y 32GB de capacidad máxima.
• Introduce la tarjeta en el ordenador, haz clic derecho sobre la unidad y selecciona Formatear. Escoge imperativamente el sistema de archivos FAT32. Si utilizas exFAT o *NTFS*, el código devolverá error de lectura de hardware.

2. Lógica del Código Avanzado (Arquitectura del Script)

A diferencia de un ordenador, cuando el ESP32 entra en sueño profundo, borra su memoria RAM interna. Si guardamos la foto con el nombre fijo foto.jpg, en cada despertar el programa sobrescribirá la foto anterior. Solucionaremos esto utilizando la memoria no volátil EEPROM de la placa para guardar el número de la foto actual.

Crea un nuevo boceto vacío en Arduino IDE e implementa la siguiente estructura lógica combinando las librerías de control de cámara:

#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h"                // Sistema de archivos
#include "SD_MMC.h"            // Control de la MicroSD dedicada
#include "EEPROM.h"            // Memoria permanente para el contador

#define EEPROM_SIZE 2
#define TIME_TO_SLEEP 3600     // Intervalo de captura: 3600 segundos (1 hora)

void setup() {
  Serial.begin(115200);
  EEPROM.begin(EEPROM_SIZE);
  
  // 1. Inicializar los pines de la cámara (Modelo AI-Thinker)
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  // ... (Configuración estándar de la estructura de la cámara a resolución UXGA)
  
  esp_err_t err = esp_camera_init(&config);
  
  // 2. Arrancar la Tarjeta MicroSD
  if(!SD_MMC.begin()){
      Serial.println("Error: Tarjeta SD no detectada");
      return;
  }
  
  // 3. Capturar frame de la planta
  camera_fb_t * fb = esp_camera_fb_get();  
  if(!fb) { Serial.println("Fallo en captura"); return; }
  
  // 4. Leer ID de foto actual de la EEPROM e incrementar
  unsigned int pictureNumber = EEPROM.read(0) + (EEPROM.read(1) << 8);
  pictureNumber++;
  
  // Definir la ruta del archivo (Ejemplo: /planta_1.jpg)
  String path = "/planta_" + String(pictureNumber) + ".jpg";
  
  fs::FS &fs = SD_MMC;
  File file = fs.open(path.c_str(), FILE_WRITE);
  if(!file){
      Serial.println("Error al abrir archivo para escritura");
  } else {
      file.write(fb->buf, fb->len); // Escribir los bytes de la imagen
      Serial.printf("Guardado correctamente en: %s\n", path.c_str());
  }
  file.close();
  esp_camera_fb_return(fb); // Liberar memoria de la cámara
  
  // Guardar el nuevo número de foto en la EEPROM
  EEPROM.write(0, pictureNumber & 0xFF);
  EEPROM.write(1, (pictureNumber >> 8) & 0xFF);
  EEPROM.commit();
  
  // 5. Configurar temporizador e ir a Sueño Profundo
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * 1000000ULL);
  Serial.println("Entrando en Deep Sleep...");
  esp_deep_sleep_start();
}

void loop() {}

3. Despliegue en Campo y Procesado Final

1. Inserta la MicroSD formateada en la ranura metálica trasera deslizando el anclaje hacia abajo para asegurar los pines.
2. Carga el programa modificado en el dispositivo.
3. Desconecta el cable del ordenador y alimenta el módulo fijándolo con cinta o un trípode apuntando directamente a una maceta o semillero. Puedes usar un cargador de pared común de 5V.
4. El Montaje Audiovisual: Tras finalizar el ciclo de observación (ej. 5 días), extrae la tarjeta. En tu ordenador verás archivos correlativos desde planta_1.jpg hasta planta_120.jpg.
5. Utiliza un software libre de edición (como VLC, FFmpeg o editores móviles como CapCut) para importar la secuencia completa de imágenes ordenadas por nombre, asignando una velocidad de exposición de 10 imágenes por segundo (0.1s por frame). El resultado revelará el movimiento natural imperceptible del crecimiento vegetal del cultivo.

Descripción: Introducción experimental avanzada al concepto de Edge Computing y TinyML. Los alumnos entrenarán una red neuronal de aprendizaje profundo (Convolutional Neural Network) para clasificar enfermedades del cultivo (ej: Hoja Sana vs Hoja con Clorosis/Plaga). El ESP32-CAM procesará la clasificación de forma interna y matemática sin enviar datos a la red.

1. Construcción de la Base de Datos Visual (Dataset)

• La Inteligencia Artificial requiere datos de ejemplo rigurosos. El grupo de alumnos debe recopilar un banco de imágenes de control.
• Utilizando el proyecto del Nivel 1 o cámaras móviles convencionales, captura al menos 40 fotografías de primer plano de hojas perfectamente sanas, bien iluminadas y enfocadas, y otras 40 fotografías de hojas enfermas de la misma especie (con manchas, hongos o roturas).
• Clasifica las imágenes en el ordenador en dos carpetas locales llamadas respectivamente: sanas y enfermas.

2. Entrenamiento de la Red Neuronal con Edge Impulse

1. Crea un perfil de desarrollo gratuito en la plataforma especializada Edge Impulse Studio (edgeimpulse.com).
2. Crea un proyecto nuevo y ve a la sección Data Acquisition > Upload existing data. Sube los archivos de la carpeta local sanas asignándoles la etiqueta de entrenamiento sana. Repite la acción para la carpeta de patologías bajo la etiqueta enferma.
3. Navega hasta Impulse Design:
   • Añade un bloque de procesamiento de tipo: Image Processing Block. Configura las dimensiones de análisis a 96 x 96 píxeles. (Esta reducción drástica es obligatoria para que la matriz matemática quepa dentro de la memoria RAM estática del ESP32).
   • Añade un bloque de aprendizaje automático de tipo: Classification (Keras).
4. Ve a la pestaña secundaria Image dentro del menú izquierdo y pulsa el botón Save parameters. Luego haz clic en la pestaña superior Generate features para transformar los píxeles de color RGB en vectores matemáticos normalizados de contraste y espectro cromático.
5. Accede a Classifier. Configura el entrenamiento a 50 épocas con una tasa de aprendizaje de 0.005. Selecciona una arquitectura de red optimizada para microcontroladores como MobileNetV2 96x96 (0.1). Haz clic en Start Training.
6. Espera a que finalice la computación en la nube. Observa la matriz de confusión. Si el parámetro de precisión (Accuracy) es inferior al 75%, el modelo fallará en campo; revisa que las fotos no tengan fondos caóticos o sombras difusas y vuelve a entrenar.

3. Exportación y Programación de la IA en C++

1. En el panel lateral de Edge Impulse, dirígete a la sección Deployment.
2. En el listado de tecnologías de despliegue, selecciona el botón flotante Arduino Library. En las opciones inferiores, verifica que esté marcada la casilla Quantized (Int8) y haz clic en Build. La web compilará y descargará un archivo empaquetado comprimido en formato .zip.
3. Abre tu Arduino IDE, dirígete a la pestaña superior Programa > Incluir Librería > Añadir librería .ZIP... y selecciona el archivo recién descargado.
4. Ahora ve a Archivo > Ejemplos > Busca el nombre exacto de tu librería exportada > esp32 > esp32_cam. Este ejemplo autogenerado ya contiene la lógica estructural para encender la cámara y meter los píxeles del sensor directo a la red neuronal.
5. Asegúrate de comprobar la sección de mapeo de pines al inicio del código cargado y descomenta los pines asignados a la placa modelo AI_THINKER. Sube el programa a tu placa a través del programador USB.

4. Validación en Tiempo Real

1. Inicia el Monitor Serie configurando la salida fija a 115200 baudios.
2. Sujeta una hoja real del cultivo frente al objetivo de la cámara a una distancia aproximada de 5 a 10 cm.
3. El terminal del ordenador imprimirá de manera continua el retardo de inferencia seguido de las probabilidades estadísticas de la Red:

   Predictions (DSP: 12 ms, Infe: 142 ms):
     enferma: 0.8923
     sana: 0.1077

   Esto significa que el procesador local deduce de manera autónoma con un 89.2% de certeza que la muestra inspeccionada presenta anomalías morfológicas, permitiendo un diagnóstico automatizado en campo sin necesidad de conectarse a servidores remotos externos.