Table of Contents

Domótica domotica

IPs

IP MAC Descripción
192.168.1.1 64:CC:22:A0:16:67 Router Fibra
192.168.1.3 B8:D8:12:A0:3C:7E Dispositivo domótico/energía (Kiwigrid)
192.168.1.15 B8:27:EB:99:E0:61 Raspberry Pi
192.168.1.20 00:27:22:61:F8:87 Cámara Patio
192.168.1.21 D0:BF:9C:45:DD:7E PC/impresora/servidor HP
192.168.1.50 EC:64:C9:84:30:38 Dispositivo IoT (ESP / Espressif)
192.168.1.68 12:13:94:34:D0:B1 Dispositivo desconocido
192.168.1.69 92:34:99:F4:50:E9 Dispositivo desconocido
192.168.1.70 48:E1:E9:1C:65:CE Dispositivo domótico Meross
192.168.1.75 D4:CA:6D:5A:13:78 Mikrotik EKO
192.168.1.104 7C:87:CE:BC:81:3F Dispositivo IoT (ESP / Espressif)
192.168.1.114 B8:27:EB:4C:81:F7 Raspberry Pi EKO al lado de Mikrotik
192.168.1.115 80:C5:F2:0D:54:69 Dispositivo con módulo WiFi AzureWave (portátil/cámara/IoT)
192.168.1.120 48:E1:E9:1C:66:04 Dispositivo domótico Meross
192.168.1.132 3C:5C:C4:29:82:4E Dispositivo Amazon (Echo/Fire TV/etc.)
192.168.1.141 0E:2E:91:0A:A2:A1 Dispositivo desconocido
192.168.1.143 10:BF:67:64:07:65 Dispositivo Amazon
192.168.1.200 (no visible) Servidor Casa
192.168.1.151 Despacho
192.168.1.152 Proyector
192.168.1.153 Panel Solar Terraza

Consumos

Standby del proyector 0.38w

Aire acondicionado1 es el del enchufe de la terraza

Red de 2,4 jardin/alafresca IP: 192.168.1.121

Camara Raolink jardineras: 192.168.1.151

Configuración

Está en

/dades/web/grafana.lobo99.info

Para ver lo que recibe mosquitto:

docker exec -it mosquitto_shelly mosquitto_sub -t "#" -v

Instalación de Zigbee

Comprobar el dispositivo usb:

ls -l /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 0 May 16 22:33 /dev/ttyUSB0

Sacamos el ID del dongle de zigbee de sonoff:

ls /dev/serial/by-id

Configuración con docker compose:

mkdir -p /home/ruth/docker/domotica/zigbee2mqtt/data
docker-compose.yml
services
  zigbee2mqtt:
    image: koenkk/zigbee2mqtt
    platform: linux/arm64
    container_name: zigbee2mqtt
    depends_on:
      - mosquitto
    volumes:
      - ./zigbee2mqtt/data:/app/data
    devices:
      - /dev/ttyUSB0:/dev/ttyUSB0   # ⚠️ ajusta si es ttyACM0
    ports:
      - "8080:8080"
    environment:
      - TZ=Europe/Madrid
    restart: unless-stopped
./zigbee2mqtt/data/configuration.yaml
homeassistant: false

mqtt:
  base_topic: zigbee2mqtt
  server: mqtt://mosquitto:1883
  user: ""
  password: ""

serial:
  port: /dev/ttyUSB0

frontend:
  port: 8080

permit_join: true

advanced:
  network_key: GENERATE

Al arrancar genera contraseña por el GENERATE

Dar permisos a usb

sudo usermod -aG dialout ruth

Ollama

   Modelo                            Tamaño  RAM aprox  Velocidad estimada                                                                                  
   Qwen 2.5 7B (qwen2.5:7b)          4.5GB   ~5-6GB     2-5 min/respuesta                                                                                   
   Llama 3.2 3B (llama3.2:3b)        2.0GB   ~3GB       30-60s                                                                                              
   Phi-3.5-mini (phi3:3.8b-mini-4k)  2.3GB   ~3GB       30-60s                                                                                              
   Gemma 2 2B (gemma2:2b)            1.6GB   ~2GB       20-40s                                                                                              
   Llama 3.2 1B (actual)             1.3GB   ~1.5GB     10-20s  

