Si se corta internet, controlar nuestra casa a distancia parece completamente imposible. Pero, ¿y si armamos un plan B con Meshtastic para seguir hablando con Home Assistant?

Ver video en YouTube

Para este proyecto usé dos nodos totalmente distintos pero que se complementan muy bien: el SenseCAP Solar Node P1-Pro, que queda fijo en casa, y el SenseCAP T1000-E, una tarjeta portátil que puedo llevar encima.

La idea es simple: poder consultar el estado de casa, controlar algunos dispositivos y recibir avisos importantes incluso cuando no hay internet ni señal celular.

Primero que nada, gracias a la gente de OpenELAB por enviarme los nodos para hacer este proyecto. Es una tienda donde pueden encontrar estos equipos y un montón de productos de electrónica, microcontroladores y dispositivos para proyectos de casa inteligente.

• SenseCAP Solar Node P1-Pro
• SenseCAP T1000-E Card Tracker

Meshtastic explicado simple

Meshtastic es un sistema de comunicación basado en LoRa que no necesita internet ni señal celular. Los nodos se comunican entre sí y forman una red tipo malla: si dos equipos no llegan de manera directa, otros nodos pueden ayudar a repetir el mensaje hasta destino.

No sirve solamente para mandar texto. También permite compartir la ubicación del nodo y, gracias a la integración con Home Assistant, usar esos mensajes para disparar acciones o recibir información de nuestra casa.

Ya había probado Meshtastic en el Cosquín Rock, donde lo usé para comunicarme en un lugar con miles de personas y señal celular prácticamente inexistente. Esta vez quería ir un poco más lejos: conectarlo con mi casa.

Seeed Studio SenseCAP T1000-E

Lo que más me sorprendió es el tamaño. Comparado con el Heltec T114 que usé en el Cosquín, y más todavía si contamos la batería que le había agregado, esto se puede llevar a cualquier lado sin llamar la atención.

• Seeed Studio SenseCAP T1000-E Card Tracker (OpenELAB)

Seeed Studio SenseCAP Solar Node P1-Pro

• Seeed Studio SenseCAP P1-Pro (OpenELAB)

La idea del proyecto

La arquitectura quedó de esta manera:

[T1000-E portátil] ←→ [Red Meshtastic] ←→ [P1-Pro en casa] ←→ [Home Assistant]

• El P1-Pro queda fijo en la terraza, alimentado por el panel solar y conectado a Home Assistant.
• El T1000-E viaja conmigo y me permite enviar comandos o recibir avisos.
• Home Assistant sigue controlando localmente luces, enchufes, sensores, aires acondicionados y el resto de la casa.

Esto permite consultar estados, controlar dispositivos o recibir una alerta por movimiento o corte de internet sin depender de servicios en la nube.

Configuración inicial de los nodos

¡IMPORTANTE!

Si un nodo usa una antena externa, conectala antes de encenderlo. Transmitir sin la carga correcta puede hacer que la etapa de radiofrecuencia trabaje mal, calentarse y terminar dañado.

Primero configuré la región de radio correspondiente. En Argentina se usa la banda de 915–928 MHz y, para esta instalación, utilicé la opción de región compatible indicada para el equipo. Siempre revisen la regulación local antes de transmitir.

Después conecté el P1-Pro al WiFi, comprobé que pudiera accederse desde la interfaz web y realicé la configuración inicial del T1000-E desde el teléfono.

Una vez que ambos nodos estaban usando la misma configuración de Meshtastic, hice una prueba de mensajes entre ellos antes de sumar Home Assistant. Conviene separar los problemas: primero verificamos que la radio funcione y después agregamos el resto de las piezas.

Cómo integrar Meshtastic con Home Assistant

Como la conexión local del nodo con Home Assistant se realiza por Bluetooth, necesitamos un Bluetooth Proxy cerca del P1-Pro. En criollo, un intermediario que recibe Bluetooth y lo lleva a Home Assistant a través del WiFi.

Para eso se puede usar cualquier ESP32 compatible con ESPHome. En mi caso reutilicé el ESP32 del lavadero porque el nodo solar quedó instalado justo encima y ya tenía una conexión estable. Si no viste el video del lavadero, lo tenes acá.

[P1-Pro Solar Node] ←→ [Proxy Bluetooth] ←→ [Home Assistant]

Proxy Bluetooth con ESPHome

En este apartado les dejo el código parcial que se necesita para agregar la funcionalida a nuestro dispositivo con un ESP32 y con ESPHome instalado o directamente el código completo para un dispositivo nuevo.

ESPHome - BLE Tracker y Proxy Bluetooh - YAML

esp32_ble_tracker:
  scan_parameters:
    active: true
    interval: 320ms
    window: 300ms

bluetooth_proxy:
  active: true
  connection_slots: 3

ESPHome - Código completo - YAML

esphome:
  name: bt-proxy
  friendly_name: bt-proxy

esp32:
  board: esp32-c6-devkitc-1
  framework:
    type: esp-idf

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "<api_key_encryption>"

ota:
  - platform: esphome
    password: "<ota_pwd>"

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Bt-Proxy Fallback Hotspot"
    password: "<fallback_hotspot_pwd>"

captive_portal:

esp32_ble_tracker:
  scan_parameters:
    active: true
    interval: 320ms
    window: 300ms

bluetooth_proxy:
  active: true
  connection_slots: 3

Meshtastic Custom Integration (HACS)

Necesitamos instalar, desde HACS, la integración custom de Meshtastic.

Cuando reiniciamos Home Assistant, nos va a aparecer el dispositvDurante la configuración activé el Web Client y el TCP Proxy, y limité la creación de destinos de notificación de mensajes directos a los nodos que realmente iba a utilizar.

Con eso Home Assistant comenzó a recibir el evento meshtastic_api_text_message y apareció la acción meshtastic.send_text, que son las dos piezas que usan las automatizaciones.

Automatizaciones en Home Assistant

ANTES DE COPIAR LAS AUTOMATIZACIONES

Los ejemplos siguientes están generalizados para no publicar los identificadores de mi instalación. Antes de usarlos, hay que reemplazar:

• ID_NODO_SOLAR por el identificador del nodo conectado a Home Assistant.
• ID_NODO_TRACKER por el identificador del T1000-E que enviará y recibirá mensajes.
• binary_sensor.internet por el sensor que represente el estado de nuestra conexión.

También es importante que las luces tengan nombres claros y estén asignadas a las áreas correctas de Home Assistant. La automatización de control usa esos nombres y áreas para saber qué dispositivo tiene que manejar.

Notificación de cambio de estado de Internet

Para saber si se cortó internet uso un sensor de tipo ping contra una IP pública. Lo agregan desde Settings → Devices and Services → Add Integration

Si el estado permanece caído durante un minuto, Home Assistant manda un aviso por Meshtastic. Cuando la conexión vuelve y se mantiene estable otro minuto, manda el mensaje de recuperación.

La espera evita que un microcorte de unos segundos nos llene de mensajes.

alias: Meshtastic - aviso status internet
description: Avisa por Meshtastic cuando internet se corta o vuelve.
triggers:
  - trigger: state
    entity_id: binary_sensor.internet
    to: "off"
    for:
      minutes: 1
    id: internet_caido
  - trigger: state
    entity_id: binary_sensor.internet
    to: "on"
    for:
      minutes: 1
    id: internet_ok
