/ Initializes the library
void begin();

// Read state of the expander digital pins
byte expanderRead();

// Write state of the expander digital pins
void expanderWrite(byte data);

// Read state of the analog to digital conversor pins
int readADC(uint8_t adcnum);

// Prints a wave formed by points in serial monitor
void printWave(uint16_t air);

// Initializes the UART expander for a specific sensor
void initSensorUART(uint8_t number);

// Initializes the UART expander
void initSensorUART(void);

// Enables the UART expander for a specific sensor
void enableSensorUART(uint8_t number);

// Disables the UART expander
void disableSensorUART(void);

// Intializes software interruptions
void initInterrupt(uint16_t sampleRate);

// Pauses software interruptions
void pauseInterrupt(void);

// Resumes software interruptions
void resumeInterrupt(void);

// Debug printing functions
void print(char * msg);
void println(char * msg);
void println();
void PrintHex8(uint8_t *data, uint8_t length);
void PrintHex16(uint16_t *data, uint8_t length);

// Returns the library version
int version(void);
		

// It opens the UART and powers the module
int8_t initModule();
	
// It closes the UART and powers off the module
void OFF();
	
// Set TX power. 
uint16_t setTXPower(uint8_t power);
	
// sends software reset command to the module. Resets in normal mode
uint8_t softwareReset();
	
// Reset the module via the hardware reset pin
void hardwareReset();
		
// Makes an inquiry to discover specific device by its Mac.
uint16_t scanDevice(char * Mac);
	
// Makes an inquiry to discover specific device by its Mac.
uint16_t scanDevice(char* Mac, uint8_t maxTime, uint8_t TXPower);
	

// This function configures the discover mode. Default observation mode.
uint16_t setDiscoverMode(uint8_t discover);

// This functions configures the discoverability mode. default general discoverable mode.
uint16_t setDiscoverableMode(uint8_t discoverable);

// This functions configures the connectability mode. default directed conectable mode.
uint16_t setConnectableMode(uint8_t connectable);
	
// This function ends the current procedure, like a scan.
uint16_t endProcedure();
	
// similar to AT -> OK
uint8_t sayHello();
	
// This function will start direct connection establishment procedure to a dedicated BLE device.
uint16_t connectDirect(char * BLEAddress, uint16_t conn_interval_min, uint16_t conn_interval_max, uint16_t timeout, uint16_t latency);
	
// This function will start direct connection establishment procedure to a dedicated BLE device.
uint16_t connectDirect(char * BLEAddress);
	
// This function disconnects an active connection
uint16_t disconnect(uint8_t connection);
	
//  wait for specified time for an event. 
uint8_t waitEvent(unsigned long time);
	
//  Sets device to bondable mode
uint16_t setBondableMode(uint8_t bondable);
	
//  deletes all devices bonded
uint16_t deleteBonding();
	
// return number of bonded devices. maximum of 8 
uint16_t getBonding();
	
// read an attribute from the local database of the BLE device.
uint16_t readLocalAttribute(uint16_t handle, uint16_t offset);
	
// read an attribute from the local database of the BLE device (default offset=0).
uint16_t readLocalAttribute(uint16_t handle);
	
// write local attribute to the local GATT database of the BLE device
uint16_t writeLocalAttribute(uint16_t handle, char * data);
	
// write local attribute to the local GATT database of the BLE device
uint16_t writeLocalAttribute(uint16_t handle, uint8_t indicate, char * data);
		
// write local attribute to the local GATT database of the BLE device 
uint16_t writeLocalAttribute(uint16_t handle, uint8_t * data, uint8_t length);
	
// write local attribute of the BLE device, indicate enabled
uint16_t writeLocalAttribute(uint16_t handle, uint8_t indicate, uint8_t * data, uint8_t length);
	
// read an attribute from a remote BLE device
uint16_t attributeRead(uint8_t connection_handle, uint16_t att_handle);
	
// write an attribute from a remote BLE device
uint16_t attributeWrite(uint8_t connection, uint16_t atthandle, char * data);
	
// write an attribute from a remote BLE device
uint16_t attributeWrite(uint8_t connection, uint16_t atthandle, uint8_t * data, uint8_t length);
	
// get the current status of the BLE module
uint8_t getStatus(uint8_t connection);

// initializes all the Bluetooth variables
void initialize_BLE_values();
	
// configures Security Manager parametes
uint16_t setSMParameters(uint8_t protection);
		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 


#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

unsigned long previous;


// Sensor list
bool selected_airflow;
bool selected_ecg;
bool selected_emg;
bool selected_gsr;
bool selected_position;
bool selected_snore;
bool selected_temp;
bool selected_spiro;
bool selected_eeg;
bool selected_spo2_uart;
bool selected_bp_uart;
bool selected_gluco_uart;
bool selected_scale_ble;
bool selected_spo2_ble;
bool selected_bp_ble;
bool selected_gluco_ble;

void setup()
{
  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);


  Serial.begin(115200);

  MySignals.initSensorUART();


  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }

}


void loop()
{

  //1. SET MODE: SLAVE (VISIBLE TO APP)
  while ((MySignals_BLE.ble_mode_flag == master_mode))
  {
    if (MySignals_BLE.setMode(slave_mode) == 0)
    {
      //TFT message:  "Slave mode ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[3])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.ble_mode_flag = slave_mode;
    }
    else
    {
      //TFT message:  "Slave mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[4])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



  //2. SET BONDABLE MODE
  if (MySignals_BLE.bond_mode_and_mitm == 0)
  {
    if (MySignals_BLE.setBondableMode(BLE_ENABLE_BONDING) == 0)
    {

      //TFT message:  "Bondable mode ok"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[5])));
      tft.drawString(buffer_tft, 0, 45, 2);



      //3. SET SM PARAMETERS
      if (MySignals_BLE.setSMParameters(BLE_ENABLE_MITM) == 0)
      {
        //TFT message:  "SM parameters ok"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[7])));
        tft.drawString(buffer_tft, 0, 60, 2);


        MySignals_BLE.bond_mode_and_mitm = 1;

      }
      else
      {
        //TFT message:  "SM parameters fail"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[8])));
        tft.drawString(buffer_tft, 0, 60, 2);

        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
    else
    {
      //TFT message:  "Bondable mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[6])));
      tft.drawString(buffer_tft, 0, 45, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



}
	
		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 


#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

unsigned long previous;


// Sensor list
bool selected_airflow;
bool selected_ecg;
bool selected_emg;
bool selected_gsr;
bool selected_position;
bool selected_snore;
bool selected_temp;
bool selected_spiro;
bool selected_eeg;
bool selected_spo2_uart;
bool selected_bp_uart;
bool selected_gluco_uart;
bool selected_scale_ble;
bool selected_spo2_ble;
bool selected_bp_ble;
bool selected_gluco_ble;

void setup()
{
  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);


  Serial.begin(115200);

  MySignals.initSensorUART();


  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }

}


void loop()
{

  //1. SET MODE: SLAVE (VISIBLE TO APP)
  while ((MySignals_BLE.ble_mode_flag == master_mode))
  {
    if (MySignals_BLE.setMode(slave_mode) == 0)
    {
      //TFT message:  "Slave mode ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[3])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.ble_mode_flag = slave_mode;
    }
    else
    {
      //TFT message:  "Slave mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[4])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



  //2. SET BONDABLE MODE
  if (MySignals_BLE.bond_mode_and_mitm == 0)
  {
    if (MySignals_BLE.setBondableMode(BLE_ENABLE_BONDING) == 0)
    {

      //TFT message:  "Bondable mode ok"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[5])));
      tft.drawString(buffer_tft, 0, 45, 2);



      //3. SET SM PARAMETERS
      if (MySignals_BLE.setSMParameters(BLE_ENABLE_MITM) == 0)
      {
        //TFT message:  "SM parameters ok"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[7])));
        tft.drawString(buffer_tft, 0, 60, 2);


        MySignals_BLE.bond_mode_and_mitm = 1;

      }
      else
      {
        //TFT message:  "SM parameters fail"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[8])));
        tft.drawString(buffer_tft, 0, 60, 2);

        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
    else
    {
      //TFT message:  "Bondable mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[6])));
      tft.drawString(buffer_tft, 0, 45, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



}
		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 
int8_t answer;

/*DEMUL*/
int S0Pin = 4;
int S1Pin = 5;
int S2Pin = 6;

int ENABLE = 7;
char aux_str[50];

void setup() {
  Serial.begin(115200);

  printlnMsg("Starting...");
  pinMode(S0Pin, OUTPUT);
  pinMode(S1Pin, OUTPUT);
  pinMode(S2Pin, OUTPUT);
  pinMode(ENABLE, OUTPUT);
  delay(1000);
  digitalWrite(S0Pin, HIGH);
  digitalWrite(S1Pin, HIGH);
  digitalWrite(S2Pin, HIGH);
  delay(1000);


  digitalWrite(ENABLE, HIGH);
  delay(1000);
  // Checks if the WiFi module is started
  answer = sendATcommand("AT", "OK", 6000);
  if (answer == 0)
  {
    printlnMsg("Error");
    // waits for an answer from the module
    while (answer == 0) {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 6000);
    }
  }
  else if (answer == 1) 
  {

    printlnMsg("WiFi succesfully working!");
    
  }



}

void loop() 
{

  delay(5000); 


}

int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


    x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0) {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        //Serial.print("Received: ");
        printlnMsg(response);

      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}


void printMsg(char * msg)
{
  digitalWrite(ENABLE, LOW);
  delay(10);
  Serial.print(msg);

  digitalWrite(ENABLE, HIGH);
  delay(10);
}

void printlnMsg(char * msg)
{
  digitalWrite(ENABLE, LOW);
  delay(10);
  Serial.println(msg);


  digitalWrite(ENABLE, HIGH);
  delay(10);
}


		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 
int8_t answer;

/*DEMUL*/
int S0Pin = 4;
int S1Pin = 5;
int S2Pin = 6;

int ENABLE = 7;
char aux_str[50];

void setup() {
  Serial.begin(115200);

  printlnMsg("Starting...");
  pinMode(S0Pin, OUTPUT);
  pinMode(S1Pin, OUTPUT);
  pinMode(S2Pin, OUTPUT);
  pinMode(ENABLE, OUTPUT);
  delay(1000);
  digitalWrite(S0Pin, HIGH);
  digitalWrite(S1Pin, HIGH);
  digitalWrite(S2Pin, HIGH);
  delay(1000);


  digitalWrite(ENABLE, HIGH);
  delay(1000);
  // Checks if the WiFi module is started
  answer = sendATcommand("AT", "OK", 6000);
  if (answer == 0)
  {
    printlnMsg("Error");
    // waits for an answer from the module
    while (answer == 0) {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 6000);
    }
  }
  else if (answer == 1) {

    printlnMsg("WiFi succesfully working!");
    
    
    if(sendATcommand("AT+CWMODE=1", "OK", 6000))
    {
      printlnMsg("AT+CWMODE=1 OK");
    }
    else{
      printlnMsg("AT+CWMODE=1 Error");

    }
    
    

    if(sendATcommand("AT+CWJAP=\"WIFI_SSID\",\"WIFI_PASSWORD\"", "OK", 20000))
    {
      printlnMsg("Successfully connected!");
    }
    else{
      printlnMsg("Error");

    }

  }



}

void loop() 
{

  delay(5000); 


}

int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


    x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0) {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        //Serial.print("Received: ");
        printlnMsg(response);

      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}


void printMsg(char * msg)
{
  digitalWrite(ENABLE, LOW);
  delay(10);
  Serial.print(msg);

  digitalWrite(ENABLE, HIGH);
  delay(10);
}

void printlnMsg(char * msg)
{
  digitalWrite(ENABLE, LOW);
  delay(10);
  Serial.println(msg);


  digitalWrite(ENABLE, HIGH);
  delay(10);
}
		

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"

void setup()
{
  Serial.begin(115200);
  MySignals.begin();

  /*
    expanderState is initialized with B10000001

    Expansor pin library names:

    EXP_3G_ON
    EXP_TOUCH_CS
    EXP_BT_POWER
    EXP_BT_KEY
    EXP_ADC_CS
    EXP_SNORE_POT
    EXP_RESET_BLE
    EXP_WIFI_ON
  */
}

void loop()
{
  //Enable 3G module power -> bit0:0
  bitClear(MySignals.expanderState, EXP_3G_ON);  
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable 3G module power -> bit0:1
  bitSet(MySignals.expanderState, EXP_3G_ON);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable Touchscreen SPI -> bit1:1
  bitSet(MySignals.expanderState, EXP_TOUCH_CS);  
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable Touchscreen SPI -> bit1:0
  bitClear(MySignals.expanderState, EXP_TOUCH_CS);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable BT2.0 module power -> bit2:1
  bitSet(MySignals.expanderState, EXP_BT_POWER);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);

  //Disable BT2.0 module power -> bit2:0
  bitClear(MySignals.expanderState, EXP_BT_POWER);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);

  //Enable BT2.0 Key to communication mode -> bit3:1
  bitSet(MySignals.expanderState, EXP_BT_KEY);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);

  //Enable BT2.0 Key to AT mode -> bit3:0
  bitClear(MySignals.expanderState, EXP_BT_KEY);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);
  
  //Enable ADC SPI -> bit4: 1
  bitSet(MySignals.expanderState, EXP_ADC_CS);   
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable ADC SPI -> bit4: 0
  bitClear(MySignals.expanderState, EXP_ADC_CS);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable Snore potentiometer SPI -> bit5: 1
  bitSet(MySignals.expanderState, EXP_SNORE_POT);   
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable Snore potentiometer SPI -> bit5: 0
  bitClear(MySignals.expanderState, EXP_SNORE_POT);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable BLE module reset -> bit6: 1
  bitSet(MySignals.expanderState, EXP_RESET_BLE);   
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable BLE module reset -> bit6: 0
  bitClear(MySignals.expanderState, EXP_RESET_BLE);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable WiFi module power (expansion board) -> bit7:0
  bitClear(MySignals.expanderState, EXP_WIFI_ON);  
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
  
  //Disable WiFi module power (expansion board) -> bit7:1
  bitSet(MySignals.expanderState, EXP_WIFI_ON);    
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);
}
		

MySignals.expanderWrite(B10000001);			
		

MySignals.expanderWrite(B10000000);
		

MySignals.expanderWrite(B10000011);
		

MySignals.expanderWrite(B10000001); //Mode: AT   -    BT Power:  off
delay(100);
MySignals.expanderWrite(B10000101);  //Mode: AT  -   BT Power:  on

		

MySignals.expanderWrite(B10010001);
		

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
  MySignals.begin(); 
}

void loop() 
{
  MySignals.expanderWrite(B00000000);
  delay(1000);

  expanderWrite(B11111111);
  delay(1000);
}
		

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 
}

void loop() 
{

  int read_adc = MySignals.readADC(ADC_AIRFLOW);
  Serial.println(read_adc);
  
  delay(1000);
  
}
		

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 
  
  MySignals.initSensorUART();
  
  MySignals.enableSensorUART(GLUCOMETER);
  delay(1000);
  
  MySignals.enableSensorUART(BLOODPRESSURE);
  delay(1000);
  
  MySignals.enableSensorUART(PULSIOXIMETER);
  delay(1000);
  
  MySignals.enableSensorUART(SPIROMETER);
  delay(1000);
}

void loop() 
{

  
}
		

