Oil Pressure monitor with ESP32, INA219

Build a digital oil-pressure monitor using an ESP32 “remote hub,” an INA219 board over I²C, and Home Assistant/ESPHome. This guide follows every technically relevant step from the video: soldering the INA219, wiring to the ESP32, tapping the existing oil sender’s “Gauge” terminal, adding INA219 in ESPHome, calibrating volts→bar from two points, creating a template sensor (in ESPHome), and adding a 0–5 bar gauge with alerting.

🧭 What You’ll Build

• ✅ ESP32 remote hub that can host multiple sensors (temp + oil pressure)
• ✅ INA219 wired via I²C (SCL/SDA) to read the sender voltage
• ✅ Template sensor converting voltage to pressure (bar) using two calibration points
• ✅ Home Assistant dashboard gauge (0–5 bar) with color severities
• ✅ Alerting options: indoor siren, outdoor horn, flashing lights, push notifications
• ✅ History trends to spot changes in engine health over time

🧰 Parts & Tools

• ✅ ESP32 dev board + small breakout/terminal board (for sturdier wiring)
• ✅ INA219 breakout (with 6 header pins + VIN+/VIN− screw terminal block)
• ✅ Dupont jumper leads (female–female; trim ends if using screw terminals)
• ✅ Soldering iron, solder; optional Blu-Tack/putty to hold parts while soldering
• ✅ Optional spade double-adapter to share the sender’s “Gauge” terminal
• ✅ Wires, 3.3 V supply for the ESP32 (shared with existing temp sensor if present)

🔩 Solder the INA219 (if your board isn’t pre-soldered)

1. Place the 6-pin header into the INA219’s 6 small holes (short pins into the PCB).
2. Insert the 2-pin screw terminal into the VIN+ / VIN− holes with the screws facing outward.
3. Use putty/Blu-Tack to hold parts. Heat each pad for a couple seconds, then feed in a small amount of solder. Avoid solder bridges.
4. Inspect and wiggle-check all joints so the pins are solid.

💡 Breakout Board Tips

• ✅ Line up ESP32 pin names/numbers with the breakout before pressing in evenly.
• ✅ A breakout with screw terminals makes wiring more robust in an engine bay.

🔧 Wire ESP32 ↔ INA219 (I²C)

• ✅ VCC on INA219 → ESP32 3.3 V
• ✅ GND on INA219 → ESP32 GND
• ✅ SCL on INA219 → ESP32 GPIO22
• ✅ SDA on INA219 → ESP32 GPIO21
• ✅ Re-use the same ESP32 from your temperature project; share 3.3 V as needed.

🛠️ Tap the Engine’s Oil Sender

Run a single wire from INA219 VIN+ to the oil-pressure sender’s terminal labeled “Gauge”. (Other terminals you may see: “Warning Light,” “Isolated Earth.”) If the analog gauge is already using that terminal, use a spade double-adapter to share it: one wire to the analog gauge, one to the INA219.

Note: If you have room and prefer a dedicated sender, a T-fitting with two senders also works; this guide still applies.

⚙️ ESPHome Setup (ESP32 Firmware)

1. Open ESPHome in Home Assistant → your ESP32 → Edit.
2. Add the I²C section and the INA219 sensor using the snippets from the code page (don’t paste code here—use the link):
   👉 smartboatinnovations.com/code/oil-pressure/
3. Use GPIO21 for SDA and GPIO22 for SCL as wired above. Default address and shunt value (0.1 Ω) are fine.
4. Give the bus-voltage sensor a helpful name (e.g., “Oil Sender Voltage”) and set update_interval ≈ 5 s.
5. Save → ⋮ → Validate → ⋮ → Install → Wirelessly (OTA). Watch logs; with the engine off, “Oil Sender Voltage” will likely read ~0.0 V.

📊 Calibrate: Volts → Bar

1. Add a temporary Entity card for “Oil Sender Voltage” to observe live values.
2. Record two points for your engine:
   • Electrics ON, engine OFF: e.g., 0 bar at ~0.72 V (example from the video).
   • Engine RUNNING: e.g., 3.8 bar at ~5.4 V (example from the video).
