Interfaz Física Robusta para Control de Domótica

Componentes y Suministros

Componente	Cantidad
Servo TowerPro SG90	3
Bisagras Pequeñas	2
Pulsadores	2
Arduino Yun	1
Transformador de Corriente 100A (YHDC SCT-013-000)	1
Resistencias y Condensadores (varios)	7

Sobre el Proyecto

Ver los dos videos al inicio para explicación rápida.

Concepto: Interfaz Física vs Virtual

La mayoría de plataformas domóticas usan "interfaz virtual": sacas el móvil, abres app, ves estado, enciendes/apagas. Vale cuando estás fuera. Pero mirar una representación virtual y parsear info en pantalla requiere foco y no es intuitivo.

Quise hacer una "interfaz física": una casa modelo que imita físicamente lo que quiero saber de mi casa real. Si la puerta del garaje está abierta, la del modelo también. Puede estar en la mesa del salón: un vistazo al acostarse confirma si el garaje quedó abierto. O en mi escritorio del trabajo (conectado por VPN): veo si la puerta principal quedó abierta. Tan creativa o utilitaria como yo la haga.

Plan del Proyecto

1. Construir casa modelo: muestra posición puertas, consumo energía, luz encendida
2. Monitor energía con librería OpenEnergyMonitor → datos a casa modelo y OpenHAB
3. Varias formas de enviar posición puertas/ventanas: sensor DIY, Wink Hub + sensor "Tripper"
4. Salidas: abrir/cerrar garaje real, encender/apagar luces (Wink + Arduino)

La casa modelo tiene servos y LEDs en Arduino. Este se suscribe a temas MQTT (posiciones puertas, consumo) y acciona servos/LEDs. Igual para LED de luz encendida. Hay varias opciones para llevar datos al broker MQTT (detalladas luego). Centro: Raspberry Pi con broker MQTT (Mosquitto) y OpenHAB. OpenHAB no es necesario para la casa modelo, pero sí para app móvil y monitorización/actuación remota. Tener interfaz física no significa tirar la virtual.

La casa modelo tiene 2 botones: uno alterna bombilla Zigbee on/off; otro abre/cierra garaje real.

Parte 1: Construcción Casa Modelo

Paso 1: Construcción

No pretendo ser prescriptivo. Soy aficionado a manualidades; solo muestro cómo hice la mía. Adáptala a tu vivienda y prioridades. Mucha creatividad posible.

Componentes

• Caja de cartón (tamaño/proporciones a tu gusto)
• 3 Servos TowerPro SG90 (enlace)
• 2 Bisagras pequeñas (enlace)
• Adhesivo (usé cinta doble cara 3M de ganchos)
• Arduino Yun (o Arduino Uno + Ethernet Shield)
• Pulsadores (enlace)
• Cositas por casa

Techo

Corté una solapa lateral de la caja y la pegué a la otra (todavía unida) para formar techo. Usé caja pequeña para ángulo recto, luego reforcé con pieza Lego. Usa lo que tengas.

Puertas/Ventanas

Recorta huecos para puertas a monitorizar. Pega bisagra(s) en puerta con cinta doble cara y fija a casa. Nada fancy; improvisa. Usé tiras adhesivas 3M foam (las de ganchos) para bisagras y montar servos.

• Puerta garaje: brazo servo la abre, gravedad la cierra
• Puerta entrada: hilo en puerta bisagrada para que servo la abra. Pieza Lego amarilla separa servo de bisagra

Medidor Energía

Recorta flecha y pégala a brazo servo. Recorta forma "arbusto", marca escala kW, encaja servo en caja con arbusto entre medio.

LED rojo sobre servo consumo. Dos pulsadores (momentáneos) para luces y garaje: roscados con tuerca exterior, contactos metálicos interior para soldar cables.

Paso 2: Cableado y Código

Conexiones (pines Arduino)

• LED estado MQTT: pin 7
• LED indicador luz: pin 4
• Servo 1 (puerta entrada): pin 3
• Servo 2 (puerta garaje): pin 5
• Servo 3 (medidor energía): pin 6
• Pulsador 1 (luces on/off): pin 8
• Pulsador 2 (garaje abrir/cerrar): pin 9

Opciones de Controlador

• Arduino Uno clone + Ethernet Shield (~$20): empecé con esto, pero cable Ethernet me ataba
• Arduino Yun (~$65): más caro, pero WiFi nativo. Muy fácil: conectar por Ethernet al router, entrar a web Yun, configurar contraseñas/IP estática, subir sketch

Sketches adjuntos para ambos (muy similares, salvo puente Ethernet en Yun). El sketch Uno no tiene los botones (los añadí al pasar a Yun).

Video con Yun (paso 1). Video con Uno + Ethernet Shield (sin botones aún): YouTube

Archivos código: smarthome_ethernet.ino, smarthome_yun.ino

Parte 2: Entradas (Sensores)

Paso 3: Sensor - Monitor Energía

Necesitamos nodo sensor que lea consumo real y publique en broker MQTT. Uso Arduino Yun (método simple, no el más barato). Alternativas: Uno + Ethernet shield + router WiFi bridge, o Raspberry Pi con paquete OpenEnergyMonitor.

Hardware

• Transformador corriente $7 (eBay): YHDC SCT-013-000 100A
• Cablear según esquema, subir sketch Yun (modificar IP broker MQTT)
• Referencia librería OpenEnergyMonitor

Valores ideales componentes

• Resistencia carga (burden): 33 Ω
• Divisor tensión: 10k Ω
• Condensador: 10 µF

