Published December 1, 2022

Group 32 MEGR 3171 Automatic AC Damper

A perfectly climate controlled house is a luxury you may not know you needed.

IntermediateShowcase (no instructions)68

Things used in this project

Hardware components

Particle Argon

Breadboard (generic)

Jumper wires (generic)

Adafruit SHT30 Temperature And Humidity Sensor - Wired Enclosed Shell

Futaba S148 Servo

USB-A to Mini-USB Cable

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Hand tools and fabrication machines

Drill / Driver, 20V

DURATOOL Metal Hacksaw of 300mm Blade Length

Story

Central air conditioning is a modern convenience that most would admit that they cannot live without. However, these systems can have limitations. Central air conditioning generally regulates temperature with one temperature sensor per floor, which is only a local approximation of the average temperature of the floor. A floor with many closed-door rooms with ducts in them may have a large variation in temperature between each room. Manual air conditioning dampers exist to help solve this issue, but these dampers are merely vents that can be manually set to different amounts of restriction to restrict hot air from flowing to the colder room. Again, this system has limitations, because the static dampers are set to an average reading, which has no ability to actively regulate the temperature in a room. The ultimate solution is to have a temperature sensor in every room, and regulate the flow of air to each room actively to maintain a constant temperature in every room. This problem poses a few obstacles that can be addressed. A thermostat is hard wired into one spot in the wall in a floor, which would make installing many active dampers a large and destructive job requiring lots of sheetrock to be removed. The solution is to have all of the electronics and damper packaged in the ceiling vent, which is easy to replace. The dampers can communicate wirelessly over the internet instead of being hard wired into the thermostat for ease of installation as well. In fact, the system does not need to know the temperature the thermostat is set to, but instead the temperature sensors can compare their values with one another and work in relative numbers.

This concept is tested with two IOT argons. These two argon are copies of each other to show the scalable nature of this idea. The argons each collect data from a temperature and humidity sensor, and control servo motors to open and close the vents. As just mentioned, humidity in the room is taken into account when controlling the vents in this model as well. The logic works as such: in the winter time, a colder room needs more heat than a warmer one. A room that is more humid than another is viewed as negative no matter the season. Of the two vents, the vent that has the higher temperature will read a one and the one with the colder temperature will read a zero. Similarly, the vent that has the lower humidity will read a one and the vent with the higher humidity will read a zero. These values are added together and passed through an if-then statement to decide when to open or close the vent. The statement says that if a vent reads a total value less than 1, the vent will close; otherwise the vent will remain open. This means that unless a room is both more humid and colder, the vent will remain open. Once the vent is commanded to close, the servo motor is commanded to rotate to a certain angle that fully closes the vent. This process loops every 10 seconds, and works digitally to balance the temperatures between rooms in the house. A more detailed description of the project exists below.

Below is a demonstration of the vents in use:

Below the video is still shots of important parts of the video. The first of these is the Thingspeak graphs produced by the boards:

Chart Key

Field 1: Temperature of vent 1 in Fahrenheit.

Field 2: Humidity of vent 1 in percent humidity

Field 3: Vent open plotter for vent 1. Y values of 1 and 0 mean the vent is open, 2 means the vent is closed.

Field 4: Temperature of vent 2 in Fahrenheit.

Field 5: Humidity of vent 2 in percent humidity

Field 6: Vent open plotter for vent 2. Y values of 1 and 0 mean the vent is open, 2 means the vent is closed.

Wiring and Fabrication

Below are images of the two vents. They are identical to each other.

Vent 1

Vent 2

Below is an image of the vent opening linkage:

This linkage is proprietary to this model vent. The mechanical advantage of the aluminum lever is critical to the functioning of the vent, as the servo motor has a limited amount of torque. With this linkage, I was even able to run the 7 volt servo off of the 3.3 volt source of the argon.

Programming Troubles

(Disclaimer: We are beginners at C and/or C++)

This project relies on the transfer of number values over the cloud, as opposed to boolean values that many Iot argon projects do. This operation turns out to be more of a challenge than one may think. The values the temperature and humidity sensors read is stored locally as an integer value. It is compared with a cloud-transferred integer to decide whether the vent will be open or not. However, the problem begins with the fact that integer values cannot be sent to the cloud, so instead they must be converted to a string to be sent to the cloud. This is done in the Particle.publish command: Particle.publish("roomtemperature2", String(fahrenheit2)); . The integer value that is read from the temperature sensor that was in the desired format is now converted to a string, which cannot be compared to an integer on the other board. The solution is to use the sscanf function to convert the cloud-transmitted string values back to integer values. This line of code does this: sscanf(data, "%d", &roomtemperature2); . This line reads as such: sscanf data from the Particle.subcribe data and print it to the roomtemperature2 variable in the integer format. The "%d" indicates the integer format.

Wiring Diagram

A wiring diagram is displayed below. The white plastic rectangle with the holes down the center of it is the SHT30 temperature sensor. It has four wires: black, red, white, and yellow. Black is wired to ground, red is wired to 3.3v power, white is wired to SDA, and yellow is wired to SCL. The Futaba servo is clearly labelled, and it has three wires: red, black, and white. Red is connected to 3.3v power, black is connected to ground, and white is the signal wire that is wired to pin D4.

