/*
  Simple AC Power Monitor
  J. McNeely
  2014-03-16
  
  This sketch allows a cheap and simple way of detecting an AC power
  failure.  I looked all over for a simple way to do this, and found
  that this is very inexpensive, and appears to be quite accurate.
  
  In order for this idea to work, the Arduino must be powered by 
  batteries or alternative sources (mine is the solar gear).
  
  This sketch is just a basic starter setup to be incorporated into
  whatever larger project you have in mind.
  
  Best of Luck!
  Joe
  
*/

#define ALARMPIN 2
#define POWERSENSEPIN A1

float  voltage = 5;
float  voltageThreshold = 4.5;

float  powerVal = 1023;
float  powerValPrv = powerVal;
int    powerState = 1;
int    powerStatePrv = powerState;
long   lastPowerDebounceTime = 0;
long   debouncePowerDelay = 5000;  // Delay before power status is considered to have changed.
int    alarmState = LOW;
int    alarmFlag = 0;


void setup() {
  pinMode(POWERSENSEPIN, INPUT_PULLUP);
  pinMode(ALARMPIN, OUTPUT);
  powerVal = analogRead(POWERSENSEPIN);
  voltage = powerVal * (5.0 / 1023.0);
  if (voltage > voltageThreshold) {
    powerState = 1;
    alarmState = HIGH;
    powerValPrv = powerVal;
  } else {
    powerState = 0;
    alarmState = LOW;
    powerValPrv = powerVal;
  }
  digitalWrite(ALARMPIN, alarmState)
  Serial.begin(9600);
  Serial.println("Commercial Power Monitor");
  Serial.println("------------------------");
  Serial.println();
}

void loop()
{
  if ((millis() - lastPowerDebounceTime) > debouncePowerDelay) {
    powerVal = analogRead(POWERSENSEPIN);
    voltage = powerVal * (5 / 1023.0);
    if (voltage > voltageThreshold) {
      powerState = 1;
      setAlarm(0);
    } else {
      powerState = 0;
      setAlarm(1);
    }
  }
  
  if (powerState != powerStatePrv) {
    lastPowerDebounceTime = millis();
    setPowerChange();
  }
}

void setPowerChange() {
  // This is a stub.  More complex actions may be hooked into this function.
  powerStatePrv = powerState;
  Serial.print("\nCommercial Power Changed: ");
  if (powerState == 1) {
    Serial.println("Power Restored");
  } else if (powerState == 0) {
    Serial.println("Power Failure");
  }
}

void setAlarm(int alarmAction) {
  // This is a stub.  The ALARMPIN could be connected to an LED, buzzer, relay, whatever.
  if (alarmAction == 0) {
    alarmFlag = 0;
    alarmState = LOW;
    digitalWrite(ALARMPIN,alarmState);
  } else if (alarmAction == 1) {
    alarmFlag = 1;
    alarmState = HIGH;
    digitalWrite(ALARMPIN,alarmState);
  }
}

#include <Ethernet.h>
#include <SPI.h>
#include "DHTSensor.h"

// Network config
byte mac[] =     { 0xAA, 0x00, 0x00, 0xE1, 0x00, 0x72};
byte ip[]  =     {192, 168, 100, 72};
byte gateway[] = {192, 168, 100, 254};
byte subnet[]  = {255, 255, 255, 0};

// Device config
#define DEVID "F2"
#define SENSORNAME "Upstairs"

// Other globals
#define VERSION "1.3"
#define TELNETPORT 2323
#define WEBPORT 8080
#define DHTTYPE DHT11
#define DHTPIN 2
#define textBuffSize 20 //length of longest command string plus two spaces for CR + LF
String rcvdCmd = "";
int charsReceived = 0;
boolean connectFlag = 0;
unsigned long timeOfLastActivity; //time in milliseconds of last activity
unsigned long allowedConnectTime = 300000; //five minutes
EthernetServer telnetServer(TELNETPORT);
EthernetClient telnetClient = 0;
EthernetServer webServer(WEBPORT);
EthernetClient webClient = 0;
DHT dht(DHTPIN, DHTTYPE);
float humid;
float tempf;

