Documentos de Académico
Documentos de Profesional
Documentos de Cultura
com/
Home Assistant #2: Preparando la
Raspberry Pi
Tutoriales
Como primer paso para poder poner en marcha el sistema, necesitamos poder
ponerlo en algún equipo, puede ser un ordenador convencional, pero, para esta
guía, usaremos una Raspberry Pi3.
cd /srv/homeassistant
python3 -m venv .
source bin/activate
Veremos que donde escribimos, ha aparecido delante
(homeassistant), por lo que ahora podemos lanzar la
instalación:
Con esto, ya estaría instalado, para poder lanzarlo por primera vez lanzamos el
comando:
hass
[Unit]
Description=Home Assistant
After=network-online.target
[Service]
Type=simple
User=%i
ExecStart=/srv/homeassistant/bin/hass -c
"/home/homeassistant/.homeassistant"
[Install]
WantedBy=multi-user.target
Es posible que algunos de vosotros hayas probado a seguir con el tutorial después
de dejarlo instalado ya que, como es normal, la curiosidad es algo que empieza
justo cuando lo has instalado, no ha dado problemas y, sobretodo, quieres
empezar a poner dispositivos.
Vamos a ver las diferentes partes de las que consta Home Assistant:
Home
Como he mostrado antes, la imagen del Home es la que vemos al entrar, en ella
tenemos varias secciones:
Donde tenemos:
tail -f homeassistant.log
En la otra sesión de ssh podréis en ese momento lanzar o reiniciar el servicio de
homeassistant y veréis como empieza a aparecer toda la información y, si os está
dando fallo, podréis descubrir donde lo hace.
Existe una manera de configuración más especifica, pudiendo decir que muestre,
por ejemplo, toda la información de todos los componentes, y, de algunos en
concreto, solo mostrar si el mensaje es de un nivel en concreto:
Supongamos que queremos encender la luz del gateway cuando se pone el sol.
Uno de los sensores que vienen por defecto en Home Assistant es el estado del
sol, pudiendo controlar desde la altura en la que está en el cielo como la hora de la
puesta o la salida del mismo. El sensor del que os hablo, luce así:
Las “Conditions” son similares a los triggers, salvo que no hacen saltar la acción
en si, sino que sirven para forzar a que se debe cumplir una condición para que se
ejecute la acción. Es decir, si tenemos un trigger y una condición, primero ha de
cumplirse el trigger y, si también se cumple la condición, ejecutamos la acción, sin
embargo, si se cumple la condición, pero no el trigger, no se lanza (tampoco lo
haría si se cumple el trigger pero no la condición).
¿Os ha funcionado?
Home Assistant #8: Detección de
dispositivos en casa
Después de un pequeño tiempo de parón, vamos a detectar y poder aprovechar
los dispositivos de la casa, para lo que necesitemos, como, podría ser el hecho de
hacer que nuestra casa se comporte de una forma cuando estamos y otra cuando
no.
En mi caso, he querido configurar Home Assistant para detectar los móviles de las
personas que están en casa para poder notificar de ciertos eventos cuando hay
gente en casa y hacer otros (principalmente funcionar como alarma) cuando no
hay nadie en casa. Para esto, he probado diferentes maneras y, os voy a explicar
la mejor que he conseguido poner y que, funciona bastante bien, aunque, con sus
fallos.
device_tracker:
- platform: nmap_tracker
hosts: 192.168.1.0/24
Suponiendo que nuestras IPs internas son del tipo 192.168.1…. si nuestra subred
cambia (eso lo podemos comprobar viendo la ip que asignamos a nuestra
Raspberry Pi en la instalación.
hide_if_away: false
icon:
mac: zz:xx:63:zz:zz:xx
name: chromecast
picture:
track: false
chromecast:
hide_if_away: false
icon:
mac: zz:xx:63:zz:zz:xx
name: MiNombre
picture: /local/mifoto.jpg
track: true
mkdir www
Por último pondremos el fichero con la foto llamado “mifoto.jpg” dentro para
que Home Assistant lo muestre.
El resto de dispositivos del fichero “known_hosts.yaml” podremos poner a false
el valor de “track” para evitar que nos aparezca y, una vez que tengamos la red
controlada, podemos añadir a la configuración:
– platform: nmap_tracker
hosts: 192.168.1.0/24
interval_seconds: 10
consider_home: 360
new_device_defaults:
track_new_devices: False
hide_if_away: True
De esta manera conseguimos evitar algunos errores de posibles desconexiones
por ahorro energético de nuestros teléfonos, así como no meter nuevos
dispositivos a ser controlados de forma automática.
Una vez que tenemos esto configurado, podemos jugar con la presencia de estos
dispositivos, ya que, estarán con el estado “home” cuando estén detectados o
“not_home” cuando se encuentran fuera de la LAN, por lo que podemos usarlos
para o bien lanzar algún trigger en una automatización (por ejemplo, el dispositivo
entra o se va) o, hacer que sean la condición para que se ejecute algo, por
ejemplo si está o no en casa.
Si ya tenéis Telegram, podéis seguir la guía, pero, para aquellos que no, os
recomiendo que busquéis en vuestra tienda de aplicaciones, como Play Store o
App Store, para descargarlo y ponerlo en marcha, al igual que se hace en
Whatsapp. Una vez que tengáis Telegram en funcionamiento, podemos seguir
para crear nuestro bot, el cual, será el que nos informará y más adelante podrá
recibir órdenes para poder hacer cosas en casa desde Telegram.
Como crear un bot de Telegram
Con ese número apuntado, ya podemos configurar nuestro Home Assistant para
comunicarse con nosotros desde Telegram
telegram_bot:
- platform: polling
api_key: ABCDEFGHJKLMNOPQRSTUVXYZ
allowed_chat_ids:
- CHAT_ID_1
- CHAT_ID_2
- CHAT_ID_3
Con ese paso ya tendréis dado de alta el bot y enumerados los usuarios a los que
puede comunicarse, ahora, quedaría crear el notificador en si, que sería como el
canal por el que mandaría el mensaje. Si queréis mandar notificaciones a más de
un usuario, tendréis que poner uno por cada:
notify:
- name: telegramdeedu
platform: telegram
chat_id: CHAT_ID_1
Ahora, solo nos queda reiniciar y esperar que todo esté correcto, si algo falla,
recordad mirar el log
Una vez que ya está configurado, necesitamos probarlo, para ello, podemos crear
una pequeña automatización para poder notificarnos cuando un dispositivo entra o
sale de casa. Por ejemplo, voy a hacer el ejemplo que tengo de cuando mi móvil
sale de casa y notifica que me he ido. Lo primero que haríamos sería ir a
Configuración y Automations, una vez dentro, le damos al botón + de añadir y
empezamos la configuración:
Posiblemente penséis que es algo que no necesitaréis nunca, pero si tenéis idea
de usar un enchufe Sonoff dentro de vuestro Home Assistant o un
microcontrolador ESP8266, tarde o temprano os tocará instalar este servidor de
mensajes, si queréis saber qué es MQTT, podéis conocer un poco más en nuestra
página pulsando sobre el link anterior.
Nuestro primer pasó, será el poder añadir la lista de paquetes a nuestra Rasbian
con el fin de instalarlo por medio de apt-get.
mkdir mosquitto
cd mosquitto
wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
cd /etc/apt/sources.list.d/
cd /etc/mosquitto
domotica123
Si todo ha ido bien, veremos aparecer el mensaje en la primera ventana, donde
teníamos el comando mosquitto_sub de esta forma:
Parece que hay algunos problemas con las librerías ssl y mosquito, prueba con lo
siguiente que nos permitirá compilar e instalar la versión 1.4.14:
cd
wget http://mosquitto.org/files/source/mosquitto-1.4.14.tar.gz
cd mosquitto-1.4.14
****
****
cmake .
make -j4
Una vez que tenemos un sistema funcional, podemos ir avanzando poco a poco
en la integración de diferentes sensores para que poco a poco nuestro sistema
sea de lo más completo, pero, a veces, podemos necesitar algo como Google
Assistant para poder complementarlo y poder activar las cosas sin necesidad de
entrar al propio sistema, sobretodo si contamos con algún hardware de los que
vende Google para su sistema.
En este tutorial, voy a tratar de explicar de la forma más sencilla posible todo lo
que tenemos que hacer para poder dejar nuestro sistema funcionando y que
podamos lanzar comandos desde Google Assistant.
NOTA: Uno de los requisitos básicos que necesitamos cumplir es el hecho de que
nuestro Home Assistant funcione con SSL (https), algo que acabo de darme
cuenta, que no he documentado, por lo que prometo tutorial al respecto.
Recomiendo hacer el tutorial con algo de tiempo y quizá comida y bebida cerca ya
que es bastante más extenso que cualquiera de los otros que hemos podido
hacer.
En Google
access_token =
UJXHzLnRZbfmIgsKoLEcVEGgNdtnUKOTOEEdgbXwgBiKrXqfDYFmcJdDDDsdD
dfvcCyRAjmnprsdkjiKGAuKpwNvPEZKQSATmCHpAuuUKZKOCgLnTbXDygT
En Home Assistant
google_assistant:
project_id: someproject-2d0b8
- switch
- light
- group
entity_config:
switch.kitchen:
aliases:
- bright lights
- entry lights
light.living_room:
expose: false
entity_config:
input_boolean.alarma:
name: alarma
En el móvil
Ahora nos toca seguir con la app en el móvil, si no la tienes, puedes entrar en Play
Store e instalar el “Google Assistant”. Una vez que lo tengas instalado, tendremos
que añadir nuestra aplicación de Google Home.
Una cosa que debes saber es que Google todavía no ha incluido Google Home en
su Assitant español, por lo que para poder seguir, será necesario que pongas tu
teléfono en inglés, además, tendremos que llegar a la configuración desde algún
sitio diferente. Una vez que arrancamos la app con el teléfono en inglés, vemos
donde nos pregunta en qué puede ayudarnos, ahí, pulsamos sobre el icono azul
de arriba a la derecha
Una vez que entramos en los ajustes, bajamos hasta abajo del todo donde pone
mostrar todas las categorías “All categories”
En el listado general de categorías tenemos que buscar el que tiene un icono de
una bombilla y se llama Home control (actualmente, como digo, solo en inglés)
Entramos y elegimos el primero (si cambiara el primero de la lista, lo normal es
que cualquiera de los que aparezca, debería servir.
Dentro de por ejemplo, el Tplink que aparece el primero, podemos bajar hasta
encontrar “Home Control” para pulsar en Settings a la derecha
Ahora ya estamos dentro de lo que sería la configuración Home Control que,
actualmente no podemos encontrar dentro de la aplicación en español ni en
cualquier idioma no soportado. En esta configuración veremos todo lo que
tengamos conectado a nuestro Home de Google, que, en mi caso es solo un
Chromecast. Para continuar, pulsamos en el + que hay en el circulo azul abajo a la
derecha
Una vez que pulsamos, si todo ha salido bien, tendremos la aplicación que hemos
creado en los pasos anteriores que, pulsando sobre ella, hará el intento de
conexión contra nuestro Home Assistant y, si no ha habido errores, la instalará en
nuestro Home Control de la App en el movil
Como vemos, Google importará aquello que le digamos que queremos compartir
con él, por lo que tendremos aquellos dispositivos/interruptores o demás
dispositivos o sensores que tiene Home Assistant, controlables con la voz, eso si,
con el comando en inglés.
Espero que seais capaces de terminarlo, pero, si tenéis cualquier duda, podéis
preguntar en los comentarios o, podéis uniros al grupo de Telegram para poder ir
avanzando juntos.
Home Assistant #12: Limpieza del código y preparando para las copias de
seguridad
Vamos a seguir con la serie de tutoriales, en este caso, toca algo menos divertido
y algo que tendría que haber hecho hace tiempo y que, aquellos que quieran llegar
a editar el código para hacer cosas más avanzadas, necesitarán hacer tarde o
temprano, limpieza del código.
Si habéis hecho como yo y habéis seguido los tutoriales, habréis hecho uso de
manera intensa del editor de automatizaciones y, si habéis intentado editar a mano
el fichero automations, habréis visto que se trata de un fichero que parece
desordenado, al menos, no sigue el orden de lógico a la hora de lanzar una
automatización de trigger (lo que lanza) – Condition (lo que debe suceder para que
se ejecute) – Action (lo que hace si lo anterior se cumple).
- action:
- data:
service: notify.telegrambot2
alias: Puerta
condition: []
id: '1513669758510'
trigger:
- entity_id:
binary_sensor.door_window_sensor_15823123dcb47f
from: 'off'
platform: state
to: 'on'
Como se puede ver, no está nada claro, ni donde empieza ni donde están las
partes de las que se compone la automatización. El caso es que como están bien
indentados, funcionan sin problemas, pero, cuando queremos entrar a modificar
de una forma manual, se complica mucho el asunto. Vamos a mirar el código con
detenimiento para analizar las partes que tiene y poder ordenarlo de una forma
más lógica:
- id: '1513669758510'
alias: Puerta
trigger:
- platform: state
entity_id:
binary_sensor.door_window_sensor_15823123dcb47f
from: 'off'
to: 'on'
condition: []
action:
- service: notify.telegrambot2
data:
base_url: https://domticaencasa:8123
api_password: miclave123
http_password: miclave123
direccion_web: https://domticaencasa:8123
Ahora que comienza el buen tiempo, mucha gente comienza a usar los fines de
semana, vacaciones para salir y, es algo que aprovechan los enamorados de lo
ajeno para realizar el robo en casas o en sitios que quedan desprotegidos al no
haber nadie. También, es posible que tengamos una segunda vivienda y, por tanto
una siempre quedará vacía mientras estamos en la otra.
Vamos a daros algunos consejos que se pueden hacer con Home Assistant y unos
pocos actuadores para poder conseguir evitar que piensen que no estamos en
casa y así que no consigan perpetrar el robo.
Es sencillo empezar por esta parte, es algo que mucha gente ya hace con un
programador, pero, ¿que pasa si vamos a pasar una larga estancia fuera? El
horario, si observan la casa, podría ser fácil de controlar. Con Home Assistant
podemos programar el encendido y apagado en función de diferentes parámetros
que varían según el día, por ejemplo, podemos hacer que se encienda 1 hora
después de la puesta de sol, ya que, por defecto viene con un sensor llamado
“Sun” que nos indica la hora de la puesta del sol, de esta forma siempre varía algo
de tiempo cada día.
En este apartado, quiero hacer pronto algún tutorial, ya que llevo idea de motorizar
las de mi casa por lo que quisiera enseñar cómo hacerlo y además diferentes
configuraciones posibles. Si queremos jugar con las persianas para la eficiencia
energética, por ejemplo, podemos moverlas para conseguir obtener el calor en
invierno subiendo las persianas y bajándolas en verano para poder hacer pantalla
a las horas más duras de calor. Esto ayudará a que las persianas estén en
movimiento, generando una sensación de que alguien está en casa y evitando así
mostrar una debilidad para el robo.
3. Usa música
Podemos dejar algún altavoz que tengamos integrado en Home Assistant para
reproducir música de una forma aleatoria, al igual que con las luces, podemos
poner música a diferentes horas (cuidado con las horas a las que ponemos para
no molestar a los vecinos) y, de esa forma, si se acercan a la puerta a oír, igual
llegan en un momento de música. Al igual que la música, podemos usar el audio
de algún vídeo de Youtube de varias horas y de esa forma, podemos hacer que
parezca que 2 ó más personas hablan.
Este es otro tutorial que me gustaría hacer, tanto con el timbre de la puerta de la
casa como con el interfono, que dependerá de cada modelo para poder hacerlo de
una forma más sencilla o más difícil. En muchas ocasiones, justo antes de intentar
entrar para realizar el robo, llaman a la puerta para confirmar que no hay nadie (si
alguien les abre, pueden preguntar por cualquier persona o bien son comerciales
de lo que menos nos interese). Más o menos, para que os hagáis una idea, con un
pequeño transformador de 230v a 5v, podemos añadir al timbre de la puerta de
casa algún emisor/sensor que si alguien llama, podamos hacer algo, de esta
forma, sabiendo que nos están llamando, podemos, por ejemplo, si es de noche,
encender luces como si estuviéramos en la cama y fuéramos a mirar quien ha
llamado a la puerta y, si es de día, poder poner música a sonar.
Por desgracia, me encuentro en las estadísticas de aquellos que han sufrido esta
experiencia y, por tanto, es mejor poner todas las medidas posibles antes de que
suceda. En mi caso, quisiera poder hacer también un tutorial (y ya van tres
pendientes) para poder explicaros cosas que tengo configuradas, que todavía
tiene sus fallos pero que controla la casa casi en su totalidad y adaptado a los
hábitos de los que vivimos, ya que, no solo controlo toda la casa cuando no
estamos, si no que controlo las puertas y ventanas que dan al exterior cuando
nosotros estamos dentro, de esta forma, hemos podido volver a dormir tranquilos y
esperamos que no nos tengamos que despertar nunca sobresaltados.
La alarma se arma sola cuando no detecta a nadie en casa y, cuando detecta que
alguno estamos en casa, al rato, activa la alarma que controla las puertas, pero,
dejando el espacio de horario en el que nos vamos al trabajo libre de alarmas para
evitar que suene. Han sido bastantes pruebas y fallos hasta dar con una
configuración que no ha quedado mal y que pronto compartiré para aquellos que
quieran usarla.
En principio, estos son los primeros 5 consejos, pero se pueden dar más, así
como poder usar Home Assistant de una forma totalmente automática para hacer
que nuestra casa esté totalmente controlada y podamos estar tranquilos, dentro de
lo posible.
Algunas de las cosas que están explicadas, ya podéis hacerlas con los tutoriales
de domótica con Home Assistant que tenemos publicados y que pronto se irán
ampliando, no obstante, tenemos un grupo en Telegram en el que si necesitáis
ayuda o, simplemente queréis ir viendo este tema, podéis entrar aquí.
Home Assistant #14: Lector de matrículas con Home Assistant
Hoy tenemos un nuevo tutorial para nuestra serie de tutoriales de Home Assistant
en español, en este caso, podremos realizar la lectura de matrículas por medio de
OpenALPR, que, al no necesitar una gran cantidad de lecturas al día, podremos
usar el servicio Cloud gratuito.
Instalación de ffmpeg
Ahora pasamos a agregar nuestra cámara, yo os voy a dar los pasos para el
modelo SP007 (Marca Sricam) , es tan sencillo como ir a nuestro archivo de
configuration.yaml y escribir:
camera:
- platform: ffmpeg
name: Entrada
input: rtsp://ipdetucamara:554/onvif1
También tendremos que escribir esta línea para habilitar el ffmpeg dentro del
configuration.yaml:
ffmpeg:
ffmpeg_bin: /usr/bin/ffmpeg
Una vez agregado todo comprobáis en vuestro Home Assistant si os sale el video
de vuestra cámara tras un reinicio:
Empezamos con la lectura de matrículas con OpenALPR
Como podéis ver, aparece la imagen de mi cámara dentro, quiere decir que la
cámara está funcionando y comunicándose bien con Home Assistant, ahora
tenemos que agregar el lector de matrículas. Para ello nos dirigimos a
https://cloud.openalpr.com/ y creamos una nueva cuenta, ya sabéis usuario,
contraseña, correo etc…. NO hace falta nada de tarjetas de crédito ni nada. Una
vez que entréis con vuestra cuenta os dirigíos hacia “Cloud Api” que se encuentra
en vuestro panel de la izquierda y copias el “Secret Key”.
Luego solo nos queda agregar otra vez en configuration.yaml con los datos
obtenidos:
image_processing:
- platform: openalpr_cloud
api_key: sk_vuestrasecretkey
region: eu
source:
- entity_id: camera.entrada
Bueno solo nos faltaría crear una automatización, os dejo está a modo de ejemplo,
simplemente reconoce la matricula “XXXXHM” y reproduce un sonido en el
Gateway de
xiaomi (en el caso de tener uno).
- service: xiaomi_aqara.play_ringtone
data:
gw_mac: 78:11:DC:XX:XX:XX
ringtone_vol: 100
trigger:
platform: event
event_type: image_processing.found_plate
event_data:
entity_id: image_processing.openalpr_entrada
plate: XXXXHM
En plate podéis indicar tantas matriculas como queráis, según tengo entendido el
cloud de Openalpr permite como unos 1000 reconocimientos de matriculas al mes,
sinceramente no creo que tengamos que utilizar más.
Como podéis imaginar, este reconocimiento de matrícula, abre (literalmente)
muchas puertas de cara a poder gestionar cosas de la casa, desde la apertura de
la puerta del garaje, hasta poder poner la casa en marcha, en función de quien
llega, para hacer cosas diferentes, como podría ser encender la calefacción, luces,
etc.
Si tenéis pensado poner una alarma en casa o tener algo para el control de la
misma cuando no estáis, o, incluso cuando estáis para usarlas de sensor de
presencia, necesitaréis, al menos, instalar una cámara.
Otra cosa interesante es si vuestra cámara, o la que elijáis para usar en Home
Assistant permite descargar una imagen cada segundo también libera el sistema.
Para poder sacar las url de la cámara, he usado en algunos casos ispyconnect,
podéis mirar antes de comprar.
- platform: ffmpeg
name: Camara1
En caso de que lo podáis hacer por medio de una imagen, liberaréis mucho la
Raspberry Pi, tendréis que ponerlo así. Asumimos de nuevo que la cámara está
en la 192.168.1.100 y que el directorio donde vemos la captura actualizada cada
segundo es /web/tmpfs/snap.jpg”:
- platform: generic
name: Camara1
still_image_url:
http://user:pass@192.168.1.100/web/tmpfs/snap.jpg
Una vez hecho esto, salváis el fichero y podéis probar a reiniciar Home Assistant
para ver si coge la configuración. En caso de estar correcto, debería saliros algo
así:
- platform: ffmpeg_motion
name: Camara1_movimiento
changes: 10
reset: 1
Los datos, son los mismos que los de la imagen, tan solo entran en juego nuevos
como por ejemplo, “changes” que define el % de diferencia entre una imagen y la
siguiente para que considere que hay movimiento. Por ejemplo, en el código que
os he puesto, si hay un 10% de cambios, saltará el aviso del sensor, cuanto más
alto, menos preciso, pero menos falsos positivos. Otro parámetro es el reset, que
es el tiempo que tarda el sensor en reiniciarse para poder volver a detectar
movimiento, por defecto es 20 segundos, pero en el ejemplo he puesto 1 segundo.
También podríamos poner un detector de ruido por medio del audio de la cámara
con la siguiente configuración en el mismo sitio:
- platform: ffmpeg_noise
name: Salon-Ruido
Una vez hecho esto, tendremos, cuando reiniciemos, el o los sensores y que
podremos usar de igual forma que si se tratara de un sensor normal de
movimiento.
Assistant
Hasta el momento, tan solo tenemos las cámaras puestas en el sistema y tenemos
el detector de movimiento si os habéis decidido a ponerlo con la propia cámara,
pero ahora, nos falta poder hacer algo con las cámaras para si detectamos
movimiento, para eso, como no todas las cámaras nos brindan la posibilidad de
hacerlo directamente, la solución que encontré pasaba por “salir” de Home
Assistant y hacer cosas por la consola, os explico el procedimiento.
--output-
document=/home/homeassistant/.homeassistant/www/camara1.jp
g http://user:pass@192.168.1.100/web/tmpfs/snap.jpg:
Fichero de salida y la dirección de la foto para
descargar, al igual que el video lo dejamos todo en www
dentro del directorio de configuración
Hasta la fecha sigo usando el editor del propio Home Assistant, por lo que os
muestro las capturas de cómo lanzo los comandos yo. Si empezamos con el
vídeo, vemos el trigger (disparador) que sería el sensor de movimiento, en mi caso
es un sensor de movimiento Xiaomi Aqara, cuando su estado pasa de off a on.
De esta forma, deberíamos tener las cámaras plenamente funcionales para poder
usarlas y no solo ser componentes pasivos grabando si no que puedan
informarnos por medio de los sensores de movimiento, aunque, quizá, necesitaréis
algo más potente con el fin de cubrir las necesidades de ffmpeg.
Espero que os haya servido el tutorial, y, como siempre, si tenéis dudas o queréis
avanzar más, tenemos un grupo de Telegram donde podéis estar al tanto de todo
y solucionar vuestras dudas. La información la tenéis al final del tutorial.
¿Os ha funcionado?
Home Assistant #17: Controlamos si nuestra web está caída
Hace tiempo que venía dándole vueltas a la posibilidad de controlar las webs que
tengo para saber si están en pie o se han caído, algo que tenemos multitud de
sitios con los que poder hacerlo de forma externo, pero creo que podía venir bien
hacerlo con Home Assistant para recibir un mensaje por Telegram si está alguna
caída.
En este caso, vamos a tener que recurrir a un comando de consola, curl, para
muchos, será una herramienta conocida, pero para otros, totalmente desconocida.
Se trata de una herramienta de la consola de Linux (aunque se encuentra en casi
todos los sistemas operativos) que nos sirve para poder trabajar con las webs,
sobretodo para diagnostico, pudiendo realizar operaciones completas.
En nuestro caso, tan solo realizaremos la petición de las cabeceras en busca del
200 OK, que es el código que devuelven las webs cuando todo va bien y ha
devuelto la web correctamente, al menos, a nivel de servidor.
Como digo, este tutorial es rápido, ya que tan solo tendremos que añadir dentro
del area de “binary_sensor:” en nuestro configuration.yaml lo siguiente:
- platform: command_line
payload_on: 200
NetData nos permite monitorizar el Sistema operativo sobre el que corre nuestro
Home Assistant integrando la interfaz en un panel de la aplicación.
A partir de este momento desde cualquier navegador que esté dentro de nuestra
red, podemos monitorizar el sistema conectandonos a http://direccion ip de la
raspberry:19999/
y veremos la siguiente pantalla:
Después de este tutorial para hacer copia de seguridad, como digo, de todo el
sistema, voy a publicar el que tengo a medio para poder guardar toda la
configuración de forma automática en github, algo que ayudaría para si queremos
cambiar el sistema o bien queremos tener el control de los cambios que hemos ido
haciendo.
NOTA: ¡Ojo! Los comandos que vais a usar son muy peligrosos y pueden
“liarla parda” si os equivocáis de unidad, es decir, aseguraros que estáis
viendo la unidad de la SD ya que, podríais copiar/restaurar la unidad que no
es, pudiendo machacar el sistema operativo en ejecución, por lo que mucho
cuidado. Espero no equivocarme en los comandos, pero, no me hago
responsable de si hay algún error en ellos, están hechos con el mayor
cuidado posible y con la mejor intención.
Requisitos:
Si usas Linux buscamos nuestra tarjeta en las unidades que nos aparecen con
el comando:
sudo fdisk -l
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
Sacará un listado de las unidades que tenemos y, por ejemplo, en mi caso, como
vemos en la captura la unidad con 120GiB es /dev/sdf, por lo que haremos copia
de dicha unidad, aunque, antes tendremos que localizar donde guardar. Tengo un
disco duro externo montado y cuya ruta es /media/usuario/USBNTFS1, por lo que
lo grabaré ahí.
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
Desde Windows:
Si estás en Windows, puedes descargar el Win32 Disk Imager, tendrías que
ver la unidad que montó cuando pinchaste la SD en el PC para ponerlo bajo
“Device”, la daríamos al icono de la carpeta azul para ponerle en la unidad
donde tengamos el espacio disponible el fichero donde se guardará el backup,
por ejemplo D:\Backup\homeassistant.img
Una vez hecho eso, le daríamos a “Read” para crear la imagen, como digo,
dependiendo del tamaño de la SD así como la velocidad del lector de tarjeta,
puede tardar muuuuucho.
Desde Mac:
diskutil list
Buscaremos la que coincide con el nombre y tamaño de nuestra SD, como podría
ser /dev/disk1
En el terminal, nos vamos a la carpeta donde tenemos sitio para poder hacer el
backup y lanzamos el comando:
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
¿Y si queremos restaurar la copia que hemos realizado? Pues más o menos, son
los mismos pasos, aunque, cambian el orden de las cosas.
Teniendo claro que tenemos nuestra copia en un fichero, tendremos que hacer lo
siguiente. Antes de nada, revisa lo de arriba para poder localizar tanto la ruta
donde está la copia y la SD, mucho cuidado de no fallar con la SD, que ahora es lo
más delicado.
Restauramos el backup de la Raspberry Pi con Home Assistant a una SD
Desde Linux:
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
Desde Windows:
Con el Win32 Disk Imager, elegimos con el icono azul el fichero de la imagen,
ponemos la unidad de la SD en “Device”, pero, ahora, pulsamos en “Write”
Desde Mac:
sudo dd if=/ruta/backup-raspberryHA.dmg of=/dev/discodelaSD
(Nos pedirá la contraseña del usuario que usamos la primera vez que lanzamos el
sudo)
Como he dicho antes, espero que no fallen las cosas y que no tengáis problemas
a la hora tanto de copiar como de restaurar, si detectáis cualquier fallo, podéis
avisar en los comentarios para poder corregirlo cuanto antes.
Assistant
Tutoriales
cd /srv/homeassistant/
source bin/activate
NOTA: Estos pasos son, en el caso de haber instalado con nuestra guía de
instalación de Home Assistant en español.
Una vez actualizada, entramos a nuestro fichero de configuración:
sudo nano
/home/homeassistant/.homeassistant/configuration.yaml
Para añadir:
Bajo el primer apartado que veis que pone “homeassistant:”
homeassistant:
# añadimos esto de abajo
auth_providers:
- type: homeassistant
# Si queremos compatibilidad con el sistema anterior,
descomentamos lo siguiente
# - type: legacy_api_password
Reiniciamos (paciencia)
Ya dentro del sistema nos pedirá al cargar la web que creemos un usuario nuevo:
Y, una vez creado, refrescará la página y nos pedirá el usuario y contraseña para
poder entrar. Una vez dentro, ya estáis preparados para el nuevo sistema de
autenticado de Home Assistant.
Home Assistant #21: Controla tu aire acondicionado con un sonoff basic por
Primero, que vas a necesitar para controlar nuestro aire acondicionado por
infrarrojos:
NOTA: En algunos sistemas puede dar error, intenta con los siguientes
comandos: python -m pip install esptool opip2 install esptool
El 1st GPIO, en mi caso GPIO-14 pero como digo se pueden usar otros, si tenéis
WEMOS o NodeMCU podéis usar otros.
switch:
- platform: mqtt
payload_on: "heatpumpir,1"
payload_off: "heatpumpir,0"
qos: 1
retain: true
Si queréis tener un control completo tendréis que usar el componente climate mqtt
(https://www.home-assistant.io/components/climate.mqtt/)
climate:
- platform: mqtt
initial: 27
min_temp: 18
max_temp: 32
#current_temperature_topic: /status/sonoff-daikin/HEATPUMPIR
modes:
- 'off'
- 'on'
- heat
- cool
- dry
- fan
- maint
- auto
swing_modes:
- auto
- swing
- up
- mup
- middle
- mdown
- down
fan_modes:
- auto
- maximum
- high
- medium
- low
- silent
power_command_topic: /sonoff-daikin/HEATPUMPIR/POWER
payload_on: 1
payload_off: 0
mode_command_topic: /sonoff-daikin/HEATPUMPIR/MODE
temperature_command_topic: /sonoff-daikin/HEATPUMPIR/TEMP
fan_mode_command_topic: /sonoff-daikin/HEATPUMPIR/FAN
swing_mode_command_topic: /sonoff-daikin/HEATPUMPIR/HSWING
qos: 1
Agradecer a let’s control it y ToniA no hubiera sido posible construir este firmware.
Espero que os haya gustado. Saludos!
Home Assistant #22: Como usar el Timer para mantener una luz encendida
Tengo una luz en la cocina bajo la encimera (tengo pendiente publicar el cambio
que le hice a la luz) que usando un sensor de movimiento, en mi caso un sensor
de movimiento Aqara para poder controlar la luminosidad, enciende la luz cuando
detecta movimiento, siempre que tenga menos luz de la indicada para que se
encienda solo cuando empieza a faltar luz en la cocina.
Estuve mirando como hacerlo y tenía pensado hacerlo por medio de algún
indicador binario para saber cuando apagar o no la luz, pero, encontré los Timers
y aunque me ha costado llegar a lo que creo que es la solución, lo tengo en
pruebas, pero, seguro que a más de uno le puede ayudar a mantener la luz
siempre encendida mientras sea necesario.
timer:
cocina:
duration: '00:02:20'
- id: '1539039314913'
trigger:
- platform: state
entity_id: binary_sensor.cocinaPIR_occupancy
from: 'off'
to: 'on'
condition:
- below: '12'
condition: numeric_state
entity_id: sensor.cocinaPIR_illuminance
action:
- service: switch.turn_on
data:
entity_id: switch.LEDCocinaEncimera
- service: timer.start
data:
entity_id: timer.cocina
Reseteo de la cuenta para que el Timer vuelva a contar desde el principio, en
caso de que la luz esté encendida y el sensor de movimiento pase de off a on
de nuevo (dejó de detectar movimiento, pero ha vuelto a detectar movimiento):
- id: '15390123123913'
trigger:
- platform: state
entity_id: binary_sensor.cocinaPIR_occupancy
from: 'off'
to: 'on'
condition:
- condition: state
state: 'on'
entity_id: switch.LEDCocinaEncimera
action:
- service: timer.start
data:
entity_id: timer.cocina
duration: '00:02:20'
Por último, la automation que apagará la luz, cuando el Timer llegue a cero y el
sensor de movimiento esté en off, es decir, ya no se detecta movimiento:
- id: '1011'
trigger:
- platform: event
event_type: timer.finished
event_data:
entity_id: timer.cocina
condition:
- condition: state
state: 'off'
entity_id: binary_sensor.cocinaPIR_occupancy
action:
- service: switch.turn_off
data:
entity_id: switch.LEDCocinaEncimera
- id: '10122'
trigger:
- platform: event
event_type: timer.finished
event_data:
entity_id: timer.cocina
condition:
- condition: state
state: 'on'
entity_id: binary_sensor.cocinaPIR_occupancy
action:
- service: timer.start
data:
entity_id: timer.cocina
duration: '00:02:20'
Si nos desplazamos por la pantalla hacia más abajo, llegaremos a una sección
que indca: “Módulos de autenticación multifactor”, habilitaremos esta opción
(según aparece en la imagen) y nos dará la oportunidad de escanear un código
QR para usar una aplicación externa que nos permita gestionar nuestros códigos
OTP.
Aquí va por gustos, podemos usar muchas y están disponibles para casi todas las
plataformas. Aquí os dejamos algunas:
Google Authenticator
Authenticator de LastPass
Authy.
Una vez hayamos escaneado el código QR con nuestra aplicación favorita,
veremos en la pantalla unos números que cada cierto tiempo irán variando. Estos
es el segundo factor que nos va a solicitar nuestro Home Assistant cuando nos
autentiquemos
Ip_ban_enabled: true
Login_attempts_threshold: 3
De esta forma cuando alguien falle más de tres veces seguidas la autenticación en
nuestro sistema, de forma automática nuestro Home Assistant bloqueará su
dirección IP creando una entrada en el fichero ip_bans.yaml
Y ya que estamos, ¿por qué no hacemos que además cada vez que haga un
baneo nos avise mediante pushbullet?, vamos allá
Para no hacer mucho más larga esta entrada en el blog, daremos por hecho que
ya tenemos configuradas las notificaciones mediante pushbullet.
#########################################################
# #
# #
#########################################################
trigger:
- platform: state
entity_id: persistent_notification.httplogin
condition:
- condition: template
action:
- service: notify.pushbullet
data_template:
title: "{{
states.persistent_notification.httplogin.attributes.message
}}"
message: 'url: https://whatismyipaddress.com/ip/{{
states.persistent_notification.httplogin.attributes.message.s
plit ("from ") [1]}}'
- service: persistent_notification.dismiss
data:
notification_id: 'httplogin'
Con esto conseguiremos que nos avise mediante el servicios Pushbullet cuando
han intentado acceder a nuestro sistemas. Pero para muestra un botón:
Seguro que muchos de vosotros estáis mirando para instalar una cámara en
Home Assistant para tener vigilancia en vuestros sistemas, pero, no sabéis que
cámara elegir, antes de comprar nada, podéis mirar este tutorial.
android_ip_webcam:
- host: 192.168.1.106
port: 8080
sensors:
- battery_level
- light
- motion
- proximity
- sound
switches:
- night_vision
- torch
- video_recording
Una vez hecho esto, reiniciaremos Home Assistant y si todo ha salido bien,
tendremos la cámara funcionando en Home Assistant así:
Como podemos ver aquí, tenemos multitud de opciones, tanto para colocar
sensores que nos los proporciona la App, como interruptores, para, por ejemplo,
poder encender el flash de la cámara a modo linterna. Os recomiendo mirar las
opciones y probar a ver las que soporta vuestro teléfono.
Hace tiempo que tengo la casa conectada a modo alarma dentro de Home
Assistant y una de las cosas que se puede hacer para poder tener acceso, o para
cualquier uso que queráis, es hacerlo por medio de tags.
Los tags son pequeños identificadores que van sin pila y que cuando lo acercamos
a un lector, es alimentada por el campo de inducción y lanzan el número que los
identifica. En el caso del NFC, además, podemos hacerlo por medio de nuestro
móvil, si soporta dicha tecnología.
Lo primero que tenemos que hacer es comprar unos pocos elementos para poder
tener el punto de identificación donde pondremos el tag o nuestro smartphone, son
pocas cosas las que hacen falta y no son caras:
Soldador: Por cierto, por si no tienes soldador y quieres comprar algo que esté
bien y no cueste mucho, yo el 936H, si queréis, podéis comprarlo aquí o aquí.
También podéis comprar puntas para el soldador más finas por poco más de
1€aquí.
Estaño: Necesitaréis algo de estaño para soldar, podéis encontrar aquí, os
recomiendo algo fino para estas soldaduras. Podéis encontrarlo aquí.
Es necesario un conversor serial a USB, que puede que lo tengáis, pero si no,
podéis comprarlo aquí.
Ahora ya, con la lista de la compra hecha, tocará esperar un tiempo y podemos
seguir con los siguientes pasos. En total ronda los 10-14€, incluyendo algún tag
para probar.
Flasheo del Wemos D1 mini
Es necesario soldar los pines del Wemos D1 mini para poder flashearlo. Podiamos
haber elegido uno con los pines ya soldados, pero, igualmente tendrías que soldar
en el PN532 y el Wemos es muy cómodo por tener la posibilidad de alimentarlo
por USB.
Una vez que tengas las soldaduras hechas tendremos que flashearlo con la
herramienta esptool desde consola o podéis usar la herramienta pyflasher que os
mostramos, y, para los pines, podéis ver el tutorial que hizo nuestro compañero
Alcar para flashear un sonoff (o cualquier ESP8266).
Deberéis bajar la última versión de la rama 2.0 de ESPEasy, que podéis
encontrarla aquí. Una vez descargado el fichero ESPEasy_mega-2019……zip (los
puntos suspensivos son la fecha), descomprimimos, y, de entre todos los ficheros,
elegiremos el que acaba en “…._normal_ESP8266_4096.bin” (cuidado que
también está el del 8285).
Arranque del Wemos D1 mini
Si todo ha salido bien, debería decirnos cual será la IP que va a tener en nuestra
WiFi real y al cabo de unos segundos o minutos, nosotros volveremos a estar en
nuestra WiFi, dentro de la configuración del ESPEasy, pero ya dentro de nuestra
propia WiFi. Si no os avisara de la IP que va a tener, os tocará ir a la configuración
de vuestro router y buscar algún nuevo equipo que se haya conectado,
normalmente con el nombre de ESPEasy, ESP0, o similares.
Configurando ESPEasy
Unit name será el nombre del dispositivo, podéis poner lo que queráis, en mi
caso he puesto “Acceso”.
En las WiFi Settings aparecerá la configuración de la WiFi que pusimos y
podemos poner una WiFi de respaldo en caso de que la primera caiga.
El resto de parámetros se pueden dejar como salen.
Pulsamos en el botón de abajo de Submit
Pestaña “Controllers”
Pestaña “Hardware”
Yo lo tengo así, aunque no le doy uso, es para usar el LED de notificaciones:
Pestaña “Devices”
Aquí es donde se configura el lector. Para ello es necesario darle al primer Edit.
Para poder usarlo, es necesario soldar los pines que van en el lado que tiene 4
(GND, VCC, SDA y SCL), además, en el lado que veréis muchos agujeros más
pequeños, es necesario soldar 1 pin, el que va etiquetado con RSTPDN (luego
explicaré el motivo)
Una vez soldados, ya solo nos quedaría conectar los cables que serían de esta
forma:
El reset lo conectamos, porque, según avisan en ESPEasy, el lector NFC/RFID
parece quedarse en algunos casos colgado y, la única manera de poder volverlo a
su ser es resetando o quitándole la corriente, de esta forma, lo puede hacer el
propio Wemos.
Si todo va según lo previsto, podemos seguir con el último paso, configurar Home
Assistant. Para ello, tenemos que recordar todo lo que pusimos o bien hacemos lo
del paso anterior para ver el topic del mensaje mqtt para poder ponerle un sensor.
Dentro de la sección “Sensor:” pondremos lo siguiente:
- platform: mqtt
state_topic: "/Acceso/TAG/Tag"
name: "Lector"
expire_after: 2
icon: mdi:nfc-variant
payload_not_available: 0
Una vez hecho esto, tocaría reiniciar para ver si efectivamente, Home Assistant lo
ve. Le he puesto el nombre “Lector” pero podéis poner lo que queráis. En
state_topic, será lo que os aparezca en el servidor MQTT, que se compone por el
nombre del Wemos que pusierais, el nombre del Device y el Tag que pusimos
segundo dentro del “Device”.
Si todo ha salido bien, tendremos nuestro Tag dentro de Home Assistant, así:
Ahora solo nos quedaría una automatización, os pongo un pequeño ejemplo para
que veáis como usar el tag como trigger:
- id: '123456789'
trigger:
- platform: state
entity_id: sensor.lector
action:
- service: notify.TelegramGrupo
data:
Y con esto, ya podéis usar los tags, o vuestros móviles para poder hacer cosas
dentro de Home Assistant.
¿Habéis podido hacerlo? Ya sabéis, si tenéis dudas, abajo tenéis los enlaces del
foro y del grupo de Telegram.
Home Assistant #32: Integramos un sensor de temperatura de 1€
Después de nuestro tutorial para poder integrar el acceso por medio de NFC o
RFID en Home Assistant, he pensado en hacer una serie de tutoriales para poder
integrar diferentes dispositivos para hacer sensores caseros muy baratos.
En este caso he pensado en hacer un sensor de temperatura y presión con
precisión de 2 decimales que podemos regular la cantidad de muestreos que
realizan para poder tener una lectura lo más precisa posible.
Soldador: Por cierto, por si no tienes soldador y quieres comprar algo que esté
bien y no cueste mucho, yo el 936H, si queréis, podéis comprarlo aquí o aquí.
También podéis comprar puntas para el soldador más finas por poco más de
1€ aquí.
Estaño: Necesitaréis algo de estaño para soldar, podéis encontrar aquí, os
recomiendo algo fino para estas soldaduras. Podéis encontrarlo aquí.
Cuando compráis los sensores, suelen incluir los pines que hay que soldar, no
cuesta mucho, tan solo tendremos que sujetar los pines para poder pegarles el
estaño en la parte trasera para dejar la parte larga lista para conectar los cables
dupond.
Si nos vamos al Log (Pestaña Tools y luego pulsamos en Log) veremos si todo ha
ido bien como aparecen los valores en el Log:
Al igual que si hemos configurado el MQTT siguiendo los pasos, veremos el valor
en el log del servidor MQTT
Integramos los valores del sensor en Home Assistant
Como con cualquier sensor MQTT, los pasos a seguir son sencillos, tendremos
que ver la estructura del topic para poder utilizarlo, si miramos el log del servidor
MQTT, lo tendremos sencillo:
Por lo que para poder usar estos valores en Home Assistant tendremos que poner
lo siguiente bajo la sección “sensor:” en nuestro configuration.yaml:
- platform: mqtt
state_topic: "/Sensores/Entorno/Temperature"
unit_of_measurement: "C"
- platform: mqtt
state_topic: "/Sensores/Entorno/Pressure"
unit_of_measurement: "hpa"
Una vez hecho esto, cuando reiniciemos Home Assitant debería aparecer dicho
sensor de esta forma:
Con esto ya tendríamos este sensor, que podemos poner, en cualquier lado de la
casa por su reducido tamaño.
En este tutorial, os voy a mostrar como controlar esta luminosidad con un sensor
que podemos comprar por menos de 1€ tanto en Aliexpress como en eBay, pero,
al igual que os dije en el tutorial con el sensor de temperatura económico, será
necesario contar con un ESP8266 para poder hacerlo, y, al igual que os dije en los
anteriores, el Wemos D1 mini es una buena opción.
Soldador: Por cierto, por si no tienes soldador y quieres comprar algo que esté
bien y no cueste mucho, yo el 936H, si queréis, podéis comprarlo aquí o aquí.
También podéis comprar puntas para el soldador más finas por poco más de
1€ aquí.
Estaño: Necesitaréis algo de estaño para soldar, podéis encontrar aquí, os
recomiendo algo fino para estas soldaduras. Podéis encontrarlo aquí.
Tendremos que usar los pines que vienen con el sensor cuando lo compramos,
por lo que es rápido y solo hacen falta 5 puntos de soldadura para poder
conseguir que tengamos las conexiones listas para ser conectados al ESP8266.
Conexión del sensor de luminosidad BH1750
Al igual que con el sensor de temperatura, el BH1750 funciona por I2C, por lo que
el conexionado será igual para poder hacerlo funcionar dentro de nuestro
ESPEasy, es decir, siguiendo esta tabla:
Podéis hacer como hice yo tapando con la mano, acercando, separando para que
veáis que actualiza los parámetros. También podemos buscar en nuestro
mosquitto, si está mandando correctamente los datos al servidor MQTT:
Una vez comprobado que todo está correcto, ya podemos integrarlo en Home
Assistant.
Integración en Home Assistant del sensor de luminosidad BH1750 en
ESPEasy
- platform: mqtt
state_topic: "/Sensores/Luminosidad/Lux"
name: "Luminosidad"
unit_of_measurement: "Lux"
Ahora, solo nos quedaría reiniciar Home Assistant para poder comprobar si ya
tenemos sensor de luminosidad muy barato funcionando:
Hay muchos servicios de meteorología de los que podemos nutrir nuestro sistema,
pero, para según que ciudades, el más acertado puede ser el de AEMET, ya que,
es el servicio estatal centrado en toda España.
Gracias a un usuario del grupo, he podido descubrir este custom component que
nos permite poner una tarjeta con los datos de meteorología que queramos, si
queréis hacerlo, esta es la manera de conseguirlo:
sensor:
- platform: aemet
name: AEMET
api_key: !secret aemet_api_key
station_id: !secret aemet_station_id
monitored_conditions:
- temperature
- humidity
- pressure
- precipitation
- snow
- visibility
Ahora, tocará reiniciar, y si todo ha salido correctamente, deberíais tener algo así:
¿Os ha salido?
Llevo tiempo con estos dispositivos baratos y la verdad, con alguno de ellos
instalados y su funcionamiento no está nada mal, y, por eso, he pensado que os
podría gustar montar un sensor de movimiento de este tamaño, aunque, no es el
único modelo, hay diferentes e incluso con regulación de la sensibilidad (ideal si
tenéis mascotas) así como el tiempo de rearme.
Lo bueno que tiene es que con un solo ESP8266 podríamos controlar multitud de
sensores de movimiento, por lo que podríamos tener controladas varias zonas con
muy poco dinero.
Para poder realizarlo, será necesario un ESP8266, que, como en otros tutoriales,
por comodidad, usaré el Wemos D1 mini.
Soldador: Por cierto, por si no tienes soldador y quieres comprar algo que esté
bien y no cueste mucho, yo el 936H, si queréis, podéis comprarlo aquí o aquí.
También podéis comprar puntas para el soldador más finas por poco más de
1€ aquí.
Estaño: Necesitaréis algo de estaño para soldar, podéis encontrar aquí, os
recomiendo algo fino para estas soldaduras. Podéis encontrarlo aquí.
Una vez que accedemos a la IP de nuestro Wemos D1, nos vamos a la pestaña
Devices, pulsamos en la primera linea que esté libre, ya que podemos tener
muchos dispositivos más conectados, y le damos a Edit.
Una vez dentro, en el desplegable, elegimos “Switch input – switch”, ahora nos
quedaría configurar el nombre, podemos poner, por ejemplo “movimiento”,
marcamos Enabled y tendremos que decirle en que patilla hemos conectado la
central del sensor de movimiento, en nuestro ejemplo, D5. Ya solo quedaría
marcar, “Send boot state” si queremos que mande la señal de como está cuando
arrancamos y “Send to Controller” para que lo mande al servidor MQTT que
tenemos que tener configurado. Quedaría algo así:
Si todo ha salido bien, podemos ver el log del ESPEasy yendo a Tools y pulsando
en Log:
binary_sensor:
- platform: mqtt
name: "Movimientoam312"
icon: mdi:motion-detector
state_topic: "/Cafetera/Movimiento/Switch"
payload_on: "1"
payload_off: "0"
A la vista de que los tutoriales DIY gustan bastante, sigo con un nuevo tutorial
para poder controlar por medio de un ESP8266 diferentes sensores, en este caso
un sensor de proximidad que nos indica la distancia a la que estamos de él.
Lo bueno es que esa distancia se puede usar dentro de Home Assistant para
hacer lo que necesitemos, por ejemplo, si tenemos un garaje en casa propio y
queremos aparcar siempre a una misma distancia, podemos hacer que nos avise
cuando llegue a esa distancia, y, lo mejor, es que es muy económico.
Soldador: Por cierto, por si no tienes soldador y quieres comprar algo que esté
bien y no cueste mucho, yo el 936H, si queréis, podéis comprarlo aquí o aquí.
También podéis comprar puntas para el soldador más finas por poco más de
1€ aquí.
Estaño: Necesitaréis algo de estaño para soldar, podéis encontrar aquí, os
recomiendo algo fino para estas soldaduras. Podéis encontrarlo aquí.
Tendréis que usar 2 patas del ESP8266 digitales para poder configurarlo, en mi
caso he usado D5 y D6, marcamos Send to Controller y Enabled (en la parte de
arriba) y ponemos el intervalo que queramos de refresco, en mi caso, he puesto 5
segundos y le ponemos la etiqueta al valor 1 que tenemos abajo como “Distancia”,
quedaría algo así:
Si todo está correcto, podemos ir al log (Tools / Log) para ver si refresca cada 5
segundos con el valor de la distancia como vemos aquí:
Y, si miramos el MQTT, veremos que está mandando también la distancia:
Una vez hecho esto, estamos listos para integrarlo en Home Assistant
- platform: mqtt
name: "Distancia"
state_topic: '/Cafetera/Distancia/Distancia'
unit_of_measurement: "cm"
Hace poco tuve problemas con uno de los controladores LED que tenía y quería
poder usar la tira de led con la que venía y, aunque un controlador de LED Magic
Home vale poco, caí en la cuenta que con ESPHome se puede realizar el control
de los mismos, por lo que me puse a mirar para poder hacer el controlador de LED
con ESPHome.
esphome:
name: led
platform: ESP8266
board: d1_mini
wifi:
ssid: "wifi"
password: "domotica"
light:
- platform: rgbw
red: output_component2
green: output_component1
blue: output_component3
white: output_component4
effects:
- random:
# Customize parameters
- random:
transition_length: 30s
update_interval: 30s
- random:
transition_length: 4s
update_interval: 5s
output:
- platform: esp8266_pwm
id: output_component1
pin: D1
- platform: esp8266_pwm
id: output_component2
pin: D2
- platform: esp8266_pwm
id: output_component3
pin: D5
- platform: esp8266_pwm
id: output_component4
pin: D6
# Enable logging
logger:
api:
ota:
Lo primero que tenemos que buscar es una placa donde soldar los componentes,
podéis usar pines hembra para evitar fijar, por ejemplo, el Wemos D1 mini, aunque
en mi caso, como tenía otro en camino, iba a dejarlo fijo, por lo que ya depende de
vosotros. El transformador que compré encaja muy bien dejando en medio el
Wemos, por lo que a los lados podemos poner los transistores y las resistencias
las podéis intentar fijar al lado o por la parte de abajo. Os pongo unas fotos de
como me ha quedado aunque no lo uséis de ejemplo, solo para colocar las cosas,
las soldaduras, hacedlas bien, porque yo he ido probando hasta que conseguí que
funcionara:
Como ya sabréis, todo lo que pongáis con ESPHome es detectado e integrado por
Home Assistant de una forma automática, por lo que tendréis en un momento el
control de la tira de LED para poder usarla con el color e intensidad que más os
guste.
En el ejemplo, he usado una tira de LED RGBW, pero podría haberse usado una
tira RGB o incluso una con leds direccionables y que puedan funcionar de forma
individual (mirad la web de ESPHome para los posibles usos.
Espero que os haya gustado y si tenéis alguna duda, podéis entrar al grupo de
Telegram o al foro para solucionarlas.
Home Assistant #41: Controlamos la cerradura de la puerta de la calle
Desde que nos robaron en casa (si, soy uno de los afortunados a los que le ha
tocado), la paranoia de tener la puerta cerrada en todo momento se ha
incrementado mucho más que antes, por eso, llevaba mucho tiempo dándole
vueltas para ver como conseguir controlar si la cerradura de la puerta de la calle
tiene o no la llave puesta.
Home Assistant
Assistant
Una vez que lo abrimos, tenemos que mirar en los huecos donde entran los
bulones (las barras de acero que tiene que tener tu puerta para poder bloquearla,
ya sea de 1 o más posiciones, en mi casa, tengo 3 zonas, por lo que podía elegir
donde colocarlo y, después de medir, el de la parte inferior parecía estar hecho a
medida, por lo que opté por esa zona.
Una vez visto, le puse cinta de doble cara al sensor de puerta que hemos
desmontado y posteriormente ponemos (todavía sin pegar) el imán en el bulón
que va a quedar enfrentado (sin tocar) al sensor. Una vez que abrimos y cerramos
unas veces y ya vemos que ni toca ni se queda demasiado lejos, podemos fijar
con cianocrilato el iman al bulón.
En caso de que el imán toque el sensor cuando cerramos, debemos ganarle algo
de hueco, limando o como podamos y, si se queda muy lejos y no lo detecta
correctamente, tendremos que acercarlo poniendo algo en la parte trasera.
¿Habéis podido? Si tenéis cualquier duda, ya sabéis, podéis comentar aquí o bien
entrar al grupo de Telegram para solucionar la duda.
Home Assistant #42: Controlar el timbre de la puerta de casa
Después de ver que el tutorial para poder controlar la cerradura de casa, quería
poder controlar el timbre de la puerta de casa (el físico que hay en la misma puerta
de la casa y que indica que alguien está al otro lado y no en la calle esperando
que le abramos).
El controlar este timbre suele ser útil, por varios aspectos, por un lado podríamos
silenciar a nuestro criterio el timbre real (por ejemplo, por las noches) pero no
perder una llamada, ya que, la idea es mandar dicha señal por Telegram para
saber cuando alguien ha llamado, y, por otro (modo paranoia ON), para si estamos
de vacaciones o fuera de casa, poder activar ruidos, música o algo que pueda
hacer creer si alguien lleva mala idea, que hay alguien dentro de casa.
Assistant
Para la compra de los dispositivos, tenemos la siguiente lista, aunque en las fotos
podéis ver otro ESP8266, he reutilizado uno que tenía en el cajón sin darle uso,
por dejarme el Wemos para los tutoriales, pero, os recomiendo el Wemos para
trabajar con él por ser más cómodo y poder alimentarlo con un USB.
En mi caso, el uso que le he dado ha sido para cuando detecta que llamen (suene
o no el timbre de forma sonora) nos notifique a Telegram así como por medio de
los altavoces Alexa que tengo en casa.
Assistant
En mi caso, el uso que le voy a dar es que me notifique cuando llamen al timbre,
tanto si está activado como si no el relé, por lo que aunque no sea audible, si que
veremos en Telegram el mensaje y, adicionalmente, lo he puesto para que suene
en el grupo que tengo creado de los altavoces Alexa.
- id: '99999001'
trigger:
- platform: state
entity_id: binary_sensor.timbre
from: 'off'
to: 'on'
action:
- service: notify.telegramgrupo
data:
- service: media_player.alexa_tts
entity_id: group.altavocesecho
data: