Mini Water Pump Guide: DC Submersible & Peristaltic Pumps for Arduino

A mini water pump opens up an enormous range of maker projects — from automated plant watering systems and aquarium circulators to lab-grade chemical dosing and household water features. The challenge is that there are several fundamentally different types of small DC pumps, each with distinct advantages and ideal applications. This guide explains how submersible centrifugal pumps, peristaltic pumps, and diaphragm pumps work, how to wire them to an Arduino, and which to choose for your project.

Types of Mini Water Pumps

The three main categories of mini pumps used in maker and hobbyist projects are centrifugal submersible pumps, peristaltic pumps, and diaphragm pumps. They work on completely different physical principles and are suited to different tasks:

• Centrifugal submersible pumps: The simplest and cheapest type. Submerged in the liquid, they use a spinning impeller to accelerate fluid outward. Best for high flow rate, low-precision applications like aquariums and fountains.
• Peristaltic pumps: Use rotating rollers to squeeze a flexible tube, pushing fluid through without any contact between the fluid and the motor mechanism. Ideal for precise dosing, food-safe applications, and pumping corrosive or contaminated fluids.
• Diaphragm pumps: Use a vibrating diaphragm to push and pull fluid through check valves. Self-priming, can run dry briefly without damage, and can pump gas-liquid mixtures. Used in portable water dispensers and garden sprayers.

DC Submersible Centrifugal Pumps

DC submersible pumps are the most common type used in maker projects. They consist of a small brushed or brushless DC motor sealed inside a waterproof housing, with an impeller that spins to move water. The entire unit sits inside the liquid being pumped — this design keeps the motor cool and eliminates the need for shaft seals.

How they work: The spinning impeller creates a low-pressure zone at the inlet (centre of the impeller) and high pressure at the outlet (periphery). Water flows in due to the pressure difference and is thrown outward by centrifugal force. The flow rate depends on pump speed (voltage) and head pressure (height of water to be lifted).

Typical specifications of a 12V mini submersible pump:

• Voltage: 5V, 6V, or 12V DC (match to your power supply)
• Flow rate: 100–600 litres/hour (LPH) depending on size
• Max head: 0.5m to 3m (the maximum height the pump can push water against gravity)
• Current draw: 0.3A–2A depending on voltage and load
• IP rating: IPX8 (fully submersible)

Applications:

• Aquarium water circulators and biological filter pumps
• Decorative fountains and water features
• Drip irrigation systems for gardens and balconies
• Coolant circulation in small 3D printer hot ends or electronics cooling loops
• Hydroponic and aeroponic growing systems

Peristaltic Pumps

A peristaltic pump moves fluid by squeezing a flexible tube between rotating rollers and the pump housing. As the rollers rotate, they create a sealed pocket of fluid between two contact points on the tube and push that pocket forward through the tubing. The fluid never contacts the pump mechanism itself — only the inner wall of the tubing.

Key advantages of peristaltic pumps:

• Fluid isolation: Pumped fluid never contacts the motor or gears — eliminates contamination risk. Safe for food, pharmaceuticals, and laboratory chemicals.
• Reversible: Run the motor in reverse to pull fluid back into the reservoir instead of pushing forward.
• Self-priming: Can draw fluid upward from a reservoir below the pump without pre-filling.
• Precise dosing: Flow rate is directly proportional to motor speed — no turbulence or cavitation effects. Each revolution of the pump head delivers a fixed, predictable volume.
• Run dry capability: Short dry-run periods will not damage the pump (unlike centrifugal pumps which overheat when run dry).

Applications:

• Chemical dosing in aquariums (pH adjusters, fertilisers, nutrient solutions)
• Coffee and beverage dispensing machines
• IV-style drip systems for plant propagation
• Ink delivery in plotters and print systems
• Any application where the fluid must not contact the pump mechanism

Limitation: Peristaltic pumps have lower flow rates than centrifugal pumps of the same motor size, and the tubing wears out over time from repeated squeezing — replace the silicone tube periodically (usually every 6–12 months in continuous use).

Diaphragm Pumps

Diaphragm pumps use an oscillating flexible membrane (diaphragm) and one-way check valves to move fluid. As the diaphragm moves one way, it expands the pump chamber and pulls fluid in through the inlet check valve. As it moves the other way, it compresses the chamber and pushes fluid out through the outlet check valve.

Key characteristics:

• Self-priming even when the inlet tube is long
• Can pump gas-liquid mixtures (useful for carbonated liquids or de-aeration)
• Creates pulsating flow (not smooth like centrifugal or peristaltic pumps)
• Can generate moderate back pressure
• More complex and expensive than submersible centrifugal pumps

Diaphragm pumps are commonly used in portable garden sprayers, RO (reverse osmosis) water purifiers, and portable pressure washers. For Arduino maker projects, they are less common than submersible pumps due to higher cost and pulsating output.

Specs Comparison Table

Wiring a DC Pump with MOSFET to Arduino

For most DC pumps (5V–24V), the best way to control them from an Arduino is through a logic-level MOSFET such as the IRLZ44N or IRL520N. A MOSFET switches the pump power on and off using a small gate signal from the Arduino GPIO pin, and supports PWM speed control.

