Using Home Assistant to Balance Humidity for Comfort and Window Condensation Risk

The first winter in our house was a challenge figuring out where to set the house humidifier connected to our furnace. How do you balance comfortable humidity against the risk of window condensation? I really had no idea and it was common to see water or ice on the inside of our windows during the coldest days.

I had wired our house humidifier through the furnace so I could use the Ecobee thermostat to control it. The Ecobee has a setting called “Front Control,” but it does a poor job balancing for comfort.

Screenshot

Remember this recommended humidity level for later.

Screenshot

Going from 36% to 45% is a large difference. From my testing, the humidity reported by Ecobee is 4-5 percentage points too high, which is also part of the problem and makes the air even drier. I wanted to do better and let Home Assistant handle everything.

First I bought a device with good reviews to be my source of truth and set it in the living room. It’s the Govee H5075 Bluetooth Digital Hygrometer and connects to Home Assistant via an ESPHome Bluetooth Proxy.

Since we don’t use the humidifier all year, the first step was to create a Toggle (or Input Boolean) helper. I’ll manually change this when I enable/disable the humidifier in the Ecobee settings.

I installed the Thermal Comfort integration to calculate the indoor dew point and the OpenWeatherMap integration with their One Call API 3.0 for fetching weather forecasts. I use a trigger template in templates.yaml to store the forecast every hour and whenever Home Assistant starts.

- trigger:
    - platform: time_pattern
      minutes: "/59"
    - platform: homeassistant
      event: start
  action:
    - service: weather.get_forecasts
      data:
        type: hourly
      target:
        entity_id: weather.openweathermap
      response_variable: hourly_forecast
  sensor:
    - name: "Weather Forecast Storage"
      unique_id: weather_forecast_storage
      icon: mdi:weather-cloudy
      state: "{{ states('weather.openweathermap') }}"
      attributes:
        forecast: "{{ hourly_forecast['weather.openweathermap'].forecast }}"

The forecast is important because I don’t want to set the humidity too high and not have enough time for the house to dry out when a cold front moves in. I added another trigger template in templates.yaml, which grabs the low temperature over the next 12 hours, estimates window glass temperature, calculates an ideal indoor humidity, and determines an offset between the trusted and Ecobee humidity values. It does all of this every 15 minutes, when Home Assistant starts, and whenever there is a change to various temperature or humidity values.

- trigger:
    - platform: time_pattern
      minutes: "/15"
    - platform: homeassistant
      event: start
    - platform: state
      entity_id: 
        - sensor.living_room_govee_temperature
        - sensor.living_room_govee_humidity
        - sensor.openweathermap_temperature
        - sensor.thermostat_current_temperature
        - sensor.thermostat_current_humidity
      for:
        seconds: 10
  sensor:
    - name: "Calculated Ideal Humidity"
      unique_id: calculated_ideal_humidity
      unit_of_measurement: "%"
      variables:
        forecast: "{{ state_attr('sensor.weather_forecast_storage', 'forecast') }}"
        has_data: "{{ forecast is not none }}"
        outdoor: "{{ (forecast[1:12] | map(attribute='temperature') | min | float(50)) if has_data else 50 }}"
        indoor: "{{ states('sensor.living_room_govee_temperature') | float(70) }}"
        glass: "{{ (outdoor + (indoor - outdoor) * 0.6) | round(1) }}" # 0.6 should be adjusted based on window efficiency
        ideal_raw: "{{ (0.8 * glass) | int(35) }}"
        ideal_final: "{{ ([25, ideal_raw, 50] | sort)[1] }}"
        
        govee_h: "{{ states('sensor.living_room_govee_humidity') | float(30) }}"
        ecobee_h: "{{ state_attr('climate.thermostat', 'current_humidity') | float(30) }}"
        offset: "{{ ecobee_h - govee_h }}"
        comp_target: "{{ ([25, (ideal_final + offset) | int(35), 50] | sort)[1] }}"

      state: "{{ ideal_final if has_data else states('sensor.calculated_ideal_humidity') }}"
      
      attributes:
        glass_temp_estimate: "{{ glass }}"
        predicted_outdoor_temp: "{{ outdoor }}"
        forecast_window: "Next 12 Hours"
        ecobee_compensated_target: "{{ comp_target }}"
        last_calculation: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"

With this data calculated and saved, an automation takes care of updating the humidity setpoint on the Ecobee thermostat. Whenever I have the Humidifier Enabled toggle on, it’ll update the setpoint every 30 minutes and whenever the Calculated Ideal Humidity changes.

alias: Set Thermostat Humidity
triggers:
  - entity_id: sensor.calculated_ideal_humidity
    trigger: state
  - minutes: /30
    trigger: time_pattern
conditions:
  - condition: and
    conditions:
      - condition: state
        entity_id: input_boolean.humidifier_enabled
        state:
          - "on"
      - condition: template
        value_template: >-
          {{ state_attr('sensor.calculated_ideal_humidity',
          'ecobee_compensated_target') is not none }}
        alias: Ecobee Compensated Target is not None
actions:
  - target:
      entity_id: climate.thermostat
    data:
      humidity: >-
        {{ state_attr('sensor.calculated_ideal_humidity',
        'ecobee_compensated_target') | int(35) }}
    action: climate.set_humidity
mode: restart

I added a card on my dashboard to see the status of everything. This was invaluable when I was testing and tweaking for several weeks.

Remember the Ecobee’s recommended 36%?! If I went by that, the actual humidity in the house at this time would have about 32%, a whole 10 percentage points dryer! Here’s the YAML for the dashboard card.

type: conditional
conditions:
  - condition: state
    entity: input_boolean.humidifier_enabled
    state: "on"
card:
  type: markdown
  content: |2-
      {% set glass_temp = state_attr('sensor.calculated_ideal_humidity', 'glass_temp_estimate') | float(0) | round (0) %}
      {% set dew_point = states('sensor.thermal_comfort_dew_point') | float(0) | round(0) %}
      {% set ideal_hum = states('sensor.calculated_ideal_humidity') | float(0) | round(0) %}
      {% set actual_hum = states('sensor.living_room_govee_humidity') | float(0) | round(0) %}
      {% set thermostat_hum = state_attr( 'climate.thermostat', 'current_humidity' ) | float(0) | round(0) %}
      {% set target_hum = state_attr( 'sensor.calculated_ideal_humidity', 'ecobee_compensated_target' ) | float(0) | round(0) %}
      {% set future_temp = state_attr('sensor.calculated_ideal_humidity', 'predicted_outdoor_temp') | round (0) %}

      ## Window Condensation Status
      {% if ( glass_temp > dew_point ) %}
      #### ✅ No Risk
      {% else %}
      #### ⚠️ Risk
      {% endif %}

      **Glass:** {{ glass_temp }}°
      **Dew Point:** {{ dew_point }}°

      **12hr Forecast Low:** {{ future_temp }}°

      ---

      ### Humidity
      {% if ( actual_hum > ideal_hum ) %}
      ⚠️ Too Humid
      {% elif ( actual_hum < ideal_hum ) %}
      💧 Too Dry
      {% else %}
      ✅ Good
      {% endif %}

      | | Current | Target |
      | :--- | :---: | :---: |
      | **Actual** | {{ actual_hum }}% | {{ ideal_hum }}% |
      | **Ecobee** | {{ thermostat_hum }}% | {{ target_hum }}% |

The windows are so much better this winter and our static shocks are limited. If you have any suggested improvements, leave a comment.

Reading Badger Water Meter Data for Home Assistant

If you have Badger water meters with the Orion Endpoint GIF2014W-OSE, this post should help you read the data for use in Home Assistant. Here is what my meters look like. I have separate lines and meters for the house and outdoor, since they get charged at different rates.

