catfeeder-node.yaml

esphome:
  name: catfeeder-node
  friendly_name: catfeeder-node

esp32:
  board: nodemcu-32s
  framework:
    type: arduino

# Enable logging
logger:
  level: INFO

# Enable Home Assistant API
api:
  services:
    - service: feed_cat
      then:
      - script.execute:
          id: feed_script
          force: true
          servings_current: 1

web_server:
  port: 80

ota:
  password: "c77a50f9d929caf56146ed0e31b0d93b"
  platform: esphome

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Catfeeder-Node Fallback Hotspot"
    password: !secret wifi_fallback_password

captive_portal:
 
output:
  - platform: ledc
    pin: GPIO23
    # frequency: 1000 Hz
    id: pwm_output
  - platform: ledc
    pin: GPIO22
    # frequency: 1000 Hz
    id: pwm_output2
  # - platform: ledc
  #   pin: GPIO4
  #   frequency: 1000 Hz
  #   id: motor_enable

fan:
  - platform: hbridge
    id: serving_motor
    name: "Cat Feeder"
    pin_a: pwm_output
    pin_b: pwm_output2
    # enable_pin: motor_enable
    # decay_mode: slow
    # internal: True
    restore_mode: ALWAYS_OFF 
    on_turn_on:
      - fan.turn_on: 
          id: serving_motor
          speed: 100

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO15
      mode:
        input: true
        pullup: true
      inverted: true
    id: feed_clicker
    name: "Feed Clicker"
    internal: True

switch:
  - platform: restart
    name: "Cat Feeder Restart"
  - platform: template
    name: "Skip Next Meal"
    id: skip_next_meal
    optimistic: True
    restore_mode: RESTORE_DEFAULT_OFF
  - platform: template
    name: "Calculate servings by refill"
    id: calculate_by_refill
    optimistic: True

number:
  - platform: template
    id: max_servings_per_day
    name: "Max Servings per day"
    optimistic: true
    min_value: 1
    max_value: 20
    restore_value: True
    initial_value: 12
    step: 1
  - platform: template
    name: "Grams per day"
    id: grams_per_day
    optimistic: true
    min_value: 60
    max_value: 130
    restore_value: True
    initial_value: 115
    step: 5
    device_class: "weight"
  - platform: template
    name: "Grams per serving"
    id: grams_per_serving
    optimistic: true
    min_value: 5
    max_value: 20
    restore_value: True
    initial_value: 7
    step: 0.1
    device_class: "weight"
  - platform: template
    name: "Refill size"
    id: refill_size
    optimistic: true
    min_value: 0
    max_value: 4000
    restore_value: False
    initial_value: 0
    step: 10
    device_class: "weight"
  - platform: template
    name: "Grams per serving (Calculated)"
    id: grams_per_serving_calculated
    optimistic: true
    internal: True
    min_value: 0
    max_value: 100
    restore_value: True
    initial_value: 0
    step: 0.1
    device_class: "weight"
  - platform: template
    name: "Last Refill size"
    id: last_refill_size
    optimistic: true
    internal: True
    min_value: 0
    max_value: 4000
    restore_value: True
    step: 10
    device_class: "weight"
  - platform: template
    name: "Servings today"
    id: servings_today
    optimistic: true
    min_value: 0
    max_value: 100
    restore_value: True
    initial_value: 0
    step: 1
    internal: true
    on_value:
      then:
      - sensor.template.publish:
          id: servings_today_sensor
          state: !lambda 'return x;'
  - platform: template
    name: "Servings since refill"
    id: servings_since_refill
    optimistic: true
    min_value: 0
    max_value: 1000
    restore_value: True
    initial_value: 0
    step: 1
    internal: True
    on_value:
      then:
      - sensor.template.publish:
          id: servings_since_refill_sensor
          state: !lambda 'return x;'
  - platform: template
    name: "Servings total"
    id: servings_total
    optimistic: true
    min_value: 0
    max_value: 1000000
    restore_value: True
    initial_value: 0
    step: 1
    internal: true
    on_value:
      then:
      - sensor.template.publish:
          id: servings_total_sensor
          state: !lambda 'return x;'
  - platform: template
    name: "Active servings"
    id: active_servings
    optimistic: true
    min_value: 0
    max_value: 10
    step: 1
    internal: true
    on_value:
      then:
      - sensor.template.publish:
          id: active_servings_sensor
          state: !lambda return x;
  - platform: template
    name: "Bonus treats internal"
    id: bonus_treats_internal
    optimistic: true
    min_value: 0
    max_value: 10
    restore_value: True
    step: 1
    internal: true

