#include <SPI.h>
#include <AIR430BoostETSI.h>

//define addresses. 
#define ADDRESS_LOCAL    0x02
#define ADDRESS_REMOTE   0x03

//FSM states. And commands
enum {
  IDLE=0x01, ACTIVE, ALERT};

unsigned char txData[60] = { 
  "\0" };

const int setButton = PUSH1; //set to active mode
const int releaseButton = PUSH2;//set to idle mode
const int ledPin =  GREEN_LED; 
const int redPin = RED_LED;

void setup() {
  //define pinouts and add serial outputr
  pinMode(ledPin, OUTPUT);      
  pinMode(redPin, OUTPUT);
  Serial.begin(9600);

  pinMode(setButton, INPUT_PULLUP);     
  pinMode(releaseButton, INPUT_PULLUP);  
  Radio.begin(ADDRESS_LOCAL, CHANNEL_1, POWER_MAX);
  Serial.println("RF start");
  txData[0] = ADDRESS_LOCAL;//set zer0 byte as our address
}

void loop(){
  //check set button
  if (digitalRead(setButton) == LOW){
    //if button is pressed, send command
    Serial.println("Active mode");
    digitalWrite(redPin, HIGH);
    txData[1] = ACTIVE;//Set command
    txData[2] = 0x00;
    Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2);
  }
  else{
    digitalWrite(redPin, LOW);
  }
  //check release button
  if (digitalRead(releaseButton) == LOW){
    Serial.println("IDLE mode");
    digitalWrite(ledPin, HIGH);
    txData[1] = IDLE;//Set command
    txData[2] = 0x00;
    //send packet
    Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2);
  }
  else{
    digitalWrite(ledPin, LOW);
  }
  sleepSeconds(1);//Low-power mode delay
  delay(50);//to Clock stabilization
}

#include <SPI.h>
#include <AIR430BoostETSI.h>

#define ADDRESS_LOCAL    0x03
#define ADDRESS_REMOTE   0x01

unsigned char rxData[60] = {
  "\0" };
  
unsigned char txData[60] = {  
  "\0" };
/*
Finite state machine:
1. IDLE mode
2. Action Mode
3. Alert mode
1 -> 2 Received command 0x01
2 -> 1 received command 0x02
2 -> 3 sensor triggered. Send alert
*/
enum {IDLE=0x01, ACTIVE, ALERT};
unsigned int fsm = IDLE;

static unsigned char sensor = 11;
static unsigned char releopen = 9;
static unsigned char releclose = 10;
static unsigned char releopenled = BLUE_LED;
static unsigned char relecloseled = GREEN_LED;

// -----------------------------------------------------------------------------
// Main example

void setup()
{
  pinMode(sensor, INPUT_PULLUP);
  pinMode(releopen, OUTPUT);
  digitalWrite(releopen, HIGH);
  pinMode(releopenled, OUTPUT);
  pinMode(relecloseled, OUTPUT);
  pinMode(releclose, OUTPUT);
  digitalWrite(releclose, HIGH);
  pinMode(12, OUTPUT);
  pinMode(12, LOW); //return pin for sensor
 
  Radio.begin(ADDRESS_LOCAL, CHANNEL_1, POWER_MAX);

   // Setup serial for debug printing.
  Serial.begin(9600);
  
  txData[0] = ADDRESS_LOCAL;//set zer byte as our address
}
uint8_t length = 0;

void loop()
{
  
  switch (fsm){
    case IDLE:
      length = Radio.receiverOn(rxData, sizeof(rxData), 1000);
      if (length > 0){
        if (rxData[1] == ACTIVE){
          //change state stage
          fsm = ACTIVE;
          txData[1] = ACTIVE;//Set command
          txData[2] = 0x00;
          Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2); 
          //send 500ms inpuls to actuator
          digitalWrite(releclose, LOW);
          digitalWrite(relecloseled, HIGH);
          delay(500);
          digitalWrite(releclose, HIGH);
          digitalWrite(relecloseled, LOW);
        }
        else{
          fsm = IDLE;
        }
      }
      else{
      }
    break;
    
    case ACTIVE:
      length = Radio.receiverOn(rxData, sizeof(rxData), 100);
      if (length > 0){
        if (rxData[1] == IDLE){
          //change state stage
          fsm = IDLE;
          txData[1] = IDLE;//Set command
          txData[2] = 0x00;
          Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2); 
          //send 500ms inpuls to actuator
          digitalWrite(releopen, LOW);
          digitalWrite(releopenled, HIGH);
          delay(500);
          digitalWrite(releopen, HIGH);
          digitalWrite(releopenled, LOW);
        }
        else{
          fsm = ACTIVE;
        }
      }
      else{
      }
         checkperimeter();   
    break;
    
    case ALERT:
      length = Radio.receiverOn(rxData, sizeof(rxData), 1000);
      if (length > 0){
        if (rxData[1] == IDLE){
          //change state stage
          fsm = IDLE;
          txData[1] = IDLE;//Set command
          txData[2] = 0x00;
          Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2); 
          //send 500ms inpuls to actuator
          digitalWrite(releopen, LOW);
          digitalWrite(releopenled, HIGH);
          delay(500);
          digitalWrite(releopen, HIGH);
          digitalWrite(releopenled, LOW);
        }
        else{
          fsm = ALERT;
        }
      }
      else{
      }   
    break;
    
    default:
    break;
  }

}

