How I Hooked Up My Cold Plunge to a Flow Sensor with ChatGPT

I’ve been loving my cold plunge—but sometimes the water stops flowing due to a clogged filter, and I don’t notice right away. The filtration system runs quietly in the background, so a stoppage can go undetected for hours. I was worried the water chiller might get damaged from the pipes freezing over. So, I built a simple system to monitor the water flow and alert me when it stops. Ideally, I wanted to know—right from my phone—if the water wasn’t moving.

After the seventh time I came home to a clogged filter, I finally pulled the trigger on a fix. To move faster, I leaned heavily on ChatGPT throughout the build

The goal was simple: build a Wi-Fi-connected sensor that tells me when the filtration system stops.

If you don’t care about my rant, you can check out the code here: github.com/dawnho/particle-flow-meter

What I Used

• Particle Photon: A WiFi-enabled microcontroller (buy one here)
• Flow Meter Sensor: HA-1044 Flow Meter (3-wire) — flow meter that connects easily to 3/4” pipe or tubing
• ChatGPT: My co-pilot for writing the embedded code and helping me debug

Setup Instructions

Wiring Setup

This project is designed for the Particle Photon to measure water flow using a flow sensor. It utilizes the FlowMeter library to calculate the flow rate and communicates with the Particle Cloud.

Wiring Guide:

• Black Wire: Connect to the GND (Ground) pin on the Particle Photon
• Red Wire: Connect to the VIN (Voltage In) pin on the Particle Photon
• Yellow Wire: Connect to A1 (Analog Pin 1) on the Particle Photon
• 10k Ohm Pull-Up Resistor: Connect one end to the 3V3 (3.3V) pin and the other end to A1

This setup ensures the Particle Photon can accurately read the pulse signals from the flow sensor.

Software Setup

• Use Particle Build to flash the particle_flow_meter.ino file to your Photon
• Include the FlowMeter Library in your project (available via the Particle Library Manager)

Flow Sensor Used: HA-1044 Flow Meter

What It Does

The flow meter is connected inline with the pump system. Every second, the Photon checks how many pulses it received and calculates a flow rate in liters per minute. If the flow rate drops to zero, it sets a variable called is_flowing to false.

The device does three things:

1. Publishes real-time flow info to the Particle cloud
2. Exposes the flow state as cloud variables
3. Sends a Slack notification if water stops flowing—and throttles alerts to one per hour

How ChatGPT Helped

This project came together through a steady, focused back-and-forth with ChatGPT. I started with a simple goal: I wanted to know when water stopped flowing in my cold plunge. ChatGPT helped me turn that idea into a working device.

First, I asked which flow sensors would fit my ¾” pipe. ChatGPT suggested inline models with open-collector outputs that a microcontroller could read. I landed on the HA-1044 flow meter. The product listing lacked solid documentation, but ChatGPT helped me decode the key details and understand how it worked—saving me from wrestling with unclear datasheets.

Once I had the sensor, I needed to wire it to a Particle Photon. ChatGPT guided me through using a pull-up resistor and pin assignments. Then it introduced me to the FlowMeter library, which let me turn raw pulses into real flow rates. I hadn’t used that library before and probably wouldn’t have found it on my own.

Next, I wanted the firmware to detect when flow stopped and send a notification. ChatGPT helped me set up a loop that checks for flow once per second, and uses Particle.publish() to trigger an alert if flow drops to zero. It also showed me how to expose flow data using Particle.variable().

When it came time for alerts, ChatGPT offered options—Zapier, email, or Slack. I picked Slack, and it walked me through setting up a webhook and connecting it to a Particle integration. Then we added throttling logic so I’d only get alerted once per hour, not every time the filter hiccuped.

In the end, I built a simple system that lets me know when the filter’s clogged. It’s a small, satisfying project—and it all came together through a clear thread of questions and answers.

The Slack Notification Logic

By default, Particle’s Particle.publish() can trigger on every loop—which would’ve flooded my Slack if the filter stayed clogged. To avoid spam, ChatGPT helped me add throttling logic so I’d only get one alert per hour while the issue persisted.

Here's the key snippet:

if (!isFlowing && (previousIsFlowing || (now - lastNotificationTime > notifyInterval))) {
    Particle.publish("is_flowing", "false", PRIVATE);
    lastNotificationTime = now;
}

It sends an alert as soon as flow stops, and waits an hour before sending another—unless flow resumes, in which case it resets.

Here’s what the alert looks like in Slack:

Final Thoughts

This took a couple of hours, a few wires, and a bit of ChatGPT magic. It’s super satisfying to wire up something physical and get that first notification—especially when it's telling you your plunge is clogged.

If you’re curious, the code is open source and ready to go: github.com/dawnho/particle-flow-meter

Let me know if you build your own!