Tan Wei Kang, Khilfie Adly B Muhlan, Soh Wei Kang

Published November 6, 2019

Smart Building: Household Utility Monitoring System

Use flow rate sensor to capture water consumption in household and provide visual information via web apps.

BeginnerFull instructions providedOver 3 days1,366

Top 3 Projects

Sigfox Universities Challenge 2019

Smart Building: Household Utility Monitoring System

Things used in this project

Hardware components

Arduino Nano R3

Pycom SiPy

Digilent 60W PCIe 12V 5A Power Supply

Bilge Pump 12V 360GPH

Linear Regulator (7805)

Rocker Switch, Splash Proof

Terminal Block Interface, Terminal Block

Jumper wires (generic)

Toggle Switch, Metal Lever

StripBoard (Veroboard)

Capacitor 470 µF

Capacitor 100 µF

DC Power Connector, Socket

Heat Sink, Panel

Plastic Enclosure, Hand-Held Plastic Box Style 2

Flow Sensor, Pulsed Output

Software apps and online services

Pycom Visual Studio Code (Pymakr)

Arduino IDE

ThingSpeak API

Hand tools and fabrication machines

Drill / Driver, Cordless

Track Cutter, Stripboard

Soldering iron (generic)

Solder Wire, Lead Free

Solder Flux, Soldering

Multitool, Screwdriver

Story

1.0 Background:

The project aims to use a flow-rate sensor to capture water consumption of a household and upload the information of water used and water bill to the web to allow residents to view them in smart devices.

2.0 Project planning:

We made use of a DC pump to simulate water flow into the household. The pump speed is varied by a voltage controller to assimilate real-life conditions of varying water flowing over time. The water pump and flow rate sensor are mounted along a water piping to detect the amount of water flow into the household.

Figure 1 shows the construction of the Liquid Flow Sensor and Bilge Pump mounted below in a water container.

Figure 1

Figure 1 Flow Sensor & Pump Installation

3.0 Interface Board

Figure 2 shows the construction of the interfacing board between the controller boards and sensors.

Figure 2

Figure 2 Interfacing Board

3.1 Two-Speed Pump design

Pump speed is controlled by changing the operating voltage to either 12V or 9V to change the flow rate of the pump. A toggle switch is used to change the pump speed for the project.

3.2 Liquid Flow Rate Sensor

A Liquid flow rate sensor is used to detect the amount of water flow over time. Arduino Nano board is used to capture and compute the pulses of voltage generated by the flow rate sensor.

Figure 3 show the connection of Flow Rate sensor with Nano Board.

Figure 3 Lquid Flow Rate Sensor connection

3.3 Power Supply for Nano & SiPy Board

The main 12V power supply from the adaptor to the power jack is connected directly to pump and also to 5V regulator for Arduino Nano & SiPy board.

3.4 Logic Shifter (Logic Converter)

The 5V output from Arduino Nano is sent to a voltage divider to convert the data to 3.3V. For this resistor network, we are using 220 ohm and 470 ohm resistors.

Figure 4 shows the schematic of a logic shifter

Figure 4 Voltage Divider for 3.3V interface with SiPy

3.5 ON/OFF Switch

We are using a rocker switch to cut off overall power supply when not using.

3.6 Schematic circuit drawing

Figure 5 Power Supply and control for the prototype

4.0 Softwarefor thePrototype

4.1 We are using Arduino 1.8.8 IDE for our Arduino Board development.

4.2 We are using Visual Studio Code 1.39.1 for SiPy Board development.

4.3 We are using Thinkspeak for our cloud display and data analytics.

5.0 Thinkspeak Account & Password

Our group used Thinkspeak account with email m6.iot06@gmail.com and password is Ite123456

Figure 6 Thinkspeak Account

6.0 Project Result and Outcomes

6.1 Arduino output

Figure 7 shows the flow rate result from Arduino output.

Figure 7 Arduino Output Monitor

6.2 Thinkspeak Raw Upload (High/Low Byte)

Figure 8 shows Thinkspeak raw upload data. SiPy board upload decimal value in High Byte and Low Byte format to represent number before decimal (High byte) and number after the decimal (Low Byte) to Thinkspeak.

Figure 8 Raw data with High Byte & Low Byte

6.3 Thinkspeak Matlab Analysis output

Matlab Analytic recombine the High byte number together with the Low byte number to recover the decimal value of the volume of water and bill computation.

Figure 9 shows the graphical representation of the actual flow rate and overall consumption with the respective water bill as of that instant.

Figure 9 Flowrate, Total consumption and water bill computation

6.4 Prototype in action

Prototype in Action

6.5 Comment on the output data

Flowrate graph shows peak and dips along with time. This indicates water flow varies with time due to change in water consumption over the daytime and night time.

The Total consumption graph shows the cumulative volume consumed at any one time. It has a positive gradient.

Total Billing is the computation of the cost per meter cube multiply with the cubic meters of the water consumed.

In this case, the cost per cubic meters in Singapore is estimated at S$2.70/m3.

Total Billing graph is in positive gradient profile as Total consumption graph as both indicate total water consumed.

Overall both hardware and software of the prototype are working well and displayed data tallied well with the real-time conditions. The upload timing is reasonably prompt with very minimal latency (~ a few seconds).

7.0 Power source & battery life

With the current battery technology, we can have a high current capacity rechargeable lithium-ion battery. Currently, the available battery is shown in Figure 10.

Figure 10 1200mAH Lithium Rechargeable 9V battery

Battery life calculation as follow:

The device consumed approximately 16mA when active and negligible when in deep sleep.

Assuming average water flow per day is 2hour, then 1200mAH can last for 60 hours or approximately one month.

Of course, we can further explore the self-charging capability from the water flow in the pipe. We shall exclude the scope of this for this competition.