conditions: []
actions:
  - action: meshtastic.send_text
    data:
      ack: false
      from: "ID_NODO_SOLAR"
      to: "ID_NODO_TRACKER"
      text: >-
        {% if trigger.id == 'internet_caido' %}
          Internet caido.
        {% else %}
          Internet restaurado.
        {% endif %}
mode: single

Saber el status de las luces encendidas

El segundo caso sirve para saber qué quedó encendido en casa. Desde el T1000-E mando solamente:

status

Home Assistant revisa todas las entidades del dominio light, se queda con las que están encendidas y las agrupa por área. Además filtra los grupos de luces para no contar dos veces el mismo dispositivo.

La respuesta tiene un formato corto, ideal para Meshtastic:

4 luces: Estudio 2, Cocina 1, Patio 1

alias: Meshtastic - status luces por zona
description: Responde cuántas luces reales hay encendidas por zona.
triggers:
  - trigger: event
    event_type: meshtastic_api_text_message
    event_data:
      data:
        from: "ID_NODO_TRACKER"
        to:
          node: "ID_NODO_SOLAR"
          channel: null
        gateway: "ID_NODO_SOLAR"
conditions:
  - condition: template
    value_template: >-
      {{ (trigger.event.data.data.message | string | lower | trim) == 'status' }}
actions:
  - delay:
      seconds: 2
  - action: meshtastic.send_text
    data:
      ack: true
      from: "ID_NODO_SOLAR"
      to: "ID_NODO_TRACKER"
      text: >-
        {% set luces = namespace(total=0, zonas={}) %}
        {% for luz in states.light
          | selectattr('state', 'eq', 'on')
          | rejectattr('attributes.entity_id', 'defined')
          | list %}
          {% set zona = area_name(luz.entity_id) or 'Sin zona' %}
          {% set luces.total = luces.total + 1 %}
          {% set luces.zonas = dict(
            luces.zonas,
            **{zona: (luces.zonas.get(zona, 0) + 1)}
          ) %}
        {% endfor %}
        {{ luces.total }} luces:
        {% for zona, cantidad in luces.zonas.items() %}
          {{ zona }} {{ cantidad }}{% if not loop.last %}, {% endif %}
        {% endfor %}
mode: single

Controlar luces por zona o individuales desde Meshtastic

Esta es la más copada. Podemos controlar una luz puntual, todas las luces de una zona o directamente toda la casa.

Algunos ejemplos:

luz principal estudio on
luces cocina off
luces off

La diferencia entre luz y luces es importante:

• luz <nombre> on|off busca una entidad por su nombre completo.
• luces <zona> on|off actúa sobre todas las luces del área.
• luces on|off actúa sobre todas las luces reales de Home Assistant.

Antes de ejecutar la acción, la automatización comprueba el estado actual. Si una luz ya estaba apagada y pedimos apagarla, responde que ya estaba así. También avisa si no encuentra el nombre o la zona.

alias: Meshtastic - controlar luces
description: Controla luces por zona, todas, o una luz puntual desde Meshtastic.
triggers:
  - trigger: event
    event_type: meshtastic_api_text_message
    event_data:
      data:
        from: "ID_NODO_TRACKER"
        to:
          node: "ID_NODO_SOLAR"
          channel: null
        gateway: "ID_NODO_SOLAR"
variables:
  msg: "{{ trigger.event.data.data.message | string }}"
  msg_norm: "{{ msg | lower | trim | replace('_', ' ') }}"
  msg_parts: "{{ msg_norm.split() }}"
  comando: "{{ msg_parts[0] if msg_parts | count > 0 else '' }}"
  accion: "{{ msg_parts[-1] if msg_parts | count >= 2 else '' }}"
conditions:
  - condition: template
    value_template: >-
      {{ msg_parts | count >= 2
         and comando in ['luz', 'luces']
         and accion in ['on', 'off'] }}
actions:
  - variables:
      objetivo: >-
        {{ msg_parts[1:-1] | join(' ') if msg_parts | count > 2 else '' }}
      luces_objetivo: >-
        {% set ns = namespace(ids=[]) %}
        {% for luz in states.light
          | rejectattr('attributes.entity_id', 'defined')
          | list %}
          {% set nombre = (luz.attributes.friendly_name or luz.name or '')
            | lower | trim %}
          {% set zona = (area_name(luz.entity_id) or '') | lower | trim %}
          {% if comando == 'luces' %}
            {% if objetivo == '' or zona == objetivo %}
              {% set ns.ids = ns.ids + [luz.entity_id] %}
            {% endif %}
          {% elif comando == 'luz' and nombre == objetivo %}
            {% set ns.ids = ns.ids + [luz.entity_id] %}
          {% endif %}
        {% endfor %}
        {{ ns.ids }}
      luces_a_cambiar: >-
        {% set ns = namespace(ids=[]) %}
        {% for entity_id in luces_objetivo %}
          {% if states(entity_id) != accion %}
            {% set ns.ids = ns.ids + [entity_id] %}
          {% endif %}
        {% endfor %}
        {{ ns.ids }}
  - choose:
      - conditions:
          - condition: template
            value_template: "{{ luces_a_cambiar | count > 0 and accion == 'on' }}"
        sequence:
          - action: light.turn_on
            target:
              entity_id: "{{ luces_a_cambiar }}"
      - conditions:
          - condition: template
            value_template: "{{ luces_a_cambiar | count > 0 and accion == 'off' }}"
        sequence:
          - action: light.turn_off
            target:
              entity_id: "{{ luces_a_cambiar }}"
  - delay:
      seconds: 2
  - action: meshtastic.send_text
    data:
      ack: false
      from: "ID_NODO_SOLAR"
      to: "ID_NODO_TRACKER"
      text: >-
        {% if luces_objetivo | count == 0 %}
          No encontre {{ 'la luz' if comando == 'luz' else 'luces' }}{% if objetivo != '' %} {{ objetivo }}{% endif %}.
        {% elif luces_a_cambiar | count == 0 %}
          Ya estaba {{ 'encendida' if accion == 'on' else 'apagada' }}{% if comando == 'luz' %}: {{ objetivo }}{% elif objetivo != '' %}: {{ objetivo }}{% else %}: todo{% endif %}.
        {% else %}
          OK, {{ luces_a_cambiar | count }} {{ 'luz' if luces_a_cambiar | count == 1 else 'luces' }} {{ 'encendida' if accion == 'on' else 'apagadas' }}{% if objetivo != '' %}: {{ objetivo }}{% else %}: todo{% endif %}.
        {% endif %}
mode: single

Mención para Meshtastic Argentina

Por último, los invito a que se sumen a la comunidad de Meshtastic Argentina. Tienen un grupo de Telegram (link). Ahí van a encontrar gente desparramada a lo largo de todo el territorio argentino. Desde coordinar despliegues de nodos por en distintas partes, hasta asistencia en cualquier duda o inconveniente que tengan.

Si llegaste hasta acá, no te olvides de suscribirte al canal.

Cansado de sacar la impresora del armario cada vez que necesitaba imprimir, me acordé de un mini router que tenía guardado y terminé en un proyecto que me llevó bastante más de lo esperado. Pero valió la pena.

Todo el detalle está en el video de YouTube, este post es un write-up para el que lo quiera hacer.

Ver video en YouTube

El mini router TP-Link TL-WR703N

