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 +* 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 +#include +#include +#include +#include + + +/* 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::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 +* 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 +* 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 //Required for c++ standard IO +#include "mraa/i2c.hpp" //Required for MRAA I2c operations +#include //Required to Temperature Unit functionality +#include //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)