{
// It returns SPO2 specific measure:
//(PULSE) 
//(SPO2) 
int getPulsioximeter(uint8_t format);

//Gets both SPO2 measures, pulse and SPO2:
uint8_t getPulsioximeter();
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

int valuePulse;
int valueSPO2;
uint8_t pulsioximeter_state = 0;

void setup() 
{

  Serial.begin(19200);
  MySignals.begin();
  
  MySignals.initSensorUART();
  MySignals.enableSensorUART(PULSIOXIMETER);
}

void loop() 
{

  // First way of getting sensor data
  MySignals.enableSensorUART(PULSIOXIMETER);
  Serial.println();
  pulsioximeter_state = MySignals.getPulsioximeter();
  if (pulsioximeter_state == 1)
  {
    Serial.print(F("Pulse:"));
    Serial.print(MySignals.pulsioximeterData.BPM);
    Serial.print(F("bpm / SPO2:"));
    Serial.print(MySignals.pulsioximeterData.O2);
    Serial.println(F("%"));
  }
  else if (pulsioximeter_state == 2)
  {
    Serial.println(F("Not valid data"));
  }
  else
  {
    Serial.println(F("No available data"));
  }
  MySignals.disableSensorUART();

  delay(2000);


  // Second way of getting sensor data
  MySignals.enableSensorUART(PULSIOXIMETER);
  valuePulse = MySignals.getPulsioximeter(PULSE);
  Serial.println();
  if (valuePulse == 2)
  {
    Serial.println(F("Not valid Pulse data"));
  }
  else if (valuePulse == 0)
  {
    Serial.println(F("No available data"));
  }
  else
  {
    Serial.print(F("Pulse:"));
    Serial.print(valuePulse);
    Serial.println(F("bpm"));
  }
  MySignals.disableSensorUART();

  
  delay(2000);


  MySignals.enableSensorUART(PULSIOXIMETER);
  valueSPO2 = MySignals.getPulsioximeter(SPO2);
  if (valueSPO2 == 2)
  {
    Serial.println(F("Not valid SPO2 data"));
  }
  else if (valueSPO2 == 0)
  {
    Serial.println(F("No available data"));
  }
  else
  {
    Serial.print(F("SPO2:"));
    Serial.print(valueSPO2);
    Serial.println(F("%"));
  }
  MySignals.disableSensorUART();


  delay(2000);
  
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


int valuePulse;
int valueSPO2;
uint8_t pulsioximeter_state = 0;

void setup() 
{

  Serial.begin(19200);
  MySignals.begin();
  
  MySignals.initSensorUART();
  MySignals.enableSensorUART(PULSIOXIMETER);
  
  tft.init();   
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
  
  tft.drawString("SPO2:", 0, 0, 2);
}

void loop() 
{

  pulsioximeter_state = MySignals.getPulsioximeter();
  if (pulsioximeter_state == 1)
  { 
	  tft.drawNumber(MySignals.pulsioximeterData.BPM, 0, 30, 2);
    tft.drawNumber(MySignals.pulsioximeterData.O2, 0, 45, 2);
  }

  delay(1000);

}
		

{
	float ECGvolt = eHealth.getECG();;
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}



void loop() 
{

  float ECG = MySignals.getECG(VOLTAGE);

  Serial.print("ECG value :  ");
  Serial.print(ECG, 2);
  Serial.println(" V");  
  
  // wait for a millisecond
  delay(1);	
 
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}



void loop() 
{
  float ECG = MySignals.getCalibratedECG(5,0,0,DATA);

  Serial.print("ECG value :  ");
  Serial.print(ECG, 0);
  Serial.println(" V");  

  // wait for a millisecond
  delay(1);	
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;

byte serialByte;

void setup() 
{
  Serial.begin(9600);
  MySignals.begin();
  Serial.println("Starting...");
}

void loop() 
{ 
  while (Serial.available()>0)
  {  
    serialByte=Serial.read();
    if (serialByte=='C')
    {        
      while(1){
        fanalog0=MySignals.getECG(DATA);  
        // Use the timer0 => 1 tick every 4 us
        time=(timer0_overflow_count << 8) + TCNT0;        
        // Microseconds conversion.
        time=(time*4);   
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);

        if (Serial.available()>0)
        {
          serialByte=Serial.read();
          if (serialByte=='F')  break;
        }
      }
    }
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"


void setup()
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop()
{

  uint16_t ecg = (uint16_t)MySignals.getECG(DATA);
  
  ecg = map(ecg, 0,1023,1023,0);
  Serial.println(ecg);

  delay(5);

 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 



void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  int ECG = MySignals.getECG(DATA);
  ECG = map(ECG,0,1023,200,0);
  
  MySignals.printWave(ECG);
     
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"



Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

//! It stores the current value of x position in the LCD.
uint16_t graphic_x = 0;
//! It stores the current value of the ECG or AirFlow sensor.
uint16_t valRead;
//! It stores the previous value of the ECG or AirFlow sensor.
uint16_t graphic_prevRead;

#define graphic_low_extrem 230
#define graphic_high_extrem 50
#define graphic_left_extrem 0
#define graphic_right_extrem 320



void setup()
{
  Serial.begin(115200);

  MySignals.begin();
  
  tft.init();

  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("ECG",5,5,4); 

}


void loop()
{
  valRead = MySignals.getECG(DATA);
  //Serial.println(valRead);
  
  valRead = map(valRead, 150, 600, graphic_high_extrem, graphic_low_extrem);

  printGraphic(valRead,0);
  
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}
		

{
// Returns airflow value in a specific format
//(VOLTAGE) - in Volts (0-5V)
//(DATA)    - in digital value (0-1023)
float getAirflow(uint8_t format);

// Returns airflow in DATA format
float getAirflow(void);

// Returns an analog value to represent the Electrocardiography (0-5V)
float getCalibratedAirflow(uint8_t samples, uint16_t delaySample, float offset, uint8_t format);

// Calculates airflow PPM
void airflowPPM(void);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  float air = MySignals.getAirflow(VOLTAGE);   
  Serial.print("Airflow value :  ");
  Serial.print(air, 2);
  Serial.println(" V");
  
  delay(100); 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();  
}


void loop() 
{
 
  float air = MySignals.getCalibratedAirflow(10,1,0,VOLTAGE);   
  Serial.print("Airflow value :  ");
  Serial.print(air, 2);
  Serial.println(" V");           
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 


extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;
byte serialByte;

void setup()
{
  
  Serial.begin(9600);
  MySignals.begin();
  
  Serial.println("Starting...");
}

void loop() 
{  
  
  while (Serial.available()>0) 
  {
    serialByte = Serial.read();

    if (serialByte == 'C')
    {
      
      while(1) 
      {
        fanalog0 = MySignals.getAirflow(DATA);  
        
        // Use the timer0 => 1 tick every 4 us
        time = (timer0_overflow_count << 8) + TCNT0;
        
        // Microseconds conversion.
        time = time*4;
        
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);
        
        if (Serial.available()>0)
        {
          serialByte = Serial.read();
          if (serialByte == 'F') break;
        }
      }
    }
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  uint16_t air = (uint16_t)MySignals.getAirflow(DATA);   
 
  Serial.println(air);
  
  delay(20);
  
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 



void setup() 
{
  Serial.begin(115200);  
  MySignals.begin();
}


void loop() 
{

  int air = MySignals.getAirflow(DATA);   
  MySignals.printWave(air);  
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
    
  tft.init();
  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("Airflow",5,5,4); 
}

void loop() 
{

  valRead = (uint16_t)MySignals.getAirflow(DATA);
    
  valRead = map(valRead, 0, 1023, 230, 30);
  
  printGraphic(valRead, 0);
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}

		

{
// Indicates if Blood Pressure sensor is connected and powered on
uint8_t getStatusBP();

// Calculates all Blood Pressure measures
bool getBloodPressure(void);

}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"



void setup()
{

  Serial.begin(19200);
  MySignals.begin();

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLOODPRESSURE);
}

void loop()
{
  if (MySignals.getStatusBP())
  {
    delay(1000);

    if (MySignals.getBloodPressure() == 1)
    {
      MySignals.disableMuxUART();
      Serial.println();
      Serial.print("Diastolic: ");
      Serial.println(MySignals.bloodPressureData.diastolic);
      Serial.print("Systolic: ");
      Serial.println(MySignals.bloodPressureData.systolic);
      Serial.print("Pulse/min: ");
      Serial.println(MySignals.bloodPressureData.pulse);
      MySignals.enableMuxUART();

    }
  }
  delay(1000);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#include <Wire.h>
#include "SPI.h"

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

void setup()
{
  Serial.begin(115200);
  MySignals.begin();
  
  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLOODPRESSURE);

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
  

  tft.drawString("Blood pressure:", 0, 0, 2);
  
}

void loop()
{
  if (MySignals.getStatusBP())
  {
    delay(1000);

    if (MySignals.getBloodPressure() == 1)
    {
      
      tft.drawString("Diastolic:", 0, 15, 2);
      tft.drawNumber(MySignals.bloodPressureData.diastolic, 100, 15, 2);
      
      tft.drawString("Systolic:", 0, 30, 2);
      tft.drawNumber(MySignals.bloodPressureData.systolic, 100, 30, 2);

      tft.drawString("Pulse/min:", 0, 45, 2);
      tft.drawNumber(MySignals.bloodPressureData.pulse, 100, 45, 2);  

    }
  }
  delay(1000);
}
		

{
// Gets glucose measures
void getGlucose(void);
}
		

{
//!Struct to store data of the glucometer.
    struct glucoseDataVector
    {
      uint8_t year;
      uint8_t month;
      uint8_t day;
      uint8_t hour;
      uint8_t minutes;
      uint8_t glucose;
      uint8_t meridian;
    };

    //!Vector to store the glucometer measures and dates.
    glucoseDataVector glucometerData[1];
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h"


void setup()
{
  Serial.begin(115200);
  MySignals.begin();
  MySignals.initSensorUART();
  MySignals.enableSensorUART(GLUCOMETER);

  delay(1000);

  MySignals.getGlucose();
  
  Serial.begin(115200);
  MySignals.disableMuxUART();
  for (uint8_t i = 0; i < MySignals.glucoseLength; i++)
  {
    Serial.print(F("measure number:"));
    Serial.println(i + 1);
    Serial.print(F("year:"));
    Serial.println(MySignals.glucometerData[i].year);
    Serial.print(F("month:"));
    Serial.println(MySignals.glucometerData[i].month);
    Serial.print(F("day:"));
    Serial.println(MySignals.glucometerData[i].day);
    Serial.print(F("hour:"));
    Serial.println(MySignals.glucometerData[i].hour);
    Serial.print(F("minutes:"));
    Serial.println(MySignals.glucometerData[i].minutes);
    Serial.print(F("glucose:"));
    Serial.println(MySignals.glucometerData[i].glucose);
    Serial.print(F("meridian:"));
    Serial.println(MySignals.glucometerData[i].meridian);
    Serial.println();
  }
  MySignals.enableMuxUART();

}

void loop()
{


}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#include <Wire.h>
#include "SPI.h"

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

void setup()
{
  Serial.begin(115200);
  MySignals.begin();
  MySignals.initSensorUART();
  MySignals.enableSensorUART(GLUCOMETER);

  delay(1000);

  MySignals.getGlucose();
  
  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  tft.drawString("Glucometer last measure:", 0, 0, 2);
  tft.drawNumber(MySignals.glucometerData[MySignals.glucoseLength-1].glucose, 0, 30, 2);
}

void loop()
{


}
		

{
// Returns the corporal temperature
float getTemperature(void);

// Returns the corporal temperature after applying measuring filter
float getCalibratedTemperature(uint8_t samples, uint16_t delaySample, float offset, uint8_t format);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  
  MySignals.begin();
}


void loop() 
{
  float temperature = MySignals.getTemperature();

  Serial.print(F("Temperature (*C): "));       
  Serial.println(temperature, 2);  


  delay(1000);	// wait for a second 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);  
  MySignals.begin();
}


void loop() 
{
  float temperature = MySignals.getCalibratedTemperature(100,10,0.2);

  Serial.print("Temperature (ºC): ");       
  Serial.print(temperature, 2);  
  Serial.println(""); 

  delay(1000);	// wait for a second 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  float temperature = MySignals.getTemperature();
     
  Serial.println(temperature+4, 2);  


  delay(20);	
  
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
    
  tft.init();
  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("Temperature",5,5,4); 
}

void loop() 
{

  valRead = (float)MySignals.getTemperature()*10.0;
   
  Serial.println(valRead);
  
  valRead = map(valRead, 300, 400, 230, 30);
  
  printGraphic(valRead, 0);
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}
		

{
// Returns EMG value in a specific format
//(VOLTAGE) - in Volts (0-5V)
//(DATA)    - in digital value (0-1023)
float getEMG(uint8_t format);

// Returns EMG in DATA format
float getEMG(void);

// Returns EMG value after applying measuring filter
float getCalibratedEMG(uint8_t samples, uint16_t delaySample, float offset, uint8_t format);

// Calculates EMG CPM
void EMGCPM(void);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  float EMG = MySignals.getEMG(VOLTAGE);

  Serial.print("EMG value :  ");
  Serial.print(EMG, 2);
  Serial.println(" V");  
  

  delay(10);	
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{
  float EMG = MySignals.getCalibratedEMG(5,0,0,VOLTAGE);

  Serial.print("EMG value :  ");
  Serial.print(EMG, 2);
  Serial.println(" V");  


  delay(10);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 



extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;
byte serialByte;

void setup() 
{
  Serial.begin(9600);
  
  MySignals.begin();
  Serial.println("Starting...");
}

void loop() 
{ 
  while (Serial.available()>0)
  {  
    serialByte=Serial.read();
    if (serialByte=='C')
    {        
      while(1)
      {
        fanalog0=MySignals.getEMG(DATA);  
        // Use the timer0 => 1 tick every 4 us
        time=(timer0_overflow_count << 8) + TCNT0;        
        // Microseconds conversion.
        time=(time*4);   
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);

        if (Serial.available()>0)
        {
          serialByte=Serial.read();
          if (serialByte=='F')  break;
        }
      }
    }
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  uint16_t EMG = (uint16_t)MySignals.getEMG(DATA);
 
  Serial.println(EMG);
  
  delay(20);
  
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 
}


void loop() 
{

  float EMG = MySignals.getEMG(DATA);
  EMG = map(EMG,100, 600,0,300);
  MySignals.printWave(EMG); 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
    
  tft.init();
  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("EMG",5,5,4); 
}

void loop() 
{
  valRead = (uint16_t)MySignals.getEMG(DATA);
  
  //Serial.println(valRead);  
  valRead = map(valRead, 100, 600, 230, 30);
  
  printGraphic(valRead, 0);
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}

		

{
// Indicates if Blood Pressure sensor is connected and powered on
uint8_t getStatusSpiro();

// Gets up to 7 spirometer measures
void getSpirometer();
}
		

{
// Deletes all measures from spirometer device memory
bool deleteSpiroMeasures();
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h"


void setup()
{
  Serial.begin(9600);
  MySignals.begin();
  MySignals.initSensorUART();
  MySignals.enableSensorUART(SPIROMETER);



  while (MySignals.getStatusSpiro() == 0)
  {
    delay(100);
  }
  Serial.println(F("Spirometer is ON"));

}

void loop()
{
  MySignals.getSpirometer();



  MySignals.disableMuxUART();
  Serial.print(F("Number of measures:"));
  Serial.println(MySignals.spir_measures);
  Serial.println();

  for (int i = 0; i < MySignals.spir_measures; i++)
  {

    Serial.print(MySignals.spirometerData[i].spir_pef);
    Serial.print(F("L/min "));

    Serial.print(MySignals.spirometerData[i].spir_fev);
    Serial.print(F("L "));

    Serial.print(MySignals.spirometerData[i].spir_hour);
    Serial.print(F(":"));
    Serial.print(MySignals.spirometerData[i].spir_minutes);

    Serial.print(F(" "));

    Serial.print(MySignals.spirometerData[i].spir_year);
    Serial.print(F("-"));
    Serial.print(MySignals.spirometerData[i].spir_month);
    Serial.print(F("-"));
    Serial.println(MySignals.spirometerData[i].spir_day);


  }
  Serial.println(F("************"));
  MySignals.enableMuxUART();


}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h"


void setup()
{
  Serial.begin(9600);
  MySignals.begin();
  MySignals.initSensorUART();
  MySignals.enableSensorUART(SPIROMETER);



  while (MySignals.getStatusSpiro() == 0)
  {
    delay(100);
  }
  MySignals.println("Spirometer is ON. Deleting measures");

  MySignals.deleteSpiroMeasures();
}

void loop()
{
  MySignals.getSpirometer();



  MySignals.disableMuxUART();
  Serial.print(F("Number of measures:"));
  Serial.println(MySignals.spir_measures);
  Serial.println();

  for (int i = 0; i < MySignals.spir_measures; i++)
  {

    Serial.print(MySignals.spirometerData[i].spir_pef);
    Serial.print(F("L/min "));

    Serial.print(MySignals.spirometerData[i].spir_fev);
    Serial.print(F("L "));

    Serial.print(MySignals.spirometerData[i].spir_hour);
    Serial.print(F(":"));
    Serial.print(MySignals.spirometerData[i].spir_minutes);

    Serial.print(F(" "));

    Serial.print(MySignals.spirometerData[i].spir_year);
    Serial.print(F("-"));
    Serial.print(MySignals.spirometerData[i].spir_month);
    Serial.print(F("-"));
    Serial.println(MySignals.spirometerData[i].spir_day);


  }
  Serial.println(F("************"));
  MySignals.enableMuxUART();
  delay(5000);

}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>



Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);



void setup(void)
{
  Serial.begin(9600);

  MySignals.begin();

  MySignals.initSensorUART();
  MySignals.enableSensorUART(SPIROMETER);

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  tft.drawString("Spirometer last measure:", 0, 0, 2);
  while (MySignals.getStatusSpiro() == 0)
  {
    delay(100);
  }
  MySignals.getSpirometer();
  
  uint16_t spir_pef_last = MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef;
  
  tft.drawNumber(spir_pef_last, 0, 30, 2);
 
}

void loop()
{
  delay(5000);

}

		

{
// Returns GSR value in a specific format
//(VOLTAGE) - in Volts (0-5V)
//(DATA)    - in digital value (0-1023)
float getGSR(uint8_t format);
    
// Returns GSR in DATA format
float getGSR(void);

// Returns GSR value after applying measuring filter
float getCalibratedGSR(uint8_t samples, uint16_t delaySample, float offset, uint8_t format);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200); 
  
  MySignals.begin();
}


void loop() 
{

  float conductance = MySignals.getGSR(CONDUCTANCE);
  float resistance = MySignals.getGSR(RESISTANCE);
  float conductanceVol = MySignals.getGSR(VOLTAGE);

  Serial.print("Conductance : ");       
  Serial.print(conductance, 2);  
  Serial.println("");         

  Serial.print("Resistance : ");       
  Serial.print(resistance, 2);  
  Serial.println("");    

  Serial.print("Conductance Voltage : ");       
  Serial.print(conductanceVol, 4);  
  Serial.println("");

  Serial.print("\n");

  // wait for a second  
  delay(1000);            
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();  
}


void loop() 
{
 
  float conductance = MySignals.getCalibratedGSR(100, 1, 0, CONDUCTANCE);
  float resistance = MySignals.getCalibratedGSR(100, 1, 0, RESISTANCE);
  float conductanceVol = MySignals.getCalibratedGSR(100, 1, 0, VOLTAGE);

  Serial.print("Conductance : ");       
  Serial.print(conductance, 2);  
  Serial.println("");         

  Serial.print("Resistance : ");       
  Serial.print(resistance, 2);  
  Serial.println("");    

  Serial.print("Conductance Voltage : ");       
  Serial.print(conductanceVol, 4);  
  Serial.println("");

  Serial.print("\n");

  // wait for a second  
  delay(1000);            
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;
byte serialByte;

void setup() 
{
  Serial.begin(9600);
  MySignals.begin();
  Serial.println("Starting...");
}

void loop() {
  while (Serial.available()>0)
  {
    serialByte=Serial.read();

    if (serialByte=='C'){        
      while(1){        
        fanalog0 = MySignals.getGSR(CONDUCTANCE);  
        // Use the timer0 => 1 tick every 4 us
        time=(timer0_overflow_count << 8) + TCNT0;
        // Microseconds conversion.
        time=time*4;
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);
        if (Serial.available() > 0){
          serialByte=Serial.read();
          if (serialByte=='F')  break;
        }
      }
    }
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop() 
{

  int valRead = (uint16_t)MySignals.getGSR(DATA);
  Serial.println(valRead);  
  
  delay(20);
  
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>

#include "Wire.h"
#include "SPI.h" 



void setup() 
{
  Serial.begin(115200);  
  MySignals.begin();
}


void loop() 
{

  int valRead = (uint16_t)MySignals.getGSR(DATA);
  MySignals.printWave(valRead);  
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>


#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
    
  tft.init();
  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("GSR",5,5,4); 
}

void loop() 
{

  valRead = (uint16_t)MySignals.getGSR(DATA);
  Serial.println(valRead);
  valRead = map(valRead, 100, 250, graphic_low_extrem, graphic_high_extrem);
  
  printGraphic(valRead, 0);
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}

		

{
// Initializes the position sensor and configure some values
void initBodyPosition(void);
}
		

{

// Returns the body position 
//1 == Supine position
//2 == Left lateral decubitus
//3 == Rigth lateral decubitus
//4 == Prone position
//5 == Stand or sit position
uint8_t getBodyPosition(void);

// Prints the current body position
void printPosition(uint8_t position);

// Prints the current body position acceleration
void getAcceleration();
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h" 


void setup() 
{ 
  Serial.begin(115200); 
  MySignals.begin();
  MySignals.initBodyPosition();

} 


void loop() 
{ 
  uint8_t position = MySignals.getBodyPosition(); 
  Serial.print("Current position : ");
  //print body position
  MySignals.printPosition(position); 
  delay(100);
   
  //print acc values
  MySignals.getAcceleration();
  
  // convert float to strintg
  char bufferAcc[50];
  char x_acc_string[10];  
  char y_acc_string[10];
  char z_acc_string[10];
  dtostrf (MySignals.x_data, 2, 2, x_acc_string); 
  dtostrf (MySignals.y_data, 2, 2, y_acc_string);
  dtostrf (MySignals.z_data, 2, 2, z_acc_string);
			
  // print the X Y Z acceleration
  sprintf (bufferAcc, "Acceleration: X= %s  Y= %s  Z= %s  ", x_acc_string, y_acc_string, z_acc_string);
  Serial.println(bufferAcc);
			
  delay(1000);
  
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
  MySignals.initBodyPosition();
   
  tft.init();   
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
 

}

void loop() 
{
  tft.drawString("Body position:", 0, 0, 2);
  uint8_t position = MySignals.getBodyPosition(); 
  
   if (position == 1)
  {
    tft.drawString("Prone position", 0, 30, 2);
  }
  else if (position == 2)
  {
    tft.drawString("Left lateral   ", 0, 30, 2);
  }
  else if (position == 3)
  {
    tft.drawString("Rigth lateral  ", 0, 30, 2);
  }
  else if (position == 4)
  {
    tft.drawString("Supine position ", 0, 30, 2);
  }
  else if (position == 5)
  {
   tft.drawString("Stand or sit     ", 0, 30, 2);
  }
  else
  {
   tft.drawString("non-defined       ", 0, 30, 2);
  }
  
   
  SPI.end();
}
		

{
// Initializes the snore sensor and configures the snore amplification gain
void initSnore(uint8_t gain);
}
		

{
// Configures the snore amplification gain
void setSnoreGain(uint8_t gain);
}
		

{

// Returns Snore value in a specific format
//(VOLTAGE) - in Volts (0-5V)
//(DATA)    - in digital value (0-1023)
float getSnore(uint8_t format);

// Returns Snore in DATA format
float getSnore(void);

// Returns Snore value after applying measuring filter
float getCalibratedSnore(uint8_t samples, uint16_t delaySample, float offset, uint8_t format);

// Calculates Snore SPM
void snoreSPM(void);
}
		

{
// Reproduces a tone in a specific frequency and duration in the snore sensor earphone
void playSoundSnore(uint16_t frequency, uint16_t duration);

// Gets the state of the digital button in snore sensor
bool getButtonSnore(void);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 

  MySignals.initSnore(30);
}


void loop() 
{

  float snore = MySignals.getSnore(VOLTAGE);

  Serial.print("Snore value :  ");
  Serial.print(snore, 2);
  Serial.println(" V");  
  

  delay(10);	
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 

  MySignals.initSnore(30);
}


void loop() 
{
  float snore = MySignals.getCalibratedSnore(5,0,0,DATA);

  Serial.print("Snore value :  ");
  Serial.print(snore, 2);
  Serial.println(" V");  


  delay(10);	
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/
#include <MyHospital.h> 

#include "Wire.h"
#include "SPI.h" 

extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;


byte serialByte;
void setup() 
{
  Serial.begin(9600);
  MySignals.begin();
    
  Serial.println("Starting...");
   
  MySignals.initSnore(30);
}

void loop() 
{ 
  while (Serial.available()>0)
  {  
    serialByte=Serial.read();
    if (serialByte=='C'){        
      while(1){
        fanalog0=MySignals.getSnore(DATA);  
        // Use the timer0 => 1 tick every 4 us
        time=(timer0_overflow_count << 8) + TCNT0;        
        // Microseconds conversion.
        time=(time*4);   
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);

        if (Serial.available()>0){
          serialByte=Serial.read();
          if (serialByte=='F')  break;
        }
      }
    }
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200);
  MySignals.begin();
  
  
  MySignals.initSnore(30);
}


void loop() 
{

  uint16_t snore = MySignals.getSnore(DATA);
 
  Serial.println(snore);
  
  delay(20);
  
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 



void setup() 
{
  Serial.begin(115200);  
  MySignals.begin(); 
  MySignals.initSnore(0);
}


void loop() 
{

  float snore = MySignals.getSnore(DATA);
  MySignals.printWave(snore);   
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();

  MySignals.initSnore(40);
      
  tft.init();
  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("Snore",5,5,4); 
}

void loop() 
{

  valRead = (uint16_t)MySignals.getSnore(DATA);
    
  valRead = map(valRead, 0, 1023, 230, 30);
  
  printGraphic(valRead, 0);
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
 Serial.begin(115200);
 MySignals.begin(); 
}

void loop() 
{
  if(MySignals.getButtonSnore() == LOW)
  {
    Serial.println("Button pressed");
    delay(10);
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
  MySignals.begin(); 
}

void loop() 
{

  MySignals.playSoundSnore(200,100);
 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

void setup() 
{
  Serial.begin(115200);
  MySignals.begin(); 

  int gain = 30;
  MySignals.initSnore(gain);
  
  Serial.print(F("Gain:"));
  Serial.println(gain);
}


void loop() 
{


 
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_SCALE[14] = "8CDE5260BCEF";

//Scale User profile
uint8_t user_gender = 1;   //1-Male    0-Female
uint8_t user_height = 175; //in cm (0-255)
uint8_t user_age = 29;     //(0-255)



uint8_t available_scale = 0;
uint8_t connected_scale = 0;
uint8_t connection_handle_scale = 0;


#define SCALE_HANDLE 83
#define SCALE_PROFILE_HANDLE 85


//!Struct to store data of the glucometer.
struct scaleDataVector
{
  uint16_t weight;
  uint16_t bodyfat;
  uint16_t musclemass;
  uint16_t water;
  uint16_t calories;
  uint8_t visceralfat;
  uint8_t bonemass;
};

//!Vector to store the glucometer measures and dates.
scaleDataVector scaleData;

void setup()
{

  MySignals.begin();

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      MySignals.println("BLE init ok");
    }
    else
    {
      MySignals.println("BLE init fail");

      while (1)
      {
      };
    }
  }
  else
  {
    MySignals.println("BLE init fail");

    while (1)
    {
    };
  }



}

void loop()
{
  available_scale = MySignals_BLE.scanDevice(MAC_SCALE, 1000, TX_POWER_MAX);

  MySignals.disableMuxUART();
  Serial.print("Scale available:");
  Serial.println(available_scale);
  MySignals.enableMuxUART();


  if (available_scale == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_SCALE) == 1)
    {
      MySignals.println("Connected");

      connected_scale = 1;
      delay(500);

      uint8_t attributeData[2] =
      {
        0x01 , 0x00
      };
      if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_HANDLE, attributeData, 2) == 0)
      {

        MySignals.println("Subscribed");

        delay(4000);

        uint8_t scale_user_profile[8] =
        {
          0xfe,  // 0  BYTE 1
          0x00,  // 1  BYTE 2 -> user group
          0x00,  // 2  BYTE 3 -> gender
          0x00,  // 3  BYTE 4 -> level
          0x00,  // 4  BYTE 5 -> height
          0x00,  // 5  BYTE 6 -> age
          0x00,  // 6  BYTE 7 -> unit
          0x00   // 7  BYTE 8 -> xor
        };

        scale_user_profile[1] = 1;              // User group
        scale_user_profile[2] = user_gender;    // gender: 1=male, 0=female
        scale_user_profile[3] = 0;              // level 0=normal
        scale_user_profile[4] = user_height;    // height
        scale_user_profile[5] = user_age;       // age
        scale_user_profile[6] = 1;              // unit KG


        uint8_t xor_result = scale_user_profile[1] xor scale_user_profile[2];
        xor_result = xor_result xor scale_user_profile[3];
        xor_result = xor_result xor scale_user_profile[4];
        xor_result = xor_result xor scale_user_profile[5];
        scale_user_profile[7] = xor_result xor scale_user_profile[6];


        if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_PROFILE_HANDLE, scale_user_profile, 8) == 0)
        {
          delay(500);

          unsigned long previous = millis();
          do
          {
            if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
            {

              uint8_t scale_weight_high = MySignals_BLE.event[13];
              uint8_t scale_weight_low = MySignals_BLE.event[14];

              uint8_t scale_bodyfat_high = MySignals_BLE.event[15];
              uint8_t scale_bodyfat_low = MySignals_BLE.event[16];

              uint8_t scale_musclemass_high = MySignals_BLE.event[18];
              uint8_t scale_musclemass_low = MySignals_BLE.event[19];

              scaleData.visceralfat = MySignals_BLE.event[20];

              uint8_t scale_water_high = MySignals_BLE.event[21];
              uint8_t scale_water_low = MySignals_BLE.event[22];

              uint8_t scale_calories_high = MySignals_BLE.event[23];
              uint8_t scale_calories_low = MySignals_BLE.event[24];


              scaleData.weight = (scale_weight_high * 256) + scale_weight_low;
              scaleData.bodyfat = (scale_bodyfat_high * 256) + scale_bodyfat_low;
              scaleData.musclemass = (scale_musclemass_high * 256) + scale_musclemass_low;
              scaleData.water = (scale_water_high * 256) + scale_water_low;
              scaleData.calories = (scale_calories_high * 256) + scale_calories_low;

              scaleData.bonemass = MySignals_BLE.event[17] * 1000 / scaleData.weight;

              MySignals.disableMuxUART();
              
              Serial.println();
              Serial.print(F("Weight: "));
              Serial.print((float(scaleData.weight) / 10), 1);
              Serial.println(F("Kg"));

              Serial.print(F("Body fat: "));
              Serial.print((float(scaleData.bodyfat) / 10), 1);
              Serial.println(F("%"));

              Serial.print(F("Bone mass: "));
              Serial.print((float(scaleData.bonemass) / 10), 1);
              Serial.println(F("%"));

              Serial.print(F("Muscle mass: "));
              Serial.print((float(scaleData.musclemass) / 10), 1);
              Serial.println(F("%"));

              Serial.print(F("Visceral fat: "));
              Serial.print(scaleData.visceralfat);
              Serial.println(F("%"));

              Serial.print(F("Water percentage: "));
              Serial.print((float(scaleData.water) / 10), 1);
              Serial.println(F("%"));

              Serial.print(F("Calories: "));
              Serial.print(scaleData.calories);
              Serial.println(F("Kcal"));
              
              MySignals.enableMuxUART();

              delay(1000);

              uint8_t shutdown_command[8] =
              {
                0xfd, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35
              };

              MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_PROFILE_HANDLE, shutdown_command, 8);

              MySignals_BLE.disconnect(MySignals_BLE.connection_handle);

              delay(200);

              connected_scale = 0;
            }
          }
          while ((connected_scale == 1) && ((millis() - previous) < 20000));

          connected_scale = 0;

        }
        else
        {
          MySignals.println("Error subscribing");
        }
      }
      else
      {
        MySignals.println("Error subscribing");
      }
    }
    else
    {
      connected_scale = 0;
      MySignals.println("Not Connected");
    }
  }
  else if (available_scale == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_SCALE[14] = "8CDE5260BCEF";

//Scale User profile
uint8_t user_gender = 1;   //1-Male    0-Female
uint8_t user_height = 175; //in cm (0-255)
uint8_t user_age = 29;     //(0-255)



uint8_t available_scale = 0;
uint8_t connected_scale = 0;
uint8_t connection_handle_scale = 0;


#define SCALE_HANDLE 83
#define SCALE_PROFILE_HANDLE 85

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

//!Struct to store data of the glucometer.
struct scaleDataVector
{
  uint16_t weight;
  uint16_t bodyfat;
  uint16_t musclemass;
  uint16_t water;
  uint16_t calories;
  uint8_t visceralfat;
  uint8_t bonemass;
};

//!Vector to store the glucometer measures and dates.
scaleDataVector scaleData;

void setup()
{

  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();



  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }


}

void loop()
{
  available_scale = MySignals_BLE.scanDevice(MAC_SCALE, 1000, TX_POWER_MAX);

  tft.drawString("Scale available:", 0, 30, 2);
  tft.drawNumber(available_scale, 110, 30, 2);



  if (available_scale == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_SCALE) == 1)
    {
      tft.drawString("Connected    ", 0, 45, 2);
      connected_scale = 1;
      delay(500);

      uint8_t attributeData[2] =
      {
        0x01 , 0x00
      };
      if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_HANDLE, attributeData, 2) == 0)
      {

        tft.drawString("Subscribed", 0, 60, 2);

        delay(4000);

        uint8_t scale_user_profile[8] =
        {
          0xfe,  // 0  BYTE 1
          0x00,  // 1  BYTE 2 -> user group
          0x00,  // 2  BYTE 3 -> gender
          0x00,  // 3  BYTE 4 -> level
          0x00,  // 4  BYTE 5 -> height
          0x00,  // 5  BYTE 6 -> age
          0x00,  // 6  BYTE 7 -> unit
          0x00   // 7  BYTE 8 -> xor
        };

        scale_user_profile[1] = 1;              // User group
        scale_user_profile[2] = user_gender;    // gender: 1=male, 0=female
        scale_user_profile[3] = 0;              // level 0=normal
        scale_user_profile[4] = user_height;    // height
        scale_user_profile[5] = user_age;       // age
        scale_user_profile[6] = 1;              // unit KG


        uint8_t xor_result = scale_user_profile[1] xor scale_user_profile[2];
        xor_result = xor_result xor scale_user_profile[3];
        xor_result = xor_result xor scale_user_profile[4];
        xor_result = xor_result xor scale_user_profile[5];
        scale_user_profile[7] = xor_result xor scale_user_profile[6];

        if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_PROFILE_HANDLE, scale_user_profile, 8) == 0)
        {
          delay(500);



          unsigned long previous = millis();
          do
          {
            if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
            {

              uint8_t scale_weight_high = MySignals_BLE.event[13];
              uint8_t scale_weight_low = MySignals_BLE.event[14];

              uint8_t scale_bodyfat_high = MySignals_BLE.event[15];
              uint8_t scale_bodyfat_low = MySignals_BLE.event[16];



              uint8_t scale_musclemass_high = MySignals_BLE.event[18];
              uint8_t scale_musclemass_low = MySignals_BLE.event[19];

              scaleData.visceralfat = MySignals_BLE.event[20];

              uint8_t scale_water_high = MySignals_BLE.event[21];
              uint8_t scale_water_low = MySignals_BLE.event[22];

              uint8_t scale_calories_high = MySignals_BLE.event[23];
              uint8_t scale_calories_low = MySignals_BLE.event[24];


              scaleData.weight = (scale_weight_high * 256) + scale_weight_low;
              scaleData.bodyfat = (scale_bodyfat_high * 256) + scale_bodyfat_low;
              scaleData.musclemass = (scale_musclemass_high * 256) + scale_musclemass_low;
              scaleData.water = (scale_water_high * 256) + scale_water_low;
              scaleData.calories = (scale_calories_high * 256) + scale_calories_low;

              scaleData.bonemass = MySignals_BLE.event[17] * 1000 / scaleData.weight;


              tft.drawString("Weight:", 0, 75, 2);
              tft.drawFloat((scaleData.weight / 10.0), 1, 100, 75, 2);

              tft.drawString("Body fat:", 0, 90, 2);
              tft.drawFloat((scaleData.bodyfat / 10.0), 1, 100, 90, 2);

              tft.drawString("Muscle mass:", 0, 105, 2);
              tft.drawFloat((scaleData.musclemass / 10.0), 1, 100, 105, 2);

              tft.drawString("Visceral fat:", 0, 120, 2);
              tft.drawNumber(scaleData.visceralfat, 100, 120, 2);

              tft.drawString("Water:", 0, 135, 2);
              tft.drawFloat((scaleData.water / 10.0), 1, 100, 135, 2);

              tft.drawString("Calories:", 0, 150, 2);
              tft.drawNumber(scaleData.calories, 100, 150, 2);

              tft.drawString("Bone mass:", 0, 165, 2);
              tft.drawFloat((scaleData.bonemass / 10.0), 1, 100, 165, 2);

              delay(1000);

              uint8_t shutdown_command[8] =
              {
                0xfd, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35
              };

              MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, SCALE_PROFILE_HANDLE, shutdown_command, 8);

              MySignals_BLE.disconnect(MySignals_BLE.connection_handle);

              delay(200);

              connected_scale = 0;
            }
          }
          while ((connected_scale == 1) && ((millis() - previous) < 20000));

          connected_scale = 0;

        }
        else
        {
          tft.drawString("Error subscribing", 0, 60, 2);
        }
      }
      else
      {
        tft.drawString("Not Connected", 0, 45, 2);
      }
    }
    else
    {
      connected_scale = 0;
      tft.drawString("Not Connected", 0, 45, 2);
    }
  }
  else if (available_scale == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_SPO2[14] = "00A0500E1823";


uint8_t available_spo2 = 0;
uint8_t connected_spo2 = 0;
uint8_t connection_handle_spo2 = 0;
uint8_t pulse_spo2 = 0;
uint8_t spo2 = 0;

#define SPO2_HANDLE 15

void setup()
{
  MySignals.begin();

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      MySignals.println("BLE init ok");
    }
    else
    {
      MySignals.println("BLE init fail");

      while (1)
      {
      };
    }
  }
  else
  {
    MySignals.println("BLE init fail");

    while (1)
    {
    };
  }

}

void loop()
{
  available_spo2 = MySignals_BLE.scanDevice(MAC_SPO2, 1000, TX_POWER_MAX);

  MySignals.disableMuxUART();
  Serial.print("SPO2 available:");
  Serial.println(available_spo2);
  MySignals.enableMuxUART();

  if (available_spo2 == 1)
  {
    MySignals.disableMuxUART();
    Serial.println("SPO2 found.Connecting");
    MySignals.enableMuxUART();


    if (MySignals_BLE.connectDirect(MAC_SPO2) == 1)
    {
      connected_spo2 = 1;
      connection_handle_spo2 = MySignals_BLE.connection_handle;

      MySignals.println("Connected");

      delay(6000);

      //To subscribe the spo2 measure write "1" in SPO2_HANDLE
      char attributeData[1] =
      {
        0x01
      };

      if (MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData, 1) == 0)
      {
        unsigned long previous = millis();
        do
        {
          if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
          {


            char attributeData[1] = {  0x00 };

            MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData , 1);

            uint8_t pulse_low = MySignals_BLE.event[12];
            pulse_low &= 0b01111111;

            uint8_t pulse_high = MySignals_BLE.event[11];
            pulse_high &= 0b01000000;

            if (pulse_high == 0)
            {
              pulse_spo2 = pulse_low;
            }

            if (pulse_high == 0b01000000)
            {
              pulse_spo2 = pulse_low + 0b10000000;
            }

            spo2 = MySignals_BLE.event[13];
            spo2 &= 0b01111111;

            if ((pulse_spo2 >= 25) && (pulse_spo2 <= 250)
                && (pulse_spo2 >= 35) && (pulse_spo2 <= 100))
            {
              MySignals.disableMuxUART();

              Serial.println();
              Serial.print(F("SpO2: "));
              Serial.print(spo2);
              Serial.print(F("%  "));
              Serial.print(F("Pulse: "));
              Serial.print(pulse_spo2);
              Serial.println(F("ppm  "));

              uint16_t errorCode = MySignals_BLE.disconnect(connection_handle_spo2);

              Serial.print(F("Disconnecting error code: "));
              Serial.println(errorCode, HEX);

              MySignals.enableMuxUART();
              connected_spo2 = 0;

            }
          }
        }
        while ((connected_spo2 == 1) && ((millis() - previous) < 10000));

        connected_spo2 = 0;

      }
      else
      {
        MySignals.println("Error subscribing");
      }
    }
    else
    {
      connected_spo2 = 0;

      MySignals.println("Not Connected");
    }
  }
  else if (available_spo2 == 0)
  {
    //Do nothing
  }
  else
  {
    
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);
    
  }


  delay(1000);
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_SPO2[14] = "00A0500E1823";


