HolzTank

Leer la temperatura mediante BLE

Mon, 08 Jun 2026 06:00:00 GMT

Introducción

Esta práctica nos permitirá obtener la temperatura y la humedad del entorno mediante un sensor DHT11 para luego mostrarlas a través de BLE.

Circuito

Conexión de un sensor DHT22 asumiendo que viene ya en un módulo

Necesitamos verificar si el sensor viene ya en un módulo o por sí solo. En la compra por kits, dicho sensor se presenta de la primera forma, lo cual nos ahorra el tener que agregar una resistencia de . Si por alguna razón viene “suelto”, entonces sí debemos agregar dicha resistencia haciendo puente entre el voltaje y la señal.

El sensor se conecta a los de la placa, mientras que la señal se conecta al pin 4. Por último, la tierra a cualquier GND de la esp32. También agregaremos el circuito básico de led, para mostrar el estado de la conexión, ya que este encenderá cuando se haya conectado un cliente.

Lo siguiente es instalar lo necesario, lo cual lo abordo enseguida.

Código

Antes de cargar nada, debemos instalar la librería que el sensor requiere, para lo cual nos vamos al Gestor de bibliotecas que se encuentra en el panel izquierdo (su icono trata de hacer referencia a unos libros apilados y es el tercero de arriba abajo, aunque no lo distingo como tales). Ahí tendremos una caja de texto en la que buscaremos dht sensor adafruit y nos instalamos la librería que haya sido subida precisamente por Adafruit. Al pedirnos si instalamos las dependencias, le decimos que sí y aceptamos.

Después de haber instalado la librería y verificar que así haya sido en la terminal de Arduino IDE, pasamos a cargar el siguiente código:

#include 
#include 
#include 
#include 
#include 

// Configurando el sensor
#define DHTPIN 4            // GPIO donde esta conectado el DHT11
#define DHTTYPE DHT11       // TIPO DE SENSOR: DHT11

DHT dht(DHTPIN, DHTTYPE);

// Configurando BLE
// Servicio de sensado de entorno (UUID Estandar)
#define SERVICE_UUID         "181A"  // Environmental Sensing Service
#define TEMP_UUID       "2A6E"  // Temperatura (caracteristica estandar)
#define HUM_UUID      "2A6F"  // Humedad (caracteristica estandar)

// Nombre visible del dispositivo
#define DEVICE_NAME          "CambiarNombre"

// Intervalo de lectura del sensor (ms)
// El DHT11 requiere al menos 2000ms entre lecturas
#define SENSOR_READ_INTERVAL 5000  // 5 segundos

// Variables
BLEServer* pServer = NULL;
BLECharacteristic* pTempCharacteristic = NULL;
BLECharacteristic* pHumidCharacteristic = NULL;
bool deviceConnected = false;

// Almacenar ultimos valores leidos
float lastTemperature = 0.0;
float lastHumidity = 0.0;
unsigned long lastSensorRead = 0;

// LED indicador (opcional)
const int pinEstadoLed = 16;
bool estadoLed = false;

// Callbacks
class MyServerCallbacks: public BLEServerCallbacks {
  void onConnect(BLEServer* pServer) override {
    deviceConnected = true;
    Serial.println("Cliente BLE conectado");
    digitalWrite(pinEstadoLed, HIGH);
  }

  void onDisconnect(BLEServer* pServer) override {
    deviceConnected = false;
    Serial.println("Cliente BLE desconectado");
    digitalWrite(pinEstadoLed, LOW);

    // Reiniciar advertising para permitir nuevas conexiones
    delay(500);
    pServer->startAdvertising();
    Serial.println("Reanudando advertising...");
  }
};

// Sensor DHT11
bool readDHT11Sensor(float& temperature, float& humidity) {
  // Leer el sensor
  temperature = dht.readTemperature();
  humidity = dht.readHumidity();

  // Verificar si la lectura fue exitosa
  // isnan() verifica si el valor es "Not a Number" (error de lectura)
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Error: No se pudo leer el sensor DHT11");
    Serial.println("Verifica las conexiones y que el sensor este alimentado");
    return false;
  }

  // El DHT11 no mide temperaturas negativas (rango 0-50°C)
  // Si se lee un valor fuera de rango, el sensor puede devolver datos erroneos

  return true;
}

void updateBLECharacteristics(float temperature, float humidity) {
  if (!deviceConnected) {
    return;  // No hay cliente conectado, no enviar datos
  }

  // Convertir temperatura a entero para BLE (formato estandar)
  // En BLE, la temperatura se suele enviar como entero con resolucion de 0.01°C
  int16_t tempInt = (int16_t)(temperature * 100);

  // Convertir humedad a entero (resolucion 0.01%)
  uint16_t humInt = (uint16_t)(humidity * 100);

  // Enviar temperatura
  pTempCharacteristic->setValue((uint8_t*)&tempInt, 2);
  pTempCharacteristic->notify();

  // Enviar humedad
  pHumidCharacteristic->setValue((uint8_t*)&humInt, 2);
  pHumidCharacteristic->notify();

  Serial.println("Datos enviados por BLE");
  Serial.print("  Temperatura (int): ");
  Serial.println(tempInt);
  Serial.print("  Humedad (int): ");
  Serial.println(humInt);
}

// Funcion para formatear valores como String (para debug)
String formatSensorData(float temperature, float humidity) {
  String data = "Temp: ";
  data += String(temperature, 1);
  data += " C | Hum: ";
  data += String(humidity, 1);
  data += " %";
  return data;
}


