WiFi Remote Garage Door

// This #include statement was automatically added by the Particle IDE.
#include "PietteTech_DHT/PietteTech_DHT.h"
// Code inspired by Prof. John Macalpine

 /*                           +-----+
 *                 +----------| USB |----------+
 *                 |          +-----+       *  |
 *  DHT11 V(in) -->| [ ] VIN           3V3 [ ] |<-- Relay VCC
 *                 | [ ] GND           RST [ ] |
 *                 | [ ] TX           VBAT [ ] |
 *                 | [ ] RX  [S]   [R] GND [ ] |<-- Relay GND
 *                 | [ ] WKP            D7 [ ] |
 *                 | [ ] DAC +-------+  D6 [ ] |
 *   Opensensor -->| [*] A5  |   *   |  D5 [ ] |
 * Closedsensor -->| [*] A4  |Photon |  D4 [*] |<-- DHT111 AM2301 Sensor
 *                 | [*] A3  |       |  D3 [ ] |
 *                 | [ ] A2  +-------+  D2 [ ] |
 *                 | [ ] A1             D1 [ ] |
 *                 | [ ] A0             D0 [*] |<-- Garage Door Switch Relay
 *                 |                           |
 *                  \    []         [______]  /
 *                   \_______________________/
 *
 *
 */

const String key = "HM51Z16VGAII6IX5"; //write key

//--------------Begin DHT------------------
// Example testing sketch for various DHT humidity/temperature sensors


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

// Uncomment whatever type you're using!
#define DHTTYPE DHT11		// DHT 11 

// 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


//declaration
void dht_wrapper(); // must be declared before the lib initialization

// Lib instantiate
PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
// globals
unsigned int DHTnextSampleTime;	    // Next time we want to start sample
bool bDHTstarted;		    // flag to indicate we started acquisition
int n;                              // counter

//---------------End DHT-------------------


unsigned int particleinterval = 100;
unsigned int particlefuncinterval = 10000;
unsigned int ubiinterval = 15000;
unsigned int dhtinterval = 5000;

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 analog2 = 0;
double analog1raw = 0;
double analog2raw = 0;
double garagetemp = 70;
double readtemp = 70;
double garagehumid = 0;


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
Timer task50ms(50, dodoor);
Timer task10sec(10000,dopublish);
Timer task15sec(15000,updateThingspeak);
Timer taskdht(5000, readdht);

void setup() {
    task50ms.start();
    task10sec.start();
    task15sec.start();
    taskdht.start();
    
    pinMode(led, OUTPUT);
    pinMode(led2, OUTPUT);
    pinMode(A0, INPUT);
    pinMode(A1, 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.
	//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----------------
}

// This wrapper is in charge of calling
// mus be defined like this for the lib work
void dht_wrapper() {
    DHT.isrCallback();
}

void loop() {
    if (Particle.connected() == false){
            Particle.connect();
    }
    analog1raw = analogRead(A0);
    analog1 = (analog1 *63 +analog1raw *3.3/4095)/64;
    analog2raw = analogRead(A1);
    analog2 = (analog2 *63 +analog2raw *3.3/4095)/64;

    doDht();
}

void dopublish(){
    rssival = WiFi.RSSI();
    sprintf(publishString,"%d",rssival);
                
    Particle.publish("RSSI",publishString);
}

void readdht() {
    if (!bDHTstarted) {		// start the sample
    Serial.print("\n");
    Serial.print(n);
    Serial.print(": Retrieving information from sensor: ");
    DHT.acquire();
    bDHTstarted = true;
    }
}

void dodoor() {
    
        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("ON",doorpublishstring); // Publishing Open Event for second Photon
                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("OFF",doorpublishstring); //Publishing Close Event for second Photon
                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.
            }
}


/*******************************************************************************
 * 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  : updateThingspeak
 * Description    : sends variables to ts
 * Input          : doorstatus global variables
 * Output         : sends data to ts
 * Return         : void
                    
 *******************************************************************************/
bool updateThingspeak() 
{
    //delay (2000);
    static int count = 0;
    Serial.println(count++);
    int rssival = WiFi.RSSI();
    //sprintf(publishString,"%d",rssival);
    //bool success = Particle.publish("RSSI",publishString);
    
    //sprintf(publishString, "%1.4f", checkbattery());

      bool success = Particle.publish("thingSpeakWrite_All", +
     "{ \"1\": \"" + String(rssival) + "\"," +
       "\"2\": \"" + String(garagetemp) + "\"," +
       "\"3\": \"" + String(garagehumid) + "\"," +
       "\"4\": \"" + String(doorstatus) + "\"," +
       "\"5\": \"" + String(doorcounter) + "\"," +
       //"\"6\": \"" + String(analog1) + "\"," +
       //"\"7\": \"" + String(analog2) + "\"," +
       "\"k\": \"" + key + "\" }", 60, PRIVATE);
    return success; //if sent, then turn of the send flag, otherwise let it try again.
    
}

/*******************************************************************************
 * Function Name  : getDht
 * Description    : gets temp and humidity
 * Input          : 
 * Output         : 
 * Return         : void
                    
 *******************************************************************************/
void doDht() {
    if (!DHT.acquiring()) {		// has sample completed?

	    // get DHT status
	    int result = DHT.getStatus();

	    Serial.print("Read DHT sensor: ");
	    switch (result) {
		case DHTLIB_OK:
		    Serial.println("OK");
		   	garagehumid = DHT.getHumidity();
            // Read temperature as Celsius
	        //garagetemp = DHT.getCelsius();
            // Read temperature as Farenheit
	        garagetemp = DHT.getFahrenheit();
	        break;
		case DHTLIB_ERROR_CHECKSUM:
		    Serial.println("Error\n\r\tChecksum error");
		    break;
		case DHTLIB_ERROR_ISR_TIMEOUT:
		    Serial.println("Error\n\r\tISR time out error");
		    break;
		case DHTLIB_ERROR_RESPONSE_TIMEOUT:
		    Serial.println("Error\n\r\tResponse time out error");
		    break;
		case DHTLIB_ERROR_DATA_TIMEOUT:
		    Serial.println("Error\n\r\tData time out error");
		    break;
		case DHTLIB_ERROR_ACQUIRING:
		    Serial.println("Error\n\r\tAcquiring");
		    break;
		case DHTLIB_ERROR_DELTA:
		    Serial.println("Error\n\r\tDelta time to small");
		    break;
		case DHTLIB_ERROR_NOTSTARTED:
		    Serial.println("Error\n\r\tNot started");
		    break;
		default:
		    Serial.println("Unknown error");
		    break;
	    }


        /*
	    Serial.print("Humidity (%): ");
	    Serial.println(DHT.getHumidity(), 2);

	    Serial.print("Temperature (oC): ");
	    Serial.println(DHT.getCelsius(), 2);

	    Serial.print("Temperature (oF): ");
	    Serial.println(DHT.getFahrenheit(), 2);
        
	    Serial.print("Temperature (K): ");
	    Serial.println(DHT.getKelvin(), 2);

	    Serial.print("Dew Point (oC): ");
	    Serial.println(DHT.getDewPoint());

	    Serial.print("Dew Point Slow (oC): ");
	    Serial.println(DHT.getDewPointSlow());
        */
        
	    n++;  // increment counter
	    bDHTstarted = false;  // reset the sample flag so we can take another
	}

	//Serial.println(Time.timeStr());
}