Secure Package Delivery Trunk for Your Front Porch

/******************************************************************************
 * CastleLocker Trunk Controller
 * 
 * Copyright (c) 2018, Vocal Intent, LLC
 *
 * This program and the accompanying materials are made available under the 
 * terms of the Creative Commons Attribution 4.0 International License
 *
 * The Creative Commons Attribution 4.0 International License is available at: 
 *    https://creativecommons.org/licenses/by/4.0/legalcode
 *
 * Contributors:
 *    Chris Meade - initial contribution
 *
 *****************************************************************************/

#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
#include <Keypad.h>
#include <elapsedMillis.h>
#include <Password.h>
#include <EEPROM.h>

// 4 x 4 Keypad Code - NOT USED IN THIS PROJECT, BUT HERE IN CASE YOU USE A 4x4 format (this affects other pin assignments!)
//const byte ROWS = 4; //four rows
//const byte COLS = 4; //four columns
////define the cymbols on the buttons of the keypads
//char hexaKeys[ROWS][COLS] = {
//  {'1','2','3','A'},
//  {'4','5','6','B'},
//  {'7','8','9','C'},
//  {'*','0','#','D'}
//};
//byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
//byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad

// 3 x 4 Keypad Code
const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {5, 6, 7, 8}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {2, 3, 4}; //connect to the column pinouts of the keypad

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS); 

const int porchMotionPin = 9;     // the number of the PIR Sensor input
const int closeBtnPin = 10;

SoftwareSerial mySoftwareSerial(11, 12); // RX, TX
const int mp3PlayerBusyPin = 13;     // the number of the MP3 Player Busy Pin

//PINS ASSIGNMENTS TO TRANSMIT AND RECEIVE INFORMATION WITH nodeMCU Board
#define PIN_SW_SERIAL_RX 14 
#define PIN_SW_SERIAL_TX 15

SoftwareSerial board2BoardSerial(PIN_SW_SERIAL_RX, PIN_SW_SERIAL_TX); // RX, TX

const int relayLockPin = 16;     // the pin for triggering the Lock Relay to Open

const int speakerPin = 17; //For playing tones when keys are pressed on the keypad

#define CW 18 //CW is relay for open/up
#define CCW 19 //CCW is relay for close/down

DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);

int buttonCWState = 0;  
int buttonCCWState = 0;  
int porchMotionState = 0;
int motionDetected = LOW;

elapsedMillis timeElapsed; //declare global if you don't want it reset every time loop runs
elapsedMillis openCloseElapsed; //tracks time elapsed while opening/closing trunk
elapsedMillis trunkOpenElapsed; //tracks time trunk has been open, to autoclose the trunk

// delay in milliseconds between motion events
unsigned int interval = 20000;
unsigned int openInterval = 2100;
unsigned int closeInterval = 2600;

unsigned int trunkStaysOpenInterval = 25000;

bool autoOpen = false;
bool autoClose = false;
bool trunkOpen = false;

// Create a Password Array to store multiple Passwords
const byte MAXPASSWD = 3;
Password passwordArray[MAXPASSWD] = { Password( "0"), Password( "1234"), Password("4321")};
//"0" will be for doorbell function and must be first in the array

//DEFINE THE IOT COMMUNICATION CONSTANTS IN HUMAN READABLE FORM
//RECEPTION VALUES
#define STATE_TRUNK_UNKNOWN 0
#define STATE_TRUNK_OPEN 1
#define STATE_TRUNK_CLOSED 2
#define STATE_TRUNK_CHANGING 3

#define CMD_IDLE 0
#define CMD_OPEN_TRUNK 1
#define CMD_CLOSE_TRUNK 2
#define CMD_PARTIAL_OPEN 3
#define CMD_PARTIAL_CLOSE 4

#define CMD_ADD_ACCESS_CODE 5
#define CMD_DELETE_ACCESS_CODE 6
#define CMD_ERASE_ACCESS_CODES 7

#define CMD_GET_TRUNK_STATE 8
#define CMD_PLAY_FILE 9
#define CMD_HOMEOWNER_NOT_AVAILABLE 10
#define CMD_DISMISS_DOORBELL 11
#define CMD_UNLOCK_KEYPAD 12