// State Variables
char* commandText = "";
char* devId = DEVID;
char* sensorName = SENSORNAME;
                   
void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet);
  Serial.begin(9600);
  telnetServer.begin();
  webServer.begin();
  Serial.println("Remote Environment Monitor");
  Serial.print("Version ");
  Serial.println(VERSION);
  Serial.println();
  Serial.print("Telnet service listening on port ");
  Serial.println(TELNETPORT);
  Serial.print("Web service listening on port ");
  Serial.println(WEBPORT);
  Serial.println();
  dht.begin();
}

void loop()
{
  if (telnetServer.available() && !connectFlag) {
    connectFlag = 1;
    telnetClient = telnetServer.available();
    telnetClient.println("\nRemote Environment Monitor");
    telnetClient.print("Device: ");
    telnetClient.print(devId);
    telnetClient.print("  Sensor: ");
    telnetClient.println(sensorName);
    telnetClient.println();
    showPrompt();
  }
  
  if (telnetClient.connected() && telnetClient.available()) getReceivedText();

  if(connectFlag) checkConnectionTimeout();
  
  webClient = webServer.available();
  
  if (webClient) {
    sendWebPage();
  }
}

void showPrompt()
{
  timeOfLastActivity = millis();
  telnetClient.flush();
  charsReceived = 0;
  telnetClient.println();
  telnetClient.print(devId);
  telnetClient.print("> ");
}

void checkConnectionTimeout()
{
  if(millis() - timeOfLastActivity > allowedConnectTime) {
    telnetClient.println();
    telnetClient.println("\n*** SESSION TIMED OUT ***\n");
    telnetClient.stop();
    connectFlag = 0;
  }
}

void getReceivedText()
{
  char c;
  int charsWaiting;

  charsWaiting = telnetClient.available();
  do {
    c = telnetClient.read();
    if(c != 0x0d) {
      rcvdCmd += c;
      charsReceived++;
      charsWaiting--;
    }
  }
  while(charsReceived <= textBuffSize && c != 0x0d && charsWaiting > 0);
  
  if(c == 0x0d) {
    parseReceivedText();
    showPrompt();
  }
  
  if(charsReceived >= textBuffSize) {
    telnetClient.println();
    showErrorMessage();
    showPrompt();
  }
}  

void parseReceivedText()
{
  if (rcvdCmd == "help") {
    showHelpMessage();
  } else if (rcvdCmd == "show version") {
    telnetClient.print("\nVersion ");
    telnetClient.println(VERSION);
    telnetClient.println();
  } else if (rcvdCmd == "quit") {
    closeConnection();
  } else if (rcvdCmd == "show reading") {
    showReading();
  } else if (rcvdCmd == "reset") {
    telnetClient.println("\n--- Reset in 5 Seconds");
    closeConnection();
    delay(5000);
    softwareReset();
  } else {
    showErrorMessage();
  }
  rcvdCmd = "";
}

void showErrorMessage()
{
  telnetClient.println(">>> Unrecognized Command");
}

void closeConnection()
{
  telnetClient.println("\n*** DISCONNECT ***\n");
  telnetClient.stop();
  connectFlag = 0;
}

void showHelpMessage()
{
  telnetClient.println("\nSupported commands:\n");
  telnetClient.println("  reset          Restart the firmware");
  telnetClient.println("  show reading   Show current temperature/humidity");
  telnetClient.println("  show version   Show version number");
  telnetClient.println("  help           Print this help message");
  telnetClient.println("  quit           Exit telnet session");
  telnetClient.println();
}

void showReading() {
  humid = dht.readHumidity();
  tempf = dht.readTemperature(1);
  telnetClient.println("\nCurrent Reading");
  telnetClient.println("================================");
  telnetClient.print("Device ID   : ");
  telnetClient.println(devId);
  telnetClient.print("Sensor Name : ");
  telnetClient.println(sensorName);
  telnetClient.print("Temperature : ");
  telnetClient.println(tempf);
  telnetClient.print("Humidity    : ");
  telnetClient.println(humid);
  telnetClient.println("================================\n");
}

void sendWebPage() {
  humid = dht.readHumidity();
  tempf = dht.readTemperature(1);
  boolean currentLineIsBlank = true;
  while (webClient.connected()) {
    if (webClient.available()) {
      char c = webClient.read();
      if (c == '\n' && currentLineIsBlank) {
        webClient.println("HTTP/1.1 200 OK");
        webClient.println("Content-Type: text/html");
        webClient.println();
        webClient.print("Device:");
        webClient.print(devId);
        webClient.print(",SensorName:");
        webClient.print(sensorName);
        webClient.print(",Temperature:");
        webClient.print(tempf);
        webClient.print(",Humidity:");
        webClient.println(humid);
        break;
      }
      if (c == '\n') {
        currentLineIsBlank = true;
      }
      else if (c != '\r') {
        currentLineIsBlank = false;
      }
    }
  }
  delay(1);
  webClient.stop();
}

void softwareReset() // Restarts program from beginning but does not reset the peripherals and registers
{
  asm volatile ("  jmp 0");  
}  

/*

  Environment Monitor
  Build for Garage - 1 DHT11 Sensor
  2014-01-23

*/

#include <stdarg.h>
#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>
#include "DHTSensor.h"
#include <ICMPPing.h>

// Fixed Definitions
#define VERSION "1.2-Garage"
#define DEVID "F3"
#define SENSORNAME "Outdoors"
#define CMDQ "net-command"
#define DHTTYPE DHT11
#define DHTPIN 2

// Network config
byte mac[]= {0xAA, 0x00, 0x00, 0xE1, 0x00, 0x73};
byte ip[]= {192, 168, 100, 73};
byte gateway[]= {192, 168, 100, 254};
byte subnet[]= {255, 255, 255, 0};
byte mqtt_broker[]= {192, 168, 100, 150};

// Function declarations
String splitString(String s, char parser,int index);
void callback(char* topic, byte* payload, unsigned int length);

// Instances
EthernetClient ethClient;
PubSubClient client(mqtt_broker, 1883, callback, ethClient);
DHT dht(DHTPIN, DHTTYPE);

// sockets
SOCKET pingSocket = 3;

// State Variables
char* commandText = "";
char* deviceId = DEVID;
char* cmdTopic = CMDQ;
char* sensorName = SENSORNAME;
char* sensorTemp = "";
char* sensorRh = "";
int sampleDelay = 30000;
long lastSampleTime = 0;
char pingBuffer[256];
int pingDelay = 10000;
long lastPingTime = 0;
int netUp = 1;

// printf work-around
char* p(char *fmt, ... ){
  char tmp[128]; // resulting string limited to 128 chars
  va_list args;
  va_start (args, fmt );
  vsnprintf(tmp, 128, fmt, args);
  va_end (args);
  return tmp;
}

void softwareReset() // Restarts program from beginning but does not reset the peripherals and registers
{
  asm volatile ("  jmp 0");  
}

void clientConnect() {
  if (client.connect(deviceId)) {
    commandText = p("Status:%s:Connected",deviceId);
    client.publish(cmdTopic,commandText);
    Serial.println(commandText);
    commandText = p("Status:%s:%i.%i.%i.%i",deviceId,ip[0],ip[1],ip[2],ip[3]);
    client.publish(cmdTopic,commandText);
    Serial.println(commandText);
    client.subscribe(cmdTopic);
    commandText = p("Status:%s:Subscribed to %s",deviceId,cmdTopic);
    Serial.println(commandText);
  } else {
    Serial.println("Connection failed to MQTT");
    netUp = 0;  // Set network down - loop will retry connect
  }
}

