Consumo de Lâmpadas

Ajuda
#1

Fala pessoal, tudo sussa com vocês?

Então, estava pensando em como poderia criar um sensor para monitorar o quanto as lâmpadas consomem (dia/semana?mês/ano), mas confesso que me perdi nas idéias de como criar o sensor, já que os T3 da Sonoff não possuem nativamente essa informação disponível.

De início, seria algo como se o estado estiver “on”, então começa a contar em W mesmo e depois converto para kWh com um template, mas não sei como faria esse cálculo, baseado apenas na potência da lâmpada (6Wh em média) e que poderia servir para qualquer dispositivo ligado na rede e que pudesse ser monitorado, como uma televisão (nessa caso, temos 2 estado, on e off ou on e standby).

Alguma idéia ou caminho para começar a fazer os teste aqui?

Forte abraço

1 curtida
#2

Sem medidor vai ser bem chutado os valores.
Sempre que conferi o consumo de algum aparelho, nunca chegou no consumo descrito na etiqueta, sempre consumiam menos.

Da uma olhada no tutorial do @Choske, ele ensina a ver por quanto tempo ficou ligado, ai já fica mais fácil adaptar para calcular o consumo e valor

#3

Fala Walber, tranquilo?

Então cara, esse esquema já utilizo para as TVs de casa, mas apenas contam por quanto tempo e quantas vezes foram ligada dentro do mês… o que preciso de ajuda é como fazer para ter um sensor que faça o cálculo (+/- aproximado, para um estudo em andamento), pois se cada lâmpada tem potência de 6Wh, então teremos 6/60 = 0.1Wm (minuto) ou 0.0016Ws (segundo). Poderia até fazer esse cálculo para cada 5 minutos (0,5W), mas daria no mesmo no final das contas.

Tentei assim, mas não deu muito certo…

  - name: "Consumo Luz Sala"
    unique_id: consumo_luz_sala
    device_class: power
    unit_of_measurement: 'W'
    state_class: measurement
    state: >
      {% set light_ws = 0.0016 %}
      {% set light_time = states('light.sala') | float %}
      {% set light_consumption = (light_time * light_ws) %}
      {% if light_time > 0 %}
        {{ light_consumption }}
      {% endif %}

Havia uma integração do NodeRED que possibilitava/facilitava isso com dispositivos da eWeLink (Sonoff) mas foi descontinuada e está sem atualização já faz mais de 2 anos e meio, então tenho que criar esse sensor (light.name_power) na mão mesmo… só não sei como ainda.

Alguma idéia?

#4

Seu calculo ta certo, o problema é sua entidade states(‘light.sala’), vc tem que trocar para a entidade que esta contando o tempo de funcionamento.

Colocando o valor na mão ta tudo certo.

      {% set light_ws = 0.0016666666666667 %}
      {% set light_time = 10800  %}
      {% set light_consumption = (light_time * light_ws)  | round(2)%}
      {% if light_time > 0 %}
        {{ light_consumption }}
      {% endif %}

Edit

      {% set light_ws = 0.0016666666666667 %}
      {% set light_time = states('sensor.copa_uptime_sec') |float %}
      {% set light_consumption = (light_time * light_ws)  | round(2)%}
      {% if light_time > 0 %}
        {{ light_consumption }}
      {% endif %}

image
image1071×481 40.3 KB

#5

Então Walber…

Percebi depois esse “erro” de identificação do sensor mas como já era quase 3h da madrugada, tive que abortar a idéia de fazer a devida correção aqui.

Mas o processo foi um tanto mais chato e mais demorado para fazer porque, na verdade, precisei criar uma quantidade grande de sensores distintos para cada dispositivo para ter o resultado que queria… e ainda está dando um trabalho danado.

Mas deixa eu exemplificar aqui para que, caso mais alguém queira fazer, tenha um ponto de partida já funcional e seja bem menos trabalhoso implementar. Para isso, tive que trabalhar com os seguintes arquivos:

sensor.yaml:
platform: history_stats - calcular o tempo (ligado/desligado)
platform: integration - converter Wh para kWh (W * Tempo / 1000)
platform: template - calcular os custos (kWh * $)

template.yaml
sensor - calcular a potência (Ws * Tempo)

utility_meter.yaml
para calcular o consumo (kWh * Tempo)

sensor.yaml:

### Calcular Tempo (ligada e standby) ###
- platform: history_stats
  name: LG Sala Ligada
  entity_id: media_player.lg_50um7510psb
  state: 'on'
  type: time
  start: '{{ now().replace(day=1).replace(hour=0).replace(minute=0).replace(second=0) }}'
  end: '{{ now() }}'

- platform: history_stats
  name: LG Sala Standby
  entity_id: media_player.lg_50um7510psb
  state: 'off'
  type: time
  start: '{{ now().replace(day=1).replace(hour=0).replace(minute=0).replace(second=0) }}'
  end: '{{ now() }}'

### Converter W para kWh ###
- platform: integration
  source: sensor.lg_sala_power
  name: LG da Sala Ligada Energy
  unique_id: sensor.lg_sala_energy
  unit_prefix: k
  method: left
  round: 2