//TRANSMISSION VALUES
#define NOTICE_IDLE 0
#define NOTICE_TRUNK_OPENED 1
#define NOTICE_TRUNK_CLOSED 2
#define NOTICE_DOORBELL_ACTIVATED 3
#define NOTICE_MOTION_ACTIVATED 4
#define NOTICE_INVALID_CODE 5
#define NOTICE_CORRECT_CODE 6
#define NOTICE_KEYPAD_LOCKED 7
#define NOTICE_CONTROLLER_ERROR 8
#define NOTICE_CONTROLLER_RESTARTED 9
#define NOTICE_EEPROM_UPDATED 10

String inData = "";

//////////////////////////////////////////
// Set-up procedure to initialize program
//////////////////////////////////////////
void setup() { //Setup initalizes comm ports and i/o pins

  mySoftwareSerial.begin(9600);
  board2BoardSerial.begin(9600);
  Serial.begin(115200);
  
  Serial.println();
  Serial.println(F("DFRobot DFPlayer Mini Demo"));
  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));

  mySoftwareSerial.listen();
  if (!myDFPlayer.begin(mySoftwareSerial)) {  //Use softwareSerial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while(true);
  }
  Serial.println(F("DFPlayer Mini online."));
  
  myDFPlayer.volume(25);  //Set volume value. From 0 to 30

  //Set up pins
  pinMode(CW, OUTPUT);
  pinMode(CCW, OUTPUT);
  pinMode(relayLockPin, OUTPUT);

  pinMode(PIN_SW_SERIAL_TX, OUTPUT);
  pinMode(PIN_SW_SERIAL_RX, INPUT);
  
  digitalWrite(CW, HIGH);
  digitalWrite(CCW, HIGH);
  digitalWrite(relayLockPin, HIGH);
  
  pinMode(speakerPin, OUTPUT);
    
//  pinMode(buttonCWPin, INPUT_PULLUP);
//  pinMode(buttonCCWPin, INPUT_PULLUP);
  
  pinMode(porchMotionPin, INPUT);
  pinMode(mp3PlayerBusyPin, INPUT);

  pinMode(closeBtnPin, INPUT_PULLUP);
  
  customKeypad.addEventListener(keypadEvent); //add an event listener for this keypad

  printEEPROM();
}


