Team Group 50:

Alex Traynham

•

Aidan Restelli

•

Ashreema Luitel

Published November 28, 2022 © GPL3+

MEGR 3171 Automated AC Water Level Detector

This device makes detecting AC water overflow automated - saving time, money, and risk of health.

IntermediateShowcase (no instructions)5 hours221

MEGR 3171 Automated AC Water Level Detector

Things used in this project

Hardware components

Particle Argon

Solderless Breadboard Half Size

Solderless Breadboard Full Size

USB-A to Micro-USB Cable

Jumper wires (generic)

ELEGOO UNO R3 Project Complete Starter Kit

Single Turn Potentiometer- 10k ohms

Resistor 220 ohm

LED (generic)

Adafruit Waterproof DS18B20 Digital temperature sensor

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Story

Has your AC unit ever leaked water? Has your home ever been without AC on a hot day, causing uncomfortable amounts of heat?

Unfortunately, this can be a very common scenario for an individual. The dreaded feeling of an AC unit going bad means no controlled air flow or temperature and, frankly, a lot of money for repairment. However, catching something like this early can be a game-changer. Turning off your AC unit as soon as a problem is detected can prevent the unit from completely breaking down with rising water levels.

Our IoT project aims to solve the problem of an AC unit going bad by monitoring the water level and temperature within the unit.

So, why does an AC (air-conditioning) unit collect water in the first place?

According to Cielo, the AC unit contains components called evaporator coils. Warm air from inside a home is blown over these coils and causes the air to condensate, controlling the humidity in the house. The catch is, when your AC begins to leak water, there becomes a problem which can quickly be serious. Your AC may still work, but the functionality of it will sharply decline until it is no longer viable.

So, with the help of three Particle Argon devices and a three sensors, we created a monitoring system which can display a low, medium, or high water level as well as the temperature of the water or environment (wherever the temperature probe is placed). Upon securing the water level and temperature sensors in the desired position, the LCD display will indicate read-outs for both the water level and temperature. Additionally, two LEDs are wired to the sensors to serve as a second-source indicator. A green light means the water level is low. A red light, however, means the water level is on the rise (indicating either a medium or high water level). The LEDs, in particular, are easier to see and therefore, can be utilized as the first checkpoint for a saturated, prematurely failing AC unit. Once the LED lights red, it's time to check the LCD display, which can indicate the level at which the water is. The temperature also serves as a strong indicator of failure as it will rise without the help of the AC unit which should be cooling continuously. The indicators can signal to immediately turn off the AC and get repair before it is too late.

This is a project which can assist many people, especially those without technical knowledge of air conditioning and central heating systems. The details of how the device works are explained in further detail in the video down below.

Group 50 IoT Project - AC Water Level and Temperature Detector

Individual circuit builds can be seen below.

Argon-DisplayIndicator

The liquid crystal display (LCD) can display both the temperature of the water and the water level in the drip pan. The water level read out is "low, " "mid, " or "high, " where low indicates a low and safe water level, mid indicates a rising water level, and high represents a high water level which needs to be quickly evaluated. The temperature and water level are constantly updating to reflect the most recent output.

Argon Display Indicator - Aerial View

The display indicator from another view to clarify the wire placement.

Argon Display Indicator - Side View (Wire Placement Clarification)

The display indicator brightness level is adjusted by the twist of a potentiometer. View the video below to see the brightness level adjustment.

Argon Display Indicator - Brightness Level Adjustment

Argon-LEDIndicators

The LED's were utilized as second-source indicators which display a "green" or "red" light. Green means low water level. Red means either medium or high water level, and further attention is required.

Argon LED Indicator - Aerial View

Argon-WaterLevel&TemperatureSensors

The Water Level and Temperature sensors were the key component to our project. The water level sensor was hooked up to the argon and then secured inside of the bowl in order to detect water levels on a rise or drop. The temperature sensor is a waterproof probe which was also secured inside the bowl and updated the temperature read-out continuously to a two-decimal place accuracy.

Argon Water Level and Temperature Sensors - Aerial View

Another feature of our Water Level and Temperature sensing system is that this data updates live. We utilized a program titled ThingSpeak, which updates the data live on a chart. This data includes the water level and temperature of the environment where the sensors are placed. This data only updates when the argon is online, so we ran another experiment exactly like the one conducted in the video above. We increased the water level first which activated high read-outs from the water level sensor, followed by some ice to activate a decline in temperature read-out from the temperature sensor. The graphs can be seen here, but are also put below for convenience. Additionally, we have added a video which highlights the live updates for the graphs below.

Water Level Read-Outs - Live Updates from ThingSpeak

Temperature Read-Outs - Live Updates from ThingSpeak

ThingSpeak Water Level and Temperature Live Updates

Code

//includes liquid crystal library
#include <LiquidCrystal.h>

//defines temperature and communication variables
int temperature ;
int comm;

//defines defines temperature as an integer from given data
void temperatureii (const char *event, const char *data) {
String pew = data;
temperature = pew.toInt();
}

//defines pins utilized from the lcd screen
LiquidCrystal lcd(D0, D1, D2, D3, D4, D5);