Code

// Include Thingspeak library
#include <ThingSpeak.h>
// Include Servo Library
#include <Tinker-Servo.h>
// Include Temperature & Humidity Sensor Library
#include <adafruit-sht31.h>
// Clarify which sensor is being used with the sensor library
Adafruit_SHT31 sht31 = Adafruit_SHT31();
// Introduce all the variables used as integers
int roomtemp;
int roomhumidity;
int fahrenheit;
int highertemp;
int higherhumidity;
int ventopen;
int roomtemperature2;
int roomhumidity2;
int vent1;
//Introduce the servo function
Servo myservo; 
//Needed to initialize Thingspeak
TCPClient client;
//Introduce Thingspeak channel number and API key
unsigned long myChannelNumber = 1935369;
const char * myWriteAPIKey = "IE74J8LAV2D2UWDI";

void setup() {
    //Initialize Temperature & Humidity Sensor
    sht31.begin(0x44);
    //Assign pin 4 as the servo signal output and assign time delays for the servo
    myservo.attach(4,600,2300);
    //Initialize Thingspeak
    ThingSpeak.begin(client);
    //Introduce particle variable roomtemperature1 as the integer value of fahrenheit
    Particle.variable("roomtemperature1", &fahrenheit, INT);
    //Introduce particle variable roomhumidity1 as the integer value of roomhumidity
    Particle.variable("roomhumidity1", &roomhumidity, INT);
    //Subscribe to particle variable roomtemperature2 and store it in function roomtempl
    Particle.subscribe("roomtemperature2", roomtempl);
    //Subscribe to particle variable roomhumidity2 and store it in function roomhumidl
    Particle.subscribe("roomhumidity2", roomhumidl);
    //Initialize serial printing
    Serial.begin(9600);
}
    //Run function roomtempl
void roomtempl(const char *event, const char *data){
    //convert subscribed "roomtemperature2" string data to integer data
    sscanf(data, "%d", &roomtemperature2);
}
    //Run function roomhumidl
void roomhumidl(const char *event, const char *data){
    //convert subscribed "roomhumidity2" string data to integer data
    sscanf(data, "%d", &roomhumidity2);
}

void loop() {
    // Read temperature and store it in roomtemp
    roomtemp = sht31.readTemperature();
    // Read humidity and store it in roomhumidity
    roomhumidity = sht31.readHumidity();
    //Convert temperature roomtemp from celcius to fahrenheit and store it in fahrenheit
    fahrenheit = (roomtemp*1.8)+32;
    //Publish fahrenehit to the particle variable roomtemperature1
    //*Note integer values must be converted to string in order to be printed to the cloud
    Particle.publish("roomtemperature1", String(fahrenheit));
    //Publish roomhumidity to the particle variable roomhumidity1
    //*Note integer values must be converted to string in order to be printed to the cloud
    Particle.publish("roomhumidity1", String(roomhumidity));
    //If the temperature of the local temperature sensor fahrenheit is less than the other
    //temperature sensor roomtemperature2, highertemp=1. Otherwise highertemp=0
    if (fahrenheit > roomtemperature2){
        (highertemp=1);
    }
    else{
        (highertemp=0);
    }
    //If the humidity of the local humidity sensor roomhumidity is greater than the other
    //temperature sensor roomhumidity2, higherhumidity=1. Otherwise higherhumidity=0
    if (roomhumidity < roomhumidity2){
        (higherhumidity=1);
    }
    else{  
        (higherhumidity=0);
    }
    //Publish highertemp to the particle variable highertemp. This helps with debugging
    Particle.publish("highertemp1", String(highertemp));
    //Publish higherhumidity to the particle variable higherhumidity. This helps with debugging
    Particle.publish("higherhumidity1", String(higherhumidity));
    //if highertemp and higherhumidity=1, then the vent will close. The vent is intstructed
    //to close by myservo.write(120) [**120 means 120 degrees]. Otherwise the vent stays open
    vent1 = highertemp+higherhumidity;
    if (vent1 > 1){
        myservo.write(120);
    }
    else{
        myservo.write(0);              
    }
    //Write fahrenheit to Thingspeak field 1
    //Write roomhumidity to Thingspeak field 2
    //Write vent1 to Thingspeak field 3
    ThingSpeak.setField(1,fahrenheit);
    ThingSpeak.setField(2,roomhumidity);    
    ThingSpeak.setField(3,vent1);    
    ThingSpeak.writeFields(myChannelNumber,myWriteAPIKey);
    //Reset vent1 to zero before the loop begins again
    vent1=0;
    //delay 10 seconds before the loop restarts
delay(10000);

}