//////////////////////////////////////////
// Main Program Loop
//////////////////////////////////////////
void loop() { 

  customKeypad.getKey();

  if (autoOpen)
  {
    digitalWrite(relayLockPin,LOW);
    if (openCloseElapsed < openInterval)
    {
      digitalWrite(CW,LOW); //Motor runs clockwise
      autoClose = false;
    }
    else
    {
      digitalWrite(relayLockPin,HIGH);
      autoOpen = false;
      trunkOpen = true;
      trunkOpenElapsed = 0;
      //Finished Opening - send notice to nodeMCU Board to put IOT shadow into Idle State
      board2BoardSerial.print(NOTICE_IDLE);
    }
  }
  else if (autoClose)
  {
    if (openCloseElapsed < closeInterval)
    {
      digitalWrite(CCW,LOW); //Motor runs counter-clockwise
      autoOpen = false;
    }
    else
    {
      autoClose = false;
      trunkOpen = false;
      myDFPlayer.play(6);
      //Finished Closing - send notice to nodeMCU Board to put IOT shadow into Idle State
      board2BoardSerial.print(NOTICE_IDLE);
    }    
  }

  if (trunkOpen)
  {
    if (trunkOpenElapsed > trunkStaysOpenInterval)
    {
      //time to close trunk
      trunkOpen = false;
      myDFPlayer.play(16); //Play ding sound effect
      delay(2000);
      myDFPlayer.play(5);  //Auto close notice
      delay(5500);
      openCloseElapsed = 0;
      autoClose = true;
    }
  }

  if (digitalRead(closeBtnPin)==LOW) //Red Button Pressed
  {
    closeTrunk();
  }
  
  if ((!autoOpen) && (!autoClose))  // Do not allow manual movements if autoOpen/Close running
  {
      digitalWrite(relayLockPin,HIGH); //Locked, no power to solenoid
      // stop motor both directions
      digitalWrite(CCW, HIGH); //Motor stops
      digitalWrite(CW, HIGH); //Motor stops
  }

  porchMotionState = digitalRead(porchMotionPin);
  if (porchMotionState == HIGH) //PIR senses motion
  {
     if (motionDetected == LOW) //Make sure PIR has been static for at least interval time period before playing welcome msg
     {
      Serial.println("Motion detected");
      resetAllPasswords();
      motionDetected = HIGH;
      board2BoardSerial.print(NOTICE_MOTION_ACTIVATED); //Let nodeMCU Board know there was motion detected
      myDFPlayer.play(16); //Play ding sound effect
      delay(2000);
      myDFPlayer.play(1);  //Play the first mp3
     }
     timeElapsed = 0;
     //Serial.println("Motion continuing");
  }
  else //PIR is not reporting motion
  {
    porchMotionState = LOW; // PIR software state setting to shadow hardware state
    if (timeElapsed > interval) //Do not allow new PIR motion detection to trip welcome message for a defined interval
    { 
      motionDetected = LOW;
      //Serial.println("Motion sensor reset");      
      timeElapsed = 0;  // reset the counter to 0 so the counting starts over...
    }
  }

  if (digitalRead(mp3PlayerBusyPin) == LOW)
  {
    timeElapsed = 0; //Don't allow motion detector to activate while playing a file
  }

// CONFLICT WITH TX/RX, too many software serials - so just comment it out unless debugging mp3 player
//  mySoftwareSerial.listen();
//  if (myDFPlayer.available()) {
//    printDetail(myDFPlayer.readType(), myDFPlayer.read()); //Print the detail message from DFPlayer to handle different errors and states.
//  }

  //PROCESS ANY INBOUND NOTICES/COMMANDS FROM THE nodeMCU Board
  byte incomingByte = 0; 

  board2BoardSerial.listen();
  if (board2BoardSerial.available() > 0) 
  {
    while (board2BoardSerial.available() > 0)
    {
           // read the incoming byte:
           incomingByte = board2BoardSerial.read()-'0';

           // say what you got:
           Serial.print("I received: ");
           Serial.println(incomingByte, DEC);

           //NOTE: the incoming characters from the nodeMCU are being converted into the 200 range, but this works
            if (incomingByte == 208)
            {
                Serial.println(F("Go Idle"));
            }
            else if (incomingByte == 209)
            {
                Serial.println(F("Open Trunk"));
                openTrunk();
            }
            else if (incomingByte == 210)
            {
                Serial.println(F("Close Trunk"));
                closeTrunk();
            }
            else
            {
                Serial.println(F("UNKNOWN CMD"));
            }             
      }
   }

//   //Use this code to manually send a character cmd from this board to the nodeMCU board from a serial window
//   if (Serial.available()) {
//     board2BoardSerial.write(Serial.read());
//   }

}


//////////////////////////////////////////
//Handle key presses on keypad
//////////////////////////////////////////
void keypadEvent(KeypadEvent eKey){
   switch (customKeypad.getState()){
    case PRESSED:
      timeElapsed = 0; 
      Serial.println(eKey);
      switch (eKey){
        case '*': beep(speakerPin,2637,100); checkAllPasswords(); break;  // check guessed pswd against passwordArray
        case '#': beep(speakerPin,2349,100); resetAllPasswords(); break;  // clean all guessed buffers on passwordArray
        default:  beep(speakerPin,2637,100); appendAllPasswords(eKey);     // update all guessed buffers on passwordArray
      }
   }
}


//////////////////////////////////////////
//Tones for the keypad
//////////////////////////////////////////
void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds){ // the sound producing function
  int x;
  long delayAmount = (long)(1000000/frequencyInHertz);
  long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));
  for (x=0;x<loopTime;x++)
    {
      digitalWrite(speakerPin,HIGH);
      delayMicroseconds(delayAmount);
      digitalWrite(speakerPin,LOW);
      delayMicroseconds(delayAmount);
    }
}


//////////////////////////////////////////
//Verify if code entered matches valid passwords array
//////////////////////////////////////////
void checkAllPasswords(){
  int i;
  int passcodeMatchedflag = 0;
  
  for (i = 0; i < MAXPASSWD; i++) {
    if (passwordArray[i].evaluate()){
      passcodeMatchedflag=1;
      if (i==0)
      {
        // Doorbell function
        board2BoardSerial.print(NOTICE_DOORBELL_ACTIVATED); //Let nodeMCU Board know the trunk is broadcasting a doorbell activation
        myDFPlayer.volume(25);
        myDFPlayer.play(12);  //Play the doorbell please wait message
        Serial.println("Doorbell Function Called!");     
        resetAllPasswords();
        return;
      }
    }
  } 

  if (passcodeMatchedflag == 1)
  {
    openTrunk();
  }
  else
  {
    // Password not matched
    myDFPlayer.volume(25);
    myDFPlayer.play(7);  //Play the error code Msg
    Serial.println("Incorrect Password!");
  }
  
  resetAllPasswords();
  
} 