Buscando entre mis cosas, encontré un TP-Link TL-WR703N. Este mini router estaba pensado para compartir internet cuando se usaban los módems 3G USB.

El modelo venía con el firmware solo en idioma chino, así que en esa época le instalé OpenWRT.

Versión de OpenWRT que tenía instalada el router desde la última vez que lo usé.

El problema: la última versión oficial de OpenWRT para este router es la 19, porque dejaron de soportar dispositivos con 4MB de almacenamiento. Todo lo que vino después requiere más espacio.

Cambio de memoria SPI Flash: de 4MB a 16MB

Para poder instalar versiones más recientes de OpenWRT, tuve que cambiar la memoria SPI flash (básicamente el "disco" del router) por una de 16MB.

Para hacer esto, tuve que comprar algunas cosas que no tenía:

Materiales necesarios

• Memoria SPI flash W25Q128FVSIG (16MB): el modelo exacto o similares → Mercado Libre
• Programador CH341A: el más barato y que funciona para estas memorias, sirve para leer y escribir el chip → Mercado Libre
• Pinzas ESD antiestáticas: para sujetar el chip al desoldar sin armar desastre → Mercado Libre

Adaptar el dump original a la nueva memoria

Primero tenemos que hacer el dump de la memoria original, utilicé la aplicación oficial del programador CH341A pero recomiendo utilizar NeoProgrammer (repo acá) ya que me dió mejores resultados a la hora de la escritura (gracias @FreeForge11 en X por la recomendación).

Una vez guardado el dump, extendemos la partición del firmware para que complete los 16MB de la memoria. Además, cambiamos el uboot por el de pepe2k (repo acá), que no es el bootloader original pero es necesario para que tome la nueva memoria.

Para hacer estas modificaciones al binario usé HxD (sitio oficial), un editor hexadecimal que permite editar los archivos byte a byte.

Compilar OpenWRT 23 para el TL-WR703N

Agradecimiento a este post que utilicé para hacer la compilación de OpenWRT: Build OpenWRT 22/23 for TL-WR703N with 16M Flash y también al amigo Cocus que estuvo detrás de todo este caos dando una mano.

Compartos los pasos que utilicé en particular del post anterior:

Primero y principal, leer e instalar lo necesario para OpenWRT.

Una vez que está todo instalado, arrancamos con el procedimiento;

1. Clonar el repositorio de OpenWrt

git clone https://github.com/openwrt/openwrt.git
cd openwrt

2. Hacer checkout de la versión a compilar

git tag -l
git checkout v23.05.6

Antes de instalar los feeds, modifiqué el archivo feeds.conf.default con los siguientes registros (los que vienen por defecto funcionan recontra lento):

src-git packages https://github.com/openwrt/packages.git^e59d9ef823bcb581e3939789b4eaeaf900b79759
src-git luci https://github.com/openwrt/luci.git^7ce34fe1a53db10bb9dd0223467f5bb71a29a659
src-git routing https://github.com/openwrt/routing.git^4a06b031dc16628c9b8351ac297ecdbc92695dc2
src-git telephony https://github.com/openwrt/telephony.git^98c8a5aa4624312ed758e2e2b6d4039050a1649d

Ahora sí instalamos los feeds:

./scripts/feeds update -a
./scripts/feeds install -a

Verificar que no haya errores de dependencias.

3. Modificar la definición Device/tplink_tl-wr703n

Editar el archivo target/linux/ath79/image/tiny-tp-link.mk. Buscar la línea define Device/tplink_tl-wr703n y cambiar $(Device/tplink-4mlzma) por $(Device/tplink-16mlzma) (para memoria de 16MB). El resultado debe quedar así:

define Device/tplink_tl-wr703n
  $(Device/tplink-16mlzma)
  SOC := ar9331            
  DEVICE_MODEL := TL-WR703N                            
  DEVICE_PACKAGES := kmod-usb-chipidea2
  TPLINK_HWID := 0x07030101
  SUPPORTED_DEVICES += tl-wr703n     
endef
TARGET_DEVICES += tplink_tl-wr703n

4. Modificar el archivo dts para 16MB de flash

Editar target/linux/ath79/dts/ar9331_tplink_tl-wr703n_tl-mr10u.dtsi:

