Get best of the week

Sistema de rega automática para jardim para Home Assistant, ESP8266 e MiFlora



Algum tempo atrás, minha família tinha uma casa com um pequeno jardim em um local muito quente e árido, e enfrentávamos o problema de regar regularmente.

Queria que o sistema de irrigação fosse automático, ao escolher, tive que levar em consideração as seguintes condições:

  • água muito cara que deve ser economizada de todas as formas disponíveis
  • plantas diferentes no jardim para necessidades de umidade, de suculentas a amantes da umidade
  • a necessidade de rega totalmente autônoma durante a ausência de pessoas na casa, de preferência com a possibilidade de controle remoto
  • clima árido que não perdoa erros de irrigação

Depois de avaliar as soluções prontas encontradas nas redes locais de bricolage e na Amazon e ler resenhas sobre sua confiabilidade (geralmente não a mais alta), decidimos tentar fazer algo por conta própria.

Isenção de responsabilidade: o autor não é especialista em TI e não afirma ser um conhecimento profissional do tópico. O nível de execução do projeto é um hobby. O autor está ciente do nível de seu conhecimento em programação e eletrônica e agradecerá muito as sugestões para melhorar e otimizar as soluções utilizadas.

Diagrama de circuito


O jardim foi dividido em 4 zonas de irrigação, cada uma delas equipada com um sensor individual de umidade do solo e pode ser regada de acordo com uma programação individual e com uma quantidade diferente de água.
No solo, são instalados tubos PND de irrigação por gotejamento com perfuração, os quais são conectados aos tubos que convergem na unidade de coleta de água e conectados através das válvulas eletromagnéticas ao suprimento de água. As válvulas são controladas por relés conectados ao ESP8266 (Sonoff 4Ch).

A rega é realizada por temporizadores, à noite, para aumentar a quantidade de água absorvida pelo solo e não será evaporada pelo sol.

No horário de rega programado, é verificado o cumprimento de várias condições:

  • umidade do solo abaixo de um valor predeterminado
  • não há precipitação prevista em uma quantidade suficientemente grande para os próximos 2 dias
  • limite de água para irrigação definido para esta linha não é excedido

Equipamento usado


Torta de framboesa com o HassIO instalado (já tinha) o

ESP32 DevKit , um firmware ESPHome, atuando como um gateway bluetooth para o MiFlora e recebendo dados de sensores de umidade com fio. Localizado no jardim.

Umidade Wired sensores capacitivos Soil Moisture Sensor v1.2 , que medem a humidade nas zonas de rega mais próximas do local ESP32 instalação. MiFlora

sensores estão conectados à ESP32 via BLE, que medem a umidade em zonas de rega remoto.

O SONOFF 4Ch , costurado com ESPHome, está localizado na unidade de entrada de água, onde tubos de todas as zonas de rega vêm

4 válvulas solenóides normalmente fechadas para 220Vlocalizado no suporte de água e conectado ao Sonoff 4Ch. Abra o suprimento de água para irrigação. Um modelo normalmente fechado foi escolhido para que a probabilidade de “inundação” no evento de qualquer falha nos componentes eletrônicos e eletrônicos fosse mínima e para minimizar o número de saídas de relé necessárias.

Um medidor de água pulsado na entrada do sistema de irrigação na unidade de entrada de água e conectado ao Sonoff 4ch. Permitido transferir totalmente os dados do fluxo de água para o Home Asssistant e implementar a funcionalidade de irrigação com uma determinada quantidade. Foi muito bem-sucedido que nesta versão do sonoff os contatos do firmware já estavam soldados e até havia um GPIO02 gratuito - um contador de pulsos estava pendurado nele.


Parece um coletor com válvulas instaladas e um medidor de água. O controlador (sonoff 4Ch) não entrou no quadro, ele é instalado a uma distância de meio metro na blindagem IP65

Configurações do ESPHome e do Assistente para Casa


Sonoff 4ch
ESPHome , :

switch:
  - platform: gpio
    name: "   1"
    pin: GPIO12
    id: sw1
    icon: mdi:water
  - platform: gpio
    name: "   2"
    pin: GPIO5
    id: sw2
    icon: mdi:water
  - platform: gpio
    name: "   3"
    pin: GPIO4
    id: sw3
    icon: mdi:water
  - platform: gpio
    name: "   4"
    pin: GPIO15
    id: sw4
    icon: mdi:water
binary_sensor:
  - platform: gpio
    name: "WaterCounter"
    id: button
    pin:
      number: GPIO2
      mode: INPUT_PULLUP


Sensor capacitivo de umidade do solo v1.2
ESPHome:

