If you want a quick, low‑cost way to monitor how clear or cloudy your water is, building an Arduino‑based turbidity meter is a great weekend project. With a common analog turbidity sensor (for example, the DFRobot Gravity Analog Turbidity Sensor, SEN0189), an Arduino board, and a few lines of code, you can read an analog voltage that changes as turbidity changes, then convert that voltage into an approximate NTU (Nephelometric Turbidity Unit) reading. This guide walks you through the science, the hardware, the wiring, the calibration, and a ready‑to‑use Arduino sketch, so you can measure turbidity meaningfully and interpret what the numbers mean for water quality.
Table of Contents
What Is Turbidity, and Why Does It Matter?
Turbidity is a measure of water’s relative clarity. It’s an optical property: when you shine light into a water sample, particles in the water (clay, silt, algae, organic matter, microorganisms, etc.) scatter that light. The more scattering, the higher the turbidity and the cloudier the water looks. In short, turbidity tells you how much suspended material is in the water.
Common materials that increase turbidity include soil particles (clay and silt), plankton, algae, and other microscopic organisms. These particles can:
- Reduce light penetration, which affects aquatic plant growth and ecosystem health.
- Provide places for pollutants like metals and bacteria to attach, making turbidity a useful indicator of potential pollution.
Turbidity is typically measured in Nephelometric Turbidity Units (NTU). You’ll often see the term NTU used interchangeably with FNU (Formazin Nephelometric Units) in technical literature; both quantify scattered light. In rivers during low flow, turbidity is often below about 10 NTU, but during storms it can spike much higher.
For drinking water, standards and guidance are stricter. Treated drinking water is often required to be at or below 0.3 NTU for the vast majority of samples, and some high‑performance treatment goals target 0.1 NTU. Very clean groundwater is often below about 1 NTU, while water bodies with sparse life may approach <0.1 NTU under ideal conditions.
Turbidity matters for human health because particles can shield microorganisms from disinfectants like chlorine or UV light, and they can support microbial regrowth in distribution systems. That’s why water utilities pay so much attention to keeping turbidity low.
How Arduino Turbidity Sensors Work (Optical Principle)
Most low‑cost Arduino turbidity sensors are simple optical devices:
- An LED shines light through a small gap in the sensor’s probe.
- On the other side, a light‑dependent resistor (LDR) or phototransistor detects how much light comes through.
- As the water gets more turbid, particles scatter and absorb more light, so less light reaches the detector. The sensor’s output voltage drops as turbidity increases.
This is a simplified version of laboratory nephelometry (measuring scattered light), which is the basis for standard turbidity meters. Strictly speaking, many inexpensive modules measure transmitted light rather than scattered light at 90°, so they’re better for trend monitoring and education than for regulatory compliance.
Key characteristics of common Arduino turbidity modules
- Operating voltage: typically 3.3–5 V.
- Output: analog voltage that varies with turbidity.
- Approximate behavior in clean water (with modules like SEN0189): around 4.1 V ±0.3 V in pure water at room temperature (NTU <0.5), decreasing with higher turbidity.
- Typical sensing range: roughly 0–3000 NTU, though accuracy and resolution are limited at very low NTU (<1 NTU).
Interpreting NTU Values for Water Quality
Below is a simplified, practical interpretation of NTU ranges for common water types. This is not a legal standard; it’s just to help you understand what your readings might mean.
- <1 NTU: Very clear water. Often associated with treated drinking water, high‑quality groundwater, or very clear reservoirs.
- 1–5 NTU: Clear to slightly cloudy; typical of some raw surface waters and groundwater.
- 5–25 NTU: Noticeably cloudy; common in rivers, especially after rain, or in ponds.
- 25–100 NTU: Very cloudy; may indicate erosion, runoff, or algal blooms.
- 100 NTU: Highly turbid water, often muddy; not suitable as drinking water without treatment.
For drinking water, utilities usually aim for <1 NTU and must meet regulatory limits such as ≤0.3 NTU for filtered water in most measurements, with a maximum around 1 NTU, depending on local rules.
Project Overview: What You Will Build
In this project, you will:
- Wire an analog turbidity sensor to an Arduino (for example, Uno or Nano).
- Read the sensor’s analog voltage.
- Convert that voltage into an approximate NTU value using a simple calibration curve (or a published equation).
- Display the result on the Serial Monitor (and optionally on a 16×2 I2C LCD).
The workflow looks like this:
Components and Tools You Will Need
- Arduino Uno, Nano, or compatible board (5 V operation is assumed here).
- Analog turbidity sensor module (DFRobot SEN0189 or equivalent).
- Breadboard and jumper wires.
- USB cable to connect Arduino to your computer.
- 16×2 I2C LCD display (optional but recommended for a standalone meter).
- Two small containers: one for clean (reference) water, one for test samples.
- Optional: formazin or commercial turbidity standards (for calibration), multimeter.
Wiring the Turbidity Sensor to Arduino
Connect all the required components as shown in the below circuit diagram to build Turbidity meter.
For modules like DFRobot’s SEN0189 or any chinese made module, the wiring is straightforward when using analog output. The module has:
- VCC: connect to Arduino 5 V.
- GND: connect to Arduino GND.
- OUT or A (analog output): connect to an analog input such as A0.
Basic wiring (no LCD)
- Sensor VCC → Arduino 5V.
- Sensor GND → Arduino GND.
- Sensor “A” pin → Arduino A0.
If you want to use an I2C LCD:
- LCD SDA → Arduino A4 (Uno) or the SDA pin on your board.
- LCD SCL → Arduino A5 (Uno) or the SCL pin.
- LCD VCC → 5V; LCD GND → GND.
Build a Professional Water Quality Monitor with PCBWay—Custom PCBs & 3D-Printed Enclosures for Your Turbidity Sensor Project
Measure water clarity like a pro with your Arduino and turbidity sensor. PCBWay’s integrated manufacturing services help you transform a laboratory prototype into a rugged, field-ready monitoring device—perfect for aquariums, environmental studies, or wastewater testing.
Custom PCB Manufacturing for Reliable Sensor Readings:
PCBWay manufactures high-quality custom PCBs that integrate your turbidity sensor, signal conditioning circuit, Arduino, and display module onto a single, compact board. Their analog-optimized layouts minimize electrical noise, ensuring stable readings even in low-turbidity conditions. With professional SMT assembly, you receive a fully populated, tested board ready to calibrate and deploy.
Water-Resistant 3D-Printed Enclosures:
Protect your electronics with a custom enclosure from PCBWay’s advanced 3D printing service. Design a splash-proof housing using waterproof PETG or durable ABS, featuring a sealed sensor port, cable gland for wiring, and a transparent window for display viewing. Add internal mounting bosses to securely hold your custom PCB and sensor module—keeping everything safe from moisture and dust.
Why PCBWay Delivers Professional Results:
- Stable Measurements: Clean PCB design preserves sensor signals for consistent turbidity data.
- Environmental Protection: Custom enclosures shield electronics during field or lab use.
- Seamless Integration: Your PCB and enclosure are manufactured to fit perfectly together.
- Complete Solution: From bare board to assembled electronics and finished housing.
Build Your Water Quality Monitor Today:
Upload your PCB design and enclosure model for instant quotes, DFM feedback, and professional manufacturing at PCBWAY.COM
Basic Arduino Sketch to Read Turbidity
Here is a minimal sketch to read the sensor and display the voltage on the Serial Monitor:
// Basic Arduino turbidity sensor sketch (analog)
const int sensorPin = A0; // Sensor connected to A0
void setup() {
Serial.begin(9600);
}
void loop() {
int raw = analogRead(sensorPin); // 0–1023
float voltage = raw * (5.0 / 1024.0); // Convert to 0–5 V
Serial.print("Raw ADC: ");
Serial.print(raw);
Serial.print(" Voltage (V): ");
Serial.println(voltage);
delay(1000);
}
This matches the basic example provided by DFRobot for the SEN0189 module.
After uploading the code you can see the Raw ADC values and ADC output values on the serial monitor as shown in the below image.
How to Calibrate: Convert Voltage to NTU
Why calibration is necessary
Every sensor has slight variations, and optical turbidity sensors behave nonlinearly. To get NTU instead of just “voltage,” you must calibrate. In practice, calibration means establishing a mapping from voltage (V) to NTU using known standards. Arduino Forum users emphasize that without calibration, readings are only qualitative, not quantitative.
Method 1: Using a calibration curve with known standards
This is the recommended approach if you need even approximate NTU:
- Prepare or buy at least two (ideally three or more) turbidity standards spanning your expected range, for example:
- 0 NTU (very clean, deionized or distilled water).
- ~20–40 NTU.
- ~100–200 NTU (or another high value).
You can buy formazin‑based standards or dilute a stock solution to known NTU values.
- Record stable sensor voltages for each standard:
- Place the sensor in each standard.
- Wait for the reading to stabilize (10–20 seconds).
- Write down the voltage (or raw ADC value) and the corresponding NTU.
- Plot voltage (x) vs NTU (y). Fit a curve (often quadratic) to the points.
Many users of the SEN0189 have published equations that approximate this mapping. For 5 V operation, one widely cited empirical equation is:
NTU = −1120.4 × V² + 5742.3 × V − 4352.9
where V is the sensor’s output voltage in volts. This is derived from fitting data points to a quadratic curve and aligns with code used in several projects.
For 3.3 V operation, users have reported a different fit:
NTU = −2572.2 × V² + 8700.5 × V − 4352.9
but note that 3.3 V operation may change the effective range and accuracy; use your own calibration points whenever possible.
Method 2: Simple two‑point linear calibration
If you don’t have multiple standards, you can do a crude calibration with two points:
- Clean water reference (e.g., filtered tap or distilled water, assume ≈0 NTU).
- A prepared dilute clay suspension of known NTU (or a single standard).
Then:
- Measure V_clean in clean water and V_known at known NTU.
- Assume a linear relationship:
NTU = NTU_known × (V_clean − V) / (V_clean − V_known)
Keep in mind this is less accurate than a multi‑point curve, but it’s better than raw voltage alone.
Example Arduino Code with NTU Conversion (Serial + I2C LCD)
Below is a more complete example that:
- Averages multiple analog readings for stability.
- Converts voltage to NTU using the 5 V quadratic equation.
- Shows both voltage and NTU on the Serial Monitor and an I2C 16×2 LCD.
This approach is similar to what you’ll find in community projects and tutorials.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Set the LCD address to 0x27 or 0x3F depending on your module
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int sensorPin = A0;
void setup() {
Serial.begin(9600);
lcd.begin();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("Turbidity Meter");
delay(2000);
}
float readAverageVoltage(int pin, int samples) {
long total = 0;
for (int i = 0; i < samples; i++) {
total += analogRead(pin);
delay(5);
}
return (total / (float)samples) * (5.0 / 1024.0);
}
float voltageToNTU(float v) {
// Empirical quadratic fit for SEN0189 at 5V (community‑reported)
// NTU = -1120.4*v^2 + 5742.3*v - 4352.9
float ntu = -1120.4 * v * v + 5742.3 * v - 4352.9;
if (ntu < 0.0) ntu = 0.0; // clamp negative values
if (ntu > 3000.0) ntu = 3000.0; // sensor range limit
return ntu;
}
void loop() {
float v = readAverageVoltage(sensorPin, 800);
float ntu = voltageToNTU(v);
Serial.print("Voltage (V): ");
Serial.print(v, 2);
Serial.print(" NTU: ");
Serial.println(ntu, 1);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(v, 2);
lcd.print(" V");
lcd.setCursor(0, 1);
lcd.print(ntu, 1);
lcd.print(" NTU");
delay(1000);
}
Notes:
- The 800‑sample averaging improves stability at the cost of a slightly slower loop.
- For a 3.3 V board, replace the conversion formula with the 3.3 V version if you adopt that fit, or (preferably) calibrate with your own standards.
- Always verify the I2C address of your LCD (0x27 is common; some modules use 0x3F).
After uploading the code you see the NTU output and voltage on the LCD display as shown in the below image
Practical Tips for Reliable Measurements
Physical placement and sample handling
- Avoid bubbles: Bubbles on the sensor’s optical surfaces scatter light just like particles, causing falsely high turbidity. Tap the probe gently and let bubbles escape before taking readings.
- Keep the optical windows clean: Fingerprints, oil, and films can affect the signal. Wipe the sensor gently with a soft, lint‑free cloth and, if necessary, rinse with distilled water.
- Use a consistent sample volume and container: A small container that fully covers the sensor’s optical gap gives more stable readings.
- Stir gently, then wait: After stirring a sample, wait 10–20 seconds for large particles to settle a bit and the reading to stabilize.
Electronics and noise
- Use a stable power supply: If you power Arduino from a noisy source, the ADC readings may fluctuate. A clean 5 V supply helps.
- Average multiple readings: In code, take many samples (for example, 100–800) and average them to reduce noise.
- Keep wiring short: Long wires can pick up noise and slightly shift the voltage levels.
Calibration best practices
- Calibrate in conditions similar to your actual use: temperature and the type of particles can affect optics, so calibrate with similar water (e.g., river water vs tap water).
- Re‑check calibration periodically: Sensor drift, LED aging, and dirt can change the relationship between voltage and NTU over time.
- Understand the sensor’s limitations: Low‑cost sensors are great for education, trend monitoring, and DIY water quality stations. They are not a substitute for calibrated laboratory or portable turbidimeters if you need regulatory‑grade accuracy or very low NTU (sub‑1 NTU) resolution.
Where to Use an Arduino Turbidity Meter
You can deploy a small Arduino turbidity sensor in many real‑world scenarios:
- Home aquariums and hydroponics: Detect when water gets too cloudy and trigger a filter or pump.
- Environmental education: Teach students about water quality by comparing river, pond, and tap water.
- Community monitoring: Track stormwater runoff events or construction site impacts on local streams (turbidity spikes are common during rain).
- Rural or off‑grid water supplies: Continuously monitor source water turbidity to decide when to filter or avoid drawing water.
Limitations and When to Use Professional Instruments
- Limited low‑range accuracy: Below about 1–2 NTU, low‑cost sensors may struggle to distinguish fine differences. Professional turbidimeters use sophisticated optics and signal processing to measure down to 0.01 NTU or better.
- Particle‑type dependence: Different particles (e.g., clay vs algae) scatter light differently. Your calibration may not transfer perfectly from one water type to another.
- Regulatory compliance: If you need data for permits, compliance, or official reports, you typically need a calibrated instrument that meets standard methods (for example, EPA‑approved methods or ISO 7027).
Frequently Asked Questions
Can I use this Arduino turbidity sensor to check if my drinking water is safe?
No. This sensor is excellent for education and trend monitoring, but it is not certified for regulatory compliance. Use it as an early‑warning tool to spot large changes or very high turbidity. For drinking‑water safety, rely on your water utility’s tests or a certified laboratory.
Why does the voltage drop when turbidity increases?
The sensor’s LED and detector face each other across a small gap. Particles between them scatter and absorb light, so less light reaches the detector. The detector’s resistance changes, and the module’s output voltage drops with higher turbidity.
Do I need an I2C LCD, or can I just use the Serial Monitor?
You can start with just the Serial Monitor: this is the simplest setup for testing and learning. Add an I2C LCD when you want a standalone meter that doesn’t require a computer.
How often should I recalibrate?
Recalibrate whenever you change the sensor, if readings start to drift, or at least every few months for long‑term deployments. A quick check with two points (clean water and one standard) is often enough.
Summary
You can measure turbidity reliably enough for many practical purposes by:
- Understanding that turbidity is an optical measure of water clarity, reported in NTU, and closely linked to the amount of suspended particles like silt, clay, algae, and microorganisms.
- Using a simple analog turbidity module with an Arduino to read a voltage that decreases as turbidity increases.
- Calibrating the sensor with at least two known turbidity standards and converting voltage to NTU with a suitable equation, such as the widely used 5 V quadratic fit.
- Averaging readings, keeping the sensor clean, avoiding bubbles, and periodically checking calibration.
With these steps, you’ll have a functional, low‑cost turbidity meter that you can extend into a full water quality monitoring system by adding pH, TDS, temperature, or IoT connectivity.