void setup() {
  Serial.begin(115200);

  // Configurar LED de estado
  pinMode(pinEstadoLed, OUTPUT);
  digitalWrite(pinEstadoLed, LOW);

  // Inicializar el sensor DHT11
  Serial.println("Inicializando sensor DHT11...");
  dht.begin();

  // Verificar que el sensor responda
  delay(2000);  // Primer delay para estabilizar el sensor
  float testTemp, testHum;
  if (readDHT11Sensor(testTemp, testHum)) {
    Serial.println("Sensor DHT11 inicializado correctamente");
    Serial.print("  Lectura inicial - Temperatura: ");
    Serial.print(testTemp);
    Serial.print(" C, Humedad: ");
    Serial.print(testHum);
    Serial.println(" %");
  } else {
    Serial.println("No se detectó el sensor DHT11");
  }

  // Inicializar BLE
  Serial.println("Inicializando BLE...");
  BLEDevice::init(DEVICE_NAME);

  // Crear servidor BLE
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Crear el servicio (UUID estandar 0x181A)
  BLEService* pService = pServer->createService(SERVICE_UUID);

  // Caracteristica para temperatura (UUID estandar 0x2A6E)
  pTempCharacteristic = pService->createCharacteristic(
    TEMP_UUID,
    BLECharacteristic::PROPERTY_READ |
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pTempCharacteristic->addDescriptor(new BLE2902());  // Necesario para notifications

  // Caracteristica para humedad (UUID estandar 0x2A6F)
  pHumidCharacteristic = pService->createCharacteristic(
    HUM_UUID,
    BLECharacteristic::PROPERTY_READ |
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pHumidCharacteristic->addDescriptor(new BLE2902());

  // Iniciar servicio
  pService->start();

  // Configurar advertising
  BLEAdvertising* pAdvertising = pServer->getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->start();

  Serial.println("BLE inicializado correctamente");
  Serial.print("  Nombre del dispositivo: ");
  Serial.println(DEVICE_NAME);
  Serial.print("  Servicio UUID: ");
  Serial.println(SERVICE_UUID);

  Serial.println();
  Serial.println("Sistema listo");
  Serial.println("1. Abrir nRF Connect en el teléfono");
  Serial.println("2. Escanear y conectarse a CambiarNombre");
  Serial.println("3. Buscar el servicio Environmental Sensing (0x181A)");
  Serial.println("4. Leer las caracteristicas de temperatura y humedad");
  Serial.println();
}

void loop() {
  unsigned long currentMillis = millis();

  // Leer el sensor cada SENSOR_READ_INTERVAL milisegundos
  if (currentMillis - lastSensorRead >= SENSOR_READ_INTERVAL) {
    lastSensorRead = currentMillis;

    // Leer el DHT11
    float temperature, humidity;
    if (readDHT11Sensor(temperature, humidity)) {
      // Actualizar variables globales
      lastTemperature = temperature;
      lastHumidity = humidity;

      // Mostrar en Monitor Serie
      Serial.print("Lectura de sensor: ");
      Serial.println(formatSensorData(temperature, humidity));

      // Si hay un cliente conectado, enviar datos por BLE
      if (deviceConnected) {
        updateBLECharacteristics(temperature, humidity);
        Serial.println("  (Datos enviados a cliente BLE)");
      } else {
        Serial.println("  (Sin cliente BLE conectado)");
      }

      // Parpadeo del LED indicador de lectura exitosa
      estadoLed = !estadoLed;
      digitalWrite(pinEstadoLed, estadoLed);
      delay(50);
      digitalWrite(pinEstadoLed, deviceConnected ? HIGH : LOW);

    } else {
      Serial.println("Error en lectura del sensor - reintentando en el proximo ciclo");
    }
  }

  // Pequena pausa para no saturar el CPU
  delay(100);
}

Toca probar con la aplicación nRF Connect y seguir las instrucciones mostradas en el monitor.

Transmitir por bluetooth

Mon, 08 Jun 2026 06:00:00 GMT

Transmitiendo por BLE

Introducción

En esta práctica haremos que la esp32 permanezca emitiendo paquetes de datos por medio de Bluetooth Low Energy (BLE) para que un dispositivo móvil los pueda leer. Es como un aviso de proximidad.

Circuito

El led con resistencia de toda la vida.

Código

Cargaremos el siguiente código a la esp32. Debemos editarlo para poner nuestro propio UUID (podemos generarlo aquí); también debemos cambiar el nombre del dispositivo.

#include 
#include 
#include 

const char* UUID = "2d214dcf-bc32-45bc-b825-6f7f8e6566f8";
const uint16_t MAJOR = 1;
const uint16_t MINOR = 1;
const int led = 16;

void setup() {
    Serial.begin(115200);
    Serial.println("Iniciando ESP32 con BLE...");

    pinMode(led, OUTPUT);
    digitalWrite(led, HIGH);

    // RENOMBRAR DISPOSITIVO BLE (cambiarlo por equipo)
    BLEDevice::init("ESP32_BLE");

    // Construir payload iBeacon (estructura para Apple)

    // Estructura:
    // Apple ID (2) + iBeacon type (2) + UUID (16) + Major (2) + Minor (2) +
    // TX Power (1)
    uint8_t payload[25];

    // Apple Manufacturer ID (0x004C) - Little Endian
    payload[0] = 0x4C;
    payload[1] = 0x00;

    // iBeacon type (0x0215)
    payload[2] = 0x02;
    payload[3] = 0x15;

    // UUID (16 bytes)
    String uuidStr = UUID;
    uuidStr.replace("-", "");
    for(int i = 0; i < 16; i++) {
        String byteStr = uuidStr.substring(i*2, i*2+2);
        payload[4 + i] = (uint8_t) strtol(byteStr.c_str(), NULL, 16);
    }

    // Major (2 bytes) - Big Endian
    payload[20] = (MAJOR >> 8) & 0xFF;
    payload[21] = MAJOR & 0xFF;

    // Minor (2 bytes) - Big Endian
    payload[22] = (MINOR >> 8) & 0xFF;
    payload[23] = MINOR & 0xFF;

    // TX Power (RSSI a 1 metro)
    payload[24] = -59;

    // Esta línea solo funciona en librerías más recientes que la 3.0.0
    String payloadString = "";
    for(int i = 0; i < 25; i++) {
        payloadString += (char)payload[i];
    }

    // Configurar advertising con los datos
    BLEAdvertisementData advData;
    advData.setFlags(0x04);
    advData.setManufacturerData(payloadString);

    // Iniciar advertising
    BLEAdvertising* pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->setAdvertisementData(advData);
    pAdvertising->start();

    Serial.println("BLE activo");
    Serial.print("   UUID: ");
    Serial.println(UUID);
    Serial.print("   Major: ");
    Serial.println(MAJOR);
    Serial.print("   Minor: ");
    Serial.println(MINOR);
    Serial.println("\n  Escanear con nRF Connect o LightBlue");
}

void loop() {
    static unsigned long lastBlink = 0;
    if (millis() - lastBlink > 2000) {
        lastBlink = millis();
        digitalWrite(led, !digitalRead(led));
        Serial.print(".");
    }
    delay(100);
}

“Leer” con un teléfono

El último paso es acceder a lo que la esp32 está mostrando en su emisión BLE. Para ello debemos instalar alguna aplicación que permita escanear dispositivos BLE. Para android podemos usar nRF Connect. Tenemos que escanear dispositivos en dicha aplicación y acceder al nuestro. Debemos también verificar que los datos que muestresean exactamente los correctos.

Controlar led por bluetooth

Mon, 08 Jun 2026 06:00:00 GMT

Controlando el led por BLE

Introducción

El siguiente paso es controlar el led de siempre por medio de la conexión BLE de la esp32.

Circuito

El de siempre con un led y su resistencia, todo al GPIO16.

Código

Procedemos a cargar en la esp32 el siguiente código:

#include 
#include 
#include 
#include 

// UUIDs del servicio Nordic UART-like
#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

// Pin del LED
const int led = 16;
bool estado = false;

// Variables globales BLE
BLEServer* pServer = NULL;
BLECharacteristic* pTxCharacteristic = NULL;
bool deviceConnected = false;

// Callback para eventos de conexion/desconexion
class MyServerCallbacks: public BLEServerCallbacks {
  void onConnect(BLEServer* pServer) override {
    deviceConnected = true;
    Serial.println("Dispositivo conectado por BLE");
  }

  void onDisconnect(BLEServer* pServer) override {
    deviceConnected = false;
    Serial.println("Dispositivo desconectado");
    // Reiniciar advertising para permitir nuevas conexiones
    delay(500);
    pServer->startAdvertising();
    Serial.println("Reanudando advertising...");
  }
};

// Callback para recibir datos del cliente
class MyCallbacks: public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic* pCharacteristic) override {
    // Obtener el valor recibido - esto devuelve String internamente
    String rxValue = pCharacteristic->getValue();

    if (rxValue.length() > 0) {
      Serial.print("Comando recibido: ");
      Serial.println(rxValue.c_str());

      // Procesar comando
      if (rxValue == "H") {
        estado = true;
        digitalWrite(led, HIGH);
        Serial.println("LED encendido");

        // Enviar confirmacion por BLE usando String
        String confirmacion = "OK_ON";
        pTxCharacteristic->setValue(confirmacion.c_str());
        pTxCharacteristic->notify();
      }
      else if (rxValue == "L") {
        estado = false;
        digitalWrite(led, LOW);
        Serial.println("LED apagado");

        String confirmacion = "OK_OFF";
        pTxCharacteristic->setValue(confirmacion.c_str());
        pTxCharacteristic->notify();
      }
      else if (rxValue == "STATUS") {
        String estado = estado ? "LED:ON" : "LED:OFF";
        pTxCharacteristic->setValue(estado.c_str());
        pTxCharacteristic->notify();
      }
      else {
        Serial.print("Comando no reconocido: ");
        Serial.println(rxValue.c_str());
      }
    }
  }
};

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println("Iniciando Servidor BLE");

  // Configurar LED
  pinMode(led, OUTPUT);
  digitalWrite(led, LOW);

  // Inicializar dispositivo BLE, CAMBIAR NOMBRE
  BLEDevice::init("CAMBIAR_NOMBRE");

  // Crear servidor BLE
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Crear servicio
  BLEService* pService = pServer->createService(SERVICE_UUID);

  // Crear caracteristicas
  // Caracteristica TX (envia datos al teléfono) con propiedad NOTIFY
  pTxCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID_TX,
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pTxCharacteristic->addDescriptor(new BLE2902());

  // Caracteristica RX (recibe datos del teléfono) con propiedad WRITE
  BLECharacteristic* pRxCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID_RX,
    BLECharacteristic::PROPERTY_WRITE
  );
  pRxCharacteristic->setCallbacks(new MyCallbacks());

  // Iniciar servicio
  pService->start();

  // Iniciar advertising
  BLEAdvertising* pAdvertising = pServer->getAdvertising();
  pAdvertising->start();

  Serial.println("Servidor BLE listo");
  // CAMBIAR AL NOMBRE ELEGIDO
  Serial.println("Nombre del dispositivo: CAMBIAR_NOMBRE");
  Serial.print("Servicio UUID: ");
  Serial.println(SERVICE_UUID);
  Serial.println("Instrucciones:");
  Serial.println("1. Abrir nRF Connect en el teléfono");
  Serial.println("2. Escanear y conectarse a CAMBIAR_NOMBRE");
  Serial.println("3. Buscar la caracteristica con RX en Nordic UART Service");
  Serial.println("4. Presionar el icono de flecha que apunta arriba");
  Serial.println("5. Escribir H (Encender) o L (Apagar)");
}

void loop() {
  // Mantener el servidor funcionando
  // Opcional: parpadeo del LED integrado como indicador de actividad
  static unsigned long lastBlink = 0;
  static bool blinkState = false;

  if (deviceConnected && (millis() - lastBlink > 5000)) {
    lastBlink = millis();
    blinkState = !blinkState;
    // Solo para depuracion, no interfiere con el LED principal
  }

  delay(100);
}

Las instrucciones estarán mostrándose en el monitor serial de Arduino IDE.

Vectores en R

Sun, 07 Jun 2026 06:00:00 GMT

Podemos utilizar R como una calculadora bastante avanzada, utilizando los operadores básicos. Sin embargo, no nos quedaremos ahí. Pasemos a ver cómo se declaran las variables y trabajaremos con vectores.

Variables

Se declaran de manera muy sencilla. Lo peculiar de R es que no se utiliza el símbolo =, si no que se asignan valores con la combinación <-. Por ejemplo:

Code

Configurando Godot para un Metroidvania genérico

Sun, 07 Jun 2026 06:00:00 GMT

Introducción

En esta serie de entradas iré vaciando lo que voy haciendo para desarrollar un videojuego en Godot que pertenece al género Metroidvania. Cabe mencionar que no todo es generado únicamente por mí, si no que iré tomando elementos de otros tutoriales, manuales, documentación y demás.

