Published March 1, 2023 © CC BY

Solar Powered Wireless Water Level Sensing for Remote Tank

Go to bathroom with the peace of mind that there is enough water on the water tank, no more shampoo head situation

BeginnerShowcase (no instructions)5 hours1,161

Solar Powered Wireless Water Level Sensing for Remote Tank

Things used in this project

Hardware components

DFRobot Beetle - The Smallest Arduino

Arduino UNO

Li-Ion Battery 1000mAh

Development Kit Accessory, Solar Cell

433.92 MHz Transmitter

433.92 MHz Receive

5 mm LED: Red

5 mm LED: Green

5 mm LED: Yellow

Resistor 100k ohm

Through Hole Resistor, 20 kohm

Buzzer

SparkFun Power Cell - LiPo Charger/Booster

Linear Regulator (7805)

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Story

Introduction

It happened to me few times, when I was in the bathroom/toilet and water ran out in the middle of doing something !

That's why I have decided to make this wireless water level sensing system which can monitor water level in the rooftop water tank (6th floor) and sent the information to (1st floor) wirelessly. The remote water level sensing transmitter is solar powered for self-sustaining operation.

Hardware Build

The Transmitter: The transmitter setup consists of

433Mhz transmitter module,
34.6 cm long 1/2 wave antenna,
bare bone ATmega328P running as Arduino Uno,
3000 mAh refurbished lipo battery,
TP4056 battery charging circuit,
LM7805 voltage regulator

everything inside a plastic enclosure.

The Transmitter setup

Solar & Battery Charging: To generate power and recharge the battery, there is a 5W (9V, 550mAh peak) solar panel.

Solar power for battery charging

Water level Sensing: To sense the water level, I am using only 2 float switches, because I only care about nearly full, nearly empty and in-between water levels.

Float Sensors

N number of float sensor/switches can give N+1 number of level detection but it will cost more money (the thing that I almost never have enough).

The Receiver: The receiver setup consists of

433 Mhz receiver module,
17.3 cm 1/4 wave antenna,
Beetle board (Arduino Leonardo on ATmega32u),
1306 OLED Display,
water level indication Red/Green/Yellow LEDs,
5v power power adapter

Receiver setup

Wireless Communication:433 MHz frequency provides longer range and less crowded spectrum (compared to BLE/WiFi). Your WiFi range is horrible ? That's because there are too many networks !

Self-Sustaining Power: 3000 mAh oversized LiPo battery, recharged with oversized 5W panel for week long operation, ensuring the system is functional under bad weather condition.

Long Autonomous Operation: Low Power Sleep mode operation by Arduino Sleep to save power, periodically sends water level data and battery voltage info about every 3 minutes, each data is sent 4 times to ensure at least one uncorrupted data packet is received. By using of Radio Head library in the code, packets are sent with preambles, start/stop bit, proper encoding to ensure wireless data integrity.

OutdoorOperation:Waterproof, air-tight enclosure for weather proof operation.

Antenna: By pulling out "just a piece of copper wire strand" from any of power cable and sizing it to match 1/2 wave antenna (34.6 cm) for the transmitter and 1/4 wave antenna on the receiver (17.3 cm). I have tried 1/4 and 5/8 wavelength antenna on transmitter but 1/2 wave seems more reliable.

Range: The distance between transmitter and receiver is about 15m and there are few concrete floors and brick walls in between.

Device Operation: Hardware & Code explained

There are few quirks going on with the hardware. Let's explain them:

Reliable 433 MHz communication : 4 things can make 433 MHz communication reliable

Higher supply voltage thus larger amplitude data pulse modulation
Slower bit rate data transfer or wider data pulses
Proper antenna type/size and polarization/orientation
Receiver sensitivity/noise immunity or build quality of the modules

The 433 MHz transmitter and receiver use simple ASK (amplitude shift keying), 1's and 0's are modulated with 433 MHz carrier signal with changing amplitude. The transmitter module can operate anywhere between 3-12V. Using a higher voltage (i.e. 12V) for the transmitter will make the amplitude bigger, yielding longer range or deeper penetration of signal through obstacles.

Sending data at a slower bit-rate (I have choose 128 bit/s) makes the 1's and 0's wider in the career wave, this also helps to achieve longer range, less corrupted/more reliable data transfer. This can be done from the arduino code