- platform: integration
  source: sensor.lg_sala_standby_power
  name: LG da Sala Standby Energy
  unique_id: sensor.lg_sala_standby_energy
  unit_prefix: k
  method: left
  round: 2

### Calcular Custos ###
- platform: template
    sensors:
      lg_sala_ligada_custo_dia:
        friendly_name: LG Sala Ligada Custo Dia
        unique_id: sensor.lg_sala_ligada_custo_dia
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_ligada_consumo_dia") | int(states("sensor.lg_sala_ligada_consumo_dia")) * (states("input_number.box1") | float)) | round(2) }}'
      lg_sala_ligada_custo_semana:
        friendly_name: LG Sala Ligada Custo Semana
        unique_id: sensor.lg_sala_ligada_custo_semana
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_ligada_consumo_semana") | int(states("sensor.lg_sala_ligada_consumo_semana")) * (states("input_number.box1") | float)) | round(2) }}'
      lg_sala_ligada_custo_mes:
        friendly_name: LG Sala Ligada Custo Mês
        unique_id: sensor.lg_sala_ligada_custo_mes
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_ligada_consumo_mes") | int(states("sensor.lg_sala_ligada_consumo_mes")) * (states("input_number.box1") | float)) | round(2) }}'

      lg_sala_standby_custo_dia:
        friendly_name: LG Sala Standby Custo Dia
        unique_id: sensor.lg_sala_standby_custo_dia
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_standby_consumo_dia") | int(states("sensor.lg_sala_standby_consumo_dia")) * (states("input_number.box1") | float)) | round(2) }}'
      lg_sala_standby_custo_semana:
        friendly_name: LG Sala Standby Custo Semana
        unique_id: sensor.lg_sala_standby_custo_semana
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_standby_consumo_semana") | int(states("sensor.lg_sala_standby_consumo_semana")) * (states("input_number.box1") | float)) | round(2) }}'
      lg_sala_standby_custo_mes:
        friendly_name: LG Sala Standby Custo Mês
        unique_id: sensor.lg_sala_standby_custo_mes
        unit_of_measurement: 'R$'
        value_template: '{{ (states("sensor.lg_sala_standby_consumo_mes") | int(states("sensor.lg_sala_standby_consumo_mes")) * (states("input_number.box1") | float)) | round(2) }}'

template.yaml

sensor:
  - name: "LG Sala Power"
    unique_id: lg_sala_power
    device_class: power
    unit_of_measurement: 'W'
    state_class: measurement
    state: >
      {% set lg_sala_ligada_w = 0.0375 %} ### consumo da tv (W) a cada segundos ###
      {% set lg_sala_ligada_time = states('sensor.lg_sala_ligada') | float %}
      {% set lg_sala_ligada_consumption = (lg_sala_ligada_w * lg_sala_ligada_time) | round(2) %}
      {% if is_state('media_player.lg_50um7510psb', 'on') %}
        {{ lg_sala_ligada_consumption }}
      {% endif %}

  - name: "LG Sala Standby Power"
    unique_id: lg_sala_standby_power
    device_class: power
    unit_of_measurement: 'W'
    state_class: measurement
    state: >
      {% set lg_sala_standby_w = 0.0001388888889 %} ### consumo da tv (W) a cada segundos ###
      {% set lg_sala_standby_time = states('sensor.lg_sala_standby') | float %}
      {% set lg_sala_standby_consumption = (lg_sala_standby_w * lg_sala_standby_time) | round(2) %}
      {% if is_state('media_player.lg_50um7510psb', 'off') %}
        {{ lg_sala_standby_consumption }}
      {% endif %}

utility_meter.yaml

lg_sala_ligada_consumo_dia:
  source: sensor.lg_sala_energy
  name: LG Sala Ligada Consumo Dia
  unique_id: lg_sala_ligada_consumo_dia
  cycle: daily
lg_sala_ligada_consumo_semana:
  source: sensor.lg_sala_energy
  name: LG Sala Ligada Consumo Semana
  unique_id: lg_sala_consumo_semana
  cycle: weekly
lg_sala_ligada_consumo_mes:
  source: sensor.lg_sala_energy
  name: LG Sala Ligada Consumo Mês
  unique_id: lg_sala_consumo_mes
  cycle: monthly

lg_sala_standby_consumo_dia:
  source: sensor.lg_sala_standby_energy
  name: LG Sala Standby Consumo Dia
  unique_id: lg_sala_standby_consumo_dia
  cycle: daily
lg_sala_standby_consumo_semana:
  source: sensor.lg_sala_standby_energy
  name: LG Sala Standby Consumo Semana
  unique_id: lg_sala_standby_consumo_semana
  cycle: weekly
lg_sala_standby_consumo_mes:
  source: sensor.lg_sala_standby_energy
  name: LG Sala Standby Consumo Mês
  unique_id: lg_sala_standby_consumo_mes
  cycle: monthly