Dejémoslo en que esta serie de entradas es una especie de repositorio y tutorial para el yo del futuro, que muy probablemente olvide todo si no lo documento.

Configuración del proyecto

Partiré con un proyecto Godot que utilizará el motor Forward+ y que llamaré Taller-Metroidvania. En el menú Proyecto -> Configuración del proyecto, en la pestaña General, nos dirigimos a la categoría Visualización -> Ventana y nos aseguramos de cambiar el parámetro Modo en la sección Estirar a canvas_item. En Tamaño de la visualización lo cambiamos a un ancho y alto de 480*270, respectivamente. Podríamos pensar que es un tamaño pequeño. Y sí, lo es. Pero lo tendremos en cuenta enseguida.

Antes de cerrar la ventana, veremos que en su parte superior derecha se encuentra un deslizador. Ahí activaré las Configuraciones Avanzadas para enseguida bajar un poco y cambiar las opciones Sobreescribir Ancho y Sobreescribir Alto de Ventana a 1440*810, respectivamente. Esto último con la intención de ajustar el escalado de la ventana al momento de ejecutar el juego en pantallas de alta resolución.

Seguimos en la configuración del proyecto, pero ahora bajaremos hacia la categoría Renderizado -> Texturas y en la sección Textura del Canvas cambiamos la opción Filtro de Textura a Nearest. Esto es así porque nuestro Metroidvania usará un estilo gráfico basado en arte píxel.

Cambiaremos a la pestaña Mapa de Entrada y configuraremos los controles iniciales para nuestro juego. Primero, lo que debemos pulsar para que el personaje se mueva a la izquierda. Colocaremos el cursor de texto en la entrada Añadir Nueva Acción y escribimos izquierda para enseguida dar clic en el botón Añadir que se encuentra a la derecha. Veremos dicho texto aparece justamente dentro de la sección Acción. A su derecha está un botón +. Daremos clic allí y Godot nos pedirá que pulsemos la tecla del teclado que responderá a dicha acción, la cual mostrará tras pulsarlo pero no la guardará hasta que pulsemos en Aceptar. Cabe decir que es posible agregar tantos botones o teclas deseemos para dicha acción, incluso podemos presionar la dirección correspondiente en la cruceta o la palanca de un control si es que lo tenemos conectado. Tendremos que repetir esto para al menos las cuatro direcciones y los movimientos que tengamos pensados.

Los movimientos que agregaré son el salto, el ataque, correr y habilidad. Aún no tengo del todo claro cuál será esa habilidad, pero conforme avancemos lo averiguaremos. Los controles que asignaré serán, respectivamente, botones A, X, B y Y en un mando genérico de XBOX y teclas Z, X, C y S en un teclado.

Cerremos la ventana y creemos un Nodo Raíz del tipo Escena 2D. Recordemos los controles básicos en Godot para el ratón. Con el botón central podemos mover la vista y con la rueda alejamos o acercamos la misma.

Guardamos la escena como playground.tscn y ya tenemos la configuración inicial de nuestro metroidvania lista. En una entrada posterior comenzaremos con el personaje principal.

GUIs con Python

Sun, 07 Jun 2026 06:00:00 GMT

Introducción

Estos no son más que un conjunto de apuntes para recordar o facilitar el cómo se desarrollan aplicaciones gráficas con Python y pyqt6. Estaré documentando el desarrollo por acá, mientras de manera paralela iré armando el proyecto en una carpeta separada.

Preparando el entorno

Primero la instalación de lo necesario. Debido a que utilizo Manjaro Linux (y lo mismo aplica para cualquier derivada de Arch), es más recomendable instalar las librerías de Python directamente con el gestor de paquetes Pacman, al contrario de lo que en muchos tutoriales se sugiere.

sudo pacman -S python-qt6

Sin embargo, siempre resulta muy útil trabajar con entornos virtuales, en los cuales es posible instalar los paquetes necesarios de manera aislada. Una ventaja de este enfoque es evitar que tras las continuas actualizaciones de paquetes en Arch se rompan las dependencias de este proyecto, que se supone es algo más serio. As’que continúemos.

Controlar un led con la terminal de comandos

Mon, 01 Jun 2026 06:00:00 GMT

Controlando un led con la terminal

Introducción

En la anterior entrada mandamos órdenes a la ESP32 por medio de comunicación serial para encender o apagar un led. En esta ocasión, dichas órdenes se emitirán por medio de una aplicación externa que se esté ejecutando en la PC.

Circuito

Partiremos del circuito con led y resistencia que armamos justo en la entrada pasada.

Código para la ESP32

Si hemos realizado justo antes la práctica del monitor serial, ya deberíamos tener el programa cargado en la placa. De todos modos lo repito aquí.

/* Entradas y salidas */
#define led1 16          // GPIO16

/* Comandos */
#define luz_on 'H'       // Luz encendida
#define luz_off 'L'      // Luz apagada

int cmd = 0; // Comando entrado por serial

void setup() {
  // Configuración de los puertos digitales
  pinMode(led1, OUTPUT);
  digitalWrite(led1, LOW);
  // Configuracion del puerto serial
  Serial.begin(115200);

}

void loop() {
  // Responde solo si hay respuesta:
  if (Serial.available() > 0) {
    // Lee lo que esté presente:
    cmd = Serial.read();

    // Encendido o apagado de la luz segun el comando
    if(cmd == luz_on) {
      digitalWrite(led1, HIGH);
      Serial.println("Encendida");
    }
    else if(cmd == luz_off) {
      digitalWrite(led1, LOW);
      Serial.println("Apagada");
    }
  }
}

Con esto, cada vez que encendíamos la placa, podíamos escribir en la entrada serial el comando “H” para encender el led y “L” para apagarlo. Esta ocasión será diferente el modo de mandar dichos comandos.

Aplicación externa

Primero debemos asegurarnos de tener instalada la librería pyserial.

pip install pyserial

Creamos un archivo serialLed.py y lo guardamos en cualquier carpeta que nos parezca adecuada. Enseguida copiamos y pegamos el código siguiente. Es importante que editemos el puerto para que coincida con el que está usando nuestra placa. Otra alternativa es descargar este archivo: Aplicación para Linux

import serial

# Cambiar el puerto COMx en Windows o /dev/ttyUSBx en Linux
ser = serial.Serial(port='COMx', baudrate=115200, timeout=.1)

def menu():
    print("Menu de control del led " )
    print("1. Encender" )
    print("2. Apagar" )
    print("3. Salir de la aplicacion" )

def luzON():
    ser.write(b'H')

def luzOFF():
    ser.write(b'L')


def main():
    print("CONTROL REMOTO DE LED")
    while True:
        menu()
        opc = input("Seleccione una opcion: ")
        if opc == '1':
            print("--> Encendiendo led\n")
            luzON()
        elif opc == '2':
            print("--> Apagando led\n")
            luzOFF()
        elif opc == '3':
            ser.close()
            print("--> Hasta luego\n")
            break
        else:
            print("--> OPCION INVALIDA\n")

if __name__ == "__main__":
    main()

Debemos tener la placa conectada a la computadora y Arduino IDE cerrado. En una terminal ejecutamos con python serialLed.py y debería aparecer el menú que desarrollamos. Toca probar su funcionamiento.

Ejecutar comandos por serial

Mon, 01 Jun 2026 06:00:00 GMT

Controlar un led con el monitor serial

Introducción

En anteriores ejemplos utilizamos la comunicación serial para imprimir en pantalla el estado de un elemento en particular, por medio del monitor serial. Por ejemplo, el estado de un botón o el valor de un potenciómetro. Ahora veremos cómo enviar comandos a través de la entrada del mismo monitor.

Circuito

Armemos el típico circuito con un led y resistencia, pero conectemos el led al GPIO16.

Código

Debemos tener en cuenta que le estaremos mandando comandos en tiempo real a la placa para que encienda y apague el led, por lo que debemos definir dichos comandos como variables en nuestro código. Pasemos a definir el código utilizado.

/* Entradas y salidas */
#define led1 16          // GPIO16

/* Comandos */
#define luz_on 'H'       // Luz encendida
#define luz_off 'L'      // Luz apagada

int cmd = 0; // Comando entrado por serial

void setup() {
  // Configuración de los puertos digitales
  pinMode(led1, OUTPUT);
  digitalWrite(led1, LOW);
  // Configuracion del puerto serial
  Serial.begin(115200);

}

void loop() {
  // Responde solo si hay respuesta:
  if (Serial.available() > 0) {
    // Lee lo que esté presente:
    cmd = Serial.read();

    // Encendido o apagado de la luz segun el comando
    if(cmd == luz_on) {
      digitalWrite(led1, HIGH);
      Serial.println("Encendida");
    }
    else if(cmd == luz_off) {
      digitalWrite(led1, LOW);
      Serial.println("Apagada");
    }
  }
}

Con esto, cada vez que encendamos la placa, debemos abrir el monitor serial y escribir en su barra de entrada el comando “H” para encender el led y “L” para apagarlo.

Usar la esp32 como servidor

Mon, 01 Jun 2026 06:00:00 GMT

Controlando un led dentro de una red WiFi

