Published September 19, 2018 © Apache-2.0

Water Quality Monitoring Autonomous Robot

ARM mcu based, autonomous waterbot, equipped with sensors to measure water quality of water reservoirs both locally/remotely

IntermediateWork in progressOver 1 day9,417

Water Quality Monitoring Autonomous Robot

Things used in this project

Hardware components

BBC micro:bit board

Adafruit Miniature Cooling Fan 12V

Seeed Studio Red Laser

Power MOSFET N-Channel

SparkFun Schottky Diode 1N5819

Temperature Sensor LM35

Breadboard (generic)

SparkFun Copper tape 5 mm

SparkFun High Temperature Adhesive Tape

Empty Plastic Bottle 1.25 Ltr

OpenBuilds Cable Ties (10 Pack)

Super Glue

Plastic Food Container ( Lunch Box )

Tongue depressor (ice cream waste)

QC Power Bank Voltage Trigger

QC compatible power bank

Software apps and online services

Arm mbed

Nordic Semiconductor nRF Cloud

Hand tools and fabrication machines

Soldering iron (generic)

Story

Introduction

Water quality data is very important for industrial applications, utility water supply, agriculture and scientific research. With conventional fixed location water quality monitoring systems (installed in water treatment plants, swimming pool etc) the whole picture of water quality can not be captured. Again, for scientific research & detection of water pollution, going to different sites and collecting water samples for lab testing is a tedious process. In this project, it is intended to design an Autonomous Robot, which can automatically travel through water bodies, collect water quality data and send those data directly to remote end.

For this project, the water bot will collect following water quality parameters :-

Temperature
Conductivity
Salinity
Turbidity
Total Suspended Solid

It will be self powered from its solar panels with power banks to store energy.

Working Principle

The brain of this robot is ARM M0 based (nRF51522) BBC Micro:bit board. This board is chosen for following reasons :

Autonomous Navigation with on board MAG3110 magnetometer compass
Movement detection with on board MMA8652 acclerometer
Low power for extended battery life
Built in BLE to IoT connectivity through Smart Phone

Autonomous Navigation is done with by maintaining compass heading with in a tolerance. During boot up the initial heading is taken as reference. There are two PWM driven propeller fans installed on the back of the robot.

Propeller Fans

If the robot is drifting to the LEFT from its reference heading, the power on the RIGHT propeller is increased (PWM) to correct course and vice versa. A PID control loop will maintain this function.

If the robot needs to turn LEFT/RIGHT, reference heading is updated by +/-90 degree and the PID control will take care of the turning.

Edge Detection for edge/wall/banks is done with ultrasonic sensor to avoid collision and automatic course correction.

Depth Detection may be necessary for shallow water bodies. Waterproof ultrasonic sensor may solve the problem

Water Quality Sensing will measure 5 parameters mentioned above with a LM35 temperature sensor, home-brew water conductivity sensor with metal electrodes and turbidity sensor with laser and photovoltaic cell.

IoT Connectivity will be made through Micro:bits BLE capabilities. BLE will connect the system to a smart phone which will work as Gateway. Over LTE network the phone connects to the cloud to send data. Alternatively, BLE-UART app enables data monitoring locally

Power to the propeller fans are delivered from a QC complaint power bank. 12 volts through PWM will be fed to the fans. Rest of the system will run on 3.3 volts.

For self charging, a 5 Watt solar panel will be attached later .

Step 1: Constructing the Vessel

The body of the water robot is build from cheap and disposable materials like empty cola bottles and food container.
Super glue and cable ties are used to fasten every part together.
CPU/Electronics cooling fans are used as propeller and parts of writing pen is used to add structural support. (scroll the images below)

1 / 8 • Final Vessel after fastening parts

Each bottle's capacity 1.25 liters. Which means, theoretically (Archimedes principle) this vessel can float 2.5 k.g. mass.

Step 2: Preparing the Hardware

6 LEDs are removes from the microbit board according to the schematic to free up the COL2 and COL3 lines which also has ADC functions. Presence of LED would have interfered with analog sensing !

1 / 2 • Modification on Micro:bit Board

A 6x4 cm protoboard is soldered on the back of the microbit to break out the edge connector pads to pins. Additionally, 2 N-Ch MOSFETs are soldered just on the other side of the protoboard to drive those for P1 and P2 pins with PWM. This part will control the propeller fans.

Back side of microbit with MOSFETs

Conductivity Sensor