//////////////////////////////////////////
//Open the Trunk
//////////////////////////////////////////
void openTrunk()
{
    // Password matched
    myDFPlayer.volume(25);
    myDFPlayer.play(4);  //Play the correct code Msg
    Serial.println("Correct Password Entered!");
    delay(8000);
    openCloseElapsed = 0;
    autoOpen = true;  
    board2BoardSerial.print(NOTICE_TRUNK_OPENED); //Let nodeMCU Board know the trunk is executing an open command
}

//////////////////////////////////////////
//Close the Trunk
//////////////////////////////////////////
void closeTrunk()
{
    if (trunkOpen) //Don't do anything if the trunk isn't open!
    {
      trunkOpen = false;
      myDFPlayer.play(16); //Play ding sound effect
      delay(2000);
      myDFPlayer.play(5);  //Auto close notice
      delay(5500);
      openCloseElapsed = 0;
      autoClose = true;
      board2BoardSerial.print(NOTICE_TRUNK_CLOSED); //Let the nodeMCU Board know the trunk is executing a close command
    } 
}


//////////////////////////////////////////
//Reset all guessed passwords
//////////////////////////////////////////
void resetAllPasswords() {
  int i;
  for (i = 0; i < MAXPASSWD; i++) {
     passwordArray[i].reset(); 
  } 
} 

void appendAllPasswords(KeypadEvent eKey) {
  int i;
  for (i = 0; i < MAXPASSWD; i++) {
     passwordArray[i].append(eKey); 
  } 
} 

//////////////////////////////////////////
//Reset all guessed passwords
//////////////////////////////////////////
void printEEPROM()
{
  byte value;

  Serial.println("EEPROM Values:");
  for (int index = 0 ; index < EEPROM.length() ; index++) {

      value = EEPROM.read(index);

      Serial.print(index);
      Serial.print("\t");
      Serial.print(value, DEC);
      Serial.println();
  }
}

//////////////////////////////////////////
//Print detailed messages from mp3 player
//////////////////////////////////////////
void printDetail(uint8_t type, int value){
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}

/******************************************************************************
 * CastleLocker nodeMCU Board Controller
 * 
 * Copyright (c) 2018, Vocal Intent, LLC
 *
 * This program and the accompanying materials are made available under the 
 * terms of the Creative Commons Attribution 4.0 International License
 *
 * The Creative Commons Attribution 4.0 International License is available at: 
 *    https://creativecommons.org/licenses/by/4.0/legalcode
 *
 * Contributors:
 *    Chris Meade - initial contribution
 *
 *****************************************************************************/
//NOTES:
// 1. if you have trouble flashing this board, try disconnecting the Rx/Tx pins as these may interfere during program loading
// 2. if the board will not take flashing from the Arduino IDE - download the flasher program from the nodeMCU git https://github.com/nodemcu/nodemcu-flasher to reset the board

#include <Arduino.h>
#include <Stream.h>
#include <ArduinoJson.h> //see https://arduinojson.org
#include "SoftwareSerial.h" //for "talking" to the Arduino Control board

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

//AWS
#include "sha256.h"
#include "Utils.h"

//WEBSockets
#include <Hash.h>
#include <WebSocketsClient.h>

//MQTT PAHO
#include <SPI.h>
#include <IPStack.h>
#include <Countdown.h>
#include <MQTTClient.h>


//AWS MQTT Websocket
#include "Client.h"
#include "AWSWebSocketClient.h"
#include "CircularByteBuffer.h"

#define PIN_SW_SERIAL_RX 13 
#define PIN_SW_SERIAL_TX 15
SoftwareSerial board2BoardSerial(PIN_SW_SERIAL_RX, PIN_SW_SERIAL_TX); // RX, TX

int trunkOpenIndicatorPin = 5;

#define THING_NAME "castleLockerIOTThing" //Change as needed

//AWS IOT config, change these:
char wifi_ssid[]       = "YOUR_WIFI_SSID"; //change as needed
char wifi_password[]   = "YOUR_WIFI_PASSWORD"; //change as needed
char aws_endpoint[]    = "YOURENDPOINT.iot.us-east-1.amazonaws.com"; //change as needed
char aws_key[]         = "YOUR_AWS_KEY"; //change as needed
char aws_secret[]      = "YOUR_AWS_SECRET"; //change as needed
char aws_region[]      = "YOUR_AWS_REGION"; //change as needed.  e.g., us-east-1
const char* aws_topic  = "$aws/things/" THING_NAME "/shadow/update";

