Building a Precision Electrolytic Tilt Sensor Circuit for ESP32

The Electrolytic Sensing Principle and AC Excitation

Electrolytic tilt sensors measure inclination by passing an electrical current through a conductive fluid housed in a curved glass or ceramic vial. As the vial tilts, the fluid shifts under gravity, changing the submerged surface area of the internal electrodes and thereby altering the electrical impedance between them. Unlike solid-state MEMS accelerometers, this fluid mass provides exceptional mechanical damping and high-resolution measurement without the micro-stiction or high-frequency noise inherent to silicon proof masses.

Because applying a direct current (DC) would cause electrolysis and rapidly degrade the conductive fluid through ion plating, bare electrolytic sensors strictly require an alternating current (AC) excitation signal, typically between 1 kHz and 10 kHz. In a practical electrolytic tilt sensor circuit, this AC signal is generated by an oscillator, passed through the sensor, and then demodulated using a synchronous detector or precision rectifier to yield a stable, ratiometric DC analog voltage proportional to the tilt angle. For embedded projects, using a pre-conditioned module with built-in AC excitation and demodulation is highly recommended over building a discrete synchronous detector from scratch.

Circuit Wiring and Signal Conditioning

For this build, we are interfacing a pre-conditioned 5V dual-axis electrolytic tilt module (such as the Jewell Instruments LCF series or an equivalent industrial ±20° module) with an ESP32 development board. The module outputs a ratiometric analog voltage. Because the ESP32's ADC pins are strictly limited to 3.3V (and practically degrade in linearity above 2.5V), we must use a resistive voltage divider to scale the sensor's 0.5V–4.5V output down to a safe 0.33V–3.0V range.

Wiring and Pinout Table

Converting Raw ADC Readings to Tilt Degrees

The output of this conditioned sensor is a ratiometric analog voltage. For a standard ±20° module powered at 5.0V, the output spans from 0.5V (-20°) to 4.5V (+20°), with a midpoint of 2.5V representing exactly 0° (level). This gives us a sensitivity of 0.1 V/°.

Because we are using a voltage divider (R1 = 10kΩ, R2 = 20kΩ), the voltage reaching the ESP32 ADC pin is attenuated by a factor of 0.6667 (20k / 30k). To find the physical tilt angle, we must reverse this attenuation in software, then apply the sensor's sensitivity math.

The Raw-to-Unit Math

1. Calculate ADC Voltage: V_adc = (Raw_ADC * 3.3) / 4095
2. Recover Sensor Voltage: V_sensor = V_adc / 0.6667
3. Calculate Tilt Angle: Angle = (V_sensor - 2.5) / 0.1

Here is the complete, copy-pasteable C++ implementation for the ESP32 Arduino core:

// ESP32 Electrolytic Tilt Sensor Reading
const int PIN_TILT_X = 34;
const int PIN_TILT_Y = 35;

const float V_REF = 3.3;
const int ADC_RESOLUTION = 4095;
const float DIVIDER_RATIO = 0.6667; // 20k / (10k + 20k)
const float SENSOR_MIDPOINT = 2.5;  // Voltage at 0 degrees
const float SENSITIVITY = 0.1;      // Volts per degree

float getTiltAngle(int rawAdc) {
    // Convert raw 12-bit ADC to voltage at the pin
    float v_adc = (rawAdc * V_REF) / ADC_RESOLUTION;
    
    // Scale back up through the voltage divider
    float v_sensor = v_adc / DIVIDER_RATIO;
    
    // Convert voltage to physical degrees
    float angle = (v_sensor - SENSOR_MIDPOINT) / SENSITIVITY;
    
    // Constrain to physical limits of the sensor
    return constrain(angle, -20.0, 20.0);
}

void setup() {
    Serial.begin(115200);
    analogReadResolution(12);
    // Note: analogSetAttenuation is deprecated in newer ESP32 cores,
    // default 11dB attenuation is used automatically for 0-3.1V range.
}

void loop() {
    int rawX = analogRead(PIN_TILT_X);
    int rawY = analogRead(PIN_TILT_Y);
    
    float angleX = getTiltAngle(rawX);
    float angleY = getTiltAngle(rawY);
    
    Serial.printf("X: %5.2f deg | Y: %5.2f deg\n", angleX, angleY);
    delay(100);
}

Calibration and Interference Mitigation

While the math above provides a functional baseline, real-world implementation requires addressing two major hurdles: ESP32 ADC non-linearity and environmental interference. According to Espressif's official ADC documentation, the ESP32's internal ADC suffers from significant non-linearity, particularly near the 0V and 3.1V rails. For precision tilt measurement, you must use the esp_adc_cal library to apply eFuse-based calibration values, or map a multi-point lookup table using a precision external reference.

Electrolytic sensors are also susceptible to specific interference sources. The most common is capacitive coupling from 50/60Hz AC mains. Because the sensor relies on high-impedance analog signals, running unshielded wires near AC wiring will inject massive noise into your readings. Always use shielded twisted-pair cable for the analog outputs, tying the shield to ground at the ESP32 end only.

Additionally, temperature drift affects the conductivity of the electrolytic fluid. As noted in Jewell Instruments' technical literature on tilt sensing, electrolytic fluid conductivity typically shifts by about 0.2% per °C. If your application operates in environments with wide temperature swings (e.g., outdoor enclosures), you must add an NTC thermistor to your circuit and apply a software temperature-compensation curve to your final angle calculation.

Electrolytic Tilt Sensor Circuit FAQ

Why does my electrolytic tilt sensor circuit output drift over time?

If your sensor output drifts continuously in one direction even when perfectly stationary, you are likely applying a DC bias to a raw, unconditioned electrolytic vial. This causes electrolysis, permanently altering the fluid's chemical composition and resistance. If you are using a properly conditioned AC-excited module and still see drift, the culprit is almost certainly ambient temperature changes altering the fluid's conductivity, requiring thermal compensation.

Can I use an electrolytic tilt sensor for high-vibration environments?

Yes, but with caveats. The conductive fluid provides excellent natural damping, meaning electrolytic sensors inherently reject high-frequency mechanical vibration much better than undamped MEMS accelerometers. However, severe low-frequency shocks or continuous heavy vibration can cause the fluid to "slosh" inside the vial, introducing low-frequency noise into your analog output. In these cases, apply a digital low-pass filter (like a moving average or Kalman filter) in your microcontroller code to smooth the slosh-induced ripple.

What is the difference between an electrolytic tilt sensor and a MEMS accelerometer for tilt?

MEMS accelerometers (like the MPU6050 or ADXL345) measure static gravity to calculate tilt. They are cheap, fast, and easily integrate with I2C/SPI, but they suffer from high-frequency noise, mechanical stiction, and lower resolution at very small angles. Electrolytic tilt sensors measure the physical shift of a fluid mass. They are more expensive, require analog signal conditioning, and have a slower response time, but they offer vastly superior resolution (down to fractions of an arc-second), zero stiction, and built-in vibration damping, making them the superior choice for precision static leveling and structural monitoring.