ESP32 Forum

Code: Select all

#include<stdio.h>
#include "esp_attr.h"
#include<stdlib.h>
#include <ArduinoJson.h>
#include <AWS_IOT.h>
AWS_IOT myiot;   // AWS_IOT instance
#include <WiFi.h>

#include "time.h"
#include <Wire.h>//I2C
#include <string.h> //string lib

#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include <math.h>
#include "ens210.h"// ENS210 library
ENS210 ens210;


//tsp data
#include <WiFiUdp.h>
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
WiFiUDP udp;

unsigned long epoch;//String utime;
unsigned int localPort = 2390;      // local port to listen for UDP packets
IPAddress timeServerIP;
const char* ntpServerName = "time.nist.gov";
const int NTP_PACKET_SIZE = 48;
byte packetBuffer[ NTP_PACKET_SIZE];

//*****************************************


//Broker Address: ahrcxnah0j2zm-ats.iot.us-east-1.amazonaws.com
//Broker Port: 8883


char WIFI_SSID[] = "XXX";
char WIFI_PASSWORD[] = "XX@1111";
char HOST_ADDRESS[] = "xxxxxxxxxxxxxxxxxxxxxxxxxx";
char CLIENT_ID[] = "xxxxxxxxxxxxxxxxxxxxxxx";
char TOPIC_NAME[] = "monitor";

const int ledpin_4 = 4; // led status
int status = WL_IDLE_STATUS; //wifi status
int aws_status = 0;
int data_cnt = 0;

int tick = 0, msgCount = 0, msgReceived = 0;

//-------------------------------------------------------------------
// How many times we should attempt to connect to AWS
//-------------------------------------------------------------------
#define AWS_MAX_RECONNECT_TRIES 5

char payload[500]; //aws cloud data

String wifi_mac;
String type_str;
String tsp_str;
String temp_str;
String hum_str;
String heart_str;
String posx_str;
String posy_str;
String posz_str;
String bat_str;
String devid_str;
String spo2_str;
String data_packet_str; //watch value stored


//sleep an restart ESP32
#define uS_TO_S_FACTOR 1000000  // Conversion factor for micro seconds to seconds
#define TIME_TO_SLEEP  10        // Time ESP32 will go to sleep (in seconds)


/*
    BLE Advertised Device found:
    Name: BABY_WATCH,
    Address: 4c:11:ae:71:28:fe
*/

#include "BLEDevice.h"
#include <BLEUtils.h>
//#include <BLEServer.h>

// The remote service we wish to connect to.
static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");

static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;

//Client device
BLEClient* pclient = NULL;
BLEClient*  pClient = NULL;
static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice = NULL;

static void notifyCallback(
  BLERemoteCharacteristic* pBLERemoteCharacteristic,
  uint8_t* pData,
  size_t length,
  bool isNotify) {
  Serial.println("Notify callback for characteristic ");
  Serial.print(pBLERemoteCharacteristic->getUUID().toString().c_str());
  Serial.print(" of data length :: ");
  Serial.println(length);
  Serial.print(" data: ");
  Serial.println((char*)pData);
  delay(1000);
}

class MyClientCallback : public BLEClientCallbacks {
    void onConnect(BLEClient* pClient) {
      connected = true;
      Serial.println(" onConnect Connected to Server");
    }
    void onDisconnect(BLEClient* pClient)
    {
      connected = false;
      Serial.println("Disconnected from Server");
      exit;
    }
};

