SS4H-RG Smart Rain Gauge – DIY project based on ESP32 and ESPHome

In this article, I’ll show you how to build a rain sensor that not only detects when it’s raining but also tells you how heavy the rainfall is. And the best part? It’s more accurate and reliable than any online service out there.

If you have a piece of land where you’re growing anything that needs watering, this information is invaluable. For example, I’ve got a lawn and a few fruit bushes in my backyard, and watering them on a daily basis is a must during summer.

That’s where my own, local, independent-of-the-internet rain gauge comes in. It tells me exactly how much rain has fallen right where I live.

If you don’t feel like building it yourself or simply don’t have the time, I invite you to visit my online store. You will find assembled, and ready-to-use device, or just the circuit board itself.

Since a picture is worth a thousand words, a short animation consisting of a dozen or so images should fully explain how it works.

By knowing the diameter of the funnel’s upper part, the capacity of one bucket, and the time interval between each tipping, we can accurately determine the intensity of the current rainfall.

But how does ESP32 know when the overflow takes place?

There’s a magnet at the top part of the tipping bucket. Inside this tightly sealed container, we’ve got our PCB with a HALL sensor.
It detects the change in the magnetic field when the bucket swings, and notifies the EPS about it.
The microcontroller measures how much time passed since the last tick, converts the units to l/m2, and sends that info to the Home Assistant.
If there’s no tipping for an hour or so, we can safely assume that the rain has stopped.

substitutions:
  #Deep Sleep 
  wake_time: '5s'

  #Battery
  max_battery_vlotage: '6'
  min_battery_voltage: '3.6'

  #Rain
  one_tick: '0.841808' #[mm]

This first segment contains variables that will potentially be modified most frequently. They are placed at the top of the configuration file for easy access and convenience.

• wake_time: the duration for which the ESP chip will stay active after being awakened by the tipping bucket.
• max(min)_battery_vlotage: at this point, you determine what percentage represents a fully charged battery and what percentage represents 0%. For regular AAA batteries, the setting I’ve chosen should be fine, but if you’re using rechargeable batteries, you might want to consider adjusting it.
• one_tick: one “tick” corresponds exactly to the value of rainfall. And 1 mm equals 1 liter per square meter. I calculated this value taking into account that the top diameter of the funnel is 110 mm, and one bucket can hold 8 ml of water. If any of these parameters are different for you, you will need to recalculate accordingly.

globals:
  - id: old_time
    type: time_t
    initial_value: "0"
    restore_value: yes
  - id: rg_flag
    type: bool
    initial_value: "false"
    restore_value: no

In this section, I store global variables, which means they are accessible throughout the configuration file and can be retained after waking up from deep sleep mode.

esphome:
  name: rain-gauge-v1-0

esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "XXX"

ota:
  password: "XXX"

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

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Rain-Gauge-V1-0 Fallback Hotspot"
    password: "ahypg3nlyxHN"

captive_portal:

These are standard things that can be found in every freshly generated configuration file, so I don’t think I need to explain them.

time:
  - platform: homeassistant
    id: homeassistant_time
    setup_priority: 900
    on_time_sync:
      then:
        - lambda: |-
            if(id(rg_flag) == false)
            {
              time_t current_time = id(homeassistant_time).now().timestamp;
              time_t delta_time = current_time - id(old_time);

              if(delta_time < 3600)
                id(precipitation_id).publish_state($one_tick * (3600 / delta_time));
              else
                id(precipitation_id).publish_state(0.01);

              id(old_time) = current_time;

              id(rg_flag) = true;
            }

This here is the most important piece of code. Right here, we calculate how much time has passed since the last “tick” of the bucket.

First thing, we set a high priority to make sure this component is high up on the priority list during the initialization process.

Then, once it’s fully up and running, it checks the current time (timestamp) and subtracts it from the previous one recorded during the last bucket trigger.

However, if this value is greater than one hour, we consider it to have just started raining. In such a case, we send a value of 0.01 mm. This is to let Home Assistant know that it’s raining, but we will be able to calculate the exact value with the next tick.

If the value of time is smaller than one hour, it converts seconds into “mm” of water column, taking into account the variable “one_tick”.

switch:
  - platform: gpio
    pin: GPIO27
    name: "RG Battery Switch"
    id: rg_battery_switch
    restore_mode: ALWAYS_ON
  - platform: gpio
    pin: GPIO12
    name: "RG LED"
    id: rg_led 

Here we’re just initializing two GPIOs as outputs.

“RG Battery Switch” disconnects the ADC line from the microcontroller during Deep Sleep mode to save battery power.

“RG LED” is connected to an LED. I use it to indicate that the Deep Sleep mode is blocked. (I’ll explain why we do this in a moment).

binary_sensor:
  - platform: status
    name: "RG Status"
  - platform: homeassistant
    id: rg_deep_sleep
    name: "RG Deep Sleep"
    entity_id: input_boolean.rg_deep_sleep
    publish_initial_state: True
    on_state:
      then:
        if:
          condition:
            lambda: return x;
          then:
            - deep_sleep.allow: init_deep_sleep
          else:
            - switch.turn_on: rg_led
            - deep_sleep.prevent: init_deep_sleep

In this section, we set up the binary sensors.

The “Status” sensor allows Home Assistant to check if the Rain Gauge is online.

As for the “RG Deep Sleep” sensor, it requires further explanation. I’ll tell you about it in the subsection “How to use OTA?“

sensor:
  - platform: adc
    pin: GPIO32
    name: "RG Battery Level"
    id: rg_battery_level
    device_class: "battery"
    unit_of_measurement: "%"
    accuracy_decimals: 0
    setup_priority: -200
    filters:
      - lambda: |-
          float current_voltage = x * 5.94;

          if(current_voltage < $min_battery_voltage)
            return 0;
          else if(current_voltage > $max_battery_vlotage)
            return 100;
          else
            return ((current_voltage - $min_battery_voltage) / ($max_battery_vlotage - $min_battery_voltage)) * 100;
  - platform: template
    name: "precipitation"
    id: precipitation_id
    unit_of_measurement: "mm/h"
    update_interval: never

The analog sensor “RG Battery Level” is responsible for measuring the voltage of the batteries and converting it into a percentage.

The “precipitation” sensor, as the name suggests, stores data about current rainfall. It’s where the calculated value based on time and the amount of water in a single bucket is recorded.

deep_sleep:
  run_duration: $wake_time
  id: init_deep_sleep
  esp32_ext1_wakeup:
    pins: GPIO25
    mode: ALL_LOW

Finally, we configure the Deep Sleep mode. We don’t set a specific time for the ESP to enter this mode because the only wake-up option is the tipping bucket.