Conductivity sensor is build from the scratch with aluminium heat sink, copper tape, insulation tape, tongue stick and super glue. The copper tape has 5 mm width and 50 mm area is exposed for touching water. A separation of 15 mm is kept in between the electrodes with a 15 mm wide heat sink in between them.

The electrode will be connected in series with a known resistor and a PWM signal will be applied, voltage drop across the electrode will be amplified by an opamp stage, then send to the ADC

1 / 3 • Conductivity Sensor

For this particular sensor, cell constant, K = d/a = 15 mm / ( 5 mm * 50 mm ) = 1.5 cm / (0.5 cm * 5 cm) = 0.6 per cm

Water resistance testing

Conductivity = K/R = K*G, where R is the measured resistance of a water sample. This simple test yeilds 24.3 uS/cm conductivity (not calibrated, DC measurement).

Temperature Sensor

For sensing water temperature, LM35 temperature sensor IC is encapsulated inside a heat shrink tube to make waterproof and flexible with a cable tie support.

1 / 2 • Waterproof Temperature sensor

Micro gap between the IC and heat shrink tube is filled with glue to prevent water.

Turbidity Sensor

The main component of this sensor is LASER and a photovoltaic cell placed in a tube. For the tube part, an empty marker/sign pen and a 3 inch aluminium tube is used.

PV cell is placed (on the wall of the Al tube with glue) 90 degree to the laser beam.

1 / 3 • Complete turbidity sensor

Presence of particles ( fine sand, mud, dirt, pollutant, plankton ) will deflect the laser beam and PV (photo voltaic) cell will pick up that beam. Higher turbidity will generate more current in the PV cell.

All signals are amplified to increase resolution with Opamps before feeding to the ADC.

System Power

The Waterbot requires different power rails for different parts. 12 Volts for the propeller fans & 5 Volts through micro-USB for Microbit (although Microbit runs @ 3.3 Volts which is generated with on board voltage regulator) and other components like the Opamps, Laser, Sensors etc.

Using a QC 2+ compliant power bank as power source

The most compact way to get 12 Volts is to use a QC 2.0 (or higher) compliant power bank with this hack or this product.

Then, adding an LM7805 with micro-USB can provide 5 Volts for the rest of the circuit.

Putting it altogether

Waterbot interconnected

Step 3: Coding with Mbed

Creating Accounts on nRF Cloud and Mbed

Go to https://os.mbed.com/account/signup and create a free account or login with existing account.

mbed online IDE

Go to https://nrfcloud.com and create an account.

nRF Cloud connect IoT

Step 4: Flashing Code & Debugging

platform selection

Go to following link and Import to Mbed Compiler

https://os.mbed.com/users/suntopbd/code/uBit_BLE_UART_Waterbot/

If everything is done properly, Mbed should appear like this on web browser :-

mbed online compiler

Board Setting : BBC micro:bit (default)
Click "Compile" to compile the code and generate hex file

Warning : Do not update "BLE_API" and "NRF51822" folders

Code Tips 1 :

ticker.attach(periodicCallback, 5);

Ticker is a thing in MBED that calls a function periodically, here it will call "periodicCallback" every 5 seconds, which means data will be send every 5 seconds to the cloud. If you wish to send data every 1 minute or 60 seconds

write this line :

ticker.attach(periodicCallback, 60);

Code Tips 2:

while (true)
{       
ble.waitForEvent();        
val = ain.read_u16();
/// bla bla your code
}

Inside the while(true) {} loop with in int main(void){} is the place to write your program code.

Following BLE API must be kept running for BLE to work continuously.

   ble.waitForEvent();

The following code fetch ADC data and keep it on val variable.

  val = ain.read_u16();

Code Tips 3:

The blePrintf() API sends UART data over BLE. It only accepts String or char array. Therefore, before sending Numerical value, it must be converted to String

void periodicCallback(void)
{
 blePrintf("Temperature: ");
 blePrintf(result);
 blePrintf("\r\n");
}

Useful Code Examples with MBED

See details here: https://os.mbed.com/docs/latest/reference/drivers.html

Writing a DigitalPin :

#include "mbed.h"
DigitalOut pin1 (P0_2); // microbit edge connector 1
int main()
{
    while(1) 
        {    
          pin1 = 1;    //same as digitalWrite (D7, HIGH)
          wait (0.5);  //same as delay(500)          
          pin1 = 0;    //same as digitalWrite (D7, LOW)       
          wait (0.5);  //same as delay(500)        
        }
}

Reading a Digital Pin :

