#if !defined(__AVR_ATmega328P__)
#error "This sketch is designed for an Arduino Uno or Duemilenova.  You are using a different processor.  You can try removing this #error, but YMMV"
#endif

// Code by Paul MacDougal for triembed.org members
// This code is released into the public domain for any and all uses
// We expect a normally low signal on pin SW
// We will count the number of rising edges (not debounced in any way in software)
// and report that every once in a while.
#include <avr/sleep.h>    // Sleep Modes
#include <avr/power.h>    // Power management
#include <avr/wdt.h>      // Watchdog timer
#include <PinChangeInt.h> // Pin Change Interrupt

//unsigned char WARstupidArduinoIssue;  // tell the Arduino IDE that this is the beginning of code so that #if works below

// Ideally, this is just the duration you want to sleep divided by 8s, but you might need to tune it per processor at temperature and voltage
// must fit in a short (65k), so you need to sleep for less than 6.1 days or change change some variables from 'short' to 'long'
#define ONE_HOUR 450 
#define EIGHT_MINUTES 60
#define ONE_MINUTE 7
#define DURATION ONE_HOUR // Set the reporting duration here

// If you are using an Ethernet Shield, you can report to a Sparkfun public data stream https://data.sparkfun.com/streams/AJgVGKqLN5hjGAgLEAAV
#define USE_ETHERNET 1
#if USE_ETHERNET
#include <SPI.h>
#include <Ethernet.h>
#define PUBLICKEY "AJgVGKqLN5hjGAgLEAAV"
#define PRIVATEKEY "ask Paul for the key"
#define HOST "follow the instructions in the comment" // change this to your initials and some trailing digits, e.g. pdm003
#endif

#if USE_ETHERNET
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // physical mac address  You can pick one :-)
const byte LED = 3, SW = 2; // The ethernet shield uses pin 13, so you will need to put an LED w/ resistor to ground on pin LED
#else
const byte LED = 13, SW = 2;
#endif

// We use a trick to toggle the LED.  The datasheet says "Writing a logic one to PINxn toggles the value of PORTxn"
uint8_t bitn; // This is a byte with PINxn set
volatile uint8_t *pinx; // This is a non-volatile pointer to a volatile PINx register

//################# Interrupt Service Routines ######################
volatile unsigned long switchRising = 0; // this is a count of SW rising edges (not debounced in SW)
void handleSW() { // ISR
    // We don't care if we were asleep or awake when the pin went high
    switchRising++;
}

// Count of watchdog timer interrupts
volatile unsigned short eightSecondPeriods = 0;
ISR(WDT_vect)
{
    eightSecondPeriods++;
    *pinx = bitn; // toggle the LED
}
//#####################################################################

// This routine puts the processor to sleep and handles waking up activities
void sleepNow()
{
    set_sleep_mode(SLEEP_MODE_PWR_DOWN); // this is the lowest level of sleep
    // you may be able to further reduce power consumption while asleep by turning off BrownOut Detection, A/D circuits, ...
    noInterrupts();          // make sure we don't get interrupted before we sleep
    sleep_enable();          // enables the sleep bit in the MCUCR register
    PCintPort::attachInterrupt(SW, handleSW, HIGH);  // wake up on high level
    interrupts();           // interrupts allowed now, next instruction WILL be executed
    sleep_cpu();            // here the device is put to sleep
    // ...
    // we wake up here
    sleep_disable();         // first thing after waking from sleep
    PCintPort::attachInterrupt(SW, handleSW, RISING);
}

const uint8_t v1 = (1<<WDCE)  // set the Watchdog Change Enable bit (HW will clear this bit in 4 cycles)
                 | (1<< WDE)  // you have to set WDE in order to clear it in the next instruction
                 | (1<<WDIF); // clear the Watchdog Interrupt Flag by writing '1' to the bit

const uint8_t v2 = (0<< WDE)  // clear the Watchdog Reset Enable (we don't want to reset the chip when the watchdog expires)
                 | (1<<WDIE)  // set Watchdog Interrupt Enable
                 |   WDTO_8S&0x7
                 | ((WDTO_8S&0x8)<<2);

