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.



martes, 29 de septiembre de 2026

repositorios debian - sudo apt install thonny -y

En la terminal Paso 1 sudo rm -f /etc/apt/sources.list Paso 2 sudo nano /etc/apt/sources.list Copiar adentro lo siguiente deb http://deb.debian.org/debian/ stable main contrib non-free non-free-firmware deb-src http://deb.debian.org/debian/ stable main contrib non-free non-free-firmware deb http://deb.debian.org/debian-security stable-security main contrib non-free non-free-firmware deb-src http://deb.debian.org/debian-security stable-security main contrib non-free non-free-firmware deb http://deb.debian.org/debian/ stable-updates main contrib non-free non-free-firmware deb-src http://deb.debian.org/debian/ stable-updates main contrib non-free non-free-firmware ctrl +o ctrl +x sudo apt clean sudo apt update sudo apt install thonny -y

viernes, 25 de septiembre de 2026

IA recomendad para OpenCode - Preguntadole a la IA de META

Mejor IA para OpenCode

Mejor IA para OpenCode en 2026

1. La mejor IA general y default recomendado: Claude Sonnet 4.5

Es el modelo que OpenCode trae por defecto en su config oficial y en casi todos los templates de agentes.

Modelo: anthropic/claude-sonnet-4-5

Modelo pequeño: anthropic/claude-haiku-4-5

Por qué:

  • Mejor balance calidad / costo / velocidad para código
  • Best instruction following en tests de OpenCode
  • Diseñado para tool-use, por eso falla menos haciendo parches y edits

2. Si quieres lo máximo en calidad (y pagas más)

Claude Opus 4.5 / 4.6 / 5.5

  • Opus 4.6: Stable - 22/23 tests. Best overall en la evaluación de toolparser de OpenCode
  • Opus 4.5: listado como Best for Coding en plugins de OpenCode

Úsalo como principal y deja Sonnet como modelo pequeño para tareas rápidas.

3. Stack recomendado por tipo de tarea

Tarea Modelo recomendado en OpenCode
Tareas complejas, refactor grande, agentes anthropic/claude-sonnet-4-5 o claude-opus-4-5
Tareas simples, lectura de archivos, parches opencode/gpt-5-nano - alta velocidad y uso eficiente de herramientas
Respuesta ultra rápida opencode/ling-2-6-flash
Gratis / OpenCode Zen opencode/deepseek-v4-flash-free - es el modelo con el que mejor se comporta OpenCode Zen y tiene capa gratuita

4. Mi recomendación práctica

Si usas OpenCode con cuenta de Anthropic / OpenRouter / Copilot:

main: anthropic/claude-sonnet-4-5
small: anthropic/claude-haiku-4-5

Si quieres gratis para empezar:

main: opencode/deepseek-v4-flash-free

Cambia rápido con /models dentro de opencode y elige el que te aparezca disponible para tu cuenta.

