Flow Rate Sensor Arduino Guide: Wiring, Code, and Debugging the YFS201

The YFS201 flow rate sensor outputs exactly 4.5 pulses per second for every Liter per minute (L/min) of water passing through it. To read this with an Arduino, you must connect the yellow signal wire to a hardware interrupt pin (Pin 2 on the Uno R3), use a 10kΩ pull-up resistor to 5V, and measure the pulse frequency over a 1-second window. This guide targets the Arduino Uno R3 (ATmega328P) and provides the exact hardware debounce circuit and non-blocking C++ code required to get stable, noise-free readings on the bench.

Project Specs & Parts List

Most generic tutorials tell you to wire the sensor directly to the Arduino. In practice, the long cables and switching pumps in water systems generate electromagnetic interference (EMI) that causes "ghost pulses." The parts list below includes the passive components needed to filter this noise.

Pin Mapping & Wiring Steps

The YFS201 has three wires: Red (VCC), Black (GND), and Yellow (Signal). The sensor operates on 5V to 18V, but since the Arduino Uno's ATmega328P GPIO pins are not 5V-tolerant above 5V (and the sensor outputs a 5V square wave when powered at 5V), we power it directly from the Uno's 5V rail.

Numbered Wiring Steps with Hardware Debounce

1. Power the sensor: Connect the Red wire to the Arduino 5V pin and the Black wire to GND.
2. Install the pull-up resistor: Insert a 10kΩ resistor on your breadboard. Connect one leg to the 5V rail and the other leg to the row where the Yellow signal wire will terminate. This ensures the signal line rests at a clean HIGH state when the internal open-collector transistor is off.
3. Install the debounce capacitor: Insert a 0.1µF ceramic capacitor. Connect one leg to the Yellow signal wire row and the other leg to GND. This creates a low-pass filter that absorbs nanosecond EMI spikes from nearby pump motors.
4. Connect the signal: Run a jumper wire from the Yellow signal row (where the resistor and capacitor meet) to Digital Pin 2 on the Arduino.
5. Verify connections: Use a multimeter in continuity mode to verify there are no shorts between 5V and GND before powering on the board.

Compilable Arduino Code with Interrupt Handling

The following code uses attachInterrupt() to count pulses without blocking the main loop. It samples the pulse count exactly every 1000ms using millis(), calculates the flow rate, and includes error handling for sensor overflow or disconnected states. For a deeper understanding of how hardware interrupts map to specific pins across different AVR boards, refer to the official Arduino attachInterrupt reference.

/*
 * YFS201 Flow Rate Sensor - Non-Blocking Interrupt Code
 * Target Board: Arduino Uno R3 (ATmega328P)
 * Signal Pin: Digital 2 (INT0)
 */

const byte SENSOR_PIN = 2; 
const unsigned long SAMPLE_INTERVAL = 1000; // 1 second sample window

// Volatile variables modified inside the ISR
volatile unsigned long pulseCount = 0;

unsigned long previousMillis = 0;
float flowRateLPM = 0.0;
float flowRateGPM = 0.0;

// Sensor specification: 4.5 pulses per second per L/min
const float PULSE_FACTOR = 4.5; 
const float MAX_THEORETICAL_LPM = 120.0; // YFS201 max rated flow

void setup() {
  Serial.begin(115200);
  Serial.println("YFS201 Flow Sensor Initialized...");
  
  // Pin 2 is configured as input. The external 10k pull-up handles the bias.
  pinMode(SENSOR_PIN, INPUT);
  
  // Attach interrupt on FALLING edge. 
  // Do NOT use CHANGE, or you will double-count the pulses.
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), pulseISR, FALLING);
}

void loop() {
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= SAMPLE_INTERVAL) {
    previousMillis = currentMillis;
    
    // Critical: Disable interrupts while copying the volatile variable
    // to prevent a race condition if a pulse arrives mid-copy.
    noInterrupts();
    unsigned long safePulseCount = pulseCount;
    pulseCount = 0; // Reset for the next window
    interrupts();

    // Calculate Frequency (Hz) = Pulses per second
    float frequency = safePulseCount; 
    
    // Error Handling: Check for disconnected sensor or impossible overflow
    if (frequency == 0 && flowRateLPM > 0) {
      // Flow stopped
      flowRateLPM = 0.0;
      flowRateGPM = 0.0;
    } 
    else if ((frequency / PULSE_FACTOR) > MAX_THEORETICAL_LPM) {
      Serial.println("ERR: FLOW_OVERFLOW - Check for EMI or ghost pulses!");
    } 
    else {
      // Q (L/min) = Frequency (Hz) / 4.5
      flowRateLPM = frequency / PULSE_FACTOR;
      flowRateGPM = flowRateLPM * 0.264172; // Liters to US Gallons
    }

    // Output Data
    Serial.print("Pulses: ");
    Serial.print(safePulseCount);
    Serial.print(" | Flow: ");
    Serial.print(flowRateLPM, 2);
    Serial.print(" L/min | ");
    Serial.print(flowRateGPM, 2);
    Serial.println(" GPM");
  }
}

// Interrupt Service Routine (ISR)
void pulseISR() {
  pulseCount++;
}

Debugging: First Three Things to Check When It Fails

When your serial monitor isn't behaving, don't start rewriting code. Embedded sensor failures almost always trace back to physics or pin mapping. Check these three items first:

1. Symptom: "Ghost pulses" (Reading 5-15 L/min when water is completely off).
   Cause: EMI from nearby wires or a floating signal pin.
   Fix: Verify your 10kΩ pull-up resistor and 0.1µF capacitor are physically installed on the breadboard. The open-collector output of the YFS201 acts like an antenna without a pull-up, picking up 50/60Hz mains noise and triggering the interrupt.
2. Symptom: Flow rate reads exactly double the actual physical flow.
   Cause: Incorrect interrupt trigger mode.
   Fix: Check your attachInterrupt() function. If you used CHANGE, the Arduino fires the ISR on both the rising and falling edges of the square wave, doubling your count. Change it to FALLING or RISING to count only one edge per pulse cycle.
3. Symptom: Serial monitor reads 0.00 L/min while water is flowing.
   Cause: Wrong interrupt vector / pin mapping mismatch.
   Fix: The code above targets the Uno R3, where Pin 2 is INT0. If you uploaded this exact code to an Arduino Mega 2560, Pin 2 is not an interrupt pin (Pins 2, 3, 18, 19, 20, 21 are interrupts on the Mega). Move the yellow wire to Pin 18 on the Mega, or use digitalPinToInterrupt() which the code already includes to handle the translation safely.