Ufa, demorei até para escrever isso aqui… agora imagina fazer isso para cada dispositivo que tenha em casa, incluindo 3 TV’s, vários eletrodomésticos e umas 10 T3 e uns 20 T2 da Sonoff. Daqui para o final de semana acabo de fazer tudo e depois vem a criação dos cards, que será outra dor de cabeça, pois estou usando o Mushroom (com animação) e tentando implementar de forma satisfatória o Honeycomb em algumas coisa.

Mas é isso, espero que de alguma forma ajude outros no tocante ao consumo de energia para lâmpadas e outros dispositivos que não fornecem isso.

Forte abraço

#6

No appdaemon da pra fazer uma vez só e aí passar uma lista de nomes de dispositivos e uma lista de potências e mandar rodar pra todos na lista.

Imagino que no node red também mas aí eu não manjo muito. Se tiver interesse posso no fim de semana um código base no appdaemon e enviar aqui
Ai seria só editar a lista de ids de entidade e potências.

#7

@ariel_leventhal

Mano do céu… isso seria top demais mas antes preciso saber como funciona esse AppDeamon, pois nunca utilizei e nem sei para onde vai.

Se tiver como/puder fazer uma intro junto com o código, ficarei muito grato :slight_smile:

Forte abraço

#8

O appdaemon é tipo nodered só que em vez de programação visual é código Python
No caso seria só instalar addon
Curar um arquivo de código, colar meu código e editar a lista de ids

A única coisa é, que eu preciso testar com calma como fazer do melhor jeito possível. A minha ideia a princípio é o código gerar um sensor que fique mudando entre, 0 e a potência, quando cada device tiver desligado ou ligado. Só não sei se da pra fazer o integration direto pelo appdaemon sem ser uma gambiarra muito grande. Talvez de pra fazer uma soma de Riemann na mão, mas tem que ver como pegar o tempo. mesmo sem integration já facilitaria muito porque seria só um sensor yaml por device em vez de vários. Além disso, Em último caso se realmente não der pra fazer 100% por lá posso fazer o código printar no log o yaml pronto c todos integrations ai só copiar do log e colar no config.yaml.

#9

@ariel_leventhal

Hum… acho que entendi, mas entendo muito pouco de Phyton e isso para mim, nesse momento, se tornaria um entrave muito grande, pois levaria muito tempo para corrigir eventuais erros ou deixar “adequado” para meus usos/testes excessivos.

Seria o caso de se pensar se valeria a pena o tempo que você precisaria investir estudando como fazer isso e muito mais tempo ainda para que eu entenda e faça as adequações necessárias… e não sei se seria válido para ambas as partes, principalmente para você, que ficaria com toda carga de desenvolvimento e auxílio quando eu necessitasse.

De coração, te agradeço imensamente, mas não fico confortável em te ver tendo todo esse trabalho para me ajudar. Agradeço de verdade pela disponibilidade mas não acho justo. Entende?

Se, no final de semana, quiser/puder postar o código que você já utiliza para eu ver e, a partir dele, trocarmos uma idéia, seria muito bom, mas nada que tenha que investir seu tempo criando.

Mais uma vez, te agradeço pela intensão. De coração.

Forte abraço

2 curtidas
#10

Atualmente eu não uso isso não, mas eu de verdade eu faço isso rapidinho, uso Python quase todo dia, não da trabalho não. É um problema simples, é basicamente um sensor template só que com um for loop. Só não faço agora pois estou em semana de provas finais, mas fim de semana/semana que vem vou estar tranquilo de férias já. Também não tem muito erro pra testar é uma coisa bem simples se tiver com erro agente vai logo de cara ver e eu resolvo. Eu fiquei interessado pelo problema, então de qualquer maneira vou fazer um teste no fim de semana aí eu mando caso queira utilizar.

2 curtidas
#11

Tem essa integração que se diz calcular o consumo já, deu uma olhada?
ps: não usei, mas como conhecia quero te passar vai que te resolve…

#12

@Choske

Cara, agradeço imensamente pela dica, não conhecia, e pelo que li é bem simples e fácil de implementar, principalmente se tiver algum dispositivo que já esteja na LUT dele (o que não é o meu caso).

Logo mais dou um feedback se rolou com a GUI ou tive que fazer na mão mesmo e as aferições :wink:

Forte abraço

#13

@Choske

Rapaz… e não é que o trem funciona muito melhor do que esperado? Até com entidades que já possuem _power e _energy você consegue criar os sensores de consumo (diário/semanal/mensal) de forma simples e fácil.

De forma geral, tem pouca coisa para inserir no configuration.yaml, que ele coloca como configs globais, para te ajudar a criar os sensores de forma mais simples e o resto você tanto pode fazer via GUI (com limitações, mas bem completo) ou direto no sensor.yaml (que foi como fiz por carregar mais rápido.

Me economizou um baita tempo escrevendo, digamos ai, umas 2k linhas de código repetitivo e horas de trabalho para menos de 200 e em pouco mais de 40 minutos. Tudo muito simples e prático :wink:

Valeu pela dica e vou marcá-la como solucionada

Forte abraço

#14

Que top mano! Bom saber disso, futuramente quando precisar tbm irei utilizar!!
Vlw!
Que bom que resolveu!