Hoy vamos a ver cómo domotizar tu lista de la compra para que puedas alimentarla de una forma sencilla e incluir algunas automatizaciones.
Índice
Requisitos previos
Antes de domotizar tu lista de la compra, debes revisar que cumples los siguientes requisitos:
- Instalar a través de HACS las tarjetas Bubble Card, Mushroom Cards, Card Mod y Auto Entities.
- Crear el fichero ‘command_line.yaml‘ dentro de la carpeta ‘config’, y añadirlo a la configuración incluyendo las siguientes líneas en tu fichero configuration.yaml:
command_line: !include command_line.yaml
- Importar y configurar el blueprint que he preparado, pulsando en el siguiente botón (más detalle en el apartado correspondiente).
Integración de la Lista de la compra
Para domotizar tu lista de la compra vamos a utilizar la integración oficial de HA, por lo que el proceso es muy sencillo. Simplemente sigue estos pasos:
- Antes de nada, si ya estabas utilizando otra integración no oficial (como la de Bring!), elimínala desde Ajustes > Dispositivos y servicios. Asegúrate también de eliminar la carpeta ‘shopping_list’ de la ruta ‘config/custom_components’ y reinicia Home Assistant.
- Ve a a Ajustes > Dispositivos y Servicios > Añadir integración, busca «Lista de la compra» y pulsa en «Enviar».
- Ahora tienes una opción nueva «Lista de la compra», dentro del apartado «Lista de tareas pendientes» del menu de la izquierda, desde la que puedes administrarla manualmente.
- También se ha creado una nueva entidad (por ejemplo, ‘todo.lista_de_la_compra’). Puedes comprobarlo desde Herramientas para desarrolladores > Estados.
Creación de sensores
Creación de sensores de la lista
El siguiente paso es crear unos sensores que nos permitan extraer los productos de la lista. Esto nos servirá para construir la tarjeta del panel de control y crear automatizaciones.
Vamos a incluir estos sensores dentro del fichero ‘command_line.yaml‘ copiando el siguiente código:
- sensor:
name: "Shopping list (items to buy)"
command: >
jq '{list: ([.[] | select(.complete==false) | .name] | join(","))}' .shopping_list.json
value_template: >
{% if value_json.list == "" %}0
{% else %}{{ value_json.list.split(',') | length }}
{% endif %}
json_attributes:
- list
scan_interval: 1
- sensor:
name: "Shopping list (bought items)"
command: >
jq '{list: ([.[] | select(.complete==true) | .name] | join(","))}' .shopping_list.json
value_template: >
{% if value_json.list == "" %}0
{% else %}{{ value_json.list.split(',') | length }}
{% endif %}
json_attributes:
- list
scan_interval: 1
Esto creará las siguientes entidades:
- La entidad ‘sensor.shopping_list_items_to_buy’ tiene como valor el número de productos en la lista de la compra, y el listado en su atributo ‘list’.
- La entidad ‘sensor.shopping_list_bought_items’ tiene como valor el número de productos comprados recientemente, y el listado en su atributo ‘list’.
Creación de sensores de productos
Cualquier producto que añadas se va a mostrar en tu lista de la compra. Pero, además, puedes crear tantos sensores personalizados para productos como quieras. Esto te va a permitir asignarle características a tus productos (como una imagen, categoría, precio, stock…), para aportar más funcionalidades a tu lista de la compra.
Para ello incluye el siguiente fragmento en tu fichero ‘sensors.yaml’, replícalo y personalízalo para cada uno de tus productos.
- platform: template
sensors:
shopping_list_aguacates:
friendly_name: "Aguacates"
value_template: >
{% set product = "Aguacates" %}
{% set products = (state_attr('sensor.shopping_list_items_to_buy','list') or '').split(',') %}
{%- set items = products | select('equalto', product) | list | length | string -%}
{{ items | int }}
entity_picture_template: "https://cdn-icons-png.flaticon.com/256/2771/2771201.png"
attribute_templates:
category: "Fruta"
store: "Carrefour"
total_cost: >
{{ (2.54 | float) * (states('sensor.shopping_list_aguacates') | float) }}
units: "Aguacates"
featured: "Favoritos"
- platform: template
sensors:
shopping_list_sandia:
friendly_name: "Sandía"
value_template: >
{% set product = "Sandía" %}
{% set products = (state_attr('sensor.shopping_list_items_to_buy','list') or '').split(',') %}
{%- set items = products | select('equalto', product) | list | length | string -%}
{{ items | int }}
entity_picture_template: "https://cdn-icons-png.flaticon.com/256/883/883518.png"
attribute_templates:
category: "Fruta"
store: "Carrefour"
total_cost: >
{{ (7.75 | float) * (states('sensor.shopping_list_sandia') | float) }}
units: "Sandías"
featured: >
{% if 10 > now().month > 4 %}Temporada
{% else %}false
{% endif %}
Revisa el código anterior y observa lo siguiente:
- El nombre del sensor siempre debe ir en minúsculas, sin espacios ni caracteres especiales y con el prefijo ‘shopping_list_’. Todo esto es importante para que se cree el sensor correspondiente y se muestre en nuestra lista.
- El valor del sensor indica la cantidad de producto que has añadido a la lista de la compra (por ejemplo, 3 aguacates, 2 cajas de leche, etc.)
- Puedes asignarle la imagen que quieras para que se muestre en la lista y el catálogo. Basta con que indiques su URL y no es necesario que la descargues (aunque te recomiendo usar iconos de baja resolución, para no ralentizar la carga).
- También puedes asignarles tantos atributos personalizados como te interese, para luego usarlos en la lista. Por ejemplo, yo he creado los siguientes:
- Category. La categoría del producto (por ejemplo, «fruta», «carne», etc.) sirve para que aparezca clasificado automáticamente en el catálogo.
- Store. La tienda en la que suelo comprar el producto (por ejemplo, «Carrefour», «LIDL», etc.) me permite filtrar la lista en función de la tienda en la que me encuentre, para ir más rápido.
- Total cost. Calcula el coste estimado de la compra del producto, teniendo en cuenta la cantidad que quieres comprar. Además, puedes indicar manualmente el precio o ‘scrapear’ el precio de tus productos desde la web de tu supermercado para mantenerlo actualizado. Esto me permite saber el coste estimado total de los productos en la lista de la compra.
- Units. Etiqueta informativa que indica la unidad de compra del producto (por ejemplo, «gramos», «cajas», «botellas», etc.) y utilizo en la lista.
- Featured. En este atributo incluyo reglas personalizadas para que me sugiera productos en la compra. Por ejemplo, si quiero incluir un producto de temporada evalúo el mes en el que nos encontramos (si se cumple devuelve «Temporada», y si no «false»). Otros ejemplos sería evaluar tu condición física para ayudarte con la «operación bikini» o los precios, para incluir ofertas.
Para cada sensor se creará una entidad del siguiente tipo (por ejemplo, ‘sensor.shopping_list_aguacate’).
Creación de sensores personalizados
Esto ya depende de tu imaginación y los atributos que hayas decidido asignar a tus productos. Por ponerte un ejemplo, a mi me ha parecido interesante reflejar el coste estimado de cada producto (teniendo en cuenta las unidades que haya metido en la lista).
La cuestión es que al asignar ese atributo a los productos, ahora me permite crear un sensor personalizado que suma el coste de todos los productos en la cesta, y me devuelve el precio orientativo de la próxima compra. A partir de ahí puedo mostrarlo en la tarjeta de la lista, usarlo en automatizaciones para que me avise cuando supera un importe o incluso acumularlo en un ayudante para saber cuánto gasto al mes.
El código para conseguir el sensor sería el siguiente:
- platform: template
sensors:
precio_proxima_compra:
friendly_name: "Precio próxima compra"
value_template: >
{% set coste = states
| selectattr('entity_id', 'contains', 'shopping_list')
| rejectattr('entity_id', 'contains', 'shopping_list_items_to_buy')
| rejectattr('entity_id', 'contains', 'sensor.shopping_list_bought_items')
| rejectattr('entity_id', 'contains', 'sensor.shopping_list_budget')
| selectattr('domain', 'equalto', 'sensor')
| selectattr('state', 'gt', '0')
| selectattr('attributes.total_cost', 'defined')
| map(attribute='attributes.total_cost')
| list
| sum
%}{{ coste | round(0) }}€
Como decía, aquí entran en juego las prioridades de cada uno. Por ejemplo, estoy seguro de que a muchos puede interesaros hacer el seguimiento de los productos con ‘stock’ bajo, registrar la fecha de caducidad, las calorías de cada alimento o el Nutri-Score.
Como siempre, estamos esperando que compartáis vuestras ideas en nuestra comunidad!
Creación del panel de control
Con los sensores que acabamos de crear ya podemos transformar la interfaz para controlar y domotizar tu lista de la compra.
Tarjeta de la lista de la compra
Esta es la tarjeta principal, que muestra los productos que están en la lista de la compra.
Como puedes observar, tiene las siguientes características:
- En la esquina superior derecha encontrarás un desplegable que te permite filtrar la lista por la tienda asignada a los productos. La idea es que te resulte más fácil hacer la compra en función de donde te encuentres. Para que funcione debes crear un ayudante de tipo desplegable, llamado ‘input_select.shopping_list_stores’ e incluir como opciones las tiendas que quieras filtrar (por ejemplo, «Carrefour», «LIDL», etc.). El nombre de las tiendas debe coincidir con el que has indicado en el atributo ‘store’ de los sensores de productos.
- A su derecha encontrarás un acceso directo al catálogo para añadir productos, que veremos a continuación.
- Debajo, un bloque para cada uno de los productos en la lista de la compra. Si pulsas en dicho bloque, se quitará una unidad de la lista de la compra. Como puedes observar, también se indican las unidades que quieres comprar. Además, los productos se van a incorporar a tu lista incluso aunque no los hayas incluido en tu catálogo.
Si ya has creado tu catálogo, lo único que tienes que hacer es copiar el siguiente código y se creará automáticamente.
type: vertical-stack
cards:
- type: custom:bubble-card
card_type: separator
name: Lista de la compra
icon: mdi:shopping
sub_button:
- name: Tienda
show_name: false
show_icon: true
icon: ""
entity: input_select.shopping_list_stores
- show_name: false
show_icon: true
icon: mdi:shopping-search
tap_action:
action: navigate
navigation_path: "#shopping_list"
modules:
- default
card_mod:
style: |
ha-card {
margin-top: 10px!important;
margin-bottom: 10px!important;
}
- type: custom:auto-entities
visibility:
- condition: state
entity: sensor.shopping_list_items_to_buy
state_not: "0"
show_empty: false
card:
square: false
type: grid
columns: 3
card_param: cards
filter:
template: >-
{% set productos =
(state_attr('sensor.shopping_list_items_to_buy','list') or
'').split(',') %} {% set unicos = productos | unique | list | sort %}
{% for producto in unicos -%}
{%- set slug = producto | slugify -%}
{%- set entity = 'sensor.shopping_list_' + slug -%}
{%- set cantidad = productos | select('equalto', producto) | list | length | string -%}
{%- set unidades = state_attr(entity,'units') -%}
{%- set store = state_attr(entity,'store') -%}
{%- if states(entity) != 'unknown' -%}
{%- set name = state_attr(entity,'friendly_name') or producto -%}
{%- set picture = state_attr(entity,'entity_picture') -%}
{%- if states('input_select.shopping_list_stores') != 'Todas' and states('input_select.shopping_list_stores') == store -%}
{{
{
'type': 'custom:mushroom-template-card',
'entity': 'sensor.items_in_shopping_list_number',
'primary': name,
'secondary': 'x' + cantidad + ' ' + unidades,
'layout': 'vertical',
'multiline_secondary': 'true',
'picture': picture,
'fill_container': 'true',
'tap_action': {
'action': 'call-service',
'service': 'shopping_list.complete_item',
'data': { 'name': name }
},
'card_mod': {
'style': 'ha-card { background: linear-gradient( rgba(238, 82, 79, 1), rgba(181, 42, 39, 1) ); border-radius: 15px; --icon-size: 40px; --card-secondary-font-size: 11px; --secondary-text-color: #ffffff; };',
},
}
}},
{%- elif states('input_select.shopping_list_stores') == 'Todas' -%}
{{
{
'type': 'custom:mushroom-template-card',
'entity': 'sensor.items_in_shopping_list_number',
'primary': name,
'secondary': 'x' + cantidad + ' ' + unidades,
'layout': 'vertical',
'multiline_secondary': 'true',
'picture': picture,
'fill_container': 'true',
'tap_action': {
'action': 'call-service',
'service': 'shopping_list.complete_item',
'data': { 'name': name }
},
'card_mod': {
'style': 'ha-card { background: linear-gradient( rgba(238, 82, 79, 1), rgba(181, 42, 39, 1) ); border-radius: 15px; --icon-size: 40px; --card-secondary-font-size: 11px; --secondary-text-color: #ffffff; };',
},
}
}},
{%- endif -%}
{%- else -%}
{%- set name = producto | capitalize -%}
{{
{
'type': 'custom:mushroom-template-card',
'primary': name,
'secondary': 'x' + cantidad,
'multiline_secondary': 'true',
'icon': 'mdi:shopping',
'icon_color': 'white',
'layout': 'vertical',
'fill_container': 'true',
'tap_action': {
'action': 'call-service',
'service': 'shopping_list.complete_item',
'data': { 'name': name }
},
'card_mod': {
'style': 'ha-card { min-height: 106px!important; background: linear-gradient( rgba(238, 82, 79, 1), rgba(181, 42, 39, 1) ); border-radius: 15px; --icon-size: 40px; --card-secondary-font-size: 11px; --secondary-text-color: #ffffff; };',
},
}
}},
{%- endif -%}
{%- endfor %}
Tarjeta para añadir productos
Esta tarjeta sirve para añadir productos a la lista de distintas formas. En mi caso abro esta tarjeta en un popup de Bubble Card, desde el acceso directo que te indicaba en el apartado anterior (aunque la puedes colocar donde quieras).
- Campo de texto. En la parte superior de la tarjeta siempre aparece un campo de texto que te permite añadir productos a la lista de la compra, sólo con escribirlos. No importa si ya están incluidos o no en tu catálogo.
- Productos comprados recientemente. En este apartado encontrarás los productos que has comprado recientemente. Si pulsas sobre ellos volverán a la lista de la compra, por lo que es la forma más rápida de hacerla. También puedes limpiar este apartado pulsando sobre el icono «Vaciar» en la parte superior.
- Productos ordenados por categoría. Desde este apartado podrás encontrar los productos que has introducido en tu catálogo, ordenados alfabéticamente y por categoría (coincidiendo con lo que hayas indicado en los sensores personalizados). Además, sabrás si ya lo has añadido a la lista (en rojo) o no, así como controlar las unidades desde los iconos correspondientes. Es la mejor forma de hacer la lista más completa.
- Productos sugeridos. Este bloque funciona igual que el anterior, pero en lugar de clasificar los productos por categoría, lo hace por tipo de sugerencia (siempre que sea distinta de ‘false’). Perfecto, si quieres dejarte guiar a la hora de seleccionar tus productos.
- Además, en la esquina superior derecha encontrarás un desplegable que te permite saltar de un apartado a otro (como aprendimos con nuestros menús dinámicos). Para que funcione sólo tienes que crear otro ayudante de tipo desplegable, llamarlo ‘input_select.shopping_list_filter’ y añadir como opciones «Categorias», «Recientes» y «Sugerencias».
Si ya has creado tu catálogo, lo único que tienes que hacer es copiar el siguiente código y se creará automáticamente.
type: vertical-stack
cards:
- type: custom:bubble-card
card_type: pop-up
hash: "#shopping_list"
icon: mdi:shopping-search
name: Catálogo
button_type: name
modules:
- default
- type: todo-list
entity: todo.lista_de_la_compra
hide_completed: true
hide_create: false
card_mod:
style: |
ha-card {
background: transparent;
border: 0px;
box-shadow: none;
margin-left: -10px;
}
ha-list {
display: none;
}
- type: vertical-stack
visibility:
- condition: state
entity: input_select.shopping_list_filter
state: Recientes
cards:
- type: custom:bubble-card
card_type: separator
name: Recientemente
icon: mdi:history
sub_button:
- name: Vaciar
show_name: true
icon: mdi:delete
tap_action:
action: perform-action
perform_action: shopping_list.clear_completed_items
target: {}
- entity: input_select.shopping_list_filter
name: ""
show_name: false
show_icon: true
modules:
- default
card_mod:
style: |
ha-card {
margin-top: 10px!important;
margin-bottom: 10px!important;
}
- type: custom:auto-entities
visibility:
- condition: numeric_state
entity: sensor.shopping_list_bought_items
above: 0
show_empty: false
card:
square: false
type: grid
columns: 3
card_param: cards
filter:
template: >-
{% set LISTA =
state_attr('sensor.shopping_list_bought_items','list').split(',') %}
{% set LISTA_ORDENADA = LISTA | sort %} {% set ITEMS =
LISTA_ORDENADA | count %}
{% for INDEX in range(ITEMS) -%}
{%- set producto_actual = LISTA_ORDENADA[INDEX] %}
{%- set check = 'sensor.shopping_list_' + producto_actual | slugify -%}
{%- if states(check) != 'unknown' -%}
{%- set entity = 'sensor.shopping_list_'+ producto_actual | slugify -%}
{%- set product = state_attr(entity,'friendly_name') -%}
{%- set picture = state_attr(entity,'entity_picture') -%}
{%- set coste = state_attr(entity,'coste') -%}
{{
{
'type': 'custom:mushroom-template-card',
'entity': 'sensor.items_in_shopping_list_number',
'primary': product,
'layout': 'vertical',
'multiline_secondary': 'true',
'picture': picture,
'fill_container': 'true',
'tap_action': {
'action': 'call-service',
'service': 'shopping_list.incomplete_item',
'data': { 'name': product }
},
'card_mod': {
'style': 'ha-card { background: linear-gradient( rgba(79, 171, 162, 1), rgba(38, 133, 124, 1) ); border-radius: 15px; --icon-size: 40px; --card-secondary-font-size: 11px; --secondary-text-color: #ffffff; };',
},
}
}},
{%- else -%}
{%- set product = producto_actual | capitalize -%}
{{
{
'type': 'custom:mushroom-template-card',
'primary': product,
'secondary': '',
'multiline_secondary': 'true',
'icon': 'mdi:shopping',
'icon_color': 'white',
'layout': 'vertical',
'fill_container': 'true',
'tap_action': {
'action': 'call-service',
'service': 'shopping_list.incomplete_item',
'data': { 'name': product }
},
'card_mod': {
'style': 'ha-card { min-height: 106px!important; background: linear-gradient( rgba(79, 171, 162, 1), rgba(38, 133, 124, 1) ); border-radius: 15px; --icon-size: 40px; --card-secondary-font-size: 11px; --secondary-text-color: #ffffff; };',
},
}
}},
{%- endif -%}
{%- endfor %}
- type: vertical-stack
visibility:
- condition: state
entity: input_select.shopping_list_filter
state: Categorias
cards:
- type: custom:bubble-card
card_type: separator
name: Categorías
icon: mdi:view-grid
sub_button:
- entity: input_select.shopping_list_filter
name: ""
show_name: false
show_icon: true
modules:
- default
card_mod:
style: |
ha-card {
margin-top: 10px!important;
margin-bottom: 10px!important;
}
- type: custom:auto-entities
show_empty: false
card:
type: vertical-stack
card_param: cards
filter:
template: |-
{%- set CATEGORIES = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('domain', 'equalto', 'sensor')
|rejectattr('entity_id', 'equalto', 'sensor.shopping_list_bought_items')
|rejectattr('entity_id', 'equalto', 'sensor.shopping_list_items_to_buy')
|map(attribute='attributes.category')
|unique
|list
|sort
-%}
{%- for CAT in CATEGORIES -%}
{%- set ITEMS = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('attributes.category', 'equalto', CAT)
|map(attribute='entity_id')
|list
|length
-%}
{{
{
'type': 'custom:bubble-card',
'card_type': 'separator',
'name': CAT,
'card_mod': {
'style': 'ha-card {margin-top: 10px!important; margin-bottom: 10px!important;}'
},
'sub_button': [
{
'name': ITEMS|string + ' Productos',
'show_name': true,
'tap_action': {
'action': 'none',
},
},
]
}
}},
{%- set PRODUCTS = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('attributes.category', 'equalto', CAT)
|map(attribute='entity_id')
|list
-%}
{%- for PRODUCT in PRODUCTS -%}
{%- set entity = PRODUCT -%}
{%- set product = state_attr(entity,'friendly_name') -%}
{{
{
'type': 'custom:bubble-card',
'card_type': 'button',
'button_type': 'state',
'entity': entity,
'show_state': False,
'show_attribute': True,
'attribute': 'store',
'show_last_changed': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
'button_action': {
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
},
'card_mod': {
'style': (
'.bubble-button-background { opacity: 1 !important; background: linear-gradient('
+ (
'rgba(238, 82, 79, 1), rgba(181, 42, 39, 1)' if product in (state_attr('sensor.shopping_list_items_to_buy','list')) else
'rgba(79, 171, 162, 1), rgba(38, 133, 124, 1)'
)
+ '); } .bubble-entity-picture { width: 25px !important; height: 25px !important; margin-top: 6px;}'
)
},
'sub_button': [
{
'entity': entity,
'show_state': True,
'attribute': 'units',
'show_background': False,
'show_attribute': True,
'show_icon': False,
},
{
'attribute': 'tienda',
'icon': 'mdi:plus-thick',
'show_background': True,
'state_background': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
},
{
'attribute': 'tienda',
'icon': 'mdi:minus-thick',
'show_background': True,
'state_background': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.complete_item',
'data': { 'name': product }
},
},
]
}
}},
{%- endfor %}
{%- endfor %}
- type: vertical-stack
visibility:
- condition: state
entity: input_select.shopping_list_filter
state: Sugerencias
cards:
- type: custom:bubble-card
card_type: separator
name: Sugerencias
icon: mdi:star
sub_button:
- entity: input_select.shopping_list_filter
name: ""
show_name: false
show_icon: true
modules:
- default
card_mod:
style: |
ha-card {
margin-top: 10px!important;
margin-bottom: 10px!important;
}
- type: custom:auto-entities
show_empty: false
card:
type: vertical-stack
card_param: cards
filter:
template: |-
{%- set SUGGESTIONS = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('domain', 'equalto', 'sensor')
|rejectattr('entity_id', 'equalto', 'sensor.shopping_list_bought_items')
|rejectattr('entity_id', 'equalto', 'sensor.shopping_list_items_to_buy')
|rejectattr('attributes.featured', 'equalto', 'false')
|map(attribute='attributes.featured')
|unique
|list
|sort
-%}
{%- for SUG in SUGGESTIONS -%}
{%- set ITEMS = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('attributes.featured', 'equalto', SUG)
|map(attribute='entity_id')
|list
|length
-%}
{{
{
'type': 'custom:bubble-card',
'card_type': 'separator',
'name': SUG,
'card_mod': {
'style': 'ha-card {margin-top: 10px!important; margin-bottom: 10px!important;}'
},
'sub_button': [
{
'name': ITEMS|string + ' Productos',
'show_name': true,
},
]
}
}},
{%- set PRODUCTS = states
|selectattr('entity_id', 'contains', 'shopping_list')
|selectattr('attributes.featured', 'equalto', SUG)
|map(attribute='entity_id')
|list
-%}
{%- for PRODUCT in PRODUCTS -%}
{%- set entity = PRODUCT -%}
{%- set product = state_attr(entity,'friendly_name') -%}
{{
{
'type': 'custom:bubble-card',
'card_type': 'button',
'button_type': 'state',
'entity': entity,
'show_state': False,
'show_attribute': True,
'attribute': 'store',
'show_last_changed': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
'button_action': {
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
},
'card_mod': {
'style': (
'.bubble-button-background { opacity: 1 !important; background: linear-gradient('
+ (
'rgba(238, 82, 79, 1), rgba(181, 42, 39, 1)' if product in (state_attr('sensor.shopping_list_items_to_buy','list')) else
'rgba(79, 171, 162, 1), rgba(38, 133, 124, 1)'
)
+ '); } .bubble-entity-picture { width: 25px !important; height: 25px !important; margin-top: 6px;}'
)
},
'sub_button': [
{
'entity': entity,
'show_state': True,
'attribute': 'units',
'show_background': False,
'show_attribute': True,
'show_icon': False,
},
{
'attribute': 'tienda',
'icon': 'mdi:plus-thick',
'show_background': True,
'state_background': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.add_item',
'data': { 'name': product }
},
},
{
'attribute': 'tienda',
'icon': 'mdi:minus-thick',
'show_background': True,
'state_background': False,
'tap_action': {
'action': 'perform-action',
'perform_action': 'shopping_list.complete_item',
'data': { 'name': product }
},
},
]
}
}},
{%- endfor %}
{%- endfor %}
Importación del blueprint
Pulsa en el siguiente botón para importar y configurar el blueprint que he creado. Básicamente lo único que tienes que hacer es seleccionar el sensor que contiene la lista de la compra. Si has seguido las instrucciones la entidad debe llamarse ‘sensor.shopping_list_items_to_buy’.
Este se encarga de realizar algunas comprobaciones para que todo funcione correctamente. Opcionalmente también puedes configurar una notificación, para que Home Assistant te avise cuando la lista de la compra supera ‘x’ objetos.
Sincronización con otras listas
Una de las ventajas de domotizar tu lista de la compra es que te permite sincronizarla con otras listas compatibles con HA.
Sincronizar la lista con Bring! y Siri
Hasta que decidí domotizar mi lista de la compra con Home Assistant, Bring! ha sido durante años mi aplicación para gestionar la lista de la compra ya que me parece una aplicación muy atractiva y que cumple todos los requisitos.
Este es el complemento perfecto, ya que nos permite disfrutar de lo mejor de ambos mundos. Desde HA podemos seguir generando automatizaciones en torno a nuestra lista de la compra, mientras que podemos confiar en Bring! para aquellos usuarios del hogar sin acceso a Home Assistant. Todo ello manteniendo la coordinación entre ambas.
Si utilizas nuestra lista de la compra, para sincronizarlas sólo necesitas integrar Bring! en Home Assistant e importar el blueprint que he creado pulsando en el siguiente botón.
Además, si eres usuario de Apple, puedes alimentarla directamente diciendo «Oye Siri, añade aguacates a la lista de la compra de Bring«. Lo mejor es que sólo tienes que instalarla en tu dispositivo iOS, nada más. No requiere ningún tipo de configuración.
Cuando le pidas a Siri que añada el producto a tu lista, automáticamente aparecerá en tu lista de Bring! y de Home Assistant.
Sincronizar la lista con Google Assistant
Lo mejor del asistente de Google es que viene integrado de forma nativa en cualquier dispositivo Android, por lo que puedes acceder a él muy fácilmente. Una gran opción para alimentar la lista desde la tablet de la cocina cuando tengo las manos ocupadas!
Cuando le pides a este que añada un producto a la lista de la compra, lo que va a hacer es añadirlo a una lista de Google Keep (la aplicación de Google para tomar notas y crear listas). Por tanto, lo único que tenemos que hacer es integrar Google Keep en Home Assistant e importar el blueprint que he creado pulsando en el siguiente botón.
Control local de la lista de la compra
Si prefieres no utilizar servicios ni aplicaciones de terceros, también puedes domotizar tu lista de la compra y controlarla desde tus dispositivos.
Gestiona la lista con Assist
Ya hemos hablado largo y tendido de Assist, el asistente local de Home Assistant (tanto de su configuración como de los múltiples dispositivos que te permiten controlarlo). Por supuesto, puedes pedirle que añada productos (tanto por escrito como con tu voz) a tu lista de la compra y lo hará sin ningún problema.
Gestiona la lista con tu reloj Amazfit
Una de mis formas favoritas de gestionar la lista de la compra es a través de nuestra aplicación para relojes Amazfit. Cuando estoy en el supermercado simplemente abro la aplicación en mi smartwatch y voy marcando los productos que he cogido. Rápido y fácil!
Para ello lo único que tienes que hacer, una vez configurada la aplicación, es seleccionar la entidad de la lista de la compra (por ejemplo, ‘todo.lista_de_la_compra’) desde el apartado de ajustes de la aplicación. Automáticamente aparecerá en tu reloj!
Más ideas para domotizar tu lista de la compra
En el tiempo que llevamos jugando con la lista de la compra hemos compartido un montón de ideas para crear automatizaciones, por ejemplo:
- Añade productos a la lista de forma automática, basándote en la información proporcionada por dispositivos integrados (por ejemplo, añade «Detergente» cada 50 ciclos de la lavadora) o en el periodo de maduración de productos que consumas de forma recurrente (por ejemplo, añade embutido una vez a la semana).
- Añade productos al escanear etiquetas NFC estratégicamente colocadas por tu casa para facilitarte el trabajo (por ejemplo, en las cajas de la despensa).
- Añade todos los productos de una receta ejecutando un ‘script’ compuesto por una secuencia de acciones que añade cada uno de sus ingredientes (y, si quieres, crea un libro de recetas en HA).
- Programa notificaciones cuando alguno de los miembros de está en el supermercado, para añadir productos de última hora a la lista.
