From e0be90589b654a4a879e1b41807439bc7718f9fd Mon Sep 17 00:00:00 2001 From: Hiroyuki Mino Date: Tue, 12 Mar 2019 19:12:26 +0000 Subject: [PATCH] 2jciebu01: initial implementation of Omron's Environment Sensor using BLE interface Signed-off-by: Hiroyuki Mino Signed-off-by: Mihai Tudor Panu --- .../upm/examples/c++/omron2jciebu01_ble.cxx | 539 ++++++++++++++++++ .../upm/src/2jciebu-ble/2jciebu01_ble.cxx | 500 ++++++++++++++++ .../upm/src/2jciebu-ble/2jciebu01_ble.hpp | 230 ++++++++ .../upm/src/2jciebu-ble/2jciebu01_ble.i | 8 + .../upm/src/2jciebu-ble/2jciebu01_ble.json | 29 + .../upm/src/2jciebu-ble/CMakeLists.txt | 5 + Omron_2jcie-bu01_ble/upm/src/CMakeLists.txt | 2 + 7 files changed, 1313 insertions(+) create mode 100644 Omron_2jcie-bu01_ble/upm/examples/c++/omron2jciebu01_ble.cxx create mode 100644 Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.cxx create mode 100644 Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.hpp create mode 100644 Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.i create mode 100644 Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.json create mode 100644 Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/CMakeLists.txt create mode 100644 Omron_2jcie-bu01_ble/upm/src/CMakeLists.txt diff --git a/Omron_2jcie-bu01_ble/upm/examples/c++/omron2jciebu01_ble.cxx b/Omron_2jcie-bu01_ble/upm/examples/c++/omron2jciebu01_ble.cxx new file mode 100644 index 00000000..3f587864 --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/examples/c++/omron2jciebu01_ble.cxx @@ -0,0 +1,539 @@ +/* +* Author: Hiroyuki Mino +* Copyright (c) 2019 Omron Electronic Components - Americas +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of +* this software and associated documentation files (the "Software"), to deal in +* the Software without restriction, including without limitation the rights to +* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +* the Software, and to permit persons to whom the Software is furnished to do so, +* subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +/* standard headers */ +#include +#include +#include +#include + + +/* omron sensor headers */ +#include "2jciebu01_ble.hpp" + +using namespace std; +using namespace upm; + +#define PREVIOUS_MENU_CHOICE 8 + +volatile sig_atomic_t flag = 1; + + +upm::OM2JCIEBU_BLE::om2jciebuData_t om2jciebuSensorData; + +void +sig_handler(int signum) +{ + if(signum == SIGABRT) { + std::cout << "Exiting..." << std::endl; + } + if(signum == SIGINT) { + flag = 0; + } +} + + +void getSensorData(OM2JCIEBU_BLE *p_om2jcieble) +{ + + if(p_om2jcieble == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + uint16_t parameterChoice = 0; + int displayDelay = 0; + uint16_t sensorParamData = 0; + uint32_t pressureData = 0; + bool seconds_validate = false; + + p_om2jcieble->getDiscoveredServices(OM2JCIEBU_BLE::ALL_PARAM); + while(true) { + printf("************************************************************\r\n"); + printf("Please select sensor attribute for display\r\n"); + printf("0) All parameter\r\n"); + printf("1) Temperature data\r\n"); + printf("2) Relative humidity data\r\n"); + printf("3) Ambient light data\r\n"); + printf("4) Barometric pressure data\r\n"); + printf("5) Sound noise data\r\n"); + printf("6) eTVOC data\r\n"); + printf("7) eCO2 data\r\n"); + printf("8) Return to main menu\r\n"); + printf("Note :: Press Ctrl+C for sensor attribute display menu\r\n"); + printf("************************************************************\r\n"); + while(!(std::cin >> parameterChoice)) { + std::cin.clear(); //clear bad input flag + std::cin.ignore(std::numeric_limits::max(), '\n'); //discard input + std::cout << "Invalid input; please re-enter.\n"; + } + if(parameterChoice >= OM2JCIEBU_BLE::ALL_PARAM && parameterChoice <= OM2JCIEBU_BLE::ECO2) { + flag = 1; + printf("Please enter time interval (in Seconds), for display sensor data\r\n"); + while(!seconds_validate) { + cin >> displayDelay; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (displayDelay >= 1 && displayDelay <= 10)) { + seconds_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an second between 1 to 10!" << endl; + } + } + while(flag) { + switch(parameterChoice) { + case OM2JCIEBU_BLE::ALL_PARAM: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ALL_PARAM, &om2jciebuSensorData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Sensor Attribute Values ***************\r\n"); + printf("Sequence Number :: %d \r\n", om2jciebuSensorData.sequence_number); + printf("Temperature :: %d degC\r\n", om2jciebuSensorData.temperature); + printf("Relative humidity :: %d RH\r\n", om2jciebuSensorData.relative_humidity); + printf("Ambient light :: %d lx\r\n", om2jciebuSensorData.ambient_light); + printf("Barometric pressure :: %d hPa\r\n", om2jciebuSensorData.pressure); + printf("Sound noise :: %d dB\r\n", om2jciebuSensorData.noise); + printf("eTVOC :: %d ppb\r\n", om2jciebuSensorData.eTVOC); + printf("eCO2 :: %d ppm\r\n", om2jciebuSensorData.eCO2); + printf("**********************************************************\r\n"); + memset(&om2jciebuSensorData, 0, sizeof(om2jciebuSensorData)); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::TEMP: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::TEMP, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Temperature Attribute Values ***************\r\n"); + printf("Temperature :: %d degC\r\n", sensorParamData); + printf("************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::HUMIDITY: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::HUMIDITY, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Relative humidity Attribute Values ***************\r\n"); + printf("Relative humidity :: %d RH\r\n", sensorParamData); + printf("******************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::AMBIENT_LIGHT: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::AMBIENT_LIGHT, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Ambient light Attribute Values ***************\r\n"); + printf("Ambient light :: %d lx\r\n", sensorParamData); + printf("***************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::PRESSURE: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::PRESSURE, &pressureData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Barometric pressure Attribute Values ***************\r\n"); + printf("Barometric pressure :: %d hPa\r\n", pressureData); + printf("********************************************************************\r\n"); + } + break; + + case OM2JCIEBU_BLE::NOISE: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::NOISE, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Sound noise Attribute Values ***************\r\n"); + printf("Sound noise :: %d dB\r\n", sensorParamData); + printf("*************************************************************\r\n"); + } else { + flag = 0; + } + break; + + case OM2JCIEBU_BLE::ETVOC: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ETVOC, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** eTVOC Attribute Values ***************\r\n"); + printf("eTVOC :: %d ppb\r\n", sensorParamData); + printf("*******************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::ECO2: + if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ECO2, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** eCO2 Attribute Values ***************\r\n"); + printf("eCO2 :: %d ppm\r\n\r\n", sensorParamData); + printf("******************************************************\r\n"); + } else { + flag = 0; + } + break; + } + printf("\r\n"); + p_om2jcieble->delay(displayDelay); + } + } else if(parameterChoice == PREVIOUS_MENU_CHOICE) { + break; + } else { + printf("Invalid choice\r\n"); + } + seconds_validate = false; + } +} + +void getAdvSensorData(OM2JCIEBU_BLE *p_om2jcieble) +{ + if(p_om2jcieble == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + + uint16_t parameterChoice = 0, sensorParamData = 0; + int displayDelay = 0; + uint32_t pressureData = 0; + bool seconds_validate = false; + + while(true) { + printf("************************************************************\r\n"); + printf("Please select sensor attribute for display\r\n"); + printf("0) All parameter\r\n"); + printf("1) Temperature data\r\n"); + printf("2) Relative humidity data\r\n"); + printf("3) Ambient light data\r\n"); + printf("4) Barometric pressure data\r\n"); + printf("5) Sound noise data\r\n"); + printf("6) eTVOC data\r\n"); + printf("7) eCO2 data\r\n"); + printf("8) Return to main menu\r\n"); + printf("Note :: Press Ctrl+C for sensor attribute display menu\r\n"); + printf("************************************************************\r\n"); + while(!(std::cin >> parameterChoice)) { + std::cin.clear(); //clear bad input flag + std::cin.ignore(std::numeric_limits::max(), '\n'); //discard input + std::cout << "Invalid input; please re-enter.\n"; + } + if(parameterChoice >= OM2JCIEBU_BLE::ALL_PARAM && parameterChoice <= OM2JCIEBU_BLE::ECO2) { + flag = 1; + printf("Please enter time interval (in Seconds), for display sensor data\r\n"); + while(!seconds_validate) { + cin >> displayDelay; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (displayDelay >= 1 && displayDelay <= 10)) { + seconds_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an second between 1 and 10!" << endl; + } + } + while(flag) { + switch(parameterChoice) { + case OM2JCIEBU_BLE::ALL_PARAM: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ALL_PARAM, &om2jciebuSensorData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Sensor Attribute Values ***************\r\n"); + printf("Sequence Number :: %d \r\n", om2jciebuSensorData.sequence_number); + printf("Temperature :: %d degC\r\n", om2jciebuSensorData.temperature); + printf("Relative humidity :: %d RH\r\n", om2jciebuSensorData.relative_humidity); + printf("Ambient light :: %d lx\r\n", om2jciebuSensorData.ambient_light); + printf("Barometric pressure :: %d hPa\r\n", om2jciebuSensorData.pressure); + printf("Sound noise :: %d dB\r\n", om2jciebuSensorData.noise); + printf("eTVOC :: %d ppb\r\n", om2jciebuSensorData.eTVOC); + printf("eCO2 :: %d ppm\r\n", om2jciebuSensorData.eCO2); + printf("*********************************************************************\r\n"); + memset(&om2jciebuSensorData, 0, sizeof(om2jciebuSensorData)); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::TEMP: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::TEMP, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Temperature Attribute Values ***************\r\n"); + printf("Temperature :: %d degC\r\n", sensorParamData); + printf("**************************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::HUMIDITY: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::HUMIDITY, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Relative humidity Attribute Values ***************\r\n"); + printf("Relative humidity :: %d RH\r\n", sensorParamData); + printf("********************************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::AMBIENT_LIGHT: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::AMBIENT_LIGHT, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Ambient light Attribute Values ***************\r\n"); + printf("Ambient light :: %d lx\r\n", sensorParamData); + printf("***************************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::PRESSURE: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::PRESSURE, &pressureData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Barometric pressure Attribute Values ***************\r\n"); + printf("Barometric pressure :: %d hPa\r\n", pressureData); + printf("*********************************************************************************\r\n"); + } else { + flag = 0; + } + break; + + case OM2JCIEBU_BLE::NOISE: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::NOISE, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement Sound noise Attribute Values ***************\r\n"); + printf("Sound noise :: %d dB\r\n", sensorParamData); + printf("*************************************************************************\r\n"); + } else { + flag = 0; + } + break; + + case OM2JCIEBU_BLE::ETVOC: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ETVOC, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("**************** Advertisement eTVOC Attribute Values ******************\r\n"); + printf("eTVOC :: %d ppb\r\n", sensorParamData); + printf("************************************************************************\r\n"); + } else { + flag = 0; + } + break; + case OM2JCIEBU_BLE::ECO2: + if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ECO2, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) { + printf("************** Advertisement eCO2 Attribute Values ***************\r\n"); + printf("eCO2 :: %d ppm\r\n\r\n", sensorParamData); + printf("******************************************************************\r\n"); + } else { + flag = 0; + } + break; + } + printf("\r\n"); + p_om2jcieble->delay(displayDelay); + } + } else if(parameterChoice == PREVIOUS_MENU_CHOICE) { + break; + } else { + printf("Invalid choice\r\n"); + } + seconds_validate = false; + } +} + +void configureLEDSetting(OM2JCIEBU_BLE *p_om2jcieble) +{ + if(p_om2jcieble == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + int led_choice = 0; + unsigned short int red_scale = 0, green_scale = 0, blue_scale = 0; + bool red_scale_validate = false, green_scale_validate = false, blue_scale_validate = false; + printf("************** Sensor LED Configuration ***************\r\n"); + printf("Please select a operation for LED\r\n"); + printf("0) Normally OFF\r\n"); + printf("1) Normally ON\r\n"); + printf("2) Temperature value scales\r\n"); + printf("3) Relative humidity value scales\r\n"); + printf("4) Ambient light value scales\r\n"); + printf("5) Barometric pressure value scales\r\n"); + printf("6) Sound noise value scales\r\n"); + printf("7) eTVOC value scales\r\n"); + printf("8) SI vale scales\r\n"); + printf("9) PGA value scales\r\n"); + printf("**********************************************************\r\n"); + while(!(std::cin >> led_choice)) { + std::cin.clear(); //clear bad input flag + std::cin.ignore(std::numeric_limits::max(), '\n'); //discard input + std::cout << "Invalid input; please re-enter.\n"; + } + + if(led_choice == OM2JCIEBU_BLE::NORMALLY_ON) { + printf("Please select a LED color scale\r\n"); + printf("Please enter Red Color scale (scale range 0 to 255)\r\n"); + while(!red_scale_validate) { + cin >> red_scale; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (red_scale >= 0 && red_scale <= 255)) { + red_scale_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an red color scale between 0 and 255!" << endl; + } + } + printf("Please enter Green Color scale(scale range 0 to 255)\r\n"); + while(!green_scale_validate) { + cin >> green_scale; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (green_scale >= 0 && green_scale <= 255)) { + green_scale_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an green color scale between 0 and 255!" << endl; + } + } + printf("Please enter Blue Color scale(scale range 0 to 255)\r\n"); + while(!blue_scale_validate) { + cin >> blue_scale; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (blue_scale >= 0 && blue_scale <= 255)) { + blue_scale_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an blue color scale between 0 and 255!" << endl; + } + } + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NORMALLY_ON, red_scale, green_scale, blue_scale); + } else { + switch(led_choice) { + case OM2JCIEBU_BLE::NORMALLY_OFF: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NORMALLY_OFF, 0, 0, 0); + break; + case OM2JCIEBU_BLE::TEMP_SACLE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::TEMP_SACLE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::HUMIDITY_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::HUMIDITY_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::AMBIENT_LIGHT_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::AMBIENT_LIGHT_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::PRESSURE_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::PRESSURE_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::NOISE_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NOISE_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::ETVOC_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::ETVOC_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::SI_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::SI_SCALE, 0, 0, 0); + break; + case OM2JCIEBU_BLE::PGA_SCALE: + p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::PGA_SCALE, 0, 0, 0); + break; + default: + std::cout << "Wrong LED scale choice please try again" << std::endl; + } + } +} + +void configureAdvInterval(OM2JCIEBU_BLE *p_om2jcieble) +{ + if(p_om2jcieble == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + uint16_t millisecond = 0; + bool milisecond_validate = false; + int advertising_mode = 0; + printf("************** Sensor Advertise Configuration ***************\r\n"); + printf("Please enter time interval (in Milliseconds), for changing Advertise interval, between 100 to 10240 milliseconds\r\n"); + while(!milisecond_validate) { + cin >> millisecond; + if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (millisecond >= 100 && millisecond <= 10240)) { + milisecond_validate = true; + } else { + cin.clear(); + cin.ignore(); + cout << "Error, enter an millisecond between 100 and 10240!" << endl; + } + } + printf("Please select an Advertise mode with the selected Advertise interval \r\n"); + printf("1) Sensor data\r\n"); + printf("2) Calculation data\r\n"); + printf("3) Sensor data and Calculation data\r\n"); + printf("4) Sensor flag and Calculation flag\r\n"); + printf("5) Serial number\r\n"); + while(!(std::cin >> advertising_mode)) { + std::cin.clear(); //clear bad input flag + std::cin.ignore(std::numeric_limits::max(), '\n'); //discard input + std::cout << "Invalid input; please re-enter.\n"; + } + switch(advertising_mode) { + case OM2JCIEBU_BLE::SENSOR_DATA: + p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::SENSOR_DATA); + break; + case OM2JCIEBU_BLE::ACCELERATION_DATA: + p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_DATA); + break; + case OM2JCIEBU_BLE::ACCELERATION_SENSOR_DATA: + p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_SENSOR_DATA); + break; + case OM2JCIEBU_BLE::ACCELERATION_SENSOR_FLAG: + p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_SENSOR_FLAG); + break; + case OM2JCIEBU_BLE::SERIAL_NUMBER: + p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::SERIAL_NUMBER); + break; + default: + std::cout << "Invalid choice\n"; + } + printf("**************************************************************\r\n"); +} + +int +main(int argc, char *argv[]) +{ + int operation_choice = 0; + if(argc <= 1) { + std::cout << "usage ./a.out xx:xx:xx:xx:xx:xx" << std::endl; + return 0; + } + signal(SIGABRT, sig_handler); + signal(SIGINT, sig_handler); + upm::OM2JCIEBU_BLE om2jciebu_ble(argv[1]); + while(true) { + std::cout << "*************************************************************" << std::endl; + std::cout << "Please choose one option for Omron sensor operation" << std::endl; + std::cout << "1) Display Advertisement Sensor attriutes" << std::endl; + std::cout << "2) Display Sensor attriutes" << std::endl; + std::cout << "3) Configure LED setting " << std::endl; + std::cout << "4) Configure advertise setting" << std::endl; + std::cout << "5) Exit" << std::endl; + std::cout << "*************************************************************" << std::endl; + while(!(std::cin >> operation_choice)) { + std::cin.clear(); //clear bad input flag + std::cin.ignore(std::numeric_limits::max(), '\n'); //discard input + std::cout << "Invalid input; please re-enter.\n"; + } + + switch(operation_choice) { + case 1: + getAdvSensorData(&om2jciebu_ble); + break; + case 2: + getSensorData(&om2jciebu_ble); + break; + case 3: + configureLEDSetting(&om2jciebu_ble); + break; + case 4: + configureAdvInterval(&om2jciebu_ble); + break; + case 5: + std::cout << "Application Exited" << std::endl; + om2jciebu_ble.removeBleDevice(); + exit(0); + break; + default: + std::cout << "Invalid choice" << std::endl; + break; + } + } +} diff --git a/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.cxx b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.cxx new file mode 100644 index 00000000..f5fcca36 --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.cxx @@ -0,0 +1,500 @@ +/* +* Author: Hiroyuki Mino +* Copyright (c) 2019 Omron Electronic Components - Americas +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of +* this software and associated documentation files (the "Software"), to deal in +* the Software without restriction, including without limitation the rights to +* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +* the Software, and to permit persons to whom the Software is furnished to do so, +* subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + +#include "2jciebu01_ble.hpp" + +using namespace upm; +using namespace std; + + + +OM2JCIEBU_BLE::OM2JCIEBU_BLE(std::string ble_address) +{ + //initializing tinyB + try { + bleManager = BluetoothManager::get_bluetooth_manager(); + } catch(const std::runtime_error& e) { + std::cerr << "Error while initializing libtinyb: " << e.what() << std::endl; + exit(1); + } + OM2JCIEBU_BLE::bleMACaddress = ble_address; + +} + +bool OM2JCIEBU_BLE::connectBleDevice(std::string ble_address) +{ + + bool ret; + //Start BLE discovery + if(startBleDiscovery()) { + std::cout << "Searching for Sensor...\r\n"; + for(int i = 0; i < OM2JCIEBU_BLE_DISCOVERY_RETRY ; ++i) { + auto list = bleManager->get_devices(); + + for(auto it = list.begin(); it != list.end(); ++it) { +#if DEBUG_LOG + std::cout << "Class = " << (*it)->get_class_name() << " "; + std::cout << "Path = " << (*it)->get_object_path() << " "; + std::cout << "Name = " << (*it)->get_name() << " "; + std::cout << "Connected = " << (*it)->get_connected() << " "; + std::cout << std::endl; +#endif + + /* Search for the device with the address given as a parameter to the program */ + if((*it)->get_address() == ble_address) { + bleSensorTag = (*it).release(); + } + } + /* Free the list of devices and stop if the device was found */ + if(bleSensorTag != nullptr) { + std::cout << "Omron Sensor found : " << ble_address << std::endl; + break; + } + std::this_thread::sleep_for(std::chrono::seconds(4)); + } + } + ret = stopBleDiscovery(); + std::cout << "Stopped Ble Discovery = " << (ret ? "true" : "false") << std::endl; + if(bleSensorTag == nullptr) { + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find device " + ble_address); + } + if(bleSensorTag->connect()) { + is_BleConnected = true; + } + return is_BleConnected; +} + +bool OM2JCIEBU_BLE::removeBleDevice() +{ + if(is_BleConnected) { //disconnect with device if connected + if(bleSensorTag->disconnect()) { + is_BleConnected = false; + } + } + return is_BleConnected; +} + +bool OM2JCIEBU_BLE::startBleDiscovery() +{ + return bleManager->start_discovery(); +} + +bool OM2JCIEBU_BLE::stopBleDiscovery() +{ + return bleManager->stop_discovery(); +} + +bool OM2JCIEBU_BLE::writePacket(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, const std::vector &arg_value) +{ + if(!(is_BleConnected)) { //Connect with device if not connected + if(!(connectBleDevice(OM2JCIEBU_BLE::bleMACaddress))) { + return false; + } + } + const char *cptr = (const char *)malloc(MAX_UUID_SIZE); + if(cptr == NULL) { + printf("Error. Allocation was unsuccessful. \r\n"); + return false; + } + memset((void *)cptr, 0, 64); + getAddress(attribute_name, BLE, (void *)cptr); + std::string uuid = ((const char *)cptr); + free((void *)cptr); + uint16_t getServiceRetryCount = 0; + while(true) { + auto list = bleSensorTag->get_services(); + //check for service list is empty or not + if(list.empty()) { + std::cout << "get services list empty " << std::endl; + getServiceRetryCount++; + if(getServiceRetryCount == OM2JCIEBU_BLE_DISCOVERY_RETRY) { + getServiceRetryCount = 0; + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find services "); + } + sleep(1); + continue; + } + for(auto it = list.begin(); it != list.end(); ++it) { +#if DEBUG_LOG + std::cout << "Class = " << (*it)->get_class_name() << " "; + std::cout << "Path = " << (*it)->get_object_path() << " "; + std::cout << "UUID = " << (*it)->get_uuid() << " "; + std::cout << "Device = " << (*it)->get_device().get_object_path() << " "; + std::cout << std::endl; +#endif + + /* Search for the LIVE sensor data service, by UUID */ + if((*it)->get_uuid() == OM2JCIEBU_BLE_LED_AND_ADV_CONFIGUARTION_SERVICE) { + bleService = (*it).release(); + } + } + break; + } + if(bleService != nullptr) { + auto charList = bleService->get_characteristics(); + std::cout << "Discovered characteristics: " << uuid << std::endl; + for(auto it = charList.begin(); it != charList.end(); ++it) { +#if DEBUG_LOG + std::cout << "Class = " << (*it)->get_class_name() << " "; + std::cout << "Path = " << (*it)->get_object_path() << " "; + std::cout << "UUID = " << (*it)->get_uuid() << " "; + std::cout << "Service = " << (*it)->get_service().get_object_path() << " "; + std::cout << std::endl; +#endif + + if((*it)->get_uuid() == uuid) { + bleSensorChar = (*it).release(); + } + } + } else { + //If not find any sevice then disconnect BLE device + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find Service "); + } + if(bleSensorChar == nullptr) { + //If not find any characteristics then disconnect BLE device + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find characteristics "); + } + bool ret = bleSensorChar->write_value(arg_value, 0); + return ret; +} + +OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T OM2JCIEBU_BLE::getDiscoveredServices(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name) +{ + if(!(is_BleConnected)) { //Connect with device if not connected + if(!(connectBleDevice(OM2JCIEBU_BLE::bleMACaddress))) { + return FAILURE; + } + } + short int getServiceRetryCount = 0; + const char *cptr = (const char *)malloc(MAX_UUID_SIZE); + if(cptr == NULL) { + printf("Error. Allocation was unsuccessful. \r\n"); + return FAILURE; + } + memset((void *)cptr, 0, MAX_UUID_SIZE); + getAddress(attribute_name, BLE, (void *)cptr); + std::string uuid = ((const char *)cptr); + free((void *)cptr); + //read services from connected BLE device + while(true) { + auto list = bleSensorTag->get_services(); + if(list.empty()) { + std::cout << "get services list empty " << std::endl; + getServiceRetryCount++; + if(getServiceRetryCount == OM2JCIEBU_BLE_DISCOVERY_RETRY) { + getServiceRetryCount = 0; + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Not Found any service "); + } + sleep(1); + continue; + } + for(auto it = list.begin(); it != list.end(); ++it) { +#if DEBUG_LOG + std::cout << "Class = " << (*it)->get_class_name() << " "; + std::cout << "Path = " << (*it)->get_object_path() << " "; + std::cout << "UUID = " << (*it)->get_uuid() << " "; + std::cout << "Device = " << (*it)->get_device().get_object_path() << " "; + std::cout << std::endl; +#endif + //check for service + if((*it)->get_uuid() == OM2JCIEBU_BLE_LIVE_SENSOR_DATA_SERVICE) { + bleService = (*it).release(); + } + } + break; + } + if(bleService != nullptr) { + auto charList = bleService->get_characteristics(); + std::cout << "Discovered characteristics: " << uuid << std::endl; + for(auto it = charList.begin(); it != charList.end(); ++it) { +#if DEBUG_LOG + std::cout << "Class = " << (*it)->get_class_name() << " "; + std::cout << "Path = " << (*it)->get_object_path() << " "; + std::cout << "UUID = " << (*it)->get_uuid() << " "; + std::cout << "Service = " << (*it)->get_service().get_object_path() << " "; + std::cout << std::endl; +#endif + //compare UUID + if((*it)->get_uuid() == uuid) { + bleSensorChar = (*it).release(); + return SUCCESS; + } + } + } else { + //If not find any sevice then disconnect BLE device + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find characteristics "); + } + if(bleSensorChar == nullptr) { + //If not find any characteristics then disconnect BLE device + removeBleDevice(); + throw std::runtime_error(std::string(__FUNCTION__) + + ": Could not find characteristics "); + } + return FAILURE; +} + + +OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T OM2JCIEBU_BLE::getSensorData(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attribute_data) +{ + if(attribute_data == NULL) { + std::cout << "Null pointer received..." << std::endl; + return FAILURE; + } + unsigned char *data; + OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T verifyResult = FAILURE; + //Read raw data from connected BLE device based on characteristics + std::vector response = bleSensorChar->read_value(); + unsigned int size = response.size(); + if(size > 0) { + data = response.data(); +#if DEBUG_LOG + std::cout << "Raw data=["; + for(unsigned i = 0; i < response.size(); i++) + std::cout << std::hex << static_cast(data[i]) << ", "; + std::cout << "] "; + std::cout << "" << std::endl; +#endif + //parse a data which is read from connected device + parseSensorData(data); + //Get data from structer + getSensorAttribute(attribute_name, attribute_data); + verifyResult = SUCCESS; + } + return verifyResult; +} + +OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T OM2JCIEBU_BLE::getAdvSensorData(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attribute_data) +{ + if(attribute_data == NULL) { + std::cout << "Null pointer received..." << std::endl; + return FAILURE; + } + uint8_t advSensordata[MAX_SENSOR_DATA_SIZE] = {0}; + int advDataindex = 0; + OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T verifyResult = FAILURE; + if(is_BleConnected) { //disconnect with device if connected + removeBleDevice(); + is_BleConnected = false; + } + + if(startBleDiscovery()) { + auto list = bleManager->get_devices(); + + for(auto it = list.begin(); it != list.end(); ++it) { + //read manufacturer data + auto mfg = (*it)->get_manufacturer_data(); + if(!mfg.empty()) { + //read manufacturer data for particular MAC address which is given by user + if((*it)->get_address() == bleMACaddress) { +#if DEBUG_LOG + std::cout << "MFG" << std::endl; + for(auto it : mfg) { + std::cout << it.second.size() << std::endl; + std::cout << "\t" << it.first << " = [ "; + for(auto arr_it : it.second) { + std::cout << std::hex << (int) arr_it << ", "; + } + std::cout << "]" << std::endl; + } +#endif + //store in buffer for verify data and parsing + for(auto it : mfg) { + advSensordata[advDataindex++] = it.first; + advSensordata[advDataindex++] = it.first >> 8; + for(auto arr_it : it.second) { + advSensordata[advDataindex++] = arr_it; + } + } + //verfiy a packet + verifyResult = verifyPacket(advSensordata, advDataindex); + if(verifyResult == SUCCESS) { + parseAdvSensorData(advSensordata); + getSensorAttribute(attribute_name, attribute_data); + advDataindex = 0; + } + } + } + } + } + return verifyResult; +} + +void OM2JCIEBU_BLE::getSensorAttribute(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attributeValue) +{ + if(attributeValue == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + switch(attribute_name) { + case ALL_PARAM: + memcpy(attributeValue, &om2jciebuData_ble, sizeof(om2jciebuData_ble)); + break; + case TEMP: + *(int16_t *) attributeValue = om2jciebuData_ble.temperature; + break; + case HUMIDITY: + *(int16_t *) attributeValue = om2jciebuData_ble.relative_humidity; + break; + case AMBIENT_LIGHT: + *(int16_t *) attributeValue = om2jciebuData_ble.ambient_light; + break; + case PRESSURE: + *(int32_t *) attributeValue = om2jciebuData_ble.pressure; + break; + case NOISE: + *(int16_t *) attributeValue = om2jciebuData_ble.noise; + break; + case ETVOC: + *(int16_t *) attributeValue = om2jciebuData_ble.eTVOC; + break; + case ECO2: + *(int16_t *) attributeValue = om2jciebuData_ble.eCO2; + break; + case DISCOMFORT_INDEX: + break; + case HEAT_STROKE: + break; + case LED_CONFIGURE: + break; + case ADV_CONFIGURE: + break; + } +} + +OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T OM2JCIEBU_BLE::verifyPacket(uint8_t *pkt, int len) +{ + if(pkt == NULL) { + std::cout << "Null pointer received..." << std::endl; + return FAILURE; + } + OM2JCIEBU_BLE::OM2JCIEBU_ERROR_T verifyResult = FAILURE; + if(pkt[OM2JCIEBU_BLE_COM_ID_INDEX] == 0xD5) { //Check for Omron company ID + if(pkt[OM2JCIEBU_BLE_COM_ID_INDEX + 1] == 0x02) { + if(pkt[OM2JCIEBU_BLE_DATA_TYPE_INDEX] == 0x01) { // Check for sensor data type + verifyResult = SUCCESS; + } else { + printf("Unable to get sensor data in advertisement packet,Please check advertisement setting\r\n"); + verifyResult = ERROR_UNKNOWN ; + } + } + } else { + printf("Unable to get sensor data in advertisement packet,Please check advertisement setting\r\n"); + verifyResult = ERROR_UNKNOWN ; + } + return verifyResult; +} + +void OM2JCIEBU_BLE::configureSensorLedState(OM2JCIEBU::OM2JCIEBU_LED_SCALE_T state, uint8_t red, uint8_t green, uint8_t blue) +{ + std::vector led_scale; + + led_scale.push_back(state); + led_scale.push_back(0x00); + led_scale.push_back(red); + led_scale.push_back(green); + led_scale.push_back(blue); + + writePacket(LED_CONFIGURE, led_scale); +} + +void OM2JCIEBU_BLE::configureSensorAdvSetting(uint16_t milliseconds, OM2JCIEBU::OM2JCIEBU_ADV_PARAM_T adv_mode) +{ + std::vector advSetting; + uint16_t interval = 0; + interval = milliseconds / OM2JCIEBU_INTERVAL_UNIT;/*calculate interval which is given by user using interval unit */ + + advSetting.push_back(interval & 0x00FF); + advSetting.push_back(interval >> 8); + advSetting.push_back(adv_mode); + + writePacket(ADV_CONFIGURE, advSetting); +} + +void OM2JCIEBU_BLE::parseSensorData(uint8_t *data) +{ + /* pasre and calculate sensor data and store in sensor data struct*/ + if(data == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + om2jciebuData_ble.sequence_number = data[0]; + + om2jciebuData_ble.temperature = data[1] | data[2] << 8; + om2jciebuData_ble.temperature = om2jciebuData_ble.temperature / 100; + + om2jciebuData_ble.relative_humidity = data[3] | data[4] << 8; + om2jciebuData_ble.relative_humidity = om2jciebuData_ble.relative_humidity / 100; + + om2jciebuData_ble.ambient_light = data[5] | data[6] << 8; + + om2jciebuData_ble.pressure = data[7] | data[8] << 8 | data[9] << 16 | data[10] << 24; + om2jciebuData_ble.pressure = om2jciebuData_ble.pressure / 1000; + + om2jciebuData_ble.noise = data[11] | data[12] << 8; + om2jciebuData_ble.noise = om2jciebuData_ble.noise / 100; + + om2jciebuData_ble.eTVOC = data[13] | data[14] << 8; + + om2jciebuData_ble.eCO2 = data[15] | data[16] << 8; +} + +void OM2JCIEBU_BLE::parseAdvSensorData(uint8_t *data) +{ + /* pasre and calculate Advertisement data and store in sensor data struct*/ + if(data == NULL) { + std::cout << "Null pointer received..." << std::endl; + return; + } + om2jciebuData_ble.sequence_number = data[3]; + + om2jciebuData_ble.temperature = data[4] | data[5] << 8; + om2jciebuData_ble.temperature = om2jciebuData_ble.temperature / 100; + + om2jciebuData_ble.relative_humidity = data[6] | data[7] << 8; + om2jciebuData_ble.relative_humidity = om2jciebuData_ble.relative_humidity / 100; + + om2jciebuData_ble.ambient_light = data[8] | data[9] << 8; + + om2jciebuData_ble.pressure = data[10] | data[11] << 8 | data[12] << 16 | data[13] << 24; + om2jciebuData_ble.pressure = om2jciebuData_ble.pressure / 1000; + + om2jciebuData_ble.noise = data[14] | data[15] << 8; + om2jciebuData_ble.noise = om2jciebuData_ble.noise / 100; + + om2jciebuData_ble.eTVOC = data[16] | data[17] << 8; + + om2jciebuData_ble.eCO2 = data[18] | data[19] << 8; +} + + diff --git a/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.hpp b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.hpp new file mode 100644 index 00000000..83b31c1c --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.hpp @@ -0,0 +1,230 @@ +/* +* +* Author: Hiroyuki Mino +* Copyright (c) 2019 Omron Electronic Components - Americas +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of +* this software and associated documentation files (the "Software"), to deal in +* the Software without restriction, including without limitation the rights to +* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +* the Software, and to permit persons to whom the Software is furnished to do so, +* subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all +* copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +/*=========================================================================*/ + +#pragma once + + +#include +#include +#include +#include +#include +#include +#include +#include +#include "../2jciebu01.hpp" + +/*MACROS and enum */ + + +#define OM2JCIEBU_BLE_DISCOVERY_RETRY 15 +#define OM2JCIEBU_BLE_LED_AND_ADV_CONFIGUARTION_SERVICE "ab705110-0a3a-11e8-ba89-0ed5f89f718b" +#define OM2JCIEBU_BLE_LIVE_SENSOR_DATA_SERVICE "ab705010-0a3a-11e8-ba89-0ed5f89f718b" + +#define OM2JCIEBU_BLE_COM_ID_INDEX 0x00 +#define OM2JCIEBU_BLE_DATA_TYPE_INDEX 0x02 + +#define VERIFY_PACKET 0 +#define DEBUG_LOG 0 +#define MAX_UUID_SIZE 64 +#define MAX_SENSOR_DATA_SIZE 64 + + +/*=========================================================================*/ + +namespace upm +{ +/** + * @brief 2JCIEBU01 Environment sensor + * @defgroup 2jciebu01 libupm-2jciebu01_ble + * @ingroup Omron USB type + */ + +/** + * @library libupm-2jciebu01_ble + * @sensor 2jciebu01 + * @comname Environment Sensor Module + * @altname Omron Environment sensor USB type + * @type USB + * @man Omron + * @web https://www.components.omron.com/solutions/mems-sensors/environment-sensor + * @con ble + * + * @brief API for the Omron USB type environment Sensor Module using BLE interface + * + * It is connected via a BLE Interface + * + * @snippet 2jciebu01_ble.cxx Interesting + */ +class OM2JCIEBU_BLE : public OM2JCIEBU +{ +public : + + /** + * OM2JCIEBU_BLE Constructor, takes the device address as + * an argument + * + * @param device MAC address of Omron Environment Sensor + */ + OM2JCIEBU_BLE(std::string ble_address); + + + /** + * Get discovery service from Connetced BLE device + * + * @param attribute_name attribute name of sensor + * @return OM2JCIEBU_ERROR_T + */ + OM2JCIEBU_ERROR_T getDiscoveredServices(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name); + + /** + * Get omron sensor live data as per request uisng 0x5012 UUID + * + * @param attribute_name Name of attribute + * @param attribute_data Data of attirbute + * @return One of the OM2JCIEBU_ERROR_T values + */ + OM2JCIEBU_ERROR_T getSensorData(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attribute_data); + + /** + * Get omron sensor live data based on advertise payload + * + * @param attribute_name Name of attribute + * @param attribute_data Data of attirbute + * @return One of the OM2JCIEBU_ERROR_T values + */ + OM2JCIEBU_ERROR_T getAdvSensorData(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attribute_data); + + /** + * Set LED configartion of sensor + * + * @param state state for led configuartion + * @param red value of red + * @param green value of green + * @param blue value of blue + */ + void configureSensorLedState(OM2JCIEBU::OM2JCIEBU_LED_SCALE_T state, uint8_t red, uint8_t green, uint8_t blue); + + /** + * Set Advertise interval setting of sensor + * + * @param miliseconds interval for Advertise data + * @param adv_mode Advertise mode + */ + void configureSensorAdvSetting(uint16_t milliseconds, OM2JCIEBU::OM2JCIEBU_ADV_PARAM_T adv_mode); + + /** + * Disconnect BLE Device + * + * @return Return success or Failure + * + */ + bool removeBleDevice(); + +private: + BluetoothManager *bleManager = nullptr; + BluetoothDevice *bleSensorTag = nullptr; + BluetoothGattCharacteristic *bleSensorChar = nullptr; + BluetoothGattService *bleService = nullptr; + om2jciebuData_t om2jciebuData_ble; + std::string bleMACaddress; + bool is_BleConnected = false; + + + /** + *connect BLE Device + * + * @param device_address BLE deivce adddress + * + * @return Return success or Failure + */ + bool connectBleDevice(std::string ble_address); + + /** + * Start BLE Discovery + * + * @return Return success or Failure + */ + bool startBleDiscovery(); + + /** + * Stop BLE Discovery + * + * @return Return success or Failure + */ + bool stopBleDiscovery(); + + + /** + * Get sensor data from global struct. + * + * @param attribute_name attribute_name of sensor data + * @param attributeValue Data of attirbute + */ + + void getSensorAttribute(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, void *attributeValue); + + /** + * Verifies the packet header and indicates its valid or not + * + * @param pkt Packet to check + * @param len length of packet + * @return One of the OM2JCIEBU_ERROR_T values + */ + + OM2JCIEBU_ERROR_T verifyPacket(uint8_t *pkt, int len); + + + /** + * Calculate and parse advertise sensor data and store into + * structure + * + * @param data Packet + * + */ + void parseAdvSensorData(uint8_t *data); + + /** + * Calculate and parse sensor data and store into + * structure + * + * @param data Packet + * + */ + void parseSensorData(uint8_t *data); + + + /** + * Write packet over BLE + * + * @param attribute_name attribute_name of sensor + * @param arg_value arg value for write a data over BLE + * + * @return Return success or Failure + */ + bool writePacket(OM2JCIEBU::OM2JCIEBU_ATTRIBUTE_T attribute_name, const std::vector &arg_value); +}; +} + diff --git a/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.i b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.i new file mode 100644 index 00000000..5fd025e4 --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.i @@ -0,0 +1,8 @@ +%include "../common_top.i" + +/* BEGIN Common SWIG syntax ------------------------------------------------- */ +%{ +#include "2jciebu01_ble.hpp" +%} +%include "2jciebu01_ble.hpp" +/* END Common SWIG syntax */ diff --git a/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.json b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.json new file mode 100644 index 00000000..fe2a99b4 --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/2jciebu01_ble.json @@ -0,0 +1,29 @@ +{ + "Library": "2jciebu01_ble", + "Description": "Omron Environment Sensor", + "Sensor Class": { + "OM2JCIEBU_BLE": { + "Name": "API for 2JCIEBU01 Sensor Module using BLE interface", + "Description": "This is the UPM Module for the Omron Environment Sensor Module using BLE interface.", + "Aliases": [""], + "Categories": ["USB"], + "Connections": ["ble"], + "Project Type": ["sensor"], + "Manufacturers": ["Omron"], + "Image": "", + "Examples": { + "C++": ["omron2jciebu01_ble.cxx"] + }, + "Platforms": { + "Intel Edison": { + "Notes": ["Might need USB type omron environment sensor"] + } + }, + "Urls": { + "Product Pages": ["https://www.components.omron.com/solutions/mems-sensors/environment-sensor"], + "Datasheets": ["https://omronfs.omron.com/en_US/ecb/products/pdf/A279-E1-01.pdf"] + } + } + } +} + diff --git a/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/CMakeLists.txt b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/CMakeLists.txt new file mode 100644 index 00000000..6dfdfcc0 --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/2jciebu-ble/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "2jciebu01_ble") +set (libdescription "Omron Environment Sensor") +set (module_src ${libname}.cxx "2jciebu01.cxx") +set (module_hpp ${libname}.hpp "2jciebu01.hpp") +upm_module_init(2jciebu01-usb) diff --git a/Omron_2jcie-bu01_ble/upm/src/CMakeLists.txt b/Omron_2jcie-bu01_ble/upm/src/CMakeLists.txt new file mode 100644 index 00000000..008204bc --- /dev/null +++ b/Omron_2jcie-bu01_ble/upm/src/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(om2jciebu-ble) +file(COPY 2jciebu01.hpp DESTINATION /usr/local/include/)