void setup() {
//clears lcd screen
lcd.clear();
//sets initial columns (16) and rows (2)
lcd.begin(16, 2);
//sets cursor to top left square on lcd screen
lcd.setCursor(0,0);
//prints "H20 Lvl:" on first line
lcd.print("H20 Lvl:");
//sets cursor to bottom left square on lcd screen
lcd.setCursor(0,1);
//prints "Temp:" on second line
lcd.print("Temp:");
//subscribes to data set which has a low, mid, high level
Particle.subscribe("Water_Level_01", Level, "LOW");
Particle.subscribe("Water_Level_01", Level, "MID");
Particle.subscribe("Water_Level_01", Level, "HIGH");
//subscribes to data set for temperature
Particle.subscribe("Temp01", temperatureii, ALL_DEVICES);
}

void loop() {
//sets cursor to second line, after "Temp:"
lcd.setCursor(5,1);
//prints temperature data live
lcd.print(temperature);
//added delay in the loop
delay(100);
//prints F after temperature data (indicates unit)
lcd.print("F");
//publishes temperature data which communicates with the argons with sensors
Particle.publish("Temp01", String(comm), ALL_DEVICES);
}

void Level(const char *event, const char *data) {
//sets cursor to first line, after "H20 Lvl:"
lcd.setCursor(8,0);
//prints water level data
lcd.print(data);
}

//define led pins on breadboard
const int led1 = A1;
const int led2 = A5;
//define data set used to control led light
int Water_Level_Value_01;

void setup() {
//defines leds as outputs
pinMode(led1,OUTPUT);
pinMode(led2, OUTPUT);
//initially sets leds to high brightness
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
//subscribes to data set
Particle.subscribe("Water_Level_Value_01", ledcontrol, ALL_DEVICES);
}

void loop() {
//if,elseif statements to indicate when led1 and led2 should turn on or off
if (Water_Level_Value_01 >= 300){
digitalWrite(led1, HIGH);
}
else if (Water_Level_Value_01 <= 300){
digitalWrite(led1, LOW);
}
else{
}

if (Water_Level_Value_01 <= 300){
digitalWrite(led2, HIGH);
}
else if (Water_Level_Value_01 >= 300){
digitalWrite(led2, LOW);
}
else{
}
}

void ledcontrol(const char *event, const char *data){
//defines water level as an integer from given data
    String pew = data;
    Water_Level_Value_01 = pew.toInt();
}

//included libraries below
#include <ThingSpeak.h>
#include <DS18B20.h>
#include <math.h>

//defines water sensor, the two water value data sets, temperature data set
int waterSens = A0; 
int waterVal; 
int Temp01; 
int Water_Level_Value_01; 

//thingspeak initialize
TCPClient client;

//channel number and api key or thingspeak
unsigned long myChannelNumber = 1951865;
const char * myWriteAPIKey = "AFHI6VZOS7RG97SV";

//defines integers for the temperature probe
const int      MAXRETRY = 4;
const uint32_t msSAMPLE_INTERVAL = 2500;
const uint32_t msMETRIC_PUBLISH  = 10000;
const int16_t dsVCC  = D2;
const int16_t dsData = D3;
const int16_t dsGND  = D4;

//temperature probe can now deliver data
DS18B20  ds18b20(dsData, true); 

//setting up parameters for the read-out of the temperature probe
char     szInfo[64];
double   celsius;
double   fahrenheit;
uint32_t number01;
uint32_t number02;

void setup() {
//serial.begin for thingspeak (serial number for specific channel)
Serial.begin(115200);
//sets up pins for ground and vcc on temperature probe & watersensor
pinMode(dsGND, OUTPUT);
digitalWrite(dsGND, LOW);
pinMode(dsVCC, OUTPUT);
digitalWrite(dsVCC, HIGH);
pinMode(waterSens, INPUT);
delay(5000);
//begins thingspeak dat collection
ThingSpeak.begin(client);
}

void loop() {
//reads the water value as an analog output
waterVal = analogRead(waterSens);
delay(5000);
//strings characters for watervalue
String level = String(waterVal);

Particle.publish("Water_Level_Value_01", level,PRIVATE); //publish water level value to console 
delay(5000);

if (waterVal>=0 && waterVal<=300){
Particle.publish("Water_Level_01", "LOW",PRIVATE); //display low water level based on values to console 
    
}
else if (waterVal>300 && waterVal<=600){
Particle.publish("Water_Level_01","MID",PRIVATE); //display mid water level based on values to console

}
else if (waterVal>600){
Particle.publish("Water_Level_01", "HIGH",PRIVATE ); //display high water level based on values to console 

}

//initializes sensorvalue for thingspeak to read water levek as an analog output
int sensorValue1 = analogRead(A0);
ThingSpeak.writeField(myChannelNumber, 1, sensorValue1, myWriteAPIKey); //publishes water level value to thing speak 
}


void publishData(){
//controls physical readout parameters
sprintf(szInfo, "%2.2f", fahrenheit);
//publishes temperature data
Particle.publish("Temp01", szInfo, PRIVATE);
number01 = millis();
}

void getTemp(){
//returns a floating point decimal number for temperature
float _temp;
int   i = 0;

number02 = millis();
//converts from celcius to fahrenheit
int sensorValue2 = ds18b20.convertToFahrenheit(_temp); 
ThingSpeak.writeField(myChannelNumber, 2, sensorValue2, myWriteAPIKey); //publish temp to thing speak
}