bool connectToServer() {
  BLERemoteService* pRemoteService = NULL;
  Serial.print(" - Forming a connection to ");
  if (myDevice != NULL)
  {
    Serial.println(myDevice->getAddress().toString().c_str());
    delay(1000);

    pClient  = BLEDevice::createClient();
    Serial.println(" - Created client");
    //  delay(1000);

    pClient->setClientCallbacks(new MyClientCallback());
    //delay(1000);

    // Connect to the remove BLE Server.
    pClient->connect(myDevice);  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
    Serial.println(" - Connected to server");
    delay(1000);

    // Obtain a reference to the service we are after in the remote BLE server.
    pRemoteService = pClient->getService(serviceUUID);
  }
  if (pRemoteService == nullptr) {
    Serial.print(" - Failed to find our service UUID: ");

    Serial.println(serviceUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }
  Serial.println(" - Found our service");
  delay(1000);

  // Obtain a reference to the characteristic in the service of the remote BLE server.
  pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
  delay(7000);

  if (pRemoteCharacteristic == nullptr)
  {
    Serial.print("Failed to find our characteristic UUID: ");
    Serial.println(charUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }  else {
    Serial.println(" - Found our characteristic");
    delay(1000);
  }
  //********   READ DATA PACKET FROM BLE_WATCH *******************
  // Read the value of the characteristic.

  if (pRemoteCharacteristic->canRead())
  {
    Serial.println("Reading packet from watch");
    delay(2000);
    std::string value = pRemoteCharacteristic->readValue();
    Serial.print("BLE_data_packet:: "); //temp value RX
    Serial.println(value.c_str());
    delay(5000);

    data_packet_str = value.c_str(); //store "WATCH" data

    Serial.print("\nWATCH data:");
    Serial.println(data_packet_str);
    delay(1000);

    //*********  split string start  ************************
    float commaIndex = data_packet_str.indexOf(','); //temp
    unsigned long secondCommaIndex = data_packet_str.indexOf(',', commaIndex + 1); //hum
    float thirdCommaIndex = data_packet_str.indexOf(',', secondCommaIndex + 1);  // HRM
    float fourthCommaIndex = data_packet_str.indexOf(',', thirdCommaIndex + 1);  //spo2
    float fifthCommaIndex = data_packet_str.indexOf(',', fourthCommaIndex + 1);  //x-axis
    float sixthCommaIndex = data_packet_str.indexOf(',', fifthCommaIndex + 1);  //y-axis
    float seventhCommaIndex = data_packet_str.indexOf(',', sixthCommaIndex + 1); //z-axis

    //float eighthCommaIndex = data_packet_str.indexOf(',', seventhCommaIndex + 1);
    //float ninthCommaIndex = data_packet_str.indexOf(',', eighthCommaIndex + 1);
    // float tenthCommaIndex = data_packet_str.indexOf(',', ninthCommaIndex + 1);


    temp_str = data_packet_str.substring(0, commaIndex);
    hum_str = data_packet_str.substring(commaIndex + 1, secondCommaIndex);
    heart_str = data_packet_str.substring(secondCommaIndex + 1, thirdCommaIndex);
    spo2_str = data_packet_str.substring(thirdCommaIndex + 1, fourthCommaIndex);
    posx_str  = data_packet_str.substring(fourthCommaIndex + 1, fifthCommaIndex);
    posy_str = data_packet_str.substring(fifthCommaIndex + 1, sixthCommaIndex);
    posz_str = data_packet_str.substring(sixthCommaIndex + 1);

    //     = data_packet_str.substring(seventhCommaIndex + 1, eighthCommaIndex);
    //    bat_str = data_packet_str.substring(eighthCommaIndex + 1, ninthCommaIndex);
    //    spo2_str = data_packet_str.substring(ninthCommaIndex + 1);
    //    //par_str = data_packet_str.substring(tenthCommaIndex + 1 );


    Serial.println("-------------------------------------------");
    Serial.println("ble datapacket after split :");
    Serial.println(type_str); Serial.println(tsp_str);
    Serial.println(temp_str); Serial.println(hum_str);
    Serial.println(heart_str); Serial.println(posx_str);
    Serial.println(posy_str); Serial.println(posz_str);
    Serial.println(bat_str); Serial.println(spo2_str);
    Serial.println("-------------------------------------------");
    delay(1000);
    //****** split string end  *************************
  }
  pClient->disconnect();
}
/*
   Scan for BLE servers and find the first one that advertises the service we are looking for.
*/
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks
{
    /* Called for each advertising BLE server.*/

    void onResult(BLEAdvertisedDevice advertisedDevice)
    {
      Serial.print("BLE Advertised Device found: ");
      Serial.println(advertisedDevice.toString().c_str());

      // We have found a device, let us now see if it contains the service we are looking for.

      if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID))
      {
        BLEDevice::getScan()->stop();
        myDevice = new BLEAdvertisedDevice(advertisedDevice);
        doConnect = true;
        doScan = true;

      } // Found our server
    } // onResult
}; // MyAdvertisedDeviceCallbacks


void setup()  // start of setup.
{
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector

  Serial.begin(115200);

  pinMode(ledpin_4, OUTPUT);      //led out

  //for capacitive
  pinMode(15, INPUT);            //touch 2
  pinMode(14, INPUT);            //touch 3

  while (!Serial) continue;
  Serial.println("\nStarting Arduino BLE Client application...");
  delay(1000);
  ble_init();              // bluetooth ON
  //ble_reconnect();
  ble_deinit();
  Serial.println("\n----------------------------------------------------------------");
  Serial.print("::::End of Setup Function::::: ");
  Serial.println("\n----------------------------------------------------------------");
} // End of setup.

//******************************************************************************************************************************
//******************************** PLEASE SEE THIS FUNCTION  ********************************************************************
//*********************************************************************************************************************************

