IE-222

Lab No:14
Name: Pak No:
NS TOSEEQ 222609
AC MUSHAF 22099038
AC UZAIR 22099026
DS FAHAD 22036008
Section:
99(B)
Submitted to:
LAB ENGG ARSHAD

LAB TITLE:
 Water Flow Measurement Using Arduino And Flow
Meter Sensor:
Objective:
Our objective is to connect the flow meter with the Arduino uno and use it to
measure the flow.Flow meter sensor works on Hall Effect.
Hall Effect:
 The Hall effect is the production of a potential difference (the Hall voltage)
across an electric conductor that is transverse(perpendicular) to an electric
current in the conductor and to an applied magnetic field perpendicular to
the current.
 The Hall effect is the deflection of electrons (holes) in an n-type (p-type)
semiconductor with current flowing perpendicular to a magnetic field.The
deflection of these charged particles sets up the voltage called the Hall
voltage, whose polarity depends on the effective charge of the carrier.

Flow Sensor:
 A flow sensor is an electronic device that measures or regulates the flow
rates of liquids and gasses within the pipes.
Flow sensors are generally connected to gauges to render their
measurements, but they can also be connected to computers and digital
interfaces.
Difference Between Flow Sensor And Flow Meter:
A flow sensor is a device that detects and measures fluid flow, providing
essential data on flow rates.
Conversely, a flow meter includes a flow sensor but also features additional
components like a display or transmitter, which help present and interpret
the flow data in a user-friendly manner.
A Flow meter is a device that can measure the rate of flow (Volume of fluid
that passes per unit time) and total flow of any liquid or and gas/air that
passes through it.

Working:
  The main components are the Hall Effect sensor, turbine wheel, and magnet.
 The water flows in through the inlet and out through the outlet.
 The water current drove the wheel to turn, and the magnet on the wheel
turned with it.
 Magnetic field rotation triggers the Hall sensor, which outputs high and low
level square waves(pulse)
 For every round of the wheel, the volume of water flowing through is a
certain amount, as is the number of square waves output.
 We can calculate the flow of water by counting the number of square
waves(pulse)
Components:
1-Arduino UNO
2-Flow Sensor YF-S201
3-Jumper wires
Lab Task:

Code:
byte statusLed = 13;
byte sensorInterrupt = 0; // 0 = digital pin 2
byte sensorPin = 2; // The Hall-effect sensor is connected to pin 2 which uses interrupt 0.
// The hall-effect flow sensor outputs approximately 4.5 pulses per . second per
// litre/minute of flow.
float calibrationFactor = 4.5;
volatile byte pulseCount;
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
void setup()
{ Serial.begin(9600); // Initialize a serial connection for reporting values to the host
pinMode(statusLed, OUTPUT); // Set up the status LED line as an output
digitalWrite(statusLed, HIGH); // We have an active-low LED attached
pinMode(sensorPin, INPUT);
digitalWrite(sensorPin, HIGH);
pulseCount = 0;
flowRate = 0.0;
flowMilliLitres = 0;
totalMilliLitres = 0;
oldTime = 0;
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
} // Configured to trigger on a FALLING state change (transition from HIGH // state to LOW
state)
void loop()
{
if((millis() - oldTime) > 1000) // Only process counters once per second
{
detachInterrupt(sensorInterrupt) // Disable the interrupt while calculating flow
// rate and sending the value to the host
// Because this loop may not complete in exactly 1 second
//intervals we calculate
// the number of milliseconds that have passed since the last execution and use
// that to scale the output. We also apply the calibrationFactor to scale the output
// based on the number of pulses per second per units of measure (litres/minute in // this case)
coming from the sensor.
flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
// Note the time this processing pass was executed. Note that because we've
// disabled interrupts the millis() function won't actually be incrementing right
// at this point, but it will still return the value it was set to just before
// interrupts went away.
oldTime = millis(); // Divide the flow rate in litres/minute by 60 to determine how many litres
have
// passed through the sensor in this 1 second interval, then multiply by 1000 to
// convert to millilitres.
flowMilliLitres = (flowRate / 60) * 1000; // Add the millilitres passed in this second to the
cumulative total
totalMilliLitres += flowMilliLitres;
unsigned int frac; // Print the flow rate for this second in litres / minute
Serial.print("Flow rate: ");
Serial.print(int(flowRate)); // Print the integer part of the variable
Serial.print("L/min");
Serial.print("\t"); // Print tab space
// Print the cumulative total of litres flowed since starting
Serial.print("Output Liquid Quantity: ");
Serial.print(totalMilliLitres);
Serial.println("mL");
Serial.print("\t"); // Print tab space o Serial.print(totalMilliLitres/1000); o Serial.print("L"); //
Reset the pulse counter so we can start incrementing again
pulseCount = 0; // Enable the interrupt again now that we've finished sending output
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
}
}
void pulseCounter()
{ // Increment the pulse counter
pulseCount++;
}

Output: