/*
 
 
 **changes - LED pin from 12 to 9 (avoid conflict with ethernet shiedl)
 **turn off LED to avoid burnout 
 **update frequency to 60 instead of 20 and int to long as maybew overflows to a negative?
 **turn it back to int/20 - probelms!
 ** used pulldown resistor to hopfully stop internittent crazy values
 ** changes int and longs to unsignedlong
 **change 20 * 1000 to 30000 (maths causes odd results)
 
 **v3 
 ** add elster code
 ** remove delay
 **remove all strings, leave it working in a roundabout kind of way...
 
 **v4 - v3 hangs after ~30 minutes
 **move url and buf to main space 
 
 
 Arduino GroveStreams Stream Feed via Ethernet
 
 The GroveStreams client sketch is designed for the Arduino and Ethernet.
 A full "how to" guide for this sketh can be found at https://www.grovestreams.com/developers/getting_started_arduino_temp.html
 This sketch updates several stream feeds with an analog input reading,
 from a temperature probe, via the GroveStreams API: https://www.grovestreams.com/developers/apibatchfeed.html#apu1a
 The Arduino uses DHCP and DNS for a simpler network setup.
 The sketch also includes Internet Connection Reset logic to ensure the
 Arduino stays connected and can regain connectivity after a network outage.
 Use the Serial Monitor on the Arduino IDE to see verbose network feedback
 and the GroveStreams connectivity status.
 
 GroveStreams Setup:
 
 * Sign Up for Free User Account - https://www.grovestreams.com
 * Create a GroveStreams organization and select the Arduino blueprint
 * Enter a unique MAC Address for this network in this sketch under "Local Network Settings"
 *    (Newer shields have the mac address on a sticker on the shield. Use that.)
 *    (A MAC address can also be generated within a GroveStreams organization: Tools toolbar button - Generate MAC Address)
 *    (The MAC address is used to identify this device within GroveStreams. It must be unique within your GS organization)
 * Enter the GroveStreams api key under "GroveStreams Settings" in this sketch  
 *    (The api key can be retrieved from a GroveStreams organization: click the Api Keys toolbar button,
 *     select your Api Key, and click View Secret Key. Paste the Secret Key below)
 
 Arduino Requirements:
 
 * Arduino with Ethernet Shield or Arduino Ethernet
 * Arduino 1.0 IDE
 
 Network Requirements:
 
 * Ethernet port on Router    
 * DHCP enabled on Router
 * Unique MAC Address for Arduino
 
 Additional Credits:
 Example sketches from Arduino team, Ethernet by David A. Mellis
 Sketch review and advice from Arduino enthusiast and expert David Thompson, http://www.desert-home.com/
 */
 
#include <SPI.h>
#include <Ethernet.h>
#include <elster.h>

ElsterA100C meter(meter_reading);
 
// Local Network Settings
byte mac[] = {
  0x90, 0xA2, 0xDA, 0x0E, 0x60, 0xA4 };  // Change this!!! Must be unique on local network.
                                         // Look for a sticker on the back of your Ethernet shield.
  char url[190] ;
  char buf [10];
// GroveStreams Settings
 
const char gsApiKey[] = "your aip key here";   //Change This!!!
const char gsComponentName[] = "Temperature";        //Optionally change. Set this to give your component a name when it initially registers.
 
//const char gsDomain[] = "grovestreams.com";   //Don't change. The GroveStreams domain.
//const char gsComponentTemplateId[] = "meter";  //Don't change. Tells GS what template to use when the feed initially arrives and a new component needs to be created.
 
 
//GroveStreams Stream IDs. Stream IDs tell GroveStreams which component streams the values will be assigned to.
//Don't change these unless you edit your GroveStreams component definition and change the stream ID to match this.
const char gsStreamId1[] = "g1";   //Don't change. Temp C - Random Stream.
const char gsStreamId2[] = "c1";   //Don't change. Temp F - Random Stream. Don't change.
 
const unsigned long updateFrequency = 300000; // GroveStreams update frequency in milliseconds (the GS blueprint is expecting 20s)
                                       // You will need to change your GroveStreams interval stream base cycles to match the new value if you change updateFrequency.
const int temperaturePin = 0;          // You might need to change depending on the Pin you are using. The Temperature pin number.    
 
// Variable Setup
//String myIPAddress;  //Don't Change. Set below from DHCP. Needed by GroveStreams to verify that a device is not uploading more than once every 10s.
//char myMac[20];        //Don't Change. Set below from the above mac variable. The readable Mac is used by GS to determine which component the
                     // feeds are uploading into. It must match an existing GroveStreams component's ID
 
