as_ezo_ec.yaml

substitutions:
  include_dependencies_as_ezo_ec: "defined"
  include_dependency_1: ${include_dependencies_as_ezo_rtd}

############################################################
##
##  INITIALIZE SENSOR STATES FROM LAST BOOT
##
############################################################
esphome:
  on_boot:
    priority: -200 # Highest priority, ensures enable pin to be turned off first
    then:
      - lambda: |-
          id(${device_name}_ec).set_sensor_type(esphome::ezo::SENSOR_TYPE_EC);
          
          /***************************************************************
          * enable/disable sensors depending on last boot sensor states
          ***************************************************************/
          
          //always on, since turning off leads to problems with i2c communication sometimes
          //id(${device_name}_ec_enable_pin).turn_off();
          id(${device_name}_ec_enable).turn_on();
          
          //if(id(ec_enabled))
          //  id(${device_name}_ec_enable).turn_on();
          //else
          //  id(${device_name}_ec_enable).turn_off(); 
            
          /***************************************************************
          * enable/disable temp compensation depending on last boot states
          ***************************************************************/  
          if(id(ec_tempcomp_enabled))
            id(${device_name}_ec_tempcomp).turn_on();
          else
            id(${device_name}_ec_tempcomp).turn_off();
            
          /***************************************************************
          * enable/disable value sending
          ***************************************************************/  
          
          if(id(ec_reading_enabled))
            id(${device_name}_ec_enable_reading_values).turn_on();
          else
            id(${device_name}_ec_enable_reading_values).turn_off();

sensor:

  # SENSOR DEFINITION      
  - platform: custom_ezo
    id: ${device_name}_ec
    name: ${device_name_upper}.ec
    address: 100
    accuracy_decimals: 2
    unit_of_measurement: "μS/cm"
    update_interval: 0.1s
    internal: ${entities_internal}
    filters:
    - sliding_window_moving_average:
        window_size: ${sliding_window_size_ec}
        send_every: ${sliding_window_send_every_ec}
    
globals:
   
   # PERMANENT GLOBALS FOR STATE STORAGE
   - id: ec_enabled
     type: bool
     restore_value: yes
     initial_value: 'true'
   
   - id: ec_reading_enabled
     type: bool
     restore_value: yes
     initial_value: 'true'

   - id: ec_tempcomp_enabled
     type: bool
     restore_value: yes
     initial_value: 'true'
  
   - id: ec_tempcomp_timestamp_0
     type: int
     restore_value: no
     initial_value: '0' 

output:
  
  # ENABLE PIN
  - platform: gpio
    pin: ${enable_ec_pin}
    id: ${device_name}_ec_enable_pin

switch:
  
  # TEMPERATURE COMPENSATION
  - platform: template
    name: ${device_name_upper}.ec.tempcomp
    id: ${device_name}_ec_tempcomp
    lambda: |-
      return id(ec_tempcomp_enabled);
    turn_on_action:
      - lambda: |-
          id(ec_tempcomp_enabled) = true;
          id(ec_tempcomp_timestamp_0) = millis();
    turn_off_action:
      - lambda: |-
          id(ec_tempcomp_enabled) = false;
  
          
  # CALIBRATION MODE
  - platform: template
    name: ${device_name_upper}.ec.cal.activate
    id: ${device_name}_ec_cal_activate
    restore_state: "true"
    lambda: |-
      return id(${device_name}_ec).calibration_mode_active();
    turn_on_action:
      - lambda: |-
          id(${device_name}_ec).activate_calibration();
      
    turn_off_action:
      - lambda: |-
          id(${device_name}_ec).deactivate_calibration();
    internal: ${entities_internal}
    
  # ENABLE/DISABLE SENSOR
  - platform: template
    id: ${device_name}_ec_enable
    name: ${device_name_upper}.ec.enable
    internal: "true"
    lambda: |-
      return id(ec_enabled);
    turn_on_action:
      - lambda: |-
          id(${device_name}_ec).enable_sensor();
      - globals.set:
          id: ec_enabled
          value: "true"
      - output.turn_off: ${device_name}_ec_enable_pin
      - switch.turn_on: ${device_name}_rtd_enable
    turn_off_action:
      - lambda: |-
          id(${device_name}_ec).disable_sensor();
      - globals.set:
          id: ec_enabled
          value: "false"
      - output.turn_on: ${device_name}_ec_enable_pin 

  # ENABLE / DISABLE VALUE SENDING
  - platform: template
    id: ${device_name}_ec_enable_reading_values
    name: ${device_name_upper}.ec.enable_reading_values
    lambda: |-
      return id(${device_name}_ec).sending_values();
    turn_on_action:
      - lambda: |-
          id(${device_name}_ec).enable_sending_values();
          id(ec_reading_enabled) = true;
    turn_off_action:
      - lambda: |-
          id(${device_name}_ec).disable_sending_values();
          id(ec_reading_enabled) = false;

