// multiparameter sensor data over BLE in WSN SYSTEM

//Temperature Sensor A0
//MEMS Pressure Sensor A1
//Humidity Sensor A2
//Strain Gauge A3
//Shock Sensor A4
//MEMS acoustic sensor A5

// Intel Curie BLE  library
#include <CurieBLE.h>

// RGB Status LED Pin definition
#define RED_LED_PIN 6        //  1
#define GREEN_LED_PIN 5      //  2
#define BLUE_LED_PIN 9       //  3

//RGB LED blink function variables
byte led_num = 0;
int blink_count = 0;
int blink_interval = 0;
int blink_count_var = 0;

//RGB LED fade function variables
int fade_brightness = 0;  // how bright the LED is
int fade_amount = 0;     // how many points to fade the LED by
int fade_delay = 0;     //dimming effect
int fade_count = 0;    //number of counts
int fade_count_var = 0;

// BLE Services & Characteristics UUIDs
#define SENSOR_SERVICE_UUID "3197ac9e-fc38-28e5-52aa-5e5517507c66"
#define TS_CHAR_UUID "3197af14-ac38-11e5-86aa-5e5517507c66"
#define PS_CHAR_UUID "3197b090-ac38-11e5-86aa-5e5517507c66"
#define HS_CHAR_UUID "3197b180-ac38-11e5-86aa-5e5517507c66"
#define FS_CHAR_UUID "3197b252-ac38-11e5-86aa-5e5517507c66"
#define SS_CHAR_UUID "3197b5ae-ac38-11e5-86aa-5e5517507c66"
#define AS_CHAR_UUID "3197b694-ac38-11e5-86aa-5e5517507c66"

// Arduino 101 acts as a BLE peripheral
BLEPeripheral blePeripheral;

// sensor data is registered as a BLE service
BLEService sensorService(SENSOR_SERVICE_UUID);

// Each IMU data point is its own characteristic
BLEIntCharacteristic tsChar(TS_CHAR_UUID, BLERead | BLENotify);
BLEIntCharacteristic psChar(PS_CHAR_UUID, BLERead | BLENotify);
BLEIntCharacteristic hsChar(HS_CHAR_UUID, BLERead | BLENotify);
BLEIntCharacteristic fsChar(FS_CHAR_UUID, BLERead | BLENotify);
BLEIntCharacteristic ssChar(SS_CHAR_UUID, BLERead | BLENotify);
BLEIntCharacteristic asChar(AS_CHAR_UUID, BLERead | BLENotify);

//sensor value variables initialized to zero
int ts = 0;
int ps = 0;
int hs = 0;
int fs = 0;
int ss = 0;
int as = 0;

void setup() {
  Serial.begin(9600);
  
   //set RGB LED pins as output
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(BLUE_LED_PIN, OUTPUT);
  
  //initially turn-off LEDs
  digitalWrite(RED_LED_PIN, LOW);
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(BLUE_LED_PIN, LOW);
  
  //system reset/initialize indication
  blink_led(1,2,100);//led,count,blink interval
  blink_led(2,2,200);//led,count,blink interval
  blink_led(3,2,200);//led,count,blink interval

  // Initialize sensors
  // sensor indication
  fade_led(1,3,10,10); //led,fade_count,fade_amount,fade_delay
  Serial.println("Initializing Sensors...");
  //Sensor complete indication
  fade_led(2,3,10,10); //led,fade_count,fade_amount,fade_delay
  
 //BLE indication
  fade_led(3,3,10,10); //led,fade_count,fade_amount,fade_delay
  BLE.begin();
  BLE.setLocalName("SENSOR_WSN");
  
  BLE.setAdvertisedService(sensorService);
  
  sensorService.addCharacteristic(tsChar);
  sensorService.addCharacteristic(psChar);
  sensorService.addCharacteristic(hsChar);
  sensorService.addCharacteristic(fsChar);
  sensorService.addCharacteristic(ssChar);
  sensorService.addCharacteristic(asChar);
  
  BLE.addService(sensorService);
  
  // Set initial values
  tsChar.setValue(ts);
  psChar.setValue(ps);
  hsChar.setValue(hs);
  fsChar.setValue(fs);
  ssChar.setValue(ss);
  asChar.setValue(as);
  
  // Now, activate the BLE peripheral
  BLE.advertise();
  
  Serial.println("Bluetooth Sensor WSN active, waiting for connections...");

  // final system ready indication
 fade_led(1,2,10,10); //led,fade_count,fade_amount,fade_delay
 fade_led(2,2,10,10); //led,fade_count,fade_amount,fade_delay
 fade_led(3,2,10,10); //led,fade_count,fade_amount,fade_delay
}