Wiring: Arduino + MOSFET + 12V DC Pump

Arduino Pin 9 (PWM) ---[220 ohm resistor]--- MOSFET Gate
Arduino GND ----------------------------------------- MOSFET Source
MOSFET Drain ---------------------------------------- Pump negative terminal
12V power supply + ---------------------------------- Pump positive terminal
12V power supply - ---------------------------------- Arduino GND (COMMON GROUND!)

Also add:
- 1N4007 flyback diode across pump terminals (cathode to +, anode to -)
  This protects the MOSFET from back-EMF voltage spikes when pump stops

MOSFET selection: Use IRLZ44N or IRFZ44N for 12V pumps
These are logic-level MOSFETs that fully switch on with 5V gate voltage
Regular MOSFETs (IRF540) need 10V+ gate and will not work with Arduino

Wiring a Pump with Relay Module

For pumps that only need on/off control (no speed regulation), a relay module is even simpler. Relay modules for Arduino use 5V control signals and can switch pump voltages up to 240V AC or 30V DC at 10A — easily handling any DC pump.

// Relay module wiring (active LOW relay typical)
// Relay Module    Arduino
// VCC         --> 5V
// GND         --> GND
// IN          --> Pin 7

// Pump wiring through relay:
// 12V supply + --> Relay COM terminal
// Relay NO terminal --> Pump positive
// Pump negative --> 12V supply -

const int relayPin = 7;

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH); // HIGH = relay OFF (active LOW module)
}

void loop() {
  // Pump ON for 10 seconds
  digitalWrite(relayPin, LOW);  // LOW = relay ON
  delay(10000);
  
  // Pump OFF for 50 seconds
  digitalWrite(relayPin, HIGH); // HIGH = relay OFF
  delay(50000);
}

PWM Flow Rate Control

With a MOSFET, you can control pump speed using PWM. Lower duty cycle = lower voltage average = slower impeller = less flow. This is useful for aquarium systems where you want a gentle trickle rather than full blast, or for plant watering systems where you want to precisely control water delivery volume over time.

// PWM pump speed control via MOSFET
const int pumpPin = 9; // Must be a PWM pin (3,5,6,9,10,11 on Uno)

void setup() {
  pinMode(pumpPin, OUTPUT);
  Serial.begin(9600);
}

void setPumpSpeed(int percent) {
  // percent: 0 to 100
  int pwmValue = map(percent, 0, 100, 0, 255);
  analogWrite(pumpPin, pwmValue);
  Serial.print("Pump speed: ");
  Serial.print(percent);
  Serial.println("%");
}

void loop() {
  setPumpSpeed(100); delay(5000); // Full speed for 5 seconds
  setPumpSpeed(50);  delay(5000); // Half speed for 5 seconds
  setPumpSpeed(25);  delay(5000); // Quarter speed for 5 seconds
  setPumpSpeed(0);   delay(5000); // Off for 5 seconds
}

// Note: Most DC pumps have a minimum PWM duty cycle (typically 30-50%)
// below which they stall. Test your specific pump to find its minimum.

Automatic Plant Watering Project

This is one of the most popular beginner projects combining a mini water pump with Arduino. The system reads soil moisture, and when moisture drops below a threshold, the pump activates for a set duration to water the plant.

#include <Arduino.h>

const int moistureSensorPin = A0; // Capacitive or resistive moisture sensor
const int pumpRelayPin = 7;       // Relay module IN pin

// Calibration values - adjust for your sensor
const int DRY_THRESHOLD = 600;   // ADC reading when soil is dry
const int WET_THRESHOLD  = 300;  // ADC reading when soil is wet enough

const unsigned long PUMP_ON_TIME  = 5000;  // Pump runs 5 seconds per cycle
const unsigned long CHECK_INTERVAL = 60000; // Check moisture every 60 seconds

unsigned long lastCheckTime = 0;

void setup() {
  pinMode(pumpRelayPin, OUTPUT);
  digitalWrite(pumpRelayPin, HIGH); // Relay OFF (active LOW module)
  Serial.begin(9600);
  Serial.println("Plant watering system started");
}

void loop() {
  if (millis() - lastCheckTime >= CHECK_INTERVAL) {
    lastCheckTime = millis();
    
    int moisture = analogRead(moistureSensorPin);
    Serial.print("Moisture reading: ");
    Serial.println(moisture);
    
    if (moisture > DRY_THRESHOLD) {
      Serial.println("Soil is dry - watering...");
      digitalWrite(pumpRelayPin, LOW);  // Pump ON
      delay(PUMP_ON_TIME);
      digitalWrite(pumpRelayPin, HIGH); // Pump OFF
      Serial.println("Watering done");
    } else {
      Serial.println("Soil moisture OK - no watering needed");
    }
  }
}

Important: Always test the pump current draw with a multimeter before final assembly. A 12V submersible pump typically draws 300–800mA. Relay modules can handle this easily; if using a MOSFET, ensure it is rated for the pump’s peak stall current (usually 2–3x the running current).

