viernes, 21 de agosto de 2026

MicroPython en tu ESP32 usando Thonny IDE

 MicroPython en tu ESP32 usando Thonny IDE

Para montar MicroPython en tu ESP32 usando Thonny IDE desde Linux, el proceso es muy visual y automático. Thonny ya incluye las herramientas necesarias para borrar la memoria de la placa y descargar el firmware oficial.
Sigue estos pasos detallados para instalarlo y dejarlo listo:

1. Preparar los permisos en Linux

Antes de abrir Thonny, asegúrate de que tu usuario de Linux tenga permiso para leer y escribir en los puertos USB. Abre una terminal en tu Linux y ejecuta:
sudo usermod -a -G dialout $USER
(Nota: Para que este cambio tenga efecto, debes cerrar sesión en Linux y volver a entrar, o reiniciar el sistema).

2. Pasos para instalar MicroPython desde Thonny

  1. Conecta tu ESP32 a la computadora mediante un cable USB (asegúrate de que sea un cable de datos y no solo de carga). [1]
  2. Abre Thonny.
  3. Ve al menú superior y selecciona Herramientas (Tools) > Opciones (Options).
  4. Haz clic en la pestaña Intérprete (Interpreter).
  5. En el primer menú desplegable, selecciona: MicroPython (ESP32). [2]
  6. En el segundo desplegable (Puerto/Port), selecciona el puerto donde está tu placa (normalmente aparece como /dev/ttyUSB0 o /dev/ttyACM0).
  7. En la esquina inferior derecha de esa misma ventana, haz clic en las letras azules que dicen Instalar o actualizar MicroPython (Install or update MicroPython).
  8. Se abrirá una pequeña ventana flotante:
    • Target port: Elige tu puerto /dev/ttyUSB0.
    • Family: Selecciona ESP32 (o ESP32 / WROOM según tu modelo).
    • Variant: Selecciona la estándar (la que dice solo Expressif ESP32).
    • Version: Deja la versión recomendada que Thonny te ofrece por defecto. [3]
  9. Haz clic en el botón Instalar (Install).
💡 Nota Importante: Thonny se conectará a internet, descargará el archivo .bin oficial, borrará la memoria de la ESP32 (Flash) e instalará el sistema de forma automática. Tardará cerca de un minuto.

3. Verificar que funciona

Una vez que termine el proceso, cierra las ventanas de configuración. Mira la parte inferior de Thonny, en la sección llamada Terminal (Shell).
Verás un mensaje de bienvenida y el prompt clásico de MicroPython:
MicroPython v1.2X.X on 2026-XX-XX; ESP32 module with ESP32
Type "help()" for more information.
>>>
Si escribes print("Hola desde ESP32") y presionas Enter, la placa te responderá inmediatamente. Desde este momento, cualquier archivo de código que guardes en Thonny te dará la opción de almacenarlo directamente dentro de la memoria de la ESP32.
¿Pudiste completar la instalación de esta manera, o te arrojó algún error de conexión o puerto al intentar flashearla?

 

Publicado por en No hay comentarios:

Comandos Esenciales de MicroPython para ESP32

 

Comandos Esenciales de MicroPython para ESP32

 

Aquí tienes una tabla con los comandos esenciales para trabajar en la consola (REPL) de MicroPython en tu ESP32. Están organizados por categorías funcionales para que puedas usarlos de referencia rápida.

Comandos Esenciales de MicroPython para ESP32

CategoríaComando en MicroPythonDescripción / Acción
Ayuda y Sistemahelp()Muestra información básica y ayuda del sistema.

import gc; gc.collect(); gc.mem_free()Libera memoria RAM basura y muestra los bytes libres.

import machine; machine.reset()Reinicia por completo la ESP32 (Hard Reset).

import machine; machine.freq()Muestra la frecuencia actual del reloj (normalmente 160MHz o 240MHz).
Archivos y Directoriosimport os; os.listdir()Lista todos los archivos dentro de la memoria de la ESP32 (como ls).