uint8_t available_spo2 = 0;
uint8_t connected_spo2 = 0;
uint8_t connection_handle_spo2 = 0;
uint8_t pulse_spo2 = 0;
uint8_t spo2 = 0;

#define SPO2_HANDLE 15

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

void setup()
{

  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();



  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }


}

void loop()
{
  available_spo2 = MySignals_BLE.scanDevice(MAC_SPO2, 1000, TX_POWER_MAX);

  tft.drawString("SPO2 available:", 0, 30, 2);
  tft.drawNumber(available_spo2, 110, 30, 2);



  if (available_spo2 == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_SPO2) == 1)
    {
      connected_spo2 = 1;
      connection_handle_spo2 = MySignals_BLE.connection_handle;

      tft.drawString("Connected    ", 0, 45, 2);


      delay(6000);

      //To subscribe the spo2 measure write "1" in SPO2_HANDLE
      char attributeData[1] =
      {
        0x01
      };

      if (MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData, 1) == 0)
      {
        tft.drawString("Subscribed", 0, 60, 2);

        unsigned long previous = millis();
        do
        {
          if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
          {


            char attributeData[1] = {  0x00 };

            MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData , 1);


            uint8_t pulse_low = MySignals_BLE.event[12];
            pulse_low &= 0b01111111;

            uint8_t pulse_high = MySignals_BLE.event[11];
            pulse_high &= 0b01000000;

            if (pulse_high == 0)
            {
              pulse_spo2 = pulse_low;
            }

            if (pulse_high == 0b01000000)
            {
              pulse_spo2 = pulse_low + 0b10000000;
            }

            spo2 = MySignals_BLE.event[13];
            spo2 &= 0b01111111;

            if ((pulse_spo2 >= 25) && (pulse_spo2 <= 250)
                && (pulse_spo2 >= 35) && (pulse_spo2 <= 100))
            {

              sprintf(buffer_tft, "Pulse: %d ppm / SPO2: %d", pulse_spo2, spo2);
              tft.drawString(buffer_tft, 0, 75, 2);



              uint16_t errorCode = MySignals_BLE.disconnect(connection_handle_spo2);
              tft.drawString("Disconnected", 0, 45, 2);

              connected_spo2 = 0;

            }
          }
        }
        while ((connected_spo2 == 1) && ((millis() - previous) < 10000));

        connected_spo2 = 0;

      }
      else
      {
        tft.drawString("Error subscribing", 0, 60, 2);
      }
    }
    else
    {
      connected_spo2 = 0;

      tft.drawString("Not Connected", 0, 45, 2);
    }
  }
  else if (available_spo2 == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_BP[14] = "A4D57812A409";


uint8_t available_bp = 0;
uint8_t connected_bp = 0;
uint8_t connection_handle_bp = 0;

#define BP_HANDLE 18



//!Struct to store data of the glucometer.
struct bloodPressureBLEDataVector
{
  uint16_t systolic;
  uint16_t diastolic;
  uint16_t pulse;
};

//!Vector to store the glucometer measures and dates.
bloodPressureBLEDataVector bloodPressureBLEData;

void setup()
{

  MySignals.begin();

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();

  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      MySignals.println("BLE init ok");
    }
    else
    {
      MySignals.println("BLE init fail");

      while (1)
      {
      };
    }
  }
  else
  {
    MySignals.println("BLE init fail");

    while (1)
    {
    };
  }

}