Mi montaje no coincide exactamente: usé 2×68Ω en paralelo (≈34Ω) por no tener 33Ω, y 2×22µF en serie (≈11µF) por no tener 10µF. Funciona.

Pinza transformador en una fase entrada casa. Solo tenía 1 transformador → monitorizo 1 fase. Futuro: más transformadores para otra fase y circuitos derivados. Comparado con pinza amperimétrica real, mi DIY lee 1A más consistentemente → restar 1A en software.

Integración OpenHAB

Datos en MQTT → también en OpenHAB para gráficas.

Definición Items

Number itm_smarthome_energy_amps "Energy (amps) [%.1f]" {mqtt="<[mymosquitto:2853:state:default]"}
Number itm_smarthome_energy_watts "Energy (Watts) [%.1f]" {mqtt="<[mymosquitto:2852:state:default]"}

Sitemap

Text label="Energy" icon="firstfloor" {
  Frame label="Energy Usage" {
    Text item=itm_smarthome_energy_amps
    Text item=itm_smarthome_energy_watts
    Chart item=itm_smarthome_energy_watts period=h refresh=5000
  }
}

Persistencia (RRD4J)

Strategies {
  everyMinute : "0 * * * * ?"
}
Items {
  itm_smarthome_energy_watts : strategy = everyUpdate
}

Archivo: energy_monitor_yun.ino

Paso 4: Sensor - Nodos DIY Inalámbricos

Opciones para sensores apertura inalámbricos:

• Proyecto previo: transceiver $5 + gateway MQTT. Uso para estado garaje real → OpenHAB → casa modelo. Código/circuito en ese Instructable (algo feo, pero en garaje no se ve).
• Sensor luz (fotorresistencia) del mismo proyecto "Uber sensor": envía brillo a OpenHAB. Aquí me suscribo al tema MQTT nivel luz.
• Sensor reed switch battery-powered (mismo transceiver/gateway). Poco estético para puertas interiores → uso sensores consumidor bonitos de Wink (siguiente paso).

Paso 5: Sensor - Wink Hub

Encontré blog de usuario temprano Wink Hub que rooteó el hub para exploit PHP. Permite ejecutar utilidad "aprontest" para controlar dispositivos emparejados. Así controlo luces desde OpenHAB.

Gran ventaja: control local sin servidor Wink. Wink Hub/API normal requiere internet para todo. Con exploit, operaciones quedan en LAN local.

Script PHP (adjunto) en Raspberry Pi: sondea Wink Hub por 2 sensores "Tripper" (reed switch). Estado → OpenHAB vía REST API → OpenHAB publica MQTT → casa modelo abre/cierra puertas.

3 archivos config OpenHAB adjuntos (items, sitemap, rules) + script control bombilla Zigbee.

Video demo: YouTube

Archivos: sitemap.txt, rules.txt, items.txt, demo_1_general.sh, polling.php

Paso 6: Salida - Luces

Pasos previos ya cubren control bombilla "conectada" desde interfaz física y OpenHAB. Probado con Cree Connected Bulb y GE Wink lights. Video demo sensor luz + botones: YouTube

Paso 7: Salida - Abridor Garaje

Configuración paso 5 cubre items OpenHAB para garaje. Falta hardware real para abrir/cerrar. Uso modificación de Instructable previo:

• Arduino clone ($10)
• Ethernet shield ($7)
• Relé reed ($2)
• Mando garaje de repuesto ($22)

Arduino controla relé reed abriendo/cerrando contactos secos. Botón mando repuesto cableado a contactos secos del relé. Pin 5 y GND Arduino → bobina relé (pines exteriores); pines interiores relé → botón mando.

Arduino se suscribe a tema MQTT y espera comando open/close. Al recibir, energiza relé momentáneamente → cierra "botón" mando. Sketch adjunto. Añadir garage_monitor_rules.txt a rules (además de rules paso 5). Si no usas sensor ultrasónico previo, adapta esa parte.

Video: YouTube

Regla extra reproduce audio al abrir garaje (se oye en primer video ~min 1:30). Demo audio

Archivos: garage_monitor_rules.txt, grage_opener.ino

Paso 8: Otras Ideas

Decisiones reflejan mis herramientas, piezas disponibles y prioridades. Tú tendrás otras. Hay flexibilidad total con MQTT y OpenHAB.

• Controlador casa modelo: Arduino (cualquier sabor), Raspberry Pi, Spark Core...
• Sensores DIY: Arduino o ESP8266 standalone
• Único requisito: datos sensor → broker MQTT
• Stick USB Z-Wave en OpenHAB → puente Z-Wave a MQTT → sensores Z-Wave
• Sensores Wink sin rootear: Wink API → OpenHAB → MQTT (usa servidor Wink, pero evita rootear hub)

Muchas formas de hacer lo mismo. Tiendo a hardware "mínimo común denominador": Arduino y cajas de cartón.

Código

• smarthome_yun.ino
• smarthome_ethernet.ino
• energy_monitor_yun.ino

smarthome_yun.ino (resumen)

Arduino Yun para interfaz física casa modelo. Suscribe MQTT: LED luz (tema 2822), puerta entrada (2832), garaje (2842), energía (2852). Publica botones: luces (2862), garaje (28872). Movimiento servos suave (sin delay). Reconexión MQTT cada 60s. LED pin 7 indica estado conexión.

smarthome_ethernet.ino

Versión para Arduino Uno + Ethernet Shield. Similar pero sin botones y con librería Ethernet estándar.

energy_monitor_yun.ino

Arduino Yun para monitor energía. Librería EmonLib. Publica amperios (tema 2853) y vatios (2852) cada 10s. Reconexión MQTT cada 60s. LED parpadea en callback.

Esquemáticos