// This is the Arduino main loop function.
void loop()
{
  // bluetooth OFF

  Serial.println("\n----------------------------------------------------------------");
  Serial.print("wifi status :: ");
  Serial.println(status);
  //check if wifi connected or not.
  //if connected then execute if part otherwise it execute else part to connect with wifi and further process
  if (status == WL_CONNECTED)
  {
    wifi_mac = WiFi.macAddress();
    Serial.print("BRIDGE Device ID :: ");
    Serial.println(wifi_mac);
    delay(2000);
    //if connected then execute if part otherwise else part
    if (aws_status == 1)
    {
      JSON_PACKET();                // JSON_DATA_PACKET STORE AND APEND
      aws_data();                   //data ready to publish
    }
    else
    {
      aws();                        // AMAZON CLOUD connect
      JSON_PACKET();                // JSON_DATA_PACKET STORE AND APEND
      aws_data();                   //data ready to publish
    }


  }
  else                              // first of all connect to wifi and do  further process
  {
    wifi();                         // wifi reconnect

    if (aws_status == 1)            //if connected then execute if part otherwise else part
    {
      JSON_PACKET();                // JSON_DATA_PACKET STORE AND APEND

      aws_data();                   //data ready to publish
    }
    else                            // firstly create aws connection and then execute rest of like json packet and aws data
    {
      aws();                        // AMAZON CLOUD connect

      JSON_PACKET();                // JSON_DATA_PACKET STORE AND APEND

      aws_data();                   //data ready to publish
    }

  }
  delay(5000);
  Serial.println("\n########################################\n########################################");
  // sleep();  ////device sleep and wake up in next 10 sec
  setup();

}

//*****************************************************************************************************************************

void wifi()
{
  //************** wifi *********************************

  if (status == WL_CONNECTED)
  {
    Serial.print(" wifi is in connected STATE  :: ");
  }
  else
  {
    while (status != WL_CONNECTED)
    {
      Serial.print("Attempting to connect to SSID :: ");
      Serial.println(WIFI_SSID);
      WiFi.mode(WIFI_MODE_STA);
      status = WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
      delay(1500);
    }

    wifi_mac = WiFi.macAddress();
    Serial.print("BRIDGE Device ID :: ");
    Serial.println(wifi_mac);
    delay(100);

    Serial.println("------------------------------------------------\n");
    Serial.println("Connected to wifi");

    Serial.print("IP address :: ");
    Serial.println(WiFi.localIP());
    Serial.print("WIFI Strength :: ");
    Serial.println( WiFi.RSSI());
    Serial.print("WiFi MAC address :: ");
    Serial.println(WiFi.macAddress());
    Serial.println("------------------------------------------------\n");
    //  Serial.print("WIFI_data:"); Serial.println(data_packet_str);
  }
}

//**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//******************              AMAZON CLOUD CONNECTION                *********************************************************************************

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

void aws()
{
  // Try to connect to AWS and count how many times we retried.
  int retries = 0;
  Serial.println("Checking connection for AWS IOT");
  delay(1000);// if return value = 0 successfully cloud connect
  while (myiot.connect(HOST_ADDRESS, CLIENT_ID) != 0 && retries < AWS_MAX_RECONNECT_TRIES) // Connect to AWS using Host Address and Cliend ID
  {
    Serial.println(" Connecting to AWS... ");
    delay(1500);
    retries++;
  }

  if (myiot.connect(HOST_ADDRESS, CLIENT_ID) == 0)
  {
    Serial.println(" AWS_cloud is  connected ");
    aws_status = 1;
    delay(1500);
    return;
  }
  delay(200);

}// aws(); end

//*************** BLE ***************************************
int k = 0;
void ble_init()
{
  if (k == 0) {
    BLEDevice::init("ESP32");
  }
  Serial.println("\n------------------------------------------------");
  Serial.println(" \t:::: Bluetooth ON :::: ");
  Serial.println("------------------------------------------------\n");
  delay(1000);
  // Retrieve a Scanner and set the callback we want to use to be informed when we
  // have detected a new device.  Specify that we want active scanning and start the
  // scan to run for 5 seconds.

  BLEScan* pBLEScan = BLEDevice::getScan();
  Serial.print("pBLEScan ::");
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setInterval(1349);
  pBLEScan->setWindow(449);
  pBLEScan->setActiveScan(true);
  pBLEScan->start(100, false);
  delay(1000);

  //Trying to connect
  if (connectToServer())
  {
    k = 1;
    Serial.println("We have received DATA from Watch (Server)");

  }
  //  else
  //  {
  //    Serial.println("We have failed to connect to the Watch server; there is nothin more we will do.");
  //    }

}


void ble_deinit()

{
  connected = false;
  delay(2000);
  myDevice = NULL;
  delay(10000);
  pClient->disconnect();
  delay(2000);
  pclient = NULL;
  delay(2000);
  myDevice = NULL;

  BLEDevice::deinit(ESP.getFreeHeap());
  Serial.println("------------------------------------------------");
  Serial.println(" \t:::: Bluetooth OFF :::: ");
  Serial.println("------------------------------------------------");
  delay(100);
}



//************* data packet*************************************