char *subscribeTopic[5] = {
  "$aws/things/" THING_NAME "/shadow/update/accepted",
  "$aws/things/" THING_NAME "/shadow/update/rejected",
  "$aws/things/" THING_NAME "/shadow/update/delta",
  "$aws/things/" THING_NAME "/shadow/get/accepted",
  "$aws/things/" THING_NAME "/shadow/get/rejected"
};
int port = 443;

//MQTT config
const int maxMQTTpackageSize = 1024; //Make sure this is big enough to handle IOT message (state values + metadata from AWS)
const int maxMQTTMessageHandlers = 1;

// If stuff isn't working right, watch the console:
#define DEBUG_PRINT 1

//DEFINE THE IOT COMMUNICATION CONSTANTS IN HUMAN READABLE FORM (NOTE: these are NOT all implemented!)
//TRANSMISSION VALUES
#define STATE_TRUNK_UNKNOWN 0
#define STATE_TRUNK_OPEN 1
#define STATE_TRUNK_CLOSED 2
#define STATE_TRUNK_CHANGING 3

#define CMD_IDLE 0
#define CMD_OPEN_TRUNK 1
#define CMD_CLOSE_TRUNK 2
#define CMD_PARTIAL_OPEN 3
#define CMD_PARTIAL_CLOSE 4

#define CMD_ADD_ACCESS_CODE 5
#define CMD_DELETE_ACCESS_CODE 6
#define CMD_ERASE_ACCESS_CODES 7

#define CMD_GET_TRUNK_STATE 8
#define CMD_PLAY_FILE 9
#define CMD_HOMEOWNER_NOT_AVAILABLE 10
#define CMD_DISMISS_DOORBELL 11
#define CMD_UNLOCK_KEYPAD 12

//RECEPTION VALUES
#define NOTICE_IDLE 0
#define NOTICE_TRUNK_OPENED 1
#define NOTICE_TRUNK_CLOSED 2
#define NOTICE_DOORBELL_ACTIVATED 3
#define NOTICE_MOTION_ACTIVATED 4
#define NOTICE_INVALID_CODE 5
#define NOTICE_CORRECT_CODE 6
#define NOTICE_KEYPAD_LOCKED 7
#define NOTICE_CONTROLLER_ERROR 8
#define NOTICE_CONTROLLER_RESTARTED 9
#define NOTICE_EEPROM_UPDATED 10

//Set initial local values for IOT Shadow values
int voiceCmd2CastleLockerCurrent = CMD_IDLE; //Idle
int castleLockerStateCurrent = STATE_TRUNK_UNKNOWN; //CastleLocker Trunk Open/Close State
int noticeFromCastleLockerCurrent = NOTICE_IDLE; //Idle

char cmdToSend = 254; //If 254, means there is no command to send.  Change to send a command to the Arduino Board

ESP8266WiFiMulti WiFiMulti;

AWSWebSocketClient awsWSclient(1000); 

IPStack ipstack(awsWSclient);
MQTT::Client<IPStack, Countdown, maxMQTTpackageSize, maxMQTTMessageHandlers> *client = NULL;

//# of connections
long connection = 0;

//generate random mqtt clientID
char* generateClientID () {
  char* cID = new char[23]();
  for (int i=0; i<22; i+=1)
    cID[i]=(char)random(1, 256);
  return cID;
}

//count messages arrived
int arrivedcount = 0;