// Program setup
void setup() {
  delay(200);
  Ethernet.begin(mac,ip,gateway,subnet);
  delay(200);
  
  dht.begin();
  
  Serial.begin(9600);
  
  Serial.println();
  Serial.println("Environment Monitor");
  Serial.println(VERSION);
  Serial.println();
  
  clientConnect();
  
  Serial.println();
}

char* deblank(char* input)                                         
{
    char *output=input;
    int k,j;
    for (k = 0, j = 0; i<strlen(input); k++,j++)          
    {
        if (input[k]!=' ')                           
            output[j]=input[k];                     
        else
            j--;                                     
    }
    output[j]=0;
    return output;
}

// splitString function
String splitString(String s, char parser,int index){
  String rs='\0';
  int parserIndex = index;
  int parserCnt=0;
  int rFromIndex=0, rToIndex=-1;

  while(index>=parserCnt){
    rFromIndex = rToIndex+1;
    rToIndex = s.indexOf(parser,rFromIndex);

    if(index == parserCnt){
      if(rToIndex == 0 || rToIndex == -1){
        return '\0';
      }
      return s.substring(rFromIndex,rToIndex);
    }
    else{
      parserCnt++;
    }
  }
  return rs;
}

void sendHumidity1() {
  float hum = dht.readHumidity();
  char hum_c[5] = "";
    
  dtostrf(hum,5, 1, hum_c);
  sensorRh = hum_c;
    
  commandText = p("Status:%s:RH=%s",deviceId,deblank(hum_c));
  client.publish(cmdTopic,commandText);
  Serial.println(commandText);
}

void sendTemperature1() {
  float tempf = dht.readTemperature(1);
  char tempf_c[5] = "";
    
  dtostrf(tempf,5, 1, tempf_c);
  sensorTemp = tempf_c;
    
  commandText = p("Status:%s:Temp=%s",deviceId,deblank(tempf_c));
  client.publish(cmdTopic,commandText);
  Serial.println(commandText);
}

// Callback function
void callback(char* topic, byte* payload, unsigned int length) {
  //convert byte to char
  payload[length] = '\0';
  String strPayload = String((char*)payload);
  String strPayloadOrig = strPayload;
  strPayload += ":"; // splitString has issues...
  String receiveId = splitString(strPayload,':',0);
  String receiveCmd = splitString(strPayload,':',1);
  String receiveChn = splitString(strPayload,':',2);
  
  if (strPayloadOrig != commandText) {
    if (receiveId == deviceId) {
      if (receiveCmd == "REQ") {
          commandText = p("Status:%s:OK",deviceId);
          client.publish(cmdTopic,commandText);
          Serial.println(commandText);
      }
      if (receiveCmd == "RST") {
        commandText = p("Status:%s:Reset in 5 seconds",deviceId);
        client.publish(cmdTopic,commandText);
        Serial.println(commandText);
        delay(5000);
        softwareReset();
      }
      if (receiveCmd == "VER") {
        commandText = p("Status:%s:%s",deviceId,VERSION);
        client.publish(cmdTopic,commandText);
        Serial.println(commandText);
      }
    }
  }
}

void loop() {
  
  client.loop();
  
  if ((millis() - lastPingTime) > pingDelay) {
    if ( netUp == 0 ) {
      delay(5000);
      clientConnect(); // Wait 5 seconds, and re-init client
    }
    ICMPPing ping(pingSocket);
    if (ping(4, mqtt_broker, pingBuffer)) {
      netUp = 1;
    } else {
      Serial.println("NetFail");
      netUp = 0;
    }
    lastPingTime = millis();
  }

  if ((millis() - lastSampleTime) > sampleDelay) {
    if ( netUp == 1 ) {
      commandText = p("Status:%s:Name=%s",deviceId,sensorName);
      client.publish(cmdTopic,commandText);
      Serial.println(commandText);
      sendTemperature1();
      sendHumidity1();
      lastSampleTime = millis();
    }
  }
}