void loop()
{
  available_bp = MySignals_BLE.scanDevice(MAC_BP, 1000, TX_POWER_MAX);

  MySignals.disableMuxUART();
  Serial.print("BP available:");
  Serial.println(available_bp);
  MySignals.enableMuxUART();


  if (available_bp == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_BP) == 1)
    {
      MySignals.println("Connected");
      
      connected_bp = 1;
      delay(8000);
      //To subscribe the BP measure write an ASCII letter "e"
      if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle,  BP_HANDLE, "e", 1) == 0)
      {

       MySignals.println("Subscribed");

        unsigned long previous = millis();
        do
        {

          if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
          {
            //Search letter "g" in ASCII
            if (MySignals_BLE.event[9] == 0x67)
            {

              if (MySignals_BLE.event[10] == 0x2f)
              {
                //Ojo esto esta mal en la guia de comandos

                //Primero da la alta -> sistolica
                uint8_t sh = MySignals_BLE.event[11] - 48;
                uint8_t sm = MySignals_BLE.event[12] - 48;
                uint8_t sl = MySignals_BLE.event[13] - 48;
                bloodPressureBLEData.systolic = (sh * 100) + (sm * 10) + sl;

                //Primero da la baja -> diastolica
                uint8_t dh = MySignals_BLE.event[15] - 48;
                uint8_t dm = MySignals_BLE.event[16] - 48;
                uint8_t dl = MySignals_BLE.event[17] - 48;
                bloodPressureBLEData.diastolic = (dh * 100) + (dm * 10) + dl;

                uint8_t ph = MySignals_BLE.event[19] - 48;
                uint8_t pm = MySignals_BLE.event[20] - 48;
                uint8_t pl = MySignals_BLE.event[21] - 48;
                bloodPressureBLEData.pulse = (ph * 100) + (pm * 10) + pl;


                MySignals.disableMuxUART();
                Serial.print(F("Systolic: "));
                Serial.println(bloodPressureBLEData.systolic);

                Serial.print(F("Diastolic: "));
                Serial.println( bloodPressureBLEData.diastolic);

                Serial.print(F("Pulse/min: "));
                Serial.println(bloodPressureBLEData.pulse);
                Serial.println(F("Disconnected from device"));

                MySignals.enableMuxUART();
                
                connected_bp = 0;

              }
            }
          }
        }
        while ((connected_bp == 1) && ((millis() - previous) < 40000));


        MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle,  BP_HANDLE, "i" , 1);
        delay(100);


        MySignals_BLE.disconnect(MySignals_BLE.connection_handle);

        connected_bp = 0;

      }
      else
      {
        MySignals.println("Error subscribing");
      }

    }
    else
    {
      connected_bp = 0;
      MySignals.println("Not Connected");
    }
  }
  else if (available_bp == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_BP[14] = "A4D57812A409";


uint8_t available_bp = 0;
uint8_t connected_bp = 0;
uint8_t connection_handle_bp = 0;

#define BP_HANDLE 18

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

//!Struct to store data of the glucometer.
struct bloodPressureBLEDataVector
{
  uint16_t systolic;
  uint16_t diastolic;
  uint16_t pulse;
};

//!Vector to store the glucometer measures and dates.
bloodPressureBLEDataVector bloodPressureBLEData;

void setup()
{

  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();



  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }


}

void loop()
{
  available_bp = MySignals_BLE.scanDevice(MAC_BP, 1000, TX_POWER_MAX);

  tft.drawString("BP available:", 0, 30, 2);
  tft.drawNumber(available_bp, 110, 30, 2);



  if (available_bp == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_BP) == 1)
    {
      tft.drawString("Connected    ", 0, 45, 2);
      connected_bp = 1;
      delay(8000);
      //To subscribe the BP measure write an ASCII letter "e"
      if (MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle,  BP_HANDLE, "e", 1) == 0)
      {

        tft.drawString("Subscribed", 0, 60, 2);
        
        unsigned long previous = millis();
        do
        {

          if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
          {
            //Search letter "g" in ASCII
            if (MySignals_BLE.event[9] == 0x67)
            {

              if (MySignals_BLE.event[10] == 0x2f)
              {
                //Ojo esto esta mal en la guia de comandos

                //Primero da la alta -> sistolica
                uint8_t sh = MySignals_BLE.event[11] - 48;
                uint8_t sm = MySignals_BLE.event[12] - 48;
                uint8_t sl = MySignals_BLE.event[13] - 48;
                bloodPressureBLEData.systolic = (sh * 100) + (sm * 10) + sl;

                //Primero da la baja -> diastolica
                uint8_t dh = MySignals_BLE.event[15] - 48;
                uint8_t dm = MySignals_BLE.event[16] - 48;
                uint8_t dl = MySignals_BLE.event[17] - 48;
                bloodPressureBLEData.diastolic = (dh * 100) + (dm * 10) + dl;

                uint8_t ph = MySignals_BLE.event[19] - 48;
                uint8_t pm = MySignals_BLE.event[20] - 48;
                uint8_t pl = MySignals_BLE.event[21] - 48;
                bloodPressureBLEData.pulse = (ph * 100) + (pm * 10) + pl;


                sprintf(buffer_tft, "S:%d D:%d P:%d      ", bloodPressureBLEData.systolic, bloodPressureBLEData.diastolic, bloodPressureBLEData.pulse);
                tft.drawString(buffer_tft, 0, 75, 2);

                connected_bp = 0;

              }
            }
          }
        }
        while ((connected_bp == 1) && ((millis() - previous) < 40000));


        MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle,  BP_HANDLE, "i" , 1);
        delay(100);


        MySignals_BLE.disconnect(MySignals_BLE.connection_handle);

        connected_bp = 0;

      }
      else
      {
        tft.drawString("Error subscribing", 0, 60, 2);
      }

    }
    else
    {
      connected_bp = 0;
      tft.drawString("Not Connected", 0, 45, 2);
    }
  }
  else if (available_bp == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);
    
  }
  delay(1000);
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <MySignals_BLE.h>

#define GLUCO_HANDLE1 99
#define GLUCO_HANDLE2 83

// Write here the MAC address of BLE device to find
char MAC_GLUCO[14] = "187A93001030";

uint8_t available_gluco = 0;
uint8_t connected_gluco = 0;
uint8_t connection_handle_gluco = 0;

//!Struct to store data of the glucometer.
struct glucometerBLEDataVector
{
  uint16_t glucose;
  uint8_t info;
};

//!Vector to store the glucometer measures and dates.
glucometerBLEDataVector glucometerBLEData;

void setup()
{

  MySignals.begin();

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      MySignals.println("BLE init ok");
    }
    else
    {
      MySignals.println("BLE init fail");

      while (1)
      {
      };
    }
  }
  else
  {
    MySignals.println("BLE init fail");

    while (1)
    {
    };
  }

}