unsigned long lastSuccessfulUploadTime = 0;    //Don't change. Used to determine if samples need to be uploaded.
boolean lastConnected = false;        //Don't change. Used for Internet Connection Reset logic
int failedCounter = 0;                //Don't change. Used for Internet Connection Reset logic
 
// Initialize Arduino Ethernet Client
EthernetClient client;
 
 
 //for pulse counter
volatile unsigned long counter = 0;
volatile unsigned long lastImpulse = 0;
volatile unsigned long diffImpulse = 0;
volatile unsigned long currentWatt = 1;  //start at 1 just to check data is being recieved by open.sen.se
volatile unsigned long PVReading = 1;  //start at 1 just to check data is being recieved by open.sen.se
 
unsigned long timeRef;
 
int val = 0;
char buffer[30];
int ledPin = 9;
int ledState = LOW;             // ledState used to set the LED
 
 
void setup()
{
  // Start Serial for debugging on the Serial Monitor
  Serial.begin(9600);
   pinMode(ledPin, OUTPUT);  
  attachInterrupt(1, blink, FALLING);
  // Start Ethernet on Arduino
    meter.init(0); //interrupt 0,pin D2
  startEthernet();
}
 
void loop()
{
 
  // Print Update Response to Serial Monitor
  if (client.available())
  {
    char c = client.read();
    Serial.print(c);
  }
 
  // Disconnect from GroveStreams
  if (!client.connected() && lastConnected)
  {
    Serial.println(F("...disconnected"));
    Serial.println();
 
    client.stop();
  }
 //Serial.println((millis() - lastSuccessfulUploadTime > updateFrequency));
 
 //Serial.println(millis() );
 //Serial.println(lastSuccessfulUploadTime );
 //Serial.println( updateFrequency);
 
  // Update sensor data to GroveStreams
  if(!client.connected() && (millis() - lastSuccessfulUploadTime > updateFrequency))
  {
 
    Serial.println(F("Trying upload:"));
    //char temps[] = getTemperatures();
    //Serial.println(temps);
 
    updateGroveStreams();
  }
 
  // Check if Arduino Ethernet needs to be restarted
  if (failedCounter > 3 ) {
 
    //Too many failures. Restart Ethernet.
    startEthernet();
  }
 
  lastConnected = client.connected();
 
    // Decode the meter stream
  const int byte_data = meter.decode_bit_stream();
  if (byte_data != -1) {
    meter.on_data(byte_data);
  }
  //delay(1000);
 
}
 
void updateGroveStreams()
{
  unsigned long connectAttemptTime = millis();
 
  if (client.connect("grovestreams.com", 80))
  {        
 
    //Assemble the url used to pass the temperature readings to GroveStreams.
    // The Arduino String class can be memory intensive. char arrays should be used instead. But,
    // to make this example simple to understand we have chosen to use the String class.
    //We are passing temperature readings into two types of GroveStreams streams, Random and Interval streams.
 
   // url[] = "PUT /api/feed?compTmplId=meter&compId=90:a2:da:0e:60:a4";
 
    strcpy(url, "PUT /api/feed?compTmplId=meter&compId=90:a2:da:0e:60:a4");
  //    strcat(url, gsComponentTemplateId);
  //   Serial.println(url);
 
     // strcat(url,"&compId=";
    //  strcat(url, myMac);
strcat(url,"&compName=");
strcat(url, gsComponentName);
strcat(url, "&api_key=");
strcat(url, gsApiKey);
  strcat(url,"&");
 strcat(url,gsStreamId1);
strcat(url,"=");
//strcat(url,String(0,DEC)); 
 
 
sprintf (buf, "%lu", PVReading);
 
strcat(url, buf);  //Temp F - Random Stream
 
//strcat(url,"0"; 
strcat(url,"&");
strcat(url,gsStreamId2);
strcat(url,"=");
//strcat(url, String(currentWatt,DEC));  //Temp F - Random Stream
 
 
sprintf (buf, "%u", currentWatt);
 
strcat(url, buf);  //Temp F - Random Stream
 
 
 
strcat(url, " HTTP/1.1");
 
 Serial.println(url);
 
     currentWatt=0; //reset to zero
  digitalWrite(ledPin, LOW);   //turn off LED to avoid burnout
 
 
    client.println(url);  //Send the url with temp readings in one println(..) to decrease the chance of dropped packets
    client.println("Host: grovestreams.com" );
    client.println(F("Connection: close"));
    //client.println("X-Forwarded-For: "+ myIPAddress); //Include this line if you have more than one device uploading behind
                                                      // your outward facing router (avoids the GS 10 second upload rule)
    client.println(F("Content-Type: application/json"));
    client.println();
 
    if (client.available())
    {
      //Read the response and display in the the console
      char c = client.read();
      Serial.print(c);
    }
 
    if (client.connected())
    {
      lastSuccessfulUploadTime = connectAttemptTime;
      failedCounter = 0;
    }
    else
    {
      //Connection failed. Increase failed counter
      failedCounter++;
 
      Serial.println("Connection to GroveStreams failed ("+String(failedCounter, DEC)+"");  
      Serial.println();
    }
 
  }
  else
  {
     //Connection failed. Increase failed counter
    failedCounter++;
 
    Serial.println("Connection to GroveStreams Failed ("+String(failedCounter, DEC)+"");  
    Serial.println();
  }
}
 