void JSON_PACKET()
{
  // JSON memory allocation
  DynamicJsonDocument doc(350); //data packet buffer
  tsp();

  doc["type"] = "monitor";
  doc["tsp"] = "1584696179";
  doc["deviceID"] = wifi_mac;                 //wifi_mac;
  doc["temperature"] = temp_str;
  doc["humidity"] =  hum_str;
  doc["heart_rate"] = heart_str;
  doc["spo2_level"] = spo2_str;
  doc["pos_x"] =  posx_str ;
  doc["pos_Y"] = posy_str;
  doc["pos_Z"] = posz_str;
  //doc ["battery"] = "full";



  Serial.println("JSON DATA PACKET   :");
  serializeJsonPretty(doc, Serial);
  // serializeJson(doc, Serial); //show on serial
  serializeJson(doc, payload);//all obj stored from doc to playload

  /*
    // JSON PAYLOAD for TEMP_ALERT doc_1  ******************************

    doc_1["type"] = type_str;
    doc_1["param"] = "temp";
    doc_1["tsp"] = tsp_str;
    doc_1["deviceID"] = wifi_mac;
    JsonArray data_1 = doc_1.createNestedArray("temperature");
    data_1.add(temp_str); data_1.add(temp_str);
    data_1.add(temp_str); data_1.add(temp_str);
    data_1.add(temp_str); data_1.add(temp_str);
    data_1.add(temp_str); data_1.add(temp_str);
    data_1.add(temp_str); data_1.add(temp_str);

    //Serial.println(" TEMP_ALERT DATA PACKET");
    //  Serial.println("JSON payload for TEMP_ALERT is ready to upload :");
    // serializeJsonPretty(doc_1, Serial);
    //serializeJson(doc_1, Serial); //show on serial
    serializeJson(doc_1, payload_1);//all obj stored from doc to playload
    delay(10);
  */

}

void aws_data()
{
  if (myiot.publish(TOPIC_NAME, payload) == 0) // Publish the message(Temp and humidity)
  {
    Serial.println("\n------------------------------------------------");
    Serial.print("\nPublish Message :: ");
    Serial.println(payload);
    Serial.print("\nSize of monitor data packet after write :: ");
    Serial.print(sizeof(payload));
    Serial.println(" bytes");
    Serial.println("\n------------------------------------------------");
    Serial.println("Published monitor data packet to AWS_CLOUD successfully");
    Serial.println("------------------------------------------------");
    delay(1000);
    memset(payload, 0, 500 *  sizeof(payload[0]));
    Serial.println("\n------------------------------------------------");
    Serial.print("Size of payload after free ::");
    Serial.print(sizeof(payload));
    Serial.println(" bytes");
    delay(1000);
    led_status();
    data_cnt++;
  }

}


void led_status()
{
  //digitalWrite(ledpin_4, HIGH);   // turn the LED on (HIGH is the voltage level)
  //  Serial.println("led on");
  //delay(500);

  //digitalWrite(ledpin_4, LOW);    // turn the LED off by making the voltage LOW
  //Serial.println("led off");
  //delay(100);
}

void tsp()
{
  delay(500);
  //time unix ********* start  ***********************
  WiFi.hostByName(ntpServerName, timeServerIP);
  sendNTPpacket(timeServerIP);
  int cb = udp.parsePacket();

  if (!cb)
  {
    delay(1);
  }
  else
  {
    udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer
    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
    unsigned long secsSince1900 = highWord << 16 | lowWord;
    const unsigned long seventyYears = 2208988800UL;
    epoch = secsSince1900 - seventyYears;
    Serial.print("UNX_TIME : ");
    Serial.println(epoch);
  }
  delay(2000);  // 10000

}//************ time end  ********************

unsigned long sendNTPpacket(IPAddress & address)
{
  Serial.println("\n");
  Serial.println("Sending NTP packet...");
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;
  udp.beginPacket(address, 123);
  udp.write(packetBuffer, NTP_PACKET_SIZE);
  udp.endPacket();
}


void ble_reconnect()
{

  if (connected)
  {
    Serial.println("bluetooth is connected mode");
    delay(500);
  }
  else if (doScan)
  {
    connected = false; // added from 28/05 on 09/06
    BLEDevice::getScan()->start(0);  // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
  }



}
void sleep()
{
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  //   Serial.println("BLE_BRIDGE  sleep for every " + String(TIME_TO_SLEEP) +
  //              " Seconds");
  //Serial.println("BRIDGE is getting UPDATING now... ");
  delay(1000);
  Serial.flush();
  esp_deep_sleep_start();
}

Code: Select all

/************************************
        Libraries Include
***********************************/

/*Standered C libraries*/
#include <stdio.h>
#include <stdlib.h>

/*Brownout Detector removing using this lib's*/
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"


/* For INT_MIN */
#include <limits.h>

/*Accelerometer */
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>


/*****************************************************************
    function_Header.h file contains function declaration
*/
#include "function_Header.h"

/******************************************************************
    macro_define.h  contains some macros required for the functions
*/
#include "macro_define.h"

/********************************************************************
  This  micro definition include, when using MAX30100 sensor
  Which is used for detection of Heart rate and SpO2 measurment
*/
#include "MAX30100_PulseOximeter.h"

/********************************************************************
    PulseOximeter is the higher level interface to the sensor
    it offers:
            > beat detection reporting
            > heart rate calculation
            > SpO2 (oxidation level) calculation
*/
PulseOximeter pox;

uint32_t tsLastReport = 0;

/*---------------------------------------------------------------------------*/
/* Assign a unique ID to this sensor at the same time */
Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);