void loop()
{
  available_gluco = MySignals_BLE.scanDevice(MAC_GLUCO, 1000, TX_POWER_MAX);

  MySignals.disableMuxUART();
  Serial.print(F("Gluco available:"));
  Serial.println(available_gluco);
  MySignals.enableMuxUART();


  if (available_gluco == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_GLUCO) == 1)
    {
      MySignals.println("Connected");
      connected_gluco = 1;

      uint8_t gluco_subscribe_message[2] = { 0x01 , 0x00 };
      delay(200);

      MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, GLUCO_HANDLE1, gluco_subscribe_message, 2);
      MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, GLUCO_HANDLE2, gluco_subscribe_message, 2);
      
      delay(200);
      MySignals.println("Insert blood stripe (20s)");

      unsigned long previous = millis();
      do
      {
        if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
        {
          MySignals.disableMuxUART();
          Serial.print(F("Glucose(mg/dl):"));

          if (MySignals_BLE.event[8] == 0x0c)
          {
            uint8_t gh = MySignals_BLE.event[12] - 48;
            uint8_t gl = MySignals_BLE.event[13] - 48;
            glucometerBLEData.glucose = (gh * 10) + gl;
            glucometerBLEData.info = 0;

            Serial.println(glucometerBLEData.glucose);
          }
          if (MySignals_BLE.event[8] == 0x0d)
          {

            uint8_t gh = MySignals_BLE.event[12] - 48;
            uint8_t gm = MySignals_BLE.event[13] - 48;
            uint8_t gl = MySignals_BLE.event[14] - 48;
            glucometerBLEData.glucose = (gh * 100) + (gm * 10) + gl;
            glucometerBLEData.info = 0;

            Serial.println(glucometerBLEData.glucose);
          }
          if (MySignals_BLE.event[8] == 0x0e)
          {
            if (MySignals_BLE.event[12] == 0x4c)
            {
              glucometerBLEData.glucose = 0;
              glucometerBLEData.info = 0xAA;
              
              Serial.println(F("Low glucose"));
            }
            else if (MySignals_BLE.event[12] == 0x48)
            {
              glucometerBLEData.glucose = 360;
              glucometerBLEData.info = 0xBB;
              
              Serial.println(F("High glucose"));
             
            }

          }

          MySignals_BLE.disconnect(MySignals_BLE.connection_handle);
          connected_gluco = 0;
        }

      }
      while ((connected_gluco == 1) && ((millis() - previous) < 20000)); //Timeout 20 seconds

      connected_gluco = 0;



    }
    else
    {
      connected_gluco = 0;
      MySignals.println("Not Connected");
    }


  }
  else if (available_gluco == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>


#define GLUCO_HANDLE1 99
#define GLUCO_HANDLE2 83

// Write here the MAC address of BLE device to find
char MAC_GLUCO[14] = "187A93001030";

uint8_t available_gluco = 0;
uint8_t connected_gluco = 0;
uint8_t connection_handle_gluco = 0;

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

//!Struct to store data of the glucometer.
struct glucometerBLEDataVector
{
  uint16_t glucose;
  uint8_t info;

};


//!Vector to store the glucometer measures and dates.
glucometerBLEDataVector glucometerBLEData;

void setup()
{

  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();



  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }
}

void loop()
{
  available_gluco = MySignals_BLE.scanDevice(MAC_GLUCO, 1000, TX_POWER_MAX);

  tft.drawString("Gluco available:", 0, 30, 2);
  tft.drawNumber(available_gluco, 110, 30, 2);



  if (available_gluco == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_GLUCO) == 1)
    {
      tft.drawString("Connected", 0, 45, 2);
      connected_gluco = 1;

      uint8_t gluco_subscribe_message[2] = { 0x01 , 0x00 };
      delay(200);

      MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, GLUCO_HANDLE1, gluco_subscribe_message, 2);
      MySignals_BLE.attributeWrite(MySignals_BLE.connection_handle, GLUCO_HANDLE2, gluco_subscribe_message, 2);
      
      delay(200);
      tft.drawString("Insert blood stripe (20s)", 0, 60, 2);
      //Serial.println(F("Waiting 20 seconds for a blood stripe"));

      unsigned long previous = millis();
      do
      {
        if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
        {

          tft.drawString("Glucose(mg/dl):", 0, 75, 2);

          if (MySignals_BLE.event[8] == 0x0c)
          {
            uint8_t gh = MySignals_BLE.event[12] - 48;
            uint8_t gl = MySignals_BLE.event[13] - 48;
            glucometerBLEData.glucose = (gh * 10) + gl;
            glucometerBLEData.info = 0;

            tft.drawNumber(glucometerBLEData.glucose, 120, 75, 2);
          }
          if (MySignals_BLE.event[8] == 0x0d)
          {

            uint8_t gh = MySignals_BLE.event[12] - 48;
            uint8_t gm = MySignals_BLE.event[13] - 48;
            uint8_t gl = MySignals_BLE.event[14] - 48;
            glucometerBLEData.glucose = (gh * 100) + (gm * 10) + gl;
            glucometerBLEData.info = 0;

            tft.drawNumber(glucometerBLEData.glucose, 120, 75, 2);
          }
          if (MySignals_BLE.event[8] == 0x0e)
          {
            if (MySignals_BLE.event[12] == 0x4c)
            {
              glucometerBLEData.glucose = 0;
              glucometerBLEData.info = 0xAA;
              //Serial.println(F("LOW GLUCOSE"));

              tft.drawString("Low", 120, 75, 2);
            }
            else if (MySignals_BLE.event[12] == 0x48)
            {
              glucometerBLEData.glucose = 360;
              glucometerBLEData.info = 0xBB;
              //Serial.println(F("HIGH GLUCOSE"));
              tft.drawString("High", 120, 75, 2);
            }

          }

          MySignals_BLE.disconnect(MySignals_BLE.connection_handle);
          connected_gluco = 0;
        }

      }
      while ((connected_gluco == 1) && ((millis() - previous) < 20000)); //Timeout 20 seconds

      connected_gluco = 0;



    }
    else
    {
      connected_gluco = 0;
      tft.drawString("Not Connected", 0, 45, 2);
    }


  }
  else if (available_gluco == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"

int8_t answer;


void setup()
{
  //Serial.begin(57600); // Communication mode baudrate with mindwave
  Serial.begin(38400);   // AT mode in HC-05 is always at this baudrate
  
  //You can use the configuration examples with the correct
  //AT+UART=**** command in order to change the baudrate

  MySignals.begin();
  
  /*
    expanderState is initialized with B10000001

    Expansor pin library names:

    EXP_3G_ON
    EXP_TOUCH_CS
    EXP_BT_POWER
    EXP_BT_KEY
    EXP_ADC_CS
    EXP_SNORE_POT
    EXP_RESET_BLE
    EXP_WIFI_ON
  */
  
  //Enable BT2.0 module power -> bit2:1
  bitSet(MySignals.expanderState, EXP_BT_POWER);    
  //Enable BT2.0 Key to AT mode -> bit3:0
  bitClear(MySignals.expanderState, EXP_BT_KEY);  
  MySignals.expanderWrite(MySignals.expanderState);

  //Reset the module to enter command mode
  
  //Disable BT2.0 module power -> bit2:0
  bitClear(MySignals.expanderState, EXP_BT_POWER);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);

  //Enable BT2.0 module power -> bit2:1
  bitSet(MySignals.expanderState, EXP_BT_POWER);    
  MySignals.expanderWrite(MySignals.expanderState);
  
  delay(1000);
  
  MySignals.initSensorUART();
  MySignals.enableSensorUART(EEG);
  //After enabling UART EEG you always need to intilize the UART at the right baudrate
  Serial.begin(38400);  // AT mode in HC-05 is always at this baudrate

  delay(1000);
  // Checks if the BT module is started
  answer = sendATcommand("AT", "OK", 6000);
  if (answer == 0)
  {
    MySignals.println("Error");
    // waits for an answer from the module
    while (answer == 0)
    {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 6000);
    }
  }
  else if (answer == 1)
  {
    MySignals.println("BT HC05 succesfully working!");
  }
  
  //You better first try these commands via Gateway in a serial communication
  //program like Cutecom

  sendATcommand("AT+UART=57600,0,0", "0K", 2000);
  delay(5000);

  sendATcommand("AT+ROLE=1", "0K", 2000);
  delay(5000);

  sendATcommand("AT+PSWD=0000", "0K", 2000);
  delay(5000);

  sendATcommand("AT+CMODE=0", "0K", 2000);
  delay(5000);

  //Write you mindwave MAC for example: AT+PAIR=2068,9D,3F4DD1
  sendATcommand("AT+BIND=****,**,******", "0K", 2000); 
  delay(5000);

  sendATcommand("AT+INIT", "0K", 2000);
  delay(5000);

  sendATcommand("AT+IAC=9E8B33", "0K", 2000);
  delay(5000);

  sendATcommand("AT+CLASS=0", "0K", 2000);
  delay(5000);

  sendATcommand("AT+INQM=1,9,48", "0K", 2000);
  delay(5000);

  //Scan for BT devices MACS
  sendATcommand("AT+INQ", "0K", 2000);
  delay(20000);

  //For example: AT+PAIR=2068,9D,3F4DD1,20
  sendATcommand("AT+PAIR=****,**,******,20", "0K", 2000); //mindwave mac
  delay(10000);

  //For example: AT+LINK=2068,9D,3F4DD1
  sendATcommand("AT+LINK=****,**,****", "0K", 2000); //mindwave mac
  delay(10000);
}

void loop()
{

}


int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0)
    {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        MySignals.println(response);
      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

#define MAX_CONCENTRATION 300
#define REPETITION 3

int i;
int m;


byte generatedChecksum = 0;
byte checksum = 0;
byte payloadData[64] = {0};
byte poorQuality = 0;
byte attention = 0;
byte meditation = 0;
int  payloadLength = 0;
long lastReceivedPacket = 0;
boolean bigPacket = false;

byte aux, concentration;
uint8_t counter = 0;


void setup()
{

  MySignals.begin();
  
  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
  tft.drawString("Concentration:", 0, 0, 2);
  
  Serial.begin(57600);     // Communication mode baudrate with mindwave
  //Serial.begin(38400);   // AT mode in HC-05 is always at this baudrate

  /*
    expanderState is initialized with B10000001

    Expansor pin library names:

    EXP_3G_ON
    EXP_TOUCH_CS
    EXP_BT_POWER
    EXP_BT_KEY
    EXP_ADC_CS
    EXP_SNORE_POT
    EXP_RESET_BLE
    EXP_WIFI_ON
  */

  //Enable BT2.0 module power -> bit2:1
  bitSet(MySignals.expanderState, EXP_BT_POWER);
  //Enable BT2.0 Key to communication mode -> bit3:1
  bitSet(MySignals.expanderState, EXP_BT_KEY);
  MySignals.expanderWrite(MySignals.expanderState);

  //Reset the module to enter communication mode

  //Disable BT2.0 module power -> bit2:0
  bitClear(MySignals.expanderState, EXP_BT_POWER);
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  //Enable BT2.0 module power -> bit2:1
  bitSet(MySignals.expanderState, EXP_BT_POWER);
  MySignals.expanderWrite(MySignals.expanderState);

  delay(1000);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(EEG);
  //After enabling UART EEG you always need to intilize the UART at the right baudrate
  Serial.begin(57600);

  delay(1000);

  tft.drawNumber(concentration, 0, 30, 2);
}


void loop() 
{
  if (ReadOneByte() == 170) 
  {
    if (ReadOneByte() == 170) 
    {
      if (ReadOneByte() == 32) 
      {
        for (i = 0; i < 32; i++) 
        {
          aux = ReadOneByte();

          if (i == 28) 
          {
            concentration = ReadOneByte();
            tft.fillRect(0, 30, 40, 20, ILI9341_BLACK);
            tft.drawNumber(concentration, 0, 30, 2);

            if (concentration >= MAX_CONCENTRATION) 
            {
              counter++;
            }
            else
            {
              counter = 0;
            }
          }
        }
      }
    }
  }

  if (counter >= REPETITION)
  {
    counter = 0;

  }
}



byte ReadOneByte()
{
  int ByteRead;
  while (!Serial.available());
  ByteRead = Serial.read();
  return ByteRead;
}



int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0)
    {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        MySignals.println(response);
      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"



Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

//! It stores the current value of x position in the LCD.
uint16_t graphic_x = 0;
//! It stores the current value of the ECG or AirFlow sensor.
uint16_t valRead;
//! It stores the previous value of the ECG or AirFlow sensor.
uint16_t graphic_prevRead;

#define graphic_low_extrem 230
#define graphic_high_extrem 50
#define graphic_left_extrem 0
#define graphic_right_extrem 320



void setup()
{
  Serial.begin(115200);

  MySignals.begin();
  
  tft.init();

  tft.setRotation(3);
  
  tft.fillScreen(ILI9341_WHITE);
  tft.fillRect(0,0,320,30,ILI9341_RED);
  tft.setTextColor(ILI9341_WHITE); 
  tft.drawString("ECG",5,5,4); 

}


void loop()
{
  valRead = MySignals.getECG(DATA);
  //Serial.println(valRead);
  
  valRead = map(valRead, 150, 600, graphic_high_extrem, graphic_low_extrem);

  printGraphic(valRead,0);
  
  
}



void printGraphic(uint16_t value, uint8_t delay_time)
{

  if (value < graphic_high_extrem)
  {
    value = graphic_high_extrem;
  }
  if (value > graphic_low_extrem)
  {
    value = graphic_low_extrem;
  }


  //Pinta la linea solo a partir de que ya exista al menos 1 valor
  if (graphic_x > graphic_left_extrem + 1)
  {
    tft.drawLine(graphic_x - 1, graphic_prevRead, graphic_x, value, ILI9341_RED);
  }

  //Wave refresh (barre pantalla pintando una linea)
  tft.drawLine(graphic_x + 1, graphic_high_extrem, graphic_x + 1, graphic_low_extrem, ILI9341_WHITE);


  graphic_prevRead = value;
  graphic_x++;

  delay(delay_time);

  if (graphic_x == graphic_right_extrem)
  {
    graphic_x = graphic_left_extrem;
  }
  SPI.end();
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>

#define graphic_low_extrem 230
#define graphic_high_extrem 30
#define graphic_left_extrem 0
#define graphic_right_extrem 320


Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


//! It stores the current value of x position in the LCD.
uint16_t graphic_x;
//! It stores the current value of the MySignals. 
uint16_t valRead;
//! It stores the previous value of the MySignals. 
uint16_t graphic_prevRead;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.begin();
  MySignals.initBodyPosition();
   
  tft.init();   
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
 

}

void loop() 
{
  tft.drawString("Body position:", 0, 0, 2);
  uint8_t position = MySignals.getBodyPosition(); 
  
   if (position == 1)
  {
    tft.drawString("Prone position", 0, 30, 2);
  }
  else if (position == 2)
  {
    tft.drawString("Left lateral   ", 0, 30, 2);
  }
  else if (position == 3)
  {
    tft.drawString("Rigth lateral  ", 0, 30, 2);
  }
  else if (position == 4)
  {
    tft.drawString("Supine position ", 0, 30, 2);
  }
  else if (position == 5)
  {
   tft.drawString("Stand or sit     ", 0, 30, 2);
  }
  else
  {
   tft.drawString("non-defined       ", 0, 30, 2);
  }
  
   
  SPI.end();
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>


// Write here the MAC address of BLE device to find
char MAC_SPO2[14] = "00A0500E1823";


uint8_t available_spo2 = 0;
uint8_t connected_spo2 = 0;
uint8_t connection_handle_spo2 = 0;
uint8_t pulse_spo2 = 0;
uint8_t spo2 = 0;

#define SPO2_HANDLE 15

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

void setup()
{

  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);

  Serial.begin(115200);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();



  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }


}