//callback to handle mqtt messages
void messageArrived(MQTT::MessageData& md)
{
  MQTT::Message &message = md.message;
  
  char *pch;
  
  Serial.println ("-------------------");
  Serial.print("Message ");
  Serial.print(++arrivedcount);
  Serial.print(" arrived: qos ");
  Serial.print(message.qos);
  Serial.print(", retained ");
  Serial.print(message.retained);
  Serial.print(", dup ");
  Serial.print(message.dup);
  Serial.print(", packetid ");
  Serial.println(message.id);
  Serial.print("Payload ");
  char* msg = new char[message.payloadlen+1]();
  memcpy (msg,message.payload,message.payloadlen);
  Serial.println(msg);
  //Serial.println (ESP.getFreeHeap ());

  const size_t bufferSize = 6*JSON_OBJECT_SIZE(1) + JSON_OBJECT_SIZE(2) + 6*JSON_OBJECT_SIZE(3) + JSON_OBJECT_SIZE(4) + 610; //calculated from https://arduinojson.org/assistant/
  DynamicJsonBuffer jsonBuffer(bufferSize);
  
  const char* json = msg;
  
  JsonObject& root = jsonBuffer.parseObject(json);

  if (!root.success()) 
  {
    // Parsing failed
      Serial.println ("Parsing msg json object failed!");
      delete msg;
      return;
  }
  
  JsonObject& state = root["state"];

  if (state.containsKey("desired")) {
    JsonObject& state_desired = state["desired"];
    int state_desired_voiceCmd2CastleLocker = state_desired["voiceCmd2CastleLocker"]; 
    int state_desired_castleLockerState = state_desired["castleLockerState"]; 
    int state_desired_noticeFromCastleLocker = state_desired["noticeFromCastleLocker"]; 
  
    bool updateNeededFlag = false;
  
//    if (state_desired_voiceCmd2CastleLocker != voiceCmd2CastleLockerCurrent) {
      Serial.print("NEW CMD RECEIVED - EXECUTE: ");
      Serial.print(state_desired_voiceCmd2CastleLocker); 
      Serial.print("\t\n");   
      
      switch (state_desired_voiceCmd2CastleLocker) {
        case CMD_IDLE:
          Serial.println(F("Go Idle"));
          cmdToSend = CMD_IDLE;
          voiceCmd2CastleLockerCurrent = state_desired_voiceCmd2CastleLocker;
          updateNeededFlag = true;
          break;
        case CMD_OPEN_TRUNK:
          Serial.println(F("Open Trunk Command Requested"));
          if (castleLockerStateCurrent == STATE_TRUNK_CLOSED)
          {
            cmdToSend = CMD_OPEN_TRUNK;
            voiceCmd2CastleLockerCurrent = state_desired_voiceCmd2CastleLocker;
            updateNeededFlag = true;            
          }
          else
          {
            Serial.println(F("Trunk is not closed - request to open ignored!"));
          }          
          break;
        case CMD_CLOSE_TRUNK:
          Serial.println(F("Close Trunk Command Requested"));
          if (castleLockerStateCurrent == STATE_TRUNK_OPEN)
          {
            cmdToSend = CMD_CLOSE_TRUNK;
            voiceCmd2CastleLockerCurrent = state_desired_voiceCmd2CastleLocker;
            updateNeededFlag = true;            
          }
          else
          {
            Serial.println(F("Trunk is not open - request to close ignored!"));
          }
          break;
        default:
          break;
      }

//    }
    
    if ((state_desired_castleLockerState > 0) && (state_desired_castleLockerState != castleLockerStateCurrent)) {
      Serial.print("NEW TRUNK STATE RECEIVED - EXECUTE: ");
      Serial.print(state_desired_castleLockerState); 
      Serial.print("\t\n");   
      updateNeededFlag = true;
    }
    
    if (state_desired_noticeFromCastleLocker != noticeFromCastleLockerCurrent) {
      Serial.print("NEW NOTICE RECEIVED - EXECUTE: ");
      Serial.print(state_desired_noticeFromCastleLocker); 
      Serial.print("\t\n");   
      noticeFromCastleLockerCurrent = state_desired_noticeFromCastleLocker;
      updateNeededFlag = true;
    }  
  
    if (updateNeededFlag)
    {
      sendReportedStateMessage();       
    }
  }
  
  Serial.println ("--------***--------");

  delete msg;
}

//connects to websocket layer and mqtt layer
bool connect () {

    if (client == NULL) {
      client = new MQTT::Client<IPStack, Countdown, maxMQTTpackageSize, maxMQTTMessageHandlers>(ipstack);
    } else {

      if (client->isConnected ()) {    
        client->disconnect ();
      }  
      delete client;
      client = new MQTT::Client<IPStack, Countdown, maxMQTTpackageSize, maxMQTTMessageHandlers>(ipstack);
    }

    //delay is not necessary... it just help us to get a "trustful" heap space value
    delay (1000);
    Serial.print (millis ());
    Serial.print (" - conn: ");
    Serial.print (++connection);
    Serial.print (" - Free Heap (");
    Serial.print (ESP.getFreeHeap ());
    Serial.println (")");

   int rc = ipstack.connect(aws_endpoint, port);
    if (rc != 1)
    {
      Serial.println("error connection to the websocket server");
      return false;
    } else {
      Serial.println("websocket layer connected");
    }

    Serial.println("MQTT connecting");
    MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
    data.MQTTVersion = 3;
    char* clientID = generateClientID ();
    data.clientID.cstring = clientID;
    rc = client->connect(data);
    delete[] clientID;
    if (rc != 0)
    {
      Serial.print("error connection to MQTT server");
      Serial.println(rc);
      return false;
    }
    Serial.println("MQTT connected");
    return true;
}