script:
  - id: feed_script
    mode: restart
    parameters:
      servings_current: int
      force: bool
    then:
      - if:
          condition:
            - or:
              - lambda: !lambda return force;
              - and:
                - lambda: !lambda return int(id(servings_today).state) < int(id(max_servings_per_day).state);
                - switch.is_off: skip_next_meal
          then:
            - number.set:
                id: active_servings
                value: !lambda 'return servings_current;'
            - while:
                condition:
                  lambda: |-
                    return id(active_servings).state > 0;
                then:
                  - if:
                      condition:
                        - lambda: !lambda return int(id(servings_today).state) > int(id(max_servings_per_day).state);
                      then:
                        - logger.log:
                            format: "Max servigns reached= %f"
                            args: [ 'id(servings_today).state' ]
                            level: INFO
                        - number.decrement: active_servings
                      else:
                        - logger.log:
                            format: "Feeding meal active= %f, total= %f, skip=%d, max=%f, today=%f"
                            args: [ 'id(active_servings).state', 'id(servings).state', 'id(skip_next_meal).state', 'id(max_servings_per_day).state', 'id(servings_today).state']
                            level: INFO
                        - sensor.template.publish:
                            id: active_servings_sensor
                            state: !lambda 'return id(active_servings).state;'
                        - fan.turn_on: 
                            id: serving_motor
                        - if:
                            condition:
                              binary_sensor.is_on: feed_clicker
                            then:
                            - wait_until:
                                binary_sensor.is_off: feed_clicker
                            - wait_until:
                                binary_sensor.is_on: feed_clicker
                            - wait_until:
                                binary_sensor.is_off: feed_clicker
                            - fan.turn_off: serving_motor
                            else:
                            - wait_until:
                                binary_sensor.is_on: feed_clicker
                            - wait_until:
                                binary_sensor.is_off: feed_clicker
                            - fan.turn_off: serving_motor
                        - number.increment: servings_today
                        - number.increment: servings_since_refill
                        - number.increment: servings_total
                        - number.decrement: active_servings
                        - text_sensor.template.publish:
                            id: last_feed
                            state: !lambda |-
                              auto timeSting = id(sntp_time).now().strftime("%c");
                              return timeSting;
                        - delay: 300s
            - number.to_min: active_servings
      - if:
          condition:
            lambda: !lambda return !force;
          then:
          - logger.log: "Resetting skip next meal"
          - switch.template.publish:
              id: skip_next_meal
              state: OFF

button:
  - platform: template
    name: Reset Refill
    on_press:
      then:
        - number.set:
            id: last_refill_size
            value: 0
        - number.set:
            id: refill_size
            value: 0
        - number.set:
            id: grams_per_serving_calculated
            value: 0
  - platform: template
    name: Save Refill
    on_press:
      - if:
          condition:
            lambda: 'return id(servings_since_refill).state > 0;'
          then:
            - number.set:
                id: last_refill_size
                value: !lambda 'return id(refill_size).state;'
            - number.set:
                id: grams_per_serving_calculated
                value: !lambda 'return id(last_refill_size).state / id(servings_since_refill).state;'
            - number.set:
                id: servings_since_refill
                value: !lambda 'return 0;'
  - platform: template
    name: Feed Single
    id: feed_single
    on_press:
      then:
      - script.execute:
          id: feed_script
          force: true
          servings_current: 1
      - number.increment: bonus_treats_internal
  - platform: template
    name: Feed Meal
    id: feed_meal
    on_press:
      then:
      - switch.template.publish:
          id: skip_next_meal
          state: Off
      - script.execute:
          id: feed_script
          force: true
          servings_current: !lambda 'return id(servings).state;'
      - switch.template.publish:
          id: skip_next_meal
          state: On