Introducción

Partiremos de la entrada anterior, con la diferencia de que prescindiremos de la placa que funge como punto de acceso, ya que nos conectaremos a una red WiFi ya existente.

Circuito

Podemos partir del mismo circuito que hemos armado con un led conectado al pin GPIO16 y su respectiva resistencia conectada a tierra.

Código

Ahora abrimos Arduino IDE y aunque podemos usar el mismo archivo servidorLED.ino que ya teníamos, vamos a agregarle mayor funcionalidad al sitio web que la esp32 alojará.

/*
  Servidor web en ESP32 conectado a una red WiFi existente.
  Permite controlar el LED mediante peticiones HTTP.

  Pasos:
  1. Conectar la ESP32 a la red WiFi domestica
  2. Averiguar la IP que el router le asigna a la ESP32 (por el monitor serie)
  3. En cualquier dispositivo de la misma red, abrir el navegador y acceder a:
     - http://IP_ESP32/H  -> Enciende el LED
     - http://IP_ESP32/L  -> Apaga el LED
*/

#include 
#include 

// === CONFIGURACION DE LA RED EXISTENTE ===
// Cambiar estos valores por los de la red WiFi domestica
const char *ssid = "ssidGenerico";      // Ejemplo: "MiFibra-2F4G"
const char *password = "passGenerica";   // Ejemplo: "ClaveWifi123"

// Puerto del servidor web (80 es el estandar HTTP)
WiFiServer server(80);

// Declarando el led
const int led = 16;

void setup() {
  pinMode(led, OUTPUT);
  digitalWrite(led, LOW);

  Serial.begin(115200);
  Serial.println();
  Serial.println("=== SERVIDOR ESP32 ===");

  // Intentar conectar a la red WiFi existente
  Serial.print("Conectando a la red WiFi: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  // Esperar hasta 10 segundos para conectarse
  int intentos = 0;
  while (WiFi.status() != WL_CONNECTED && intentos < 20) {
    delay(500);
    Serial.print(".");
    intentos++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println();
    Serial.println("Conectado a la red WiFi exitosamente");
    Serial.print("Direccion IP asignada por el router: ");
    Serial.println(WiFi.localIP());
    Serial.print("Puerta de enlace (router): ");
    Serial.println(WiFi.gatewayIP());
    Serial.print("Intensidad de señal (RSSI): ");
    Serial.print(WiFi.RSSI());
    Serial.println(" dBm");

    server.begin();
    Serial.println("Servidor HTTP iniciado en puerto 80");
    Serial.println("------------------------------------");
    Serial.println("Para controlar el LED, acceder a:");
    Serial.print("   - http://");
    Serial.print(WiFi.localIP());
    Serial.println("/H  -> ENCENDER");
    Serial.print("   - http://");
    Serial.print(WiFi.localIP());
    Serial.println("/L  -> APAGAR");
    Serial.println("------------------------------------");
  } else {
    Serial.println();
    Serial.println("No se pudo conectar a la red WiFi");
    Serial.println("Verifica que:");
    Serial.println("   - El nombre de la red (SSID) sea correcto");
    Serial.println("   - La contrasena sea correcta");
    Serial.println("   - El router este encendido y dentro del alcance");
  }
}

void loop() {
  // Si la conexion WiFi se pierde, intentar reconectar automaticamente
  if (WiFi.status() != WL_CONNECTED) {
    static unsigned long ultimoIntento = 0;
    if (millis() - ultimoIntento > 10000) {  // Intentar cada 10 segundos
      Serial.println("Conexion WiFi perdida. Reconectando...");
      WiFi.reconnect();
      ultimoIntento = millis();
    }
    return;
  }

  WiFiClient client = server.available();

  if (client) {
    Serial.println("Nuevo cliente conectado");
    String currentLine = "";

    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);  // Mostrar la peticion HTTP (opcional)

        if (c == '\n') {
          if (currentLine.length() == 0) {
            // Enviar respuesta HTTP
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();

            // Pagina web de control
            client.println("");
            client.println("");
            client.println("");
            client.println("Control LED ESP32");
            client.println("");
            client.println("");
            client.println("");
            client.println("");
            client.println("");
            client.println("Control de LED ESP32
");
            client.println("");
            client.print("Conectado a la red: ");
            client.print(ssid);
            client.println("
");
            client.println("
");
            client.println("");
            client.println("");
            client.println("Servidor ESP32
");
            client.println("");
            client.println("");

            client.println();
            break;
          } else {
            currentLine = "";
          }
        } else if (c != '\r') {
          currentLine += c;
        }

        // Procesar comandos HTTP
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(led, HIGH);
          Serial.println("LED ENCENDIDO");
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(led, LOW);
          Serial.println("LED APAGADO");
        }
      }
    }

    client.stop();
    Serial.println("Cliente desconectado");
  }

  delay(10);
}

El script puede bajarse desde este enlace.

El monitor serial nos brindará información importante, como la dirección a la que debemos apuntar con el navegador de nuestra computadora. Si todo ha sucedido bien, aparecerá un sitio web muy básico con un par de vínculos. Al dar clic en ellos podremos alterar el estado del led.

Usar la esp32 como punto de acceso

Mon, 01 Jun 2026 06:00:00 GMT

Controlando un led dentro de una red WiFi

Introducción

Es posible utilizar la esp32 como un punto de acceso (AP), así otros dispositivos pueden conectarse a ella mediante la red que crea. Veamos cómo.

Circuito

Podemos partir del mismo circuito que hemos armado con un led y su respectiva resistencia. El punto importante es que utilizaremos dos placas esp32 para esta práctica. El circuito estará conectado a una de ellas, reservando la otra para crear el punto de acceso.

Consideraciones

Se sugiere que primero hagamos una prueba de conectividad para corroborar que todo funciona correctamente en ambas placas. En Arduino IDE, nos dirigimos a Archivo -> Ejemplos -> WiFi -> WiFiScan. Esto nos abrirá un nuevo script. Lo cargamos en ambas placas y verificamos mediante el monitor serial que efectivamente hayan encontrado algunas redes inalámbricas que estén disponibles.

Una vez que hayamos comprobado que las placas pueden detectar redes WiFi, pasamos a la siguiente etapa. Una de ellas se mantendrá en modo Estación (STA, es decir, se conectará al AP) para convertirla en un servidor que controlará un led, mientras la otra la volveremos punto de acceso y creará una red local a la que nos conectaremos. Seguiremos utilizando nuestra computadora para enviar peticiones por medio del AP, por lo que será el cliente en esta red.

Código del AP

Seleccionamos en Arduino IDE la esp32 que usaremos como AP y cargamos el siguiente código:

#include 
#include 

bool led_on = false;
String inputString = "";

const char *ssid = "RED-AP";
const char *password = "PASSWD-AP";

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  Serial.println();
  Serial.println("Configurando punto de acceso...");

  WiFi.softAP(ssid, password);

  IPAddress AP_IP = WiFi.softAPIP();
  Serial.print("Dirección IP del AP: ");
  Serial.println(AP_IP);
  Serial.println();
  Serial.println("Comandos disponibles:");
  Serial.println("  'ip'  - Muestra la IP del AP");
  Serial.println("  'sta' - Muestra número de clientes conectados");
  Serial.println("  'ver' - Muestra configuración actual");
}

void loop() {
    // Verificar comandos por serial
    while (Serial.available()) {
        char inChar = (char)Serial.read();
        inputString += inChar;

        if (inChar == '\n') {
            inputString.trim();  // Eliminar espacios y saltos de línea

            if (inputString == "ip") {
                Serial.print("IP del AP: ");
                Serial.println(WiFi.softAPIP());
            }
            else if (inputString == "sta") {
                Serial.print("Clientes conectados: ");
                Serial.println(WiFi.softAPgetStationNum());
            }
            else if (inputString == "ver") {
                Serial.println("=== CONFIGURACIÓN AP ===");
                Serial.print("SSID: ");
                Serial.println(ssid);
                Serial.print("IP: ");
                Serial.println(WiFi.softAPIP());
                Serial.print("MAC: ");
                Serial.println(WiFi.softAPmacAddress());
                Serial.print("Canal: ");
                Serial.println(WiFi.channel());
                Serial.print("Clientes: ");
                Serial.println(WiFi.softAPgetStationNum());
            }
            else if (inputString.length() > 0) {
                Serial.println("Comando no reconocido. Usar: ip, sta, ver");
            }

            inputString = "";
        }
    }

    // Mostrar cambios en conexiones
    static int last_stations = -1;
    int current_stations = WiFi.softAPgetStationNum();

    if (current_stations != last_stations) {
        Serial.print("Conexiones: ");
        Serial.println(current_stations);
        if (current_stations > 0) {
            Serial.println("Usar 'ip' para ver la dirección del AP");
        }
        last_stations = current_stations;
    }

    // Parpadeo del LED (menos frecuente para no saturar)
    static unsigned long last_toggle = 0;
    if (millis() - last_toggle > 500) {
        digitalWrite(LED_BUILTIN, led_on ? HIGH : LOW);
        led_on = !led_on;
        last_toggle = millis();
    }
}

O bien, se puede descargar el script desde aquí.