#include "mbed.h"
DigitalIn buttonA (P0_17); // On Board Push Switch A
int main()
{
 int sw_state = 0;
     while(1)
         {    sw_state = buttonA.read(); // same as x = digotalRead(3)
          if (sw_state)           
                 { 
                  // do something 
                 }  
         else    
                 {
                  // do something else
                 }
         }
}

Flashing hex on Micro:bit

Connect micro:bit to PC with an USB cable and copy the hex file to micro:bit.

Flashing Microbit

Step 5: IoT Connectivity

Installing nRF Cloud Gateway

Go to Google Play store and Install nRF Gateway app.
Turn on Bluetooth on the android device and run the app
Login with previously created ID and Password for nRF cloud account.
Keep the micro:bit nearby

Establish Connection to the Cloud

To establish the connection login from both the app and the remote terminal is required. This way both sides are connected to the cloud and exchange data.

Step 6: Device Operation

Unfortunately, lack of access to swimming pools/water bodies makes it difficult for me to test the bots full autonomous operation

Action Video

A video on bathtub will be added asap, stay tuned !

Possible Area of Applications

Water Treatment Facility Monitoring
River Pollution Monitoring
Detecting Contamination Hot spots
Water Pollution Data Mapping
Scientific Research Data Collection

Future Development Suggestions

Due to the unavailability of standard sensors and limited funding, some un-calibrated sensors are developed with generic electronic components for demonstration purpose. Also, lack of 3D printer access and technical support (mechanical engineering/chemistry/programming) makes this design far from the envisioned version. So, there is scope for improvement :

Proper mechanical design to sustain stress, shock and turbulence
Installation of real water quality sensors
Powerful propellers to work against strong stream
GPS capabilities for data mapping
Submarine capabilities with underwater camera
Autonomous and Manual control
Water Sample retrieval capability for further lab test
pH Sensor, Dissolved Gas Sensor, Radioactivity sensing
Mini on board Lab for checking Microbes
Amphibious design, underwater anchoring during storm
AI based camera to survey marine life
Internet connectivity through satellite
Independent and sufficient solar energy generation
Long term research on ocean

References

Pin Mapping from Microbit to nRF51822 in Mbed

pin alias on mbed for nRF51822

Code

mbed code