//subscribe to a mqtt topic(s)
void subscribe () {

      for (int i=0; i<5; i++) {
        int rc = client->subscribe(subscribeTopic[i], MQTT::QOS0, messageArrived);
        if (rc != 0) {
          Serial.print("rc from MQTT subscribe is ");
          Serial.println(rc);
          break;
        }
        Serial.println("MQTT Topic subscribed");
      }
    
}

//send a message to a mqtt topic
void sendReportedStateMessage() {
    //send a message
    Serial.println("MQTT Updating IOT Topic from device");
    //Serial.println (ESP.getFreeHeap ());
    
    MQTT::Message message;

    String cmd = String(voiceCmd2CastleLockerCurrent);
    String state = String(castleLockerStateCurrent);
    String notice = String(noticeFromCastleLockerCurrent);
          
    if (isnan(voiceCmd2CastleLockerCurrent)) 
    {
      Serial.println("Failed to read voiceCmd2CastleLocker!");
      return;
    } 
    else if (isnan(castleLockerStateCurrent)) 
    {
      Serial.println("Failed to read castleLockerState!");
      return;
    }
    else if (isnan(noticeFromCastleLockerCurrent)) 
    {
      Serial.println("Failed to read noticeFromCastleLocker!");
      return;
    }
    
    String values = "{\"state\":{\"reported\":{\"voiceCmd2CastleLocker\": " + cmd + ",\"castleLockerState\": " + state + ",\"noticeFromCastleLocker\": " + notice + "}}}";
      // http://stackoverflow.com/questions/31614364/arduino-joining-string-and-char
    const char *publish_message = values.c_str();
    char buf[1000];
    strcpy(buf, publish_message);
    
    message.qos = MQTT::QOS0;
    message.retained = false;
    message.dup = false;
    message.payload = (void*)buf;
    message.payloadlen = strlen(buf)+1;
    int rc = client->publish(aws_topic, message); 
}

//send a message to a mqtt topic
void sendDesiredStateMessage() {
    //send a message
    Serial.println("MQTT Updating IOT Topic from device");
    //Serial.println (ESP.getFreeHeap ());
    
    MQTT::Message message;

    String cmd = String(voiceCmd2CastleLockerCurrent);
    String state = String(castleLockerStateCurrent);
    String notice = String(noticeFromCastleLockerCurrent);
          
    if (isnan(voiceCmd2CastleLockerCurrent)) 
    {
      Serial.println("Failed to read voiceCmd2CastleLocker!");
      return;
    } 
    else if (isnan(castleLockerStateCurrent)) 
    {
      Serial.println("Failed to read castleLockerState!");
      return;
    }
    else if (isnan(noticeFromCastleLockerCurrent)) 
    {
      Serial.println("Failed to read noticeFromCastleLocker!");
      return;
    }
    
    String values = "{\"state\":{\"desired\":{\"voiceCmd2CastleLocker\": " + cmd + ",\"castleLockerState\": " + state + ",\"noticeFromCastleLocker\": " + notice + "}}}";
      // http://stackoverflow.com/questions/31614364/arduino-joining-string-and-char
    const char *publish_message = values.c_str();
    char buf[1000];
    strcpy(buf, publish_message);
    
    message.qos = MQTT::QOS0;
    message.retained = false;
    message.dup = false;
    message.payload = (void*)buf;
    message.payloadlen = strlen(buf)+1;
    int rc = client->publish(aws_topic, message); 
}