/******************************************************************
      ENS210 Library included for Temprature and Humidity recording
      Header for Temperature & Humidity
      ens210 is structer header for Temperature & Humidity
*/
#include <ens210.h>
ENS210 ens210;

/*Librarys included to use Bluetooth functionality of controller*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include"esp_gap_bt_api.h"
#include "esp_err.h"
#include "BluetoothSerial.h"
/*
    Pointer requirement for Initiating BLE Server.
    We have initialize all the pointer with NULL value.
      The design of creating the BLE server is:
   1. Create a BLE Server
   2. Create a BLE Service
   3. Create a BLE Characteristic on the Service
   4. Create a BLE Descriptor on the characteristic
   5. Start the service.
   6. Start advertising.
*/
BLEServer *pServer = NULL ;
BLEService *pService;
BLEAdvertising *pAdvertising = NULL;

bool deviceConnected = false;
bool oldDeviceConnected = false;


/* define the characteristic and it's propeties */
BLECharacteristic  pCharacteristic(
  CHARACTERISTIC_UUID,
  BLECharacteristic::PROPERTY_READ |
  BLECharacteristic::PROPERTY_NOTIFY
);

/* This function handles server callbacks */
class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };
    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

int afs = 0;

int BLE_lock = 0;
/********************************************
          Setup Function
*********************************************/
void setup()
{
  delay(3000);
  /*Disable Brownout Detector*/
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);

  Wire.begin();         //TWI comunication starts

  Serial.begin(115200); //Console Starts

  /*************Temperature sensor Initialization*****************/
  ens210.begin();

  /*************Accelerometer sensor Initialization*****************/
  accel.begin();
  accel.setRange(ADXL345_RANGE_16_G);

  /*Push button to on/off*/
  pinMode(button, INPUT);

  /*GPIO 15 used for HRM Reset*/
  pinMode(Resetz, OUTPUT);

  /*GPIO 04 used to check ADC ready input from HRM*/
  pinMode(ADC_RDY, INPUT);

  Serial.print("\n\nInitializing device Please wait  ");
  int a = 0;
  DOTS;
  Serial.println("");

  /*
       Initialize the PulseOximeter instance and register a beat-detected callback.
       The parameter passed to the begin() method changes the samples flow that the library spews to the serial.
       Options:
          PULSEOXIMETER_DEBUGGINGMODE_PULSEDETECT : filtered samples and beat detection threshold
          PULSEOXIMETER_DEBUGGINGMODE_RAW_VALUES : sampled values coming from the sensor, with no processing
          PULSEOXIMETER_DEBUGGINGMODE_AC_VALUES : sampled values after the DC removal filter

       Initialize the PulseOximeter instance
       Failures are generally due to an improper I2C wiring, missing power supply or wrong target chip

  */
  /*      Uncomment below statements when MAX3010x sensor connected */
  //    if (!pox.begin(PULSEOXIMETER_DEBUGGINGMODE_PULSEDETECT)) {
  //        Serial.println("ERROR: Failed to initialize pulse oximeter");
  //        for(;;);
  //    }

  pox.setOnBeatDetectedCallback(onBeatDetected); //callbback function defined in function definiition

  delay(1000);
}  /*void setup() ends here*/

