Twin-shaft sync tachometer

New to electronics? Start here

What we're actually building

If you've ever replaced a crank position sensor or an ignition pickup, you already understand the heart of this. A magnet sweeps past a sensor, the sensor says "tick," and from the rhythm of those ticks you know how fast something is spinning. We do exactly that on each prop shaft — then put both numbers on a screen in the cockpit, with a needle that tells you when the two engines are matched.

The four pieces, in plain terms

Why one wire instead of a fat cable bundle

Your boat already does this. Rather than run a separate wire from every sensor all the way to the dash, modern gear shares one pair of wires and takes turns talking — that's what NMEA 2000 (or J1939 on the engine side) is. We borrow the same trick, called CAN. Each engine room gets its own little computer, and both report up a single shared pair of wires to the screen. Adding a third shaft later is just hanging one more box on that pair.

What the build actually involves

Glue a couple of magnets to a stainless clamp on each shaft (or fit a sensor that reads the coupling bolts), mount a sensor a few millimetres away on a solid bracket, run a two-wire bus to the cockpit, mount the screen, and flash the code we hand you using a free program on your laptop. No prior coding needed for the starter version — you copy our sketch, click upload, and watch the number move.

How it works

Time the magnet, don't count it

The whole accuracy story lives in one decision, and it's worth understanding before buying anything.

For sync specifically, what matters is the relative timing of the two shafts. Run both channels identically and average each reading over one full revolution, and most of the per-magnet placement error cancels — the needle settles instead of buzzing.

Start here

Prove one shaft on the bench

Before anything goes near the boat, get a single channel reading RPM on your desk. One board, one sensor, a tiny screen. An afternoon, ~$35, and you'll understand the whole system.

1. Wire the Hall module to the board

   Three pins: 3.3V, GND, and signal to a GPIO. The common A3144-based module already has a pull-up and an LED that blinks on each magnet pass — instant visual confirmation.

2. Spin a magnet past it by hand

   Tape a neodymium magnet to anything that turns — a drill chuck, a bench grinder, a bit of dowel. Watch the module's LED tick. South pole facing the sensor for an A3144.

3. Flash the period-timing sketch

   The snippet below reads RPM from the interval between pulses and prints it over USB. No screen needed yet — just the serial monitor.

4. Add the OLED, then the second channel

   Drop in a small I²C OLED for a standalone readout. Once one channel is solid, duplicating it for the second shaft is the easy part.

Wiring — which pin goes where

Everything shares one 3.3V rail and one ground. The Hall sensor's output goes to GPIO 4 (the HALL_PIN in the sketch); the OLED uses the ESP32's standard I²C pins, GPIO 21 and GPIO 22.

// Bench starter — one shaft, RPM by period. Runs on ESP32 or Uno/Nano.
#ifndef IRAM_ATTR
#define IRAM_ATTR // no-op on AVR; real attribute on ESP32
#endif

#if defined(ESP32)
 const int HALL_PIN = 4; // any GPIO — matches the wiring diagram
#else
 const int HALL_PIN = 2; // Uno/Nano interrupt pin (D2)
#endif

const int MAGNETS_PER_REV = 2; // match your magnet count
volatile uint32_t lastEdge = 0, period = 0;

void IRAM_ATTR onPulse() {
 uint32_t now = micros();
 uint32_t dt = now - lastEdge;
 if (dt > 500) { period = dt; lastEdge = now; } // glitch filter
}

void setup() {
 Serial.begin(115200);
 pinMode(HALL_PIN, INPUT_PULLUP);
 attachInterrupt(digitalPinToInterrupt(HALL_PIN), onPulse, FALLING);
}

void loop() {
 uint32_t p; noInterrupts(); p = period; interrupts();
 float rpm = p ? 60000000.0 / ((float)p * MAGNETS_PER_REV) : 0;
 Serial.print("RPM: "); Serial.println(rpm, 0);
 delay(200);
}

The full build

Two smart nodes, one bus

Two engine rooms means two long sensor runs to the cockpit — and raw Hall pulses dragged past alternators turn to noise. So put a small brain at each shaft and send finished numbers up a robust two-wire bus.

The bus is CAN: two twisted wires, differential, built for exactly this kind of electrically filthy environment — the same physical layer NMEA 2000 rides on. The board has a CAN controller built in; each node just needs a cheap transceiver chip, with a 120 Ω resistor at each end of the run.

Prices are rough USD ballparks for mid-2026 and move with supplier and region — treat them as planning figures, not quotes.

Wiring diagrams

The schematics

Drawn to the recommended parts — ESP32 sensor nodes, Hall sensing, the Waveshare display, distributed CAN. One colour code throughout: power, ground, sensor signal, CAN. Swap the sensor or display and a few pin labels shift.

Options to weigh

Five forks in the road

Each has a sensible default (marked) and a reason you might go the other way. Open any one for the tradeoff.

Before it touches saltwater

The marine reality checklist

Firmware shape

What each node actually runs

The bench snippet in Start here is the kernel of the sensor node. The rest is hardening — the ring-buffer averaging, the CAN publish, the LVGL faces — and it's a natural next step once one channel reads true on the desk.