void loop()
{
  available_spo2 = MySignals_BLE.scanDevice(MAC_SPO2, 1000, TX_POWER_MAX);

  tft.drawString("SPO2 available:", 0, 30, 2);
  tft.drawNumber(available_spo2, 110, 30, 2);



  if (available_spo2 == 1)
  {

    if (MySignals_BLE.connectDirect(MAC_SPO2) == 1)
    {
      connected_spo2 = 1;
      connection_handle_spo2 = MySignals_BLE.connection_handle;

      tft.drawString("Connected    ", 0, 45, 2);


      delay(6000);

      //To subscribe the spo2 measure write "1" in SPO2_HANDLE
      char attributeData[1] =
      {
        0x01
      };

      if (MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData, 1) == 0)
      {
        tft.drawString("Subscribed", 0, 60, 2);

        unsigned long previous = millis();
        do
        {
          if (MySignals_BLE.waitEvent(1000) == BLE_EVENT_ATTCLIENT_ATTRIBUTE_VALUE)
          {


            char attributeData[1] = {  0x00 };

            MySignals_BLE.attributeWrite(connection_handle_spo2, SPO2_HANDLE, attributeData , 1);


            uint8_t pulse_low = MySignals_BLE.event[12];
            pulse_low &= 0b01111111;

            uint8_t pulse_high = MySignals_BLE.event[11];
            pulse_high &= 0b01000000;

            if (pulse_high == 0)
            {
              pulse_spo2 = pulse_low;
            }

            if (pulse_high == 0b01000000)
            {
              pulse_spo2 = pulse_low + 0b10000000;
            }

            spo2 = MySignals_BLE.event[13];
            spo2 &= 0b01111111;

            if ((pulse_spo2 >= 25) && (pulse_spo2 <= 250)
                && (pulse_spo2 >= 35) && (pulse_spo2 <= 100))
            {

              sprintf(buffer_tft, "Pulse: %d ppm / SPO2: %d", pulse_spo2, spo2);
              tft.drawString(buffer_tft, 0, 75, 2);



              uint16_t errorCode = MySignals_BLE.disconnect(connection_handle_spo2);
              tft.drawString("Disconnected", 0, 45, 2);

              connected_spo2 = 0;

            }
          }
        }
        while ((connected_spo2 == 1) && ((millis() - previous) < 10000));

        connected_spo2 = 0;

      }
      else
      {
        tft.drawString("Error subscribing", 0, 60, 2);
      }
    }
    else
    {
      connected_spo2 = 0;

      tft.drawString("Not Connected", 0, 45, 2);
    }
  }
  else if (available_spo2 == 0)
  {
    //Do nothing
  }
  else
  {
    MySignals_BLE.hardwareReset();
    MySignals_BLE.initialize_BLE_values();
    delay(100);

  }
  delay(1000);
}
		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <UTouch.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>



Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);


UTouch  myTouch(14,NULL,15,16,17);

int touch_x;
int touch_y;


void setup(void) 
{
  Serial.begin(115200);
  
  MySignals.expanderWrite(B11111111);
  
  Wire.begin();
  myTouch.InitTouch();
  myTouch.setPrecision(PREC_MEDIUM);
  
}

void loop() {
 
  if (myTouch.dataAvailable())
  {
    myTouch.read();
    touch_x=myTouch.getX();
    touch_y=myTouch.getY();
    Serial.print("x=");
    Serial.print(touch_x);
    Serial.print("  y=");
    Serial.println(touch_y);
  }
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 


void setup() 
{
  Serial.begin(115200); 
  
  MySignals.begin();
}


void loop() 
{

  float conductance = MySignals.getGSR(CONDUCTANCE);
  float resistance = MySignals.getGSR(RESISTANCE);
  float conductanceVol = MySignals.getGSR(VOLTAGE);

  Serial.print("Conductance : ");       
  Serial.print(conductance, 2);  
  Serial.println("");         

  Serial.print("Resistance : ");       
  Serial.print(resistance, 2);  
  Serial.println("");    

  Serial.print("Conductance Voltage : ");       
  Serial.print(conductanceVol, 4);  
  Serial.println("");

  Serial.print("\n");

  // wait for a second  
  delay(1000);            
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

extern volatile unsigned long timer0_overflow_count;
float fanalog0;
int analog0;
unsigned long time;

byte serialByte;

void setup() 
{
  Serial.begin(9600);
  MySignals.begin();
  Serial.println("Starting...");
}

void loop() 
{ 
  while (Serial.available()>0)
  {  
    serialByte=Serial.read();
    if (serialByte=='C')
    {        
      while(1){
        fanalog0=MySignals.getECG(DATA);  
        // Use the timer0 => 1 tick every 4 us
        time=(timer0_overflow_count << 8) + TCNT0;        
        // Microseconds conversion.
        time=(time*4);   
        //Print in a file for simulation
        Serial.print(time);
        Serial.print(";");
        Serial.println(fanalog0,5);

        if (Serial.available()>0)
        {
          serialByte=Serial.read();
          if (serialByte=='F')  break;
        }
      }
    }
  }
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"


void setup()
{
  Serial.begin(115200);
  MySignals.begin();
}


void loop()
{

  uint16_t ecg = (uint16_t)MySignals.getECG(DATA);
  
  ecg = map(ecg, 0,1023,1023,0);
  Serial.println(ecg);

  delay(5);

 
}

		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 


#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>
char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

unsigned long previous;


// Sensor list
bool selected_airflow;
bool selected_ecg;
bool selected_emg;
bool selected_gsr;
bool selected_position;
bool selected_snore;
bool selected_temp;
bool selected_spiro;
bool selected_eeg;
bool selected_spo2_uart;
bool selected_bp_uart;
bool selected_gluco_uart;
bool selected_scale_ble;
bool selected_spo2_ble;
bool selected_bp_ble;
bool selected_gluco_ble;
uint8_t sensor_list_mode;

uint8_t spir_measure_individual;
uint8_t gluco_measure_individual;

uint8_t last_measure_hour_spiro;
uint8_t last_measure_minutes_spiro;
uint8_t last_measure_number_spiro;

uint8_t last_measure_hour_gluco;
uint8_t last_measure_minutes_gluco;
uint8_t last_measure_number_gluco;



void setup()
{
  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);


  Serial.begin(115200);

  MySignals.initSensorUART();


  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }



}


void loop()
{

  //1. SET MODE: SLAVE (VISIBLE TO APP)
  while ((MySignals_BLE.ble_mode_flag == master_mode))
  {

    if (MySignals_BLE.setMode(slave_mode) == 0)
    {
      //TFT message:  "Slave mode ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[3])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.ble_mode_flag = slave_mode;
    }
    else
    {
      //TFT message:  "Slave mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[4])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



  //2. SET BONDABLE MODE
  if (MySignals_BLE.bond_mode_and_mitm == 0)
  {
    if (MySignals_BLE.setBondableMode(BLE_ENABLE_BONDING) == 0)
    {

      //TFT message:  "Bondable mode ok"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[5])));
      tft.drawString(buffer_tft, 0, 45, 2);



      //3. SET SM PARAMETERS
      if (MySignals_BLE.setSMParameters(BLE_ENABLE_MITM) == 0)
      {
        //TFT message:  "SM parameters ok"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[7])));
        tft.drawString(buffer_tft, 0, 60, 2);


        MySignals_BLE.bond_mode_and_mitm = 1;

      }
      else
      {
        //TFT message:  "SM parameters fail"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[8])));
        tft.drawString(buffer_tft, 0, 60, 2);

        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
    else
    {
      //TFT message:  "Bondable mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[6])));
      tft.drawString(buffer_tft, 0, 45, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }


  //3. BONDING AND CONNECTION CONFIGURATION
  if ((MySignals_BLE.ble_mode_flag == slave_mode) && (MySignals_BLE.bonded_and_connected_flag == 0))
  {

    MySignals_BLE.bonding_correct = 0;
    MySignals_BLE.app_connected_flag = 0;
    MySignals_BLE.bonding_fail = 0;

    /////////////////////

    //TFT message:  "Waiting connections..."
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[9])));
    tft.drawString(buffer_tft, 0, 75, 2);


    uint8_t flag = MySignals_BLE.waitEvent(500);

    if (flag == BLE_EVENT_CONNECTION_STATUS)
    {
      MySignals_BLE.app_connected_flag = 1;
    }
    else if (flag == BLE_EVENT_SM_BOND_STATUS)
    {
      if (MySignals_BLE.event[6] == 0x01)
      {
        MySignals_BLE.bonding_correct = 1;
        delay(1000);
      }
    }
    else if (flag == 0)
    {
      // If there are no events, then no one tried to connect
    }
    else if (flag == BLE_EVENT_ATTRIBUTES_VALUE)
    {
      //Already connected
      MySignals_BLE.app_connected_flag = 1;
      MySignals_BLE.bonding_correct = 1;
      MySignals_BLE.bonded_and_connected_flag = 1;
    }
    else
    {
      // Other event received from BLE module
    }

    /////////////////////

    if ((MySignals_BLE.bonding_correct == 1) || MySignals_BLE.app_connected_flag == 1)
    {
      //TFT message:  "Connection detected..."
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[10])));
      tft.drawString(buffer_tft, 0, 90, 2);

      previous = millis();

      while ((MySignals_BLE.bonded_and_connected_flag == 0) && (MySignals_BLE.bonding_fail == 0))
      {
        //	Timeout 30 sg
        if ((millis() - previous) > 30000)
        {
          MySignals_BLE.bonding_fail = 1;
        }

        flag = MySignals_BLE.waitEvent(1000);

        if (flag == 0)
        {
          //Do nothing
        }
        else if (flag == BLE_EVENT_SM_PASSKEY_DISPLAY)
        {

          uint32_t passkey_temp =
            uint32_t(MySignals_BLE.event[5]) +
            uint32_t(MySignals_BLE.event[6]) * 256 +
            uint32_t(MySignals_BLE.event[7]) * 65536 +
            uint32_t(MySignals_BLE.event[8]) * 16777216;

          //TFT message:  "Passkey:";"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[11])));
          tft.drawString(buffer_tft, 0, 105, 2);
          tft.drawNumber(passkey_temp, 50, 105, 2);
        }

        else if (flag == BLE_EVENT_ATTRIBUTES_VALUE)
        {
          //Already connected
          MySignals_BLE.app_connected_flag = 1;
          MySignals_BLE.bonding_correct = 1;
          MySignals_BLE.bonded_and_connected_flag = 1;
        }

        else if (flag == BLE_EVENT_SM_BOND_STATUS)
        {

          if (MySignals_BLE.event[6] == 0x01)
          {
            //Man-in-the-Middle mode correct
            MySignals_BLE.bonding_correct = 1;
          }
        }

        else if (flag == BLE_EVENT_CONNECTION_FEATURE_IND)
        {
          //Do nothing
        }

        else if (flag == BLE_EVENT_CONNECTION_VERSION_IND)
        {
          //Do nothing
        }

        else if (flag == BLE_EVENT_SM_BONDING_FAIL)
        {
          MySignals_BLE.bonded_and_connected_flag = 0;
          MySignals_BLE.bonding_fail = 1;
        }
        else if (flag == BLE_EVENT_CONNECTION_STATUS)
        {

          if (MySignals_BLE.event[5] == 0x03)
          {
            //Connection correct
            MySignals_BLE.app_connected_flag = 1;

          }
        }
        else if (flag == BLE_EVENT_CONNECTION_DISCONNECTED)
        {
          MySignals_BLE.bonded_and_connected_flag = 0;
          MySignals_BLE.bonding_fail = 1;
        }
        else
        {
          //Do nothing
        }


        if (MySignals_BLE.bonding_correct && MySignals_BLE.app_connected_flag)
        {

          //TFT message:  "Connected!"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[12])));
          tft.drawString(buffer_tft, 0, 120, 2);


          //TFT message:  "Sensor list:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[14])));
          tft.drawString(buffer_tft, 0, 135, 2);

          //// SENSORES

          //TFT message:  "Airflow:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[20])));
          tft.drawString(buffer_tft, 0, 150, 2);

          //TFT message:  "Temperature:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[21])));
          tft.drawString(buffer_tft, 0, 165, 2);

          //TFT message:  "Position:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[22])));
          tft.drawString(buffer_tft, 0, 180, 2);

          //TFT message:  "GSR:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[23])));
          tft.drawString(buffer_tft, 0, 195, 2);

          //TFT message:  "ECG:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[24])));
          tft.drawString(buffer_tft, 0, 210, 2);

          //TFT message:  "EMG:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[25])));
          tft.drawString(buffer_tft, 0, 225, 2);

          //TFT message:  "Snore:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[26])));
          tft.drawString(buffer_tft, 0, 240, 2);

          //TFT message:  "SPO2:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[28])));
          tft.drawString(buffer_tft, 0, 255, 2);

          //TFT message:  "Glucometer:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[29])));
          tft.drawString(buffer_tft, 0, 270, 2);

          //TFT message:  "Spirometer:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[30])));
          tft.drawString(buffer_tft, 0, 285, 2);

          MySignals_BLE.bonded_and_connected_flag = 1;
        }

      }


      // Si el bonding ha fallado reiniciar el modulo y recargar pagina
      if (MySignals_BLE.bonding_fail == 1)
      {
        //TFT message:  "Connection failed. Reseting"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[13])));
        tft.drawString(buffer_tft, 0, 120, 2);

        MySignals_BLE.bonded_and_connected_flag = 1;
        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
  }




  //4. READ SENSOR LIST AND UPDATE VALUES OF SENSORS
  if ((MySignals_BLE.ble_mode_flag == slave_mode) && (MySignals_BLE.app_connected_flag == 1))
  {

    MySignals.enableSensorUART(BLE);
    //MySignals.pauseInterrupt();
    if (MySignals_BLE.readLocalAttribute(handle_3_0) == 0)
    {

      sprintf(buffer_tft, "%X %X %X  ", MySignals_BLE.attributeValue[1], MySignals_BLE.attributeValue[0], MySignals_BLE.attributeValue[2]);
      tft.drawString(buffer_tft, 100, 135, 2);

      sensor_list_mode = MySignals_BLE.attributeValue[2];

      selected_airflow    = MySignals_BLE.attributeValue[0] & 0b00000001;
      selected_gluco_uart = MySignals_BLE.attributeValue[0] & 0b00000010;
      selected_spiro      = MySignals_BLE.attributeValue[0] & 0b00000100;
      selected_gluco_ble  = MySignals_BLE.attributeValue[0] & 0b00001000;
      selected_bp_uart    = MySignals_BLE.attributeValue[0] & 0b00010000;
      selected_bp_ble     = MySignals_BLE.attributeValue[0] & 0b00100000;
      selected_scale_ble  = MySignals_BLE.attributeValue[0] & 0b01000000;
      selected_ecg        = MySignals_BLE.attributeValue[0] & 0b10000000;

      selected_eeg        = MySignals_BLE.attributeValue[1] & 0b00000001;
      selected_emg        = MySignals_BLE.attributeValue[1] & 0b00000010;
      selected_gsr        = MySignals_BLE.attributeValue[1] & 0b00000100;
      selected_position   = MySignals_BLE.attributeValue[1] & 0b00001000;
      selected_snore      = MySignals_BLE.attributeValue[1] & 0b00010000;
      selected_spo2_uart  = MySignals_BLE.attributeValue[1] & 0b00100000;
      selected_spo2_ble   = MySignals_BLE.attributeValue[1] & 0b01000000;
      selected_temp       = MySignals_BLE.attributeValue[1] & 0b10000000;
    }
    //MySignals.resumeInterrupt();


    if (selected_gluco_uart)
    {
      MySignals.enableSensorUART(GLUCOMETER);

      delay(10);
      MySignals.getGlucose();

      if (
        ((MySignals.glucoseLength > 0)
         && (MySignals.glucometerData[0].hour != last_measure_hour_gluco)
         && (MySignals.glucometerData[0].minutes != last_measure_minutes_gluco)
         && (MySignals.glucometerData[0].hour != 255))
        ||
        ((MySignals.glucoseLength > 0)
         && (last_measure_number_gluco != MySignals.glucoseLength)
         && (MySignals.glucometerData[0].hour != 255))
      )
      {
        last_measure_hour_gluco = MySignals.glucometerData[0].hour;
        last_measure_minutes_gluco = MySignals.glucometerData[0].minutes;
        last_measure_number_gluco = MySignals.glucoseLength;

        if (MySignals.glucometerData[MySignals.glucoseLength - 1].glucose != 0)
        {
          //Last measure
          uint8_t gluco_vector[9] =
          {
            MySignals.glucometerData[MySignals.glucoseLength - 1].year,
            MySignals.glucometerData[MySignals.glucoseLength - 1].month,
            MySignals.glucometerData[MySignals.glucoseLength - 1].day,
            MySignals.glucometerData[MySignals.glucoseLength - 1].hour,
            MySignals.glucometerData[MySignals.glucoseLength - 1].minutes,
            MySignals.glucometerData[MySignals.glucoseLength - 1].glucose,
            MySignals.glucometerData[MySignals.glucoseLength - 1].meridian,
            MySignals.glucoseLength,
            MySignals.glucoseLength
          };

          tft.fillRect(70, 272, 100, 11, ILI9341_BLACK);
          tft.drawNumber(MySignals.glucometerData[MySignals.glucoseLength - 1].glucose, 80, 270, 2);

          SPI.end();
          //MySignals.pauseInterrupt();
          // Write local attributes
          MySignals.enableSensorUART(BLE);
          MySignals_BLE.writeLocalAttribute(handle_3_9, gluco_vector, 9);
          //MySignals.resumeInterrupt();
        }
      }
    }



    if (selected_spiro)
    {
      MySignals.enableSensorUART(SPIROMETER);
      if (MySignals.getStatusSpiro() == 1)
      {
        delay(10);
        MySignals.getSpirometer();

        if (
          ((MySignals.spir_measures > 0)
           && (MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef < 1000)
           && (MySignals.spirometerData[0].spir_hour != last_measure_hour_spiro)
           && (MySignals.spirometerData[0].spir_minutes != last_measure_minutes_spiro))
          ||
          ((MySignals.spir_measures > 0)
           && (MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef < 1000)
           && (last_measure_number_spiro != MySignals.spir_measures))
        )
        {

          last_measure_hour_spiro = MySignals.spirometerData[0].spir_hour;
          last_measure_minutes_spiro = MySignals.spirometerData[0].spir_minutes;
          last_measure_number_spiro = MySignals.spir_measures;


          if (MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef < 1000)
          {
            uint8_t spir_pef_low = MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef & 0b0000000011111111;
            uint8_t spir_pef_high = (MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef & 0b1111111100000000) / 256;

            uint8_t spir_fev_low = MySignals.spirometerData[MySignals.spir_measures - 1].spir_fev & 0b0000000011111111;
            uint8_t spir_fev_high = (MySignals.spirometerData[MySignals.spir_measures - 1].spir_fev & 0b1111111100000000) / 256;

            //Last measure
            uint8_t spir_vector[11] =
            {
              MySignals.spirometerData[MySignals.spir_measures - 1].spir_year,
              MySignals.spirometerData[MySignals.spir_measures - 1].spir_month,
              MySignals.spirometerData[MySignals.spir_measures - 1].spir_day,
              MySignals.spirometerData[MySignals.spir_measures - 1].spir_hour,
              MySignals.spirometerData[MySignals.spir_measures - 1].spir_minutes,
              spir_pef_low,
              spir_pef_high,
              spir_fev_low,
              spir_fev_high,
              MySignals.spir_measures,
              MySignals.spir_measures
            };


            tft.fillRect(70, 287, 100, 11, ILI9341_BLACK);
            tft.drawNumber(MySignals.spirometerData[MySignals.spir_measures - 1].spir_pef, 80, 285, 2);


            SPI.end();
            //MySignals.pauseInterrupt();
            // Write local attributes
            MySignals.enableSensorUART(BLE);
            MySignals_BLE.writeLocalAttribute(handle_3_10, spir_vector, 11);
            //MySignals.resumeInterrupt();
          }
        }
      }
    }

    if (selected_spo2_uart)
    {
      MySignals.enableSensorUART(PULSIOXIMETER);

      if (MySignals.getPulsioximeter() == 1)
      {
        uint8_t spo2_vector[2] =
        {
          MySignals.pulsioximeterData.O2,
          MySignals.pulsioximeterData.BPM
        };

        tft.fillRect(70, 257, 100, 11, ILI9341_BLACK);
        tft.drawNumber(MySignals.pulsioximeterData.BPM, 80, 255, 2);
        tft.drawNumber(MySignals.pulsioximeterData.O2, 150, 255, 2);


        SPI.end();
        //MySignals.pauseInterrupt();
        // Write local attributes
        MySignals.enableSensorUART(BLE);
        MySignals_BLE.writeLocalAttribute(handle_3_8, spo2_vector, 2);
        //MySignals.resumeInterrupt();
      }
    }

    if (selected_airflow)
    {
      // PPM flag initialization
      //MySignals.airflowFlagPPM = 1;

      //MySignals.airflow_ppm = MySignals.airflowDataPPMBalanced;
      SPI.end();
      uint16_t airflow_raw = (uint16_t)MySignals.getAirflow(DATA);

      uint8_t airflow_raw_low = airflow_raw & 0b0000000011111111;
      uint8_t airflow_raw_high = (airflow_raw & 0b1111111100000000) / 256;


      tft.fillRect(70, 152, 100, 11, ILI9341_BLACK);
      tft.drawNumber(airflow_raw, 80, 150, 2);
      tft.drawNumber(MySignals.airflow_ppm, 150, 150, 2);

      uint8_t airflow_vector[3] =
      {
        airflow_raw_low, airflow_raw_high, MySignals.airflow_ppm
      };

      MySignals.enableSensorUART(BLE);
      //MySignals.pauseInterrupt();
      MySignals_BLE.writeLocalAttribute(handle_3_5, airflow_vector, 3);
      //MySignals.resumeInterrupt();
    }


    if (selected_temp)
    {

      SPI.end();
      uint16_t temp_dummy =  MySignals.getTemperature() * 100;
      uint8_t temp_low = temp_dummy & 0b0000000011111111;
      uint8_t temp_high = (temp_dummy & 0b1111111100000000) / 256;


      tft.fillRect(70, 167, 100, 11, ILI9341_BLACK);
      tft.drawFloat(float(temp_dummy / 100.0), 1, 80, 165, 2);



      uint8_t temp_vector[2] =
      {
        temp_low, temp_high
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_2, temp_vector, 2);

    }


    if (selected_position)
    {
      SPI.end();

      uint8_t position = MySignals.getBodyPosition();

      tft.fillRect(70, 182, 100, 11, ILI9341_BLACK);
      tft.drawNumber(position, 80, 180, 2);

      uint8_t position_vector[4] =
      {
        position, MySignals.x_data, MySignals.y_data, MySignals.z_data
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_1, position_vector, 4);

    }




    if (selected_gsr)
    {
      SPI.end();

      MySignals.getGSR();

      tft.fillRect(70, 197, 100, 11, ILI9341_BLACK);
      tft.drawNumber(MySignals.gsr_raw, 80, 195, 2);

      uint8_t gsr_raw_low = MySignals.gsr_raw & 0b0000000011111111;
      uint8_t gsr_raw_high = (MySignals.gsr_raw & 0b1111111100000000) / 256;


      uint8_t gsr_vector[2] =
      {
        gsr_raw_low, gsr_raw_high
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_6, gsr_vector, 2);

    }


    if (selected_ecg)
    {
      SPI.end();

      MySignals.ECGFlagBPM = 1;

      uint16_t ecg_raw = MySignals.getECG();

      tft.fillRect(70, 212, 100, 11, ILI9341_BLACK);
      tft.drawNumber(ecg_raw, 80, 210, 2);

      uint8_t ecg_raw_low = ecg_raw & 0b0000000011111111;
      uint8_t ecg_raw_high = (ecg_raw & 0b1111111100000000) / 256;

      uint8_t ecg_vector[3] =
      {
        ecg_raw_low, ecg_raw_high, MySignals.ECGDataBPMBalanced
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_4, ecg_vector, 3);

    }


    if (selected_emg)
    {
      SPI.end();
      //MySignals.EMGFlagCPM = 1;
      uint16_t emg_raw = MySignals.getEMG();

      uint8_t emg_raw_low = emg_raw & 0b0000000011111111;
      uint8_t emg_raw_high = (emg_raw & 0b1111111100000000) / 256;

      tft.fillRect(70, 227, 100, 11, ILI9341_BLACK);
      tft.drawNumber(emg_raw, 80, 225, 2);

      uint8_t emg_vector[3] =
      {
        emg_raw_low, emg_raw_high, MySignals.EMGDataCPMBalanced
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_3, emg_vector, 3);

    }


    if (selected_snore)
    {
      SPI.end();

      //MySignals.snoreFlagSPM = 1;
      uint16_t snore_raw = MySignals.getSnore();

      uint8_t snore_raw_low = snore_raw & 0b0000000011111111;
      uint8_t snore_raw_high = (snore_raw & 0b1111111100000000) / 256;

      tft.fillRect(70, 242, 100, 11, ILI9341_BLACK);
      tft.drawNumber(snore_raw, 80, 240, 2);

      uint8_t snore_vector[3] =
      {
        snore_raw_low, snore_raw_high, MySignals.snoreDataSPMBalanced
      };

      MySignals.enableSensorUART(BLE);
      MySignals_BLE.writeLocalAttribute(handle_3_11, snore_vector, 3);

    }





    // parse the status: 0 not connected; 1 connected; 2 encrypted;
    // 4 connection completed; 8 parameters changed
    MySignals.enableSensorUART(BLE);
    //MySignals.pauseInterrupt();
    if (MySignals_BLE.getStatus(MySignals_BLE.connection_handle) == 0)
    {

      //TFT message:  "Disconnected"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[15])));
      tft.drawString(buffer_tft, 0, 120, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
    //MySignals.resumeInterrupt();
  }

}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/


#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>

char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

unsigned long previous;


// Sensor list
bool selected_airflow;
bool selected_ecg;
bool selected_emg;
bool selected_gsr;
bool selected_position;
bool selected_snore;
bool selected_temp;
bool selected_spiro;
bool selected_eeg;
bool selected_spo2_uart;
bool selected_bp_uart;
bool selected_gluco_uart;
bool selected_scale_ble;
bool selected_spo2_ble;
bool selected_bp_ble;
bool selected_gluco_ble;

uint8_t blood_syst_low;
uint8_t blood_syst_high;
uint8_t blood_dias_low;
uint8_t blood_dias_high;
uint8_t blood_bpm_low;
uint8_t blood_bpm_high;


void setup()
{
  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  tft.drawString("Connect blood pressure to continue", 0, 0, 2);


  Serial.begin(115200);

  MySignals.initSensorUART();


  MySignals.enableSensorUART(BLOODPRESSURE);

  while (MySignals.getStatusBP() == 0)
  {
    delay(100);
  }

  delay(100);

  if (MySignals.getBloodPressure() == 1)
  {
    if (MySignals.bloodPressureData.systolic != 0)
    {

      blood_syst_low = MySignals.bloodPressureData.systolic & 0b0000000011111111;
      blood_syst_high = (MySignals.bloodPressureData.systolic & 0b1111111100000000) / 256;

      blood_dias_low = MySignals.bloodPressureData.diastolic & 0b0000000011111111;
      blood_dias_high = (MySignals.bloodPressureData.diastolic & 0b1111111100000000) / 256;

      blood_bpm_low = MySignals.bloodPressureData.pulse & 0b0000000011111111;
      blood_bpm_high = (MySignals.bloodPressureData.pulse & 0b1111111100000000) / 256;

    }
  }




  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }
}


void loop()
{

  //1. SET MODE: SLAVE (VISIBLE TO APP)
  while ((MySignals_BLE.ble_mode_flag == master_mode))
  {

    if (MySignals_BLE.setMode(slave_mode) == 0)
    {
      //TFT message:  "Slave mode ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[3])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.ble_mode_flag = slave_mode;
    }
    else
    {
      //TFT message:  "Slave mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[4])));
      tft.drawString(buffer_tft, 0, 30, 2);


      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }



  //2. SET BONDABLE MODE
  if (MySignals_BLE.bond_mode_and_mitm == 0)
  {
    if (MySignals_BLE.setBondableMode(BLE_ENABLE_BONDING) == 0)
    {

      //TFT message:  "Bondable mode ok"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[5])));
      tft.drawString(buffer_tft, 0, 45, 2);



      //3. SET SM PARAMETERS
      if (MySignals_BLE.setSMParameters(BLE_ENABLE_MITM) == 0)
      {
        //TFT message:  "SM parameters ok"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[7])));
        tft.drawString(buffer_tft, 0, 60, 2);


        MySignals_BLE.bond_mode_and_mitm = 1;

      }
      else
      {
        //TFT message:  "SM parameters fail"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[8])));
        tft.drawString(buffer_tft, 0, 60, 2);

        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
    else
    {
      //TFT message:  "Bondable mode fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[6])));
      tft.drawString(buffer_tft, 0, 45, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
  }


  //3. BONDING AND CONNECTION CONFIGURATION
  if ((MySignals_BLE.ble_mode_flag == slave_mode) && (MySignals_BLE.bonded_and_connected_flag == 0))
  {

    MySignals_BLE.bonding_correct = 0;
    MySignals_BLE.app_connected_flag = 0;
    MySignals_BLE.bonding_fail = 0;

    /////////////////////

    //TFT message:  "Waiting connections..."
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[9])));
    tft.drawString(buffer_tft, 0, 75, 2);


    uint8_t flag = MySignals_BLE.waitEvent(500);

    if (flag == BLE_EVENT_CONNECTION_STATUS)
    {
      MySignals_BLE.app_connected_flag = 1;
    }
    else if (flag == BLE_EVENT_SM_BOND_STATUS)
    {
      if (MySignals_BLE.event[6] == 0x01)
      {
        MySignals_BLE.bonding_correct = 1;
        delay(1000);
      }
    }
    else if (flag == 0)
    {
      // If there are no events, then no one tried to connect
    }
    else if (flag == BLE_EVENT_ATTRIBUTES_VALUE)
    {
      //Already connected
      MySignals_BLE.app_connected_flag = 1;
      MySignals_BLE.bonding_correct = 1;
      MySignals_BLE.bonded_and_connected_flag = 1;
    }
    else
    {
      // Other event received from BLE module
    }

    /////////////////////

    if ((MySignals_BLE.bonding_correct == 1) || MySignals_BLE.app_connected_flag == 1)
    {
      //TFT message:  "Connection detected..."
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[10])));
      tft.drawString(buffer_tft, 0, 90, 2);

      previous = millis();

      while ((MySignals_BLE.bonded_and_connected_flag == 0) && (MySignals_BLE.bonding_fail == 0))
      {
        //	Timeout 30 sg
        if ((millis() - previous) > 30000)
        {
          MySignals_BLE.bonding_fail = 1;
        }

        flag = MySignals_BLE.waitEvent(1000);

        if (flag == 0)
        {
          //Do nothing
        }
        else if (flag == BLE_EVENT_SM_PASSKEY_DISPLAY)
        {

          uint32_t passkey_temp =
            uint32_t(MySignals_BLE.event[5]) +
            uint32_t(MySignals_BLE.event[6]) * 256 +
            uint32_t(MySignals_BLE.event[7]) * 65536 +
            uint32_t(MySignals_BLE.event[8]) * 16777216;

          //TFT message:  "Passkey:";"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[11])));
          tft.drawString(buffer_tft, 0, 105, 2);
          tft.drawNumber(passkey_temp, 50, 105, 2);
        }

        else if (flag == BLE_EVENT_ATTRIBUTES_VALUE)
        {
          //Already connected
          MySignals_BLE.app_connected_flag = 1;
          MySignals_BLE.bonding_correct = 1;
          MySignals_BLE.bonded_and_connected_flag = 1;
        }

        else if (flag == BLE_EVENT_SM_BOND_STATUS)
        {

          if (MySignals_BLE.event[6] == 0x01)
          {
            //Man-in-the-Middle mode correct
            MySignals_BLE.bonding_correct = 1;
          }
        }

        else if (flag == BLE_EVENT_CONNECTION_FEATURE_IND)
        {
          //Do nothing
        }

        else if (flag == BLE_EVENT_CONNECTION_VERSION_IND)
        {
          //Do nothing
        }

        else if (flag == BLE_EVENT_SM_BONDING_FAIL)
        {
          MySignals_BLE.bonded_and_connected_flag = 0;
          MySignals_BLE.bonding_fail = 1;
        }
        else if (flag == BLE_EVENT_CONNECTION_STATUS)
        {

          if (MySignals_BLE.event[5] == 0x03)
          {
            //Connection correct
            MySignals_BLE.app_connected_flag = 1;

          }
        }
        else if (flag == BLE_EVENT_CONNECTION_DISCONNECTED)
        {
          MySignals_BLE.bonded_and_connected_flag = 0;
          MySignals_BLE.bonding_fail = 1;
        }
        else
        {
          //Do nothing
        }


        if (MySignals_BLE.bonding_correct && MySignals_BLE.app_connected_flag)
        {
          //TFT message:  "Connected!"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[12])));
          tft.drawString(buffer_tft, 0, 120, 2);

          //TFT message:  "Sensor list:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[14])));
          tft.drawString(buffer_tft, 0, 135, 2);

          //// SENSORS

          //TFT message:  "Blood pressure:"
          strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[27])));
          tft.drawString(buffer_tft, 0, 150, 2);

          MySignals_BLE.bonded_and_connected_flag = 1;
        }

      }


      // Si el bonding ha fallado reiniciar el modulo y recargar pagina
      if (MySignals_BLE.bonding_fail == 1)
      {
        //TFT message:  "Connection failed. Reseting"
        strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[13])));
        tft.drawString(buffer_tft, 0, 120, 2);

        MySignals_BLE.bonded_and_connected_flag = 1;
        MySignals_BLE.hardwareReset();
        delay(100);
        MySignals_BLE.initialize_BLE_values();
      }
    }
  }




  //4. READ SENSOR LIST AND UPDATE VALUES OF SENSORS
  if ((MySignals_BLE.ble_mode_flag == slave_mode) && (MySignals_BLE.app_connected_flag == 1))
  {

    //MySignals.enableSensorUART(BLE);
    //MySignals.pauseInterrupt();
    if (MySignals_BLE.readLocalAttribute(handle_3_0) == 0)
    {

      sprintf(buffer_tft, "%X %X %X  ", MySignals_BLE.attributeValue[1], MySignals_BLE.attributeValue[0], MySignals_BLE.attributeValue[2]);
      tft.drawString(buffer_tft, 100, 135, 2);


      selected_airflow    = MySignals_BLE.attributeValue[0] & 0b00000001;
      selected_gluco_uart = MySignals_BLE.attributeValue[0] & 0b00000010;
      selected_spiro      = MySignals_BLE.attributeValue[0] & 0b00000100;
      selected_gluco_ble  = MySignals_BLE.attributeValue[0] & 0b00001000;
      selected_bp_uart    = MySignals_BLE.attributeValue[0] & 0b00010000;
      selected_bp_ble     = MySignals_BLE.attributeValue[0] & 0b00100000;
      selected_scale_ble  = MySignals_BLE.attributeValue[0] & 0b01000000;
      selected_ecg        = MySignals_BLE.attributeValue[0] & 0b10000000;

      selected_eeg        = MySignals_BLE.attributeValue[1] & 0b00000001;
      selected_emg        = MySignals_BLE.attributeValue[1] & 0b00000010;
      selected_gsr        = MySignals_BLE.attributeValue[1] & 0b00000100;
      selected_position   = MySignals_BLE.attributeValue[1] & 0b00001000;
      selected_snore      = MySignals_BLE.attributeValue[1] & 0b00010000;
      selected_spo2_uart  = MySignals_BLE.attributeValue[1] & 0b00100000;
      selected_spo2_ble   = MySignals_BLE.attributeValue[1] & 0b01000000;
      selected_temp       = MySignals_BLE.attributeValue[1] & 0b10000000;
    }



    if (selected_bp_uart)
    {

      uint8_t bp_vector[6] =
      {
        blood_dias_low, blood_dias_high,
        blood_syst_low, blood_syst_high,
        blood_bpm_low, blood_bpm_high
      };
      SPI.end();

      tft.fillRect(70, 152, 160, 11, ILI9341_BLACK);
      tft.drawNumber(MySignals.bloodPressureData.diastolic, 110, 150, 2);
      tft.drawNumber(MySignals.bloodPressureData.systolic, 140, 150, 2);
      tft.drawNumber(MySignals.bloodPressureData.pulse, 170, 150, 2);

      // Write local attributes
      MySignals.enableSensorUART(BLE);
      //sensor.pauseInterrupt();
      MySignals_BLE.writeLocalAttribute(handle_3_7, bp_vector, 6);
      //sensor.resumeInterrupt();



    }



    // parse the status: 0 not connected; 1 connected; 2 encrypted;
    // 4 connection completed; 8 parameters changed
    MySignals.enableSensorUART(BLE);
    //MySignals.pauseInterrupt();
    if (MySignals_BLE.getStatus(MySignals_BLE.connection_handle) == 0)
    {

      //TFT message:  "Disconnected"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[15])));
      tft.drawString(buffer_tft, 0, 120, 2);

      MySignals_BLE.hardwareReset();
      delay(100);
      MySignals_BLE.initialize_BLE_values();
    }
    //MySignals.resumeInterrupt();
  }




}
		

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 * http://www.libelium.com
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    Luis Martin / Victor Boria
 */ 

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_AS.h>
#include <MySignals.h>
#include <MySignals_BLE.h>
#include <Wire.h>
#include <SPI.h>