Una vez cargado el código, abrimos el monitor serial y confirmamos que se encuentre mostrando el número de conexiones (serán cero), los comandos disponibles y la dirección IP del punto de acceso. Además, el led integrado debe parpadear.

Código del servidor

Ahora abrimos otra ventana de Arduino IDE y cargamos este código en la otra esp32:

/*
 puntoAcceso.ino crea un punto de acceso WiFi y servidorLED.ino proporciona un servidor web en él.

  Pasos:
  1. Conectarse al punto de acceso "RED-AP"
  2. Apuntar el navegador web a http://IP_ESP32/H para encender el LED o a http://IP_ESP32/L para apagarlo
     O
     Ejecutar TCP raw "GET /H" y "GET /L" en la terminal PuTTY con 192.168.4.1 como dirección IP y 80 como puerto
*/

#include 
#include 

// Establecer las credenciales deseadas.
const char *ssid = "RED-AP";
const char *password = "PASSWD-AP";

// Establecer el puerto del servidor web a 80
WiFiServer server(80);

// Declarar pin del led
const int led = 16;

void setup() {
  pinMode(led, OUTPUT);
  Serial.begin(115200);
  Serial.println();
  Serial.print("Conectando a ");

  // Conectarse a la red WiFi con SSID y contraseña
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  IPAddress myIP = WiFi.localIP();
  Serial.print("Conectado con la dirección IP asignada: ");
  Serial.println(myIP);
  server.begin();
  Serial.println("Servidor iniciado en puerto 80");
  Serial.print("Accede desde el navegador en: http://");
  Serial.println(myIP);
}