Aquaponics and Aquarium Applications

For aquariums and aquaponics systems, submersible pumps run continuously to circulate water through biological filters. Key considerations:

• Flow rate sizing: For aquariums, a common rule is to turn over the total tank volume 4–6 times per hour. A 60-litre tank needs a 240–360 LPH pump minimum.
• Head pressure: If pumping water from the sump to an overhead grow bed (aquaponics), measure the vertical height and choose a pump with sufficient head pressure. A pump rated for 1.5m head can push water 1.5 metres vertically at near-zero flow rate.
• Noise: Cheap brushed DC pumps can be noisy. Look for pumps described as “mute” or “silent” — these use magnetic coupling or rubber-mounted impellers to reduce vibration transmission.
• Power failure safety: For valuable aquariums, consider a UPS or battery backup for the circulation pump. Fish can survive surprisingly long without food, but will die quickly without oxygen from water movement.

Measuring Flow Rate

For applications where precise water volume matters (dosing, billing, water management), add a Hall-effect flow sensor (like the YF-S201) to your circuit. These sensors generate one pulse per fixed volume of water flowing through them.

// YF-S201 Flow Sensor - measure litres dispensed
volatile int pulseCount = 0;
const float calibrationFactor = 7.5; // Pulses per litre per minute

void pulseCounter() {
  pulseCount++;
}

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), pulseCounter, FALLING);
  Serial.begin(9600);
}

void loop() {
  // Measure flow over 1 second
  pulseCount = 0;
  interrupts();
  delay(1000);
  noInterrupts();
  
  float flowRate = ((1000.0 / 1000) / calibrationFactor) * pulseCount;
  float totalLitres = pulseCount / calibrationFactor / 60.0;
  
  Serial.print("Flow rate: ");
  Serial.print(flowRate);
  Serial.print(" L/min | Total: ");
  Serial.print(totalLitres, 3);
  Serial.println(" L");
}

Pump Lifespan and Maintenance

Submersible centrifugal pumps: Lifespan of 2,000–10,000 hours depending on quality. Main failure modes are impeller wear (from particles in water), bearing wear, and magnet degradation. Extend life by filtering the water before it reaches the pump inlet, keeping the pump fully submerged at all times (running dry even briefly overheats and destroys the motor), and running the pump at moderate speed rather than maximum voltage.

Peristaltic pumps: The tubing is the consumable component. Silicone tubing lasts 1,000–3,000 hours in continuous use. The pump head mechanism (rollers and housing) lasts much longer. Replace tubing when you notice flow rate dropping (tube has deformed and lost its round cross-section) or any leakage from tube pinch points.

General tips for all pump types:

• Always use the correct voltage — overvoltage dramatically reduces bearing and magnet lifespan
• Keep the water clean and filtered to prevent abrasive particles from wearing the impeller or tubing
• For seasonal projects (outdoor garden systems), flush and drain the pump before storing it — residual water grows algae and can freeze in winter
• Check connections and tubing for calcium scale buildup in hard water areas — flush with diluted citric acid solution annually
• If a pump makes new grinding or rattling sounds, inspect for debris caught in the impeller before the damage spreads

Frequently Asked Questions

Q: Can I power a 12V submersible pump directly from Arduino?

No. The Arduino 5V pin can only supply 500mA and cannot output 12V at all. Use a separate 12V DC adapter and control the pump through a relay module or logic-level MOSFET. Connect the grounds of the Arduino and the 12V supply together (common ground) so the MOSFET gate signal works correctly.

Q: What is the difference between a submersible pump and an inline pump?

A submersible pump is designed to operate with its motor fully submerged in the liquid. An inline (or external) pump is mounted outside the water and connected to the plumbing with inlet and outlet pipes. Submersible pumps are simpler, quieter, and less prone to air-lock issues. Inline pumps are easier to service and are preferred when the pump must sit in a dry enclosure or cannot be submerged.

Q: Can I control pump speed with PWM?

Yes, for brushed DC submersible pumps. Use a logic-level MOSFET (IRLZ44N) on a PWM pin. However, there is a minimum duty cycle (typically 30–50%) below which most pumps stall due to insufficient starting torque. Test your specific pump to find its operational PWM range. Peristaltic pumps are even more amenable to PWM control because their flow rate is directly proportional to motor speed.

Q: How do I prevent my plant watering pump from running dry?

Add a float switch or ultrasonic level sensor to detect when the water reservoir is empty, and add logic to cut pump power before it runs dry. Alternatively, use a peristaltic pump positioned above the water level — if the reservoir empties, the peristaltic pump simply stops moving water (it does not overheat when pumping air briefly), unlike submersible centrifugal pumps which can burn out in minutes when running dry.

Q: What GPH or LPH pump do I need for my aquaponics system?

Calculate your total water volume (tank + sump + pipes) in litres, then multiply by 4–6 for an adequate turnover rate per hour. For a 100-litre system, you need 400–600 LPH. Add extra capacity for head pressure losses — a pump rated for 800 LPH at zero head may only deliver 400 LPH at 1 metre of vertical lift. Always check the pump’s head-vs-flow curve in the datasheet.