/* mbed MicrocontrollerLL Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

 //////////////////////////////////////////////////////////
///////////////////////NOTE ///////////////////////////////
// This program uses BBC microbit as a NRF51822 board    //
// with limited onboard functionality, mainly focused    //
// BLE-uart/ADC/DIO/PWM capability, see pin maping below //
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
//////////////////////BLE WATER BOT/////////////////////////
////////////////////////////////////////////////////////////


        
#include <string.h>
#include "mbed.h"
#include "PID.h"
#include "BLE.h"
#include "stdio.h"
#include "UARTService.h"

#include "ble/BLE.h"
#include "ble/services/URIBeaconConfigService.h"
#include "ble/services/DFUService.h"
#include "ble/services/DeviceInformationService.h"
#include "ConfigParamsPersistence.h"


#include "math.h"
#include "MAG3110.h"


 
#define INTERVAL 0.1

#define NEED_CONSOLE_OUTPUT 1 // if BLE printf messages needed on the remote console (PC/phone/host);                            
#if NEED_CONSOLE_OUTPUT
#define blePrintf(STR) { if (uart) uart->write(STR, strlen(STR)); }
#else
#define blePrintf(...) 
#endif

///////////////// pin table /////////////////////////
/////////////////////////////////////////////////////
// edge.pin    nrf51822pin    functions      note  //
/////////////////////////////////////////////////////
//  P2           P0_1        ADC/PWM/DIO      2    //
//  P1           P0_2        ADC/PWM/DIO      1    // 
//  P0           P0_3        ADC/PWM/DIO      0    //
//  P4           P0_5            ADC        COL 2  //
//  P10          P0_6            ADC        COL 3  //
//  P16          P_16            DIO               //
//  P14          P0_25       SPI MIS/DIO           //
//  P5           P_17        Button A/DI    pullup //
//  P11          P_26        Button B/DI    pullup //
//  P20          P0_30       I2C SDA/DIO    pullup //
//  P19          P0_0        I2C SCL/DIO    pullup //
//  P15                      SPI MOS/DIO           //
//  P13                      SPI SCK/DIO           //

/////////////////////////////////////////////////////
//                  LED Matrix pins                //
//  ROW 1  P0_13   ROW 2  P0_14   ROW 3  P0_15     //
//  COL 1  P0_4    COL 2  P0_5    COL 3  P0_6      //
//  COL 4  P0_7    COL 5  P0_8    COL 6  P0_9      //
//  COL 7  P0_10   COL 8  P0_11   COL 9  P0_12     //
/////////////////////////////////////////////////////
/////////// See uBit to nrf51822 Schematic for detailed pinout //////////////////////
// https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf  //
/////////////////////////////////////////////////////////////////////////////////////
  //Kc, Ti, Td, interval
          PID controllerL(1.0, 0.1, 0.1, INTERVAL);
          PID controllerR(1.0, 0.1, 0.1, INTERVAL);
          



// Fan drive pwm

PwmOut   LP(P0_2); // left propeller
PwmOut   RP(P0_1); // right propeller

MAG3110 mag(P0_30, P0_0); // set i2c pins SDA, SCL here //
BLEDevice  ble;
UARTService *uart;
 
AnalogIn   temperature(P0_3); 
AnalogIn   turbidity(P0_5);
AnalogIn   conductivity(P0_6);

DigitalOut   row1(P0_13);  // uBit 1st LED cathode 
DigitalOut   col1(P0_4); // uBit 1st LED anode
DigitalIn    swA(P0_17); // uBit button A
//  col2(P0_5); // adc pin now led removed
//  col3(P0_6); // adc pin now led removed

//DigitalOut   col1(P0_4);


int val,dVal, dec, i;
int blepush = 0; 
int refupdate = 0;
char result[100];
float TEMP = 0.0;
float TURB = 0.0;
float COND = 0.0;

float heading = 0.0; // magnetometer heading
float heading_ref = 0.0;

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    ble.startAdvertising();
}

void periodicCallback(void)
{
    blepush = 1;
   // blePrintf("heading ");
   // blePrintf(result);
   // blePrintf("\r\n");
}

void navigationAdjust (void)
{
    
}

void calXY() //magnetometer calibration: finding max and min of X, Y axis
{
    int tempXmax, tempXmin, tempYmax, tempYmin, newX, newY;

    wait(3);

    tempXmax = tempXmin = mag.readVal(MAG_OUT_X_MSB);
    tempYmax = tempYmin = mag.readVal(MAG_OUT_Y_MSB);
    int sample = 0;
     
    while(sample<501) {
        wait(0.05);
        newX = mag.readVal(MAG_OUT_X_MSB);
        newY = mag.readVal(MAG_OUT_Y_MSB);
        if (newX > tempXmax) tempXmax = newX;
        if (newX < tempXmin) tempXmin = newX;
        if (newY > tempYmax) tempYmax = newY;
        if (newY < tempYmin) tempYmin = newY;
        sample++;
    col1.write(!(col1.read()));
    //col3.write(!(col3.read()));
    
    }
   
    mag.setCalibration( tempXmin, tempXmax, tempYmin, tempYmax );
 

}


int main(void)
{
    //  pwm freq
    LP.period(0.01f); 
    RP.period(0.01f);
    LP.write(1.0);
    RP.write(1.0);
    wait(1);
    LP.write(0.0);
    RP.write(0.0);

   row1.write(1);
 
    ble.init();
    ble.onDisconnection(disconnectionCallback);
    
    uart = new UARTService(ble);

    /* setup advertising */
    ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED);
    ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME,
                                     (const uint8_t *)"uBit BLE", sizeof("uBit BLE") - 1);
                                     // device name on BLE //
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,
                                     (const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));

    ble.setAdvertisingInterval(160); /* 100ms; in multiples of 0.625ms. */
    ble.startAdvertising();
    

    // may necessary //
    while(swA.read())
    {
    ble.waitForEvent();
    col1.write(!(col1.read()));
    wait(1);
    blePrintf("Hold A to start\n");
    }
  // max 20 Character at a time over BLE
  // max 20 Character at a time over BLE
  // max 20 Character at a time over BLE
  
    
   ble.waitForEvent();   
   blePrintf("Init  nRF51822  \n");
   blePrintf("Calibrating Sensors\n");
   blePrintf("Rotate To Calibrate\n");
   blePrintf("when LED blinks fast\n");
  
    calXY(); // do the mag calib
    ble.waitForEvent();
    
   blePrintf("Calibrate Completed\n");
   blePrintf("Put Robot on Water\n");
  
    while(swA.read())
    {
        col1.write(!(col1.read()));
        wait(1);
        blePrintf("Hold A to proceed\n");
  
    }
    
    Ticker ticker;
    ticker.attach(&periodicCallback, 5);

    Ticker ticker2;
    ticker2.attach(&navigationAdjust, .5);
    
 
  //Reference angle input from 0.0 to 3.3V
  controllerL.setInputLimits(0.0, 360.0);
  controllerR.setInputLimits(0.0, 360.0);
 
  //Pwm output from 0.0 to 1.0
  controllerL.setOutputLimits(0.0, 1.0);
  controllerR.setOutputLimits(0.0, 1.0);
  
  //If there's a bias.
  controllerL.setBias(0.0);
  controllerR.setBias(0.0);
  
  controllerL.setMode(AUTO_MODE);
  controllerR.setMode(AUTO_MODE);

  //process variable or heading to be 90
  controllerL.setSetPoint(90.0);
  controllerR.setSetPoint(90.0);
  
       heading_ref = mag.getHeading();
       if (heading_ref<0.0) heading_ref = heading_ref+360.00;
       if (heading_ref>360.00) heading_ref = heading_ref -360.00;
       controllerL.setProcessValue(heading_ref);
       controllerR.setProcessValue(heading_ref);
       float LPwr = controllerL.compute();
       float RPwr = controllerR.compute();
       //////////////////////////////////
   
 

    while (true) {
        ble.waitForEvent();
       //////////////////////////////////
       //// WORKS BETTER THAN PID //////
       //////////////////////////////////
      
      
      if(refupdate == 1)
      {
       while(heading_ref != heading)
       {
        heading = mag.getHeading();
       if (heading<0.0) heading_ref = heading+360.00;
       if (heading>360.00) heading_ref = heading -360.00;
       LP.write(.9);
        }   
       }
      
       
       heading = heading_ref;
       
       for (int z =0;z<10;z++)
       {
       heading = mag.getHeading();
       if (heading<0.0) heading = heading+360.00;
       if (heading>360.00) heading = heading -360.00;
     
       if (heading> heading_ref+2.0)
       LP.write((heading - 90.0)/20.0);
       else
       LP.write(.0);   
       wait(0.2);
       
       if (heading> heading_ref+2.0)
       RP.write(( 90 - heading )/20.0);
       else
       RP.write(.0);   
       wait(0.2);
       LP.write(.7);   
       RP.write(.7);   
       wait(0.2);
       
       
       }
       /// heading is corrected after this line ///
       /// calib may needed //

    // val = ain.read_u16();
    // 22k+100K VOLTAGE DIVIDER AND 0.15 IS OFFSET   
    // batt = (122/22)*3.6*val/1023.0 - 0.15
    
    //Update the process variable.
    //Set the new output.
 
      
  if (blepush ==1)
  {
    
    TEMP = 3.3*100*temperature.read_u16()/(5*1023); // 10 mV= 1 deg c, vcc =3.3 v, Opamp gain 5
    dVal = TEMP;
    dec = (int)(TEMP * 100) % 100;

    memset(result, 0, 100);
    
    result[0] = (dVal / 100) + '0';
    result[1] = ((dVal / 10)%10) + '0';
    result[2] = (dVal % 10) + '0';
    result[3] = '.';
    result[4] = (dec / 10) + '0';
    result[5] = (dec % 10) + '0';
    for (i=strlen(result)-1; i>=0; i--)
        putc(result[i], stdout);
    
    blePrintf("temperature ");
    blePrintf(result);
    blePrintf("\n");  

    TURB = 3.3*10*turbidity.read_u16()/1023; // fix gain later
    dVal = TURB;
    dec = (int)(TURB * 100) % 100;

    memset(result, 0, 100);
    
    result[0] = (dVal / 100) + '0';
    result[1] = ((dVal / 10)%10) + '0';
    result[2] = (dVal % 10) + '0';
    result[3] = '.';
    result[4] = (dec / 10) + '0';
    result[5] = (dec % 10) + '0';
    for (i=strlen(result)-1; i>=0; i--)
        putc(result[i], stdout);
    
    blePrintf("turbidity ");
    blePrintf(result);
    blePrintf("\n");  



    COND = 3.3*10*conductivity.read_u16()/1023; // fix gain later
    dVal = COND;
    dec = (int)(COND * 100) % 100;

    memset(result, 0, 100);
    
    result[0] = (dVal / 100) + '0';
    result[1] = ((dVal / 10)%10) + '0';
    result[2] = (dVal % 10) + '0';
    result[3] = '.';
    result[4] = (dec / 10) + '0';
    result[5] = (dec % 10) + '0';
    for (i=strlen(result)-1; i>=0; i--)
        putc(result[i], stdout);
    
    blePrintf("conductivity ");
    blePrintf(result);
    blePrintf("\n");  
   blepush =0;
   }
    
            }
// end of while(1)            
}
// end of main()