• En partition@20000 { cambiar reg = <0x20000 0x3d0000>; por reg = <0x20000 0xfd0000>;
• Cambiar art: partition@3f0000 { por art: partition@ff0000 {
• Debajo de eso, cambiar reg = <0x3f0000 0x10000>; por reg = <0xff0000 0x10000>;

El resultado debe quedar así:

&spi {                  
        status = "okay";
                                             
        flash@0 {                            
                compatible = "jedec,spi-nor";  
                reg = <0>;                     
                spi-max-frequency = <25000000>;
                                                        
                partitions {                            
                        compatible = "fixed-partitions";
                        #address-cells = <1>;
                        #size-cells = <1>;  
                                                    
                        uboot: partition@0 {        
                                reg = <0x0 0x20000>;
                                label = "u-boot";
                                read-only;
                        };                                     
                                                               
                        partition@20000 {                      
                                compatible = "tplink,firmware";
                                reg = <0x20000 0xfd0000>;
                                label = "firmware";
                        };                               
                                                         
                        art: partition@ff0000 {          
                                reg = <0xff0000 0x10000>;
                                label = "art";
                                read-only;
                        };
                };
        };
};

5. Configurar el build

Descargar el config.buildinfo para OpenWrt v23.05.6:

wget https://downloads.openwrt.org/releases/23.05.6/targets/ath79/tiny/config.buildinfo -O config.buildinfo

Agregar las siguientes líneas al config.buildinfo:

CONFIG_TARGET_DEVICE_ath79_tiny_DEVICE_tl-wr703n-v1=y
CONFIG_TARGET_DEVICE_PACKAGES_ath79_tiny_DEVICE_tl-wr703n-v1=""

Y estos paquetes que son clave para mi caso del print server:

CONFIG_PACKAGE_kmod-usb-core=y
CONFIG_PACKAGE_kmod-usb-printer=y    # crea /dev/usb/lp0
CONFIG_PACKAGE_p910nd=y              # el print server
CONFIG_PACKAGE_luci-app-p910nd=y     # interfaz web para p910nd
CONFIG_PACKAGE_libusb-1.0=y

Sobreescribir .config con config.buildinfo. Deberías ver TL-WR703N en la lista de Target Devices:

cat config.buildinfo > .config
make defconfig
make menuconfig

Antes de hacer el build, les recomiendo destildar la opción Build the LLVM-BPF toolchain tarball ya que a mi me trajo errores a la hora de buildear.

Comencemos el build, esto va a tomar bastante tiempo como dice el post original pueden ser bastantes minutos o incluso horas.

nohup time make -j8 V=s &

Se puede ver en tiempo real como va el proceso con este comando:

tail -f nohup.out

Una vez terminado el build, tenemos que subir el firmware al router.

Flashear el firmware via web (método pepe2k)

Una de las ventajas del uboot de pepe2k es que incluye un servidor web integrado que permite subir el firmware directamente desde el navegador, sin necesidad de consola serie ni servidor TFTP.

1. Conectar el router al PC con un cable de red por el puerto LAN
2. Configurar la IP del PC manualmente: 192.168.1.2 con máscara 255.255.255.0
3. Encender el router manteniendo presionado el botón de reset hasta que el LED parpadee (unos 3 segundos)
4. Abrir el navegador y entrar a http://192.168.1.1
5. Va a aparecer una página simple con un formulario de carga de archivo
6. Seleccionar el archivo .bin del firmware compilado (el sysupgrade o factory)
7. Hacer click en el botón para iniciar la escritura y esperar que el router reinicie solo Así se ve la web del uboot de pepe2k para subir el firmware compilado. Una vez que reinicia ya tiene el nuevo OpenWRT corriendo.

La arquitectura: CUPS + p910nd

Como el router tiene poca RAM (32MB), desistí con la idea de correr CUPS ahí dentro. La arquitectura final quedó así:

[Cliente]  →IPP→  [CUPS / Home Server]  →TCP 9100→  [p910nd / Router]  →USB→  [HP P1005]

¿Por qué no CUPS directo en el router?

La HP P1005 requiere el driver foo2zjs, que a su vez depende de ghostscript para convertir PDF/PS. El binario de ghostscript ocupa ~15MB. El TL-WR703N tiene 4MB de flash total. Es imposible.

¿Qué hace p910nd?

p910nd es un proxy extremadamente liviano (~15KB, sin dependencias) que hace exactamente una cosa: abre el puerto TCP 9100 y reenvía cada byte que recibe hacia el dispositivo USB configurado (/dev/usb/lp0), y viceversa. No interpreta nada. Es un puente bidireccional puro.

La HP LaserJet P1005 y el firmware correcto

Un cañito esta impresora, vieja pero se la banca.

Esta impresora es host-based (también llamada GDI o "winprinter"): no tiene procesador ni firmware propio almacenado en ROM. Al conectarla por USB, el sistema operativo del host debe enviarle un archivo de firmware antes de que pueda recibir trabajos de impresión.

El firmware se pierde cada vez que la impresora se desconecta o apaga. Hay que cargarlo de nuevo en cada conexión.

El USB ID de la impresora nunca cambia (03f0:3d17). Lo que cambia es el Device ID IEEE 1284:

Sin firmware:  CMD:ACL
Con firmware:  CMD:HBS,PJL,ACL;FWVER:20080415

La clave estaba en usar el firmware correcto. Hay dos versiones del archivo sihpP1005.dl dando vueltas:

El firmware que funciona es el del paquete foo2zjs (open source), no el plugin propietario de HPLIP.

Cómo obtenerlo:

Opción 1: desde un sistema Debian/Ubuntu con el paquete instalado

sudo apt install printer-driver-foo2zjs
# El archivo queda en: /usr/lib/firmware/hp/sihpP1005.dl

Opción 2: descargar con el script del proyecto foo2zjs

git clone https://github.com/koenkooi/foo2zjs
cd foo2zjs
./getweb P1005
# → crea sihpP1005.dl en el directorio actual

Verificar siempre el MD5 antes de usar:

md5sum sihpP1005.dl
# debe mostrar: ed18611a9c0c6c23b97d8c543fb2ec79

Configurar OpenWRT y p910nd

Copiar el firmware de la impresora al router

# Desde la máquina que tiene el archivo:
scp -O sihpP1005.dl root@IP-DEL-ROUTER:/lib/firmware/sihpP1005.dl

# Verificar en el router:
md5sum /lib/firmware/sihpP1005.dl
# → ed18611a9c0c6c23b97d8c543fb2ec79

Configurar p910nd

Archivo /etc/config/p910nd en el router:

config p910nd
    option device         '/dev/usb/lp0'
    option port           '0'
    option bidirectional  '1'
    option enabled        '1'
    option runas_root     '1'
    option usbvidpid      '03f0/3d17'
    option driver_file    '/lib/firmware/sihpP1005.dl'

Luego ejecutar:

/etc/init.d/p910nd restart
/etc/init.d/p910nd enable

Opciones críticas

Al conectar la impresora al router, los logs deben mostrar:

daemon.info p910nd hotplug: Sending driver to p910nd printer 03f0/3d17
daemon.info p910nd hotplug: Sent /lib/firmware/sihpP1005.dl to /dev/usb/lp0 [ 03f0/3d17 ]
daemon.info p910nd hotplug: (Re)starting p910nd

# Verificar con:
logread | grep p910nd

CUPS en un contenedor

La instalación de CUPS es sencilla; lo tengo corriendo en un contenedor. Uso una imagen customizada donde ya dejé preinstalados los drivers foomatic, que son clave para esta impresora:

Repo: https://github.com/Pocho-Labs/cups-avahi-airprint

Ahí también van a encontrar recursos sobre cómo agregar drivers o correrlo como contenedor.

Configuración de reintentos en CUPS

Como la impresora y el router están apagados la mayor parte del tiempo, necesitamos que CUPS reintente el trabajo mientras todo se está encendiendo. Esto va en /etc/cups/cupsd.conf:

ErrorPolicy retry-job
JobRetryInterval 30
JobRetryLimit 20

Con esta configuración, CUPS tiene hasta 10 minutos (20 reintentos × 30 segundos) para que el router levante y cargue el firmware de la impresora antes de descartar el trabajo.

Agregar la impresora en CUPS

Por interfaz web (recomendado para la primera vez):

1. Abrir la interfaz web de CUPS (por defecto en el puerto 631)
2. Administración → Añadir impresora
3. Seleccionar AppSocket/HP JetDirect
4. En conexión poner: socket://IP-DEL-ROUTER:9100
5. Poner nombre y descripción
6. Tildar Compartición
7. En el último paso seleccionar el driver HP LaserJet P1005 Foomatic/foo2zjs y añadir

Automatización con Home Assistant

Con todo andando, quería aprovechar y automatizar el encendido. Para eso usé:

• Enchufe inteligente: link - ZigBee va conectado a un doble toma donde van la impresora y el router.
• Fingerbot: link - ZigBee dispositivo que hace de "dedo" para presionar el botón físico de encendido de la impresora y se integra fácil a Home Assistant.

La lógica es la siguiente: al tener la impresora en la red, Home Assistant la integra mediante CUPS y conoce el estado. Cuando llega un trabajo de impresión, la impresora cambia de En reposo a Imprimiendo.

Ahí dispara el script que enciende el enchufe y activa el fingerbot. Una vez que el router levanta y carga el firmware, CUPS reintenta solo imprimir (gracias a la config de reintentos). Luego, cuando la impresora vuelve a En reposo durante 20 minutos, se apaga el enchufe. También dejé un botón en el dashboard para cuando me gana la ansiedad.

Script: Encender impresora HP LaserJet P1005

sequence:
  - action: switch.turn_on
    metadata: {}
    target:
      entity_id: switch.smart_plug
    data: {}
  - delay:
      hours: 0
      minutes: 0
      seconds: 50                 # Un tiempo prudente para que inicie primero el router
      milliseconds: 0
  - action: switch.toggle
    metadata: {}
    target:
      entity_id: switch.fingerbot
    data: {}
    enabled: true
alias: Encender impresora HP LaserJet P1005
description: ""

Automatización: Encender impresora en recibir trabajo

alias: Encender impresora en recibir trabajo
description: ""
triggers:
  - trigger: state
    entity_id:
      - sensor.hp_laserjet_p1005
    from:
      - idle
    to:
      - printing
conditions:
  - condition: device
    type: is_off
    device_id: device_id_smart_plug
    entity_id: entity_id_smart_plug
    domain: switch
actions:
  - action: script.turn_on
    metadata: {}
    target:
      entity_id: script.encender_impresora
    data: {}
mode: single

Automatización: Apagar la impresora inactiva por 20 minutos

alias: Apagar la impresora inactiva por 20 minutos
description: ""
triggers:
  - trigger: state
    entity_id:
      - sensor.hp_laserjet_p1005_foomatic_foo2xqx_recommended
    from:
      - printing
    to:
      - idle
    for:
      hours: 0
      minutes: 20
      seconds: 0
conditions:
  - condition: device
    type: is_on
    device_id: device_id_smart_plug
    entity_id: entity_id_smart_plug
    domain: switch
actions:
  - action: switch.turn_off
    metadata: {}
    target:
      entity_id: switch.smart_plug
    data: {}
mode: single

Espero que les haya sido de utilidad, los leo en los comentarios del video. Sumensé con un like y una suscripción al canal.

Saludos!

Tenés un lavarropas común y corriente y te pasa como a mi que lavas y te olvidas sacar la ropa? Seguime que te muestro como!

Ver video en YouTube

Entendiendo el comportamiento del lavarropas

Para comprender como es el funcionamiento, me puse a ver el consumo del lavarropa en sus distintos estados (standby, lavado programado, lavando y apagado). Para poder generar dichos estados en Home Assistant, tuve que utilizar un template sensor que, dependiendo el consumo que realiza el lavarropas, identifica los estados. Además, tuve que utilizar un input datetime para guardar la hora de encendido del lavarropas, que sirve para poder diferenciar Standby de Lavado programado. Este input datetime se actualiza mediante esta automatización.

• Standby: este estado es cuando encendemos el lavarropas y consume menos de 8w durante un periodo menor a 10 minutos, ya que el modelo de mi lavarropas cuando pasan 10 minutos se apaga automáticamente.
• Lavado programado: cuando el consumo está por debajo de los 8w y ya pasaron 10 minutos de encendido, se considera que está en este estadío esperando a arrancar a lavar.
• Lavando: acá tuve que hacer algo particular, si bien cuando lava consume más de estos 8w, por momentos el consumo baja este umbral y hacía que cambie de estado a programado mientras lavaba. Para solucionar esto, la condición verifica si el estado anterior es Lavando, si esto es así, continúa con dicho estado. La lógica siempre es que de Lavando pasa a apagado, es raro que cancele un lavado.
• Apagado: tan simple como que el consumo es 0w.

De paso, guardé algunos atributos para poder hacer troubleshooting más fácilmente y los íconos del template sensor van cambiando dependiendo del estado.

Código - template sensor

template:
  - sensor:
      - name: "Estado Lavarropas"
        unique_id: lavarropas_status
        state: >
          {# Variables #}
          {% set power = states('sensor.lavarropas_power') | float(0) %}
          {% set current_state = states('sensor.lavarropas_status') | default('Apagado') %}
          {% set standby_start =
              states('input_datetime.lavarropas_hora_de_encendido')
              | as_datetime
              | default(now())
              | as_local %}
          {% set minutes_in_standby = (now() - standby_start).total_seconds() / 60 %}

          {# Umbrales #}
          {% set standby_w = 8 %}        {# Consumo máximo para standby/programado #}
          {% set program_delay = 10 %}   {# Minutos para pasar a Lavado programado #}

          {# Logica del estado #}
          {% if power == 0 %}
            Apagado
          {% elif power > standby_w %}
            Lavando
          {% elif 0 < power <= standby_w %}
            {% if current_state == 'Lavando' %}
              Lavando
            {% elif minutes_in_standby < program_delay %}
              Standby
            {% else %}
              Lavado programado
            {% endif %}
          {% endif %}
        attributes:
          current_power: "{{ states('sensor.lavarropas_power') | float(0) }}"
          standby_start_time: "{{ states('input_datetime.lavarropas_hora_de_encendido') }}"
          minutes_in_standby: >
            {% if this.state == 'Apagado' %}
              0
            {% else %}
              {% set ss = states('input_datetime.lavarropas_hora_de_encendido')
                  | as_datetime
                  | default(now())
                  | as_local %}
              {{ (now() - ss).total_seconds() / 60 }}
            {% endif %}
        icon: >
          {% set s = this.state %}
          {% if s == 'Apagado' %}
            mdi:power-plug-off
          {% elif s == 'Standby' %}
            mdi:power-standby
          {% elif s == 'Lavado programado' %}
            mdi:washing-machine-alert
          {% elif s == 'Lavando' %}
            mdi:washing-machine
          {% else %}
            mdi:help-circle
          {% endif %}

Automatización - Guardar hora de encendido

alias: Lavarropas - Guardar hora de encendido
description: ""
triggers:
  - entity_id: sensor.lavarropas_status
    from: Apagado
    to:
      - Standby
      - Lavando
      - Lavado programado
    trigger: state
actions:
  - data:
      datetime: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"
    action: input_datetime.set_datetime
    target:
      entity_id: input_datetime.lavarropas_hora_de_encendido
mode: single

Automatizaciones

Acá tengo una lista variada de automatizaciones, algunas relacionadas al lavarropas y el aviso de cuando termina de lavar, y otras para lo que es la automatización de la luz del lavadero.

Aviso de colgar ropa

Para lo que es la notificación recurrente, utilicé un input_boolean que se llama colgar_ropa. Cuando el lavarropas pasa de Lavando a Apagado, cambia el valor a encendido.

Esto lo hago para mantener el estado de colgar_ropa hasta que realmente pase esa acción y desactivar las notificaciones recurrentes con el botón.

Setear colgar ropa despues del lavado

Esta automatización además de cambiar el estado a encendido, hace que el led del pulsador se encienda en color azul:

alias: Setear colgar ropa despues del lavado
description: ""
triggers:
  - trigger: state
    entity_id:
      - sensor.lavarropas_status
    from: Lavando
    to: Apagado
conditions: []
actions:
  - action: input_boolean.turn_on
    metadata: {}
    data: {}
    target:
      entity_id: input_boolean.colgar_ropa
  - action: light.turn_on
    metadata: {}
    data:
      rgb_color:
        - 0
        - 0
        - 255
      brightness_pct: 30
    target:
      entity_id: light.lavadero_led_lavarropas
mode: single

Sonar cuando hay ropa para colgar y entro al lavadero

Esta es la automatización que hace que cada vez que entro al lavadero, suene la melodía de Volver al Futuro y titile el LED.

alias: Sonar cuando hay ropa para colgar y entro al lavadero
description: ""
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.lavadero_ld2410_presence
    from: "off"
    to: "on"
conditions:
  - condition: state
    entity_id: input_boolean.colgar_ropa
    state: "on"
actions:
  - action: esphome.lavadero_play_song
    metadata: {}
    data: {}
mode: single

Notificacion terminó el lavarropas

Esta automatización es un poco más "compleja" por así decirlo, ya que depende si estoy en casa o no, que notificaciones envía.

Si estoy en casa, cada 10 minutos envía un mensaje a la app de Home Assistant en iOS y además Alexa me notifica lo mismo. Para enviar este tipo de notificaciones utilizo el custom component de Alexa Media Player.

Si no estoy en casa, me manda una notificación a la app de Home Assistant de iOS cada media hora.

alias: Notificacion termino el lavarropas
description: ""
triggers:
  - trigger: state
    entity_id:
      - input_boolean.colgar_ropa
    to: "on"
conditions: []
actions:
  - repeat:
      until:
        - condition: state
          entity_id: input_boolean.colgar_ropa
          state: "off"
      sequence:
        - if:
            - condition: state
              entity_id: person.ezequiel
              state: home
          then:
            - action: notify.mobile_app_itasskkk
              metadata: {}
              data:
                title: Lavarropas
                message: >-
                  Terminó el lavado, andá a colgarla antes que quede arrugada y
                  con olor!
            - action: notify.alexa_media_echo
              metadata: {}
              data:
                message: Pochito, terminó el lavarropas!
            - delay:
                hours: 0
                minutes: 10
                seconds: 0
                milliseconds: 0
          else:
            - repeat:
                until:
                  - condition: zone
                    entity_id: person.ezequiel
                    zone: zone.home
                sequence:
                  - action: notify.mobile_app_itasskkk
                    metadata: {}
                    data:
                      title: Lavarropas
                      message: >-
                        Terminó el lavado, andá a colgarla antes que quede
                        arrugada y con olor!
                  - delay:
                      hours: 0
                      minutes: 30
                      seconds: 0
                      milliseconds: 0
mode: single

Apagar el switch despues de lavar

alias: Apagar switch despues de lavar
description: ""
triggers:
  - trigger: state
    entity_id:
      - sensor.lavarropas_status
    to: Apagado
    for:
      hours: 0
      minutes: 10
      seconds: 0
conditions: []
actions:
  - action: switch.turn_off
    metadata: {}
    data: {}
    target:
      entity_id: switch.lavarropas
mode: single

Enciende la luz del lavadero cuando detecta presencia

Cuando es de noche y detecta que entro al lavadero, enciende la luz.

alias: Encende la luz del lavadero cuando detecte presencia
description: ""
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.lavadero_ld2410_presence
    from: "off"
    to: "on"
conditions:
  - condition: sun
    before: sunrise
    after: sunset
    enabled: false
actions:
  - action: light.turn_on
    metadata: {}
    data: {}
    target:
      entity_id: light.lavadero_lavadero
mode: single

Apaga la luz del lavadero cuando no hay nadie

No hay mucha más complejidad en esta automatización, espera 2 minutos luego de cambiar el estado de Detected a Clear para apagar la luz.

alias: Apaga la luz del lavadero cuando no hay nadie
description: ""
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.lavadero_ld2410_presence
    from: "on"
    to: "off"
    for:
      hours: 0
      minutes: 2
      seconds: 0
conditions: []
actions:
  - action: light.turn_off
    metadata: {}
    data: {}
    target:
      entity_id: light.lavadero_lavadero
mode: single

Dispositivo con ESPHome

Para este proyecto, utilicé un ESP32-C6-Zero. Es un microcontrolador bastante potente, soporta WiFi 6, Bluetooth 5 y soporta el estándar IEEE 802.15.4 - Zigbee 3.0/Thread. Les comparto el link del fabricante para más info.

Si lo comparamos con el ESP32 más comun que conocemos es muchísimo más chico, casi del tamaño de una moneda:

Componentes

En el microcontrolador utilicé:

• Modulo doble de relays (para la luz del lavadero y del pasillo)
• Botón pulsador rojo (puede ser cualquier boton)
• LED RGB
• Buzzer (usé uno típico de PC)
• Resistencias 220 Ohms para el LED RGB (1 en cada paga de los colores)
• Transistor 2N2222 (para potenciar el sonido del buzzer)
• Resistencia de 1k Ohms (conectada a la pata base del transistor)
• 2 switches típicos de electricidad para controlar los relays de las luces

El PCB que usé es una típica placa de desarrollo que se puede cortar a gusto.

Esquema de conexión

Como hacemos para que el buzzer reproducza melodías?

Para que el buzzer reproduzca melodías, debemos utilizar el formato RTTTL. Ring Tone Text Transfer Language es un formato desarrollado por Nokia y que podemos utilizar en nuestros microcontroladores. En internet hay varios sitios de donde podemos descargar estas cadenas de texto, les dejo los que anduve investigando:

• Arcade Ringtones
• RTTTL Player
• RTTTL Ringtone downloads
• Todomovil.net

Si quieren innovar y probar sus propios RTTTL, está este sitio.

También les dejo la configuración del ESP32 con ESPHome para que puedan crear su propio dispositivo:

ESPHome - yaml

esphome:
  name: lavadero
  friendly_name: lavadero

esp32:
  board: esp32-c6-devkitc-1
  framework:
    type: esp-idf

logger:

api:
  encryption:
    key: !secret lavadero_encryption
  services:
    - service: play_song
      then:
        - script.execute: play_song

ota:
  - platform: esphome
    password: !secret lavadero_ota_pwd

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  fast_connect: true

  ap:
    ssid: "Lavadero-dev Fallback Hotspot"
    password: "<fallback_hotspot_password>"

captive_portal:

output:
  # Buzzer
  - platform: ledc
    pin: GPIO14
    id: buzzer_output
    frequency: 1000Hz
  
  # LED RGB
  - platform: ledc
    pin: GPIO22
    id: led_r
    inverted: true
  - platform: ledc
    pin: GPIO4
    id: led_g
    inverted: true
  - platform: ledc
    pin: GPIO5
    id: led_b
    inverted: true

  # Relays
  - platform: gpio
    pin: GPIO18
    id: relay_pasillo
    inverted: true

  - platform: gpio
    pin: GPIO19
    id: relay_lavadero
    inverted: true

rtttl:
  output: buzzer_output
  id: my_buzzer
  gain: 40%

# Script para reproducir la melodía y alternar colores
script:
  - id: play_song
    then:
      - rtttl.play: "BackToTheFuture:d=16,o=5,b=200:4g.,p,4c.,p,2f#.,p,g.,p,a.,p,8g,p,8e,p,8c,p,4f#,p,g.,p,a.,p,8g.,p,8d.,p,8g.,p,8d6.,p,4d6.,p,4c#6,p,b.,p,c#6.,p,2d6."
      - repeat:
          count: 7
          then:
            - light.turn_on:
                id: led_lavarropas
                red: 50%
                green: 0%
                blue: 0%
                transition_length: 0s
            - delay: 500ms
            - light.turn_on:
                id: led_lavarropas
                red: 0%
                green: 0%
                blue: 50%
                transition_length: 0s
            - delay: 500ms

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO0
      inverted: true
      mode:
        input: true
        pullup: true
    name: "Pulsador"
    internal: true
    on_click:
      - homeassistant.service:
          service: input_boolean.turn_off
          data:
            entity_id: input_boolean.colgar_ropa
      - light.turn_off:
          id: led_lavarropas


  # Interruptores
  - platform: gpio
    pin:
      number: GPIO20
      mode: INPUT_PULLUP
      # inverted: true
    name: "Switch Lavadero"
    internal: true
    on_press:
      - light.toggle: lavadero
    on_release:
      - light.toggle: lavadero

  - platform: gpio
    pin:
      number: GPIO21
      mode: INPUT_PULLUP
      # inverted: true
    name: "Switch Pasillo"
    internal: true
    on_press:
      - light.toggle: pasillo
    on_release:
      - light.toggle: pasillo
  
  # Sensor de presencia LD2410
  - platform: ld2410
    has_target:
      name: "LD2410 Presence"
      id: presence_sensor
    has_moving_target:
      name: "LD2410 Moving Target"
    has_still_target:
      name: "LD2410 Still Target"

uart:
  id: uart_ld2410
  tx_pin: GPIO1
  rx_pin: GPIO3
  baud_rate: 256000

ld2410:
  uart_id: uart_ld2410

sensor:
  - platform: ld2410
    moving_distance:
      name: "LD2410 Moving Distance"
    still_distance:
      name: "LD2410 Still Distance"
    moving_energy:
      name: "LD2410 Moving Energy"
    still_energy:
      name: "LD2410 Still Energy"
    detection_distance:
      name: "LD2410 Detection Distance"

light:
  - platform: rgb
    id: led_lavarropas
    name: "Led Lavarropas"
    red: led_r
    green: led_g
    blue: led_b

  - platform: binary
    name: "Lavadero"
    id: lavadero
    output: relay_lavadero

  - platform: binary
    name: "Pasillo"
    id: pasillo
    output: relay_pasillo

NOTA IMPORTANTE!

Para que el microcontrolador pueda ejecutar acciones dentro de Home Assistant, tenemos que ir al dispositivo dentro de HA y habilitarle que pueda realizar acciones, sinó la parte de presionar el botón y que cambie el estado de colgar_ropa no va a funcionar.

Caja

En breve voy a estar subiendo el diseño de la caja para que puedan descargarlo e imprimirlo.

Espero que les haya gustado este proyecto y les sea de utilidad. Si tienen alguna duda o sugerencia, los leo en los comentarios del video!

Hoy quiero mostrarte como podes controlar tu aire acondicionado tradicional desde Home Assistant de una manera muy sencilla y económica. Para esto vamos a utilizar el control remoto universal de Broadlink, el RM4 Mini y la integración custom SmartIR.

Esta integración nos va a permitir controlar el aire desde Home Assistant y hacer distintas automatizaciones.

Ver video en YouTube

SmartIR

SmartIR es una integración custom que trae una gran cantidad de códigos IR predefinidos para distintos dispositivos, como aires acondicionados, televisores, luces, etc. Se instala desde HACS y es muy simple de configurar.

La documentación con el listado de aires acondicionados soportados y sus códigos se encuentra acá.

Para realizar la instalación, primero tenemos que agregar el repositorio de SmartIR (https://github.com/smartHomeHub/SmartIR/) en HACS y luego descargarlo. Una vez hecho esto, antes de reiniciar, vamos al configuration.yaml y agregamos nuestro dispositivo.

Les dejo el ejemplo de configuración de mi aire, en este caso, Samsung:

Configuración

smartir:
climate:
  - platform: smartir
    name: AC Estudio
    unique_id: estudio_ac
    device_code: 1405 # Código de nuestro aire acondicionado (en mi caso Samsung - lo podés encontrar en la documentación de SmartIR)
    controller_data: remote.rm4_mini_estudio # Nombre de nuestro control remoto
    temperature_sensor: sensor.rm4_mini_estudio_temperature # Opcional
    humidity_sensor: sensor.rm4_mini_estudio_humidity # Opcional

Automatizaciones

Si se deja una puerta abierta por 10 minutos, cambia el modo del aire de frio a ventilación

alias: Puerta abierta - Modo frio a ventilacion
description: ""
triggers:
  - trigger: state
    entity_id:
      - binary_sensor.puerta
    from: "off"
    to: "on"
    for:
      hours: 0
      minutes: 0
      seconds: 10
conditions:
  - condition: state
    entity_id: climate.ac_estudio
    state: cool
actions:
  - action: climate.set_hvac_mode
    metadata: {}
    data:
      hvac_mode: fan_only
    target:
      entity_id: climate.ac_estudio
mode: single

Cambiar el modo del aire dependiendo la temperatura

Esta automatización cambia el modo del aire acondicionado dependiendo la temperatura ambiente. Si la temperatura es menor a 25°C, cambia el modo a ventilación y si es mayor a 29°C, cambia el modo a frío.

alias: Cambio de modo dependiendo la temperatura
description: ""
triggers:
  - entity_id:
      - climate.ac_estudio
    attribute: current_temperature
    below: 25
    for:
      hours: 0
      minutes: 30
      seconds: 0
      milliseconds: 0
    trigger: numeric_state
  - entity_id:
      - climate.ac_estudio
    attribute: current_temperature
    above: 29
    trigger: numeric_state
conditions:
  - condition: or
    conditions:
      - condition: state
        entity_id: climate.ac_estudio
        state: cool
      - condition: state
        entity_id: climate.ac_estudio
        state: fan_only
actions:
  - choose:
      - conditions:
          - condition: numeric_state
            entity_id: climate.ac_estudio
            attribute: current_temperature
            below: 25
        sequence:
          - data:
              entity_id: climate.ac_estudio
              hvac_mode: fan_only
            action: climate.set_hvac_mode
      - conditions:
          - condition: numeric_state
            entity_id: climate.ac_estudio
            attribute: current_temperature
            above: 29
        sequence:
          - data:
              entity_id: climate.ac_estudio
              hvac_mode: cool
            action: climate.set_hvac_mode
mode: restart

Apaga el aire si no hay nadie en casa por 10 minutos

alias: Apagar aire fuera de casa
description: ""
triggers:
  - trigger: state
    entity_id:
      - zone.home
    attribute: persons
    to: "0"
    for:
      hours: 0
      minutes: 10
      seconds: 0
conditions:
  - condition: not
    conditions:
      - condition: state
        entity_id: climate.ac_estudio
        state: "off"
actions:
  - action: climate.turn_off
    metadata: {}
    data: {}
    target:
      entity_id: climate.ac_estudio
mode: single

Espero que les guste y sea de utilidad. Si tienen alguna duda o sugerencia, te leo en los comentarios!

¿Tenés una impresora 3D y querés aprovecharla al máximo? En este video te muestro como logré sumarle funcionalidades a mi impresora gracias OctoPrint, un enchufe inteligente y Home Assistant.

Desde encenderla desde el celular, calentar la impresora, que nos notifique por Telegram con una foto de la impresión finalizada o simplemente que se apague cuando termina de imprimir y detecta que no la vamos a usar más.

Ver video en YouTube

Paso a compartir todas las automatizaciones, scripts y comandos RESTful de Home Assistant:

Automatizaciones

Reintentar conectar la impresora a OctoPrint al encender enchufe

alias: 3D Printer - Try to connect after turn on
description: ""
triggers:
  - entity_id:
      - <switch.nombre_del_switch_conectado_a_la_impresora>
    from: "off"
    to: "on"
    trigger: state
conditions: []
actions:
  - delay:
      hours: 0
      minutes: 3
      seconds: 0
      milliseconds: 0
  - if:
      - condition: state
        entity_id: sensor.octoprint_current_state
        state: unavailable
    then:
      - metadata: {}
        data:
          device_id: <device_id>
          profile_name: <nombre_del_perfil_de_la_impresora_en_octoprinta>
        action: octoprint.printer_connect
mode: single

Apagar impresora al terminar de imprimir

Esta automatización se encarga de apagar la impresora cuando termina de imprimir y detecta que no la vamos a usar más.

alias: 3D Printer - Shutdown after print
description: ""
triggers:
  - entity_id:
      - sensor.octoprint_job_percentage
    to: "100.0"
    trigger: state
conditions: []
actions:
  - delay:
      hours: 0
      minutes: 10
      seconds: 0
      milliseconds: 0
  - if:
      - condition: and
        conditions:
          - condition: state
            entity_id: sensor.octoprint_target_tool0_temp
            state: "0.0"
          - condition: state
            entity_id: sensor.octoprint_target_bed_temp
            state: "0.0"
    then:
      - action: switch.turn_off
        metadata: {}
        data: {}
        target:
          entity_id: <switch.nombre_del_switch_conectado_a_la_impresora>
mode: single

Notificación de Alexa al terminar de imprimir

alias: Notification - 3D Printer finished
description: ""
triggers:
  - entity_id:
      - sensor.octoprint_job_percentage
    to: "100.0"
    trigger: state
conditions:
  - condition: time
    after: "09:00:00"
    before: "23:59:00"
actions:
  - metadata: {}
    data:
      message: "\"Pochito, se terminó la impresión 3D\""
    action: <notify.nombre_de_tu_dispositivo_alexa_o_que_quieras_que_reciba_la_notificacion>
mode: single

Sacar foto y enviar por Telegram al finalizar la impresión

alias: Photo OctoPrint to Telegram
description: ""
triggers:
  - entity_id:
      - sensor.octoprint_job_percentage
    to: "100.0"
    trigger: state
conditions: []
actions:
  - variables:
      filename: >-
        /config/www/snapshots/{{ now().strftime('%Y%m%d_%H%M%S') }}_{{
        state_attr('camera.octoprint_camera', 'friendly_name') | slugify }}.jpg
  - action: camera.snapshot
    metadata: {}
    data:
      filename: "{{ filename }}"
    target:
      entity_id: camera.octoprint_camera
  - action: telegram_bot.send_photo
    metadata: {}
    data:
      authentication: digest
      file: "{{ filename }}"
      caption: Terminó la impresión 3D!
mode: single

Scripts

Calentar impresora

alias: Precalentar impresora
sequence:
  - if:
      - condition: state
        entity_id: sensor.octoprint_current_state
        state: Operational
    then:
      - metadata: {}
        data: {}
        action: rest_command.octoprint_set_bed_temp_60
      - metadata: {}
        data: {}
        action: rest_command.octoprint_set_tool_temp_195
      - wait_template: |-
          {{ 
            states('sensor.octoprint_actual_bed_temp')|float >= 59 and 
            states('sensor.octoprint_actual_tool0_temp')|float >= 194 
          }}
        continue_on_timeout: false
        timeout: "00:05:00"
      - metadata: {}
        data:
          message: Impresora lista para imprimir
        action: <notify.nombre_de_tu_dispositivo_alexa_o_que_quieras_que_reciba_la_notificacion>
description: ""
icon: mdi:heat-wave
mode: restart

Imprimir test de calibracion de la cama

Este script es valido para enviar cualquier tipo de impresión. Solo hay que cambiar el archivo que se envía.

alias: Imprimir calibracion
sequence:
  - if:
      - condition: device
        type: is_on
        device_id: <device_id>
        entity_id: <entity_id>
        domain: switch
      - condition: state
        entity_id: sensor.octoprint_current_state
        state: Operational
    then:
      - action: rest_command.octoprint_set_bed_test_file
        metadata: {}
        data: {}
        response_variable: octoprint_response
      - if:
          - condition: template
            value_template: "{{ octoprint_response['status'] == 204 }}"
        then:
          - action: rest_command.octoprint_start_job
            metadata: {}
            data: {}
    else:
      - action: <notify.nombre_de_tu_dispositivo_alexa_o_que_quieras_que_reciba_la_notificacion>
        metadata: {}
        data:
          message: No se pudo imprimir. Verificar el estado de la impresora
description: ""
icon: mdi:printer-3d-nozzle

Comandos RESTful

Para mantener el orden, agrupé todos los comandos en el archivo rest_command.yaml, recuerden incluirlo en su configuración de Home Assistant. Por otra parte, para utilizar la API de OctoPrint necesitamos obtener una API Key. Se obtiene desde OctoPrint, en la parte de User Settings.

Setear temperatura del fusor a 195°C

octoprint_set_tool_temp_195:
    url: https://url_de_octoprint/api/printer/tool
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "target", "targets": { "tool0": 195} }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Setear temperatura de la cama a 60°C

octoprint_set_bed_temp_60:
    url: https://url_de_octoprint/api/printer/bed
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "target", "target": 60 }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Enviar archivo de prueba de nivelación de la cama

octoprint_set_bed_test_file:
    url: https://url_de_octoprint/api/files/local/Bed%20Level%20Test%20(full).gcode
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "select", "print": true }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Iniciar impresión

octoprint_start_job:
    url: https://url_de_octoprint/api/job
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "start" }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Cancelar impresión

octoprint_cancel_job:
    url: https://url_de_octoprint/api/job
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "cancel" }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Pausar/Reanudar impresión

octoprint_pause_job:
    url: https://url_de_octoprint/api/job
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "pause", "action": "toggle" }'
    content_type:  'application/json; charset=utf-8'
    verify_ssl: true

Mover ejes a la posición de home

octoprint_home:
    url: https://url_de_octoprint/api/printer/printhead
    method: POST
    headers:
      authorization: !secret octoprint_header_api_key
      accept: "application/json, text/html"
      user-agent: 'Mozilla/5.0 {{ useragent }}'
    payload: '{ "command": "home",  "axes": ["x", "y", "z"]}'
    content_type: 'application/json; charset=utf-8'
    verify_ssl: true  

Espero que les guste y sea de utilidad. Si tienen alguna duda o sugerencia, te leo en los comentarios!

En estos dos videos quiero compartir como logré convertir todos los ventiladores de casa en smart con el iFan03 de Sonoff.

Si bien estos dispositivos se pueden controlar e integrar a Home Assistant con eWeLink, prefiero utilizar un firmware alternativo como Tasmota para tener un control local y total de los dispositivos.

Como es un tema no menor, separé el video en dos partes para que puedan ver todas las funcionalidades del iFan03 y luego, si soy un poco más tryhard, flashear el dispositivo con Tasmota.

Videos

Así convertí los ventiladores de techo en smart con el iFan03 de Sonoff

Ver video en YouTube

Flasheo del iFan03 con Tasmota

Ver video en YouTube

Diseño para caja de luz rectangular

Además, hice un diseño para poder colocar el iFan en la caja de la luz tipo rectangular (típicamente usada en Argentina) para poder hacer uso del botón de encendido y que quede todo prolijo. Comparto el link al diseño en Thingiverse por si les interesa imprimirlo. Link a Thingiverse

Agradecimientos a Estudio Tangente por ser mi gurú en el mundo del diseño 3D.

Espero que les guste y sea de utilidad. Si tienen alguna duda o sugerencia, no duden en dejar un comentario.

El Smart Plug v2 de la marca Athom, que viene preflasheado con ESPHome, ideal para utilizar con Home Assisant ya que se integra localmente a nuestra instalación.

Ver video en YouTube

Conocé sobre Home Assistant, sus alternativas y por qué lo prefiero sobre el resto. Además te muestro rápidamente como podes hacer para instalarlo dentro de una Raspberry Pi y comenzar en este mundo del hogar inteligente.

Ver video en YouTube