Smart Ambient Lighting

/* This is the ESP8266 code for the Smart Ambient Lighting Project
 *  Uses Weather Underground API
 *  
 *  Uses code from the following website: https://gist.github.com/bbx10/149bba466b1e2cd887bf
 *  for utilizing the Weather Underground API.
 *  
 *  Instructions for establishing TCP connection to Yn:
 *  https://github.com/iot-playground/Arduino/blob/master/ESP8266ArduinoIDE/WiFiWebServer/WiFiWebServer.ino
 *  
 *  The ESP8266 board is connected to photocells, an IR Transmitter/Receiver, and
 *  an RGB LED. When motion is detected, the LED lights up according to the outside 
 *  temperature. If it is locally dark, the ESP sends a signal to Arduino Yn's
 *  Python program to turn on the Family Room Lights.
 *  
 * Created by Daniel Martin
 */

// To setup the board, follow these instructions:
// https://learn.sparkfun.com/tutorials/esp8266-thing-development-board-hookup-guide/all

// Go to https://www.wunderground.com/weather/api to create a free account and select a plan

// Install libraries:
// https://github.com/adafruit/Adafruit_NeoPixel
// https://github.com/myDevicesIoT/Cayenne-MQTT-ESP8266

#include <ESP8266WiFi.h>
#include <LiquidCrystal.h>
#include <Wire.h>
#include <Adafruit_NeoPixel.h>
#include <ArduinoJson.h>

#define CAYENNE_PRINT Serial
#include <CayenneMQTTESP8266.h>

#define WU_API_KEY "*************"  // From Weather Underground website

#define WU_LOCATION "90001"         // Change this to your zip code

int outTemp = 72;     // initial temperature (a placeholder until the real value is received)
long timer = millis();

long interval = 5*60*1000;   // 5 minute delay

#define DELAY_NORMAL    (5*60*1000)

#define DELAY_ERROR     (20*60*1000)

#define WUNDERGROUND "api.wunderground.com"

// HTTP request
const char WUNDERGROUND_REQ[] =
    "GET /api/" WU_API_KEY "/conditions/q/" WU_LOCATION ".json HTTP/1.1\r\n"
    "User-Agent: ESP8266/0.1\r\n"
    "Accept: */*\r\n"
    "Host: " WUNDERGROUND "\r\n"
    "Connection: close\r\n"
    "\r\n";
static char respBuf[4096];

int irRec = 12;               // IR Receiver digital pin number
int irLed = 13;               // IR Transmitter digital pin number
int maxNumIR = 5;             // Number of 1's received to trigger LED
int led = 14;                 // RGB LED pin
int photoPin = A0;            // ADC pin for photocells
bool irTrue = false;
unsigned long lastMillis = 0;

// Setup of RGB LED
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, led, NEO_RGB + NEO_KHZ400);


char s = ' ';
const char* host = "100.100.1.10";        // Change to your IP Address
char ssid[] = "*********";                // Change to your SSID
char wifiPassword[] = "***********";      // Change to your Wi-Fi password


// Go to cayenne.mydevices.com to setup your Sparkfun board
char username[] = "****-***-***-***-******";    // Username from Cayenne
char password[] = "****************";           // Password from Cayenne
char clientID[] = "******-***-***-***-********"; // Client ID from Cayenne

WiFiClient client;

void setup() {
  pinMode(irRec, INPUT);  pinMode(irLed, OUTPUT);   // IR LED & Receiver
  Serial.begin(9600);
  delay(10);
  Cayenne.begin(username, password, clientID, ssid, wifiPassword);
  pixels.begin();
  pixels.setPixelColor(0, pixels.Color(0, 0, 0));
  pixels.show();

  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

   delay(5000);

  Serial.print("connecting to ");
  Serial.println(host);

  // Use WiFiClient class to create TCP connections
  // We are using port 5560 -- must be consist with Yn's python code
  const int port = 5560;        
  if (!client.connect(host, port)) 
  {
    Serial.println("connection failed");
    return;
  }

}

void loop() {
  Cayenne.loop();
  int photoval = analogRead(photoPin);          // Read the value of light intensity
  Serial.println(photoval);
  
  irTrue = IRSensor();                        // Check if there is motion
  
  if((irTrue) && (photoval >= 600)) {        // If there is enough light, only turn on LED
    OutTempRead();
  }
  else if ((irTrue) && (photoval < 600)) {   // If not enough light, send to Yun also

    OutTempRead();
    sendToYun();

    delay(1000);
  }

  if (millis() - lastMillis > 10000) {
    lastMillis = millis();

    Cayenne.fahrenheitWrite(1, outTemp);
    
    Cayenne.virtualWrite(2, photoval);
    Cayenne.virtualWrite(3, irTrue);

  }


  if(millis() - timer > interval) {     // Every 5 mins, check temperature
    WunderSetup();
    timer = millis();
  }
  delay(2000);

}

// Send a different number to Yn based on the outside temperature
void sendToYun() {
  Serial.println("Sending to Yun.");
  if (outTemp > 100) {
    client.print('8');
    delay(1000); 
    client.print('0');
  }
  else if (outTemp > 90) {
    client.print('1'); 
    delay(1000); 
    client.print('0');
  }
  else if (outTemp > 80) {
    client.print('2'); 
    delay(1000); 
    client.print('0');    
  }
  else if (outTemp > 70) {
    client.print('3');
    delay(1000); 
    client.print('0');     
  }
  else if (outTemp > 60) {
    client.print('4'); 
    delay(1000); 
    client.print('0');    
  }
  else if (outTemp > 50) {
    client.print('5'); 
    delay(1000); 
    client.print('0');    
  }
  else if (outTemp > 40) {
    client.print('6');
    delay(1000); 
    client.print('0');     
  }
  else if (outTemp <= 40) {
    client.print('7'); 
    delay(1000); 
    client.print('0');    
  }
}