void loop() {
  WiFiClient client = server.available();   // Escuchar clientes entrantes

  if (client) {                             // Si se recibe un cliente,
    Serial.println("Nuevo Cliente.");       // Imprimir un mensaje en el puerto serie
    String currentLine = "";                // Crear un String para almacenar datos entrantes del cliente
    while (client.connected()) {            // Bucle mientras el cliente esté conectado
      if (client.available()) {             // Si hay bytes para leer del cliente,
        char c = client.read();             // Leer un byte
        Serial.write(c);                    // Imprimirlo en el monitor serie
        if (c == '\n') {                    // Si el byte es un carácter de nueva línea

          // Si la línea actual está vacía, se obtuvieron dos caracteres de nueva línea consecutivos.
          // Ese es el final de la petición HTTP del cliente, por lo que se envía una respuesta:
          if (currentLine.length() == 0) {
            // Las cabeceras HTTP siempre comienzan con un código de respuesta (ej. HTTP/1.1 200 OK)
            // y un tipo de contenido para que el cliente sepa lo que viene, luego una línea en blanco:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();

            // El contenido de la respuesta HTTP sigue a la cabecera:
            client.print("Hacer \"/H\">clic para encender el LED.
");
            client.print("Hacer \"/L\">clic para apagar el LED.
");

            // La respuesta HTTP termina con otra línea en blanco:
            client.println();
            // Salir del bucle while:
            break;
          } else {    // Si se recibió una nueva línea, entonces limpiar currentLine:
            currentLine = "";
          }
        } else if (c != '\r') {  // Si se recibió cualquier cosa excepto un retorno de carro,
          currentLine += c;      // Añadirlo al final de currentLine
        }

        // Verificar si la petición del cliente fue "GET /H" o "GET /L":
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(led, HIGH);               // GET /H enciende el LED
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(led, LOW);                // GET /L apaga el LED
        }
      }
    }
    // Cerrar la conexión:
    client.stop();
    Serial.println("Cliente desconectado.");
  }
}

El script puede descargarse desde este enlace.

El monitor serial de cada placa nos brindará información importante, como la IP del punto de acceso o la dirección a la que debemos apuntar con el navegador de nuestra computadora. Si todo ha sucedido bien, aparecerá un sitio web muy básico con un par de vínculos. Al dar clic en ellos podremos alterar el estado del led.

Controlar un led con GUI

Mon, 01 Jun 2026 06:00:00 GMT

Controlando un led con una GUI

Introducción

En la anterior entrada mandamos órdenes a la ESP32 por medio de comunicación serial y una aplicación externa desarrollada en python para encender o apagar un led. En esta ocasión, dichas órdenes se emitirán por medio de otra aplicación externa que no se ejecutará desde la terminal, si no que tendrá su respectiva interfaz gráfica.

Circuito

Partiremos del circuito con led y resistencia que armamos justo en la entrada pasada.

Código para la ESP32

Exactamente el mismo que para la práctica anterior.

Aplicación externa

Primero debemos asegurarnos de tener instalada la librería kivy. Por ejemplo, para Windows se sugiere:

pip install "kivy[base]" kivy_examples

Y para ArchLinux:

sudo pacman -S python-kivy

Estamos partiendo del supuesto de que las anteriores prácticas han funcionado correctamente. Creamos un archivo llamado serialLedGUI.py y pegamos el siguiente código:

# -*- coding: utf-8 -*-

import sys
import glob
import serial
from serial.tools import list_ports
import time

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.gridlayout import GridLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.switch import Switch
from kivy.uix.spinner import Spinner
from kivy.uix.widget import Widget
from kivy.graphics import Color, RoundedRectangle, Ellipse, Rectangle
from kivy.core.text import LabelBase
from kivy.logger import Logger
from kivy.clock import Clock
from kivy.utils import get_color_from_hex

class LEDIndicator(Widget):
    """Indicador LED circular personalizado"""
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.size_hint = (None, None)
        self.size = (30, 30)
        self._color = (0.3, 0.3, 0.3, 1)  # Color apagado por defecto
        self.bind(pos=self._update, size=self._update)
        self._draw()

    def _draw(self):
        self.canvas.clear()
        with self.canvas:
            Color(*self._color)
            Ellipse(pos=self.pos, size=self.size)

    def _update(self, *args):
        self._draw()

    def set_color(self, color):
        """Cambiar color del LED: color en formato (r,g,b,a)"""
        self._color = color
        self._draw()

    def set_on(self, is_on):
        """Método rápido para encender/apagar"""
        if is_on:
            self.set_color((0.2, 0.9, 0.2, 1))  # Verde brillante
        else:
            self.set_color((0.3, 0.3, 0.3, 1))  # Gris apagado

class StatusIndicator(Widget):
    """Indicador de estado de conexión circular"""
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.size_hint = (None, None)
        self.size = (12, 12)
        self._color = (0.5, 0, 0, 1)  # Rojo apagado
        self.bind(pos=self._update, size=self._update)
        self._draw()

    def _draw(self):
        self.canvas.clear()
        with self.canvas:
            Color(*self._color)
            Ellipse(pos=self.pos, size=self.size)

    def _update(self, *args):
        self._draw()

    def set_connected(self, connected):
        if connected:
            self._color = (0.2, 0.8, 0.2, 1)  # Verde
        else:
            self._color = (0.6, 0, 0, 1)  # Rojo
        self._draw()

    def set_error(self):
        self._color = (0.9, 0.5, 0, 1)  # Naranja
        self._draw()

class StyledButton(Button):
    """Botón personalizado con estilo consistente"""
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.background_normal = ''
        self.background_color = (0.15, 0.45, 0.7, 1)  # Azul oscuro
        self.color = (1, 1, 1, 1)
        self.font_size = '14sp'
        self.size_hint_y = None
        self.height = '40dp'
        self.bold = True

    def on_press(self):
        self.background_color = (0.1, 0.35, 0.55, 1)
        return super().on_press()

    def on_release(self):
        self.background_color = (0.15, 0.45, 0.7, 1)
        return super().on_release()

class DisconnectButton(StyledButton):
    """Botón de desconectar con color rojo"""
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.background_color = (0.7, 0.2, 0.2, 1)

    def on_release(self):
        self.background_color = (0.7, 0.2, 0.2, 1)
        return super().on_release()

class StyledSpinner(Spinner):
    """Spinner personalizado"""
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.background_normal = ''
        self.background_color = (0.2, 0.2, 0.2, 1)
        self.color = (0.9, 0.9, 0.9, 1)
        self.font_size = '12sp'
        self.size_hint_y = None
        self.height = '35dp'

class MainApp(App):

    def on_stop(self):
        """Cerrar la aplicación correctamente"""
        if hasattr(self, 'ser') and self.ser and self.ser.is_open:
            try:
                self.lightOFF()
                time.sleep(0.1)
                self.ser.close()
                print("Puerto cerrado correctamente")
            except:
                pass
        print("Cerrando la aplicación")

    def build(self):
        self.conect_status = False
        self.ser = None

        # Obtener puertos disponibles
        available_ports = self.listPorts()
        if not available_ports:
            Logger.warning("No se encontraron puertos seriales")
            self.PORT = "Ninguno"
        else:
            self.PORT = available_ports[0]

        # Contenedor principal con padding y espaciado - Fondo oscuro
        main_layout = BoxLayout(
            orientation="vertical",
            padding=20,
            spacing=15,
            size_hint=(1, 1)
        )

        # Fondo oscuro con borde redondeado
        with main_layout.canvas.before:
            Color(0.08, 0.08, 0.1, 1)  # Gris muy oscuro azulado
            self.rect = RoundedRectangle(size=main_layout.size, pos=main_layout.pos, radius=[10])
        main_layout.bind(size=self._update_rect, pos=self._update_rect)

        # ===== TÍTULO =====
        title_label = Label(
            text='[b][size=24]Control de LED[/size][/b]',
            markup=True,
            size_hint_y=None,
            height='50dp',
            color=(0.9, 0.9, 0.9, 1)
        )
        main_layout.add_widget(title_label)

        # ===== PANEL DEL LED =====
        led_card = BoxLayout(
            orientation="vertical",
            size_hint_y=None,
            height='150dp',
            padding=15,
            spacing=10
        )

        # Fondo de la tarjeta (gris oscuro)
        with led_card.canvas.before:
            Color(0.12, 0.12, 0.15, 1)
            self.card_rect = RoundedRectangle(size=led_card.size, pos=led_card.pos, radius=[10])
        led_card.bind(size=self._update_card_rect, pos=self._update_card_rect)

        # Subtítulo
        led_subtitle = Label(
            text='[b]Estado del LED[/b]',
            markup=True,
            size_hint_y=None,
            height='30dp',
            color=(0.7, 0.7, 0.7, 1),
            font_size='14sp',
            halign='left'
        )
        led_subtitle.bind(size=led_subtitle.setter('text_size'))
        led_card.add_widget(led_subtitle)

        # Controles del LED
        led_controls = BoxLayout(orientation="horizontal", spacing=20, size_hint_y=None, height='80dp')

        # Switch
        self.light_switch = Switch(active=False, size_hint_x=0.3)
        self.light_switch.disabled = True
        self.light_switch.bind(active=self.change_light)
        led_controls.add_widget(self.light_switch)

        # Indicador LED visual (widget circular real)
        self.led_indicator = LEDIndicator()
        led_controls.add_widget(self.led_indicator)

        # Texto de estado
        self.light_status = Label(
            text='APAGADO',
            markup=True,
            font_size='18sp',
            bold=True,
            color=(0.6, 0.6, 0.6, 1),
            size_hint_x=0.5
        )
        led_controls.add_widget(self.light_status)

        led_card.add_widget(led_controls)
        main_layout.add_widget(led_card)

        # ===== PANEL DE CONFIGURACIÓN =====
        config_card = BoxLayout(
            orientation="vertical",
            size_hint_y=None,
            height='200dp',
            padding=15,
            spacing=10
        )

        with config_card.canvas.before:
            Color(0.12, 0.12, 0.15, 1)
            self.config_rect = RoundedRectangle(size=config_card.size, pos=config_card.pos, radius=[10])
        config_card.bind(size=self._update_config_rect, pos=self._update_config_rect)

        # Subtítulo
        config_title = Label(
            text='[b]Configuración Serial[/b]',
            markup=True,
            size_hint_y=None,
            height='30dp',
            color=(0.7, 0.7, 0.7, 1),
            font_size='14sp',
            halign='left'
        )
        config_title.bind(size=config_title.setter('text_size'))
        config_card.add_widget(config_title)

        # Selector de puerto
        port_layout = BoxLayout(orientation="horizontal", spacing=10, size_hint_y=None, height='40dp')
        port_layout.add_widget(Label(
            text='Puerto:',
            size_hint_x=0.2,
            color=(0.8, 0.8, 0.8, 1),
            font_size='13sp',
            halign='right'
        ))

        self.port_spinner = StyledSpinner(
            text=self.PORT if self.PORT != "Ninguno" else "Sin puertos",
            values=available_ports if available_ports else ["Sin puertos"],
            size_hint_x=0.5
        )
        self.port_spinner.bind(text=self.on_port_selected)
        port_layout.add_widget(self.port_spinner)

        # Botón refrescar
        self.refresh_button = Button(
            text='⟳',
            font_size='18sp',
            size_hint_x=0.15,
            size_hint_y=None,
            height='35dp',
            background_normal='',
            background_color=(0.3, 0.3, 0.35, 1),
            color=(0.9, 0.9, 0.9, 1)
        )
        self.refresh_button.bind(on_press=self.refresh_ports)
        port_layout.add_widget(self.refresh_button)

        port_layout.add_widget(Label(size_hint_x=0.15))
        config_card.add_widget(port_layout)

        # Botones de conexión
        connection_layout = BoxLayout(orientation="horizontal", spacing=10, size_hint_y=None, height='45dp', padding=(0, 10, 0, 0))

        self.connect_button = StyledButton(text="CONECTAR")
        self.connect_button.bind(on_press=self.connect)
        connection_layout.add_widget(self.connect_button)

        # Estado de conexión con indicador visual
        status_layout = BoxLayout(orientation="horizontal", spacing=8, size_hint_x=0.5)

        self.status_indicator = StatusIndicator()
        status_layout.add_widget(self.status_indicator)

        self.connection_status = Label(
            text='Desconectado',
            color=(0.7, 0.7, 0.7, 1),
            font_size='13sp',
            size_hint_x=0.85,
            halign='left'
        )
        self.connection_status.bind(size=self.connection_status.setter('text_size'))
        status_layout.add_widget(self.connection_status)

        connection_layout.add_widget(status_layout)
        config_card.add_widget(connection_layout)

        main_layout.add_widget(config_card)

        # Barra de información inferior
        info_bar = Label(
            text='[size=10]✓ Listo para conectar[/size]',
            markup=True,
            size_hint_y=None,
            height='25dp',
            color=(0.6, 0.6, 0.6, 1)
        )
        self.info_label = info_bar
        main_layout.add_widget(info_bar)

        return main_layout

    def _update_rect(self, instance, value):
        self.rect.size = instance.size
        self.rect.pos = instance.pos

    def _update_card_rect(self, instance, value):
        self.card_rect.size = instance.size
        self.card_rect.pos = instance.pos

    def _update_config_rect(self, instance, value):
        self.config_rect.size = instance.size
        self.config_rect.pos = instance.pos

    def on_port_selected(self, spinner, text):
        if not self.conect_status:
            self.PORT = text
            Logger.debug(f"Puerto seleccionado: {self.PORT}")

    def refresh_ports(self, instance):
        available_ports = self.listPorts()
        if available_ports:
            self.port_spinner.values = available_ports
            if self.PORT not in available_ports:
                self.PORT = available_ports[0]
                self.port_spinner.text = self.PORT
            # Animación de refresco
            instance.text = '✓'
            Clock.schedule_once(lambda dt: setattr(instance, 'text', '⟳'), 0.5)
            self.info_label.text = '[size=10]✓ Puertos actualizados[/size]'
            Clock.schedule_once(lambda dt: self._reset_info(), 2)
        else:
            self.port_spinner.values = ["Sin puertos"]
            self.port_spinner.text = "Sin puertos"
            self.info_label.text = '[size=10]⚠ No se encontraron puertos[/size]'

    def _reset_info(self):
        if not self.conect_status:
            self.info_label.text = '[size=10]✓ Listo para conectar[/size]'
        else:
            self.info_label.text = f'[size=10]✓ Conectado a {self.PORT}[/size]'

    def change_light(self, instance, value):
        if not self.conect_status:
            Logger.warning("No conectado al puerto serial")
            self.light_switch.active = False
            return

        try:
            if value:
                self.light_status.text = 'ENCENDIDO'
                self.light_status.color = (0.3, 0.9, 0.3, 1)
                self.led_indicator.set_on(True)
                Logger.debug("LED On")
                self.lightON()
            else:
                self.light_status.text = 'APAGADO'
                self.light_status.color = (0.6, 0.6, 0.6, 1)
                self.led_indicator.set_on(False)
                Logger.debug("LED Off")
                self.lightOFF()
        except Exception as e:
            Logger.error(f"Error al cambiar LED: {e}")
            self.light_switch.active = not value

    def connect(self, instance):
        if not self.conect_status:
            try:
                if self.PORT == "Ninguno" or self.PORT == "Sin puertos":
                    Logger.error("No hay puerto disponible")
                    self.info_label.text = '[size=10]✗ Error: No hay puerto disponible[/size]'
                    return

                self.ser = serial.Serial(
                    port=self.PORT,
                    baudrate=115200,
                    timeout=0.5,
                    write_timeout=0.5
                )
                time.sleep(0.5)

                self.connect_button.text = "DESCONECTAR"
                self.connect_button.background_color = (0.7, 0.2, 0.2, 1)
                self.connection_status.text = 'Conectado'
                self.connection_status.color = (0.3, 0.8, 0.3, 1)
                self.status_indicator.set_connected(True)
                self.light_switch.disabled = False
                self.conect_status = True
                self.info_label.text = f'[size=10]✓ Conectado a {self.PORT}[/size]'
                Logger.debug(f"Conectado a {self.PORT}")

            except serial.SerialException as e:
                Logger.error(f"Error de conexión: {e}")
                self.connection_status.text = 'Error'
                self.connection_status.color = (0.9, 0.5, 0, 1)
                self.status_indicator.set_error()
                self.info_label.text = f'[size=10]✗ Error: {str(e)[:40]}[/size]'

        else:
            try:
                if self.ser and self.ser.is_open:
                    self.lightOFF()
                    time.sleep(0.1)
                    self.ser.close()

                self.connect_button.text = "CONECTAR"
                self.connect_button.background_color = (0.15, 0.45, 0.7, 1)
                self.connection_status.text = 'Desconectado'
                self.connection_status.color = (0.7, 0.7, 0.7, 1)
                self.status_indicator.set_connected(False)
                self.light_switch.disabled = True
                self.light_switch.active = False
                self.light_status.text = 'APAGADO'
                self.light_status.color = (0.6, 0.6, 0.6, 1)
                self.led_indicator.set_on(False)
                self.conect_status = False
                self.info_label.text = '[size=10]✓ Desconectado[/size]'
                Logger.debug("Desconectado")

            except Exception as e:
                Logger.error(f"Error al desconectar: {e}")

    def listPorts(self):
        ports = []
        try:
            for port in list_ports.comports():
                if 'ttyUSB' in port.device or 'ttyACM' in port.device:
                    ports.append(port.device)
                elif 'COM' in port.device:
                    ports.append(port.device)
            Logger.debug(f"Puertos encontrados: {ports}")
        except Exception as e:
            Logger.error(f"Error al listar puertos: {e}")
        return ports

    def lightON(self):
        if self.ser and self.ser.is_open:
            try:
                self.ser.write(b'H')
                self.ser.flush()
                Logger.debug("Comando H enviado")
            except Exception as e:
                Logger.error(f"Error al enviar H: {e}")

    def lightOFF(self):
        if self.ser and self.ser.is_open:
            try:
                self.ser.write(b'L')
                self.ser.flush()
                Logger.debug("Comando L enviado")
            except Exception as e:
                Logger.error(f"Error al enviar L: {e}")

if __name__ == "__main__":
    app = MainApp()
    app.run()

Igual el código fuente se puede descargar de aquí.

Debemos asegurarnos de conectar primero el puerto. Si esto se logra, deberíamos poder encender y apagar el led por medio de los botones.

Detalles de hacerle al webmaster

Mon, 18 May 2026 06:00:00 GMT

Hey, yo no estoy a la altura

No todo sale bien

Pues resulta que después de una actualización, FileZilla se negó rotundamente a conectarse al servidor. Desconozco si la actualización que rompió mi flujo fue de mi sistema, de FileZilla o del servidor pero el punto es que ya no pude actualizar el sitio.

Después de algunas búsquedas (y estar peleando con la IA del proveedor de hosting) y la ayuda de otra IA (DeepSeek) parece que he ido resolviendo el asunto. Documento el proceso aquí, para no andarlo buscando de nuevo.

Toca instalar lftp:

sudo pacman -S lftp

Luego me conecto al servidor usando este nuevo programa:

lftp -u USUARIO,CONTRASENA ftp://holztank.top:21

Entonces zsh, que es mi emulador de terminal me manda al diablo y me dice que no encuentra coincidencias. Vaya. Está identificando el * como una extensión. Toca entrecomillar el usuario y contraseña:

lftp -u 'USUARIO,CONTRASENA' ftp://holztank.top:21

Y con eso devuelve el prompt lftp usuario@holztank.top:~>, lo que indica que todo va bien. El siguiente paso es ir introduciendo las siguientes líneas, una por una:

set ftp:ssl-allow true
set ftp:ssl-force true
set ftp:ssl-protect-data true
set ssl:verify-certificate false
ls

Cabe mencionar que la última línea tarda demasiado, así que solo la usaré cuando realmente necesite saber qué hay dentro de la carpeta en cuestión.

Lo ideal ahora es cerrar lftp y ejecutarlo dentro del directorio raíz de mi proyecto (lo tengo hecho en Quarto), para de esa manera repetir todo lo anterior (menos el ls) y ejecutar lo siguiente:

open -u USUARIO,CONTRASENA ftp://holztank.top:21

El comando anterior permite abrir el puerto, básicamente. Para ya “subir” mis archivos al servidor, ejecuto

mirror -R --delete --verbose --only-newer _site/ public_html/

Este comando borra archivos que no estén en la carpeta origen y copia solamente los que hayan sido modificados. Cabe decir que Quarto genera los sitios web en la carpeta _site y que mi servidor los debe alojar en la carpeta public_html. Es probable que se tarde también lo suyo.

Había olvidado un punto: que para salir de lftp hay que ejecutar un simple quit.

Y si todo ha salido bien, el sitio debe estar actualizado y por eso lo podrá estar viendo el yo del futuro o tú lo estarás leyendo.

EDIT: Pues resulta que FileZilla sí funciona, pero como mi proveedor de hosting actualizó un no-sé-qué sobre asuntos de privacidad, pues el certificado SSL ya no coincidía. Cosas de la vida, supongo. Tenía que permitir al programa que pudiera esperar hasta 300 segundos para que el diálogo que me tenía que preguntar si aceptaba el certificado apareciera. Y pues eso, apareció, lo acepté y ya funciona la transferencia por FileZilla.

EDIT 2: Ahora la transferencia es lentísima. Más de 30 segundos para volver a conectarse al servidor. Esto no era así hace un par de semanas.

EDIT 3: Vuelvo a lftp, pero ahora con el uso de scripts que incluyan notificaciones de escritorio (en KDE Plasma) y quizá un arreglo a lo lento que se han vuelto las transferencias. Veremos qué tal.

Repito, cosas de la vida.

Lectura del estado de un botón

Thu, 07 May 2026 06:00:00 GMT

Circuito

Estaremos utilizando un botón switch y leeremos su estado, imprimiéndolo mediante el monitor serial. Haremos uso de la propiedad pull up de los pines de la ESP32 para así prescindir de una resistencia en el circuito.

Leyendo el estado de un botón

Código

const int boton = 13;

void setup() {
  Serial.begin(115200);
  pinMode(boton, INPUT_PULLUP);
}

void loop() {
  int estado_boton = digitalRead(boton);
  Serial.println(estado_boton);
}

Encendiendo un led gradualmente (con un pot)

Thu, 07 May 2026 06:00:00 GMT

Circuito

Controlaremos el brillo del led tras manipular el potenciómetro.

Encendiendo gradualmente un led con un pot

int led = 16;
int pot = 4;
int valorpot = 0;
int valorled = 0;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  valorpot = analogRead(pot);
  valorled = map(valorpot, 0, 4095, 0, 255);
  analogWrite(led, valorled);
  Serial.print("Lectura del pot = ");
  Serial.print(valorpot);
  Serial.print("\t Brillo del led = ");
  Serial.println(valorled);
  delay(2);
}