3. These senders are near-linear, so use a simple line between the two points. The video’s sample yields a slope of ~0.812 with an offset from the start voltage (0.72 V).

🧮 Template Sensor (in ESPHome)

1. From the same code page, copy the Oil Pressure template snippet (don’t inline it here; link above) and paste it at the end of your ESPHome YAML.
2. Replace the constants with your two calibration values (start voltage and slope). The sample includes a small guard so pressure doesn’t go negative when the engine/electrics are off.
3. Save → Validate → Install (OTA) again.

📟 Dashboard Gauge & Alerts

1. Add card → Gauge for the new oil-pressure sensor.
2. Range: 0–5 bar. Style: Needle.
3. Severity (per the video demo): Green 3, Yellow 4, Red 0 (low pressure = red).
4. Create automations for low pressure (sirens/horns/lights/phone notifications).

🧪 Test & Iterate

With the engine running, you should see ~3.7–3.8 bar and ~5.3–5.4 V (as in the demo). Small variation is normal. If needed, refine your constants so the gauge matches observed behavior.

🎬 Video Transcript

Introduction

I’m Rob from Smart Boat Innovations. In this video we set up oil-pressure monitoring for our engine—our second engine-monitoring project using the super-useful ESP32 microcontroller. In the first project we set up engine-temperature monitoring with the ESP32; here we’ll use the same ESP32. The ESP32 functions as a remote hub with numerous ports to connect sensors. In our case, it connects to temperature and oil-pressure sensors, collects data from them, and transmits it wirelessly to our central system: a Raspberry Pi running Home Assistant.

If you haven’t set up an ESP32, don’t worry—I have a separate, quick video dedicated to that. Integrating oil-pressure monitoring into our smart-boat system gives several advantages. The most important is the ability to set alerts when the pressure deviates from the optimal range. Those alerts can trigger actions such as sounding an indoor siren, an outdoor horn, flashing lights, or pushing notifications to tablets and phones.

Many engines include a built-in oil alarm, but they often aren’t loud enough. Can you hear yours while you’re up at the bow watching dolphins, or if a soft watch and inexperienced crew members are in control? With this system you also get historical data on engine pressure trends, so you can monitor and evaluate variations over time and get a clearer view of performance and health.

I spent time considering the best approach for oil-pressure monitoring. For the temperature project we added extra sensors alongside the engine’s built-in one. Initially I planned a similar approach for oil pressure by introducing a separate, dedicated sender using a T-fitting so we could house two senders: the existing engine sender and another dedicated to the smart-boat system. Space constraints around my engine prevented adding the T-fitting and extra sender. Given the reliability of standard oil-pressure senders and a desire not to disturb the existing setup, I decided to use readings from the existing sender for this project. If you want to go the T-fitting route, this guide still applies.

For the measurement we’ll use a compact INA219 device (about two dollars on AliExpress). The setup is straightforward: connect a single wire from the INA219 to the pressure sender’s “Gauge” terminal, connect the INA219 to the ESP32, and then do some basic configuration in Home Assistant.

ESP32 and INA219 Overview

Please watch my previous video on setting up the ESP32, power supply, and integrating it with Home Assistant. I like to use a breakout board with the ESP32—it makes wiring sensors easier and the assembly less fragile. Line up the pin numbers and names between the ESP32 and the breakout board, and press the ESP32 in left-right-left-right until the pins seat fully.

For this project we’ll use the INA219 board. It’s tiny, about the size of a finger. On the front there are six small pins, of which we’ll use four, and on the other side two screw-terminal pins labeled VIN+ and VIN−.

Soldering INA219 Pins

Many boards no longer come pre-soldered. In the description I link to one that is; if yours isn’t, you’ll solder it yourself. Insert the six header pins into the six holes (it’s not symmetrical—the shorter pins go into the board and the longer pins face out). Insert the screw terminal into the two VIN holes with the screws facing outwards. Put the board on a piece of wood and use Blu-Tack or similar to hold it. Heat the pin with the iron for a couple of seconds, then touch solder to the pin so it flows. Don’t add too much and don’t let it bridge across pins. Do the six header pins and then the two VIN pins. Check the joints are solid.