os.mkdir('nombre_carpeta')Crea una nueva carpeta en el almacenamiento.

os.chdir('nombre_carpeta')Cambia el directorio de trabajo actual (como cd).

os.remove('archivo.py')Elimina un archivo específico (como rm).

os.stat('archivo.py')Muestra el tamaño en bytes y metadatos del archivo.
Lectura/Escritura de Archivosf = open('boot.py', 'r'); print(f.read()); f.close()Lee y muestra el contenido de un archivo en pantalla (como cat).

f = open('test.py', 'w'); f.write('print("Hola")'); f.close()Crea o sobreescribe un archivo escribiendo texto en él.
Control de Pines (GPIO)from machine import PinImporta la librería necesaria para controlar los pines físicos.

led = Pin(2, Pin.OUT)Configura el Pin 2 (suele ser el LED azul integrado) como salida.

led.value(1) o led.on()Enciende el pin (pone el voltaje en alto, 3.3V).

led.value(0) o led.off()Apaga el pin (pone el voltaje en bajo, 0V).

boton = Pin(4, Pin.IN, Pin.PULL_UP)Configura el Pin 4 como entrada con resistencia Pull-Up.

boton.value()Lee el estado del pin (devuelve 1 o 0).
Señales Analógicas y PWMfrom machine import ADC; adc = ADC(Pin(34))Configura el Pin 34 para leer voltajes analógicos (0 a 3.3V).

adc.read_uv()Lee el voltaje del pin analógico directamente en microvoltios.

from machine import PWM; pwm = PWM(Pin(2), freq=1000, duty_u16=32768)Genera una señal PWM (para atenuar luces o mover servos).
Redes y Wi-Fiimport network; wlan = network.WLAN(network.STA_IF)Inicializa la interfaz de red en modo estación (cliente).

wlan.active(True)Enciende la antena Wi-Fi de la ESP32.

wlan.scan()Escanea las redes Wi-Fi al alcance y muestra sus datos.

wlan.connect('SSID', 'PASSWORD')Se conecta a tu red Wi-Fi local.

wlan.isconnected()Devuelve True si la conexión Wi-Fi es exitosa.

wlan.ifconfig()Muestra la dirección IP asignada, máscara, puerta de enlace y DNS.

Atajos útiles de teclado en la consola (REPL) desde Linux

Cuando estés conectado por tio, screen o WebREPL, estos atajos te ahorrarán mucho tiempo:
  • Ctrl + C: Interrumpe el programa que se esté ejecutando en ese momento y te devuelve la línea de comandos.
  • Ctrl + D: Realiza un reinicio suave (Soft Reset) del software. Recarga los archivos boot.py y main.py al instante.
  • Ctrl + E: Activa el Modo Pegado (Paste Mode). Ideal para copiar códigos largos desde tu Linux y pegarlos en la consola sin que se rompa la indentación. Presionas Ctrl + D para terminar de pegar y ejecutar.
¿Te gustaría que diseñemos un script para automatizar el parpadeo de un LED al arrancar, o prefieres ver cómo enviar datos de sensores a través de la red?


 

Publicado por en No hay comentarios:

ESP32 consola comandos acceder por Wi-Fi a MicroPython WebREPL o configurando una terminal por Telnet/SSH.

 ESP32 consola comandos acceder por Wi-Fi a MicroPython WebREPL o configurando una terminal por Telnet/SSH.

 

Sí, se puede acceder por Wi-Fi a MicroPython de forma completamente inalámbrica. Puedes hacerlo mediante una consola interactiva en el navegador web (WebREPL) o configurando una terminal por Telnet/SSH. [1]
Aquí tienes los pasos exactos para activar el acceso inalámbrico:

Opción 1: WebREPL (La oficial y más segura)