void wdt_setup()
{
    wdt_reset(); // make sure the wdt does not expire while we are configuring it

    MCUSR = 0; // specifically, clear the WDRF bit
    // These next two writes have to happen within 4 cycles
    WDTCSR = v1;
    WDTCSR = v2;
}

void setup() {
    // disable the watchdog
    wdt_disable();

    // configure the pins
    pinMode(LED, OUTPUT);
    pinMode(SW, INPUT); // expect this to be normally low, so no pullup

    // blink four times at reset
    for (uint8_t i=0; i<4; i++)
    {
      digitalWrite(LED, HIGH);
      delay(250);
      digitalWrite(LED, LOW);
      delay(250);
    }

    // Start up the serial port
    Serial.begin(9600);
    while (!Serial); // for Leonardo
    Serial.println(F("Initialized LongSleep"));

    // look up the bit and port for the LED pin
    bitn = digitalPinToBitMask(LED);
    pinx = portInputRegister(digitalPinToPort(LED));

    // On rising edge of SW pin, call handleSW
    PCintPort::attachInterrupt(SW, handleSW, RISING);

    // Set up the watchdog timer to interrupt every 8 seconds
    // The WDT is not turned off during reporting, so we don't have to subtract reporting time from our DURATION
    wdt_setup();
}

unsigned short sleepCycles = 0; // this is a count of how many times we went to sleep.  We get awakened by WDT and SW interrupts
void handleSleep(unsigned short periodsToSleep)
{
    unsigned short myEightSecondPeriods = 0;
    sleepCycles = 0;

    // Spend an hour in this loop
    while (myEightSecondPeriods < periodsToSleep) {
        Serial.print(F("Going to sleep now ... "));
        Serial.flush();
        sleepNow(); // sleep for 8 seconds or until external interrupt wakes us
        Serial.print(F(" awake switchRising "));

        // Critical section for transferring switch count from ISR
        noInterrupts();
        unsigned long mySwitchRising = switchRising;
        myEightSecondPeriods = eightSecondPeriods;
        interrupts();

        Serial.print(mySwitchRising);
        Serial.print(" elapsed cycles ");
        Serial.print(myEightSecondPeriods);
        Serial.print(" of ");
        Serial.println(periodsToSleep);

        sleepCycles++; // this counts WDT and PIN interrupts.  Don't use it to compute time delta
    }
}

void handleReporting()
{
    // Critical section for transferring switch count from ISR and resetting it to zero
    noInterrupts();
    unsigned long mySwitchRising = switchRising;
    switchRising = 0;
    eightSecondPeriods = 0;
    interrupts();

    // Power up the "network" and report our status
    Serial.print(F("Time to report our status.  We had "));
    Serial.print(mySwitchRising);
    Serial.print(" switch toggles during ");
    Serial.print(sleepCycles);
    Serial.println(" sleep cycles");

#if USE_ETHERNET
    //start Ethernet
    if (Ethernet.begin(mac /*, ip, gateway, subnet*/))
    {
        EthernetClient client;
        char server[] = "data.sparkfun.com";

        if (client.connect(server, 80)) {
            Serial.println("connected");
            // Make a HTTP request:
            client.print("GET /input/");
            client.print(PUBLICKEY);
            client.print("?private_key=");
            client.print(PRIVATEKEY);
            client.print("&count=");
            client.print(mySwitchRising);
            client.print("&host=");
            client.print(HOST);
            client.println(" HTTP/1.1");
            client.println("Host: data.sparkfun.com");
            client.println("Connection: close");
            client.println();

            while (client.connected())
            {
                if ( client.available() )
                {
                    char c = client.read();
                    Serial.print(c);
                }
            }
            Serial.println();
            client.stop();
        } else {
            Serial.println("client.connect() failed");
        }

        // there is no member function like Ethernet.end()

    } else {
        Serial.println("Ethernet.begin() failed");
    }
#endif
}

void loop() {
    handleSleep(DURATION);
    handleReporting();
}