Lectura de valores de un potenciómetro

Thu, 07 May 2026 06:00:00 GMT

Circuito

Realizaremos la lectura de los valores de un potenciómetro. Es importante saber que este es un dispositivo analógico, por lo que la lectura sí permite valores graduales (no solamente unos y ceros).

Leyendo los valores del pot

void setup() // Se ejecuta cada vez que el Arduino se inicia
{
  pinMode(34, INPUT);
  Serial.begin(115200); //Inicia comunicación serial
  delay(1000);
}
//------------------------------------
//Funcion cíclica
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{
 // cuando este energizado el Arduino
//Guardar en una variable entera el valor del potenciómetro 0 a 1023
int valor = analogRead(34);
//Imprime en la consola serial el valor de la variable
Serial.println(valor);
//Retardo para la visualización de datos en la consola
delay(500);
}

Encendiendo un led con un botón

Wed, 06 May 2026 06:00:00 GMT

Circuito

Combinaremos lo aprendido con el led y el botón para controlar al primero con el segundo.

Encendiendo un led presionando un botón

Código

const int boton = 13;
const int led = 2;
int estado_boton = 0;

void setup() {
  Serial.begin(115200);
  pinMode(boton, INPUT_PULLUP);
  pinMode(led, OUTPUT);
}

void loop() {
  int estado_boton = digitalRead(boton);
  if (estado_boton == LOW) {
    Serial.println(estado_boton);
    digitalWrite(led, HIGH);
  }
  else {
    digitalWrite(led, LOW);
  }
}

TexLive

Mon, 04 May 2026 06:00:00 GMT

Hola, mundo en LaTex

Instalando texlive

Si estamos en Linux, especialmente ArchLinux o sus derivadas, la instalación de un entorno de “desarrollo” para LaTex puede ser un tanto más sencilla que en otros sistemas operativos. Sin embargo, también depende, aunque en menor medida, del entorno de escritorio que estemos utilizando. En mi caso, en el día a día uso KDE Plasma, por lo que la elección para editar documentos es Kile. Pero toca instalar antes una distribución LaTex, que será texlive.

Hay que instalar

sudo pacman -S texlive-latex texlive-latexrecommended

Esto nos dejará tener un sistema básico y funcional. Pero como hablamos y escribimos en español, toca incluir un paquete más:

sudo pacman -S texlive-langspanish

Ahora sí, nos ponemos a instalar Kile:

sudo pacman -S kile

Ejecutamos Kile y lo primero que nos mostrará será su “Verificador del sistema”, el cual es un cuadro de diálogo que revisará si podemos renderizar documentos en tiempo real en nuestro equipo. Presionamos Siguiente y esperamos a que escanee nuestro equipo. Si seguimos los pasos anteriores, debería pasar todas las pruebas. Dejamos seleccionadas las tres opciones que nos muestra y clicamos en Aceptar.

Probando la instalación