Next important thing is using appropriate antenna length, as RF emission pattern depends on antenna type and size. For 433 MHz, 1/4 wave antenna is widely use because it is smaller. I recommend using straight monopole 1/2 wave antenna for 433Mhz Project, avoid using coiled up or pcb trace antenna. If size is not an issue, 1/2 wave antenna is better than 1/4 wave antenna. For extra range 5/8 wave antenna can be used but their radiation pattern makes them difficult to align in the correct polarization.

1/4 wave 433 MHz antenna = 17.3 cm long single core wire
1/2 wave 433 MHz antenna = 34.6 cm long single core wire
Both transmitter and receiver antenna must be oriented similarly on the same plane meaning they both must have vertical polarization or both must have horizontal polarization.
For horizontal plane range both antenna must be vertical to earth
For vertical plane range both antenna mustbe horizontal to earth

Since, I am sending data from roof (6th floor) to 1st floor, both my transmitter and receiver antenna are in Horizontal Polarization

Lastly, performance varies from module to module, receiver with higher sensitivity will be able to capture the data packets better. The RXB6 model (this one is shielded and uses 433 MHz crystal) receiver is better than the FS1000A model (this one uses Inductor based LC oscillator).

Dickson Charge-Pump Voltage Booster: The remote unit (transmitter setup) is powered by 4.2 volts LiPo battery but the transmitter module itself can take maximum 12 volts. Powering the module with maximum voltage gives stronger RF output, thus longer and reliable data transmission.

So, how to get 12v cheaply and easily from 4.2v battery ? Charge-Pump ! Just few diodes and capacitors in voltage multiplier configuration, driven by one of the PWM pins of arduino, I can easily get 12v.

courtesy : EEVBLOG Dave

The diodes need to be low dropout Schottky diode 1N5819, the capacitors are 10uF/22uF multilayer ceramic type, the last stage needs a bigger capacitor somewhere between 100-470uF.

AVR Sleep, Watchdog Bark, Power Consumption: Solar powered hardware must conserve power for bad weather. Although the 3000mAh battery is oversized, I have programmed the ATmega328p on the transmitter setup to sleep about every 3 minutes before sending updated water level data. During sleep, it only consumes 130 uA current, which can increase another 120-250 uA if the float sensors pull-down the pull up resistors. The Watchdog timers wakes up the mcu every 8 seconds to keep track of time, during this short window current consumption is about 10-11 mA for few milliseconds. About every 3 minutes the PWM turns on the Charge-Pump to power the transmitter module, current consumption is 25-27 mA for 7-8 seconds during wireless activity.

Float Sensor and Counter Weight: Float sensor is basically a mechanical switch inside a floating enclosure that opens/closes based on its orientation. With the rise and fall of water level as the float sensor position changes, there is a conductive ball inside it which rolls from one side to the other side to activate and deactivate the switch. To avoid oscillation, there are grooved chambers which keeps the ball in place until the water level crosses a certain point, which basically acts like mechanical hysteresis. To keep the float sensors from floating all the way top, when the tank is full, there are counter weights which keeps them where they are suppose to be.

Things Happening on Receiver side: The receiver setup is always listening for meaningful data. Radio Head library related code takes care of the incoming packets. Then some software filtering is done to extract the transmitter battery voltage information data and water level data. This is done by checking the first character of a data packet. The battery voltage data will be sent from the transmitter with 'B' as the leading character, followed by the ADC value.

(see code below for details)

1306 OLED Display is driven by U8GLib library, this display will show approximate water level and how much time has passed since last packet received. If something breaks on transmitter side or transmission gets corrupted, the time passed info will be more than 3 minutes.

The Red/Green/Yellow LEDs is a quick way to check the water level from a distance. Green means the water level is somewhere between 50% and nearly full, Yellow means the water level is somewhere between 50% and above 20%, Red means water level is almost empty or less than 20%.

Here is my setup

Transmitter setup and solar panel

Float sensor hanging inside tank with counter weight

Conclusion

If you need any additional info regarding this project, ask your queries in the comment section. I will try to answer

References

How 433 MHz modules work with Arduino

How to put Arduino into Sleep and Save Power

How to use Charge Pump Voltage Multiplier with Microcontroller

transmitter schematic

Code

// For periodic nap and Power saving
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

// For 433Mhz transmission with some kind of protocol
#include <RH_ASK.h>
#include <SPI.h> 


