miércoles, 7 de octubre de 2026

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)
```




martes, 6 de octubre de 2026

Guía Paso a Paso: Instalación de MicroPython y Programación de la ESP8266 NodeMCU Amica en Linux Mint

 

Guía Paso a Paso: Instalación de MicroPython y Programación de la ESP8266 NodeMCU Amica en Linux Mint

Autor: AlexanderArias Londoño
Clase: IoT
Fecha: 6 de octubre de 2026


La tarjeta de desarrollo ESP8266 NodeMCU Amica es una plataforma versátil y económica ampliamente utilizada en proyectos de Internet de las Cosas (IoT). Programar este dispositivo con MicroPython bajo Linux Mint permite crear aplicaciones empotradas eficientes utilizando la sintaxis de Python.

Esta guía paso a paso abarca desde la preparación inicial de Linux Mint y la resolución de conflictos con puertos serie, hasta el flasheado del firmware, la resolución de problemas comunes como el bucle de reinicio (boot loop) y la configuración de Thonny IDE para ejecutar scripts interactivos.


1. Preparación del Sistema Operativo Linux Mint

Antes de conectar la tarjeta ESP8266, es necesario preparar el entorno de Linux Mint para asegurar la correcta detección del convertidor serie USB (generalmente los chips CP2102 o CH340).

Paso 1.1: Diagnóstico del hardware USB con lsusb

Conecte la tarjeta ESP8266 a la computadora utilizando un cable USB que soporte transmisión de datos. Abra una terminal (Ctrl + Alt + T) y ejecute:

lsusb

Examine la lista desplegada. Debe identificar una línea similar a una de las siguientes:

  • Bus 001 Device 005: ID 10c4:ea60 Silicon Labs CP210x UART Bridge
  • Bus 001 Device 004: ID 1a86:7523 QinHeng Electronics CH340 serial converter

Nota de diagnóstico: Si no aparece ninguna línea nueva al conectar la placa, reemplace el cable USB. Muchos cables comerciales económicos solo incluyen líneas de alimentación eléctrica y carecen de hilos de datos.

Paso 1.2: Eliminación del servicio conflictivo brltty

En distribuciones basadas en Debian y Ubuntu como Linux Mint, el servicio del sistema brltty (diseñado para lectores de pantalla Braille) intercepta automáticamente los convertidores USB-Serie al detectarlos, provocando que el puerto /dev/ttyUSB0 desaparezca a los pocos segundos de ser creado.

Para eliminar esta interferencia, desinstale el paquete ejecutando:

sudo apt remove brltty

Paso 1.3: Asignación de permisos de acceso serie (dialout)

Por defecto, los dispositivos serie en Linux pertenecen al grupo de sistema dialout. Para interactuar con la tarjeta sin requerir permisos de superusuario (sudo), agregue su usuario actual al grupo:

sudo usermod -aG dialout $USER

Importante: Debe cerrar la sesión en Linux Mint y volver a iniciarla para que el sistema aplique el cambio de grupo.

Paso 1.4: Confirmación del puerto /dev/ttyUSB0

Reconecte la tarjeta a la computadora y verifique la creación del puerto serie:

ls /dev/ttyUSB*

Si la terminal responde con /dev/ttyUSB0, la comunicación física está correctamente establecida.


2. Creación del Entorno Virtual de Python e Instalación de esptool

Para cumplir con las especificaciones de gestión de paquetes de Python en Linux Mint (PEP 668), la herramienta oficial de flasheado de Espressif (esptool) debe instalarse dentro de un entorno virtual aislado.

  1. Cree un entorno virtual denominado esp_env en su carpeta personal:
    python3 -m venv esp_env
    
  2. Active el entorno virtual:
    source esp_env/bin/activate
    
    (Verá la etiqueta (esp_env) al inicio del indicador de la terminal).
  3. Instale o actualice esptool:
    pip install esptool
    

3. Descarga y Flasheado del Firmware de MicroPython

A diferencia de los microcontroladores ESP32 (donde la memoria flash se graba a partir de la dirección 0x1000), en la arquitectura ESP8266 la imagen del firmware debe escribirse comenzando exactamente en la dirección 0x0.

Paso 3.1: Descarga del firmware binario

  1. Visite la sección oficial de descargas de MicroPython para ESP8266 en micropython.org/download/esp8266.
  2. Descargue la versión estable más reciente en formato .bin y guarde el archivo en su carpeta ~/Descargas.

Paso 3.2: Borrado de la memoria flash

Con el entorno (esp_env) activo en la terminal, elimine el contenido previo de la memoria flash de la tarjeta:

esptool --port /dev/ttyUSB0 --chip esp8266 erase-flash

Espere aproximadamente 10 segundos hasta que la terminal confirme Flash memory erased successfully.

Paso 3.3: Grabación del firmware en modo dout

Muchas tarjetas NodeMCU Amica cuentan con memorias flash SPI que requieren el modo de comunicación dout (Dual Output) y una asignación explícita del tamaño de memoria (4MB). Usar otros modos (como dio o qio) puede causar que la placa falle al arrancar.

Ejecute el siguiente comando de grabado:

esptool --port /dev/ttyUSB0 --chip esp8266 write-flash --flash-mode dout --flash-size 4MB 0x0 ~/Descargas/ESP8266_GENERIC-*.bin

Sugerencia de conexión: Si la terminal muestra el mensaje Connecting......_____, mantenga presionado el botón físico FLASH (o BOOT) de la placa durante 2 segundos hasta que comience el progreso de transferencia.

Al llegar al 100%, desconecta el cable USB del ordenador, espera 5 segundos y vuelve a conectarlo para realizar un reinicio eléctrico completo del chip.


4. Diagnóstico de Caracteres Extraños y Bucle de Reinicio (Boot Loop)

Si al intentar conectar la tarjeta observa que el LED azul parpadea rápidamente de forma ininterrumpida y en la terminal aparecen caracteres raros o símbolos corruptos ($plN|...), la placa se encuentra en un bucle de reinicio.

¿Por qué ocurren los caracteres extraños?

Al encenderse o reiniciar, el gestor de arranque (bootloader) del chip ESP8266 emite mensajes de diagnóstico a una velocidad nativa de 74880 baudios. Como los entornos como Thonny escuchan a la velocidad estándar de 115200 baudios, esa diferencia de velocidad provoca que el texto legible se convierta en símbolos extraños.

Verificación del diagnóstico con miniterm

Para leer los mensajes de diagnóstico reales del bootloader y confirmar la causa del reinicio, puede abrir una terminal a 74880 baudios:

python3 -m serial.tools.miniterm /dev/ttyUSB0 74880
  • Si observa texto legible indicando el estado del sistema, presione Ctrl + ] (o cierre la terminal) para salir de miniterm.
  • Si confirma que la tarjeta se reinicia continuamente, la causa principal es haber flasheado sin la opción --flash-mode dout. Repita el Paso 3.2 y Paso 3.3 asegurándose de incluir --flash-mode dout.

5. Configuración de Thonny IDE

Una vez grabado el firmware correctamente y realizado el reinicio eléctrico, configure el entorno Thonny:

  1. Inicie la aplicación Thonny en Linux Mint.
  2. Vaya al menú superior Herramientas > Opciones... (Tools > Options...).
  3. Seleccione la pestaña Intérprete (Interpreter).
  4. En la opción de microcontrolador, seleccione MicroPython (ESP8266).
  5. En la opción de puerto, seleccione /dev/ttyUSB0.
  6. Presione Aceptar.

Haga clic en la consola inferior (Shell) de Thonny y presione Ctrl + C o Ctrl + D. Verá aparecer la consola interactiva con el prompt >>>:

MicroPython v1.2x.x on 2026-xx-xx; ESP module with ESP8266
Type "help()" for more information.
>>>

6. Pruebas de Funcionamiento y Control de E/S con machine

En la tarjeta ESP8266 NodeMCU Amica, el LED azul integrado en la placa está conectado al pin GPIO 2 (marcado en la serigrafía como D4).

Mapeo de estados y lógica invertida

El circuito del LED integrado en la ESP8266 funciona con lógica invertida:

Nivel LógicoEstado en MicroPythonNivel de VoltajeEstado del LED
0 (LOW)led.value(0)0 V (GND)ENCENDIDO
1 (HIGH)led.value(1)3.3 VAPAGADO

Código de prueba interactivo (Shell)

Escriba las siguientes órdenes directamente en la consola >>> de Thonny para encender y apagar el LED:

import machine

# Configurar GPIO 2 como salida digital
led = machine.Pin(2, machine.Pin.OUT)

# Encender el LED azul integrado
led.value(0)

# Apagar el LED azul integrado
led.value(1)

Programa autónomo de parpadeo (main.py)

Para que la tarjeta ejecute la rutina de forma automática cada vez que se conecte a la energía sin depender de la computadora:

  1. En Thonny, cree un archivo nuevo (Archivo > Nuevo).

  2. Copie el siguiente código:

    import machine
    import time
    
    # Pin GPIO 2 correspondiente al LED de la NodeMCU
    led = machine.Pin(2, machine.Pin.OUT)
    
    # Bucle principal de parpadeo
    while True:
        led.value(0)   # Encender LED (0V / LOW)
        time.sleep(1)  # Esperar 1 segundo
        led.value(1)   # Apagar LED (3.3V / HIGH)
        time.sleep(1)  # Esperar 1 segundo
    
  3. Guarde el archivo seleccionando como destino Dispositivo MicroPython (MicroPython device).

  4. Asígnele el nombre exacto main.py.

Al presionar el botón de reinicio RST de la NodeMCU Amica, el programa main.py se iniciará automáticamente, haciendo parpadear el LED de forma indefinida.

Guía Completa: Flasheado de MicroPython en ESP32 WROOM desde Linux Mint y Configuración en Thonny IDE

 

Guía Completa: Flasheado de MicroPython en ESP32 WROOM desde Linux Mint y Configuración en Thonny IDE

Autor: AlexanderArias Londoño
Clase: IoT
Fecha: 6 de octubre de 2026


El desarrollo de soluciones para Internet de las Cosas (IoT) utilizando la tarjeta ESP32 WROOM de 30 pines en el sistema operativo Linux Mint requiere realizar una adecuada configuración de permisos de comunicación serie, resolver conflictos con servicios en segundo plano del sistema operativo y gestionar las herramientas de flasheado mediante un entorno virtual de Python.

Esta guía ofrece un procedimiento paso a paso adaptado para Linux Mint para descargar el firmware oficial de MicroPython, preparar los permisos del sistema, instalar el entorno de grabado esptool, vincular la placa con Thonny IDE y ejecutar el programa de control del LED integrado mediante el módulo machine.


1. Identificación y Diagnóstico del Hardware en Linux Mint

Antes de proceder con la instalación del firmware, es necesario verificar que el kernel de Linux Mint reconozca correctamente el chip conversor USB a Serie de la tarjeta ESP32 (por lo general, chips como Silicon Labs CP210x o QinHeng Electronics CH340/CH341).

  1. Conecte la tarjeta ESP32 WROOM a un puerto USB de la computadora mediante un cable de datos.
  2. Abre una terminal (Ctrl + Alt + T) y ejecute el comando:
    lsusb
    
  3. Verifique la presencia del dispositivo en la lista (por ejemplo, Silicon Labs CP210x UART Bridge o QinHeng Electronics CH340 serial converter). Si el comando no muestra ningún dispositivo nuevo al conectar y desconectar la placa, reemplace el cable USB por uno certificado para transmisión de datos.

2. Paso 1: Descarga del Firmware Oficial de MicroPython

El firmware contiene el intérprete de MicroPython que se ejecutará dentro de la memoria flash del microcontrolador.

  1. Visite el sitio web oficial de MicroPython (micropython.org/download/esp32).
  2. Descargue la versión binaria estable correspondiente al microcontrolador ESP32 (archivo genérico .bin para ESP32 WROOM).
  3. Guarde el archivo descargado en la carpeta de descargas del usuario (~/Descargas).

3. Paso 2: Permisos de Puerto USB y Solución al Conflicto con brltty

Linux Mint protege los puertos serie (/dev/ttyUSB0 o /dev/ttyACM0) restringiendo el acceso únicamente a usuarios administradores o miembros del grupo de comunicación dialout.

Configuración del grupo dialout

Para otorgar acceso permanente a los puertos de comunicación sin necesidad de usar sudo continuamente:

sudo usermod -a -G dialout $USER

Nota obligatoria: Cierre la sesión de usuario y vuelva a iniciarla (o reinicie el sistema) para que Linux Mint aplique el cambio de grupo.

Desinstalación del servicio brltty

En distribuciones basadas en Ubuntu y Debian como Linux Mint, el servicio de accesibilidad brltty se ejecuta en segundo plano e interrumpe los convertidores USB-Serie (especialmente el chip CH340), desconectando el puerto /dev/ttyUSB0 inmediatamente después de enchufar la tarjeta.

Para desinstalarlo y liberar el puerto, ejecute:

sudo apt remove brltty

4. Paso 3: Entorno Virtual e Instalación de esptool

Para cumplir con la directiva PEP 668 en Linux Mint, que previene la modificación directa de los paquetes de Python del sistema operativo, se crea un entorno virtual aislado.

  1. Instale los paquetes necesarios e instale el entorno virtual en su carpeta personal:
    sudo apt update
    sudo apt install python3-venv python3-pip
    python3 -m venv esp_env
    
  2. Active el entorno virtual (observará el prefijo (esp_env) en la terminal):
    source esp_env/bin/activate
    
  3. Instale la herramienta oficial de flasheado de Espressif:
    pip install esptool
    

5. Paso 4: Liberación del Puerto y Flasheado de la ESP32 WROOM

Asegúrese de cerrar cualquier aplicación que pueda estar utilizando el puerto serie (como Thonny, Arduino IDE o terminales serie).

Liberación del puerto

Para forzar el cierre de cualquier proceso que bloquee el puerto:

sudo fuser -k /dev/ttyUSB0

Escritura de la memoria flash

Con el entorno esp_env activo en la terminal, ejecute el comando de borrado de memoria y grabado del firmware (sustituya el nombre del archivo .bin por el que descargó en el Paso 1):

esptool.py --port /dev/ttyUSB0 --chip esp32 --baud 115200 write-flash --flash_mode keep --flash_size keep --erase-all 0x1000 ~/Descargas/ESP32_GENERIC-20260824-v1.29.0.bin

Tip de conexión: Si la terminal muestra el mensaje Connecting......_____, mantenga presionado el botón físico BOOT (o IO0) en la placa ESP32 hasta que inicie la barra de progreso de escritura.


6. Paso 5: Configuración de Thonny IDE en Linux Mint

  1. Instale Thonny en Linux Mint desde los repositorios oficiales o mediante el Gestor de Software:
    sudo apt install thonny
    
  2. Abra Thonny.
  3. Vaya al menú Herramientas > Opciones... (Tools > Options...).
  4. En la pestaña Intérprete (Interpreter), seleccione MicroPython (ESP32).
  5. En el menú desplegable de puerto, elija /dev/ttyUSB0 (o /dev/ttyACM0).
  6. Haga clic en Aceptar.

La consola inferior (Shell) mostrará la línea de comandos de MicroPython (>>>), indicando que la placa está conectada y lista.


7. Paso 6: Verificación y Control del LED Integrado con machine

En la placa ESP32 de 30 pines, el pin digital GPIO 2 está conectado al LED integrado de la tarjeta.

Prueba en la consola interactiva (>>>)

import machine

# Configuración del pin GPIO 2 como salida
led = machine.Pin(2, machine.Pin.OUT)

# Encender el LED
led.value(1)

# Apagar el LED
led.value(0)

Script de parpadeo continuo (main.py)

Para que el programa se ejecute automáticamente al encender la ESP32:

  1. Abra un archivo nuevo en Thonny e ingrese el siguiente código:
    import machine
    import time
    
    # Pin GPIO 2 para el LED de la placa
    led = machine.Pin(2, machine.Pin.OUT)
    
    while True:
        led.value(1)   # Encender LED
        time.sleep(1)  # Esperar 1 segundo
        led.value(0)   # Apagar LED
        time.sleep(1)  # Esperar 1 segundo
    
  2. Guarde el archivo en el Dispositivo MicroPython (MicroPython device) con el nombre exacto main.py.

Guía Completa: Flasheado de MicroPython en ESP32 WROOM desde Debian y Configuración en Thonny IDE

 

Guía Completa: Flasheado de MicroPython en ESP32 WROOM desde Debian y Configuración en Thonny IDE

El desarrollo de proyectos de Internet de las Cosas (IoT) con la tarjeta ESP32 WROOM de 30 pines bajo entornos Debian o Linux Mint requiere la correcta gestión de permisos del sistema, la configuración de entornos aislados en Python para evitar bloqueos del gestor de paquetes del sistema (apt), y la eliminación de conflictos con servicios del kernel que puedan interceptar el puerto serie.

Esta guía paso a paso detalla el proceso completo para descargar el firmware oficial de MicroPython, preparar el entorno de ejecuciones en Linux, realizar la escritura de la memoria flash mediante la herramienta oficial esptool, vincular la tarjeta con Thonny IDE y controlar el LED integrado utilizando el módulo machine.


1. Identificación y Diagnóstico del Hardware en Linux

Antes de iniciar el proceso de flasheado, es indispensable confirmar que la computadora reconozca físicamente el chip conversor USB a Serie de la tarjeta ESP32 (frecuentemente los chips Silicon Labs CP210x o QinHeng Electronics CH340/CH341).

Para verificar la conexión del dispositivo en Debian, ejecute en una terminal:

lsusb

Si el sistema detecta correctamente la placa, la lista desplegará entradas representativas como Silicon Labs CP210x UART Bridge o QinHeng Electronics CH340 serial converter. Si al conectar y desconectar el cable no aparece ningún dispositivo nuevo, reemplace el cable USB, ya que algunos cables comerciales solo proveen alimentación eléctrica sin líneas de datos.


2. Paso 1: Descarga del Firmware Oficial de MicroPython

El firmware de MicroPython proporciona el intérprete ejecutable dentro de la memoria flash del microcontrolador.

  1. Ingrese al sitio web oficial de MicroPython (micropython.org/download/esp32).
  2. Seleccione el archivo binario estable correspondiente al chip ESP32 (por ejemplo, el firmware genérico .bin para ESP32 WROOM).
  3. Guarde el archivo descargado en el directorio de descargas del usuario: ~/Descargas.

3. Paso 2: Configuración de Permisos y Liberación del Puerto Serie

El sistema operativo Debian restringe el acceso directo de lectura y escritura a los dispositivos de puerto de comunicación serie (/dev/ttyUSB0 o /dev/ttyACM0) por razones de seguridad.

Adición del usuario al grupo dialout

Para conceder acceso permanente a los puertos de comunicación, agregue su usuario actual al grupo de seguridad dialout:

sudo usermod -a -G dialout $USER

Nota de aplicación de permisos: Para que Debian valide la adición al grupo dialout, es necesario cerrar la sesión actual de usuario y volver a iniciarla, o reiniciar la computadora.

Eliminación del conflicto con el servicio brltty

En distribuciones basadas en Debian, el servicio brltty (asistencia para dispositivos Braille) suele interceptar automáticamente los convertidores USB a Serie como el CH340 o CP210x, desconectándolos inmediatamente de /dev/ttyUSB0. Para eliminar este bloqueo del sistema, desinstale dicho paquete mediante:

sudo apt remove brltty

4. Paso 3: Creación de un Entorno Virtual de Python e Instalación de esptool

Las distribuciones modernas de Debian implementan la especificación PEP 668 (externally-managed-environment), la cual bloquea la instalación global de paquetes mediante pip para proteger la estabilidad del sistema. La metodología estándar consiste en crear un entorno virtual aislado.

  1. Cree un entorno virtual en su directorio personal denominado esp_env:
    python3 -m venv esp_env
    
  2. Active el entorno virtual (el prompt de la terminal mostrará el prefijo (esp_env)):
    source esp_env/bin/activate
    
  3. Instale la utilidad oficial de flasheado desarrollada por Espressif (esptool):
    pip install esptool
    

5. Paso 4: Liberación de Puertos y Flasheado del Firmware

Antes de escribir en la memoria flash de la tarjeta, asegúrese de que ningún otro proceso o entorno de desarrollo (como Thonny IDE, Arduino IDE o un monitor serie) mantenga abierto el puerto /dev/ttyUSB0.

Liberación forzada del puerto serie

Para garantizar la liberación inmediata del puerto en Linux, ejecute:

sudo fuser -k /dev/ttyUSB0

Ejecución del flasheado mediante esptool

Con el entorno virtual esp_env activo en la terminal y la ESP32 conectada por USB, ejecute el comando de borrado previo y escritura del firmware. Reemplace el nombre del archivo binario por la versión exacta que descargó en el Paso 1:

esptool.py --port /dev/ttyUSB0 --chip esp32 --baud 115200 write-flash --flash_mode keep --flash_size keep --erase-all 0x1000 ~/Descargas/ESP32_GENERIC-20260824-v1.29.0.bin

Instrucción de conexión de hardware: Si la terminal se detiene mostrando el mensaje Connecting......_____, mantenga presionado el botón físico BOOT (o IO0) ubicado en la placa ESP32 hasta que observe el inicio de la barra de progreso en la pantalla.

El proceso concluirá con la confirmación de escritura al 100% (Hash of data verified / Success).


6. Paso 5: Configuración del Intérprete y Puerto en Thonny IDE

Una vez grabado el firmware de MicroPython en el dispositivo, se procede a vincular la placa con el entorno de desarrollo Thonny IDE.

  1. Si no tiene instalado Thonny en Debian, puede instalarlo desde los repositorios del sistema:
    sudo apt install thonny
    
  2. Abra la aplicación Thonny.
  3. Navegue en el menú superior a Herramientas > Opciones... (Tools > Options...).
  4. Seleccione la pestaña Intérprete (Interpreter).
  5. En el menú de selección de entorno, elija MicroPython (ESP32).
  6. En el menú desplegable de puerto (Port), seleccione explícitamente el puerto asignado por Linux: /dev/ttyUSB0 (o /dev/ttyACM0).
  7. Presione Aceptar.

En la consola inferior (Shell) de Thonny aparecerá el prompt interactivo de MicroPython (>>>), confirmando la comunicación directa con la ESP32 WROOM.


7. Paso 6: Verificación y Control del LED Integrado con el Módulo machine

En la placa ESP32 de 30 pines, el puerto digital GPIO 2 está internamente conectado al LED de pruebas de la tarjeta.

Prueba directa en el prompt interactivo (>>>)

Escriba los siguientes comandos línea por línea en la consola de Thonny para validar el control del puerto de entrada/salida:

import machine

# Configuración del pin GPIO 2 como salida digital
led = machine.Pin(2, machine.Pin.OUT)

# Encender el LED
led.value(1)

# Apagar el LED
led.value(0)

Script ejecutable de parpadeo continuo (main.py)

Para guardar un programa permanente que se ejecute de forma autónoma cada vez que la ESP32 reciba energía:

  1. Abra un archivo nuevo en la ventana de edición de Thonny.

  2. Escriba el código de parpadeo periódico:

    import machine
    import time
    
    # Asignación del pin GPIO 2 para el LED integrado
    led = machine.Pin(2, machine.Pin.OUT)
    
    # Bucle principal de ejecución
    while True:
        led.value(1)   # Activa el LED (3.3V)
        time.sleep(1)  # Retardo de 1 segundo
        led.value(0)   # Desactiva el LED (0V)
        time.sleep(1)  # Retardo de 1 segundo
    
  3. Haga clic en Guardar, seleccione como destino Dispositivo MicroPython (MicroPython device) y nombre el archivo exactamente como main.py.

  4. Al reiniciar la placa o desconectar y reconectar el cable USB, el programa iniciará automáticamente el ciclo de encendido y apagado del LED.

Linux Mint Thony Micropython NodeMCU Amica (que utiliza el chip ESP8266)

 
Es obligatorio instalar el firmware de MicroPython en tu NodeMCU Amica (que utiliza el chip ESP8266), ya que estas placas vienen de fábrica preparadas para programarse en lenguaje C++ (entorno Arduino) o Lua.
Para conectar tu NodeMCU a Thonny en Linux Mint, sigue estos pasos detallados:
## 1. Dar permisos al puerto serie en Linux Mint
Por seguridad, Linux bloquea el acceso directo a los puertos USB para usuarios comunes. Si no configuras esto, Thonny no detectará tu placa.

   1. Abre la terminal de Linux Mint.
   2. Ejecuta el siguiente comando para agregar tu usuario al grupo dialout:
   
   sudo usermod -a -G dialout $USER
   
   3. Cierra sesión en Linux Mint y vuelve a iniciarla (o reinicia el sistema) para que los cambios surtan efecto.

## 2. Descargar el firmware de MicroPython

   1. Ve a la página oficial de descargas en MicroPython para ESP8266.
   2. Descarga la versión estable más reciente (un archivo con extensión .bin). El NodeMCU Amica estándar suele tener 4MB de memoria flash, por lo que la versión común te servirá perfectamente.

## 3. Conectar e instalar el firmware desde Thonny

   1. Conecta tu NodeMCU Amica a la computadora mediante un buen cable Micro-USB (asegúrate de que sea de datos y no solo de carga).
   2. Abre el IDE Thonny.
   3. En el menú superior, ve a Ejecutar (Run) > Configurar intérprete... (Configure interpreter...).
   4. En la pestaña Intérprete, despliega la lista y selecciona MicroPython (ESP8266).
   5. En la opción Puerto (Port), haz clic en el botón inferior derecho que dice Instalar o actualizar firmware (Install or update firmware).
   6. Se abrirá una ventana pequeña:
   * Target port: Selecciona el puerto de tu placa (normalmente aparece como /dev/ttyUSB0).
      * Firmware: Haz clic en Browse (Examinar) y selecciona el archivo .bin que descargaste en el paso anterior.
      * Flash mode: Déjalo en keep o dio.
   7. Haz clic en Instalar (Install). Espera a que la barra llegue al 100%.

## 4. Establecer la conexión
Una vez que la instalación finalice con éxito, cierra esa ventana secundaria. En la ventana principal de configuración del intérprete, asegúrate de que el puerto seleccionado sea /dev/ttyUSB0 (o el que corresponda a tu placa) y haz clic en Aceptar.
Verás que la Terminal (Shell) de Thonny en la parte inferior se actualiza y muestra tres flechas de comando (>>>). Esto significa que ya estás conectado directamente al intérprete de MicroPython de tu NodeMCU Amica y puedes empezar a programar.