Nos vamos al menú Archivo -> Nuevo o presionamos Ctrl+N y clicamos en Archivo vacío y en Aceptar. Para poder ver la vista en vivo, debemos guardar el archivo en Archivo -> Guardar o presionamos Ctrl+S. Kile nos indicará que hay algo mal, pero vamos a ignorarlo. Marca error al renderizar porque no hay algo que renderice. Lo guardamos donde deseemos con el nombre prueba (el programa agregará la extensión .tex) y comenzamos a escribir lo siguiente:

\documentclass{article}
\begin{document}
 ¡Hola, mundo!
\end{document}

Le damos en Guardar y a la derecha debe verse nuestro documento en su “forma final”. Si queremos generar el documento PDF, nos vamos a la pestaña Konsole que está abajo a la izquierda y escribimos

pdflatex prueba

Esto debe hacer que aparezca el archivo en el mismo sitio donde guardamos prueba.tex. Y ya está, hemos creado nuestro primer documento LaTex.

Encendiendo un led

Thu, 30 Apr 2026 06:00:00 GMT

Lo necesario

Tablilla de prototipado
ESP32 / cable USB
Led
Resistencia de 220R
Dos cables macho-hembra

Circuito

Es el más básico. Solo hay que asegurarse de siempre conectar una resistencia al led, puede ser en cualquiera de sus terminales, aunque por costumbre la conectamos a la tierra de este (la terminal corta).

Encendiendo un led

Código en C++

Ya una vez armado nuestro circuito, pasamos a programarlo. El código necesario es:

// Declaración de variables
const int led = 2;

// Código que solo corre al inicio
void setup() {
  pinMode(ledPin, OUTPUT); // Pin 2 como salida
}

// Código que se estará ejecutando indefinidamente
void loop() {
  digitalWrite(led, HIGH); // Enciende el pin 2
  delay(1000); // durante un segundo.
  digitalWrite(led, LOW); // Apaga el pin 2
  delay(500); // durante otro segundo
}

Código en MicroPython

# Importamos los módulos necesarios
import machine
import time

# Declaramos el pin 2 como salida
led = machine.Pin(2, machine.Pin.OUT)

# Ejecutamos un ciclo
while True:
    # Enciende el led
    led.on()
    # por un segundo
    time.sleep(1)
    # Apaga el led
    led.off()
    # por otro segundo
    time.sleep(1)

ESP32 y Arduino IDE

Thu, 30 Apr 2026 06:00:00 GMT

Pantalla principal de Arduino IDE

Si ya te decidiste a desarrollar tus prácticas con la ESP32, pero no te quieres agobiar con su propio framework, puedes optar por programarla en Arduino IDE y con C++. Sin embargo, no es algo tan simple como conectar y ya. Debe prepararse tu entorno de desarrollo. Pasemos a ello.

Placas soportadas

Prácticamente todas, pero un par de ellas con un matiz: la C2 y la C61 requieren reconstruir las bibliotecas estáticas. Si tu placa no es una de ellas, podemos continuar.

Arduino IDE

Lo primero es descargar e instalar Arduino IDE desde la página oficial de Descargas de Arduino, que al momento de escribir esta entrada iba en la versión 2.3.8. Al ejecutarlo por primera vez comenzará a descargar e instalar librerías y demás. Es normal.
Enseguida nos vamos al menú File -> Preferences, lo que abrirá una nueva ventana en la que podemos modificar la carpeta en la que se estarán guardando los archivos que vayamos generando, además del tema y el lenguaje. En lo personal, prefiero cambiar la carpeta y el idioma.

Importante

A partir de este momento, todas las referencias a la interfaz de Arduino IDe estarán en español.

Lo importante está al final de la ventana: hay una caja de texto que dice “URLs adicionales de gestor de placas” y en la cual podemos pegar cualquiera de las direcciones de las cuales sacaremos los archivos necesarios:

# Versión estable
https://espressif.github.io/arduino-esp32/package_esp32_index.json

# Versión en desarrollo
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Incluso si queremos pegar ambas, las separamos con una coma. Aunque no es muy recomendable hacerlo. Damos clic en Aceptar.

Nos vamos al menú Herramientas -> Placa -> Gestor de placas y veremos aparecer un panel a la izquierda del programa. Ahí tendrá su propia caja de búsqueda. Escribimos esp32 y nos instalamos la subida por Espressif Systems, que a abril de 2026 va en la versión 3.3.8. El proceso de instalación puede ser tardado. Una vez que haya terminado nos avisará de ello.
Lo siguiente es buscar y seleccionar nuestra placa en el menú Herramientas -> Placa -> esp32. Muy probablemente no encontremos nuestro modelo específico, pero algunos funcionan muy bien con los que normalmente se consiguen en el país. Uno es DOIT ESP32 DEVKIT V1.
Conectamos la placa a la computadora y esta debería ser reconocida. Si no, muy probablemente la instalación automática de los controladores en Windows no funcionó. Toca instalarlos manualmente.

Controladores para Windows

Se obtienen en el sitio de Silicon Labs, siendo suficiente el comprimido CP210x Universal Windows Drivers. En este se encuentra un archivo llamado silabser.inf. Darle clic derecho y luego Instalar.

Una vez reconocida, ya podemos subir nuestros programas a la placa. En una posterior entrada encenderemos un led con ella.

Si deseas desarrollar en microPython para esta placa, la siguiente entrada aborda el proceso de preparación del entorno.

ESP32 y MicroPython

Thu, 30 Apr 2026 06:00:00 GMT

Ventana principal de Arduino Labs for microPython

Windows

Para poder desarrollar nuestras aplicaciones embebidas con microPython en Windows necesitamos tener los controladores UART para la PC y Python instalado tanto en la misma como en la placa ESP32.

Controladores UART

Python

Lo primero se consigue descargando el instalador en python.org. Una vez instalado, podemos instalar la siguiente herramienta.

ESPtool

En la terminal (el CMD en Windows) escribimos el comando

pip install esptool

Cabe mencionar que en ocasiones este comando no funciona, por lo que tocará buscar otras alternativas, del estilo de:

python.exe -m install esptool

Linux

Python viene instalado por defecto en la mayoría de las distribuciones Linux, por lo que solo será necesario instalar esptool, lo cual dependerá de la distro en sí. En el caso de ArchLinux y derivadas basta con

sudo pacman -S esptool

MicroPython

Detectando la placa

Conectamos la ESP32 a la PC y nos aseguramos que ha sido detectada. En Windows podemos verlo en el Gestor de Dispositivos -> Puertos, típicamente estando en los COMx (siendo x un número).

En Linux hay que escribir en la terminal

lsusb

Entonces nos dirigimos al sitio de descargas de microPython (https://micropython.org/download/?port=esp32) y elegimos el binario correspondiente a nuestra placa. Típicamente es la ESP32/WROOM, pero debemos verificar con la imagen de referencia que el mismo sitio coloca. Descargamos el firmware más reciente y lo dejamos en la carpeta que nos parezca más adecuada.

Borrando el firmware

Después debemos borrar la memoria flash de la placa. Basta con escribir en la terminal de Windows:

esptool.py erase-flash

O en Linux:

esptool erase-flash

Es probable que en Linux debamos hacerlo con permisos de superusuario. Además, si ocurre un error de escritura, sobretodo si la placa es nueva, debemos habilitar el modo escritura, lo cual se logra presionando el botón BOOT de la misma cuando aparezca el mensaje Connecting... y soltarlo cuando ya haya comenzado a escribir.

Si no es encontrada la placa, podemos forzar la escritura del comando agregando el parámetro --port COMx:

esptool.py --port COMx erase-flash

Instalando microPython en la placa

Estando en la terminal, nos dirigimos a la carpeta en la que dejamos el firmware descargado y procedemos a instalarlo en la placa. Escribimos el comando

esptool.py --baud 460800 write-flash 0x1000 ESP32_GENERIC-20260406-v1.28.0.bin

Es probable que la versión de microPython haya cambiado, por lo que el nombre del archivo difiera del mostrado (ESP32_GENERIC-20260406-v1.28.0.bin).

El IDE

En sí no existe un buen IDE para microPython, pero uno que resulta aceptable es Arduino Lab for microPython, del cual puede descargarse un portable desde su sitio.

Una vez descargado, descomprimimos y ejecutamos. Lo primero que hará será preguntarnos en dónde queremos guardar los archivos que vayamos generando. Es importante tener en cuenta que deberíamos crear una carpeta para cada proyecto, ya que los archivos que estaremos enviando a la placa se llaman indistintamente main.py.

Elegimos la ubicación y, si tenemos conectada la placa a la PC, podemos optar por presionar el botón Conectar y esperar a que aparezca el diálogo que nos da a elegir el puerto en el que se encuentra la placa. Si todo se realiza bien, ya estaremos en condiciones de ejecutar nuestros programas en la ESP32 con microPython.

Probablemente en Linux surjan problemas de permisos. En Arch y derivadas se resuelve reiniciando después de ejecutar el siguiente comando en consola (donde usuario es el nombre de quien inicia la sesión en Linux):

sudo usermod -a -G uucp <usuario>

Ya estaremos en condiciones de subir nuestros programas a la placa, lo cual abordaremos en la siguiente entrada.