#define TRANSMISSION_ACTIVE_LED 13
#define FLOAT_SENSOR_UPPER A4
#define FLOAT_SENSOR_LOWER A5
#define LIPO_BATTERY_SENSE A1

RH_ASK rf433_driver(128); // 128 bit/s over the air (speed) 
volatile unsigned int seconds = 0;


void setup()
{
    rf433_driver.init();    // init the wireless transmission drive
    delay(500);
    dickson_booster_init(); // generate 12v for transmitter from 4.2v lipo
    setup_watchdog(9);      // every 8 seconds watch dog barks
    analogReference(INTERNAL); // 1.1v analog reference for batt monitor
    pinMode(TRANSMISSION_ACTIVE_LED, OUTPUT);
    pinMode(FLOAT_SENSOR_UPPER, INPUT_PULLUP);
    pinMode(FLOAT_SENSOR_LOWER, INPUT_PULLUP);
}

void loop()
{

 // system will go to slumber to save power now !
 system_sleep () ;
 sleep_disable();                     
 
 // the following if block will run every 3.3 minutes once
 if (seconds >=200)
 {
   seconds = 0; 
 
 
    power_up_transmitter();         
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    delay(500);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(500);
    
     delay(500);
  // make a data packet that will hold battery voltage info
     char  valbuff[4];
     int temp = analogRead(LIPO_BATTERY_SENSE);
     valbuff [0] = 'B';
     valbuff [1] = temp;
     valbuff [2] = temp>>8;
     valbuff [3] = '/0';
  // send battery voltage level info packet over 433 MHz link
    char *msg0 = valbuff;
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    rf433_driver.send((uint8_t *)msg0, strlen(msg0));
    rf433_driver.waitPacketSent();
    delay(100);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(2000);
  
  // read the float sensors and send water level data 3 times over 433 MHz
  for(int x=0;x<3;x++)
  {
        // send bottom float sensor data
////////////////////////////////////////////
    if (digitalRead(FLOAT_SENSOR_UPPER) && digitalRead(FLOAT_SENSOR_LOWER))
    {
     char *msg1 = ">80%";
         rf433_driver.send((uint8_t *)msg1, strlen(msg1));
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    rf433_driver.waitPacketSent();
    delay(200);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(200);

    }
/////////////////////////////////////////////    
    if ((!digitalRead(FLOAT_SENSOR_UPPER)) && digitalRead(FLOAT_SENSOR_LOWER))
    {
     char *msg2 = "~50%";
         rf433_driver.send((uint8_t *)msg2, strlen(msg2));
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    rf433_driver.waitPacketSent();
    delay(200);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(200);

    }
//////////////////////////////////////////////
 if ((!digitalRead(FLOAT_SENSOR_UPPER)) && !(digitalRead(FLOAT_SENSOR_LOWER)))
       {
     char *msg3 = "<20%";
         rf433_driver.send((uint8_t *)msg3, strlen(msg3));
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    rf433_driver.waitPacketSent();
    delay(200);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(200);

    }
//////////////////////////////////////////////  
if (digitalRead(FLOAT_SENSOR_UPPER) && !(digitalRead(FLOAT_SENSOR_LOWER)))
        {
     char *msg4 = "ERR";
         rf433_driver.send((uint8_t *)msg4, strlen(msg4));
    digitalWrite(TRANSMISSION_ACTIVE_LED,HIGH);
    rf433_driver.waitPacketSent();
    delay(200);
    digitalWrite(TRANSMISSION_ACTIVE_LED,LOW);
    delay(200);

    }
    
//////////////////////////////////////////////  

  }
  } 
  // turn off dickson voltage booster after transmission is end
    power_down_transmitter();
    

} // end of void loop

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////

// drives diode-capacitor dickson charge pump to
// generate 12v from 4v lipo to power the transmitter

void power_up_transmitter()
{
 analogWrite(6,127);
 delay(200); 
}

// turns off charge pump to save power
void power_down_transmitter()
{
  
 analogWrite(6,0);
 delay(200);
}

// init pwm 1khz on pin 6 to drive charge pump
void dickson_booster_init()
{
  pinMode(6,OUTPUT);
}


// Puts MCU into Sleep// 
////////////////////////

void system_sleep(void) 
{

  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();
  sleep_mode();                        // System sleeps here
  sleep_disable();                     // System continues execution here when watchdog timed out 
}


