Tutorial Thonny ESP32CAM: Configuración, Flasheo y Programación de la ESP32-CAM en Linux Mint

 

---

# 📑 Tutorial (Versión 2): Configuración, Flasheo y Programación de la ESP32-CAM en Linux Mint

Este tutorial documenta el proceso estándar para preparar el entorno de desarrollo en **Linux Mint**, instalar las herramientas necesarias mediante `pip`, limpiar la memoria de la **ESP32-CAM**, cargar el firmware de **MicroPython** y realizar las primeras pruebas de hardware.

---

## 🏗️ Fase 1: Preparación del Sistema Operativo en Linux Mint

### Opción A: Instalación de Thonny mediante el Script Oficial (Recomendado / Nativo)
Este método instala Thonny de forma nativa en tu carpeta personal (`~/apps/thonny`). Al ejecutarse directamente en el sistema operativo, tiene acceso inmediato al hardware y **no requiere** configuraciones adicionales de aislamiento.

```bash
# 1. Actualizar los repositorios del sistema e instalar Thonny
sudo apt update
wget -qO- https://thonny.org | bash

# 2. Agregar tu usuario al grupo dialout para habilitar los puertos USB
sudo usermod -aG dialout,plugdev $USER
```
*(Nota: Reinicia la computadora después de ejecutar este comando para que Linux Mint aplique los nuevos grupos de usuario).*

### Opción B: Instalación de Thonny mediante la Tienda de Software (Flatpak)
Si instalas Thonny como un paquete plano (Flatpak), el programa correrá dentro de un contenedor aislado (*sandbox*). Debes romper manualmente este aislamiento para permitirle comunicarse con los puertos seriales:

```bash
# 1. Instalar Thonny desde los repositorios de Flathub
flatpak install flathub org.thonny.Thonny -y

# 2. Otorgar permisos explícitos de hardware al contenedor de Thonny
flatpak override org.thonny.Thonny --device=all

# 3. Asegurar los permisos de acceso del usuario a nivel del sistema operativo
sudo usermod -aG dialout,plugdev $USER
```

### 🚏 Paso Obligatorio: Inhabilitar el Conflicto del Lector Braille (`brltty`)
Sin importar el método de instalación que elijas (Opción A o B), Linux Mint activa por defecto un servicio llamado `brltty`. Este proceso se adueña erróneamente del chip serial **FTDI** de tu programador y bloquea el puerto. **Remuévelo por completo ejecutando:**

```bash
sudo systemctl stop brltty-udev.service
sudo systemctl mask brltty-udev.service
sudo apt remove brltty -y
```

---

## 🐍 Fase 2: Configuración del Entorno de Python e Instalación de Esptool

Para cumplir con las normas de seguridad de Linux Mint (PEP 668) y mantener tu sistema limpio, se debe crear un entorno virtual para instalar `esptool` y sus herramientas asociadas de forma automatizada:

```bash
# 1. Navegar a la carpeta de trabajo y crear el entorno virtual
cd ~/Descargas
python3 -m venv esp_env

# 2. Activar el entorno virtual
source esp_env/bin/activate
```
*Sabrás que el entorno está activo porque verás el prefijo `(esp_env)` al inicio de tu terminal.*

```bash
# 3. Instalar esptool de forma estándar con sus dependencias automáticas
pip install esptool
```
*Este comando descargará el núcleo de esptool junto con todos sus paquetes requeridos (`pyserial`, `click`, `rich-click`, `cryptography`, `intelhex`, etc.) en un solo bloque.*

---

## 🔌 Fase 3: Conexión UART, Modos Físicos y Borrado de Flash

### 1. Preparación Física de la ESP32-CAM (Modo Flasheo)
La ESP32-CAM requiere ser puesta manualmente en modo de descarga de firmware. Realiza un **puente físico (jumper) entre el pin GPIO 0 y el pin GND** de la placa. Una vez hecho el puente, conecta el adaptador FTDI / cable USB a la computadora.

### 2. Verificar el Puerto Serial UART
Asegúrate de que el sistema operativo integró la placa de desarrollo ejecutando:
```bash
ls /dev/ttyUSB*
```
*Debe retornar el puerto asignado por el sistema, comúnmente:* `/dev/ttyUSB0`

