En efecto sí, existen enchufes inteligentes basados en ESP32 que se pueden hackear para ser controlados con scripts en Python, especialmente aquellos que permiten cambiar su firmware o, directamente, los modelos DIY y genéricos que se encuentran en el mercado asiático.

Modelos y Alternativas Usados

• Muchos enchufes inteligentes económicos, especialmente los compatibles con Tuya, Teckin, Sonoff y otros, utilizan chips ESP32 o ESP8266 y pueden «abrirse» para flashear un firmware personalizado como Tasmota, ESPHome o incluso MicroPython.
• Hay marcas como SwitchBot mini que incluyen ESP32 y permiten flasheo OTA (over-the-air) según experiencias de usuarios. Esto facilita la modificación del firmware sin necesidad de abrir el dispositivo físicamente, en algunos casos.
• Enchufes DIY o placas Smart Plug de Aliexpress que indican “ESP32 hack” o “ESP32 flashable” son buenas opciones, ya que suelen traer pines expuestos de programación UART y ejemplos de uso Python y MicroPython.

Control Desde Python

• Si el enchufe permite ejecutar MicroPython (como muchos modelos basados en ESP32), es sencillo cargar un pequeño servidor web o script que pueda recibir comandos desde Python, ya sea usando sockets o HTTP.
• Alternativamente, proyectos como Tasmota o ESPHome hacen que el enchufe sea controlable desde la red local, y existen bibliotecas en Python para interactuar con ellos por MQTT, HTTP REST o incluso desde Home Assistant.
• Existen tutoriales y repos públicos (por ejemplo, “SmartUPy” en GitHub) que muestran cómo controlar enchufes inteligentes desde Python usando ESP32 y MicroPython—y explican cómo configurarlo y modificar el firmware.
• Por tanto las opciones más accesibles son los enchufes basados en Tuya/Sonoff con ESP32, o los modelos de Aliexpress genéricos y DIY, flasheando Tasmota, ESPHome o MicroPython,

Cómo empezar

• Para flashear estos dispositivos normalmente necesitas: conexión por USB-TTL al ESP32 (acceso físico), el firmware elegido (MicroPython, Tasmota, ESPHome, etc.), y una herramienta como esptool o similar para la carga.
• Una vez flasheado, puedes desarrollar un script en Python que controle el enchufe por WiFi usando HTTP, MQTT, WebSocket o cualquier protocolo que soporte ese firmware personalizado.
• Busca modelos en Aliexpress o Amazon que especifiquen ESP32 y tengan buena documentación para el flasheo y acceso a UART/GPIO.

Controlar enchufes inteligentes desde un PC con python

Y hablando de control también es totalmente posible controlar uno o varios enchufes inteligentes desde un PC usando scripts en Python, tanto para modelos comerciales (como TP-Link, Tuya, Sonoff) como para enchufes DIY con ESP32. Existen varias bibliotecas y métodos según la marca y el firmware del enchufe.

Opciones para control desde Python

• Enchufes TP-Link (Kasa): Se pueden controlar localmente con la biblioteca python-kasa, que permite encender, apagar, y leer el estado fácilmente si están en la misma red.github+2
• Enchufes compatibles con Tuya/Smart Life: Si el enchufe es compatible con la plataforma Tuya, existen herramientas como tinytuya y APIs Python que permiten el control local, siempre que consigas el Device ID, local key e IP. Esto es válido para marcas como Teckin y muchas otras económicas.isnum+2
• Enchufes con firmware Tasmota o ESPHome: Si se flashea el enchufe con Tasmota/ESPHome, el dispositivo expone interfaces HTTP, MQTT o REST, lo cual facilita su control con cualquier script Python—esto aplica también para dispositivos basados en ESP32 y ESP8266.tinkeriot+3
• MicroPython en ESP32: Para enchufes DIY o hackeados, si pueden ejecutar MicroPython, es posible cargar scripts personalizados y controlarlos por sockets, HTTP o MQTT, y enviar comandos desde Python en el PC.lemariva

Bibliotecas útiles

• python-kasa: para TP-Link Kasa.
• tinytuya: para enchufes Tuya/SmartLife.
• Requests/MQTT: para dispositivos con Tasmota/ESPHome.