// watchdog periodically wakes up mcu from sleep to do something 
// or go back to sleep if nothing needs to be done !

void setup_watchdog(int i) 
{
  // 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec

  uint8_t bb;
  if (i > 9 ) i=9;
  bb=i & 7;
  if (i > 7) bb|= (1<<5);
  bb|= (1<<WDCE);

  MCUSR &= ~(1<<WDRF);
  WDTCSR |= (1<<WDCE) | (1<<WDE);
  WDTCSR = bb;
  WDTCSR |= _BV(WDIE);
}

// keep a rough track of time in watchdog ISR

ISR(WDT_vect)
{
sleep_disable();
seconds = seconds+8; // update every 4 second
}

// library for OLED, 433MHz Radio-head protocol

#include "U8glib.h"
#include <RH_ASK.h>
#include <SPI.h> // Not actualy used but needed to compile

RH_ASK rf433_driver(128); // 128 bit/s data rate OTA 


U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);   // SCL = 2  SDA = 3

// UI buttons (only one is used for now)
#define BUTTON_DEC    A2
#define BUTTON_INC     1
#define BUTTON_SEL    A0

//#define RF_433_IN   11 (radio head library will use pin 11 by default)

// indication LEDs
#define LOW_LEVEL_LEDS_RED   A1
#define MID_LEVEL_LEDS_YELLOW   9
#define HIGH_LEVEL_LEDS_GREEN   0
#define BUZZER_ALARM 10
#define BLUE_LED      13


long last_millis;
bool selector = 0;
int battvolt = 0;
float vbatt =0.0;

    uint8_t buf[12];
    uint8_t buflen = sizeof(buf);

    uint8_t lvl[12];
    uint8_t lvllen = sizeof(lvl);

    uint8_t bat[12];
    uint8_t batlen = sizeof(bat);


void setup(void)
{
 
// u8g.setRot90();        // change oled display orientation

 // set GPIOs for buttons and LED
 
 pinMode(BUTTON_DEC, INPUT_PULLUP);
 pinMode(BUTTON_INC, INPUT_PULLUP);
 pinMode(BUTTON_SEL, INPUT_PULLUP);

 pinMode(BLUE_LED, OUTPUT);
 pinMode(LOW_LEVEL_LEDS_RED, OUTPUT);
 pinMode(MID_LEVEL_LEDS_YELLOW, OUTPUT);
 pinMode(HIGH_LEVEL_LEDS_GREEN, OUTPUT);
 
 pinMode(BUZZER_ALARM, OUTPUT);

 digitalWrite(LOW_LEVEL_LEDS_RED, 1);
 digitalWrite(MID_LEVEL_LEDS_YELLOW, 1);
 digitalWrite(HIGH_LEVEL_LEDS_GREEN, 1);
 digitalWrite(BUZZER_ALARM, 0);

  
 
 delay(500);
 
 // init 433 MHz Radio head driver for receiver
 rf433_driver.init();
  
}

void loop()
{
 
 // check if there are valid data in receiver buffer
 
    if (rf433_driver.recv(buf, &buflen)) // Non-blocking
    {
      int i;
    last_millis = millis();
    transmission_blinky(); // indicates some valid data just received
    }
///////////////////////////////////    
    // separate data from buffer
    // extract battery voltage info from received data
    // if data array starts with 'B', then following bytes contain 
    // adc info of battery on the transmitter end
    if((char*)buf[0] == 'B')
    {
     byte lowbyte = byte(buf[1]);
     byte highbyte = byte(buf[2]);
     battvolt = lowbyte + (highbyte <<8);
     vbatt = ((10+2)/2)*(1.07*battvolt/1023); //1M//200k voltage div
   
    }
    
    // if it is not battery voltage info then it is float sensor info
    else
    {
      for(int i=0; i<=4;i++)
      {
      lvl[i] = buf [i];
      }
    }

    
    // refresh oled every 10 sec to avoid pixel burnout from 
    // static info that rarely changes with time
    // also beep alarm only on lowest water level 
   
    if (((millis()/1000)%10) == 0)
    {
    clear_display_message();
    // beep alarm if water level lowest
    if((char*)lvl[1]=='2')
    {digitalWrite(BUZZER_ALARM,1);}
    delay(100);
    digitalWrite(BUZZER_ALARM,0);
    delay(300);
    u8g.setColorIndex(1);    
    }

    // takes button press from user and 
    // switches between vbatt and water level info
    if(!digitalRead(BUTTON_SEL))
    {
      selector = !(selector);
      delay(100);
    }

    if (selector == 0)
    {
      update_display_message();
    }
    else
    {
      update_display_vbatt();
    }
 // Show water level on Red/Green/Yellow LEDs
 water_level_LEDS();
 
} // end of loop