void loop() {

  // system stand-by indication
  fade_led(2,2,10,10); //led,fade_count,fade_amount,fade_delay
  
  BLECentral central = blePeripheral.central();

  if(central) {
    Serial.print("Connected to central: ");
    Serial.println(central.address());
    //ble link connection notification
    blink_led(3,5,100);
    
    while(central.connected()) {
      updateSensorData();
    }
    
    Serial.print("Disconnected from central: ");
    Serial.println(central.address());
    //ble link disconnecttion indication
    blink_led(1,5,100);
  }
}

void updateSensorData() {
  //read sensors
  ts = map( analogRead(A0), 0, 1023, 0, 100);
  ps = map( analogRead(A1), 0, 1023, 0, 100);
  hs = map( analogRead(A2), 0, 1023, 0, 100);
  fs = map( analogRead(A3), 0, 1023, 0, 100);
  ss = map( analogRead(A4), 0, 1023, 0, 100);
  as = map( analogRead(A5), 0, 1023, 0, 100);
 
  //update the sensor values
  tsChar.setValue(ts);
  psChar.setValue(ps);
  hsChar.setValue(hs);
  fsChar.setValue(fs);
  ssChar.setValue(ss);
  asChar.setValue(as);

  // update sensor data
  blink_led(1,1,20); //led,count,blink interval
  
  Serial.print(ts); Serial.print("\t");
  Serial.print(ps); Serial.print("\t");
  Serial.print(hs); Serial.print("\t");
  Serial.print(fs); Serial.print("\t");
  Serial.print(ss); Serial.print("\t");
  Serial.print(as); Serial.print("\t");

  Serial.println("");
}
// RGB Led blink Function
void blink_led(int led_num, int blink_count, int blink_interval)
{
  if( led_num == 1)
  {
    for( blink_count_var = 1; blink_count_var <= blink_count; blink_count_var++ )
    {
      digitalWrite(RED_LED_PIN, HIGH);   
      delay(blink_interval);                       
      digitalWrite(RED_LED_PIN, LOW);    
      delay(blink_interval); 
    }
  }
  if( led_num == 2)
  {
    for( blink_count_var = 1; blink_count_var <= blink_count; blink_count_var++ )
    {
      digitalWrite(GREEN_LED_PIN, HIGH);   
      delay(blink_interval);                       
      digitalWrite(GREEN_LED_PIN, LOW);    
      delay(blink_interval); 
    }
  }
  if( led_num == 3)
  {
    for( blink_count_var = 1; blink_count_var <= blink_count; blink_count_var++ )
    {
      digitalWrite(BLUE_LED_PIN, HIGH);   
      delay(blink_interval);                       
      digitalWrite(BLUE_LED_PIN, LOW);    
      delay(blink_interval); 
    }
  }
}
// RGB Led Fade Function
void fade_led(int led_num, int fade_count, int fade_amount, int fade_delay  ) 
{
  if( led_num == 1)
  {
    for(fade_count_var = 1; fade_count_var <= fade_count; fade_count_var++ )
    {
      for(fade_brightness = 0; fade_brightness < 255; fade_brightness += fade_amount)
      {
          analogWrite(RED_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      for(fade_brightness = 255; fade_brightness > 0; fade_brightness -= fade_amount)
      {
          analogWrite(RED_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      digitalWrite(RED_LED_PIN, LOW);
    }
  }
 if( led_num == 2)
  {
    for(fade_count_var = 1; fade_count_var <= fade_count; fade_count_var++ )
    {
      for(fade_brightness = 0; fade_brightness < 255; fade_brightness += fade_amount)
      {
          analogWrite(GREEN_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      for(fade_brightness = 255; fade_brightness > 0; fade_brightness -= fade_amount)
      {
          analogWrite(GREEN_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      digitalWrite(GREEN_LED_PIN, LOW);
    }
  } 
 if( led_num == 3)
  {
    for(fade_count_var = 1; fade_count_var <= fade_count; fade_count_var++ )
    {
      for(fade_brightness = 0; fade_brightness < 255; fade_brightness += fade_amount)
      {
          analogWrite(BLUE_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      for(fade_brightness = 255; fade_brightness > 0; fade_brightness -= fade_amount)
      {
          analogWrite(BLUE_LED_PIN, fade_brightness);
          delay(fade_delay );
      }
      digitalWrite(BLUE_LED_PIN, LOW);
    }
  } 
}