// Include Thingspeak library
#include <ThingSpeak.h>
// Include Servo Library
#include <Stepper.h>
// Include Temperature & Humidity Sensor Library
#include <adafruit-sht31.h>
// Clarify which sensor is being used with the sensor library
Adafruit_SHT31 sht31 = Adafruit_SHT31();
// Introduce all the variables used as integers
int roomtemp2;
int roomhumidity2;
int fahrenheit2;
int highertemp2;
int higherhumidity2;
int ventopen;
int roomtemperature1;
int roomhumidity1;
int vent2;
//Introduce the servo function
Servo myservo;
//Needed to initialize Thingspeak
TCPClient client;
//Introduce Thingspeak channel number and API key
unsigned long myChannelNumber = 1935369;
const char * myWriteAPIKey = "IE74J8LAV2D2UWDI";

void setup() {
    //Initialize Temperature & Humidity Sensor
    sht31.begin(0x44);
    //Assign pin 4 as the servo signal output and assign time delays for the servo
    myservo.attach(4,600,2300);
    //Initialize Thingspeak
    ThingSpeak.begin(client);
    //Introduce particle variable roomtemperature2 as the integer value of fahrenheit2
    Particle.variable("roomtemperature2", &fahrenheit2, INT);
    //Introduce particle variable roomhumidity2 as the integer value of roomhumidity2
    Particle.variable("roomhumidity2", &roomhumidity2, INT);
    //Subscribe to particle variable roomtemperature1 and store it in function roomtempm
    Particle.subscribe("roomtemperature1", roomtempm);
    //Subscribe to particle variable roomhumidity1 and store it in function roomhumidm
    Particle.subscribe("roomhumidity1", roomhumidm);
    //Initialize serial printing
    Serial.begin(9600);
delay(200);
}
    //Run function roomtempm
void roomtempm(const char *event, const char *data){
    //convert subscribed "roomtemperature1" string data to integer data
    sscanf(data, "%d", &roomtemperature1);
}
    //Run function roomhumidm
void roomhumidm(const char *event, const char *data){
    //convert subscribed "roomhumidity1" string data to integer data    
    sscanf(data, "%d", &roomhumidity1);
}

void loop() {
    // Read temperature and store it in roomtemp2
    roomtemp2 = sht31.readTemperature();
    // Read humidity and store it in roomhumidity2
    roomhumidity2 = sht31.readHumidity();
    //Convert temperature roomtemp2 from celcius to fahrenheit and store it in fahrenheit2
    fahrenheit2 = (roomtemp2*1.8)+32;
    //Publish fahrenehit2 to the particle variable roomtemperature2
    //*Note integer values must be converted to string in order to be printed to the cloud
    Particle.publish("roomtemperature2", String(fahrenheit2));
    //Publish roomhumidity2 to the particle variable roomhumidity2
    //*Note integer values must be converted to string in order to be printed to the cloud
    Particle.publish("roomhumidity2", String(roomhumidity2));
    //If the temperature of the local temperature sensor fahrenheit2 is less than the other
    //temperature sensor roomtemperature1, highertemp2=1. Otherwise highertemp2=0
    if (fahrenheit2 > roomtemperature1){
        (highertemp2=1);
    }
    else{
        (highertemp2=0);
    }
    //If the humidity of the local humidity sensor roomhumidity2 is greater than the other
    //temperature sensor roomhumidity1, higherhumidity2=1. Otherwise higherhumidity2=0
    if (roomhumidity2 < roomhumidity1){
        (higherhumidity2=1);
    }
    else{  
        (higherhumidity2=0);
    }
    //Publish highertemp to the particle variable highertemp2. This helps with debugging
    Particle.publish("highertemp2", String(highertemp2));
    //Publish higherhumidity to the particle variable higherhumidity2. This helps with debugging
    Particle.publish("higherhumidity2", String(higherhumidity2));
    //if highertemp2 and higherhumidity2=1, then the vent will close. The vent is intstructed
    //to close by myservo.write(110) [**110 means 110 degrees]. Otherwise the vent stays open
    vent2 = highertemp2+higherhumidity2;
    if (vent2 > 1) {
        myservo.write(110);
    }
    else{
        myservo.write(0);           
    }
    //Write fahrenheit2 to Thingspeak field 4
    //Write roomhumidity2 to Thingspeak field 5
    //Write vent2 to Thingspeak field 6
    ThingSpeak.setField(4,fahrenheit2);
    ThingSpeak.setField(5,roomhumidity2);
    ThingSpeak.setField(6,vent2);    
    ThingSpeak.writeFields(myChannelNumber,myWriteAPIKey);
    //Reset vent2 to zero before the loop begins again
    vent2=0;
    //delay 10 seconds before the loop restarts
delay(10000);

}

Credits

Gregory Estell

1 project • 1 follower

Thanks to Layne Riggs.

Group 32 MEGR 3171 Automatic AC Damper

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

Wiring Diagram

Code

Greg's Argon

Layne's Argon

Credits

Gregory Estell

Comments

Embed the widget on your own site

Group 32 MEGR 3171 Automatic AC Damper

Group 32 MEGR 3171 Automatic AC Damper

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

Wiring Diagram

Code

Greg's Argon

Layne's Argon

Credits

Gregory Estell

Comments

Related channels and tags