Diesel Heater Controller

The story, version by version

It started as a cheap diesel heater off Amazon and turned into a multi-year obsession with controlling it well. Each version fixed the previous one's biggest annoyance — from a servo literally slapping a button, to an ESP32 that speaks the heater's own radio language.

1. V0 2020 · the spark

   Bought a cheap diesel heater off Amazon and bench-tested the whole system before trusting it in the van. No custom electronics yet — just proving the heater worked and getting a feel for how its wireless remote behaved. I had no idea it would grow into a years-long project.

2. V1 2020–2022 · servos

   The first automation. An Arduino read cabin temperature from a DS18B20 sensor, showed it on an OLED, and drove two hobby servos hot-glued over the stock remote to physically press ON and OFF — holding a 68–74°F window on its own. Charming, but the servos drifted and the glue mounts rattled loose with the van's vibration. It lived in a wood-and-plexiglass box, spray-painted Space Blue.

3. V2 2023 · relay, on the breadboard

   Ditched the servos. I soldered wires straight onto the remote's PCB and let the Arduino pulse a relay across the ON/OFF button — an electrical "press" instead of a mechanical one. Far more reliable, and proven out first on a breadboard.

4. V3 2025 · relay, made permanent

   The same idea, cleaned up and made real: a proper enclosure, tidier wiring, and a refactor of the code into reusable helpers with a fail-safe that shows an error rather than acting on a dead temperature sensor.

5. V4 2025 · ESP32 + RF · field-tested

   The big leap. Using an RF receiver and a logic analyzer, I sniffed and decoded the remote's 433 MHz packets, then replayed them from an ESP32 through a SYN115 transmitter — removing the physical remote from the loop entirely. It adds a phone Web UI over the ESP32's own WiFi, a 4-page OLED, anti–short-cycle protection, and a boots-disarmed safety default. It ran in the van, fact-checked against a thermometer — and became the base for V5.

6. V5 2026 · the build running now

   The "holy grail." A reliability/hardening pass on V4 — same hardware, same RF codes — built to be trusted unattended: closed-loop RF re-assertion (a dropped 433 MHz burst self-heals on the next pass), a fully non-blocking loop (temperature and RF on millis() timers, no delay()), and a watchdog that reboots to a safe DISARMED state. Plus a redesigned, fully self-contained web UI (temperature gauge + live sparkline, no external CDN) and an OLED Wi-Fi QR code to hop onto the heater's network. This is what runs today.

Code Progression

How the firmware actually evolved — each tab opens on the line that makes that version what it is; hit Show full code to load the complete sketch. V5 is the latest — a hardened, self-healing pass on V4.

// V1 — hobby servos physically push the stock remote's buttons.
#include <Servo.h>
Servo servoOff;   // presses the OFF button
Servo servoOn;    // presses the ON button

// Thermostat: a DS18B20 reads cabin temp; hold a fixed 68–74°F window, shown on an OLED.

// Turn the heater ON — swing the servo onto the button, twice for reliability.
if (tempf < tempF_low) {
  if (count2 < 1) {
    servoOn.write(41);  delay(1500);  servoOn.write(90);   // push, then release
    delay(1000);
    servoOn.write(41);  delay(1500);  servoOn.write(90);   // again, just in case
    count2 = 1; count1 = 0;
  }
}

// Turning the heater OFF works the same way on servoOff.
// Problem: servos drift, and the hot-glued mounts shook loose with the van's vibration.

// V2 — servos gone. Pulse a relay wired across the remote's button instead.
//   Rev 5 (11/23/2023): "Upgrading to the new shiiiiiiiit" — a breadboard proof-of-concept.
pinMode(5, OUTPUT);   // relay across the OFF button
pinMode(8, OUTPUT);   // relay across the ON button

// Same 68–74°F thermostat, but now the button press is electrical, not mechanical.