/************************************************
                    Loop Function
************************************************/
void loop()
{
  Serial.println("\nModified Date :: 12/06/2020");
  /* Variables to stores Data*/
  float Temp_Array[50], Humidity_Array[50], HRM_Array[50], SpO2_Array[50], ACC_X_Array[50], ACC_Y_Array[50], ACC_Z_Array[50];

  double HRM1_SpO2[2];

  float HRM, SpO2, Fahrenheit, Humidity, Acc_Mag[3], time_delay;

  int  sampling_unit = 0, processing_unit = 1;
  /* variable are used for running the loop for given sample unit
    to do this you can change the "processing_unit" manually
    calculation is given below,
    time_delay = (60 / processing_unit) * 1000;
    the time delay is the time to send data to bridge
  */

  char unx_str[100], heart_str[100], SPO2_str[100], far_str[100], hum_str[100], a_x[100], a_y[100], a_z[100];


  //milliseconds/no. of samples multiply by 1000 it will gives duration
  //here 60 is configuired as one minute
  // 60 can be replaced by as per requirement

  //time_delay = (60 / processing_unit) * 100;
  time_delay = 1000;
  /***********************************************************
    Data(Interger) to string conversion
    unx_str epox time converting to string epoch  //Now we are not using this
    heart_str Heart rate converting to string HRM
    SPO2_str SpO2 converting to string SpO2
    far_str Temperature converting to string Fahrenheit
    hum_str Humidity converting to string Humidity
    a_x X-axis converting to string Acc_Mag[0]
    a_y Y-axis converting to string Acc_Mag[1]
    a_z Z-axis converting to string Acc_Mag[2]
  ************************************************************/
  // dtostrf(epoch, 1, 2, unx_str);

  dtostrf(HRM1_SpO2[0], 1, 3, heart_str);
  dtostrf(HRM1_SpO2[1], 1, 3, SPO2_str);
  dtostrf(Fahrenheit, 1, 3, far_str);
  dtostrf(Humidity, 1, 3, hum_str);
  dtostrf(Acc_Mag[0], 1, 3, a_x);
  dtostrf(Acc_Mag[1], 1, 3, a_y);
  dtostrf(Acc_Mag[2], 1, 3, a_z);

  char BLE_PACKET[200];             //Bluetooth Data packet used for sending to Gateway
  char BLE_TEMP_ALERT_PACKET[200];  //Temperatur Alert packet



  /*To turn on and off the device*/
  Button_on_off();

  /**********  WI-FI Initialization ************
    //WiFi.begin(ssid, pass);
    //  while (WiFi.status() != WL_CONNECTED)
    //  {
    //    Serial.println("Connection to wifi");
    //    delay(500);
    //  }
    //
    //  udp.begin(localPort);
    //
    //  Serial.println("wifi Conected ");
  */

  Serial.println("Starting BLE_WATCH ");

  DOTS;
  afs = 0;

  /*--------------------------------------------------------------------------------------------------------------------------*/

  Serial.println("Executing All Tasks");

  /*------------------------------------------------------------------------------------*/
  /*
                    Looping all tasks
  */
  loop_running_task_ (sampling_unit != processing_unit)
  {
    /*------------------------------------------------------------------------------------*/

    temp_Hum_task( &Fahrenheit, &Humidity );          // Calling Temperatur function

    Serial.println("-----------------------------------------------------------------------------------------------");

    Serial.print(" Temperature :: "); Serial.println(Fahrenheit);
    Serial.print(" Humidity :: "); Serial.println(Humidity);

    Serial.println("-----------------------------------------------------------------------------------------------");

    Temp_Array[sampling_unit] = Fahrenheit;         //Storing temperature values

    Serial.print(" Temp_Array[sampling_unit] :: ");
    Serial.println(Temp_Array[sampling_unit]);

    Serial.println("-----------------------------------------------------------------------------------------------");
    Humidity_Array[sampling_unit] = Humidity;      //Storing Humidity calue

    Serial.print(" Humidity_Array[sampling_unit] :: ");
    Serial.println(Humidity_Array[sampling_unit]);

    Serial.print(" time_delay :: "); Serial.println(time_delay);

    /*
         We have to generate ALERTs for temperature changes from HIGH or LOW.
         These change in temperature are used to check with the threashold values set for high and low detection.
         These alertsare send to Gateway by using BLE on detect.
         In this BLE_PACKET stores the values which is above or equal to threashold and update to Gateway.
    */

    if (Fahrenheit > 99 && Fahrenheit < 102) {                        // if temp > 90 alert payload send
      //Collecting data in packet
      sprintf(BLE_PACKET, "%0.2f", Fahrenheit);                       //Need to define exact time for alert without using wifi
      pCharacteristic.setValue(BLE_PACKET);                          //transfering collected data alert via bluetooth to Bridgge
      pCharacteristic.notify();
      Serial.print(" High TEMPERATURE ALERT :: ");
      Serial.println(BLE_TEMP_ALERT_PACKET);
      delay(1000);
    } else if (Fahrenheit > 102) {                                    // if temp > 102 alert payload send
      // change readings for 100 and 102
      // Very high tempperature alert packet
      // Collecting data in packet
      int high_alert = 0;
      while (high_alert != 2) {                                       //We are sending this alert signal thrice after every 5 Second to gateway.
        sprintf(BLE_PACKET, "%0.2f", Fahrenheit);
        pCharacteristic.setValue(BLE_PACKET);                        //transfering collected data alert via bluetooth to Bridgge
        pCharacteristic.notify();
        Serial.print(" High TEMPERATURE ALERT:");
        Serial.println(BLE_TEMP_ALERT_PACKET);
        high_alert++;                                                 //Sending high alert 3 times after every 5 second
        delay(5000);
      }
    } else if (Fahrenheit < 80) {                                     // if temp <80 alert payload send
      //Low temperature alert packet
      sprintf(BLE_PACKET, "%0.2f", Fahrenheit);                       //Collecting data in packet
      pCharacteristic.setValue(BLE_PACKET);                          //transfering collected data alert via bluetooth to Bridgge
      pCharacteristic.notify();
      Serial.print(" High TEMPERATURE ALERT:");
      Serial.println(BLE_TEMP_ALERT_PACKET);
      delay(1000);
    }

    //******************** TEMP alert end  ********************
    /*------------------------------------------------------------------------------------*/

    delay(200);

    /*------------------------------------------------------------------------------------*/

    //Motion starts
    /*
       Function returns the values of Accelration
       x- axis
       y-axis
       z-axis
       Storing these values in a array ACC_X_Array[],ACC_Y_Array[],ACC_Z_Array[]

    */
    // Calling Accelration Task
    task_Acc_Mag(Acc_Mag);

    Serial.println("-----------------------------------------------------------------------------------------------");

    ACC_X_Array[sampling_unit] = Acc_Mag[0];         //Storing x-axis value

    Serial.print(" ACC_X_Array[sampling_unit] :: "); Serial.println(ACC_X_Array[sampling_unit]);

    ACC_Y_Array[sampling_unit] = Acc_Mag[1];         //Storing y-axis value

    Serial.print(" ACC_Y_Array[sampling_unit] :: "); Serial.println(ACC_Y_Array[sampling_unit]);

    ACC_Z_Array[sampling_unit] = Acc_Mag[2];         //Storing z-axis value

    Serial.print(" ACC_Z_Array[sampling_unit] :: "); Serial.println(ACC_Z_Array[sampling_unit]);

    Serial.println("-----------------------------------------------------------------------------------------------");

    delay(200);

    /*------------------------------------------------------------------------------------*/

    // Calling HRM Task
    HRM_FUNCTION(HRM1_SpO2);

    Serial.println("-----------------------------------------------------------------------------------------------");

    Serial.print(" HRM1_SpO2[0] :: "); Serial.println(HRM1_SpO2[0]);
    Serial.print(" HRM1_SpO2[1] :: "); Serial.println(HRM1_SpO2[1]);

    HRM_Array[sampling_unit] = HRM1_SpO2[0];

    Serial.println("-----------------------------------------------------------------------------------------------");

    Serial.print(" HRM_Array[sampling_unit] :: "); Serial.println(HRM_Array[sampling_unit]);

    SpO2_Array[sampling_unit] = HRM1_SpO2[1];

    Serial.print(" SpO2_Array[sampling_unit] :: "); Serial.println(SpO2_Array[sampling_unit]);

    Serial.println("-----------------------------------------------------------------------------------------------");

    delay(time_delay);

    Serial.print(" Sample time :: "); Serial.println(sampling_unit);

    delay(1000);

    sampling_unit++;

    delay(time_delay);                //delaying the loop

    Serial.println("-----------------------------------------------------------------------------------------------");
  }//Loop running Task ends here..............

  Serial.print(" Temperature : : ");              Serial.println(Temp_Array[0]);
  Serial.print(" Humidity : : ");                 Serial.println(Humidity_Array[0]);
  Serial.print(" HRM_Array[sampling_unit] :: ");  Serial.println(HRM_Array[0]);
  Serial.print(" SpO2_Array[sampling_unit] :: "); Serial.println(SpO2_Array[0]);
  Serial.print("X Axis ::");                      Serial.println(ACC_X_Array[0]);
  Serial.print("Y Axis ::");                      Serial.println(ACC_Y_Array[0]);
  Serial.print("Z Axis ::");                      Serial.println(ACC_Z_Array[0]);

  /*-------------------------------------------------------------------------------------------
      BLE_PACKET is a charecter array that stores all the values that,
      we have to send via Bluetooth to the Bridge/Gateway in JSON format
    ---------------------------------------------------------------------------------------------*/
  Serial.println("-----------------------------------------------------------------------------------------------");
  //Following JSON packet is of TYPE monitor packet
  Serial.println("BLE Packet to Send via BLE");

  /* BLE_PACKET holds all the data from sensors */
  sprintf(BLE_PACKET, "%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f",
          Fahrenheit, Humidity, HRM_Array[0], SpO2_Array[0], Acc_Mag[0], Acc_Mag[1], Acc_Mag[2]);

  Serial.println("\n------------------------------------------------");

  /*************** Bluetooth Initialization********************/

  // Name your BLE Device
  BLEDevice::init("BABY_WATCH");

  //Create the BLE Server
  pServer = BLEDevice::createServer();
  Serial.println("\n::::: Pserver Created ::::: ");

  // Set the function that handles server callbacks
  pServer->setCallbacks(new MyServerCallbacks());
  delay(1000);

  // Create the BLE Service
  pService = pServer->createService(SERVICE_UUID);
  Serial.println(":::::PServise Created ::::: ");
  delay(1000);

  // Create a BLE Characteristic
  pService->addCharacteristic(&pCharacteristic);

  // Create a BLE Descriptor
  pCharacteristic.addDescriptor(new BLE2902());

  // Start the service

  Serial.println("\n ::::: Turning ON Bluetooth :::: ");
  DOTS; afs = 0;
  Serial.println("------------------------------------------------\n");
  Serial.println("");
  Serial.println("\n ::::: BLUETOOTH TURNED ON ::::: \n");
  Serial.println("------------------------------------------------\n");

  pService->start();

  // Configure Advertising
  pAdvertising = BLEDevice::getAdvertising();     // Start advertising
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);            //previous it was true
  pAdvertising->setMinPreferred(0x06);            // functions that help with iPhone connections issue
  pAdvertising->setMinPreferred(0x12);            // set value to 0x00 to not advertise this parameter
  BLEDevice::startAdvertising();

  Serial.println("Waiting a Gateway connection to notify...");
  Serial.println("------------------------------------------------\n");
  Serial.println("\n");

  /*Sending collected data via BLE*/
  delay(10000);

  if (deviceConnected) {
    Serial.println(" Sending MONITOR packet to Bridge via bluetooth");
    //This value is transfer to gateway over BLE
    pCharacteristic.setValue(BLE_PACKET);
    pCharacteristic.notify();
    delay(10000);
    deviceConnected = false;
    pServer == NULL;
    BLEDevice::stopAdvertising();
  }
  Serial.println("BRIDGE is getting UPDATING now... \n");

  // deviceConnected = false;

  Serial.print(" Data packet :: ");
  Serial.println(BLE_PACKET);                         //Final BLE Packet, send to Gateway
  Serial.println("\n-----------------------------------------------------------------------------------------------");

  delay(2000);
  // BLE DATA PACKET END
  // Disconnecting BLE