void startEthernet()
{
  //Start or restart the Ethernet connection.
  client.stop();
 
  Serial.println(F("Connecting Arduino to network..."));
  Serial.println();  
 
  //Wait for the connection to finish stopping
  delay(2000);
 
  //Connect to the network and obtain an IP address using DHCP
  if (Ethernet.begin(mac) == 0)
  {
    Serial.println(F("DHCP Failed, reset Arduino to try again"));
    Serial.println();
  }
  else
  {
 
    Serial.println(F("Arduino connected to network using DHCP"));
    Serial.println();
 
    //Set the mac and ip variables so that they can be used during sensor uploads later
 
   // snprintf(myMac, 100, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    //myMac = getMacReadable();
    //Serial.println(strcat("MAC:", myMac);
 
  //  myIPAddress = getIpReadable(Ethernet.localIP());
  //  Serial.println("IP address: " + myIPAddress);
  }
 
}
 
 
//String getIpReadable(IPAddress p)
//{
//  //Convert the ip address to a readable string
//  String ip;
//  for (int i =0; i < 3; i++)
//  {
//    ip += String(p[i], DEC);
//    ip += ".";
//  }
//  ip +=String(p[3], DEC);
//  return ip;
//}
 
char getTemperatures()
{
  //Get the temperature analog reading and convert it to a string
 /* float voltage, degreesC, degreesF;
 
  voltage = (analogRead(temperaturePin) * 0.004882814);
  degreesC = (voltage - 0.5) * 100.0;
  degreesF = degreesC * (9.0/5.0) + 32.0;
 
  char temp[15] = {0}; //Initialize buffer to nulls
  dtostrf(degreesC, 12, 3, temp); //Convert float to string
  String tempC(temp);
  tempC.trim();
 
  char temp2[15] = {0}; //Initialize buffer to nulls
  dtostrf(degreesF, 12, 3, temp2); //Convert float to string
  String tempF(temp2);
  tempF.trim();
 */
 
  //char temps[];
 // strcat(temps,"&"
 // + gsStreamId1 + "=" + String(0,DEC);   //Temp C - Random Stream
 // temps += "&" + gsStreamId2 + "=" + String(currentWatt,DEC);  //Temp F - Random Stream
 
 
 //currentWatt=0; //reset to zero
 // digitalWrite(ledPin, LOW);   //turn off LED to avoid burnout
 
 // return temps;
}
 
void blink() {
  unsigned long currentImpulse = millis();
 
//  Serial.println("Pulse";
 
  if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;
 
    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
 
 
  // Increment counter
  counter++;
 
  // Calculate current Watt usage by measuring the time difference between two impulses
  if (lastImpulse != 0) { // we can now calculcate
    if (currentImpulse > lastImpulse) {
      diffImpulse = currentImpulse - lastImpulse;
      currentWatt = long((3600UL * 1000UL) / diffImpulse);
    } else if (lastImpulse > currentImpulse) { // overflow
      diffImpulse = currentImpulse + (4294967295UL - lastImpulse);
      currentWatt = long((3600UL * 1000UL) / diffImpulse);
    } else {
      // We should never get here UNLESS THEY ARE THE SAME millisecond
      diffImpulse = 0;
 
    }
  }
 
  lastImpulse = currentImpulse;
 
}
 
void meter_reading(unsigned long r)
{
  Serial.print(r);
  Serial.print("rn");
 
  PVReading = r;
 
 
 
 
}