// Turn the heater OFF — a 100 ms pulse closes the relay, tapping the button.
if (tempf > tempF_high) {
  if (count1 < 1) {
    count1 = 1; count2 = 0;
    digitalWrite(5, HIGH); delay(100); digitalWrite(5, LOW);
  }
}
// Turn the heater ON.
if (tempf < tempF_low) {
  if (count2 < 1) {
    count2 = 1; count1 = 0;
    digitalWrite(8, HIGH); delay(100); digitalWrite(8, LOW);
  }
}

// V3 — the relay approach matured into a permanent, enclosed build.
//   Rev 6 (04/06/2025): "Enclosure built, moved heater control to relays." Refactored + fault check.
#define HEATER_ON_PIN  5   // Relay #1
#define HEATER_OFF_PIN 8   // Relay #2
const unsigned long PULSE_DURATION_MS = 1000;

// One tidy helper replaces the copy-pasted digitalWrite blocks:
void pulseHeaterControl(int pin) {
  digitalWrite(pin, HIGH);
  delay(PULSE_DURATION_MS);
  digitalWrite(pin, LOW);
}

// The loop now guards against a dead sensor before acting on it:
float currentTempF = readTemperatureSensor();
if (currentTempF != INVALID_TEMP_F) {
  updateOledDisplay(currentTempF);
  processThermostatLogic(currentTempF);   // pulses ON below 68°F, OFF above 74°F
} else {
  display.println(F("TEMP SENSOR ERROR!"));   // fail-safe: show the fault, don't act blind
}

// V5 — the hardened "holy grail". Same hardware & 433 MHz codes as V4; a reliability pass, not a rewrite.
#include <RCSwitch.h>
#include "esp_task_wdt.h"          // watchdog: reset a wedged loop, reboot DISARMED (heater off)

const unsigned long CODE_ON = 1931481520UL, CODE_OFF = 1931478280UL;   // captured from the stock remote

// Non-blocking RF: send ONE frame per loop tick on a millis() timer — never delay() the control loop.
void rfService(unsigned long now) {
  if (!rfJob.active || (long)(now - rfJob.nextAt) < 0) return;
  rc.send(rfJob.code, CODE_BITS);
  if (--rfJob.framesLeft == 0) rfJob.active = false;
  else rfJob.nextAt = now + rfGapMs;
}

// Closed-loop RF re-assertion — 433 MHz is one-way and lossy, so re-send the desired state
// every few minutes; a dropped burst simply self-heals on the next pass.
if (armed && !sensorFault && now - lastReassertMs >= RF_REASSERT_MS) {
  rfEnqueue(lastHeaterState == H_ON ? CODE_ON : CODE_OFF);
}

// Plus non-blocking DS18B20, deadband + anti-short-cycle, an OLED Wi-Fi QR to join the AP,
// and a self-contained web UI (temp gauge + live sparkline) — no external CDN.

// V4 — the physical remote is gone entirely.
//   An ESP32 replays the remote's sniffed 433 MHz codes through a SYN115 transmitter,
//   serves a phone Web UI over its own WiFi AP, cycles a 4-page OLED, and boots DISARMED.
#include <WiFi.h>
#include <WebServer.h>
#include <RCSwitch.h>          // "rc-switch"
RCSwitch rc;
const int RF_TX_PIN = 18;

// Codes sniffed from the stock remote with an RF receiver + logic analyzer:
const unsigned long CODE_ON    = 1931481520UL;
const unsigned long CODE_OFF   = 1931478280UL;
const unsigned long CODE_PLUS  = 1931479280UL;
const unsigned long CODE_MINUS = 1931477640UL;

// Replay a code — repeat the burst a few times so the heater reliably hears it.
void rfSendReal(unsigned long code) {
  rc.setPulseLength(rfPulseUs);
  for (uint8_t i = 0; i < rfRepeats; i++) {
    rc.send(code, 32);
    delay(rfGapMs);
  }
}

// Plus anti–short-cycle (3 min ON / 1.5 min OFF) and a sensor fail-safe:
//   an invalid DS18B20 reading auto-DISARMs the heater.

Bill of materials

Cost of the electronics and printed parts the build actually used — multi-pack items are prorated from their pack price. Item names link to what I bought.

The diesel heater itself, plus common shop supplies (solder, breadboard, tools), were on-hand and left off the tally.