diff --git a/examples/c++/2smpb02e.cxx b/examples/c++/2smpb02e.cxx
new file mode 100644
index 00000000..46278938
--- /dev/null
+++ b/examples/c++/2smpb02e.cxx
@@ -0,0 +1,1193 @@
+/*
+* Author: Hiroyuki Mino <omronsupportupm@omron.com>
+* 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.
+*/
+
+/* headers */
+#include "2smpb02e.hpp"
+
+#include <limits>
+#include <signal.h>
+#include <upm_utilities.h>
+#include <sys/time.h>
+#include <iomanip>
+
+
+/* Define */
+#define CLEAR_SCREEN "\033[2J\033[1;1H" /* Clear screen */
+
+using namespace upm;
+using namespace std;
+
+volatile sig_atomic_t flag = true;
+UINT8 isCinWaitState = 0; //State for cin is waiting for input or not.
+
+void
+sig_handler(int signum)
+{
+ // Check for Interrupt signal
+ if (signum == SIGINT || signum == SIGTERM){
+ cout << "exit" << endl;
+ flag = false;
+ if(isCinWaitState ==1){
+ std::cin.setstate(std::ios_base::badbit);
+ }
+ }
+}
+
+UINT8
+takeInput(STRING str, INT32 &value, INT32 startIndex, INT32 endIndex){// Take input
+
+ isCinWaitState = 1;
+
+ try{
+ cin.exceptions(std::ios_base::badbit);
+
+ do{
+ cout << str;
+ cin >> value;
+
+ // Clear and ignor bad input
+ if(isdigit(value) != true){
+ cin.clear(); // reset badbit
+ cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //skip bad input
+ }
+
+ // Check start index and end index with input value
+ if(value < startIndex || value > endIndex){
+ cout << "*************************************************************" << endl;
+ cout << "Invalid choice. Please select from " << std::dec << startIndex << " to " << endIndex << "." << endl;
+ cout << "*************************************************************" << endl;
+ }else{
+ isCinWaitState = 0;
+ return true;
+ }
+
+ }while((value < startIndex || value > endIndex) && flag);
+
+ }catch (std::ios_base::failure& fail){
+
+ isCinWaitState = 0;
+ return false;
+ }
+
+ isCinWaitState = 0;
+ return false;
+}
+
+int
+main(int argc, char** argv)
+{
+ INT32 bus = OM2SMPB02E_DEFAULT_I2C_BUS_NUM;
+ UINT32 display_time = 1000;
+ UINT8 addr = OM2SMPB02E_DEFAULT_I2C_ADDR;
+ TemperatureUnit iTempscale = TemperatureUnit::CELSIUS;
+ PressureUnit iPresscale = PressureUnit::PA;
+ INT32 choice,sub_choice,input,sub_input;
+ UINT8 chipId;
+ OM2SMPB02E_STATUS_T returnStatus;
+ UINT8 ret;
+
+ OM2SMPB02E_VAL_POWERMODE_VALUES_T powerMode;
+ OM2SMPB02E_VAL_MEASMODE_VALUES_T measMode;
+ OM2SMPB02E_VAL_IIR_VALUES_T iirVal;
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T standbyTimeValue;
+
+ FLOAT temperatureData;
+ FLOAT pressureData;
+
+ // Data and Time
+ INT8 dateAndTime[30];
+ struct timeval value;
+ time_t curtime;
+
+ signal(SIGINT, sig_handler);
+
+ // Instantiate a 2SMPB02E sensor on I2C using bus and address.
+ OM2SMPB02E sensor(bus,addr);
+
+ while(flag){
+
+ // Clear screen
+ cout << CLEAR_SCREEN;
+
+ // Get Device Chip Id
+ returnStatus = sensor.getDeviceId(chipId);
+
+ // Check return value
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get Device Id with error code : " << returnStatus << endl;
+ return 0;
+ }
+
+ cout << "*************************************************************" << endl;
+ cout << " Barometric Pressure Sensor Chip ID (Device ID) : " << hex
+ << uppercase << (unsigned) chipId << endl;
+
+ // Print main menu for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " MAIN MENU " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. Display Temperature " << endl;
+ cout << "2. Display Pressure " << endl;
+ cout << "3. Display Temperature and Pressure " << endl;
+ cout << "4. Settings " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from main menu : ",choice,1,4);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(choice){
+
+ case 1:// Display Temperature
+
+ // Print Temperature scale for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Temperature Scale " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. CELSIUS [deg C] " << endl;
+ cout << "2. FAHRENHEIT [deg F] " << endl;
+ cout << "3. KELVIN [deg K] " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of temperature scale : ",sub_choice,1,3);
+
+ if(ret != true){
+ break;
+ }
+
+ // Update Temperature scale variable
+ switch(sub_choice){
+
+ case 1:// Celsius
+ iTempscale = TemperatureUnit::CELSIUS;
+ break;
+
+ case 2:// Fahrenheit
+ iTempscale = TemperatureUnit::FAHRENHEIT;
+ break;
+
+ case 3:// Kelvin
+ iTempscale = TemperatureUnit::KELVIN;
+ break;
+
+ default:
+ break;
+
+ }// end switch select temperature scale
+
+ // Set temperature scale
+ returnStatus = sensor.setTemperatureScale(iTempscale);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set Temperature scale with error code : " << returnStatus << endl;
+ break;
+ }
+
+ // Print display time
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Display time " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Please enter display time [ms] : ",input,1,1000000);
+
+ if(ret != true){
+ break;
+ }
+
+ display_time = input;
+
+ // Set precision
+ cout << fixed << setprecision(2);
+
+ cout << "*************************************************************" << endl;
+ cout << "Timestamp Temperature " << endl;
+ cout << "*************************************************************" << endl;
+
+ while(flag){
+
+ // Get date and time
+ gettimeofday(&value, NULL);
+ curtime=value.tv_sec;
+ strftime(dateAndTime,30,"[%F %T.",localtime(&curtime));
+ cout << dateAndTime << std::setfill('0') << std::setw(3) << std::dec << value.tv_usec/1000 << "] " << setfill(' ') << setw(1) << " ";
+
+ // Get temperature value
+ returnStatus = sensor.getTemperature(temperatureData);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get temperatue value with error code : " << returnStatus << endl;
+ }else{
+ // Print temperature data
+ cout << temperatureData << endl;
+ }
+
+ //Delay
+ upm_delay_ms(display_time);
+ }
+
+ break;
+
+ case 2:// Display Pressure
+
+ // Print Pressure scale for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Pressure Scale " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. Pascal [pa] " << endl;
+ cout << "2. Bar [bar] " << endl;
+ cout << "3. Standard atmosphere [atm] " << endl;
+ cout << "4. Torr [torr] " << endl;
+ cout << "5. Pounds per square inch [psi] " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of pressure scale : ",sub_choice,1,5);
+
+ if(ret != true){
+ break;
+ }
+
+ // Update Pressure scale variable
+ switch(sub_choice){
+
+ case 1:// Pascal
+ iPresscale = PressureUnit::PA;
+ break;
+
+ case 2:// Bar
+ iPresscale = PressureUnit::BAR;
+ break;
+
+ case 3:// Standard Atmosphere
+ iPresscale = PressureUnit::ATM;
+ break;
+
+ case 4:// Torr
+ iPresscale = PressureUnit::TORR;
+ break;
+
+ case 5:// Pounds per square inch
+ iPresscale = PressureUnit::PSI;
+ break;
+
+ default:
+ break;
+
+ }// end switch select pressure scale
+
+ // Set Preesure scale
+ returnStatus = sensor.setPressureScale(iPresscale);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set pressure scale with error code : " << returnStatus << endl;
+ break;
+ }
+
+ // Print display time
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Display time " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Please enter display time [ms] : ",input,1,1000000);
+
+ if(ret != true){
+ break;
+ }
+
+ display_time = input;
+
+ cout << "*************************************************************" << endl;
+ cout << "Timestamp Pressure " << endl;
+ cout << "*************************************************************" << endl;
+
+ while(flag){
+
+ // Get date and time
+ gettimeofday(&value, NULL);
+ curtime=value.tv_sec;
+ strftime(dateAndTime,30,"[%F %T.",localtime(&curtime));
+ cout << dateAndTime << std::setfill('0') << std::setw(3) << std::dec << value.tv_usec/1000 << "] " << setfill(' ') << setw(1) << " ";
+
+ // Get pressure data
+ returnStatus = sensor.getPressure(pressureData);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get pressure value with error code : " << returnStatus << endl;
+ }else{
+ // Print pressure data
+ cout << fixed << (iPresscale==PressureUnit::PA?setprecision(2):setprecision(7)) << pressureData << endl;
+ }
+
+ //Delay
+ upm_delay_ms(display_time);
+ }
+
+ break;
+
+ case 3:// Display Temperature and Pressure
+
+ // Print Temperature scale for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Temperature Scale " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. CELSIUS [deg C] " << endl;
+ cout << "2. FAHRENHEIT [deg F] " << endl;
+ cout << "3. KELVIN [deg K] " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of temperature scale : ",sub_choice,1,3);
+
+ if(ret != true){
+ break;
+ }
+
+ // Update Temperature scale variable
+ switch(sub_choice){
+
+ case 1:// Celsius
+ iTempscale = TemperatureUnit::CELSIUS;
+ break;
+
+ case 2:// Fahrenheit
+ iTempscale = TemperatureUnit::FAHRENHEIT;
+ break;
+
+ case 3:// Kelvin
+ iTempscale = TemperatureUnit::KELVIN;
+ break;
+
+ default:
+ break;
+
+ }// end switch select temperature scale
+
+ // Set Temeperature scale
+ returnStatus = sensor.setTemperatureScale(iTempscale);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set Temperature scale with error code : " << returnStatus << endl;
+ break;
+ }
+
+ // Print Pressure scale for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Pressure Scale " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. Pascal [pa] " << endl;
+ cout << "2. Bar [bar] " << endl;
+ cout << "3. Standard atmosphere [atm] " << endl;
+ cout << "4. Torr [torr] " << endl;
+ cout << "5. Pounds per square inch [psi] " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of pressure scale : ",input,1,5);
+
+ if(ret != true){
+ break;
+ }
+
+ // Update Pressure scale variable
+ switch(input){
+
+ case 1:// Pascal
+ iPresscale = PressureUnit::PA;
+ break;
+
+ case 2:// Bar
+ iPresscale = PressureUnit::BAR;
+ break;
+
+ case 3:// Standard Atmosphere
+ iPresscale = PressureUnit::ATM;
+ break;
+
+ case 4:// Torr
+ iPresscale = PressureUnit::TORR;
+ break;
+
+ case 5:// Pounds per square inch
+ iPresscale = PressureUnit::PSI;
+ break;
+
+ default:
+ break;
+
+ }// end switch select pressure scale
+
+ // Set pressure scale
+ returnStatus = sensor.setPressureScale(iPresscale);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set pressure scale with error code : " << returnStatus << endl;
+ break;
+ }
+
+ // Print display time
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Display time " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Please enter display time [ms] : ",sub_input,1,1000000);
+
+ if(ret != true){
+ break;
+ }
+
+ display_time = sub_input;
+
+ cout << "*************************************************************" << endl;
+ cout << "Timestamp Temperature Pressure " << endl;
+ cout << "*************************************************************" << endl;
+
+ while(flag){
+
+ // Get date and time
+ gettimeofday(&value, NULL);
+ curtime=value.tv_sec;
+ strftime(dateAndTime,30,"[%F %T.",localtime(&curtime));
+ cout << dateAndTime << std::setfill('0') << std::setw(3) << std::dec << value.tv_usec/1000 << "]" << setfill(' ') << setw(3) << " ";
+
+ // Get pressura and temperature data
+ returnStatus = sensor.getPresAndTempValues(pressureData,temperatureData);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get pressure and temperature value with error code : " << returnStatus << endl;
+ }else{
+ // Print pressure and temperature data
+ cout << fixed << setprecision(2) << temperatureData << " " << setfill(' ') << setw(15) << " " << fixed << (iPresscale==PressureUnit::PA?setprecision(2):setprecision(7)) << pressureData << endl;
+ }
+
+ //Delay
+ upm_delay_ms(display_time);
+ }
+
+ break;
+ case 4:// Settings
+
+ // Print main menu for selection
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " SETTINGS " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. Get Power Mode " << endl;
+ cout << "2. Set Power Mode " << endl;
+ cout << "3. Get IIR filter value " << endl;
+ cout << "4. Set IIR filter value " << endl;
+ cout << "5. Get Measurement Mode " << endl;
+ cout << "6. Set Measurement Mode " << endl;
+ cout << "7. Set I2C Frequency " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of settings : ",sub_choice,1,7);
+
+ if(ret != true){
+ break;
+ }
+ switch(sub_choice){
+
+ case 1:// Get Power Mode
+
+ // Get Power mode
+ returnStatus = sensor.getPowerMode(powerMode);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get power mode with error code : " << returnStatus << endl;
+ break;
+ }
+
+ switch(powerMode){
+
+ case OM2SMPB02E_VAL_POWERMODE_SLEEP:
+ cout << "Power Mode : SLEEP" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_POWERMODE_FORCED:
+ cout << "Power Mode : FORCED" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_POWERMODE_NORMAL:
+
+ returnStatus = sensor.getStandbyTimeValue(standbyTimeValue);
+
+
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get standby time value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "Power Mode : NORMAL, and Standby Time Value : ";
+
+ switch(standbyTimeValue){
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_0001MS:
+ cout << "1 ms." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_0005MS:
+ cout << "5 ms." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_0050MS:
+ cout << "50 ms." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_0250MS:
+ cout << "250 ms." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_0500MS:
+ cout << "500 ms." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_1000MS:
+ cout << "1 s." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_2000MS:
+ cout << "2 s." << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IOSETUP_STANDBY_4000MS:
+ cout << "4 s." << endl;
+ break;
+
+ default:
+ cout << "Invalid value received for standby time." << endl;
+
+ }// end switch get standby time value
+
+ break;
+
+ default:
+ cout << "Invalid power mode value receive." << endl;
+
+ }// end switch getPowerMode
+
+ break;
+
+ case 2:// Set Power Mode
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " POWER MODE " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. Sleep " << endl;
+ cout << "2. Forced " << endl;
+ cout << "3. Normal " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of power mode : ",input,1,3);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(input){
+
+ case 1:// Sleep
+ powerMode = OM2SMPB02E_VAL_POWERMODE_SLEEP;
+ break;
+
+ case 2:// Forced
+ powerMode = OM2SMPB02E_VAL_POWERMODE_FORCED;
+ break;
+
+ case 3:// Normal
+ powerMode = OM2SMPB02E_VAL_POWERMODE_NORMAL;
+
+ // Set Standby time Value
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " STANDBY TIME VALUES " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. 1 ms " << endl;
+ cout << "2. 5 ms " << endl;
+ cout << "3. 50 ms " << endl;
+ cout << "4. 250 ms " << endl;
+ cout << "5. 500 ms " << endl;
+ cout << "6. 1 s " << endl;
+ cout << "7. 2 s " << endl;
+ cout << "8. 4 s " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of standby time value : ",sub_input,1,8);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(sub_input){
+
+ case 1:// 1 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_0001MS;
+ break;
+
+ case 2:// 5 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_0005MS;
+ break;
+
+ case 3:// 50 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_0050MS;
+ break;
+
+ case 4:// 250 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_0250MS;
+ break;
+
+ case 5:// 500 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_0500MS;
+ break;
+
+ case 6:// 1000 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_1000MS;
+ break;
+
+ case 7:// 2000 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_2000MS;
+ break;
+
+ case 8:// 4000 MS
+ standbyTimeValue = OM2SMPB02E_VAL_IOSETUP_STANDBY_4000MS;
+ break;
+
+ default:
+ break;
+ }//end switch set standby time value
+
+ break;
+
+ default:
+ break;
+
+ }//end switch set power mode
+
+ // Set power mode
+ returnStatus = sensor.setPowerMode(powerMode);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set power mode with error code : " << returnStatus << endl;
+ break;
+ }
+
+ if(input == 3){// Check Power mode input is Normal
+ returnStatus = sensor.setStandbyTimeValue(standbyTimeValue);
+
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set standby time value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "Power Mode set successfully with standby time value." << endl;
+
+ }else{
+ cout << "Power Mode successfully changed." << endl;
+ }
+
+ break;
+
+ case 3:// Get IIR filter value
+
+ // Get IIR Filter value
+ returnStatus = sensor.getIIRFilterValue(iirVal);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get IIR filter value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ switch(iirVal){
+
+ case OM2SMPB02E_VAL_IIR_OFF:
+ cout << "IIR Value : 0 Times (OFF)" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IIR_02TIMES:
+ cout << "IIR Value : 2 Times" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IIR_04TIMES:
+ cout << "IIR Value : 4 Times" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IIR_08TIMES:
+ cout << "IIR Value : 8 Times" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IIR_16TIMES:
+ cout << "IIR Value : 16 Times" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_IIR_32TIMES:
+ cout << "IIR Value : 32 Times" << endl;
+ break;
+
+ default:
+ cout << "Invalid iir value receive." << endl;
+
+ }// end switch getIIRFilterValue
+
+ break;
+
+ case 4:// Set IIR filter value
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " IIR Filter Value " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. 0 Times (OFF) " << endl;
+ cout << "2. 2 Times " << endl;
+ cout << "3. 4 Times " << endl;
+ cout << "4. 8 Times " << endl;
+ cout << "5. 16 Times " << endl;
+ cout << "6. 32 Times " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of iir filter value : ",input,1,6);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(input){
+
+ case 1:// 0 Times (OFF)
+ iirVal = OM2SMPB02E_VAL_IIR_OFF;
+ break;
+
+ case 2:// 2 Times
+ iirVal = OM2SMPB02E_VAL_IIR_02TIMES;
+ break;
+
+ case 3:// 4 Times
+ iirVal = OM2SMPB02E_VAL_IIR_04TIMES;
+ break;
+
+ case 4:// 8 Times
+ iirVal = OM2SMPB02E_VAL_IIR_08TIMES;
+ break;
+
+ case 5:// 16 Times
+ iirVal = OM2SMPB02E_VAL_IIR_16TIMES;
+ break;
+
+ case 6:// 32 Times
+ iirVal = OM2SMPB02E_VAL_IIR_32TIMES;
+ break;
+
+ default:
+ break;
+
+ }//end switch set iir filter value
+
+ // Set IIR Filter value
+ returnStatus = sensor.setIIRFilterValue(iirVal);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set iir filter value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "IIR filter value set successfully." << endl;
+
+ break;
+
+ case 5:// Get Measurement Mode
+
+ // Get measurement mode
+ returnStatus = sensor.getMeasurementMode(measMode);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to get measurement mode value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "*************************************************************" << endl;
+
+ switch(measMode){
+
+ case OM2SMPB02E_VAL_MEASMODE_HIGHSPEED:// High Speed
+ cout << "Measurement Mode : High Speed ";
+ break;
+
+ case OM2SMPB02E_VAL_MEASMODE_LOWPOWER:// Low Power
+ cout << "Measurement Mode : Low Power ";
+ break;
+
+ case OM2SMPB02E_VAL_MEASMODE_STANDARD:// Standard
+ cout << "Measurement Mode : Standard ";
+ break;
+
+ case OM2SMPB02E_VAL_MEASMODE_HIGHACCURACY:// High Accuracy
+ cout << "Measurement Mode : High Accuracy ";
+ break;
+
+ case OM2SMPB02E_VAL_MEASMODE_ULTRAHIGH:// Ultra High
+ cout << "Measurement Mode : Ultra High ";
+ break;
+
+ default:
+ cout << "Measurement Mode : Custom ";
+
+ }// end switch getMeasurementMode
+
+ cout << "[Pressure Measurement Avg time : ";
+
+ switch(measMode & OM2SMPB02E_MASK_PRESAVERAGE){
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_00:
+ cout << "Skip";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_01:
+ cout << "1";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_02:
+ cout << "2";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_04:
+ cout << "4";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_08:
+ cout << "8";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_16:
+ cout << "16";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_32:
+ cout << "32";
+ break;
+
+ case OM2SMPB02E_VAL_PRESAVERAGE_64:
+ cout << "64";
+ break;
+
+ default:
+ cout << "Invalud pressure average value";
+
+ }//end switch print pressure average value
+
+ cout << ", Temperature Measurement Avg time : ";
+
+ switch(measMode & OM2SMPB02E_MASK_TEMPAVERAGE){
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_00:
+ cout << "Skip]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_01:
+ cout << "1]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_02:
+ cout << "2]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_04:
+ cout << "4]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_08:
+ cout << "8]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_16:
+ cout << "16]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_32:
+ cout << "32]" << endl;
+ break;
+
+ case OM2SMPB02E_VAL_TEMPAVERAGE_64:
+ cout << "64]" << endl;
+ break;
+
+ default:
+ cout << "Invalid temperature average value" << endl;
+
+ }//end switch print temperature average value
+
+ break;
+
+ case 6:// Set Measurement Mode
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Measurement Mode " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. High Speed " << endl;
+ cout << "2. Low Power " << endl;
+ cout << "3. Standard " << endl;
+ cout << "4. High Accuracy " << endl;
+ cout << "5. Ultra High " << endl;
+ cout << "6. Custom " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of measurement mode : ",input,1,6);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(input){
+
+ case 1:// High Speed
+ measMode = OM2SMPB02E_VAL_MEASMODE_HIGHSPEED;
+ break;
+
+ case 2:// Low Power
+ measMode = OM2SMPB02E_VAL_MEASMODE_LOWPOWER;
+ break;
+
+ case 3:// Standard
+ measMode = OM2SMPB02E_VAL_MEASMODE_STANDARD;
+ break;
+
+ case 4:// High Accuracy
+ measMode = OM2SMPB02E_VAL_MEASMODE_HIGHACCURACY;
+ break;
+
+ case 5:// Ultra High
+ measMode = OM2SMPB02E_VAL_MEASMODE_ULTRAHIGH;
+ break;
+
+ case 6:// Custom
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Temperature Average Value " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. 1 " << endl;
+ cout << "2. 2 " << endl;
+ cout << "3. 4 " << endl;
+ cout << "4. 8 " << endl;
+ cout << "5. 16 " << endl;
+ cout << "6. 32 " << endl;
+ cout << "7. 64 " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of temperature average value : ",sub_input,1,7);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(sub_input){
+
+ case 1:// 1
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_01;
+ break;
+
+ case 2:// 2
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_02;
+ break;
+
+ case 3:// 4
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_04;
+ break;
+
+ case 4:// 8
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_08;
+ break;
+
+ case 5:// 16
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_16;
+ break;
+
+ case 6:// 32
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_32;
+ break;
+
+ case 7:// 64
+ measMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T) OM2SMPB02E_VAL_TEMPAVERAGE_64;
+ break;
+
+ default:
+ break;
+
+ }// end sub input temperature average value
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " Pressure Average Value " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. 1 " << endl;
+ cout << "2. 2 " << endl;
+ cout << "3. 4 " << endl;
+ cout << "4. 8 " << endl;
+ cout << "5. 16 " << endl;
+ cout << "6. 32 " << endl;
+ cout << "7. 64 " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of pressure average value : ",sub_input,1,7);
+
+ if(ret != true){
+ break;
+ }
+
+ switch(sub_input){
+
+ case 1:// 1
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_01);
+ break;
+
+ case 2:// 2
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_02);
+ break;
+
+ case 3:// 4
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_04);
+ break;
+
+ case 4:// 8
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_08);
+ break;
+
+ case 5:// 16
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_16);
+ break;
+
+ case 6:// 32
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_32);
+ break;
+
+ case 7:// 64
+ measMode = OM2SMPB02E_VAL_MEASMODE_VALUES_T (measMode | OM2SMPB02E_VAL_PRESAVERAGE_64);
+ break;
+
+ default:
+ break;
+
+ }// end sub input pressure average value
+
+ break;
+
+ default:
+ break;
+
+ }//end switch set Measurement Mode
+
+ // Set measurement mode
+ returnStatus = sensor.setMeasurementMode(measMode);
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set measurement mode value with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "Measurement mode value set successfully." << endl;
+
+ break;
+
+ case 7:// Set I2C Frequency
+
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << " I2C Frequency " << endl;
+ cout << "*************************************************************" << endl;
+ cout << "*************************************************************" << endl;
+ cout << "1. 100 KHz " << endl;
+ cout << "2. 400 KHz " << endl;
+ cout << "3. 3.4 MHz " << endl;
+ cout << "*************************************************************" << endl;
+
+ ret = takeInput("Select from the list of i2c frequency : ",input,1,3);
+
+ if(ret != true){
+ break;
+ }
+
+ // Set I2C Frequency
+ returnStatus = sensor.setI2cFrequency((mraa::I2cMode)(input-1));
+
+ // Check return status
+ if(returnStatus != OM2SMPB02E_STATUS_SUCCESS){
+ cout << "Failed to set I2C frequency with error code : " << returnStatus << endl;
+ break;
+ }
+
+ cout << "I2C frequency set successfully." << endl;
+ break;
+
+ default:
+ break;
+
+ }// end sub_choice
+
+ break;
+
+ default:
+ break;
+
+ }//end switch
+
+ if(flag){
+ cout << "Press enter to continue...";
+ //cin.ignore();
+ cin.get();
+ }
+ }//end while
+ return 0;
+}
diff --git a/src/2smpb02e/2smpb02e.cxx b/src/2smpb02e/2smpb02e.cxx
new file mode 100644
index 00000000..4dc2ec60
--- /dev/null
+++ b/src/2smpb02e/2smpb02e.cxx
@@ -0,0 +1,598 @@
+/*
+* Author: Hiroyuki Mino <omronsupportupm@omron.com>
+* 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 "2smpb02e.hpp"
+
+using namespace upm;
+
+OM2SMPB02E::OM2SMPB02E(INT32 bus,UINT8 address): mBus(bus), mAddress(address){
+
+ OM2SMPB02E_VAL_MEASMODE_VALUES_T tempByte;
+
+ // Create I2c object
+ mI2c = new mraa::I2c(mBus);
+
+ // Check for I2c object created well or not
+ if(mI2c->address(mAddress) != mraa::SUCCESS){
+ throw std::invalid_argument(std::string(__FUNCTION__) + ": I2c.address() failed");
+ }
+
+ // Set default Temperature scale to celsius
+ mTempScale = upm::TemperatureUnit::CELSIUS;
+
+ // Set default Pressure scale to pascal
+ mPressureScale = upm::PressureUnit::PA;
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_COEFS)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed to get co-effi values" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(mBuf, OM2SMPB02E_COEFFI_MAX_VALUE)){
+
+ #ifdef DEBUG
+ std::cout << "read failed to get co-effi values" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ // Get co-effi values
+ getCOEFFValues(mCompFactor);
+
+ try{// Get Measurement Mode
+ getMeasurementMode(tempByte);
+ }catch(const std::runtime_error& e){
+ throw std::runtime_error(std::string(__FUNCTION__) + ": getMeasurementMode() failed");
+ }
+
+ try{// Get power mode
+ getPowerMode(mPowerMode);
+ }catch(const std::runtime_error& e){
+ throw std::runtime_error(std::string(__FUNCTION__) + ": getPowerMode() failed");
+ }
+
+}
+
+OM2SMPB02E::~OM2SMPB02E(){
+
+ // Delete I2c instance
+ delete mI2c;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getPresAndTempValues(FLOAT &outPres, FLOAT &outTemp){
+
+ UINT8 buf[6] = {0};
+ UINT32 rawpres,rawtemp;
+ DOUBLE Pr, Po;
+ DOUBLE Tr, Dt;
+
+ outPres = 0;
+ outTemp = 0;
+
+ // Check power mode and return if sleep mode
+ if(mPowerMode == OM2SMPB02E_VAL_POWERMODE_SLEEP){
+ std::cerr << "Error: The sensor is in sleep mode. Please change the power mode to either forced or normal." << std::endl;
+ return OM2SMPB02E_STATUS_SLEEP_MODE;
+ }
+
+ // Check measurement mode average value
+ if((mPresMeasValue == OM2SMPB02E_VAL_PRESAVERAGE_00) && (mTempMeasValue == OM2SMPB02E_VAL_TEMPAVERAGE_00)){
+ std::cerr << "Error: Get pressure and temperature value requires both measurement mode enabled." << std::endl;
+ return OM2SMPB02E_STATUS_TEMP_PRES_MEASUREMENT_SKIP;
+ }
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_PRES_TXD2)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed to get pres register" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(buf, sizeof(buf))){
+
+ #ifdef DEBUG
+ std::cout << "read failed to get pres value" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ rawpres = OM2SMPB02E_CONV8S_S24_BE(buf[0], buf[1], buf[2]);
+ rawtemp = OM2SMPB02E_CONV8S_S24_BE(buf[3], buf[4], buf[5]);
+
+ // Check power mode
+ if(mPowerMode == OM2SMPB02E_VAL_POWERMODE_FORCED){
+ try{// Set power mode
+ setPowerMode(mPowerMode);
+ }catch(const std::runtime_error& e){
+ throw std::runtime_error(std::string(__FUNCTION__) + ": setPowerMode() failed");
+ }
+ }
+
+ #ifdef DEBUG
+ std::cout << "Raw pres data : " << rawpres << std::endl;
+ std::cout << "Raw temp data : " << rawtemp << std::endl;
+ #endif
+
+ // temperature compensation
+ if(rawtemp){
+ Dt = (INT32)rawtemp - 0x800000;
+ Tr = mCompFactor._A0 + (mCompFactor._A1 * Dt) + (mCompFactor._A2 * (Dt * Dt));
+
+ // Check Temperature average value
+ if(mTempMeasValue != OM2SMPB02E_VAL_TEMPAVERAGE_00){
+ outTemp = Tr/256.0;
+
+ // Check temperature unit scale and convert
+ if(mTempScale != upm::TemperatureUnit::CELSIUS){
+ outTemp = convertCelsiusTo(outTemp,mTempScale);
+ }
+ }
+ }
+
+ // barometer compensation
+ if(rawtemp && rawpres){
+ Pr = (INT32)rawpres - 0x800000;
+ Po = mCompFactor._B00 + (mCompFactor._BT1 * Tr) + (mCompFactor._BP1 * Pr) +
+ (mCompFactor._B11 * Tr * Pr) + mCompFactor._BT2 * (Tr * Tr) +
+ (mCompFactor._BP2 * (Pr * Pr)) + (mCompFactor._B12 * Pr * (Tr * Tr)) +
+ (mCompFactor._B21 * (Pr * Pr) * Tr) + (mCompFactor._BP3 * (Pr * Pr * Pr));
+
+ // Check Pressure average value
+ if((mPresMeasValue != OM2SMPB02E_VAL_PRESAVERAGE_00) && (mTempMeasValue != OM2SMPB02E_VAL_TEMPAVERAGE_00)){
+ outPres = Po;
+
+ // Check pressure unit scale and convert
+ if(mPressureScale != upm::PressureUnit::PA){
+ outPres = convertPaTo(outPres,mPressureScale);
+ }
+ }
+ }
+
+ #ifdef DEBUG
+ std::cout << "outTemp data : " << outTemp << std::endl;
+ std::cout << "outPres data : " << outPres << std::endl;
+ #endif
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getPressure(FLOAT &outPres){
+
+ FLOAT temTemp;
+
+ // Check power mode and return if sleep mode
+ if(mPowerMode == OM2SMPB02E_VAL_POWERMODE_SLEEP){
+ std::cerr << "Error: The sensor is in sleep mode. Please change the power mode to either forced or normal." << std::endl;
+ return OM2SMPB02E_STATUS_SLEEP_MODE;
+ }
+
+ // Check Pressure average value
+ if(mPresMeasValue == OM2SMPB02E_VAL_PRESAVERAGE_00 || mTempMeasValue == OM2SMPB02E_VAL_TEMPAVERAGE_00){
+ std::cerr << "Error: Get pressure value requires temperature and pressure both measurement mode enabled." << std::endl;
+ return OM2SMPB02E_STATUS_TEMP_PRES_MEASUREMENT_SKIP;
+ }
+
+ // Get Preesure value
+ return getPresAndTempValues(outPres,temTemp);
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getTemperature(FLOAT &outTemp){
+
+ FLOAT temPres;
+
+ // Check power mode and return if sleep mode
+ if(mPowerMode == OM2SMPB02E_VAL_POWERMODE_SLEEP){
+ std::cerr << "Error: The sensor is in sleep mode. Please change the power mode to either forced or normal." << std::endl;
+ return OM2SMPB02E_STATUS_SLEEP_MODE;
+ }
+
+ // Check Temperature average value
+ if(mTempMeasValue == OM2SMPB02E_VAL_TEMPAVERAGE_00){
+ std::cerr << "Error: Get temperature value requires temperature measurement mode enabled." << std::endl;
+ return OM2SMPB02E_STATUS_TEMP_MEASUREMENT_SKIP;
+ }
+
+ // Get Temperature value
+ return getPresAndTempValues(temPres,outTemp);
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getPowerMode(OM2SMPB02E_VAL_POWERMODE_VALUES_T &powerMode){
+
+ UINT8 tempByte;
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_CTRL_MEAS)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed getPowerMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(&tempByte, 1)){
+
+ #ifdef DEBUG
+ std::cout << "read failed getPowerMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ #ifdef DEBUG
+ std::cout << "Power Mode Register value : " << (unsigned)tempByte << std::endl;
+ #endif
+
+ // Parse power mode bits
+ powerMode = (OM2SMPB02E_VAL_POWERMODE_VALUES_T)(tempByte & OM2SMPB02E_MASK_POWERMODE_VALUE);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setPowerMode(OM2SMPB02E_VAL_POWERMODE_VALUES_T powerMode){
+
+ OM2SMPB02E_VAL_MEASMODE_VALUES_T tempByte;
+ UINT8 tempBuf[2];
+
+ try{// Get measurement mode
+ getMeasurementMode(tempByte);
+ }catch(const std::runtime_error& e){
+ std::cerr << "Error while handling: " << e.what() << std::endl;
+ return OM2SMPB02E_STATUS_FAILURE;
+ }
+
+ tempBuf[0] = OM2SMPB02E_REGI2C_CTRL_MEAS;
+ tempBuf[1] = (powerMode | tempByte);
+
+ // Write register
+ if((mI2c->write(tempBuf,sizeof(tempBuf))) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed setPowerMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.write failed");
+ }
+
+ mPowerMode = powerMode;
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getMeasurementMode(OM2SMPB02E_VAL_MEASMODE_VALUES_T &measurementMode){
+
+ UINT8 tempByte;
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_CTRL_MEAS)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed getMeasurementMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(&tempByte, 1)){
+
+ #ifdef DEBUG
+ std::cout << "Read failed getMeasurementMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ // Parse measurement mode bits
+ measurementMode = (OM2SMPB02E_VAL_MEASMODE_VALUES_T)(tempByte & (OM2SMPB02E_MASK_TEMPAVERAGE|OM2SMPB02E_MASK_PRESAVERAGE));
+
+ // Mask the pressure and temperature value
+ mPresMeasValue = (measurementMode & OM2SMPB02E_MASK_PRESAVERAGE);
+ mTempMeasValue = (measurementMode & OM2SMPB02E_MASK_TEMPAVERAGE);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setMeasurementMode(OM2SMPB02E_VAL_MEASMODE_VALUES_T measurementMode){
+
+ UINT8 tempBuf[2];
+
+ // Check measurement mode average value
+ if(((measurementMode & OM2SMPB02E_MASK_PRESAVERAGE) == OM2SMPB02E_VAL_PRESAVERAGE_00) ||
+ ((measurementMode & OM2SMPB02E_MASK_TEMPAVERAGE) == OM2SMPB02E_VAL_TEMPAVERAGE_00)){
+ return OM2SMPB02E_STATUS_TEMP_PRES_MEASUREMENT_SKIP;
+ }
+
+ try{// Get power mode
+ getPowerMode(mPowerMode);
+ }catch(const std::runtime_error& e){
+ std::cerr << "Error while handling: " << e.what() << std::endl;
+ return OM2SMPB02E_STATUS_FAILURE;
+ }
+
+ tempBuf[0] = OM2SMPB02E_REGI2C_CTRL_MEAS;
+ tempBuf[1] = (measurementMode | mPowerMode);
+
+ // Write register
+ if((mI2c->write(tempBuf,sizeof(tempBuf))) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed setMeasurementMode" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.write failed");
+ }
+
+ // Mask the pressure and temperature value
+ mPresMeasValue = (measurementMode & OM2SMPB02E_MASK_PRESAVERAGE);
+ mTempMeasValue = (measurementMode & OM2SMPB02E_MASK_TEMPAVERAGE);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getStandbyTimeValue(OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T &standbyTimeValue){
+
+ UINT8 tempByte;
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_IO_SETUP)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "Write failed getStandbyTimeValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(&tempByte, 1)){
+
+ #ifdef DEBUG
+ std::cout << "Read failed getStandbyTimeValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ // Parse standby value bits
+ standbyTimeValue = (OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T)(tempByte & OM2SMPB02E_MASK_TEMPAVERAGE);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setStandbyTimeValue(OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T standbyTimeValue){
+
+ UINT8 tempBuf[2];
+
+ tempBuf[0] = OM2SMPB02E_REGI2C_IO_SETUP;
+ tempBuf[1] = standbyTimeValue;
+
+ // Write register
+ if((mI2c->write(tempBuf,sizeof(tempBuf))) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed setStandbyTimeValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.write failed");
+ }
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getIIRFilterValue(OM2SMPB02E_VAL_IIR_VALUES_T &iirValue){
+
+ UINT8 tempByte;
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_IIR)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "Write failed getIIRFilterValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(&tempByte, 1)){
+
+ #ifdef DEBUG
+ std::cout << "Read failed getIIRFilterValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ // Assign IIT Filter value
+ iirValue = (OM2SMPB02E_VAL_IIR_VALUES_T)(tempByte);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setIIRFilterValue(OM2SMPB02E_VAL_IIR_VALUES_T iirValue){
+
+ UINT8 tempBuf[2];
+
+ tempBuf[0] = OM2SMPB02E_REGI2C_IIR;
+ tempBuf[1] = iirValue;
+
+ // Write register
+ if((mI2c->write(tempBuf,sizeof(tempBuf))) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed setIIRFilterValue" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.write failed");
+ }
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getTemperatureScale(TemperatureUnit &unit){
+
+ // Get temperature scale
+ unit = mTempScale;
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setTemperatureScale(TemperatureUnit unit){
+
+ // Set temperature scale
+ mTempScale = unit;
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getPressureScale(PressureUnit &unit){
+
+ // Get pressure scale
+ unit = mPressureScale;
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setPressureScale(PressureUnit unit){
+
+ // Set pressure scale
+ mPressureScale = unit;
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getDeviceId(UINT8 &deviceId){
+
+ // Write register
+ if((mI2c->writeByte(OM2SMPB02E_REGI2C_CHIP_ID)) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "write failed getDeviceId" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.writeByte failed");
+ }
+
+ // Read values
+ if(!mI2c->read(&deviceId, 1)){
+
+ #ifdef DEBUG
+ std::cout << "read failed getDeviceId" << std::endl;
+ #endif
+
+ throw std::runtime_error(std::string(__FUNCTION__) + ": I2c.read() failed");
+ }
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::setI2cFrequency(mraa::I2cMode frequency){
+
+ // Set I2C frequency
+ if(mI2c->frequency(frequency) != mraa::SUCCESS){
+
+ #ifdef DEBUG
+ std::cout << "set I2C frequency failed" << std::endl;
+ #endif
+
+ throw std::invalid_argument(std::string(__FUNCTION__) + ": I2c.frequency() failed");
+ }
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::getCOEFFValues(OM2SMPB02E_SETTING_T &setting){
+
+ // pressure parameters
+ setting.ex = (mBuf[OM2SMPB02E_COEFFI_MAX_VALUE - 1] & 0xF0) >> 4;
+
+ conv20Q4ToDouble(mBuf,setting._B00,setting.ex,0);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_BT1,OM2SMPB02E_COEFF_S_BT1,mBuf,setting._BT1,2);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_BT2,OM2SMPB02E_COEFF_S_BT2,mBuf,setting._BT2,4);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_BP1,OM2SMPB02E_COEFF_S_BP1,mBuf,setting._BP1,6);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_B11,OM2SMPB02E_COEFF_S_B11,mBuf,setting._B11,8);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_BP2,OM2SMPB02E_COEFF_S_BP2,mBuf,setting._BP2,10);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_B12,OM2SMPB02E_COEFF_S_B12,mBuf,setting._B12,12);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_B21,OM2SMPB02E_COEFF_S_B21,mBuf,setting._B21,14);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_BP3,OM2SMPB02E_COEFF_S_BP3,mBuf,setting._BP3,16);
+
+ // temperature parameters
+ setting.ex = (mBuf[OM2SMPB02E_COEFFI_MAX_VALUE - 1] & 0x0F);
+
+ conv20Q4ToDouble(mBuf,setting._A0,setting.ex,18);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_A1,OM2SMPB02E_COEFF_S_A1,mBuf,setting._A1,20);
+ conv16ToDouble(OM2SMPB02E_COEFF_A_A2,OM2SMPB02E_COEFF_S_A2,mBuf,setting._A2,22);
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::conv16ToDouble(DOUBLE a, DOUBLE s, UINT8* inValue, DOUBLE &outValue, INT32 offSet){
+
+ UINT16 val;
+ INT16 ret;
+
+ // Integer values shift
+ val = (UINT16)((UINT16)(inValue[offSet] << 8) | (UINT16)inValue[offSet + 1]);
+
+ // Check value
+ if((val & 0x8000) != 0){
+ ret = (INT16)((INT32)val - 0x10000);
+ }else{
+ ret = val;
+ }
+
+ // Convert value
+ outValue = a + (DOUBLE)ret * s /32767.0;
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
+OM2SMPB02E_STATUS_T OM2SMPB02E::conv20Q4ToDouble(UINT8* inValue, DOUBLE &outValue, UINT8 ex, INT32 offSet){
+
+ INT32 ret;
+ UINT32 val;
+
+ // Integet values shift
+ val = (UINT32)((inValue[offSet] << 12) | (inValue[offSet + 1] << 4) | ex);
+
+ // Check value
+ if((val & 0x80000) != 0){
+ ret = (INT32)val - 0x100000;
+ }else{
+ ret = val;
+ }
+
+ // Convert value
+ outValue = (DOUBLE)ret / 16.0;
+
+ return OM2SMPB02E_STATUS_SUCCESS;
+}
+
diff --git a/src/2smpb02e/2smpb02e.hpp b/src/2smpb02e/2smpb02e.hpp
new file mode 100644
index 00000000..344b59f5
--- /dev/null
+++ b/src/2smpb02e/2smpb02e.hpp
@@ -0,0 +1,428 @@
+/*
+* Author: Hiroyuki Mino <omronsupportupm@omron.com>
+* 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 <iostream> //Required for c++ standard IO
+#include "mraa/i2c.hpp" //Required for MRAA I2c operations
+#include <interfaces/iTemperature.hpp> //Required to Temperature Unit functionality
+#include <interfaces/iPressure.hpp> //Required to Pressure Unit functionality
+
+/**
+ * MACROS and enum
+ */
+#define OM2SMPB02E_DEFAULT_I2C_BUS_NUM 6
+#define OM2SMPB02E_DEFAULT_I2C_ADDR 0x56
+#define OM2SMPB02E_COEFFI_MAX_VALUE (UINT8)25
+//#define DEBUG /* Debug print */
+
+typedef unsigned char UINT8; /* 8 bit Unsigned Integer */
+typedef int INT32; /* 32 bit Signed Integer */
+typedef unsigned int UINT32; /* 32 bit Signed Integer */
+typedef char INT8; /* 8 bit Signed Integer */
+typedef double DOUBLE; /* 64 bit Floating-Point */
+typedef unsigned short int UINT16; /* 16 bit Unsigned Integer */
+typedef short int INT16; /* 16 bit Signed Integer */
+typedef float FLOAT; /* 32 bit Floating-Point */
+typedef std::string STRING; /* string */
+
+/* Registers */
+#define OM2SMPB02E_REGI2C_PRES_TXD2 0xF7
+#define OM2SMPB02E_REGI2C_IO_SETUP 0xF5
+#define OM2SMPB02E_REGI2C_CTRL_MEAS 0xF4
+#define OM2SMPB02E_REGI2C_IIR 0xF1
+#define OM2SMPB02E_REGI2C_CHIP_ID 0xD1
+#define OM2SMPB02E_REGI2C_COEFS 0xA0
+
+/**
+ * OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES enum.
+ * An Enum contains io setup stand by values.
+ */
+typedef enum OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES{
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_0001MS = 0x00,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_0005MS = 0x20,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_0050MS = 0x40,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_0250MS = 0x60,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_0500MS = 0x80,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_1000MS = 0xA0,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_2000MS = 0xC0,
+ OM2SMPB02E_VAL_IOSETUP_STANDBY_4000MS = 0xE0,
+}OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T;
+
+#define OM2SMPB02E_MASK_TEMPAVERAGE ((UINT8)0xE0)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_00 ((UINT8)0x00)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_01 ((UINT8)0x20)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_02 ((UINT8)0x40)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_04 ((UINT8)0x60)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_08 ((UINT8)0x80)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_16 ((UINT8)0xA0)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_32 ((UINT8)0xC0)
+#define OM2SMPB02E_VAL_TEMPAVERAGE_64 ((UINT8)0xE0)
+
+#define OM2SMPB02E_MASK_PRESAVERAGE ((UINT8)0x1C)
+#define OM2SMPB02E_VAL_PRESAVERAGE_00 ((UINT8)0x00)
+#define OM2SMPB02E_VAL_PRESAVERAGE_01 ((UINT8)0x04)
+#define OM2SMPB02E_VAL_PRESAVERAGE_02 ((UINT8)0x08)
+#define OM2SMPB02E_VAL_PRESAVERAGE_04 ((UINT8)0x0C)
+#define OM2SMPB02E_VAL_PRESAVERAGE_08 ((UINT8)0x10)
+#define OM2SMPB02E_VAL_PRESAVERAGE_16 ((UINT8)0x14)
+#define OM2SMPB02E_VAL_PRESAVERAGE_32 ((UINT8)0x18)
+#define OM2SMPB02E_VAL_PRESAVERAGE_64 ((UINT8)0x1C)
+
+/**
+ * OM2SMPB02E_VAL_MEASMODE_VALUES enum.
+ * An Enum contains measurement mode values.
+ */
+typedef enum OM2SMPB02E_VAL_MEASMODE_VALUES{
+ OM2SMPB02E_VAL_MEASMODE_HIGHSPEED = (OM2SMPB02E_VAL_PRESAVERAGE_02 | OM2SMPB02E_VAL_TEMPAVERAGE_01),
+ OM2SMPB02E_VAL_MEASMODE_LOWPOWER = (OM2SMPB02E_VAL_PRESAVERAGE_04 | OM2SMPB02E_VAL_TEMPAVERAGE_01),
+ OM2SMPB02E_VAL_MEASMODE_STANDARD = (OM2SMPB02E_VAL_PRESAVERAGE_08 | OM2SMPB02E_VAL_TEMPAVERAGE_01),
+ OM2SMPB02E_VAL_MEASMODE_HIGHACCURACY = (OM2SMPB02E_VAL_PRESAVERAGE_16 | OM2SMPB02E_VAL_TEMPAVERAGE_02),
+ OM2SMPB02E_VAL_MEASMODE_ULTRAHIGH = (OM2SMPB02E_VAL_PRESAVERAGE_32 | OM2SMPB02E_VAL_TEMPAVERAGE_04),
+}OM2SMPB02E_VAL_MEASMODE_VALUES_T;
+
+
+#define OM2SMPB02E_MASK_POWERMODE_VALUE ((UINT8)0x03)
+
+/**
+ * OM2SMPB02E_VAL_POWERMODE_VALUES enum.
+ * An Enum contains power mode values.
+ */
+typedef enum OM2SMPB02E_VAL_POWERMODE_VALUES{
+ OM2SMPB02E_VAL_POWERMODE_SLEEP = 0x00,
+ OM2SMPB02E_VAL_POWERMODE_FORCED = 0x01,
+ OM2SMPB02E_VAL_POWERMODE_NORMAL = 0x03,
+}OM2SMPB02E_VAL_POWERMODE_VALUES_T;
+
+/**
+ * OM2SMPB02E_VAL_IIR_VALUES enum.
+ * An Enum contains IIR values.
+ */
+typedef enum OM2SMPB02E_VAL_IIR_VALUES{
+ OM2SMPB02E_VAL_IIR_OFF = 0x00,
+ OM2SMPB02E_VAL_IIR_02TIMES = 0x01,
+ OM2SMPB02E_VAL_IIR_04TIMES = 0x02,
+ OM2SMPB02E_VAL_IIR_08TIMES = 0x03,
+ OM2SMPB02E_VAL_IIR_16TIMES = 0x04,
+ OM2SMPB02E_VAL_IIR_32TIMES = 0x05,
+}OM2SMPB02E_VAL_IIR_VALUES_T;
+
+/* Coeff */
+#define OM2SMPB02E_COEFF_S_A1 ((DOUBLE)( 4.3E-04))
+#define OM2SMPB02E_COEFF_A_A1 ((DOUBLE)(-6.3E-03))
+#define OM2SMPB02E_COEFF_S_A2 ((DOUBLE)( 1.2E-10))
+#define OM2SMPB02E_COEFF_A_A2 ((DOUBLE)(-1.9E-11))
+#define OM2SMPB02E_COEFF_S_BT1 ((DOUBLE)( 9.1E-02))
+#define OM2SMPB02E_COEFF_A_BT1 ((DOUBLE)( 1.0E-01))
+#define OM2SMPB02E_COEFF_S_BT2 ((DOUBLE)( 1.2E-06))
+#define OM2SMPB02E_COEFF_A_BT2 ((DOUBLE)( 1.2E-08))
+#define OM2SMPB02E_COEFF_S_BP1 ((DOUBLE)( 1.9E-02))
+#define OM2SMPB02E_COEFF_A_BP1 ((DOUBLE)( 3.3E-02))
+#define OM2SMPB02E_COEFF_S_B11 ((DOUBLE)( 1.4E-07))
+#define OM2SMPB02E_COEFF_A_B11 ((DOUBLE)( 2.1E-07))
+#define OM2SMPB02E_COEFF_S_BP2 ((DOUBLE)( 3.5E-10))
+#define OM2SMPB02E_COEFF_A_BP2 ((DOUBLE)(-6.3E-10))
+#define OM2SMPB02E_COEFF_S_B12 ((DOUBLE)( 7.6E-13))
+#define OM2SMPB02E_COEFF_A_B12 ((DOUBLE)( 2.9E-13))
+#define OM2SMPB02E_COEFF_S_B21 ((DOUBLE)( 1.2E-14))
+#define OM2SMPB02E_COEFF_A_B21 ((DOUBLE)( 2.1E-15))
+#define OM2SMPB02E_COEFF_S_BP3 ((DOUBLE)( 7.9E-17))
+#define OM2SMPB02E_COEFF_A_BP3 ((DOUBLE)( 1.3E-16))
+
+/* CALIBRATION DATA */
+typedef struct OM2SMPB02E_SETTING{
+ /* Compensation Factor */
+ UINT8 ex;
+ DOUBLE _A0, _A1, _A2;
+ DOUBLE _B00, _BT1, _BP1;
+ DOUBLE _B11, _BT2, _BP2;
+ DOUBLE _B12, _B21, _BP3;
+}OM2SMPB02E_SETTING_T;
+
+#define OM2SMPB02E_CONV8S_S24_BE(a, b, c) \
+ (INT32)((((UINT32)a << 16) & 0x00FF0000) | \
+ (((UINT32)b << 8) & 0x0000FF00) | \
+ ((UINT32)c & 0x000000FF))
+
+
+/**
+ * OM2SMPB02E_STATUS enum
+ * An Enum contains status code of operations
+ */
+typedef enum OM2SMPB02E_STATUS{
+OM2SMPB02E_STATUS_FAILURE = 0,
+OM2SMPB02E_STATUS_SUCCESS = 1,
+OM2SMPB02E_STATUS_I2C_NOT_INITED,
+OM2SMPB02E_STATUS_I2C_WRITE_FAILED,
+OM2SMPB02E_STATUS_I2C_READ_FAILED,
+OM2SMPB02E_STATUS_INVALID_MEASURMENT_INTERVAL,
+OM2SMPB02E_STATUS_INVALID_INPUT,
+OM2SMPB02E_STATUS_PRES_MEASUREMENT_SKIP,
+OM2SMPB02E_STATUS_TEMP_MEASUREMENT_SKIP,
+OM2SMPB02E_STATUS_TEMP_PRES_MEASUREMENT_SKIP,
+OM2SMPB02E_STATUS_SLEEP_MODE,
+}OM2SMPB02E_STATUS_T;
+
+/*=========================================================================*/
+
+namespace upm {
+ /**
+ * @brief Barometric Perssure Sensors
+ * @defgroup 2smpb02e libupm-2smpb02e
+ * @ingroup --add group
+ */
+ /**
+ * @library 2smpb02e
+ * @sensor 2smpb-02e
+ * @comname Omron Barometric Pressure sensors
+ * @type --add type
+ * @man omron
+ * @con I2C
+ * @web --add weblink
+ *
+ * @brief API for the Omron Mems thermal sensors interface
+ *
+ * It is connected via a I2C Interface.
+ *
+ * @snippet 2smpb02e.cxx Interesting
+ */
+
+ class OM2SMPB02E : virtual private iTemperature, virtual private iPressure{
+ public :
+ /**
+ * OM2SMPB02E constructor
+ * @param bus I2c bus the sensor is attached to. Default is 6.
+ * @param address I2c address Optional device address. Default is 0x56.
+ */
+ OM2SMPB02E(INT32 bus = OM2SMPB02E_DEFAULT_I2C_BUS_NUM,UINT8 address = OM2SMPB02E_DEFAULT_I2C_ADDR);
+
+ /**
+ * OM2SMPB02E destructor
+ */
+ ~OM2SMPB02E();
+
+ /**
+ * Get Barometric Pressure sensor get pressure and temperature data.
+ *
+ * @param outPres Pressure value. Value is based on current pressure scale unit setting.
+ * @param outTemp Temperature data. Value is based on current temperature scale unit setting.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getPresAndTempValues(FLOAT &outPres, FLOAT &outTemp);
+
+ /**
+ * Get Barometric Pressure sensor get pressure data.
+ *
+ * @param outPres Pressure value. Value is based on current pressure scale unit setting.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getPressure(FLOAT &outPres);
+
+ /**
+ * Get Barometric Pressure sensor get temperature data.
+ *
+ * @param outTemp Temperature data. Value is based on current temperature scale unit setting.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getTemperature(FLOAT &outTemp);
+
+ /**
+ * Get power mode.
+ *
+ * @param powerMode power mode.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getPowerMode(OM2SMPB02E_VAL_POWERMODE_VALUES_T &powerMode);
+
+ /**
+ * Set power mode.
+ *
+ * @param powerMode power mode.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T setPowerMode(OM2SMPB02E_VAL_POWERMODE_VALUES_T powerMode);
+
+ /**
+ * Get measurement mode.
+ *
+ * @param measurementMode measurement mode.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getMeasurementMode(OM2SMPB02E_VAL_MEASMODE_VALUES_T &measurementMode);
+
+ /**
+ * Set measurement mode.
+ *
+ * @param measurementMode measurement mode.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T setMeasurementMode(OM2SMPB02E_VAL_MEASMODE_VALUES_T measurementMode);
+
+ /**
+ * Get Standby time value
+ *
+ * @param standbyTimeValue standby time.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getStandbyTimeValue(OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T &standbyTimeValue);
+
+ /**
+ * Set Standby time value
+ *
+ * @param standbyTimeValue standby time.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T setStandbyTimeValue(OM2SMPB02E_VAL_IOSETUP_STANDBY_VALUES_T standbyTimeValue);
+
+ /**
+ * Get IIR filter value
+ *
+ * @param iirValue iif filter value.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T getIIRFilterValue(OM2SMPB02E_VAL_IIR_VALUES_T &iirValue);
+
+ /**
+ * Set IIR filter value
+ *
+ * @param iirValue iif filter value.
+ * @return One of the OM2SMPB02E_STATUS_T value.
+ */
+ OM2SMPB02E_STATUS_T setIIRFilterValue(OM2SMPB02E_VAL_IIR_VALUES_T iirValue);
+
+ /**
+ * Get the temperature unit.
+ *
+ * @param unit Temperature scale unit
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T getTemperatureScale(TemperatureUnit &unit);
+
+ /**
+ * Set the temperature unit.
+ *
+ * @param unit Temperature scale unit
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T setTemperatureScale(TemperatureUnit unit);
+
+ /**
+ * Get the Pressure unit.
+ *
+ * @param unit Pressure scale unit
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T getPressureScale(PressureUnit &unit);
+
+ /**
+ * Set the Pressure unit.
+ *
+ * @param unit Pressure scale unit
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T setPressureScale(PressureUnit unit);
+
+ /**
+ * Set the I2C Frequency.
+ *
+ * @param I2cMode frequency
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T setI2cFrequency(mraa::I2cMode frequency);
+
+ /**
+ * Get the device Id.
+ *
+ * @param deviceId Device ID
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T getDeviceId(UINT8 &deviceId);
+
+ private:
+ INT32 mBus;
+ INT32 mAddress;
+ TemperatureUnit mTempScale;
+ PressureUnit mPressureScale;
+ mraa::I2c* mI2c;
+ UINT8 mBuf[OM2SMPB02E_COEFFI_MAX_VALUE] = {0};
+ OM2SMPB02E_SETTING_T mCompFactor;
+ UINT8 mTempMeasValue = OM2SMPB02E_VAL_TEMPAVERAGE_00;
+ UINT8 mPresMeasValue = OM2SMPB02E_VAL_PRESAVERAGE_00;
+ OM2SMPB02E_VAL_POWERMODE_VALUES_T mPowerMode = OM2SMPB02E_VAL_POWERMODE_SLEEP;
+
+ /**
+ * Returns the temperature. This method is not publicly accessible.
+ *
+ * @return Dummy value
+ */
+ virtual FLOAT getTemperature(){return 0.0;}
+
+ /**
+ * Returns the Pressure. This method is not publicly accessible.
+ *
+ * @return Dummy value
+ */
+ virtual FLOAT getPressure(){return 0.0;}
+
+ /**
+ * Get the co-effi. values for Temperature and Pressure.
+ *
+ * @param settings Settings.
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T getCOEFFValues(OM2SMPB02E_SETTING_T &Setting);
+
+ /**
+ * Convert byte buffer to double. Byte buffer format is a signed-16bit Big-Endian.
+ *
+ * @param a
+ * @param s
+ * @param inBuf
+ * @param outBuf
+ * @param offSet
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T conv16ToDouble(DOUBLE a, DOUBLE s, UINT8* inValue, DOUBLE &outValue, INT32 offSet);
+
+ /**
+ * Convert byte buffer to double. Byte buffer format is a signed-20Q4,from -32768.0 to 32767.9375.
+ *
+ * @param inValue
+ * @param outValue
+ * @param ex
+ * @param offSet
+ * @return One of the OM2SMPB02E_STATUS_T values.
+ */
+ OM2SMPB02E_STATUS_T conv20Q4ToDouble(UINT8* inValue, DOUBLE &outValue, UINT8 ex, INT32 offSet);
+
+ /*
+ * Copy Constructor
+ */
+ OM2SMPB02E(const OM2SMPB02E&);
+
+ /**
+ * Operator Overloading
+ */
+ OM2SMPB02E& operator=(const OM2SMPB02E&);
+ };
+}
diff --git a/src/2smpb02e/2smpb02e.i b/src/2smpb02e/2smpb02e.i
new file mode 100644
index 00000000..bf4ee25f
--- /dev/null
+++ b/src/2smpb02e/2smpb02e.i
@@ -0,0 +1,19 @@
+#ifdef SWIGPYTHON
+%module (package="upm") 2smpb02e
+#endif
+
+%include "../common_top.i"
+
+/* BEGIN Java syntax ------------------------------------------------------- */
+#ifdef SWIGJAVA
+JAVA_JNI_LOADLIBRARY(javaupm_d6t)
+#endif
+/* END Java syntax */
+
+/* BEGIN Common SWIG syntax ------------------------------------------------- */
+%{
+#include "2smpb02e.hpp"
+%}
+
+%include "2smpb02e.hpp"
+/* END Common SWIG syntax */
diff --git a/src/2smpb02e/2smpb02e.json b/src/2smpb02e/2smpb02e.json
new file mode 100644
index 00000000..e78b87a5
--- /dev/null
+++ b/src/2smpb02e/2smpb02e.json
@@ -0,0 +1,28 @@
+{
+ "Library": "2smpb02e",
+ "Description": "Omron Digital Barometric Pressure Sensor",
+ "Sensor Class": {
+ "d6t": {
+ "Name": "API for Barometric Pressure Sensor",
+ "Description": "This is the UPM Module for the Omron Barometric Pressure Sensor using I2C interface.",
+ "Aliases": ["Absolute Pressure Sensor"],
+ "Connections": ["I2C"],
+ "Project Type": ["sensor"],
+ "Manufacturers": ["Omron"],
+ "Examples": {
+ "C++": ["2smpb02e.cxx"]
+ },
+ "Platforms": {
+ "Intel Edison": {
+ "Notes": ["Might need omron barometric pressure sensor"]
+ }
+ },
+ "Urls": {
+ "Product Pages": ["https://www.components.omron.com/product-detail?partId=35065"],
+ "Datasheets": ["https://omronfs.omron.com/en_US/ecb/products/pdf/en_2smpb_02e.pdf"]
+ }
+ }
+ }
+}
+
+
diff --git a/src/2smpb02e/CMakeLists.txt b/src/2smpb02e/CMakeLists.txt
new file mode 100644
index 00000000..242514c4
--- /dev/null
+++ b/src/2smpb02e/CMakeLists.txt
@@ -0,0 +1,5 @@
+set (libname "2smpb02e")
+set (libdescription "Omron Digital Barometric Pressure Sensor")
+set (module_src "${libname}.cxx" "2smpb02e.cxx")
+set (module_hpp "${libname}.hpp" "2smpb02e.hpp")
+upm_module_init(mraa)