///////////////////////////////////
///control and display functions///
///////////////////////////////////

// updates oled with the latest water level data

void update_display_message(void)
{
    u8g.firstPage();  
  do {
    u8g.setFont(u8g_font_10x20); 
    u8g.setPrintPos(0,13 );
    u8g.print("water lv:");
    u8g.setPrintPos(89,13 );
    u8g.print((char*)lvl);

    u8g.setFont(u8g_font_6x13); 
   u8g.setPrintPos(0,25 );
    u8g.print("last updated :");
   u8g.setPrintPos(87,25 );
    u8g.print((millis()-last_millis)/60000);
   u8g.setPrintPos(104,25 );
    u8g.print("min");    
     
  } while( u8g.nextPage() );
delay(10);

}

// updates oled with battery voltage info
void update_display_vbatt(void)
{
    u8g.firstPage();  
  do {
    u8g.setFont(u8g_font_10x20); 
    u8g.setPrintPos(0,13 );
    u8g.print("V_batt");
    u8g.setPrintPos(80,13 );
    u8g.print(vbatt);

    u8g.setFont(u8g_font_6x13); 
   u8g.setPrintPos(0,25 );
    u8g.print("last updated :");
   u8g.setPrintPos(86,25 );
    u8g.print((millis()-last_millis)/60000);
   u8g.setPrintPos(103,25 );
    u8g.print("min");    
     
  } while( u8g.nextPage() );
delay(10);

}

// blackens the oled to refresh
void clear_display_message(void)
{
    u8g.firstPage();  
  do {
    u8g.setColorIndex(0);
    u8g.drawBox(1, 1, 32, 128); 
  } while( u8g.nextPage() );
delay(10);

}

// indicates a valid transmission data received
void transmission_blinky(void)
{
  digitalWrite(BLUE_LED,HIGH);
  delay(25);  
  digitalWrite(BLUE_LED,LOW);
  delay(25);

}

// helps determine water level quickly 
void water_level_LEDS(void)
{
  if ((char*)lvl[1]=='8')
  {
   digitalWrite(LOW_LEVEL_LEDS_RED, 1);
   digitalWrite(MID_LEVEL_LEDS_YELLOW, 1);
   digitalWrite(HIGH_LEVEL_LEDS_GREEN, 0);
  }

  
  else if ((char*)lvl[1]=='5')
  {
   digitalWrite(LOW_LEVEL_LEDS_RED, 1);
   digitalWrite(MID_LEVEL_LEDS_YELLOW, 0);
   digitalWrite(HIGH_LEVEL_LEDS_GREEN, 1);
  }
  
  else if ((char*)lvl[1]=='2')
  {
   digitalWrite(LOW_LEVEL_LEDS_RED, 0);
   digitalWrite(MID_LEVEL_LEDS_YELLOW, 1);
   digitalWrite(HIGH_LEVEL_LEDS_GREEN, 1);
  }
  else
  {
   digitalWrite(LOW_LEVEL_LEDS_RED, 1);
   digitalWrite(MID_LEVEL_LEDS_YELLOW, 1);
   digitalWrite(HIGH_LEVEL_LEDS_GREEN, 1);
  }
  
}

Credits

Shahariar

75 projects • 270 followers

"What Kills a 'Great life' is a 'Good Life', which is Living a Life Inside While Loop"

Contact

Comments

Please log in or sign up to comment.

Solar Powered Wireless Water Level Sensing for Remote Tank

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

Hardware Build

Device Operation: Hardware & Code explained

Here is my setup

Conclusion

References

Schematics

433 Receive

txv 433 sch

Code

main.c

main.c

Credits

Shahariar

Comments

Embed the widget on your own site

Solar Powered Wireless Water Level Sensing for Remote Tank

Solar Powered Wireless Water Level Sensing for Remote Tank

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Introduction

Hardware Build

Device Operation: Hardware & Code explained

Here is my setup

Conclusion

References

Schematics

433 Receive

txv 433 sch

Code

main.c

main.c

Credits

Shahariar

Comments

Related channels and tags