char buffer_tft[30];

Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(TFT_CS, TFT_DC);

void setup() 
{
  MySignals.begin();

  tft.init();
  tft.setRotation(2);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  //TFT message: Welcome to MySignals
  strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[0])));
  tft.drawString(buffer_tft, 0, 0, 2);


  Serial.begin(115200);

  MySignals.initSensorUART();


  MySignals.enableSensorUART(BLE);

  MySignals_BLE.hardwareReset();
  MySignals_BLE.initialize_BLE_values();


  if (MySignals_BLE.initModule() == 1)
  {

    if (MySignals_BLE.sayHello() == 1)
    {
      //TFT message: "BLE init ok";
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[1])));
      tft.drawString(buffer_tft, 0, 15, 2);
    }
    else
    {
      //TFT message:"BLE init fail"
      strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
      tft.drawString(buffer_tft, 0, 15, 2);


      while (1)
      {
      };
    }
  }
  else
  {
    //TFT message: "BLE init fail"
    strcpy_P((char*)buffer_tft, (char*)pgm_read_word(&(table_MISC[2])));
    tft.drawString(buffer_tft, 0, 15, 2);

    while (1)
    {
    };
  }

  
  delay(5000);

   uint16_t bonding_number = MySignals_BLE.getBonding();

   sprintf(buffer_tft, "Bondings before: %d", bonding_number);
   tft.drawString(buffer_tft, 0, 30, 2);
   
   MySignals_BLE.deleteBonding();
 
   bonding_number = MySignals_BLE.getBonding();
   
   sprintf(buffer_tft, "Bondings after: %d", bonding_number);
   tft.drawString(buffer_tft, 0, 45, 2);
}

void loop() 
{
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h"


//Enter here your wifi network data
#define wifi_ssid "libelium_wsn2"
#define wifi_password "libelium.2012_"


void setup()
{
  //Write here you correct baud rate
  Serial.begin(9600);
  
  MySignals.begin();

  /*
     expanderState is initialized with B10000001

     Expansor pin library names:

     EXP_3G_ON
     EXP_TOUCH_CS
     EXP_BT_POWER
     EXP_BT_KEY
     EXP_ADC_CS
     EXP_SNORE_POT
     EXP_RESET_BLE
     EXP_WIFI_ON
  */

  //Enable WiFi module power (expansion board) -> bit7:0
  bitClear(MySignals.expanderState, EXP_WIFI_ON);
  MySignals.expanderWrite(MySignals.expanderState);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(EXPANSION);

  sendCommand("exit\r", "EXIT", 2000);
  
  delay(2000);

  if (enterConfig(2000)) 
  {
    sendCommand("leave\r", "DeAuth", 2000);
    delay(1000);
    
    // Sets DHCP and TCP protocol
    sendCommand("set ip dhcp 1\r", "AOK", 2000);
    delay(1000);
    
    sendCommand("set ip protocol 18\r", "AOK", 2000);
    delay(1000);

    // Configures the way to join the network AP, sets the encryption of the
    // network and joins it
    sendCommand("set wlan join 0\r", "AOK", 2000); //The auto-join feature is disabled
    delay(1000);
    
    char aux_str[50];
    snprintf(aux_str, sizeof(aux_str), "set wlan phrase %s\r", wifi_password);
    sendCommand(aux_str, "AOK", 2000);
    delay(1000);
    
    snprintf(aux_str, sizeof(aux_str), "join %s\r", wifi_ssid);
    uint8_t answer = sendCommand(aux_str, "Associated", 10000);


    if (answer == 1)
    {

      snprintf(aux_str, sizeof(aux_str), "Connected to \"%s\"", wifi_ssid);
      MySignals.println(aux_str);
      delay(5000);
    }

    else
    {
      snprintf(aux_str, sizeof(aux_str), "Error connecting to: \"%s\"", wifi_ssid);
      MySignals.println(aux_str);
      delay(1000);
    }
  }
  else
  {
    MySignals.println("Wifi no OK");
  }
}

void loop()
{
  delay(5000);
}




int8_t sendCommand(const char* Command, const char* expected_answer, unsigned int timeout) 
{
  char response[300];
  uint8_t x = 0,  answer = 0;
  unsigned long previous;

  memset(response, 0, 300);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  Serial.println(Command);    // Send Command

  x = 0;
  previous = millis();

  // this loop waits for the answer
  do 
  {
    if (Serial.available() != 0) 
    {
      // if there are data in the UART input buffer, reads it and checks for the asnwer
      response[x] = Serial.read();
      x++;
      // check if the desired answer  is in the response of the module
      if (strstr(response, expected_answer) != NULL)
      {
        answer = 1;
      }
    }
  }
  // Waits for the asnwer with time out
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}


int8_t enterConfig(unsigned int timeout)
{
  char response[100];
  uint8_t x = 0,  answer = 0;
  unsigned long previous;

  memset(response, 0, 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  Serial.print("$$$");    // Send Command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {
    if (Serial.available() != 0) 
    {
      // if there are data in the UART input buffer, reads it and checks for the asnwer
      response[x] = Serial.read();
      x++;
      // check if the desired answer  is in the response of the module
      if (strstr(response, "CMD") != NULL)
      {
        answer = 1;
      }
    }
  }
  // Waits for the asnwer with time out
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"



void setup()
{
  //Try different baudrates, for example:
  //Serial.begin(57600);
  Serial.begin(38400);
  //You can use the configuration examples with the correct 
  //AT+UART=**** command in order to change the baudrate
  
  MySignals.begin();
 
  MySignals.expanderWrite(B00000100);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(EEG);


  delay(1000);
  // Checks if the BT module is started
  answer = sendATcommand("AT", "OK", 6000);
  if (answer == 0)
  {
    MySignals.println("Error");
    // waits for an answer from the module
    while (answer == 0) 
    {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 6000);
    }
  }
  else if (answer == 1) 
  {
    
    MySignals.println("BT HC05 succesfully working!");
  }
  
  
  //You better first try these commands via Gateway commands in a serial communication 
  //programa like Cutecom
  
  Serial.println("Enter AT commands:");

    delay(3000);
	sendATcommand("AT", "0K", 2000);
	delay(5000);
	sendATcommand("AT+UART=57600,0,0", "0K", 2000);
	delay(5000);
	sendATcommand("AT+ROLE=1", "0K", 2000);
	delay(5000);
	sendATcommand("AT+PSWD=0000", "0K", 2000);
	delay(5000);
	sendATcommand("AT+CMODE=0", "0K", 2000);
	delay(5000);
	sendATcommand("AT+BIND=****,**,******", "0K", 2000); // mindwave mac
	delay(5000);
	sendATcommand("AT+INIT", "0K", 2000);
	delay(5000);
	sendATcommand("AT+IAC=9E8B33", "0K", 2000);
	delay(5000);
	sendATcommand("AT+CLASS=0", "0K", 2000);
	delay(5000);
	sendATcommand("AT+INQM=1,9,48", "0K", 2000);
	delay(5000);
	sendATcommand("AT+INQ", "0K", 2000);
	delay(20000);
	sendATcommand("AT+PAIR=****,**,******,20", "0K", 2000); //mindwave mac
	delay(10000);
	sendATcommand("AT+LINK=****,**,****", "0K", 2000); //mindwave mac
	delay(10000);
}

void loop()
{

}


int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer
  
  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0) 
    {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        MySignals.println(response);
      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h" 

int8_t answer;



void setup() 
{
  //Try different baudrates, for example:
  //Serial.begin(57600);
  Serial.begin(38400);
  //You can use the configuration examples with the correct 
  //AT+UART=**** command in order to change the baudrate
  
  MySignals.begin();
 
  MySignals.expanderWrite(B00000100);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(EEG);


  delay(1000);
  // Checks if the BT module is started
  answer = sendATcommand("AT", "OK", 6000);
  if (answer == 0)
  {
    MySignals.println("Error");
    // waits for an answer from the module
    while (answer == 0) 
    {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 6000);
    }
  }
  else if (answer == 1) 
  {
    
    MySignals.println("BT HC05 succesfully working!");
  }
  
  sendATcommand("AT+NAME?", "OK", 6000);

}

void loop() 
{
  


}

int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[500];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer
  
  delay(1000);
  Serial.println(ATcommand);    // Send the AT command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0) 
    {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
        MySignals.println(response);
      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}

		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include "Wire.h"
#include "SPI.h"



void setup()
{
  MySignals.begin();
  //Try different baudrates, for example:
  Serial.begin(57600);
  //Serial.begin(38400);
  //You can use the configuration examples with the correct
  //AT+UART=**** command in order to change the baudrate
}

void loop()
{
  //Mode: communication Power: off
  MySignals.expanderWrite(B00001000);
  delay(1000);

  //Mode: communication Power:  on
  MySignals.expanderWrite(B00001100);
  delay(5000);

  //Mode: AT Power:  off
  MySignals.expanderWrite(B00000000);
  delay(1000);
  
  //Mode: AT Power:  on
  MySignals.expanderWrite(B00000100);
  delay(5000);
}
		

/*

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
   http://www.libelium.com

    By using it you accept the MySignals Terms and Conditions.
    You can find them at: http://libelium.com/legal

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           0.1
    Design:            David Gascon
    Implementation:    Luis Martin / Victor Boria
*/

#include <MySignals.h>
#include <Wire.h>
#include "SPI.h"

#define phone_number "XXXXXXX"

void setup()
{
  //Write here you correct baud rate
  Serial.begin(115200);

  MySignals.begin();

  /*
     expanderState is initialized with B10000001

     Expansor pin library names:

     EXP_3G_ON
     EXP_TOUCH_CS
     EXP_BT_POWER
     EXP_BT_KEY
     EXP_ADC_CS
     EXP_SNORE_POT
     EXP_RESET_BLE
     EXP_WIFI_ON
  */

  //Enable 3G module power -> bit0:0
  bitClear(MySignals.expanderState, EXP_3G_ON);
  MySignals.expanderWrite(MySignals.expanderState);

  MySignals.initSensorUART();
  MySignals.enableSensorUART(EXPANSION);
  
 
  delay(2000);

  // checks if the module is started
  uint8_t answer = sendATcommand("AT", "OK", 2000);
  if (answer == 0)
  {
    delay(3000);
    // waits for an answer from the module
    while (answer == 0)
    {
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", "OK", 2000);
    }
  }
  MySignals.println("Connecting network");
  
  while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) || 
    sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );

  MySignals.print("Setting SMS mode...");
  
  sendATcommand("AT+CMGF=1", "OK", 1000);    // sets the SMS mode to text
  
  MySignals.println("Sending SMS");
  
  char aux_string[30];
  sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);
  answer = sendATcommand(aux_string, ">", 2000);    // send the SMS number
  if (answer == 1)
  {
    Serial.println(F("Test-Arduino-Hello World"));
    Serial.write(0x1A);
    answer = sendATcommand("", "OK", 20000);
    
    if (answer == 1)
    {
      MySignals.println("Sent");    
    }
    else
    {
      MySignals.println("error");
    }
  }
  else
  {
    MySignals.println("error");
  }

  delay(1000);
}

void loop()
{
  delay(5000);
}




int8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout)
{

  uint8_t x = 0,  answer = 0;
  char response[100];
  unsigned long previous;

  memset(response, '\0', 100);    // Initialize the string

  delay(100);

  while ( Serial.available() > 0) Serial.read();   // Clean the input buffer

  Serial.println(ATcommand);    // Send the AT command


  x = 0;
  previous = millis();

  // this loop waits for the answer
  do {

    if (Serial.available() != 0) {
      response[x] = Serial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)
      {
        answer = 1;
      }
    }
    // Waits for the asnwer with time out
  }
  while ((answer == 0) && ((millis() - previous) < timeout));

  return answer;
}

		

<?php

/*
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is distributed WITHOUT ANY WARRANTY; without
 *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 *  PARTICULAR PURPOSE.
 *
 *  By using it you accept the MySignals Terms and Conditions.
 *  You can find them at: http://libelium.com/legal
 *
 *
 *  Version:           0.1
 *  Design:            David Gascon
 *  Implementation:    J.Berrocal
 */

include('includes/httpful.phar');

// Config
$email = 'your@email.com';
$password = 'your_password';

// API Vars
$api_base = 'https://api.libelium.com/mysignals';
$api_headers = ['Accept' => 'application/x.webapi.v1+json'];


//1.- Login
$parameters = json_encode([
    'email' => $email,
    'password' => $password
]);
$response_login = \Httpful\Request::post($api_base . '/auth/login')
    ->sendsJson()
    ->body($parameters)
    ->addHeaders($api_headers)
    ->send();
echo "1.- Login: <br><br>".$response_login->raw_body."<hr><br>";

//Save the Token in the header array.
if($response_login->code == 200){
    $api_headers['Authorization'] = 'Bearer '.$response_login->body->token;
}


//2.- Get my members
$response_members = \Httpful\Request::get($api_base . '/members')
    ->addHeaders($api_headers)
    ->send();

echo "2.- Get my members: <br><br><pre>".json_encode($response_members->body, JSON_PRETTY_PRINT)."</pre><hr><br>";



//3.- Get values from the first of my members
if(count($response_members->body->data) >= 1){
    $member_id = $response_members->body->data[0]->id;

    $parameters = [
        'member_id' => $member_id,
        'sensor_id' => 'temp',
        'ts_start' => '2015-01-01 00:00:00',
        'ts_end' => '2017-01-01 00:01:00',
        'limit' => '5',
        'cursor' => '0',
        'order' => 'desc'
    ];
    $response_values = \Httpful\Request::get($api_base . '/values?'.http_build_query($parameters))
        ->addHeaders($api_headers)
        ->send();

    echo "3.- Get values from one member (member_id= ".$member_id."): <br><br><pre>".json_encode($response_values->body, JSON_PRETTY_PRINT)."</pre><hr><br>";

}