The GIF2014W-OSE broadcasts data from the water meter over radio frequency (RF). Monthly or quarterly the township water department drives around neighborhoods reading these RF signals to determine everyone’s water usage. You can read the same data with a software defined radio (SDR). I’m using a RTL-SDR Blog V4 dongle with a 915MHz LoRa Antenna and ferrite beads (to filter noise) on a USB extension cable. It plugs directly in to my Home Assistant server.

If you want to test the SDR on your computer before setting everything up in Home Assistant check out the rtl_433 repo on GitHub.

To get started in HA, make sure you’re running a MQTT broker. I use the recommended Mosquitto broker. Install the MQTT Explorer and rtl_433 (next) apps. Note, the main rtl_433 HA app wasn’t updated yet with the latest version of rtl_433, which is needed for the GIF2014W-OSE, so that’s why I had to use the (next) version. It may be updated by the time you’re reading this.

The configuration for the rtl_433 (next) app is stored in a file. I have mine at /homeassistant/rtl_433/rtl_433.conf and here is how my app configuration looks.

Below is a good start for the config file’s contents. Put in your IP address, user, and password.

sample_rate 1600k
gain 28
hop_interval 22
pulse_detect autolevel
pulse_detect minlevel=-35
report_meta level
report_meta noise
report_meta stats:1
output mqtt://[MQTT_IP],user=[MQTT_USER],pass=[MQTT_PASSWORD],retain=1

protocol 282

frequency 905.3M
frequency 906.1M
frequency 906.9M
frequency 907.7M
frequency 908.5M
frequency 909.3M
frequency 910.1M
frequency 910.9M
frequency 911.7M
frequency 912.5M
frequency 913.3M
frequency 914.1M
frequency 914.9M
frequency 915.7M
frequency 916.5M
frequency 917.3M
frequency 918.1M
frequency 918.9M
frequency 919.7M
frequency 920.5M
frequency 921.3M
frequency 922.1M
frequency 922.9M
frequency 923.7M

The water meter endpoint broadcasts across the range of 904.4 to 924.6Mhz and this is going to hop between the 24 frequencies (taken from a GitHub comment) listed in the config every 22 seconds. You may need to tweak the gain, pulse_detect, and other settings depending on your setup. Use your favorite AI to help. If you these next couple of lines to the config file you can see more of what happening, but I wouldn’t leave these in after everything is working.

verbose 7
output json
output log

You can view the HA app’s logs to see more details. When everything is running, open up MQTT Explorer and look for the rtl_433 topics. Hopefully within an hour or two you’ll see something similar to this.

In this screenshot 40338908 and 40313961 are the ids for my meter endpoints. You may see a bunch of other ids for other meters in your neighborhood. You may have physical tags on the devices with their IDs or you can compare the reading values to what is displayed on the water meter.

Now this data can be brought in to Home Assistant. It’ll take some tinkering and customization to fit it all for your HA install. I’m also writing this over a week after setting everything up, so I don’t remember the order of adding everything, but you should be able to do most of it at once and restart. Make sure to update the name, unique_id, source, and state everywhere to fit your needs. The state_topic‘s need to match what you see in MQTT Explorer, and any other cross references have to match your renames. Only use what applies to your situation. If you only have one meter, remove all the outdoor/sprinkler stuff. I’m scraping the Saginaw Township water rates from their web site, so that stuff is going to be very custom, but gives you an idea of what you can do.

In configuration.yaml:

mqtt:
  binary_sensor:
    - name: "House Water Meter Leak"
      unique_id: "house_water_meter_leak"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313908/leaking"
      payload_on: "1"
      payload_off: "0"
      device_class: moisture
    - name: "Outdoor Water Meter Leak"
      unique_id: "outdoor_water_meter_leak"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313961/leaking"
      payload_on: "1"
      payload_off: "0"
      device_class: moisture
  sensor:
    - name: "House - Water Meter"
      unique_id: "house_water_meter"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313908/reading"
      unit_of_measurement: "gal"
      device_class: water
      state_class: total_increasing
      icon: mdi:water-pump
      value_template: "{{ value | float(0) / 10 }}"
    - name: "House - Water Meter Daily Snap"
      unique_id: "house_water_meter_daily_snap"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313908/daily_reading"
      device_class: water
      state_class: total
      unit_of_measurement: "gal"
      entity_category: diagnostic
      icon: mdi:history
      value_template: "{{ value | float(0) / 10 }}"
    - name: "House - Water Meter - Freq 1"
      unique_id: "house_water_meter_freq1"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313908/freq1"
      value_template: "{{ value | float(0) }}"
      unit_of_measurement: "MHz"
      state_class: measurement
      device_class: frequency
    - name: "House - Water Meter - Freq 2"
      unique_id: "house_water_meter_freq2"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313908/freq2"
      value_template: "{{ value | float(0) }}"
      unit_of_measurement: "MHz"
      state_class: measurement
      device_class: frequency
    - name: "Outdoor - Water Meter"
      unique_id: "water_meter_outdoor"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313961/reading"
      unit_of_measurement: "gal"
      device_class: water
      state_class: total_increasing
      icon: mdi:water-pump
      value_template: "{{ value | float(0) / 10 }}"
    - name: "Outdoor - Water Meter Daily Snap"
      unique_id: "outdoor_water_meter_daily_snap"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313961/daily_reading"
      device_class: water
      state_class: total
      unit_of_measurement: "gal"
      entity_category: diagnostic
      icon: mdi:history
      value_template: "{{ value | float(0) / 10 }}"
    - name: "Outdoor - Water Meter - Freq 1"
      unique_id: "outdoor_water_meter_freq1"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313961/freq1"
      value_template: "{{ value | float(0) }}"
      unit_of_measurement: "MHz"
      state_class: measurement
      device_class: frequency
    - name: "Outdoor - Water Meter - Freq 2"
      unique_id: "outdoor_water_meter_freq2"
      state_topic: "rtl_433/9b13b3f4-rtl433-next/devices/Orion-Endpoint/40313961/freq2"
      value_template: "{{ value | float(0) }}"
      unit_of_measurement: "MHz"
      state_class: measurement
      device_class: frequency

scrape:
  - resource: https://saginawtownship.org/departments/public_services/water_distribution.php
    scan_interval: 86400 
    sensor:
      - name: "Saginaw House Water Rate Raw"
        select: "article ul li"
        index: 2
        value_template: >
          {{ value | regex_findall_index('Combined:\s*\$?\s*(\d+\.\d+)', ignorecase=True) }}
      - name: "Saginaw Outdoor Water Rate Raw"
        select: "article ul li"
        index: 2
        value_template: >
          {{ value | regex_findall_index('\(Sprinkler Meter\)\s*\$?\s*(\d+\.\d+)', ignorecase=True) }}

utility_meter:
  house_daily_water:
    name: "House Daily Water"
    unique_id: house_daily_water
    source: sensor.house_water_meter
    cycle: daily
    always_available: true
  outdoor_daily_water:
    name: "Outdoor Daily Water"
    unique_id: outdoor_daily_water
    source: sensor.water_meter_outdoor
    cycle: daily
    always_available: true

In templates.yaml:

- binary_sensor:
  - name: "Outdoor Water Flowing Hourly"
    unique_id: outdoor_water_flowing_hourly
    device_class: moving
    state: >
      {{ states('sensor.outdoor_water_hourly_change') | float(0) > 0 }}
  - name: "House Water Flowing Hourly"
    unique_id: house_water_flowing_hourly
    device_class: moving
    state: >
      {{ states('sensor.house_water_hourly_change') | float(0) > 0 }}
  - name: "Sprinklers Watering"
    unique_id: sprinklers_watering
    device_class: running
    state: >
      {{ is_state('binary_sensor.sprinkler_zone_1_watering', 'on')
         or is_state('binary_sensor.sprinkler_zone_2_watering', 'on')
         or is_state('binary_sensor.sprinkler_zone_3_watering', 'on')
         or is_state('binary_sensor.sprinkler_zone_4_watering', 'on')
         or is_state('binary_sensor.sprinkler_zone_5_watering', 'on')
         or is_state('binary_sensor.sprinkler_zone_6_watering', 'on') }}
  - name: "Outdoor Water Leak Persistent"
    unique_id: outdoor_water_leak_persistent
    device_class: problem
    delay_on: "02:00:00"
    state: >
      {% set water_usage = states('sensor.outdoor_water_hourly_change') | float(0) > 0 %}
      {% set sprinklers_active = states('sensor.sprinklers_active_last_hour') | float(0) > 0 %}

      {{ water_usage and not sprinklers_active }}
  - name: "House Water Nightly Leak Possible"
    unique_id: house_water_nightly_leak_possible
    device_class: problem
    state: >
    
      {% if now().hour == 6 and now().minute == 0 %}
        {# If water usage increased 7/9 hours from 9p-6a #}
        {# (allowing for minor signal lag and missed reads) #}
        {{ states('sensor.house_water_flowing_9_hours') | float(0) > 6.8 }}
      {% else %}
        {{ states('binary_sensor.house_water_nightly_leak_possible') }}
      {% endif %}

In automations.yaml:

- id: '1770044944973'
  alias: Notify - Water Meter Leak Detected
  description: ''
  triggers:
  - trigger: state
    entity_id:
    - binary_sensor.house_water_meter_leak
    - binary_sensor.outdoor_water_meter_leak
    from:
    - 'off'
    to:
    - 'on'
  actions:
  - action: notify.mobile_app_nickphone
    metadata: {}
    data:
      title: "\U0001F6B0 Water Leak Flag Detected!"
      message: The internal leak flag for {{ trigger.to_state.name }} has been triggered.            This
        usually indicates continuous flow for the last 24 hours.
      data:
        priority: high
        ttl: 0
- id: '1770082584926'
  alias: Notify - Outdoor Water Leak
  description: Alerts family when unexplained water flow persists for 2 hours
  triggers:
  - entity_id: binary_sensor.outdoor_water_leak_persistent
    from: 'off'
    to: 'on'
    trigger: state
  conditions: []
  actions:
  - action: notify.mobile_app_nickphone
    metadata: {}
    data:
      data:
        priority: high
        ttl: 0
        tag: outdoor-leak-alert
        color: '#ff0000'
      title: "\U0001F6B0 Outdoor Water Leak Detected"
      message: 'Unexplained water flow has been detected for over 2 hours. Current
        hourly rate: {{ states(''sensor.outdoor_water_hourly_change'') }} gal.'
- id: '1770084282355'
  alias: Notify - House Water Leak Possible
  description: Water meter usage increased every hour from 9p-6a
  triggers:
  - at: 07:01:00
    trigger: time
  conditions:
  - condition: state
    entity_id: binary_sensor.house_water_nightly_leak_possible
    state: 'on'
  actions:
  - data:
      title: "\U0001F3E0 House Water Alert"
      message: Potential water leak detected! Water usage increased every hour from
        9 PM to 6 AM.
      data:
        priority: high
        ttl: 0
        tag: house-leak-alert
        color: '#ffa500'
    action: notify.mobile_app_nickphone
- id: '1770485349188'
  alias: Count House Water Meter Frequency Updates
  triggers:
  - entity_id: sensor.house_water_meter_freq_1
    trigger: state
  actions:
  - target:
      entity_id: input_number.house_water_meter_freq1_updates_per_hour
    data:
      value: '{{ states(''input_number.house_water_meter_freq1_updates_per_hour'')
        | float(0) + 1 }}'
    action: input_number.set_value
- id: '1770485394121'
  alias: Count Outdoor Water Meter Frequency Updates
  triggers:
  - entity_id: sensor.outdoor_water_meter_freq_1
    trigger: state
  actions:
  - target:
      entity_id: input_number.outdoor_water_meter_freq1_updates_per_hour
    data:
      value: '{{ states(''input_number.outdoor_water_meter_freq1_updates_per_hour'')
        | float(0) + 1 }}'
    action: input_number.set_value
- id: '1770485452657'
  alias: Reset Water Meter Freq Hourly
  description: ''
  triggers:
  - hours: /1
    trigger: time_pattern
  actions:
  - action: input_number.set_value
    metadata: {}
    target:
      entity_id:
      - input_number.house_water_meter_freq1_updates_per_hour
      - input_number.outdoor_water_meter_freq1_updates_per_hour
    data:
      value: 0