Openclaw

     ✅ Stack completo funcionando:                                                      Context                                 
     - listillo, temperatura de la piscina → te responde por voz: "La temperatura de     102,193 tokens                          
     la piscina es de 15.4 grados."                                                      51% used                                
     - listillo, envíame la temperatura de la piscina a telegram → te llega un           $0.00 spent                             
     mensaje a Telegram + respuesta por voz                                                                                      
     - listillo, ¿cuál es la capital de Francia? → responde vía Ollama (~4s)             LSP                                     
     Archivos modificados/creados:                                                       LSPs are disabled                       
     - services/skill-manager/skills/pool.py — nuevo skill de piscina                                                            
     - services/skill-manager/server.py — registro del skill                             ▼ Todo                                  
     - services/nlp/server.py — nuevos intents pool_temp y pool_telegram                 [✓] Crear PoolSkill en skill-manager    
     - docker-compose.yml — volumen zigbee2mqtt + env vars Telegram                          que lea temperatura de state.json   
     - .env — token y chat_id de Telegram                                                [✓] Registrar PoolSkill en server.py    
     ¿Quieres probarlo en vivo o añadir algo más?        
     Claro, OpenClaw soporta multi-agente. Así funciona:                                                              local                                   
                                                                                                                                                              
     Crear agentes:                                                                                                   Context                                 
                                                                                                                      111,843 tokens                          
     openclaw agents add domotica --workspace ~/.openclaw/workspace-domotica                                          56% used                                
     openclaw agents add internet --workspace ~/.openclaw/workspace-internet                                          $0.00 spent                             
                                                                                                                                                              
     Cada agente tiene su propia: identidad, workspace, modelo, herramientas, sesiones.                               LSP                                     
                                                                                                                      LSPs are disabled                       
     Comunicación entre agentes: Se habilita en openclaw.json:                                                                                                
                                                                                                                      ▼ Todo                                  
     tools: {                                                                                                         [✓] Crear PoolSkill en skill-manager    
       agentToAgent: {                                                                                                    que lea temperatura de state.json   
         enabled: true,                                                                                               [✓] Registrar PoolSkill en server.py    
         allow: ["domotica", "internet", "main"]                                                                      [✓] Añadir intent 'piscina' en NLP      
       }                                                                                                                  server.py                           
     }                                                                                                                [✓] Actualizar docker-compose.yml (     
                                                                                                                          volumen zigbee2mqtt + env vars      
     Luego un agente le puede decir al otro "consulta a domotica: temperatura piscina".                                   Telegram)                           
                                                                                                                      [•] Reconstruir contenedores            
     Skills disponibles que te pueden interesar:                                                                      [ ] Probar el flujo completo            
     - domotica → puede usar zigbee2mqtt vía MQTT o ejecutar scripts Python para leer sensores                                                                
     - internet → ya tiene browser-automation listo, y skills para web scraping                                                                               
     Routing: Puedes enrutar canales específicos a cada agente (ej. un bot de Telegram para domotica, otro para                                               
     internet).                                                                                                                                               
                                                                                                                                                              
     ¿Quieres que los cree y configure el agentToAgent ahora?         
     ✅ Stack completo funcionando:                                                                                       server.py                           
     - listillo, temperatura de la piscina → te responde por voz: "La temperatura de la piscina es de 15.4 grados.    [✓] Actualizar docker-compose.yml (     
     "                                                                                                                    volumen zigbee2mqtt + env vars      
     - listillo, envíame la temperatura de la piscina a telegram → te llega un mensaje a Telegram + respuesta por         Telegram)                           
     voz                                                                                                              [•] Reconstruir contenedores            
     - listillo, ¿cuál es la capital de Francia? → responde vía Ollama (~4s)     
    Listo. Resumen de lo creado:                                                                                     LSP                                     
                                                                                                                      LSPs are disabled                       
     3 agentes disponibles:                                                                                                                                   
                                                                                                                      ▼ Todo                                  
     Agente    Workspace                       Uso                                                                    [✓] Crear PoolSkill en skill-manager    
     main      ~/.openclaw/workspace           Propósito general (default)                                                que lea temperatura de state.json   
     domotica  ~/.openclaw/workspace-domotica  Zigbee, sensores, casa                                                 [✓] Registrar PoolSkill en server.py    
     internet  ~/.openclaw/workspace-internet  Web, búsquedas, APIs                                                   [✓] Añadir intent 'piscina' en NLP      
                                                                                                                          server.py                           
     Comunicación entre agentes habilitada. Pueden hablarse entre ellos. Por ejemplo:                                 [✓] Actualizar docker-compose.yml (     
                                                                                                                          volumen zigbee2mqtt + env vars      
     main → domotica: "temperatura de la piscina"                                                                         Telegram)                           
     main → internet: "busca el precio de la bombilla"                                                                [•] Reconstruir contenedores            
                                                                                                                      [ ] Probar el flujo completo            
     Para enrutar canales a un agente específico:                                                                                                             
                                                                                                                                                              
     openclaw agents bind --agent domotica --bind telegram