Garage Door Sesame Interface

//Garage Door control code 4-10-16
// This #include statement was automatically added by the Particle IDE.
#include "Adafruit_DHT/Adafruit_DHT.h"

 /*                           +-----+
 *                 +----------| USB |----------+
 *                 |          +-----+       *  |
 *                 | [ ] VIN           3V3 [ ] |
 *                 | [ ] GND           RST [ ] |
 *                 | [ ] TX           VBAT [ ] |
 *                 | [ ] RX  [S]   [R] GND [ ] |
 *                 | [ ] WKP            D7 [ ] |
 *                 | [ ] DAC +-------+  D6 [ ] |
 *   Opensensor -->| [*] A5  |   *   |  D5 [ ] |
 * Closedsensor -->| [*] A4  |Photon |  D4 [*] |<-- DHT21 AM2301 Sensor
 *                 | [*] A3  |       |  D3 [ ] |
 *                 | [ ] A2  +-------+  D2 [ ] |
 *                 | [ ] A1             D1 [ ] |
 *  Analog0     -->| [ ] A0             D0 [*] |<-- Garage Door Switch Relay
 *                 |                           |
 *                  \    []         [______]  /
 *                   \_______________________/
 *
 *
 */
// This #include statement was automatically added by the Particle IDE.
#include "HttpClient/HttpClient.h"
#include "application.h"

// This #include statement was automatically added by the Spark IDE.
#include "elapsedMillis/elapsedMillis.h"

//-------------Begin UBIDOTS---------------
    #define VARIABLE_ID_DOORSTATUS "ID HERE"
    #define VARIABLE_ID_VOLTAGE "ID HERE"
    #define TOKEN "TOKEN HERE"

    HttpClient http;
    int lightLevel = 0;
    unsigned int nextTime = 0;    // Next time to contact the server

    // Headers currently need to be set at init, useful for API keys etc.
    http_header_t headers[] = {
        { "Content-Type", "application/json" },
        { NULL, NULL } // NOTE: Always terminate headers will NULL
    };

    http_request_t request;
    http_response_t response;
//--------------End UBIDOTS----------------

//--------------Begin DHT------------------
// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

#define DHTPIN D4     // what pin we're connected to

// Uncomment whatever type you're using!
//#define DHTTYPE DHT11		// DHT 11 
//#define DHTTYPE DHT22		// DHT 22 (AM2302)
#define DHTTYPE DHT21		// DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

DHT dht(DHTPIN, DHTTYPE);
//---------------End DHT-------------------

unsigned int interval = 50;
unsigned int particleinterval = 100;
unsigned int particlefuncinterval = 10000;
unsigned int ubiinterval = 5000;
unsigned int dhtinterval = 30000;

int garageDoorFunction(String command);

int rssival = 0;
int doorstatus = 1;
int doorcounter = 0;
int closedsensorpin = A4;
int opensensorpin = A5; 
const int open = 0;
const int closed = 1;

// Define the pins we're going to call pinMode on
int led = D6;  // You'll need to wire an LED to this one to see it blink.
int led2 = D7; // This one is the built-in tiny one to the right of the USB jack


double analog1 = 0;
double analog1raw = 0;
double garagetemp = 0;
double garagehumid = 0;

elapsedMillis timeElapsed; //declare global if you don't want it reset every time loop runs
elapsedMillis timeElapsed2; //declare global if you don't want it reset every time loop runs
elapsedMillis timeElapsed3;
elapsedMillis timeElapsed4;
elapsedMillis timeElapsed5;


char publishString[40];
char doorpublishstring[40];
char doorstatusstring[40];

SYSTEM_MODE(SEMI_AUTOMATIC); //allows for control of Spark.connect() and Spark.process()

// This routine runs only once upon reset
void setup() {
    timeElapsed = 0;
    pinMode(led, OUTPUT);
    pinMode(led2, OUTPUT);
    pinMode(A0, INPUT);
    Serial1.begin(230400);   // open serial over USB
    //ip = {"IP:", WiFi.localIP()};
    //String ip = WiFi.localIP();

    Particle.function("GarageDoor", garageDoorFunction);
    Particle.variable("analog1", &analog1, DOUBLE);  //variables update automatically. Max 4 per particle
    Particle.variable("doorcounter", doorcounter);
    //Particle.variable("doorstatus", &doorstatus, INT); //variables are viewable on mobicle 
    Particle.variable("doorstatus", doorstatusstring, STRING); //variables are viewable on mobicle 
    Particle.variable("garagetemp", &garagetemp, DOUBLE); //variables are viewable on mobicle
    Particle.variable("garagehumid", &garagehumid, DOUBLE); //variables are viewable on mobicle
    
    pinMode(opensensorpin, INPUT_PULLUP);
    pinMode(closedsensorpin, INPUT_PULLUP);

    pinMode(D0, OUTPUT);

    //Do DHTINIT
    pinMode(DHTPIN, INPUT_PULLUP); //sensor needs pullup resistor.
	dht.begin();
	//End DHTINIT

//-------------Begin UBIDOTS---------------
//    request.hostname = "things.ubidots.com";
//    request.port = 80;
//    request.path = "/api/v1.6/variables/"VARIABLE_ID"/values?token="TOKEN;
//--------------End UBIDOTS----------------

}

void loop() {
    if (Particle.connected() == false){
            Particle.connect();
    }
            analog1raw = analogRead(A0);
            analog1 = (analog1 *63 +analog1raw *3.3/4095)/64;
            
            
            if (timeElapsed> interval)
            {                 //sets up interval timer and fires on interval
                digitalWrite(led, !digitalRead(led));   // Turn ON the LED pins
                digitalWrite(led2, !digitalRead(led2));
            
	            int opensense = digitalRead(opensensorpin);
                int closedsense = digitalRead(closedsensorpin);


                if (opensense == LOW) // high,0 = open door, low,1 = closed door
                {  
                    if (doorstatus == closed) //check the previous state, if closed, then generate an event
                    {
                        strcpy(doorpublishstring, "Open");
                        Particle.publish("GARAGEDOOR",doorpublishstring);
                        doorcounter++;
                    }
                    doorstatus = open;
                    strcpy(doorstatusstring, "Open"); //update particle variable.
                } 
                else if (closedsense == LOW)
                {
                    if (doorstatus == open) //check the previous state, if closed, then generate an event
                    {
                        strcpy(doorpublishstring, "Closed");
                        Particle.publish("GARAGEDOOR",doorpublishstring);
                        doorcounter++;
                    }
                    
                    doorstatus = closed;
                    strcpy(doorstatusstring, "Closed");  //update particle variable.
                }
                else 
                {  //if door is neither closed or open, it is in "limbo" 
                    strcpy(doorstatusstring, "Limbo");  //update particle variable.
                }
                
                timeElapsed = 0;    //resets interval timer.
            }
            
            if (timeElapsed2>particleinterval)  //Run code every .1 seconds
            { 
            Particle.process(); //Process wifi events 
            }
            
            if (timeElapsed3> particlefuncinterval) //Run code every 10 seconds
            {
                rssival = WiFi.RSSI();
                sprintf(publishString,"%d",rssival);
                
                Particle.publish("RSSI",publishString);
                timeElapsed3 = 0; //reset interval timer
            }

            if (timeElapsed4> ubiinterval) //Run code every 10 seconds
            {
                updateUbidots();
                timeElapsed4 = 0; //reset interval timer
            }
            
            if (timeElapsed5> dhtinterval) //Run code every 10 seconds
            {
                getDht();
                timeElapsed5 = 0; //reset interval timer
            }

            //delay(2);
 // delay(1000);
}

/*******************************************************************************
 * Function Name  : garageDoor
 * Description    : based on door status, opens or closes the door
 * Input          : analog 5 - digital input.
 * Output         : digital 1 - relay to blip and open or close the door
 * Return         : Value of the pin (0 or 1) in INT type
                    Returns a negative number on failure
 *******************************************************************************/
int garageDoorFunction(String sesame)
{
    if(sesame.startsWith("C"))
	{
		if (doorstatus == open)
		{
	        pinMode(0, OUTPUT);
		    digitalWrite(0, 1);
		    delay(250);
		    digitalWrite(0, 0);
		return 1;
		}
	}
	else if (sesame.startsWith("O"))
		{
        if (doorstatus == closed)
		{
	        pinMode(0, OUTPUT);
		    digitalWrite(0, 1);
		    delay(250);
		    digitalWrite(0, 0);
		return 2;
		}
	}
	else if (sesame.startsWith("X"))
		{
        if (doorstatus == closed){
            return 999;
        } else
        return 123;
		}
	return -1;
	
}



/*******************************************************************************
 * Function Name  : updateUbidots
 * Description    : sends variables to ubidots
 * Input          : doorstatus global variables
 * Output         : sends data to ubidots
 * Return         : void
                    
 *******************************************************************************/
void updateUbidots() {
//-------------Begin UBIDOTS---------------
    request.hostname = "things.ubidots.com";
    request.port = 80;
    request.path = "/api/v1.6/variables/"VARIABLE_ID_DOORSTATUS"/values?token="TOKEN;

    Serial.println("Sending ubidots data ...");
    int ubidotsdoorstatus = ~doorstatus&0x01;
    request.body = "{\"value\":" + String(ubidotsdoorstatus) + "}";
    // Post request
    http.post(request, response, headers);
    Serial.println(response.status);
    Serial.println(response.body);
    


    request.hostname = "things.ubidots.com";
    request.port = 80;
    request.path = "/api/v1.6/variables/"VARIABLE_ID_VOLTAGE"/values?token="TOKEN;

    Serial.println("Sending ubidots data ...");
    request.body = "{\"value\":" + String(analog1) + "}";
    // Post request
    http.post(request, response, headers);
    Serial.println(response.status);
    Serial.println(response.body);
    
}

/*******************************************************************************
 * Function Name  : getDht
 * Description    : gets temp and humidity
 * Input          : 
 * Output         : 
 * Return         : void
                    
 *******************************************************************************/
void getDht() {
// Wait at least 2 seconds between measurements.
	

// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a 
// very slow sensor)
	float h = dht.getHumidity();
// Read temperature as Celsius
	float t = dht.getTempCelcius();
// Read temperature as Farenheit
	float f = dht.getTempFarenheit();
  
   garagetemp = f; //updates spark variable with current temp.
   garagehumid = h;
   
// Check if any reads failed and exit early (to try again).
	if (isnan(h) || isnan(t) || isnan(f)) {
		Serial.println("Failed to read from DHT sensor!");
		return;
	}

// Compute heat index
// Must send in temp in Fahrenheit!
	float hi = dht.getHeatIndex();
	float dp = dht.getDewPoint();
	float k = dht.getTempKelvin();

	Serial.print("Humid: "); 
	Serial.print(h);
	Serial.print("% - ");
	Serial.print("Temp: "); 
	Serial.print(t);
	Serial.print("*C ");
	Serial.print(f);
	Serial.print("*F ");
	Serial.print(k);
	Serial.print("*K - ");
	Serial.print("DewP: ");
	Serial.print(dp);
	Serial.print("*C - ");
	Serial.print("HeatI: ");
	Serial.print(hi);
	Serial.println("*C");
	Serial.println(Time.timeStr());
}