- id: '1770038217308'
  alias: Notify - Saginaw Water Rate Changed
  description: ''
  triggers:
  - entity_id:
    - sensor.saginaw_house_water_rate
    - sensor.saginaw_outdoor_water_rate
    id: rate_changed
    trigger: state
    alias: Saginaw Water Rate Changes
  - entity_id:
    - sensor.saginaw_house_water_rate_raw
    - sensor.saginaw_outdoor_water_rate_raw
    to: unavailable
    for:
      seconds: 30
    id: scrape_failed
    trigger: state
    alias: Saginaw Water Rate Raw Scrape Changes
  actions:
  - choose:
    - conditions:
      - condition: trigger
        id: rate_changed
      - condition: template
        value_template: "{{ trigger.from_state.state not in ['unknown', 'unavailable']
          and \n  trigger.to_state.state not in ['unknown', 'unavailable'] }}\n"
      sequence:
      - data:
          title: "\U0001F4B0 Water Rate Change"
          message: 'Rate for {{ trigger.to_state.name }} has changed! Old Value: ${{
            trigger.from_state.state }} New Value: ${{ trigger.to_state.state }}'
          data:
            priority: high
            ttl: 0
        action: notify.mobile_app_nickphone
    - conditions:
      - condition: trigger
        id: scrape_failed
      sequence:
      - data:
          title: '⚠️ Scrape Error: Saginaw Water'
          message: 'The scrape for {{ trigger.to_state.name }} failed or returned
            non-numeric data.  Stable value of ${{ states(trigger.entity_id.replace(''_raw'',
            '''')) }} is being maintained. Check: https://saginawtownship.org/departments/public_services/water_distribution.php'
          data:
            priority: high
            ttl: 0
        action: notify.mobile_app_nickphone

In Devices -> Helpers there are a bunch, but some come from templates above and others when you add the water data to your Energy dashboard (after a reboot and data starts coming in). Here’s my list of helpers:

Some key findings when I started looking at the data. My meters are broadcasting many times per minute, but the gallons used reading only changes at 11 minutes after every hour. They do this to save the endpoint battery I guess. So no realtime data, but hourly is better than nothing.

In the data, there is a leaking flag. From what I’ve read this flag only gets turned on if the usage increases for 24 hours straight. Not great for leak detection, but would have been useful last summer when something busted on a sprinkler line and I didn’t find out for a week or so. I have leak notifications based on these flags, but my custom leak notifications should trigger sooner. If the sprinklers have been off and the outdoor usage increases two hours in a row, I’ll get an alert. If the house usage have been increasing all through the overnight I’ll get an alert in the morning.

Once everything is setup, let it run. After several days, check out the freq1 sensor data, which should look similar to these graphs.

Your meters might be different, but mine hop between three frequencies at a time. There’s a low, medium, and high. Every 8 hours (3:11am, 11:11am, and 7:11pm), one of the frequencies increases by 400MHz, so over the course of a day they all increase. Then one day they all peaked and reset to the lower end of a frequency band.

From all this data I knew:

  • Low Band: 904.8 – 910.8 MHz with changes at 7:11 pm
  • Med Band: 911.2 – 917.2 MHz with changes at 3:11 am
  • High Band: 917.6 – 923.6 MHz with changes at 11:11 am

I also tracked how many times per hour I caught data from each meter.

Not bad, but some hours I’d only get one or two data packets for a meter. Technically enough, but there was a risk of missing data. Since I knew the pattern I felt I could do smarter frequency hopping with my SDR to listen for data and then capture a lot more. It worked!

I was getting a lot more reads and rarely less than 10 in any hour. In order to do this I updated the rtl_433.conf file to replace the 24 frequencies with three bands.

# Low band - shifts at 7:11 PM ET (904.8 - 910.8 MHz)
frequency 904.6M
frequency 905.0M
#frequency 905.4M
#frequency 905.8M
#frequency 906.2M
#frequency 906.6M
#frequency 907.0M
#frequency 907.4M
#frequency 907.8M
#frequency 908.2M
#frequency 908.6M
#frequency 909.0M
#frequency 909.4M
#frequency 909.8M
#frequency 910.2M
#frequency 910.6M
#frequency 911.0M

# Mid band - shifts at 3:11 AM ET (911.2 - 917.2 MHz)
frequency 911.0M
frequency 911.4M
#frequency 911.8M
#frequency 912.2M
#frequency 912.6M
#frequency 913.0M
#frequency 913.4M
#frequency 913.8M
#frequency 914.2M
#frequency 914.6M
#frequency 915.0M
#frequency 915.4M
#frequency 915.8M
#frequency 916.2M
#frequency 916.6M
#frequency 917.0M
#frequency 917.4M

# High band - shifts at 11:11 AM ET (917.6 - 923.6 MHz)
frequency 917.4M
frequency 917.8M
#frequency 918.2M
#frequency 918.6M
#frequency 919.0M
#frequency 919.4M
#frequency 919.8M
#frequency 920.2M
#frequency 920.6M
#frequency 921.0M
#frequency 921.4M
#frequency 921.8M
#frequency 922.2M
#frequency 922.6M
#frequency 923.0M
#frequency 923.4M
#frequency 923.8M

# ^ keep blank line

The two uncommented frequencies in each band are the ones on either side of the frequency currently used by the meters. I added a scripts folder and a new update_rtl433_channels.sh file in there.

#!/bin/bash
# update_rtl433_channels.sh
#
# Advances one band's frequency pair in the rtl_433 config.
# Finds the two uncommented frequencies in the band's section,
# comments out the first one, and uncomments the next one after the pair.
# If the pair is at the end of the section, wraps to the first two.
#
# Usage: update_rtl433_channels.sh <low|mid|high> [config_path]

BAND="$1"
CONFIG_PATH="${2:-/config/rtl_433/rtl_433.conf}"

if [ -z "$BAND" ]; then
    echo "Usage: $0 <low|mid|high> [config_path]"
    exit 1
fi

if [ ! -f "$CONFIG_PATH" ]; then
    echo "Error: Config file not found: $CONFIG_PATH"
    exit 1
fi

# Determine the section header
case "$BAND" in
    low)  SECTION="# Low band -" ;;
    mid)  SECTION="# Mid band -" ;;
    high) SECTION="# High band -" ;;
    *)    echo "Error: band must be low, mid, or high"; exit 1 ;;
esac

# Find start line of this section
SECTION_START=$(grep -n "$SECTION" "$CONFIG_PATH" | head -1 | cut -d: -f1)
if [ -z "$SECTION_START" ]; then
    echo "Error: Could not find section '$SECTION' in config"
    exit 1
fi

# Find end line: next section header or end of file
NEXT_SECTION=$(tail -n +$((SECTION_START + 1)) "$CONFIG_PATH" | grep -n "^# .* band -" | head -1 | cut -d: -f1)
if [ -z "$NEXT_SECTION" ]; then
    SECTION_END=$(wc -l < "$CONFIG_PATH")
else
    SECTION_END=$((SECTION_START + NEXT_SECTION - 1))
fi

echo "Band: $BAND (lines $SECTION_START-$SECTION_END)"

# Get absolute line numbers of all active (uncommented) frequency lines in this section
ACTIVE_ABS=()
for LINE_NUM in $(seq "$SECTION_START" "$SECTION_END"); do
    if sed -n "${LINE_NUM}p" "$CONFIG_PATH" | grep -q "^frequency "; then
        ACTIVE_ABS+=("$LINE_NUM")
    fi
done

if [ "${#ACTIVE_ABS[@]}" -ne 2 ]; then
    echo "Error: Expected 2 active frequencies, found ${#ACTIVE_ABS[@]}"
    exit 1
fi

FIRST_ABS=${ACTIVE_ABS[0]}
SECOND_ABS=${ACTIVE_ABS[1]}

echo "Active:"
echo "  Line $FIRST_ABS: $(sed -n "${FIRST_ABS}p" "$CONFIG_PATH")"
echo "  Line $SECOND_ABS: $(sed -n "${SECOND_ABS}p" "$CONFIG_PATH")"

# Find the next commented frequency line after the second active one
NEXT_COMMENTED=""
for LINE_NUM in $(seq $((SECOND_ABS + 1)) "$SECTION_END"); do
    if sed -n "${LINE_NUM}p" "$CONFIG_PATH" | grep -q "^#frequency "; then
        NEXT_COMMENTED=$LINE_NUM
        break
    fi
done

if [ -z "$NEXT_COMMENTED" ]; then
    # At end of section — wrap to first two
    echo "End of section, wrapping to first two"

    # Comment out both active lines
    sed -i "${FIRST_ABS}s/^frequency /#frequency /" "$CONFIG_PATH"
    sed -i "${SECOND_ABS}s/^frequency /#frequency /" "$CONFIG_PATH"

    # Find the first two commented frequency lines in the section
    WRAP_LINES=()
    for LINE_NUM in $(seq "$SECTION_START" "$SECTION_END"); do
        if sed -n "${LINE_NUM}p" "$CONFIG_PATH" | grep -q "^#frequency "; then
            WRAP_LINES+=("$LINE_NUM")
            if [ "${#WRAP_LINES[@]}" -eq 2 ]; then
                break
            fi
        fi
    done

    for ABS in "${WRAP_LINES[@]}"; do
        sed -i "${ABS}s/^#frequency /frequency /" "$CONFIG_PATH"
    done
else
    # Normal advance: comment the first, uncomment the next
    echo "Advancing: commenting line $FIRST_ABS, uncommenting line $NEXT_COMMENTED"

    sed -i "${FIRST_ABS}s/^frequency /#frequency /" "$CONFIG_PATH"
    sed -i "${NEXT_COMMENTED}s/^#frequency /frequency /" "$CONFIG_PATH"
fi

echo ""
echo "Active frequencies:"
grep "^frequency " "$CONFIG_PATH"

This file needs a permissions change. Install the Terminal & SSH app in HA, start it, open it, and type:
chmod +x /config/config/update_rtl433_channels.sh.

In configuration.yaml:

shell_command:
  rtl433_shift_low: 'bash /config/scripts/update_rtl433_channels.sh low /config/rtl_433/rtl_433.conf'
  rtl433_shift_mid: 'bash /config/scripts/update_rtl433_channels.sh mid /config/rtl_433/rtl_433.conf'
  rtl433_shift_high: 'bash /config/scripts/update_rtl433_channels.sh high /config/rtl_433/rtl_433.conf'

In automations.yaml:

- id: '1770813439694'
  alias: RTL 433 - Shift Low Band Frequencies
  description: Advances low band frequencies at 7:11 PM ET daily
  triggers:
  - trigger: time
    at: '19:11:00'
  actions:
  - action: shell_command.rtl433_shift_low
  - delay:
      seconds: 5
  - action: hassio.addon_restart
    data:
      addon: 9b13b3f4_rtl433-next
  mode: single
- id: '1770813477228'
  alias: RTL 433 - Shift Mid Band Frequencies
  description: Advances mid band frequencies at 3:11 AM ET daily
  triggers:
  - trigger: time
    at: 03:11:00
  actions:
  - action: shell_command.rtl433_shift_mid
  - delay:
      seconds: 5
  - action: hassio.addon_restart
    data:
      addon: 9b13b3f4_rtl433-next
  mode: single
- id: '1770813511146'
  alias: RTL 433 - Shift High Band Frequencies
  description: Advances high band frequencies at 11:11 AM ET daily
  triggers:
  - trigger: time
    at: '11:11:00'
  actions:
  - action: shell_command.rtl433_shift_high
  - delay:
      seconds: 5
  - action: hassio.addon_restart
    data:
      addon: 9b13b3f4_rtl433-next
  mode: single

Make sure to uncomment the correct pair of frequencies in each band, update the automation trigger times, and make sure the slug for the rtl433-next app is correct. Each time an automation runs the active frequencies are updated for the associated band. Since they should be on both sides of the frequency used by the water meter both can read the RF broadcasts. When it gets to the end of the band’s frequency list, it shifts up to the top of the list.

A lot of this is dependent on your water meters and situation, but hopefully it gives you enough information to make it work.

How Do Event LED Wristbands Work?

When we attended the Lions Thanksgiving game in 2024, we got these wristbands.

You’ve probably wore one at a game or concert or at least seen them on TV. When everyone at a venue wears one, they create cool lighting effects. They were still flashing when we got home that night and I took a video.

I’ve always wondered how they work. A few weeks ago I found them in a box and dove in. They’re made by a Canadian company called PixMob.

Inside the plastic case is a small circuit board powered by a couple of CR2032 coin cell batteries.

Some models work via Infrared (IR) and others by Radio Frequency (RF). Almost every remote control you’ve ever had uses either IR or RF. This board actually says RF on one of the battery contact points. After putting in new batteries I found RF captures on GitHub and used my Flipper Zero to broadcast the RF signals.

Pretty neat. I doubt I’ll ever do anything with them, but now I know how they work.’

A Larger Drill Press Table with a Motor

The table on my new Bucktool drill press is about 9-1/2 inches square, which is too small. I set out to make something bigger. First, a side quest though. I still had the top from my old work table, which was two sheets of 3/4″ plywood glued together.

A big chunk was going to the sanding station, which had sheet metal over junk MDF for the top. The brackets holding it to the metal frame were always getting pulled out.

I cut up the plywood lamination and rounded the corners and edges. I changed the orientation of the machines to give me easier access to the big belt sander, which saved about 10″ of width. I also mounted a power strip.

The small chunk of plywood was for a new drill press table. I worked on the layout, routed the middle for inserts, and routed slots.

The wide slots are for T-tracks. One of my requirements for the table was to make it function with the Magswitch fence I had. So I bought 3/4 x 1/4″ steel bar stock, which fit perfectly through the top of the T-track. The shorts slots in the table offset to the left got additional pieces of metal, allowing me to move the fence over to clear the quill feed handles.

When I bought the flat bar, I place it across both magnets and I could not pull it off. That turned out to be a flawed test. After screwing in the short pieces as shown in that last picture I could easily move the fence. I did some research and found the 1/4″ thick metal was fine, but it needed more surface area to hit the magnetic field. I clamped two pieces of the metal side by side and couldn’t move the fence.

So I bought a piece of 1/4 x 4 x 12″ flat cold rolled steel and cut two 5-1/2″ pieces. Then I did a bunch of sanding and drilling before spraying three coats of lacquer.

On the table, I cut and glued plywood in the back section of the T-track slots. After the glue dried, I routed large areas for the plates. I cut the T-tracks shorter, sanded the table, and gave it 3 coats of shellac. Then I mounted the tracks and metal plates. This turned out to be a much better solution.

It was time to start working on a powerful upgrade. Raising and lowering a drill press table is usually a pain in the ass. This larger table actually got in the way of the hang crank and I wanted to motorize it. I bought a couple high torque gear motors, a momentary 3-way rocker switch, and a 15mm to 8mm flexible shaft coupling.

The crank shaft on the drill press is actually 9/16″, so the coupling was too large (I could only find metric sizes on Amazon). Three small pieces of aluminum can were thick enough to shim it and test. I connected an 18 volt laptop power brick, added extra weight to the table, and toggled the switch. It worked!

I had ordered both the DC90 and DC350 motors and went with the DC90. The beefier motor was too slow and has way more torque than I’ll even need.

I bought a 24v power supply, motor speed controller, fuse, and 12 gauge wire. I also grabbed a toggle switch and limit switches from my parts bins. The toggle switch was so AC wouldn’t be constantly flowing to the power supply. The limit switches were to prevent the table from going out of bounds, which I do enough of on the golf course! I wired things up for an initial test.

When I bought the speed controller there wasn’t much documentation and I was hoping the FWD/REV terminals would allow me to directly connect limit switches. They didn’t. At least not out of the box. The controller has two modes; you can use the switch on the front or bypass it with your own switch connected to those back terminals. In the picture above I got the bypass working with my limit switches and the 3-position switch used in my initial testing.

This was unnecessarily complex, disabled the switch on the front of the box, and meant I’d have to mount the additional switch. I opened up the controller to see how it worked. The case’s switch was plugged in to the circuit board, so I popped off the connector and connected it through my circuit instead. Bingo!

It was a latching switch, but I wanted a momentary 3-position switch, so I bought a pack. I soldered wires to the new switch, clipped a bit of plastic from the case, and fed the wires through the larger hole. The new switch was a perfect fit.

I took the original table off the drill press and brought it to my assembly table. First, I mounted the tables together and then screwed down the power supply. I made a custom bracket for the speed controller.

I forgot about the on/off switch though! So I scrapped the mounting bracket and made a new one. The second one used a piece of metal saved from a table top basketball game and turned out much better.

To make a proper coupling that would join the two shafts I ordered parts from Motion Industries:

The middle piece is flexible and would help with any misalignment, but I wanted to try to get the shafts lined up the best I could. I think it turned out pretty well.

Then I put the table back on the drill press column. After squaring it to the cart, I tightened hose clamps around the rack to prevent rotation. I never need that functionality. Then I figured out the limit switch triggers and positions.

I hadn’t used the drill press much, but while drilling the holes in that piece of butter knife, I was already sick of the cluck key location. So I mounted the clip on the side of the table instead.

I had extra hold down clamps from the assembly table, so I bought M6 star knobs, 100m M6-1.0 bolts, and T-track slider nuts to make them useable for this table. I also bought a 19×12″ silicon tray for the table, to help contain the cutting fluid and chips, when drilling metal.

I forgot to cut corners off the inserts earlier, so quickly did that. It’ll make it much easier to get the inserts out of the table. Eight spares should last a long time.

Here’s a quick demo of the motor and limit switches. This thing is awesome!

This project was a lot of fun and is a big improvement to the machine.

Tracking Cat Litter Cleaning with ESPHome and Home Assistant

One of our daily tasks is to clean out the cat litter boxes and we (on maybe I just wanted an excuse to automate part of the process!) run in to a couple of small problems:

  1. We usually don’t know if the other has already cleaned them.
  2. We obviously don’t want to forget.
  3. Since I primarily took over this job, I’ve been using a daily reminder, but it’s on my iPhone nagging me all day, even though it’s set for noon. I only need a reminder when it doesn’t get done.

I thought of a solution with an ESPHome based device and Home Assistant. I used a WEMOS D1 Mini Lite, WEMOS OLED Shield, button, red LED, green LED, and 220 Ohm resistors. I connected everything on a breadboard for testing and then made it more permanent.

Key functionality:

  • During the day, the green LED will be lit if the litter boxes have been cleaned and the red LED if they need to be cleaned. If we’re walking by, green means keep going and red means stop here.
  • At night (8pm to 8am), the LEDs are off, unless the device is woken up.
  • Press the button to turn on the display and status LED if at night. The display shows the last time the litter was cleaned in one of three formats, depending on how long it’s been.
    • Today
      1:23 PM
    • Yesterday
      2:48 PM
    • 2 days ago
      11:00 AM
  • Press the button when the display is on to update the litter box last cleaned date and time. The LEDs flash to signify something is happening. The new date and time gets shown on the display.
  • After 30 seconds the display turns off.
  • At 4pm send a reminder to our phones if the litter boxes need to be cleaned.
  • In Home Assistant a toggle can disable the reminders. Useful when we’re on vacation.

Here’s the ESPHome device YAML:

substitutions:
  device_name: cat-litter
  api_key: !secret catlitter_api
  ota_password: !secret catlitter_ota
  ip_address: !secret catlitter_ip

packages:
  base: !include z_package_base.yaml

esphome:
  name: ${device_name}
  friendly_name: Cat Litter
  on_boot:
    priority: 800 
    then:
      - lambda: |-
          id(cat_litter_display).turn_on();
          id(screen_is_active) = true;
      - component.update: cat_litter_display
      - script.execute: display_timer

esp8266:
  board: d1_mini_lite

globals:
  - id: screen_is_active
    type: bool
    restore_value: no
    initial_value: 'true'

# WEMOS OLED Shield
i2c:
  sda: GPIO4 
  scl: GPIO5 
  scan: true
  id: bus_a
  frequency: 100kHz

time:
  - platform: homeassistant
    id: esptime
    on_time:
      - seconds: 1
        minutes: 0
        hours: 8
        then:
          - script.execute: update_led_logic
      - seconds: 1
        minutes: 0
        hours: 20
        then:
          - script.execute: update_led_logic

font:
  - file: "fonts/Roboto-Regular.ttf"
    id: roboto_font
    size: 12

text_sensor:
  - platform: homeassistant
    id: litter_text
    entity_id: sensor.cat_litter_status_formatted
    on_value:
      then:
        - component.update: cat_litter_display
        - script.execute: update_led_logic

binary_sensor:
  - platform: homeassistant
    id: remote_litter_status
    entity_id: binary_sensor.litter_needs_cleaning
    on_state:
      then:
        - script.execute: update_led_logic

  # Physical button
  - platform: gpio
    pin: 
      number: GPIO0 
      inverted: true
      mode: INPUT_PULLUP
    name: "Cleaned Button"
    filters:
      - delayed_on: 50ms
    on_press:
      then:
        - if:
            condition:
              lambda: 'return !id(screen_is_active);'
            then:
              # WAKE UP
              - lambda: |-
                  id(cat_litter_display).turn_on();
                  id(screen_is_active) = true;
              - component.update: cat_litter_display
              - script.execute: update_led_logic
              - script.execute: display_timer
            else:
              # TRIGGER CLEANED
              - delay: 50ms 
              - homeassistant.service:
                  service: script.cat_litter_cleaned
              - script.execute: led_flash_animation
              - script.execute: display_timer

output:
  - platform: esp8266_pwm
    pin: GPIO14 
    id: led_green
  - platform: esp8266_pwm
    pin: GPIO12 
    id: led_red

script:
  - id: update_led_logic
    then:
      - lambda: |-
          if (!id(remote_litter_status).has_state()) return;

          auto time = id(esptime).now();
          bool is_night = false;
          if (time.is_valid()) {
            is_night = (time.hour >= 20 || time.hour < 8);
          }

          if (id(cat_litter_display).is_on()) { is_night = false; }

          if (is_night) {
            id(led_red).turn_off();
            id(led_green).turn_off();
          } else {
            if (id(remote_litter_status).state) {
              id(led_red).set_level(0.2); 
              id(led_green).turn_off();
            } else {
              id(led_red).turn_off();
              id(led_green).set_level(0.2);
            }
          }

  - id: display_timer
    mode: restart
    then:
      - delay: 30s
      - lambda: |-
          id(cat_litter_display).turn_off();
          id(screen_is_active) = false;
      - script.execute: update_led_logic

  - id: led_flash_animation
    mode: restart
    then:
      - repeat:
          count: 5
          then:
            - output.set_level: { id: led_green, level: 0.3 }
            - output.turn_off: led_red
            - delay: 150ms
            - output.turn_off: led_green
            - output.set_level: { id: led_red, level: 0.3 }
            - delay: 150ms
      - script.execute: update_led_logic

display:
  - platform: ssd1306_i2c
    id: cat_litter_display
    model: "SSD1306 64x48"
    address: 0x3C
    rotation: 180° 
    lambda: |-
      if (id(litter_text).has_state()) {
        std::string full_text = id(litter_text).state;
        size_t pos = full_text.find("@");
        if (pos != std::string::npos) {
          std::string day = full_text.substr(0, pos);
          std::string time_str = full_text.substr(pos + 1);
          it.printf(32, 8, id(font_main), TextAlign::TOP_CENTER, "%s", day.c_str());
          it.printf(32, 26, id(font_main), TextAlign::TOP_CENTER, "%s", time_str.c_str());
        } else {
          it.printf(32, 24, id(font_main), TextAlign::CENTER, "%s", full_text.c_str());
        }
      } else {
        it.printf(32, 24, id(font_main), TextAlign::CENTER, "Syncing...");
      }

Some helpers in configuration.yaml:

template:
- binary_sensor:
  - name: "Litter Needs Cleaning"
    unique_id: litter_needs_cleaning
    # This turns ON (Red LED) if the date is not today
    state: >
      {% set last = states('input_datetime.cat_litter_last_cleaned') | as_datetime %}
      {% if last is none %} true {% else %}
        {{ last.date() < now().date() }}
      {% endif %}
- sensor:
  - name: "Cat Litter Status Formatted"
    unique_id: cat_litter_status_formatted
    state: >
        {% set last = states('input_datetime.cat_litter_last_cleaned') | as_datetime %}
        {% if last is none %}
            No Data @ --:--
        {% else %}
            {% set diff = (now().date() - last.date()).days %}
            {% set time = last.strftime('%-I:%M %p').lower() %}
            {% if diff == 0 %}
                Today @ {{ time }}
            {% elif diff == 1 %}
                Yesterday @ {{ time }}
            {% else %}
                {{ diff }} days ago @ {{ time }}
            {% endif %}
        {% endif %}

notify:
  - name: "momrik_phones"
    platform: group
    services:
      - service: mobile_app_nick
      - service: mobile_app_brandi

Automations in automations.yaml:

- id: '1768843528106'
  alias: Notify - Cat Litter @ 4PM
  description: ''
  triggers:
  - trigger: time
    at: '16:00:00'
  conditions:
  - condition: state
    entity_id: binary_sensor.litter_needs_cleaning
    state:
    - 'on'
  - condition: state
    entity_id: input_boolean.cat_litter_reminders
    state:
    - 'on'
  actions:
  - action: notify.momrik_phones
    metadata: {}
    data:
      title: "Cat Litter \U0001F408 \U0001F4A9"
      message: The litter hasn't been cleaned yet today!
      data:
        tag: cat-litter-alert
        actions:
        - action: MARK_LITTER_CLEANED
          title: I did it
  mode: single
- id: '1768843827814'
  alias: Notify Clear - Cat litter
  description: ''
  triggers:
  - trigger: event
    event_type: mobile_app_notification_action
    event_data:
      action: MARK_LITTER_CLEANED
  conditions: []
  actions:
  - action: script.cat_litter_cleaned
    data: {}
  - action: notify.momrik_phones
    data:
      message: clear_notification
      data:
        tag: cat-litter-alert
  mode: single

One script in scripts.yaml:

cat_litter_cleaned:
  alias: "Cat Litter Cleaned"
  sequence:
    - service: input_datetime.set_datetime
      target:
        entity_id: input_datetime.cat_litter_last_cleaned
      data:
        datetime: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"
    - service: notify.momrik_phones
      data:
        message: "clear_notification"
        data:
          tag: "cat-litter-alert"

I also added a couple of simpler helpers via Settings -> Devices & services -> Helpers:

  • Cat Litter Last Cleaned – Date and time
  • Cat Litter Reminders – Toggle

Finally, I added cards to a Home Assistant dashboard. See screenshots of the different states of each card below.

Here’s the dashboard YAML if you want it.

type: horizontal-stack
title: Cat Litter
cards:
  - type: custom:mushroom-template-card
    primary: >-
      {% set last = states('input_datetime.cat_litter_last_cleaned') |
      as_datetime %}

      {% if last is none %}
        Unknown State
      {% else %}
        {% set diff = (now().date() - last.date()).days %}
        {% if diff == 0 %}
        Cleaned Today
        {% else %}
        Needs Cleaning
        {% endif %}
      {% endif %}
    icon: mdi:emoticon-poop
    features_position: bottom
    secondary: >-
      {% set last = states('input_datetime.cat_litter_last_cleaned') |
      as_datetime %}

      {% if last is none %}

      ???

      {% else %}
        {% set diff = (now().date() - last.date()).days %}
        {% if diff > 0 %}
          {{ last.strftime('%b %-d') }} -
        {% endif %}
        {{ last.strftime('%-I:%M %p') }}
      {% endif %}
    color: |-
      {% if is_state('binary_sensor.litter_needs_cleaning', 'on') %}
        red
      {% else %}
        green
      {% endif %}
    tap_action:
      action: more-info
    icon_tap_action:
      action: perform-action
      perform_action: script.cat_litter_cleaned
      target: {}
      confirmation:
        text: Are you sure you want to update the last cleaned date/time to now?
    entity: input_datetime.cat_litter_last_cleaned
  - type: custom:mushroom-entity-card
    entity: input_boolean.cat_litter_reminders
    name: Reminders
    tap_action:
      action: toggle
    hold_action:
      action: more-info
    icon_color: amber

If we get a reminder, it looks like this. We can click I did it to update the date/time to now if we forgot to press the button on the physical device. With the automation set to run at 4pm, we should rarely see this though.

The final device lives right next to the waste bag dispenser I made. This way it’s easy to see the state and hit the button when cleaning out the litter. Here are photos in place with a few different states.

This project was so fun. Using Google Gemini for stuff like this makes it so much faster. I’ve had some of these microcontrollers and other parts for almost a decade so it’s nice to finally put them to use.

What other features or automations would you add to this? Have you built anything similar?

Updates to my PyPortal Home Assistant Display Project

I picked up a 5m strip of adressable LEDs for my PyPortal device. The strip has 60 LEDs/m, which is double the density of the Neopixel strip I fried. To prevent future accidents, I tested improvements. Adding a 1,000 µF electrolytic capacitor protects the LEDs from a power spike and a 470Ω resister protects the first LED from data ringing.

Everything worked great, so I cut off a section of 62 LEDs. Then I worked on a little board and better wiring.

I didn’t trim the protoboard, so I could use the two holes to screw it to the undersize of my desk. This LED strip had an adhesive backing, which worked much better than the clips. I did a bit of cable management and also mounted the air quality monitor under the desk.

The code, which can be found on GitHub, got a bunch of small improvements:

  • Updated the LED count
  • Limited brightness to 50%, which is plenty and helps with power draw
  • Adjusted the pulse functionality to account for the brightness limit
  • Added a button to the interface which can be used to clear the LEDs
  • When filling a color, reset the LED params global, so an animation won’t play on the next loop
  • Tweaked the chase functionality to work better with the new LED density
  • Changed the button success animation so the loop continues sooner

I had Google Gemini help me some stuff. First was to update the PyPortal firmware and CircuitPython version. Then update the code to make it compatible with CircuitPython 10.03. I also made an interface for my dashboard where I can select the different commands and options to send to the device manually instead of typing them in through Developer Tools -> Actions in Home Assistant.

Here’s a new demo video, so you can see how it works and what the lighting looks like.

Of course, the real power still comes from automations, where something happening around the house triggers Home Assistant to send commands to the device. Time to work on more of those. Almost a year later and this project is finally where I hoped it would end up.

Drill Press Cart

When I setup the new shop, I decided to finally put my planer on a cart and took over the one used by the bandsaw. Then the bandsaw needed somewhere to go, so I scooted the drill press over, added a piece of plywood to support the overhang, and screwed it down. It did not fit and had been terrible since day one. The sharp edges of the bandsaw table were an accident waiting to happen.

I did this because I’d been wanting a new cart for the old Homier Distributing Company BDM 5 Drill Press. It was too high and I needed more drawers so I could organize everything better. This move would surely force my hand, though it ended up taking over a year.

I’ll get to the cart in a minute, but there’s more to this story. For years, to change speeds on a drill press has required opening the top housing and moving belts. I restored that Homier over eight years ago and can’t ever remember changing the speeds, which isn’t good. Different materials and bits should be drilled at various speeds. The problem is almost always spinning too fast, which can dull bits and produce poor results. I saw the Nova Voyager drill press in a YouTube video and wanted one because of the digital features.

For what I do, I could never justify the cost. About two months ago I started searching for other options and found models where variable speed is adjusted by a handle. The popular budget version seemed to be the WEN 4214T (or the 6.2-amp WEN DP1263V). After more research I decided, when I was ready, I’d get the Bauer 12″ from Harbor Freight. Then on Christmas Eve morning a deal for the Bucktool DP12 popped up. I threw it in my cart and it was half off after discounts. Sold!

That new cart became a priority, so I determined a much lower height and the dimensions. I got out 4″ castors and 22″ drawer slides. I didn’t have enough 3/4″ plywood, so cut up MDF leftover from the outfeed table. Assembly was quick and attaching the slides to the cabinet before putting it together makes it so much easier.

I was worried about the castor screws pulling out of the MDF, so I glued and screwed pieces of 3/4″ plywood to the bottom of the cart and then the castors. I also added more support across the middle of the top, where the bulk of the machine’s weight will be. Then attached the top and a shiplap paneling back.

Next, I made four drawers.

The final step was to mount the drill press. The height of this cart is a huge improvement!

With everything done I organized the drawers and made a custom holder for my Forstner bits. I think I’ll eventually make a something for all the drill bits and everything that goes with the rotary tool.

Now the bandsaw could live by itself on the old cart. I removed the butcher block and replaced it with 3/4″ plywood to lower it as well. There isn’t much to go with it, so I was able to store other various plastic and metal materials in the cabinet. Those were the last boxes to unpack after the move!

Stay tuned for other cool drill press upgrades. Ideas are baking and parts have been ordered.

Making Things in 2025

A new year means it’s time for a recap of my maker projects from last year. We’ve settled in to the new house, which let to quite a few home automation things and setting up my shop.

January

February

March

April

September

November

December

Even with hernia surgery recovery and restrictions I got a ton done in December.

Check out the previous making recap posts for 201720182019202020212022, 2023, and 2024.

Using PyPortal to Display Air Quality Data and Interact with Home Assistant

I got AdaBox 011 in March of 2019 and wrote this about the PyPortal (buy at Adafruit):

I’ll likely turn this into something that interfaces with my Home Assistant server to control different devices around my house.

The PyPortal has been sitting on a shelf ever since. Way back in February, it caught my eye, and I picked it up, not remembering what it’s capabilities were. Then I started upgrading IKEA air quality monitors and even made my own. Since I’m at the desk in my office a large portion of the week I thought I would make that 2019 prediction come true.

I could show a bunch of data on the screen and the PyPortal has a touchscreen, so I could display buttons for triggering things around the house. The device also has connectors for doing GPIO, so I got the idea of adding an LED strip, which I could use for notifications. I even had a meter long strip of Adafruit Mini Skinny NeoPixels I had bought in 2017 and never touched that would be perfect. I needed to buy a 2.0mm JST PH Connector kit in order to make a wire that would connect to the pack of the PyPortal. I ended up using a piece of Cat6 cable, even though I only needed 3 of the 8 wires inside.

I used light strip clips to mount the LEDs to the back of my desk.

I also mounted a power strip under the desk and cleaned up all of the cables.

The code I’m running on the PyPortal was heavily inspired by Adafruit’s PyPortal MQTT Sensor Node/Control Pad for Home Assistant and PyPortal NeoPixel Color Picker. It’s done with CircuitPython and I’ve added my code to pyportal-home-assistant-display on GitHub.

All of this was done back in March. I quickly began having issues with the ethernet cable and the small JST connectors, so I put this post on pause. Figured it was time to finally fix this before the end of the year. While testing, I determined the LED strip got fried up at some point. It was probably some kind of short from the janky wire.

Here’s what my display looks like.

My favorite aspect of the project and code is being able to publish MQTT messages from Home Assistant, which the PyPortal listens for and reacts to. I can send various commands, such as fill:blue, which turns all of the LEDs blue, or whatever color I set. I have commands to chase a color from one side to the other, bounce a color from left to right and back to the left, pulse the entire strip, animate a rainbow, or set the brightness. Since I don’t have another strip of Neopixels, in order to create a demo video, I wired up a 24 LED circle. You’ll have to imagine the effects on the back of my desk, lighting up the wall.

I can manually send these MQTT messages as shown in the demo, but the real power comes from automations. For example, the LEDs automatically pulse blue when the washing machine is done and pink when the dryer is done.

With the different effects and color combinations, the possibilities are endless. What kind of automations would you run?

Update: I got a new LED strip, made a new demo video, and improved a bunch of stuff. See Updates to my PyPortal Home Assistant Display Project.

Building a Shop Air Filter with Box Fans

Over the years, I’ve seen many versions of a shop air filter, made from box fans and 20×20 inch furnace filters. A few years ago I picked up some old box fans on Facebook Marketplace and bought a pack of filters from Sam’s Club. They’ve been stacked in the corner.

It was finally time to build my air filter. I removed the back covers, feet, handles, and knobs from the fans. I got my first look at the switches inside, which are nearly identical.

I’d easily be able to wire the fans together, so I removed the switches and power cords.

I put together a frame from OSB, cut slots to feed the wires through, and screwed the box fans in.

Then I grabbed wood that had been salvaged from a pallet to construct a door.

On the back side, I used glue and brad nails to attach plywood rails. I also made tabs to hold the filters secure.

I attached the door with a couple hinges and made some notched tabs to hold the door shut.

Then it was time to work on the wiring and electronics. I had recently watched a YouTube video showing how to make an old fan smart and his code with ESPHome and Home Assistant gave my a great start. I bought a 4 channel relay board to use with a an ESP8266 development board, a button, and some LEDs. I tore open an old USB power plug and was originally going to tie in the 120 volt line, but decided against it. First, I tested out the circuit and code on a breadboard and then soldering things up more permanently.

A plastic screw container was a good side, so I used hot glue to secure the boards and then wired up all of the fan connections.

I’m not sure if I’ll ever use the button, but it allows me to cycle between the three speeds and turn it off. The three LEDs show which speed is currently running. The only thing I got wrong was reversing the low and high speeds, which was a quick fix in the ESPHome code. Speaking of the code, here’s mine.

esphome:
  name: shop-air-filter
  friendly_name: Shop Air Filter

esp8266:
  board: d1_mini

logger:
  level: WARN

api:
  encryption:
    key: "input_yours"

ota:
  - platform: esphome
    password: "input_yours"

wifi:
  min_auth_mode: WPA2
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  manual_ip:
    static_ip: 192.168.1.2
    gateway: 192.168.1.1
    subnet: 255.255.255.0

time:
  - platform: homeassistant
    id: home_time

binary_sensor:
  - platform: gpio
    pin: {number: D5, mode: INPUT_PULLUP, inverted: true}
    name: "Speed Button"
    on_press:
      then:
        - script.execute: cycle_fan_speed

  - platform: template
    id: active
    lambda: 'return id( fan_speed ).state > 0;'

switch:
  # Relays
  - platform: gpio
    pin: D3
    id: speed_1
    inverted: true
    interlock: &fan_interlock [speed_1, speed_2, speed_3]
    internal: true
  - platform: gpio
    pin: D2
    id: speed_2
    inverted: true
    interlock: *fan_interlock
    internal: true
  - platform: gpio
    pin: D1
    id: speed_3
    inverted: true
    interlock: *fan_interlock
    internal: true

  # LEDs
  - platform: gpio
    pin: D6
    id: led_1
    internal: true
  - platform: gpio
    pin: D7
    id: led_2
    internal: true
  - platform: gpio
    pin: D8
    id: led_3
    internal: true

number:
  - platform: template
    name: "Fan Speed"
    id: fan_speed
    min_value: 0
    max_value: 3
    step: 1
    optimistic: true
    restore_value: true
    on_value:
      then:
        - script.execute: set_shop_filter_speed

text_sensor:
  - platform: template
    name: "Current State"
    id: current_state

sensor:
  - platform: duty_time
    name: "Filter Runtime"
    id: shop_filter_usage
    sensor: active
    restore: true
    unit_of_measurement: h
    accuracy_decimals: 1
    filters:
      - multiply: 0.000277778 # Convert seconds to hours

button:
  - platform: template
    name: "Reset Filter Timer"
    icon: "mdi:timer-off"
    on_press:
      then:
        - sensor.duty_time.reset: shop_filter_usage

script:
  - id: set_shop_filter_speed
    mode: restart
    then:
      - switch.turn_off: speed_1
      - switch.turn_off: speed_2
      - switch.turn_off: speed_3
      - switch.turn_off: led_1 
      - switch.turn_off: led_2
      - switch.turn_off: led_3
      - delay: 300ms 
      - lambda: |-
          if ( id( fan_speed ).state == 0 ) {
            id( current_state ).publish_state( "Off" );
          } else if ( id( fan_speed ).state == 1 ) {
            id( speed_1 ).turn_on();
            id( led_1 ).turn_on();
            id( current_state ).publish_state( "Low" );
          } else if ( id( fan_speed ).state == 2 ) {
            id( speed_2 ).turn_on();
            id( led_1 ).turn_on(); id( led_2 ).turn_on();
            id( current_state ).publish_state( "Medium" );
          } else if ( id( fan_speed ).state == 3 ) {
            id( speed_3 ).turn_on();
            id( led_1 ).turn_on(); id( led_2 ).turn_on(); id( led_3 ).turn_on();
            id( current_state ).publish_state( "High" );
          }
  - id: cycle_fan_speed
    then:
      - lambda: |-
          int next_speed = id( fan_speed ).state + 1;
          if ( next_speed > 3 ) next_speed = 0;
          id( fan_speed ).publish_state( next_speed );

I used Google Gemini to help and it had a great suggestion to track the run time and add a maintenance reminder when it was time to replace the filters.

In Home Assistant I created some automations. My dust collector uses a smart plug, so when it draws electricity, the air filter automatically turns on at high speed. When the dust collector turns off, the air filter continues to run for 15 minutes before turning off. If I had to remember to turn on the air filter all the time, it would rarely happen, so this is amazing.

I’m still on lifting restrictions for several weeks so Brandi helped me install the air filter on the ceiling.

I wish I hadn’t waited so long to build this!