time:
  - platform: sntp
    id: sntp_time
    on_time:
      # Every morning on weekdays
      - seconds: 0
        minutes: 0
        hours: 0
        then:
          - number.to_min: servings_today
          - number.to_min: bonus_treats_internal
  - platform: sntp
    on_time:
      - hours: 7,16,21
        seconds: 0
        minutes: 0
        then:
          - script.execute:
              id: feed_script
              force: false
              servings_current: !lambda 'return id(servings).state;'

text_sensor:
  - platform: template
    name: "Last feed"
    id: last_feed
  - platform: template
    name: "Feed schedule"
    lambda: !lambda |-
      return {"07:00, 16:00, 21:00"};
  - platform: template
    name: "Next feed"
    update_interval: 1s
    lambda: !lambda |-
      int current_hour = id(sntp_time).now().hour;
      std::vector<int> ordered_list = {7, 16, 21};
      bool skip_next_higher = id(skip_next_meal).state;

      int next_hour = 0;
      bool found = false;

      for (size_t i = 0; i < ordered_list.size(); i++) {
          if (ordered_list[i] > current_hour) {
              if (skip_next_higher) {
                  if (i + 1 < ordered_list.size()) {
                      next_hour = ordered_list[i + 1];
                  } else {
                      next_hour = ordered_list[0]; // Wrap around to 0
                  }
              } else {
                  next_hour = ordered_list[i];
              }
              found = true;
              break;
          }
      }
      if (!found) {
        // Set next_hour based on some default logic since no higher hour was found
        // For example, setting it to the first hour in the ordered_list
        next_hour = ordered_list[0];
      }
      std::string period = (next_hour >= 12) ? "PM" : "AM";
      int hour12 = (next_hour > 12) ? next_hour - 12 : next_hour;
      if (hour12 == 0) {
          hour12 = 12;
      }
      return std::to_string(hour12) + ":00 " + period;
sensor:
  - platform: template
    name: "Active Servings"
    id: active_servings_sensor
    state_class: "measurement"
  - platform: template
    name: "Servings per day"
    id: servings_per_day
    state_class: "measurement"
    update_interval: 1s
    lambda: !lambda |-
      return id(grams_per_day).state / id(grams_per_serving).state;
  - platform: template
    name: "Servings per day (calculated)"
    id: servings_per_day_calculated
    state_class: "measurement"
    lambda: !lambda |-
      return id(grams_per_day).state / id(grams_per_serving_calculated).state;
  - platform: template
    name: "Servings per meal"
    id: servings
    state_class: "measurement"
    update_interval: 1s
    lambda: !lambda |-
      float feed_count = 3;
      if(id(grams_per_serving_calculated).has_state() && id(grams_per_serving_calculated).state > 0 && id(calculate_by_refill).state) {
        return floor(id(servings_per_day_calculated).state / feed_count);
      }
      return floor(id(servings_per_day).state / feed_count);
  - platform: template
    name: "Servings today"
    id: servings_today_sensor
    state_class: "total_increasing"
  - platform: template
    id: servings_total_sensor
    name: "Servings total"
    state_class: "total"
  - platform: template
    id: servings_since_refill_sensor
    name: "Servings Since Refill"
    state_class: "total_increasing"
  - platform: template
    id: last_refill_size_sensor
    name: "Last refill size"
    lambda: !lambda |-
      return id(last_refill_size).state;
  - platform: template
    id: grams_per_serving_calculated_sensor
    name: "Grams per Serving (Calculated)"
    lambda: !lambda |-
      return id(grams_per_serving_calculated).state;
  - platform: template
    name: "Bonus treats today"
    id: bonus_treats
    state_class: "measurement"
    lambda: !lambda |-
      return id(bonus_treats_internal).state;