```

miércoles, 23 de septiembre de 2026

Informe Tutorial: Diseño de Aplicación Animada en LOGO -Rebote Cíclico de la Tortuga en Arcos Horizontales"

 Informe Tutorial: Diseño de Aplicación Animada en LOGO -Rebote Cíclico de la Tortuga en Arcos Horizontales"

 

https://turtleacademy.com/programs/459225

 

🐢 Código en LOGO (Sintaxis en Español) con Encabezado Institucional:

; =========================================================  
; REBOTE EN ARCOS (VELOCIDAD LENTA Y TORTUGA SIEMPRE VISIBLE)  
; Autor: Prof. Alexander Arias Londoño
; Semillero de Investigación: Semillero MMCC
; Asignatura: Lógica de Programación y Laboratorio
; ---------------------------------------------------------
; - Ida (Izquierda -> Derecha): Color ROJO (ponercolor 1)  
; - Regreso (Derecha -> Izquierda): Color AZUL (ponercolor 4)  
; =========================================================  

bp ; Limpiar la pantalla (borrarpantalla)
mt ; Mostrar la tortuga (mostrartortuga)
ponergrosorlapiz 3 ; Grosor del trazo  

; BUCLE INFINITO DE REBOTE  
while [ 1 = 1 ]  [  

 ; --------------------------------------------------------  
 ; FASE 1: IDA (IZQUIERDA A DERECHA) - COLOR ROJO  
 ; --------------------------------------------------------  
 ponercolor 1 ; Color ROJO  
 hacer "x -250  

 repetir 5 [  
   sl ; Subir lápiz
   ponerxy :x -250 ; Posicionar en el punto base  
   ponerd 0 ; Apuntar hacia ARRIBA (Norte)  
   mt ; Asegurar visibilidad de la tortuga  
   bl ; Bajar lápiz para trazar  

   ; Arco horizontal hacia la derecha (recorrido más lento)  
   repetir 18 [  
     ad 8.72 ; Avanzar paso del arco  
     de 10 ; Girar a la DERECHA  
     mt ; Mantener visible el ícono de la tortuga  
     espera 3 ; Pausa de 3 milisegundos por paso (más lento)  
   ]  

   hacer "x :x + 100 ; Avanzar 100px al siguiente punto  
 ]  

 ; --------------------------------------------------------  
 ; FASE 2: REGRESO (DERECHA A IZQUIERDA) - COLOR AZUL  
 ; --------------------------------------------------------  
 ponercolor 4 ; Color AZUL  
 hacer "x 250  

 repetir 5 [  
   sl ; Subir lápiz
   ponerxy :x -250 ; Posicionar en el punto base  
   ponerd 0 ; Apuntar hacia ARRIBA (Norte)  
   mt ; Asegurar visibilidad de la tortuga  
   bl ; Bajar lápiz para trazar  

   ; Arco horizontal hacia la izquierda (recorrido más lento)  
   repetir 18 [  
     ad 8.72 ; Avanzar paso del arco  
     iz 10 ; Girar a la IZQUIERDA  
     mt ; Mantener visible el ícono de la tortuga  
     espera 3 ; Pausa de 3 milisegundos por paso (más lento)  
   ]  

   hacer "x :x - 100 ; Retroceder 100px al siguiente punto  
 ]  

]

Informe Tutorial: Diseño de Aplicación Animada en LOGO

"Rebote Cíclico de la Tortuga en Arcos Horizontales"

Autor: Prof. Alexander Arias Londoño
Semillero de Investigación: Semillero MMCC (Modelamiento, Matemática, Computación y Ciencia)
Asignatura: Lógica de Programación y Laboratorio
Entorno de Ejecución: Turtle Academy Playground
Plataforma / Lenguaje: LOGO (Sintaxis en Español e Inglés)


1. Introducción y Contexto Pedagógico

Este informe tutorial detalla la arquitectura, el diseño geométrico y la implementación algorítmica de un programa interactivo en lenguaje LOGO. La aplicación simula el movimiento continuo e infinito de una tortuga rebotando sobre la base inferior del lienzo mediante arcos semicirculares horizontales (U invertida), alternando la dirección del movimiento y el color del trazo.

Objetivos de Aprendizaje para los Estudiantes

  • Control de Flujo Iterativo: Manejo de bucles infinitos (while [1 = 1]) y bucles contados anidados (repeat / repetir).
  • Manejo de Estado y Variables: Definición, incremento y decremento de variables de posición (make "x / hacer "x).
  • Geometría Dinámica: Aplicación del plano cartesiano $$(X, Y)$$ y descomposición de trayectorias en giros y pasos discretos.
  • Visualización y Animación: Control fino del renderizado (st / mt, pd / bl, pu / sl), velocidad (wait / espera) y paleta cromática (setcolor / ponercolor).

2. Requisitos de Diseño y Especificaciones Geométricas

  1. Lienzo de Ejecución: Cuadrado centrado de 500 × 500 píxeles (rangos: $$X \in [-250, 250]$$, $$Y \in [-250, 250]$$).
  2. Línea Base (Piso): Fijada permanentemente en $$Y = -250$$.
  3. Puntos de Contacto (Atardeceres/Aterrizajes): 6 coordenadas discretas sobre la base: $$\text{Puntos } X: {-250, -150, -50, 50, 150, 250}$$
  4. Parámetros del Arco Semicircular:
    • Diámetro: $$100\text{ px}$$ entre punto y punto.
    • Ángulo total de giro: $$180^\circ$$ (medio círculo perfecto).
    • Descomposición: 18 pasos discretos de $$10^\circ$$ cada uno ($$18 \times 10^\circ = 180^\circ$$).
    • Longitud del paso (fd / ad): $$\approx 8.72\text{ px}$$, derivado del perímetro del semicírculo ($$\pi \times r = \pi \times 50 \approx 157\text{ px}$$; $$157 / 18 \approx 8.72\text{ px}$$).
  5. Diferenciación de Sentido y Color:
    • Ida (Izquierda a Derecha): Color Rojo (setcolor 1 / ponercolor 1).
    • Regreso (Derecha a Izquierda): Color Azul (setcolor 4 / ponercolor 4).
  6. Visibilidad y Control Temporal:
    • La tortuga debe mantenerse visible durante toda la animación (st / mt).
    • Pausa por fotograma (wait 3 / espera 3) para garantizar una animación fluida y pedagógicamente observable.

3. Código Fuente Completo (Sintaxis en Español - LOGO)

; =========================================================  
; REBOTE EN ARCOS (VELOCIDAD LENTA Y TORTUGA SIEMPRE VISIBLE)  
; Autor: Prof. Alexander Arias Londoño
; Semillero de Investigación: Semillero MMCC
; Asignatura: Lógica de Programación y Laboratorio
; ---------------------------------------------------------
; - Ida (Izquierda -> Derecha): Color ROJO (ponercolor 1)  
; - Regreso (Derecha -> Izquierda): Color AZUL (ponercolor 4)  
; =========================================================  

bp ; Limpiar la pantalla (borrarpantalla)
mt ; Mostrar la tortuga (mostrartortuga)
ponergrosorlapiz 3 ; Grosor del trazo  

; BUCLE INFINITO DE REBOTE  
while [ 1 = 1 ]  [  

 ; --------------------------------------------------------  
 ; FASE 1: IDA (IZQUIERDA A DERECHA) - COLOR ROJO  
 ; --------------------------------------------------------  
 ponercolor 1 ; Color ROJO  
 hacer "x -250  

 repetir 5 [  
   sl ; Subir lápiz
   ponerxy :x -250 ; Posicionar en el punto base  
   ponerd 0 ; Apuntar hacia ARRIBA (Norte)  
   mt ; Asegurar visibilidad de la tortuga  
   bl ; Bajar lápiz para trazar  

   ; Arco horizontal hacia la derecha (recorrido más lento)  
   repetir 18 [  
     ad 8.72 ; Avanzar paso del arco  
     de 10 ; Girar a la DERECHA  
     mt ; Mantener visible el ícono de la tortuga  
     espera 3 ; Pausa de 3 milisegundos por paso (más lento)  
   ]  

   hacer "x :x + 100 ; Avanzar 100px al siguiente punto  
 ]  

 ; --------------------------------------------------------  
 ; FASE 2: REGRESO (DERECHA A IZQUIERDA) - COLOR AZUL  
 ; --------------------------------------------------------  
 ponercolor 4 ; Color AZUL  
 hacer "x 250  

 repetir 5 [  
   sl ; Subir lápiz
   ponerxy :x -250 ; Posicionar en el punto base  
   ponerd 0 ; Apuntar hacia ARRIBA (Norte)  
   mt ; Asegurar visibilidad de la tortuga  
   bl ; Bajar lápiz para trazar  

   ; Arco horizontal hacia la izquierda (recorrido más lento)  
   repetir 18 [  
     ad 8.72 ; Avanzar paso del arco  
     iz 10 ; Girar a la IZQUIERDA  
     mt ; Mantener visible el ícono de la tortuga  
     espera 3 ; Pausa de 3 milisegundos por paso (más lento)  
   ]  

   hacer "x :x - 100 ; Retroceder 100px al siguiente punto  
 ]  

]

3.1. Código Fuente Equivalente (Sintaxis Estándar en Inglés)

; =========================================================  
; REBOTE EN ARCOS (VELOCIDAD CONTROLADA Y TORTUGA VISIBLE)  
; Author: Prof. Alexander Arias Londoño
; Research Group: Semillero MMCC
; Course: Lógica de Programación y Laboratorio
; ---------------------------------------------------------
; - Ida (Izquierda -> Derecha): Color ROJO (setcolor 1)  
; - Regreso (Derecha a Izquierda): Color AZUL (setcolor 4)  
; =========================================================  

cs               ; Limpiar la pantalla (clearscreen)
st               ; Mostrar la tortuga (showturtle)
setpensize 3     ; Grosor del trazo

; BUCLE INFINITO DE REBOTE
while [1 = 1] [

  ; --------------------------------------------------------
  ; FASE 1: IDA (IZQUIERDA A DERECHA) - COLOR ROJO
  ; --------------------------------------------------------
  setcolor 1     ; Color ROJO
  make "x -250

  repeat 5 [
    pu           ; Pen up (Subir lápiz)
    setxy :x -250  ; Posicionar en el punto base
    seth 0         ; Apuntar hacia ARRIBA (Norte)
    st             ; Asegurar visibilidad de la tortuga
    pd             ; Pen down (Bajar lápiz)

    ; Arco horizontal hacia la derecha
    repeat 18 [
      fd 8.72      ; Avanzar paso del arco
      rt 10        ; Girar a la DERECHA
      st           ; Mantener visible el ícono de la tortuga
      wait 3       ; Pausa de animación (velocidad moderada)
    ]

    make "x :x + 100 ; Avanzar 100px al siguiente punto
  ]

  ; --------------------------------------------------------
  ; FASE 2: REGRESO (DERECHA A IZQUIERDA) - COLOR AZUL
  ; --------------------------------------------------------
  setcolor 4     ; Color AZUL
  make "x 250

  repeat 5 [
    pu           ; Pen up (Subir lápiz)
    setxy :x -250  ; Posicionar en el punto base
    seth 0         ; Apuntar hacia ARRIBA (Norte)
    st             ; Asegurar visibilidad de la tortuga
    pd             ; Pen down (Bajar lápiz)

    ; Arco horizontal hacia la izquierda
    repeat 18 [
      fd 8.72      ; Avanzar paso del arco
      lt 10        ; Girar a la IZQUIERDA
      st           ; Mantener visible el ícono de la tortuga
      wait 3       ; Pausa de animación (velocidad moderada)
    ]

    make "x :x - 100 ; Retroceder 100px al siguiente punto
  ]

]

4. Tabla de Equivalencia de Comandos (Español vs. Inglés)

Comando EspañolComando InglésDescripción / Función
bp / borrarpantallacs / clearscreenLimpia todo el lienzo de trabajo
mt / mostrartortugast / showturtleMuestra e ilumina la posición del cursor de la tortuga
sl / subirlapizpu / penupDesactiva el trazo para desplazarse libremente
bl / bajarlapizpd / pendownActiva el lápiz para dibujar las líneas
ponergrosorlapizsetpensizeDefine el ancho de la línea en píxeles
ponercolorsetcolorEstablece el color del lápiz (1 = Rojo, 4 = Azul)
ponerxysetxyPosiciona la tortuga en las coordenadas $$(X, Y)$$
ponerd / ponerdireccionseth / setheadingOrienta el ángulo de despegue (0 = Norte / Arriba)
ad / adelantefd / forwardAvanza la cantidad dada de píxeles
de / derechart / rightGira los grados especificados hacia la derecha
iz / izquierdalt / leftGira los grados especificados hacia la izquierda
hacermakeDeclara o actualiza el valor de una variable
repetirrepeatEjecuta un bloque de instrucciones un número fijo de veces
esperawaitGenera una pausa temporal de animación

5. Análisis Estructural y Descomposición Algorítmica

5.1. Inicialización del Entorno

  • bp / cs: Restablece el lienzo eliminando trazos previos.
  • mt / st: Fuerza la aparición del ícono visual de la tortuga.
  • ponergrosorlapiz 3 / setpensize 3: Establece un grosor adecuado para destacar los arcos.

5.2. El Bucle Principal (while [1 = 1])

Garantiza la ejecución continua de la animación sin detenerse, alternando indefinidamente entre la Fase 1 (Ida) y la Fase 2 (Regreso).

5.3. Fase 1: Ida (Izquierda a Derecha)

  1. Asignación Inicial: hacer "x -250 sitúa el puntero de control en el extremo izquierdo.
  2. Iteración de Saltos (repetir 5): Ejecuta exactamente 5 arcos consecutivos.
  3. Reposicionamiento y Alineación:
    • sl / ponerxy :x -250 / bl: Mueve la tortuga al punto de despegue sin rayar la pantalla en el traslado.
    • ponerd 0: Orienta la tortuga hacia el Norte (0°). Este es el secreto del diseño: al despegar verticalmente y girar a la derecha (de 10), se forma una curva en forma de U invertida que se eleva y vuelve a descender.
  4. Construcción del Arco (repetir 18):
    • ad 8.72 avanza una fracción exacta del perímetro.
    • de 10 acumula $$180^\circ$$ de curvatura hacia la derecha.
    • mt y espera 3 aseguran que la tortuga se muestre fotograma a fotograma sin parpadeos.
  5. Actualización de Estado: hacer "x :x + 100 suma 100 píxeles a la variable de posición para preparar el despegue del siguiente arco.

5.4. Fase 2: Regreso (Derecha a Izquierda)

  1. Cambio Cromático: ponercolor 4 conmuta el color de la tinta a Azul.
  2. Asignación Inicial: hacer "x 250 establece la partida en el extremo derecho.
  3. Inversión Geométrica: Mantiene la orientación de despegue vertical (ponerd 0), pero invierte los giros a la izquierda (iz 10), logrando que la U invertida avance hacia el oeste.
  4. Decremento de Estado: hacer "x :x - 100 resta 100 píxeles por cada arco finalizado.

6. Lecciones de Depuración (Debugging)

Durante el proceso iterativo de desarrollo se identificaron y resolvieron los siguientes retos técnicos:

Desafío DetectadoCausa RaízSolución Aplicada
Bucles en forma de "C" o desviacionesLa tortuga iniciaba apuntando a 90° (Oriente), provocando giros laterales.Cambiar el ángulo de despegue a ponerd 0 / seth 0 (Norte) antes de cada arco.
Desplazamiento progresivo del pisoLa acumulación de pequeñas diferencias decimales inclinaba la base.Forzar ponerxy :x -250 al inicio de cada arco para anclar el piso exacto.
Invisibilidad de la tortugaEl motor de renderizado ocultaba el cursor durante ciclos rápidos de movimiento.Insertar mt / st de forma explícita dentro del bucle de dibujo repetir 18.
Animación demasiado rápidaEjecución instantánea por defecto del motor LOGO.Introducir la instrucción espera 3 / wait 3 por paso discreto del arco.

7. Guía para la Presentación en Clase

Para aprovechar este ejercicio al máximo durante la sesión académica, se sugiere la siguiente secuencia pedagógica:

  1. Reto Inicial: Pedir a los alumnos que logren un solo arco desde (-250, -250) hasta (-150, -250).
  2. Generalización con Variables: Introducir la variable :x y demostrar cómo el comando hacer "x :x + 100 automatiza la secuencia.
  3. Anidación de Ciclos: Integrar el repetir 18 del arco dentro del repetir 5 de los saltos.
  4. Análisis de Colores y Sentidos: Discutir por qué es necesario cambiar de de 10 a iz 10 al invertir la dirección de desplazamiento.
  5. Desafío Extendido: Proponer a los estudiantes modificar el código para que la altura del arco varíe aleatoriamente o para que la tortuga dibuje 3 arcos de ida y 3 de regreso.