Consideraciones prácticas

• Es recomendable configurar los enchufes con IP fija en tu red.
• Necesitarás obtener credenciales básicas (ID/dispositivo y claves) para algunos enchufes.
• Puedes controlar varios enchufes simultáneamente simplemente guardando sus datos (ID, IP, clave) y manejando cada uno desde tu script Python.

Ejemplos de código Python para enchufes Tuya usando tinytuya

Aquí tienes varios ejemplos de código en Python para controlar enchufes inteligentes Tuya usando la librería tinytuya. Debes obtener primero el Device ID, Local Key y la IP del enchufe (consulta la documentación oficial para extraerlos fácilmente):github . Para obtener el Device ID, Local Key y la IP de tu enchufe Tuya, existen varios métodos prácticos y accesibles:

Método oficial con cuenta Tuya Developer

1. Regístrate en la plataforma Tuya IoT Developer y vincula tu cuenta de la app Tuya o Smart Life.
2. En el panel de desarrollador, crea un proyecto y añade tus dispositivos (enchufes).
3. En la sección «Devices» del proyecto, verás listados todos tus dispositivos con su Device ID y su IP si están conectados.
4. Para obtener el Local Key, usa la API Explorer dentro de la plataforma Tuya, solicitando la información del dispositivo; la respuesta incluirá esa clave.

Este método es seguro y oficial para extraer las credenciales necesarias para control local de dispositivos Tuya.

Método manual y práctico (más simple)

• Algunos usuarios extraen el Local Key con apps específicas o herramientas que interceptan el tráfico en la red local o acceden al almacenamiento de la app Tuya Smart o Smart Life en el móvil.
• Hay tutoriales disponibles en video donde se explica paso a paso cómo usar versiones específicas de apps o herramientas externas para obtener estas claves directamente desde la app móvil o red local (requiere conocimientos técnicos y puede implicar riesgo de seguridad).

Información necesaria para control con tinytuya

• Device ID: Identificador único del enchufe Tuya.
• Local Key: Clave local para comunicación segura.
• IP: Dirección local en red del enchufe (puedes obtenerla desde el router o la app Tuya).

Una vez que tengas estos datos, podrás controlar el enchufe con scripts Python usando tinytuya como en los ejemplos previos. Veamos los siguientes pasos para controlar uno o varios enchufes Tuya mediante Python:

Instalar la librería

python -m pip install tinytuya

Ejemplo básico: Leer estado y encender/apagar

import tinytuya

# Inicializa el enchufe
dev = tinytuya.OutletDevice('DEVICE_ID', 'IP_DEL_ENCHUFE', 'LOCAL_KEY')
dev.set_version(3.3)  # Asegúrate de poner la versión correcta

# Leer estado actual
data = dev.status()
print("Estado del enchufe:", data)

# Encender el enchufe
dev.turn_on()

# Apagar el enchufe
dev.turn_off()

Ejemplo: Alternar estado

import tinytuya

dev = tinytuya.OutletDevice('DEVICE_ID', 'IP_DEL_ENCHUFE', 'LOCAL_KEY')
dev.set_version(3.3)
estado = dev.status()["dps"]["1"]
dev.set_status(not estado)

Múltiples enchufes en un solo script

import tinytuya

enchufes = [
    {"id": "ID1", "ip": "192.168.1.50", "key": "LOCAL_KEY1"},
    {"id": "ID2", "ip": "192.168.1.51", "key": "LOCAL_KEY2"}
]

for enchufe in enchufes:
    dev = tinytuya.OutletDevice(enchufe["id"], enchufe["ip"], enchufe["key"])
    dev.set_version(3.3)
    dev.turn_on()  # Enciende todos los enchufes

Encontrar dispositivos en la red (escaneo)

import tinytuya

devices = tinytuya.deviceScan()
for dev in devices:
    print(devices[dev])

Estos ejemplos muestran cómo automatizar desde un PC el control de uno o varios enchufes inteligentes Tuya por red local usando Python, sin depender de la nube.github

1. https://github.com/jasonacox/tinytuya