void checkperimeter(){
    uint8_t sensorstate = digitalRead(sensor);
    if (sensorstate == LOW){
      Serial.println("Alert!");
          //alert!!
        fsm = ALERT;
        txData[1] = ALERT;//Set command
        txData[2] = 0x00;
        Radio.transmit(ADDRESS_REMOTE, (unsigned char*)&txData, 2);     
    }
}

#include <SPI.h>
#include <AIR430BoostETSI.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <Temboo.h>
#include "TembooAccount.h" // Contains Temboo account information

WiFiClient client;

#define ADDRESS_LOCAL    0x01

unsigned char rxData[60] = {
  "\0" };

unsigned char txData[60] = {  
  "\0" };
/*
Finite state machine:
 1. IDLE mode
 2. Action Mode
 3. Alert mode
 1 -> 2 Received command 0x01
 2 -> 1 received command 0x02
 2 -> 3 sensor triggered. Send alert
 */
enum {
  IDLE=0x01, ACTIVE, ALERT};
unsigned int fsm = IDLE;

// -----------------------------------------------------------------------------
// Main example

void setup()
{
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  digitalWrite(YELLOW_LED, LOW);
  digitalWrite(RED_LED, LOW);
  digitalWrite(GREEN_LED, LOW);

  Radio.begin(ADDRESS_LOCAL, CHANNEL_1, POWER_MAX);

  // Setup serial for debug printing.
  txData[0] = ADDRESS_LOCAL;//set zer byte as our address

  Serial.begin(9600);

  int wifiStatus = WL_IDLE_STATUS;

  // Determine if the WiFi Shield is present
  Serial.print("\n\nShield:");
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("FAIL");

    // If there's no WiFi shield, stop here
    while(true);
  }

  Serial.println("OK");

  // Try to connect to the local WiFi network
  while(wifiStatus != WL_CONNECTED) {
    Serial.print("WiFi:");
    wifiStatus = WiFi.begin(WIFI_SSID, WPA_PASSWORD);

    if (wifiStatus == WL_CONNECTED) {
      Serial.println("OK");
    } 
    else {
      Serial.println("FAIL");
    }
    delay(5000);
  }
  digitalWrite(YELLOW_LED, HIGH);
  Serial.println("Setup complete.\n");
}
uint8_t length = 0;

void loop()
{
  length = Radio.receiverOn(rxData, sizeof(rxData), 1000);
  if (length > 0){
    Serial.print("Get state: ");
    Serial.println(rxData[1], DEC);

    switch (fsm){
    case IDLE:
      if (rxData[1] == ACTIVE){
        fsm = ACTIVE;
        digitalWrite(GREEN_LED, HIGH);
      }
      break;

    case ACTIVE:
      if (rxData[1] == IDLE){
        fsm = IDLE;
        digitalWrite(GREEN_LED, LOW);
        digitalWrite(RED_LED, LOW);
      }
      if (rxData[1] == ALERT){
        fsm = ALERT;
        digitalWrite(RED_LED, HIGH);
        sendmessage();
      }    
      break;

    case ALERT:
      if (rxData[1] == IDLE){
        fsm = IDLE;
        digitalWrite(GREEN_LED, LOW);
        digitalWrite(RED_LED, LOW);
      }     
      break;
    }
  }
}

void sendmessage(){
  Serial.println("Running SendMessage - Run #" + String(numRuns++));

    TembooChoreo SendMessageChoreo(client);

    // Invoke the Temboo client
    SendMessageChoreo.begin();

    // Set Temboo account credentials
    SendMessageChoreo.setAccountName(TEMBOO_ACCOUNT);
    SendMessageChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
    SendMessageChoreo.setAppKey(TEMBOO_APP_KEY);

    // Set Choreo inputs
    String TextValue = "Testing! Testing! 1, 2, 3";
    SendMessageChoreo.addInput("Text", TextValue);
    String APIKeyValue = "000";
    SendMessageChoreo.addInput("APIKey", APIKeyValue);
    String ToValue = "000";
    SendMessageChoreo.addInput("To", ToValue);
    String APISecretValue = "000";
    SendMessageChoreo.addInput("APISecret", APISecretValue);
    String FromValue = "000";
    SendMessageChoreo.addInput("From", FromValue);

    // Identify the Choreo to run
    SendMessageChoreo.setChoreo("/Library/Nexmo/SMS/SendMessage");

    // Run the Choreo; when results are available, print them to serial
    SendMessageChoreo.run();

    while(SendMessageChoreo.available()) {
      char c = SendMessageChoreo.read();
      Serial.print(c);
    }
    SendMessageChoreo.close();
}