Alternatively, we can also use a portable 10000mAH power bank pack for the prototype which may last more than 10 months.

8. Prototype Appearance

Figure 11 shows the complete assembly of the prototype.

Figure 11 Appearance

9. Reflection

The team had work hard on this project. We have overcome many setbacks and challenges throughout the development of the prototype.

Gathering the fund for the project was our first challenge and we managed to get the school project fund to kick off this project.

The timeline was very tight as most of us have other commitments to our course of study. We planned and commit our schedule wholeheartedly.

Technically, the sensor testing went off well and all circuitries were tested out smoothly. There were some minor heat dissipation problems and we resolved it by using a heat sink.

The most challenging of all was to learn how to use SiPy board and the Visual Studio Code.

Registering the board took us quite a while and then coding using Visual Studio code was new to us.

We manage to get things done via web guide and advice from seniors. We would like to thank Sipy Pycom web help and guidance, and all helpful web pages pertaining to Sipy and Visual Studio Coding which we had learned to use them in our project development.

We also wish to express our thank to the organiser of this event to provide us with the hardware Sipy PyCom board for us to explore at the very early stage of the project development phase.

Schematics

Code

% Read flowrate_H and flowrate_L and total consumption from a public ThingSpeak channel created


% Channel ID to read data from 
readChID = 888517; 
   
% Obtain the channel ID and write API key for your channel 
% Replace [] with your channel ID 
writeChID = 890527; 
% Enter your Write API Key between the '' 
writeAPIKey = '1VNEDKGLY4QK417D'; 
   
% Read air temperature, time stamps, and wind speed from weather station 
[Flowrate_H] = thingSpeakRead(readChID,'Fields',1);
[Flowrate_L] = thingSpeakRead(readChID,'Fields',2);
[Total_Consumption_H] = thingSpeakRead(readChID,'Fields',3);
[Total_Consumption_L,time] = thingSpeakRead(readChID,'Fields',4); 
   
% Calculate and display flowrate data 
Flowrate = Flowrate_H + (Flowrate_L * 0.1); 
display(Flowrate,'FlowRate '); 

% Calculate and display total consumption data 
Total_Consumption = Total_Consumption_H + (Total_Consumption_L * 0.01); 
display(Total_Consumption,'Total_Consumption'); 

% Calculate billing
Total_Billing = (Total_Consumption *0.001) * 2.7
display(Total_Billing,'Total Billing (S$)'); 

% Plot flowrate and total_consumtion to your channel 
thingSpeakWrite(writeChID,[Flowrate,Total_Consumption,Total_Billing],'Fields',[1,2,3],... 
'TimeStamps',time,'WriteKey',writeAPIKey);

/*
Liquid flow rate sensor -DIYhacking.com Arvind Sanjeev

Measure the liquid/water flow rate using this code. 
Connect Vcc and Gnd of sensor to arduino, and the 
signal line to arduino digital pin 2.
 
 */
#include <SoftwareSerial.h>

SoftwareSerial nanoSend(3,4); //Rx,Tx

byte statusLed    = 13;

byte sensorInterrupt = 0;  // 0 = digital pin 2
byte sensorPin       = 2;

// 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 frac;
unsigned int flowMilliLitres;
//unsigned long totalMilliLitres;
float totalMilliLitres;
unsigned long oldTime;
unsigned long oldTime1;

void setup()
{
  
  // Initialize a serial connection for reporting values to the host
  Serial.begin(9600);
  nanoSend.begin(9600); 
  // Set up the status LED line as an output
  pinMode(statusLed, 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;

  // The Hall-effect sensor is connected to pin 2 which uses interrupt 0.
  // Configured to trigger on a FALLING state change (transition from HIGH
  // state to LOW state)
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
}

/**
 * Main program loop
 */
void loop()
{
   
   if((millis() - oldTime) > 5000)    // Only process counters once per second
  { 
    // Disable the interrupt while calculating flow rate and sending the value to
    // the host
    detachInterrupt(sensorInterrupt);
        
    // 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.
    
    
    // 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)* 0.001;
      
  
    
    // 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(".");             // Print the decimal point
    // Determine the fractional part. The 10 multiplier gives us 1 decimal place.
    frac = (flowRate - int(flowRate)) * 10;
    Serial.print(frac, DEC) ;      // Print the fractional part of the variable
    Serial.print("L/min");
    // Print the number of litres flowed in this second
    /*Serial.print("  Current Liquid Flowing: ");             // Output separator
    Serial.print(flowMilliLitres);
    Serial.print("mL/Sec");*/

    // Print the cumulative total of litres flowed since starting
    Serial.print("  Output Liquid Quantity: ");             // Output separator
    Serial.print(totalMilliLitres);
    Serial.println("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);
    oldTime = millis();
  }

  if((millis() - oldTime1) > 120000)
  {
       byte flowrate_H = int(flowRate);    
    byte flowrate_L = frac;
    byte totalML_H = floor(totalMilliLitres);
    byte totalML_L = (totalMilliLitres - totalML_H) * 100;

    String dataMsg = "";

    dataMsg += flowrate_H;
    dataMsg += ",";
    dataMsg += flowrate_L;
    dataMsg += ",";
    dataMsg += totalML_H;
    dataMsg += ",";
    dataMsg += totalML_L;

    Serial.print("\n dataMsg : ");
    Serial.println(dataMsg);
    nanoSend.print(dataMsg);
    oldTime1 = millis();
  }
}

/*
Insterrupt Service Routine
 */
void pulseCounter()
{
  // Increment the pulse counter
  pulseCount++;
}

Credits

Comments

Awards

Top 3 Projects

Sigfox Universities Challenge 2019

Smart Building: Household Utility Monitoring System