int OutTempRead() {       // Set the RGB LED based on the outside temp

  if (outTemp < 60) {
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(100);
    pixels.setPixelColor(0, pixels.Color(0, 255, 0));
    pixels.show();
    delay(4000);
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(1000);
  }
  else if(outTemp >= 60 && outTemp <= 80) {
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(100);
    pixels.setPixelColor(0, pixels.Color(255, 0, 0));
    pixels.show();
    delay(4000);
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(1000);   
  }
  else {
    pixels.setPixelColor(0, pixels.Color(255, 255, 255));
    pixels.show();
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(4000);
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    delay(1000);   
  }
}

// Connect to Weather Underground -- modified from the website mentioned above
void WunderSetup() {
 // TODO check for disconnect from AP

  // Open socket to WU server port 80
  Serial.print(F("Connecting to "));
  Serial.println(WUNDERGROUND);

  // Use WiFiClient class to create TCP connections
  WiFiClient httpclient;
  const int httpPort = 80;
  if (!httpclient.connect(WUNDERGROUND, httpPort)) {
    Serial.println(F("connection failed"));
    delay(DELAY_ERROR);
    return;
  }

  // This will send the http request to the server
  Serial.print(WUNDERGROUND_REQ);
  httpclient.print(WUNDERGROUND_REQ);
  httpclient.flush();

  // Collect http response headers and content from Weather Underground
  // HTTP headers are discarded.
  // The content is formatted in JSON and is left in respBuf.
  int respLen = 0;
  bool skip_headers = true;
  while (httpclient.connected() || httpclient.available()) {
    if (skip_headers) {
      String aLine = httpclient.readStringUntil('\n');
      //Serial.println(aLine);
      // Blank line denotes end of headers
      if (aLine.length() <= 1) {
        skip_headers = false;
      }
    }
    else {
      int bytesIn;
      bytesIn = httpclient.read((uint8_t *)&respBuf[respLen], sizeof(respBuf) - respLen);
      Serial.print(F("bytesIn ")); Serial.println(bytesIn);
      if (bytesIn > 0) {
        respLen += bytesIn;
        if (respLen > sizeof(respBuf)) respLen = sizeof(respBuf);
      }
      else if (bytesIn < 0) {
        Serial.print(F("read error "));
        Serial.println(bytesIn);
      }
    }
    delay(1);
  }
  httpclient.stop();

  if (respLen >= sizeof(respBuf)) {
    Serial.print(F("respBuf overflow "));
    Serial.println(respLen);
    delay(DELAY_ERROR);
    return;
  }
  // Terminate the C string
  respBuf[respLen++] = '\0';


  showWeather(respBuf);

}

// Find out the current temperature -- modified from the website mentioned above
void showWeather(char *json)
{
  StaticJsonBuffer<3*1024> jsonBuffer;

  // Skip characters until first '{' found
  // Ignore chunked length, if present
  char *jsonstart = strchr(json, '{');
  //Serial.print(F("jsonstart ")); Serial.println(jsonstart);
  if (jsonstart == NULL) {
    Serial.println(F("JSON data missing"));
    //return false;
  }
  json = jsonstart;

  // Parse JSON
  JsonObject& root = jsonBuffer.parseObject(json);
  if (!root.success()) {
    Serial.println(F("jsonBuffer.parseObject() failed"));
    //return false;
  }

  // Extract weather info from parsed JSON
  JsonObject& current = root["current_observation"];
  const float temp_f = current["temp_f"];
  outTemp = round(temp_f);
  Serial.print(outTemp); Serial.print(F(" F"));

}

// Check if there is motion
bool IRSensor() {
  int irvals = 0;
  for (int i = 0; i < 20; i++) {      // Check 20 times to account for random detection
    irvals = irvals + irDetect(irLed, irRec, 38000);       // Check for object
    //delay(15);
  }
  Serial.println(irvals);                    

  if(irvals > maxNumIR) {     // If 5/20 are 1's, then we know for sure there is motion
    return true;
  }
  else {
    pixels.setPixelColor(0, pixels.Color(0, 0, 0));
    pixels.show();
    return false;
  }
  
  

}

// Send and receive an IR signal
int irDetect(int irLedPin, int irReceiverPin, long frequency)
{
  tone(irLedPin, frequency, 8);              // IRLED 38 kHz for at least 1 ms
  delay(1);                                  // Wait 1 ms
  int ir = digitalRead(irReceiverPin);       // IR receiver -> ir variable
  delay(1);                                  // Down time before recheck
  return !(ir);                                 // Return 1 no detect, 0 detect
}  

//The following function is taken from Cayenne
//Default function for processing actuator commands from the Cayenne Dashboard.
//You can also use functions for specific channels, e.g CAYENNE_IN(1) for channel 1 commands.
CAYENNE_IN_DEFAULT()
{
  CAYENNE_LOG("CAYENNE_IN_DEFAULT(%u) - %s, %s", request.channel, getValue.getId(), getValue.asString());
  //Process message here. If there is an error set an error message using getValue.setError(), e.g getValue.setError("Error message");
}