### 3. Limpieza de la Memoria Flash
Limpia de forma masiva los sectores de memoria interna de la tarjeta ejecutando:
```bash
esptool erase-flash
```
*El proceso tomará unos segundos y finalizará con la confirmación:* `Flash memory erased successfully`.

---

## 💾 Fase 4: Carga del Firmware de MicroPython

Con la memoria limpia, escribe el archivo binario de MicroPython en la dirección de inicio de fábrica (`0x1000`) utilizando una velocidad óptima de comunicación de 460800 baudios:

```bash
esptool --port /dev/ttyUSB0 --baud 460800 write-flash -z 0x1000 ESP32_GENERIC-20260824-v1.29.0.bin
```
*Al finalizar el proceso al 100%, verás la verificación hash exitosa y el reinicio:* `Hard resetting via RTS pin...`.

---

## 💻 Fase 5: Cambio a Modo Ejecución y Prueba de Conexión UART

### 1. El Paso Físico Obligatorio
Para que la tarjeta salga del modo programación y comience a ejecutar MicroPython:
1. **Desconecta el cable USB** de la computadora.
2. **Retira por completo el puente (jumper) entre GPIO 0 y GND**.
3. Vuelve a conectar el cable USB a la computadora.
4. Presiona una vez el botón físico **RST / EN** ubicado en la parte trasera de la ESP32-CAM.

### 2. Probar la terminal de MicroPython (REPL) vía Miniterm
Comprueba la comunicación utilizando la utilidad nativa de `pyserial`:
```bash
python3 -m serial.tools.miniterm /dev/ttyUSB0 115200
```
* Presiona **Enter** un par de veces hasta ver los símbolos **`>>>`**.
* **🚨 TIP VITAL:** Para salir de miniterm y liberar el puerto para Thonny, presiona **`Ctrl + ]`**. Si no cierras este monitor, el puerto quedará ocupado.

---

## 🛠️ Fase 6: Configuración de Thonny IDE

1. Abre **Thonny IDE** desde tu menú de aplicaciones de Linux Mint.
2. Ve al menú superior: **Herramientas** -> **Opciones** -> pestaña **Intérprete**.
3. En el primer menú desplegable selecciona: **MicroPython (ESP32)**.
4. En el puerto selecciona manualmente: **`/dev/ttyUSB0`**.
5. Haz clic en **Aceptar**.

### 🛑 El Secreto del Botón Stop
Cada vez que inicies Thonny, modifiques un archivo o sientas que la consola está congelada, haz clic en el **botón rojo "Stop"** (o presiona `Ctrl + F2`). Esto enviará una señal de interrupción al microcontrolador para detener cualquier bucle en segundo plano y te devolverá de forma limpia el prompt **`>>>`** listo para recibir instrucciones.

---

## 💡 Fase 7: Pruebas de Hardware en MicroPython (Modo Consola)

Ingresa las siguientes líneas de código directamente en el prompt `>>>` de la consola inferior de Thonny para interactuar con los periféricos de la ESP32-CAM:

### 1. Prueba con el LED Flash de Alta Potencia (GPIO 4 - Lógica Normal)
El flash frontal blanco responde a la lógica estándar (`1` enciende, `0` apaga):
```python
import machine

# Configurar el pin 4 como salida
flash = machine.Pin(4, machine.Pin.OUT)

# Controlar el encendido y apagado
flash.value(1)   # 🌟 ENCIENDE el Flash
flash.value(0)   # 🌑 APAGA el Flash

flash.on()       # 🌟 ENCIENDE el Flash
flash.off()      # 🌑 APAGA el Flash
```

### 2. Prueba con el LED Indicador Trasero Rojo (GPIO 33 - Lógica Inversa)
El pequeño LED rojo trasero responde a la lógica invertida debido a su diseño electrónico (*Active Low*), donde un estado `0` activa el paso de energía y un estado `1` lo interrumpe:
```python
# Configurar el pin 33 como salida
led_rojo = machine.Pin(33, machine.Pin.OUT)

# Controlar mediante Lógica Inversa
led_rojo.value(0)  # 🔴 ENCIENDE el LED rojo
led_rojo.value(1)  # 🌑 APAGA el LED rojo

led_rojo.off()     # 🔴 ENCIENDE el LED rojo (envía un 0 físico)
led_rojo.on()      # 🌑 APAGA el LED rojo (envía un 1 físico)
```

---