//  BLEDevice::deinit(ESP.getFreeHeap());

  int t = 1;
  if (!deviceConnected)
  {
    deviceConnected = false;
    delay(2000);
    Serial.println("------------------------------------------------");
    Serial.println(":::: Bluetooth OFF ::::");
    Serial.println("------------------------------------------------\n");
    t = 0;
  }else if (t) {
      Serial.println("Not in if(!disconnect)");
    }
    
  //  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  //  //   Serial.println("BLE_BRIDGE  sleep for every " + String(TIME_TO_SLEEP) +
  //  //              " Seconds");
  //
  delay(5000);

  //  Serial.flush();
  //  esp_deep_sleep_start();
}  /*void loop() function ends here*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       Temperature and Humidity Task Execution
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
void temp_Hum_task( float * Fahrenheit, float * Humidity )
{
  Serial.println("Executing Temperature and Humidity Function");
  /*******  Temperature and Humidity Event  *******/
  /*Variable for Temprature & Humidity*/
  int t_data, t_status, h_data, h_status;
  /*Temprature and Humidity measurment*/
  ens210.measure(&t_data, &t_status, &h_data, &h_status );
  /*Calculating temperature in Fahrenheit*/
  *Fahrenheit = ens210.toFahrenheit(t_data, 100);
  *Fahrenheit /= 100;
  /*Calculating Humidity in % Relative humidity*/
  *Humidity =  ens210.toPercentageH(h_data, 1);
  //  Serial.print(" Humidity: ");  Serial.print(*Humidity);  Serial.print(" %\t");
  //  Serial.print(" Temperature: ");  Serial.print(*Fahrenheit);    Serial.println(" *F ");
  delay(50);
}  /*void temp_Hum_task() function ends here*/