void setup() {
    Serial.begin (115200);
    delay (2000);
    Serial.setDebugOutput(1);

    pinMode(PIN_SW_SERIAL_TX, OUTPUT);
    pinMode(PIN_SW_SERIAL_RX, INPUT);

    pinMode(trunkOpenIndicatorPin, INPUT_PULLUP);

    board2BoardSerial.begin(9600);

    //fill with ssid and wifi password
    WiFiMulti.addAP(wifi_ssid, wifi_password);
    Serial.println ("connecting to wifi");
    while(WiFiMulti.run() != WL_CONNECTED) {
        delay(100);
        Serial.print (".");
    }
    Serial.println ("\nwifi connected");

    //fill AWS parameters    
    awsWSclient.setAWSRegion(aws_region);
    awsWSclient.setAWSDomain(aws_endpoint);
    awsWSclient.setAWSKeyID(aws_key);
    awsWSclient.setAWSSecretKey(aws_secret);
    awsWSclient.setUseSSL(true);

    if (connect ())
    {
      subscribe (); //subscribe to all MQTT topics

      //Grab current trunk open/closed state and report it to IOT shadow
      int buttonState = digitalRead(trunkOpenIndicatorPin);
      if (buttonState==LOW) // the magnetic contact switch is closed, lid is down
      {
        //Trunk is closed
        castleLockerStateCurrent = STATE_TRUNK_CLOSED;
      }
      else // the lid is up
      {
        //Trunk is open
        castleLockerStateCurrent = STATE_TRUNK_OPEN;
      }
       
      sendReportedStateMessage(); //intial update msg to IOT thing
    }
}

void loop() {

  // keep the mqtt up and running
  if (awsWSclient.connected ()) {    
      client->yield(100L); //Keep this value short, or our loop will be SLOW!
  } else {
    //handle reconnection
    if (connect ()){ 
      subscribe ();   
    }
  }

  //If a command is queued, send the command to the Arduino Control board
  if (cmdToSend != 254)
  {
    Serial.print("sending: ");
    Serial.println(cmdToSend);
    board2BoardSerial.print(cmdToSend);
    cmdToSend = 254;
  }

  //Handle updates to trunk Open/Close state
  int buttonState = digitalRead(trunkOpenIndicatorPin);
      if (buttonState==LOW) // the magnetic contact switch is closed, lid is down
      {
        //Trunk is closed
        if (castleLockerStateCurrent != STATE_TRUNK_CLOSED) //if state has changed for the local variable, update the IOT shadow document
        {
          castleLockerStateCurrent = STATE_TRUNK_CLOSED;
          sendReportedStateMessage();
        }
      }
      else // the lid is up
      {
        Serial.print(".");
        //Trunk is open
        if (castleLockerStateCurrent != STATE_TRUNK_OPEN) //if state has changed for the local variable, update the IOT shadow document
        {
          castleLockerStateCurrent = STATE_TRUNK_OPEN;
          sendReportedStateMessage();
        }
      }


  //PROCESS ANY INBOUND NOTICES/COMMANDS FROM THE Arduino Board
  byte incomingByte = 0; 

  board2BoardSerial.listen();
  if (board2BoardSerial.available() > 0) 
  {
    while (board2BoardSerial.available() > 0)
    {
           // read the incoming byte:
           incomingByte = board2BoardSerial.read()-'0';

           // say what you got:
           Serial.print("I received: ");
           Serial.println(incomingByte, DEC);
           
            if (incomingByte == NOTICE_IDLE)
            {
                Serial.println(F("Going Idle"));
                voiceCmd2CastleLockerCurrent = CMD_IDLE;
                sendDesiredStateMessage(); //Update IOT Shadow document
            }
            else if (incomingByte == NOTICE_TRUNK_OPENED)
            {
                Serial.println(F("Opening Trunk"));
                voiceCmd2CastleLockerCurrent = CMD_OPEN_TRUNK;
                sendReportedStateMessage(); //Update IOT Shadow document
            }
            else if (incomingByte == NOTICE_TRUNK_CLOSED)
            {
                Serial.println(F("Closing Trunk"));
                voiceCmd2CastleLockerCurrent = CMD_CLOSE_TRUNK;
                sendReportedStateMessage(); //Update IOT Shadow document
            }
            else if (incomingByte == NOTICE_DOORBELL_ACTIVATED)
            {
                Serial.println(F("Doorbell Activated"));
                //TO DO - Add function to send doorbell notice to IOT Shadow and Alexa
            }
            else if (incomingByte == NOTICE_MOTION_ACTIVATED)
            {
                Serial.println(F("Motion Detected"));
                //TO DO - Add function to report motion to IOT Shadow and Alexa
            }                        
            else
            {
                Serial.println(F("UNKNOWN CMD"));
            }             
      }
   }
      
}