button:

  # CALIBRATION METHODS
  - platform: template
    name: ${device_name_upper}.ec.cal.check
    id: ${device_name}_ec_cal_check
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_check(); 
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.cal.clear
    id: ${device_name}_ec_cal_clear
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_clear();  
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.cal.dry
    id: ${device_name}_ec_cal_dry
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_ec_dry(); 
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.cal.single_point
    id: ${device_name}_ec_cal_single_point
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_ec();   
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.cal.high
    id: ${device_name}_ec_cal_high
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_ec_high();
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.cal.low
    id: ${device_name}_ec_cal_low
    on_press:
      lambda: |-
        id(${device_name}_ec).start_calibration_ec_low();  
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.k_value.check
    id: ${device_name}_ec_k_value_check
    on_press:
      lambda: |-
        id(${device_name}_ec).start_send_ec_k_value(); 
    internal: ${entities_internal}
    
  - platform: template
    name: ${device_name_upper}.ec.k_value.send
    id: ${device_name}_ec_k_value_send
    on_press:
      lambda: |-
        id(${device_name}_ec).start_check_ec_k_value();
    internal: ${entities_internal}
    
  # FACTORY RESET
  - platform: template
    name: ${device_name_upper}.ec.factory_reset
    id: ${device_name}_ec_factory_reset
    on_press:
      lambda: |-
        id(${device_name}_ec).start_factory_reset();
    internal: ${entities_internal}
    
number:

  # SAMPLE INTERVAL TIME IN [MS]
  - platform: template
    min_value: ${min_sample_interval_ec}
    max_value: ${max_sample_interval_ec}
    step: "1"
    id: ${device_name}_ec_sample_interval
    name: ${device_name}.ec.sample_interval
    optimistic: true
    mode: box
    restore_value : true
    initial_value: ${min_sample_interval_ec}
    update_interval: "10s"
    unit_of_measurement: "ms"
    on_value:
      - lambda: |-
         id(${device_name}_ec).set_sample_interval(x);
  
  # TEMPCOMP INTERVAL TIME IN [MS]
  - platform: template
    min_value: ${min_sample_interval_ec_tempcomp}
    max_value: ${max_sample_interval_ec_tempcomp}
    step: "1"
    id: ${device_name}_ec_tempcomp_sample_interval
    name: ${device_name}.ec.tempcomp.sample_interval
    optimistic: true
    mode: box
    restore_value : true
    initial_value: ${min_sample_interval_ec_tempcomp}
    update_interval: "10s"
    unit_of_measurement: "ms"
  
  # CALIBRATION POINTS
  - platform: template
    min_value: "0"
    max_value: "100000.0"
    step: "0.01"
    id: ${device_name}_ec_cal_single_value
    name: ${device_name}.ec.cal.single_value
    optimistic: true
    mode: box
    restore_value : true
    initial_value: "80000.0"
    update_interval: "10s"
    unit_of_measurement: "S/m"
    on_value:
      - lambda: |-
         id(${device_name}_ec).set_ec_cal_value(x);  
    internal: ${entities_internal}
    
  - platform: template
    min_value: "0"
    max_value: "100000.0"
    step: "0.01"
    id: ${device_name}_ec_cal_high_value
    name: ${device_name}.ec.cal.high_value
    optimistic: true
    mode: box
    restore_value : true
    initial_value: "80000.0"
    update_interval: "10s"
    unit_of_measurement: "S/m"
    on_value:
      - lambda: |-
         id(${device_name}_ec).set_ec_cal_high_value(x);   
    internal: ${entities_internal}
    
  - platform: template
    min_value: "0"
    max_value: "100000.0"
    step: "0.01"
    id: ${device_name}_ec_cal_low_value
    name: ${device_name}.ec.cal.low_value
    optimistic: true
    mode: box
    restore_value : true
    initial_value: "12880.0"
    update_interval: "10s"
    unit_of_measurement: "S/m"
    on_value:
      - lambda: |-
         id(${device_name}_ec).set_ec_cal_low_value(x);   
    internal: ${entities_internal}
    
  - platform: template
    min_value: "0.1"
    max_value: "10.0"
    step: "0.01"
    id: ${device_name}_ec_k_value
    name: ${device_name}.ec.k_value
    optimistic: true
    mode: box
    restore_value : true
    initial_value: "1.0"
    update_interval: "10s"
    unit_of_measurement: ""
    on_value:
      - lambda: |-
         id(${device_name}_ec).set_ec_k_value(x); 
    internal: ${entities_internal}
    
binary_sensor:

  # ERROR CHECKING SENSOR
  #- platform: template
  #  name: "${device_name_upper}.ec.error"
  #  id: ${device_name}_ec_error
  #  lambda: |-
  #    if (id(${device_name}_ec).retry_counter() >= ${max_retry_attempts})
  #    {
  #       return true;
  #    }else
  #    {
  #      return false;
  #    }
  #  on_press:
  #    then:
  #      if:
  #        condition:
  #          lambda: |-
  #            return id(rtd_enabled);
  #        then:
  #          - switch.turn_off: ${device_name}_ec_enable
  #          - delay: 2s
  #          - switch.turn_on: ${device_name}_ec_enable
    
interval:

  # TEMPCOMP SET INTERVAL
  - interval: 1s
    then:
      lambda: |-
        if (id(ec_tempcomp_enabled))
        {
          int time_now = millis();
          // integer overflow protection -> restart waiting timer -> (TODO: maybe implement exact value reset via max integer)
          if (time_now < id(ec_tempcomp_timestamp_0))
          	id(ec_tempcomp_timestamp_0) = time_now;
          
          // check if we should send a sample
          if (time_now - id(ec_tempcomp_timestamp_0) >= id(${device_name}_ec_tempcomp_sample_interval).state)
          {
            id(${device_name}_ec).set_tempcomp_value(id(${device_name}_rtd).state);
            id(ec_tempcomp_timestamp_0) = time_now;
          }
        }
        else
        {
          id(${device_name}_ec).set_tempcomp_value(${default_temp_comp_value});
        }