MicroPython incluye una herramienta oficial llamada WebREPL que te permite abrir la consola y transferir archivos desde cualquier navegador web en tu Linux.
  1. Conéctate por primera vez por cable serial y ejecuta este comando para configurarlo:
    import webrepl_setup
  2. Sigue las instrucciones en pantalla:
    • Presiona E para habilitarlo (enable).
    • Define una contraseña de acceso (4 a 9 caracteres).
    • Reinicia la ESP32 cuando te lo pida.
  3. Conecta la ESP32 a tu red Wi-Fi. Para que se conecte automáticamente al arrancar, crea o edita el archivo boot.py en la ESP32 con este código:
    import network
import webrepl

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
    print('Conectando a la red...')
    wlan.connect('NOMBRE_DE_TU_WIFI', 'CONTRASEÑA_DE_TU_WIFI')
    while not wlan.isconnected():
        pass
print('Configuración de red:', wlan.ifconfig())

# Inicia el servicio inalámbrico
webrepl.start()
    [2]
  4. Accede desde tu Linux:
    • Anota la dirección IP que te dio el código anterior (ej. 192.168.1.50).
    • Abre en tu navegador Linux el cliente oficial: micropython.org
    • Cambia la IP en el cuadro de texto (ej. ws://192.168.1.50:8266/) y haz clic en Connect.
    • Introduce la contraseña que creaste en el paso 1. ¡Listo!

Opción 2: Telnet tradicional (Para usar tu terminal de Linux)

Si prefieres usar comandos puros en la terminal de tu Linux (telnet o netcat) en lugar de un navegador web, puedes levantar un servidor de sockets manual en la ESP32 que redirija la consola.
Para ello, una vez conectada la ESP32 al Wi-Fi, ejecuta este script en la placa para redirigir la entrada/salida a la red:
import os
import socket

# Crear un servidor en el puerto 23 (Telnet)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
print("Esperando conexión Telnet...")

conn, addr = s.accept()
# Redirigir la consola interactiva (REPL) al socket de red
os.dupterm(conn)
Luego, desde la terminal de tu computadora Linux, simplemente ejecutas:
telnet 192.168.1.50 23
¿Qué método prefieres implementar? Si quieres, te puedo ayudar a escribir el script completo para automatizar la conexión Wi-Fi o mostrarte cómo subir archivos .py de forma remota usando la herramienta mpremote.

 

Publicado por en No hay comentarios:

ESP32 consola interactiva estilo Unix con comandos como ls, cd, control de pines y red - Solución MicroPython

 ESP32 consola interactiva estilo Unix con comandos como ls, cd, control de pines y red - Solución MicroPython

 

Para un ESP32, la opción más práctica y madura con consola interactiva estilo Unix (con comandos como ls, cd, control de pines y red) es MicroPython. No es un Linux completo, pero em funciona como un micro-SO con REPL (consola interactiva en Python) accesible por puerto serial (/dev/ttyUSB0 o /dev/ttyACM0) desde tu otro equipo Linux usando herramientas como screen o tio. [1, 2, 3, 4]
Aquí te detallo las mejores alternativas de "micro-SO / shells" según lo que busques:

1. MicroPython (La opción más recomendada)

  • Qué es: Un intérprete de Python optimizado para microcontroladores que expone una consola interactiva directa.
  • Por qué elegirlo: Te da acceso inmediato a una línea de comandos en la ESP32 apenas enciendes el dispositivo. Puedes importar librerías, inspeccionar memoria, leer pines GPIO y programar lógica al vuelo sin compilar código en C.
  • Cómo conectarte desde Linux: Conectas la ESP32 por USB y usas en tu terminal de Linux:
    sudo usermod -a -G dialout $USER  # (Solo la primera vez para permisos de puerto)
tio /dev/ttyUSB0 -b 115200
    [1, 5, 6, 7, 8]

2. Esp32OS o MiniOS-ESP (Entornos estilo Unix sobre FreeRTOS)

  • Qué es: Proyectos de código abierto como Esp32OS o MiniOS-ESP.
  • Por qué elegirlo: Implementan un shell estilo Linux (con comandos tipo ls, cd, cat, manejo de tareas y control de hardware) corriendo sobre FreeRTOS. Muchos soportan acceso dual por consola serial UART y por Telnet a través de Wi-Fi. [9, 10, 11]

¿Cómo flashear y acceder desde tu Linux principal?

  1. Instala la herramienta de flasheo en tu Linux:
    pip install esptool
  2. Descarga el firmware .bin oficial desde la web de MicroPython.
  3. Borra la flash e instala el micro-SO:
    esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-firmware.bin
  4. Abre la consola serial con screen, minicom o tio a 115200 baudios y verás el prompt >>> listo para usarse. [6, 12, 13, 14]
Para ayudarte a dar el siguiente paso de la mejor manera, ¿te gustaría conocer los comandos básicos para controlar los pines GPIO desde esa consola o prefieres saber cómo configurarlo para acceder de forma inalámbrica vía Wi-Fi/Telnet?
¿Te gustaría saber cómo controlar los pines GPIO desde la consola o prefieres configurar el acceso por Wi-Fi (Telnet) desde tu Linux?

 

Publicado por en No hay comentarios:

miércoles, 19 de agosto de 2026

que framework proramando me recomiendas para realizar bancos de preguntas y poner a estudiantes a presentar de acuerdo a un spreadsheet con # id nombres y apellidos, correos

 

 

 

Si quieres programar tu propia solución a medida para tener control total y costo cero en servidores, la mejor combinación del mundo es usar Next.js (React) con TypeScript en el frontend, y conectar todo mediante una API de Google Sheets como tu base de datos de alumnos y preguntas.
Para un despliegue rápido y escalable, el ecosistema ideal que te recomiendo es el siguiente:

El Stack Técnico Recomendado

  • Framework Principal: Next.js (React) con TypeScript. Te da rutas protegidas rápidas, renderizado del lado del servidor para validar accesos, y tipado estricto para evitar errores con las preguntas.
  • Base de Datos y Datos de Alumnos: Google Sheets API. No necesitas configurar PostgreSQL o MongoDB. Usas la hoja de cálculo existente con ID, Nombres, Apellidos y Correos como tu base de datos en tiempo real.
  • Estilos y UI: Tailwind CSS + shadcn/ui. Te permite diseñar interfaces limpias, adaptables a celulares y con componentes listos (como temporizadores o tarjetas de preguntas).
  • Procesamiento de Fórmulas Matemáticas: KaTeX o MathJax. Librerías ligeras de JavaScript para renderizar perfectamente el código LaTeX de tus preguntas de matemáticas en el navegador.

Arquitectura de la Solución (Cómo estructurarlo)

[ Google Sheets ] ──(API)──> [ Next.js Backend (API Routes) ] ──> [ Frontend del Estudiante ]
  - Pestaña 1: Alumnos          - Valida el Correo/ID.              - Muestra las 20 preguntas.
  - Pestaña 2: 200 Preguntas    - Mezcla y selecciona 20 de 200.    - Envía las respuestas al Sheets.
  1. Autenticación sin contraseñas: El estudiante ingresa su correo. Tu servidor Next.js consulta la pestaña Alumnos del Spreadsheet. Si el correo existe, le permite iniciar el examen.
  2. Algoritmo de Aleatoriedad (Backend): Para evitar que los alumnos hagan trampa inspeccionando el código del navegador, las 200 preguntas se procesan en el servidor. Tu backend hace un Fisher-Yates shuffle a la lista, extrae solo 20 y se las envía al frontend.
  3. Guardado de Notas: Cuando el alumno da clic en "Enviar", el sistema calcula la nota y usa la API de Google Sheets para escribir el resultado directamente en una fila al lado del nombre del alumno.

Archivo Base de Configuración

Para que empieces a programar ya mismo, he generado un archivo comprimido que contiene la estructura inicial de la base de datos de alumnos en formato CSV, junto con el script base en TypeScript (utils/quiz.ts) que procesa la selección aleatoria de las 20 preguntas de forma segura.
Aquí está tu archivo: banco_preguntas_base.zip.
Este archivo contiene:
  • alumnos_template.csv: Plantilla con las columnas id, nombres, apellidos, correo listos para subir a tu Google Sheets.
  • quiz.ts: Código fuente en TypeScript con la función algorítmica para mezclar las preguntas eficientemente en el servidor sin repetir elementos.
El código clave en TypeScript que debes usar en tus rutas de Next.js para segmentar las preguntas es el siguiente:
export interface Pregunta {
  id: number;
  enunciado: string;
  opciones: string[];
  respuestaCorrecta: string;
}

// Algoritmo Fisher-Yates para aleatoriedad real
export function obtenerPreguntasAleatorias(banco: Pregunta[], cantidad = 20): Pregunta[] {
  const arreglo = [...banco];
  for (let i = arreglo.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [arreglo[i], arreglo[j]] = [arreglo[j], arreglo[i]];
  }
  return arreglo.slice(0, cantidad);
}
¿Prefieres que te ayude a escribir el código para conectar Next.js directamente con la API de Google Sheets, o te gustaría ver cómo estructurar el componente del temporizador en React para el examen?


 

Publicado por en No hay comentarios:

Comparativa Quizizz, Kahoot! y Formative

 

 

Aquí tienes la tabla comparativa detallada para el año 2026. Se evalúan los costos de las versiones que permiten la aleatoriedad avanzada de preguntas y el soporte técnico para fórmulas y código:
CaracterísticaQuizizzKahoot!Formative (por Newsela)
Precio aproximado (Plan con aleatoriedad)Desde $8 - $12 USD/mes (Plan Individual Premier/Super) o licencias escolares.Desde $10 - $15 USD/mes (Plan Edu Pro) o licencias institucionales.Desde $15 USD/mes (Plan Silver/Gold Individual) o contratos escolares.
Capacidad de almacenamiento de preguntasIlimitada en biblioteca personal y bancos de preguntas.Ilimitada en el banco de preguntas del curso.Ilimitada en rastreadores y bancos de ítems.
Ecuaciones matemáticas con LaTeX🧮 Excelente. Soporta edición nativa de LaTeX con un editor visual de ecuaciones muy intuitivo.🔣 Básico. Permite símbolos matemáticos y superíndices, pero el soporte LaTeX avanzado es limitado.📐 Excelente. Incluye un editor de expresiones matemáticas avanzado compatible con sintaxis LaTeX.
Soporte de Código / TypeScript💻 Básico (Solo texto). No tiene bloques de código con formato sintáctico para TypeScript. Se debe pegar como texto plano o imagen.📋 Muy básico. El texto se ingresa de forma lineal; no preserva tabulaciones ni resalta sintaxis de programación.🖥️ Avanzado. Permite insertar código fuente formateado y configurar preguntas tipo "estudiante responde con código".
Integración con Google ClassroomEnlace directo, sincronización automática de listas de alumnos y exportación directa de notas.Enlace directo y asignaciones, pero la exportación automática de notas detalladas requiere planes altos.Sincronización bidireccional profunda de tareas, rúbricas y calificaciones.

Recomendación según tu especialidad:

  • Si enseñas Matemáticas puras: Quizizz es el ganador por su rapidez para procesar LaTeX y la facilidad de importar las 200 preguntas de golpe desde Excel.
  • Si enseñas Programación (TypeScript/Informática): Formative es superior porque respeta la sangría del código, resalta la sintaxis y permite que los alumnos escriban fragmentos de código reales como respuesta.
¿Cuál de estas áreas se adapta mejor a tu curso? Si lo deseas, puedo generar la plantilla en formato Excel (.xlsx) estructurada para la plataforma que elijas para que empieces a organizar tus preguntas de inmediato.


 

Publicado por en No hay comentarios:

Las tres mejores plataformas externas que se integran con Google Classroom y permiten crear un banco de 200 preguntas para extraer 20 de forma aleatoria por alumno son Quizizz, Kahoot! y Formative.

 

 

Las tres mejores plataformas externas que se integran con Google Classroom y permiten crear un banco de 200 preguntas para extraer 20 de forma aleatoria por alumno son Quizizz, Kahoot! y Formative.
A continuación, te detallo cómo funciona cada una y los pasos exactos para configurar tu banco de preguntas en la opción más recomendada.

Las 3 mejores plataformas compatibles

PlataformaIntegración con ClassroomCómo maneja la aleatoriedadFacilidad de importación
Quizizz🔄 Completa (Sincroniza alumnos y calificaciones)Excelente mediante "Conjuntos de preguntas" (Question Jacks)Muy alta (Plantilla de Excel/Google Sheets)
Kahoot!🔄 Completa (Permite asignar retos directos)Buena (Función de "Banco de preguntas del curso")Alta (Plantilla de Excel)
Formative (Silver/Gold)🔄 Completa (Sincroniza tareas)Excelente (Bloques de preguntas aleatorias)Alta (Subir archivos o copiar texto)

Guía paso a paso usando Quizizz (La opción más eficiente)

Quizizz es la herramienta más cómoda para este caso porque te permite importar todas las preguntas desde la tabla que te dio Gemini y configurar la aleatoriedad en pocos clics.

1. Preparar el archivo con Gemini

  1. Descarga la plantilla de Excel que ofrece Quizizz para importar preguntas.
  2. Pídele a Gemini que ordene las 200 preguntas adaptándolas exactamente a las columnas de esa plantilla (Pregunta, Opción 1, Opción 2, Opción 3, Opción 4, Respuesta Correcta, Tiempo).
  3. Copia los datos en tu hoja de Google Sheets y descárgala en formato .xlsx (Excel). [1, 2, 3]

2. Crear el Banco de Preguntas en Quizizz

  1. Inicia sesión en Quizizz con tu cuenta de profesor (puedes registrarte con tu correo de Google).
  2. Haz clic en Crear y selecciona Cuestionario.
  3. Elige la opción Importar desde un archivo y sube el documento de Excel con tus 200 preguntas. Al hacerlo, todas se cargarán de forma masiva en segundos. [4, 5]

3. Configurar la aleatoriedad (20 de 200)

  1. Una vez creado el cuestionario con las 200 preguntas, ve a la configuración del juego/examen.
  2. Busca la sección de Configuración Avanzada o Modo de asignación.
  3. Activa la opción Selección aleatoria de preguntas (dependiendo de la interfaz de tu cuenta, esto se hace agrupando las preguntas en un contenedor o activando el modo examen/test).
  4. Define el número exacto: establece que el sistema muestre únicamente 20 preguntas a cada usuario.

4. Enlazar con Google Classroom

  1. Al momento de asignar el cuestionario (ya sea en vivo o como tarea para la casa), haz clic en el botón Asignar a una clase.
  2. Selecciona Vincular con Google Classroom y elige el grupo de alumnos correspondiente.
  3. Envía la tarea. A los alumnos les aparecerá el enlace directo en su muro de Classroom. Cuando entren, el sistema les barajará el banco de datos y les entregará 20 reactivos únicos a cada uno. Las notas se exportarán automáticamente a tu sección de calificaciones. [6, 7]
Si quieres avanzar con este método, te puedo generar una plantilla de Excel (.xlsx) limpia y estructurada con los encabezados exactos que pide Quizizz para que solo tengas que pegar tus preguntas de Gemini dentro de ella. ¿Te gustaría que la prepare?

 

Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)