Wiring Up INA219 and ESP32

We’ll connect the INA219 to an ESP32 and the breakout board. I like to use Dupont (breadboard) cables; buy a bunch. I choose colors to match: red for 3.3 V, green for ground, and two different colors for the data pins (clock and data), say brown and yellow.

From left to right on the INA219: the first pin is the power pin (VCC) for 3.3 V from the ESP32, then GND, then the clock (SCL), then the data (SDA). Push the Dupont plugs onto the header; they’re tight. Since I’m using a breakout board with screw terminals on the ESP32 side, I trim the Dupont females off that end and land the bare ends in the breakout screws. (You can also buy female-to-male jumpers.)

Connections on the ESP32 breakout: brown (clock) to GPIO22, yellow (data) to GPIO21, red to 3.3 V (shared with the temperature sensor), and green/black to GND.

Wiring Diagram

Summary: SCL → GPIO22, SDA → GPIO21, VCC → 3.3 V, GND → GND. That’s all we need between the INA219 and the ESP32.

Connect the Oil Sender

Now connect the INA219 to the engine’s oil-pressure sender. Run a red wire from VIN+ on the INA219 to the sender terminal labeled Gauge. You may also see terminals labeled Warning Light and Isolated Earth. If you’re sharing the existing sender with the analog gauge, use a spade double-adapter so two wires can share the “Gauge” terminal: one to the analog gauge, one to the INA219. That’s the wiring complete.

Add to Home Assistant

In Home Assistant, open ESPHome. This continues from the earlier ESP32 setup and engine-temperature video. Open the ESP32 device you set up for engine monitoring and view its YAML. We’ll add more YAML: first the I²C section that declares the bus and pins (GPIO21 and GPIO22), then the INA219 platform block. The code is on my website; copy it from there rather than typing.

The I²C section defines the protocol between the INA219 and the ESP32, and the pins we’re using (21 and 22 for SDA/SCL). After that, add the INA219 sensor block. The default address is fine, the shunt resistance is 0.1 Ω (typical), we’ll read the bus voltage and name it something like Oil Sender Voltage, set maximums, and an update interval of about 5 s. Save, validate, and install OTA. Watch the logs: with nothing powered you’ll see Oil Sender Voltage at 0.0 V, which is expected. You’ll also see the temperature sensor from the previous project.

Sensor Configuration & Calibration

To help calibrate, add the Oil Sender Voltage to a dashboard as a temporary card. We need a couple of points: the relationship between voltage and pressure (bar). With electrics on and engine off I get about 0.72 V, which corresponds to 0 bar. With the engine running I get about 5.4 V at around 3.8 bar. That gives two points.

These pressure senders are almost linear in resistance, so we can use basic maths to derive a simple formula. Using the two points, the slope comes out at about 0.812, and we subtract the start voltage (0.72 V). It won’t be exact, but it’s close enough to know when the engine is at normal pressure and when it deviates substantially.

Template in ESPHome

We can implement the formula in ESPHome (or as a Home Assistant template sensor). I’ll do it in ESPHome. On my website there’s a code snippet for the Oil Pressure template YAML; paste it at the end of your ESPHome YAML. Replace the constants with your values from calibration (including the small check to prevent negative values when the engine/electrics are off). Save, validate, and install OTA again.

Dashboard Gauge & Testing

Back on the dashboard, add a gauge for oil pressure. I’m using 0–5 bar with a needle gauge. For severities I set Green at 3, Yellow at 4, and Red at 0 (low pressure red). You can add automations to alert when the bar value changes—sirens or notifications. Start the engine: I see about 3.7 bar and a voltage of ~5.3 V (previously it was 5.4 V). Engines vary a little. The calculation is based on the formula we put in the ESPHome YAML. We now have a digital oil-pressure meter; set up your alerts as needed.