/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   Acceleration and Magnetometer Task Execution
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
void task_Acc_Mag(float Acc_Mag[])
{
  Serial.println("Executing Acceleration Function");
  delay(5);
  /*******  Acceleration Event  *******/
  sensor_t sensor;                        //header for Acceleration sensor

  accel.getSensor(&sensor);               //Reading values from sensor

  sensors_event_t event;                  // header for occurence of event

  accel.getEvent(&event);                 //Reading values from event

  /* Display the results (acceleration is measured in m/s^2) */

  float Acc_X = event.acceleration.x;     //Acc_X-Axis

  Acc_Mag[0] = Acc_X;                     //Storing result from X-axis

  float Acc_Y = event.acceleration.y;     //Acc_Y-Axis

  Acc_Mag[1] = Acc_Y;                     //Storing result from Y-axis

  float Acc_Z = event.acceleration.z;     //Acc_Z-Axis

  Acc_Mag[2] = Acc_Z;                     //Storing result from Z-axis

  delay(5);

}/*void task_Acc_Mag() function ends here*/

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                  Max_HR_SpO2()

      This function gives the Heart rate and SpO2 measurments

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
void Max_HR_SpO2(float HR_SpO2[])
{
  // Make sure to call update as fast as possible
  pox.update();

  // Asynchronously dump heart rate and oxidation levels to the serial
  // For both, a value of 0 means "invalid"
  if (millis() - tsLastReport > REPORTING_PERIOD_MS) {
    Serial.print("H:"); Serial.println(pox.getHeartRate());
    HR_SpO2[0] = pox.getHeartRate();
    Serial.print("Heart Rate :: "); Serial.println(HR_SpO2[0]);
    Serial.print("O:"); Serial.println(pox.getSpO2());
    HR_SpO2[1] = pox.getSpO2();
    Serial.print("SpO2 :: "); Serial.println(HR_SpO2[1]);
    tsLastReport = millis();
  }
}



void ble_deinit()

{
  BLEDevice::deinit(ESP.getFreeHeap());
  Serial.println("------------------------------------------------");
  Serial.println(" \t:::: Bluetooth OFF :::: ");
  Serial.println("------------------------------------------------");
  delay(100);
}


/************************************
    EPOCH UNIX TIME FUNCTION
*************************************/
/*
  unsigned long sendNTPpacket(IPAddress& address) {
  Serial.println(" Sending NTP packet...");
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;
  udp.beginPacket(address, 123);
  udp.write(packetBuffer, NTP_PACKET_SIZE);
  udp.endPacket();
  return 0;
  //unsigned long sendNTPpacket() function ends here
  }
*/