sensor:
  - platform: adc
    pin: GPIO34
    filters:
      - lambda: |-
          if (x > 3.22) {
            return 0;
          } else if (x < 1.65) {
            return 100;
          } else {
            return (3.22-x) / (3.22-1.65) * 100.0;
          }
    name: "   1  "
    update_interval: 60s
    attenuation: 11db
    unit_of_measurement: "%"
    accuracy_decimals: 0
    icon: mdi:water-percent

(ADC)
, ( 3.22 ) (1,65 ). log' ESPHome HassIO .



ESP32 Home Assistant ,

Medidor de água de pulso
«», ( ). — , , ( — 3 10 ).
, GND GPIO .

ESPHome :

binary_sensor:
  - platform: gpio
    name: "WaterCounter"
    id: counter
    pin:
      number: GPIO2
      mode: INPUT_PULLUP

Home Assistant :

(counter),
(, «» ). — counter, ESPHome, sensor, counter ( ).

2 — , «». , , .

( automations.yaml )
- alias:     
  trigger:
  - entity_id: binary_sensor.watercounter
    platform: state
    from: 'on'
    to: 'off'
  action:
  - data:
      entity_id:
      - counter.my_water_counter
    service: counter.increment
- alias:    1 
  trigger:
  - entity_id: binary_sensor.watercounter
    platform: state
    from: 'on'
    to: 'off'
  condition:
    - condition: state
      entity_id: switch.sistema_poliva_liniia_1
      state: 'on'
  action:
  - data:
      entity_id:
      - counter.my_water_line1, counter.my_water_line1t
    service: counter.increment


configuration.yaml +

sensor:
  - platform: template
    sensors:
      water_counter:    
        unit_of_measurement: 'M3'
        value_template: "{{ (states('counter.my_water_counter')| float)/1000 }}"    
counter:
  my_water_counter:
    initial: 2.667
    step: 10
  my_water_line1:
    name: " 1     ()"
    initial: 0
    step: 10
  my_water_line1t:
    name: " 1   ()"
    initial: 0
    step: 10



MiFlora Sensor
MiFlora ESPHome , esphome.io
Home Assistant — , , «» . — , .

Sensor virtual de chuva
— . , .

darksky. , Apple « ». API , , , , HA . darksky, , .

2 :

configuration.yaml sensors.yaml

sensor:
  - platform: darksky
    api_key: xxxx_your_API_key_xxxx
    forecast:
      - 1
      - 2
    monitored_conditions:
      - precip_intensity

HA : sensor.dark_sky_precip_intensity_1d sensor.dark_sky_precip_intensity_2d, .

template-sensor:

configuration.yaml sensors.yaml

sensor:
  - platform: template
    sensors:
       rain2days:    
        unit_of_measurement: 'mm'
        value_template: "{{ (((states('sensor.dark_sky_precip_intensity_2d')| float)+(states('sensor.dark_sky_precip_intensity_1d')| float))*24)| round(3) }}"

HA sensor.rain2days 2 .
, Darksky ,


Após a coleta de todos os dados, você pode prosseguir diretamente para a rega.

É assim que olho uma parte da interface de uma das zonas do Assistente Domiciliar:



Aqui você pode definir a quantidade de água para irrigação (com um controle deslizante) e ver os valores dos principais sensores e contadores. Eu dei a interface para uma das linhas, para o resto tudo é o mesmo, apenas nas linhas com sensores de dados com fio é um pouco menos.

Na interface, você pode notar um detalhe "supérfluo" - o sensor auxiliar "A norma foi atingida". Tinha que ser introduzido, porque Não consegui obter condição: o modelo funcionava para interromper a automação quando a norma para a quantidade de água foi atingida e, como resultado, a automação apenas verifica o valor desse sensor. Estou certo de que essa parte da automação pode ser mais simples e elegante, mas meu nível não foi suficiente para isso.

Abaixo está o código para o sensor de gabarito "muleta" resultante:

Sensor de suficiência de rega (dentro de configuration.yaml ou um arquivo separado)
  - platform: template
    sensors:
      line4_status:
        friendly_name: " 4 -  "
        value_template: >-
          {% if states('counter.my_water_line4t')|float > states('input_number.slider4')|float %}
            yes
          {% elif states('counter.my_water_line4t')|float == states('input_number.slider4')|float  %}
            yes
          {% else %}
            no
          {% endif %}


A automação para iniciar a rega acaba sendo assim:

Comece a regar (dentro de automations.yaml ou em um arquivo separado)
- alias:   4   23.01
  trigger:
    platform: time
    at: "23:01:00"
  condition:
   condition: and
   conditions:
#    
    - condition: numeric_state
      entity_id: sensor.rainfor2days
      below: 5
#      
    - condition: numeric_state
      entity_id: sensor.miflora_1_moisture
      below: 50
# ,       
    - condition: state
      entity_id: 'sensor.line4_status'
      state: 'no'
  action:
   - service: switch.turn_on
     entity_id: switch.sistema_poliva_liniia_4


A rega começa no final da noite, com cada linha começando em seu próprio intervalo de tempo. A separação por hora de início permite que você use um medidor de água de entrada para obter dados em 4 linhas.

Na inicialização, três condições são verificadas:

  • O limite da quantidade de água hoje não foi excedido (se, por exemplo, a irrigação manual foi ativada)
  • a umidade excede 50% (de acordo com as observações em nossas condições, o solo recém derramado tem um teor de umidade não superior a 60%)
  • precipitação maior que 5 mm não é esperada nos próximos dois dias.

A próxima automação está desativando a rega:

Desativando a rega (dentro de automations.yaml ou um arquivo separado)
- alias:   4 
  trigger:
#      
  - entity_id: sensor.line4_status
    platform: state
    to: 'yes'
    for: 
      seconds: 5    
#   
  - platform: time
    at: "23:59:00"
#     
  - platform: numeric_state
    entity_id: sensor.miflora_1_moisture
    above: 65
#       
  - platform: state
    entity_id: switch.sistema_poliva_liniia_4
    to: 'on'
    for: 
      minutes: 60
  action:
   - service: switch.turn_off
     entity_id: switch.sistema_poliva_liniia_4


Na automação, foram utilizadas até 4 variantes de gatilhos, mas na maioria dos casos funciona de acordo com o primeiro - um sensor de “muleta”, que monitora o excesso do limite pela quantidade de água. O restante dos gatilhos é feito em grande parte por razões de segurança.

Bem, a última automação relacionada ao problema é redefinir o contador diário

Zerando o contador diário (dentro de automations.yaml ou um arquivo separado)

- alias:    4 
  trigger:
  - platform: time
    at: "00:00:01"
  action:
  - service: counter.reset
    entity_id: counter.my_water_line4t


Economia do projeto


Os custos para a parte de controle do sistema de irrigação foram os seguintes:

(TORTA de framboesa com HassIO a bordo e um roteador WiFi com revestimento no jardim já estavam antes do início do projeto, não os levo em consideração)

Válvula solenóide UNIPUMP BCX-15 1/2 "(normalmente fechada) 4 * 20 euros
Sonoff 4CH 17 euros
Medidor de
pulsações Pulsar 8 euros ESP32 DevKitC 3,5 euros
Sensor capacitivo de umidade do solo v1.2 2 * 0,67 euros
Sensores MiFlora 2 * 16 euros
Guardas, coletores, fios, conexões, todos juntos cerca de 50 euros

TOTAL: cerca de 190 euros

O tempo gasto na configuração dos sensores e MK é de cerca de 15 a 16 horas por várias horas, mas a maior parte do tempo foi gasta em “inventar bicicletas” e em “muletas”, em geral, não há muito trabalho. A montagem física do sistema levou cerca de 2 noites.
Em geral, são esperadas economias de água de cerca de 20 a 50% em comparação com o sistema de timer “bobo” e, a preços locais da água, o sistema deve pagar em uma ou duas estações.

Deficiências e planos de revisão


Como resultado do projeto, algumas nuances e oportunidades para melhorias adicionais foram reveladas.

Em particular, eu substituiria as válvulas solenóides de 220V por um modelo de 24V - essa tensão é padrão para sistemas de irrigação. Nesse caso, você teria que adicionar um transformador de 24V ao sistema e mudar o Sonoff 4Ch para algo com contato seco (por exemplo, Sonoff 4CH Pro ou algo auto-montado). As válvulas são mais baratas (de 8 euros) e reduzem a probabilidade de choque elétrico.

Também ocorreu que, para trabalhar com tubulações de plástico, a pressão do suprimento de água é muito alta e os encaixes podem vazar durante o ciclo de irrigação. No meu caso, isso não é crítico, todos os acessórios estão localizados acima do ponto de irrigação, mas, de uma maneira boa, você precisa adicionar um redutor na entrada para diminuir a pressão.

Fiquei ainda mais chateado com a impossibilidade de contabilizar a quantidade de água para irrigação em volumes inferiores a 10 litros - esse volume é a quantidade mínima mensurável para esse medidor. Esse problema pode ser resolvido desmontando o balcão e trocando as rodas, mas até então as mãos não o alcançaram.

More articles:


All Articles