C++ Core: Add base class per sensor/actuator type

Adding base classes for UPM sensors and actuators.

Signed-off-by: Noel Eck <noel.eck@intel.com>

.travis.yml

@@ -12,21 +12,15 @@ before_install:
 jobs:
   fast_finish: true
   allow_failures:
-    - env: TARGET=android
+    - env: TARGET=ipk
   include:
     - &run-with-clang-minimal
       stage: Clang 3.8 - minimal with unit tests
-      env:
+      env: TARGET=minimal
-        - TARGET=minimal
-        - CMAKE_BUILD_TYPE=Debug
       before_script: docker-compose pull ${TARGET}
       script:
         - export CC=clang-3.8 CXX=clang++-3.8
-        - docker-compose run ${TARGET}
+        - BUILDARCH=MOCK docker-compose run ${TARGET}
-    - <<: *run-with-clang-minimal
-      env:
-        - TARGET=minimal
-        - CMAKE_BUILD_TYPE=Release
     - &run-with-clang
       stage: Clang 3.8
       env: TARGET=python
@@ -87,5 +81,9 @@ jobs:
       env: TARGET=examples
     - <<: *run-additional-jobs
       env: TARGET=sonar-scan
+    - <<: *run-additional-jobs
+      env: TARGET=ipk
+    - <<: *run-additional-jobs
+      env: TARGET=rpm
     - <<: *run-additional-jobs
       env: TARGET=npm

CMakeLists.txt

@@ -10,6 +10,8 @@ option (BUILDSWIGNODE "Build swig node modules" ON)
 option (BUILDSWIGJAVA "Build swig java modules" OFF)
 option (BUILDCORDOVA "Build cordova bindings" OFF)
 option (BUILDEXAMPLES "Build C/C++/JAVA examples" OFF)
+option (IPK "Generate IPK using CPack" OFF)
+option (RPM "Generate RPM using CPack" OFF)
 option (NPM "Generate NPM/GYP tarballs" OFF)
 option (BUILDTESTS "Generate check-ups for upm" OFF)
 option (WERROR "Make all warnings into errors." ON)
@@ -89,16 +91,13 @@ endfunction ()
 
 # Compiler flags common to both C and CXX
 # Enable -Wall
+# GCC-6 added -Wmisleading-indentation to -Wall, skip these for now
 set (C_CXX_WARNING_FLAGS -Wall
+    -Wno-misleading-indentation
     -Wno-strict-aliasing
     -Wno-deprecated-declarations # Temp fix for MRAA deprecated methods
     )
 
-# GCC-6 added -Wmisleading-indentation to -Wall, skip these for now
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "6")
-  list (APPEND C_CXX_WARNING_FLAGS -Wno-misleading-indentation)
-endif ()
-
 # Warnings as errors?
 if (WERROR)
   list (APPEND C_CXX_WARNING_FLAGS -Werror)
@@ -131,7 +130,7 @@ find_package (PkgConfig REQUIRED)
 
 # Force a libmraa search and minimum required version every time a config is generated
 unset(MRAA_FOUND CACHE)
-set(MRAA_MINIMUM 2.0.0)
+set(MRAA_MINIMUM 1.9.0)
 pkg_check_modules (MRAA REQUIRED mraa>=${MRAA_MINIMUM})
 # Also, get full path to the mraa library
 find_library(MRAA_LIBRARY NAMES mraa HINTS ${MRAA_LIBDIR})
@@ -151,11 +150,6 @@ pkg_check_modules (MODBUS libmodbus>=3.1.2)
 # Check for OPENZWAVE
 pkg_check_modules (OPENZWAVE libopenzwave)
 
-# Check for TinyB
-pkg_check_modules (TINYB tinyb>=0.5.1)
-# And get full path to the tinyb library
-find_library(TINYB_LIBRARY NAMES tinyb HINTS ${TINYB_LIBDIR})
-
 # Find JPEG
 find_package (JPEG)
 
@@ -235,7 +229,7 @@ include (GetGitRevisionDescription)
 git_describe (VERSION "--tags")
 # If git_describe fails, use a dirty version
 if (${VERSION} MATCHES -NOTFOUND)
-  set (VERSION "v1.7.1")
+  set (VERSION "v1.6.0")
   message (WARNING "Failed to retrieve UPM version with 'git describe' (using "
       "${VERSION}). Check that git is installed and this is a valid git repo.")
 endif ()
@@ -258,6 +252,11 @@ set (upm_VERSION_MINOR ${VERSION_MINOR})
 set (upm_VERSION_PATCH ${VERSION_PATCH})
 set (upm_VERSION_STRING ${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH})
 
+# Detect arch
+include (TargetArch)
+target_architecture (DETECTED_ARCH)
+message (STATUS "Target arch is ${DETECTED_ARCH}")
+
 # enable c++11 standards support unconditionally
 include(CheckCXXCompilerFlag)
 if (CMAKE_VERSION VERSION_LESS "3.1")
@@ -418,12 +417,71 @@ function (CreateDocumentationTargets)
   endif(BUILDSWIGNODE)
 endfunction()
 
+if (IPK)
+ # Get target package arch from Yocto ADT sysroot if set or host OS, mapping to Ubuntu name if necessary
+  if (DEFINED ENV{OECORE_TARGET_SYSROOT})
+    GET_FILENAME_COMPONENT (DETECTED_SYSROOT $ENV{OECORE_TARGET_SYSROOT} NAME)
+    string (REGEX REPLACE "-poky-linux" "" TARGET_ARCH "${DETECTED_SYSROOT}")
+  else ()
+    # Debian uses amd64 to denote x86_64
+    if (DETECTED_ARCH STREQUAL "x86_64")
+      set (TARGET_ARCH "amd64")
+    else ()
+      set (TARGET_ARCH ${DETECTED_ARCH})
+    endif ()
+  endif ()
+  message (STATUS "Package arch is ${TARGET_ARCH}")
+
+  set(CPACK_GENERATOR "DEB")
+  set(OPKG_ARCH ${TARGET_ARCH})
+  set(CPACK_BINARY_DIR ${CMAKE_BINARY_DIR})
+  set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Intel IoT-Devkit") #required
+  set(upm_PACKAGE_ON_TAG ".")
+  if ("${VERSION_COMMIT}" STREQUAL "")
+    set(upm_PACKAGE_ON_TAG "")
+  endif()
+  set(CPACK_PACKAGE_VERSION
+      "${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH}${upm_PACKAGE_ON_TAG}${VERSION_COMMIT}")
+  set(CPACK_PACKAGE_NAME "upm")
+  set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
+  set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE ${TARGET_ARCH})
+  set(CPACK_SYSTEM_NAME ${TARGET_ARCH})
+  set(CPACK_DEBIAN_PACKAGE_DEPENDS "mraa (>= ${MRAA_VERSION})")
+  set(CPACK_DEBIAN_PACKAGE_PROVIDES "upm-dev, upm-dbg, upm-doc")
+  set(CPACK_DEBIAN_PACKAGE_REPLACES ${CPACK_DEBIAN_PACKAGE_PROVIDES})
+  set(CPACK_DEBIAN_PACKAGE_CONFLICTS ${CPACK_DEBIAN_PACKAGE_PROVIDES})
+  set(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}")
+  include (CPack)
+endif()
+
+if (RPM)
+  message (STATUS "RPM packaging enabled for ${DETECTED_ARCH}")
+  set(CPACK_GENERATOR "RPM")
+  set(CPACK_PACKAGE_NAME "upm")
+  set(upm_PACKAGE_ON_TAG ".")
+  if ("${VERSION_COMMIT}" STREQUAL "")
+    set(upm_PACKAGE_ON_TAG "")
+  endif()
+  set(CPACK_PACKAGE_VERSION
+      "${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH}${upm_PACKAGE_ON_TAG}${VERSION_COMMIT}")
+  set(CPACK_PACKAGE_CONTACT "Intel IoT-Devkit")
+  set(CPACK_PACKAGE_VENDOR "Intel IoT-Devkit")
+  set(CPACK_RPM_PACKAGE_REQUIRES "mraa >= ${MRAA_VERSION}")
+  set(CPACK_RPM_PACKAGE_PROVIDES "${CPACK_PACKAGE_NAME}-devel")
+  set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+  EXECUTE_PROCESS(COMMAND rpm --showrc
+    COMMAND grep -E "dist[[:space:]]*\\."
+    COMMAND sed -e "s/^.*dist\\s*\\.//"
+    COMMAND tr \\n \\t
+    COMMAND sed  -e s/\\t//
+    OUTPUT_VARIABLE DIST_TAG)
+  set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.${DIST_TAG}.${DETECTED_ARCH}")
+  include(CPack)
+endif()
+
 # UPM common headers
 set (UPM_COMMON_HEADER_DIRS ${CMAKE_HOME_DIRECTORY}/include)
 
-# Generate a build-only C++ header to add functionality to SWIG'ed modules
-configure_file (${PROJECT_SOURCE_DIR}/cmake/modules/version.hpp.in ${PROJECT_BINARY_DIR}/src/version.hpp @ONLY)
-
 # UPM source
 add_subdirectory (src)
 

README.md

@@ -14,21 +14,21 @@ Programmers can access the interfaces for each sensor by including the sensor’
 corresponding header file and instantiating the associated sensor class. In the
 typical use case, a constructor initializes the sensor based on parameters that
 identify the sensor, the I/O protocol used and the pin location of the sensor.
-As of UPM 2.0, sensor initialization can also be done, in most cases, via
-overloaded constructors that accept string identifiers.
 
 We endorse additions that implement the generic C and C++ interfaces provided
-with the libraries. With the 2.0 release, UPM introduces the following sensor
+with the libraries. Multiple sensor and actuator types have been defined, for
-interfaces: iAcceleration, iAngle, iButton, iClock, iCollision, iDistance,
+instance:
-iDistanceInterrupter, iEC, iElectromagnet, iEmg, iGas, iGps, iGyroscope,
-iHallEffect, iHeartRate, iHumidity, iLight, iLineFinder, iMagnetometer,
-iMoisture, iMotion, iOrp, iPH, iPressure, iProximity, iTemperature, iVDiv,
-iWater.
 
-The developer community is invited to propose new interfaces for actuator types.
+* Light controller 
+* Light sensor
+* Temperature sensor
+* Humidity sensor
+* Pressure sensor
+* Gas sensor
+* Analog to digital converter
 
-The UPM project is joining the Eclipse Foundation as an Eclipse IoT project.
+The developer community is welcome to submit feedback on existing categories or
-You can read more about this [here](https://projects.eclipse.org/proposals/eclipse-upm).
+suggest new ones.
 
 ### Example
 
@@ -97,16 +97,12 @@ See building documentation [here](docs/building.md).
 
 A quick way to add a new sensor driver is to port existing code from another
 platform (e.g. Arduino) and swap the IO calls to the MRAA API. This of course
-assumes either ownership of the original code or a MIT compatible license that
+assumes either ownership of the original code or licensing that allows
-allows unrestricted redistribution.
+unrestricted redistribution.
 
 The [porting](docs/porting.md) section has more information on this process,
 and there is an example available based on the max31855 [sensor](docs/max31855.md).
 
-We have an [on demand webinar](https://software.seek.intel.com/IoT_WebinarSeries_Reg)
-available that covers using an IDE to develop for the UPM project along with other
-considerations for new contributions.
-
 Read more on creating Java [bindings](docs/creating_java_bindings.md) for your
 new driver.
 
@@ -118,8 +114,7 @@ The name you pick for a newly added sensor needs to be unique in the UPM library
 Then, please go over this short set of rules for new [contributions](docs/contributions.md).
 Make sure you add yourself as an author on every new code file submitted.
 If you are providing a fix with significant changes, feel free to add yourself
-as a contributor. Signing-off your commits is mandatory and acts as an
+as a contributor. Signing-off your commits is mandatory.
-acknowledgment of the committer agreement.
 
 Documenting your code is also a big part of the task. We have a strict set of
 tags used to classify our sensors and their capabilities. You can find out more
@@ -142,6 +137,9 @@ our API in a way that will break backwards compatibility. If you find yourself
 unable to compile code that was working fine before a library update, make sure
 you check the [API changes](docs/apichanges.md) section first.
 
+**NOTE** - Several important API changes are currently underway for some of our
+widely used libraries including `libupm-grove`
+
 ### Changelog
 Version changelog [here](docs/changelog.md).
 

cmake/Toolchains/oe-sdk_cross.cmake

@@ -0,0 +1,25 @@
+# this toolchain file comes from gnuradio project
+
+set( CMAKE_SYSTEM_NAME Linux )
+#set( CMAKE_C_COMPILER  $ENV{CC} )
+#set( CMAKE_CXX_COMPILER  $ENV{CXX} )
+string(REGEX MATCH "sysroots/([a-zA-Z0-9]+)" CMAKE_SYSTEM_PROCESSOR $ENV{SDKTARGETSYSROOT})
+string(REGEX REPLACE "sysroots/" "" CMAKE_SYSTEM_PROCESSOR ${CMAKE_SYSTEM_PROCESSOR})
+set( CMAKE_CXX_FLAGS $ENV{CXXFLAGS}  CACHE STRING "" FORCE )
+set( CMAKE_C_FLAGS $ENV{CFLAGS} CACHE STRING "" FORCE ) #same flags for C sources
+set( CMAKE_LDFLAGS_FLAGS ${CMAKE_CXX_FLAGS} CACHE STRING "" FORCE ) #same flags for C sources
+set( CMAKE_LIBRARY_PATH ${OECORE_TARGET_SYSROOT}/usr/lib )
+set( CMAKE_FIND_ROOT_PATH $ENV{OECORE_TARGET_SYSROOT} $ENV{OECORE_NATIVE_SYSROOT} )
+set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
+set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
+set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
+set( CMAKE_INSTALL_PREFIX $ENV{OECORE_TARGET_SYSROOT}/usr CACHE STRING "" FORCE)
+set( ORC_INCLUDE_DIRS $ENV{OECORE_TARGET_SYSROOT}/usr/include/orc-0.4 )
+set( ORC_LIBRARY_DIRS $ENV{OECORE_TARGET_SYSROOT}/usr/lib )
+
+# for java
+set( JAVA_AWT_INCLUDE_PATH $ENV{JAVA_HOME}/include CACHE PATH "" FORCE)
+set( JAVA_AWT_LIBRARY $ENV{JAVA_HOME}/jre/lib/amd64/libjawt.so CACHE FILEPATH "" FORCE)
+set( JAVA_INCLUDE_PATH $ENV{JAVA_HOME}/include CACHE PATH "" FORCE)
+set( JAVA_INCLUDE_PATH2 $ENV{JAVA_HOME}/include/linux CACHE PATH "" FORCE)
+set( JAVA_JVM_LIBRARY $ENV{JAVA_HOME}/jre/lib/amd64/libjvm.so CACHE FILEPATH "" FORCE)

cmake/modules/TargetArch.cmake

@@ -0,0 +1,136 @@
+# Based on the Qt 5 processor detection code, so should be very accurate
+# https://qt.gitorious.org/qt/qtbase/blobs/master/src/corelib/global/qprocessordetection.h
+# Currently handles arm (v5, v6, v7), x86 (32/64), ia64, and ppc (32/64)
+
+# Regarding POWER/PowerPC, just as is noted in the Qt source,
+# "There are many more known variants/revisions that we do not handle/detect."
+
+set(archdetect_c_code "
+#if defined(__arm__) || defined(__TARGET_ARCH_ARM)
+    #if defined(__ARM_ARCH_7__) \\
+        || defined(__ARM_ARCH_7A__) \\
+        || defined(__ARM_ARCH_7R__) \\
+        || defined(__ARM_ARCH_7M__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 7)
+        #error cmake_ARCH armv7
+    #elif defined(__ARM_ARCH_6__) \\
+        || defined(__ARM_ARCH_6J__) \\
+        || defined(__ARM_ARCH_6T2__) \\
+        || defined(__ARM_ARCH_6Z__) \\
+        || defined(__ARM_ARCH_6K__) \\
+        || defined(__ARM_ARCH_6ZK__) \\
+        || defined(__ARM_ARCH_6M__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 6)
+        #error cmake_ARCH armv6
+    #elif defined(__ARM_ARCH_5TEJ__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 5)
+        #error cmake_ARCH armv5
+    #else
+        #error cmake_ARCH arm
+    #endif
+#elif defined(__i586) || defined(__i586__)
+    #error cmake_ARCH i586
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+    #error cmake_ARCH i386
+#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
+    #error cmake_ARCH x86_64
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+    #error cmake_ARCH ia64
+#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \\
+      || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \\
+      || defined(_M_MPPC) || defined(_M_PPC)
+    #if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
+        #error cmake_ARCH ppc64
+    #else
+        #error cmake_ARCH ppc
+    #endif
+#endif
+
+#error cmake_ARCH unknown
+")
+
+# Set ppc_support to TRUE before including this file or ppc and ppc64
+# will be treated as invalid architectures since they are no longer supported by Apple
+
+function(target_architecture output_var)
+    if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+        # On OS X we use CMAKE_OSX_ARCHITECTURES *if* it was set
+        # First let's normalize the order of the values
+
+        # Note that it's not possible to compile PowerPC applications if you are using
+        # the OS X SDK version 10.6 or later - you'll need 10.4/10.5 for that, so we
+        # disable it by default
+        # See this page for more information:
+        # http://stackoverflow.com/questions/5333490/how-can-we-restore-ppc-ppc64-as-well-as-full-10-4-10-5-sdk-support-to-xcode-4
+
+        # Architecture defaults to i386 or ppc on OS X 10.5 and earlier, depending on the CPU type detected at runtime.
+        # On OS X 10.6+ the default is x86_64 if the CPU supports it, i386 otherwise.
+
+        foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
+            if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
+                set(osx_arch_ppc TRUE)
+            elseif("${osx_arch}" STREQUAL "i386")
+                set(osx_arch_i386 TRUE)
+            elseif("${osx_arch}" STREQUAL "x86_64")
+                set(osx_arch_x86_64 TRUE)
+            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
+                set(osx_arch_ppc64 TRUE)
+            else()
+                message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
+            endif()
+        endforeach()
+
+        # Now add all the architectures in our normalized order
+        if(osx_arch_ppc)
+            list(APPEND ARCH ppc)
+        endif()
+
+        if(osx_arch_i386)
+            list(APPEND ARCH i386)
+        endif()
+
+        if(osx_arch_x86_64)
+            list(APPEND ARCH x86_64)
+        endif()
+
+        if(osx_arch_ppc64)
+            list(APPEND ARCH ppc64)
+        endif()
+    else()
+        file(WRITE "${CMAKE_BINARY_DIR}/arch.c" "${archdetect_c_code}")
+
+        enable_language(C)
+
+        # Detect the architecture in a rather creative way...
+        # This compiles a small C program which is a series of ifdefs that selects a
+        # particular #error preprocessor directive whose message string contains the
+        # target architecture. The program will always fail to compile (both because
+        # file is not a valid C program, and obviously because of the presence of the
+        # #error preprocessor directives... but by exploiting the preprocessor in this
+        # way, we can detect the correct target architecture even when cross-compiling,
+        # since the program itself never needs to be run (only the compiler/preprocessor)
+        try_run(
+            run_result_unused
+            compile_result_unused
+            "${CMAKE_BINARY_DIR}"
+            "${CMAKE_BINARY_DIR}/arch.c"
+            COMPILE_OUTPUT_VARIABLE ARCH
+            CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+        )
+
+        # Parse the architecture name from the compiler output
+        string(REGEX MATCH "cmake_ARCH ([a-zA-Z0-9_]+)" ARCH "${ARCH}")
+
+        # Get rid of the value marker leaving just the architecture name
+        string(REPLACE "cmake_ARCH " "" ARCH "${ARCH}")
+
+        # If we are compiling with an unknown architecture this variable should
+        # already be set to "unknown" but in the case that it's empty (i.e. due
+        # to a typo in the code), then set it to unknown
+        if (NOT ARCH)
+            set(ARCH unknown)
+        endif()
+    endif()
+
+    set(${output_var} "${ARCH}" PARENT_SCOPE)
+endfunction()

cmake/modules/version.hpp.in

@@ -1,6 +0,0 @@
-#include <string>
-
-inline std::string getVersion()
-{
-    return "@upm_VERSION_STRING@";
-}

docker-compose.yaml

@@ -16,7 +16,6 @@ services:
       - BUILDCORDOVA=${BUILDCORDOVA:-OFF}
       - BUILDSWIGNODE=${BUILDSWIGNODE:-OFF}
       - BUILDEXAMPLES=${BUILDEXAMPLES:-OFF}
-      - CMAKE_BUILD_TYPE
       - IPK=${IPK:-OFF}
       - RPM=${RPM:-OFF}
       - NPM=${NPM:-OFF}
@@ -56,6 +55,20 @@ services:
       - BUILDEXAMPLES=ON
     command: bash -c "./scripts/run-cmake.sh && cd build && make -j8"
 
+  ipk:
+    extends: all
+    environment:
+      - IPK=ON
+      - BUILDDOC=OFF
+    command: bash -c "./scripts/run-cmake.sh && make -Cbuild -j8 package"
+
+  rpm:
+    extends: all
+    environment:
+      - RPM=ON
+      - BUILDDOC=OFF
+    command: bash -c "./scripts/run-cmake.sh && make -Cbuild -j8 package"
+
   npm:
     extends: all
     environment:
@@ -64,10 +77,12 @@ services:
     command: bash -c "./scripts/run-cmake.sh && make -Cbuild -j8 npmpkg"
 
   sonar-scan:
-    extends: base
+    extends: all
-    image: inteliotdevkit/upm-sonar
     environment:
-      - BUILDTESTS=OFF
+      - BUILDSWIGPYTHON=ON
+      - BUILDSWIGNODE=ON
+      - BUILDSWIGJAVA=ON
+      - BUILDEXAMPLES=ON
       - SONAR_TOKEN
       - SONAR_ORG
       - SONAR_PROJ_KEY

docs/apichanges.md

@@ -4,24 +4,10 @@ API Changes                       {#apichanges}
 Here's a list of other API changes made to the library that break source/binary
 compatibility between releases:
 
-# v2.0.0
+# vNext
- * Sensors implementing the old interfaces (bme280, bmpx8x, si7005, si1132,
+ * The interface of **kx122** has been modified to return values instead of
- max44009, lp8860, ds1808lc, hlg150h) have been updated to use the new ones,
+ receiving pointers.  This applies to member functions: getWhoAmI,
- hence some function names and parameters will be different.
+ getInterruptSource, getBufferStatus, getRawBufferSamples, and getBufferSamples.
- * Removed deprecated basic grove classes from project, see API changes for
- v1.1.0 and prior for a complete list
-
-# v1.7.0
- * The interface of **kx122** has been modified to return values instead
- of receiving pointers. This applies to member functions: getWhoAmI,
- getInterruptSource, getBufferStatus, getRawBufferSamples, and
- getBufferSamples.
- * The **tm1637** constructor has been updated and the fast GPIO parameter
- has been removed with the deprecation of supporting MRAA functions. The
- GPIO lines will initialize by default in fast mode when available.
- * The generic **nmea_gps** library for GPS devices has been greatly enhanced
- with new APIs to offer better control over acquisition intervals and simplify
- parsing of the returned data.
 
 # v1.6.0
 

docs/building.md

@@ -96,16 +96,13 @@ You can also generate the include and lib directories containing all the sensor
 headers and library files respectively with *make install*. Further, you may
 choose to generate these only for a specific sensor you modified, and this can
 be achieved by building from the individual makefile of the sensor. Assuming
-you're in the build directory, to build/install the lcd module you would:
+you're in the build directory, to make the lcd module you would:
 
 ~~~~~~~~~~~~~
 cd src/lcd
 make install
 ~~~~~~~~~~~~~
 
-Note: 'make install' under src/lcd will build all targets (and dependencies)
-for the lcd but will NOT install dependencies.
-
 Often developers are only interested in building one module or even just the
 python/node module to do some quick testing using scripting. In order to do
 this you need to use the target name for the python or node module you want to

docs/changelog.md

@@ -4,37 +4,6 @@ Changelog                         {#changelog}
 Here's a list summarizing some of the key undergoing changes to our library
 from earlier versions:
 
-### v2.0.0
-
- * Reworked existing interfaces and extended the list to include iAcceleration,
- iAngle, iButton, iClock, iCollision, iDistance, iDistanceInterrupter, iEC,
- iElectromagnet, iEmg, iGas, iGps, iGyroscope, iHallEffect, iHeartRate, iHumidity,
- iLight, iLineFinder, iMagnetometer, iMoisture, iMotion, iOrp, iPH, iPressure,
- iProximity, iTemperature, iVDiv, iWater
- * Provided overloaded string based constructors for a good number of sensors,
- allowing initialization from external frameworks without type knowledge
- * Removed deprecated basic grove classes from project
- * Replaced 6 unsafe occurrences of sprintf() usage
- * Cleaned-up build system around target arch detection and cpack usage, added
- detection and resolution of tinyb library when used as a dependency
- * New sensors: 2jciebu01_ble, 2jciebu01_usb
-
-### v1.7.1
-
- * Bumped library compatibility to new MRAA 2.0 APIs
- * Added installation details for Fedora
- * Minor fixes based on static analysis vulnerability report
-
-### v1.7.0
-
- * Added Cordova bindings based on Java packages
- * Complete rework of the nmea_gps library giving more control over data
- acquisition and parsing
- * Added GTest support for unit tests
- * Removed calls to deprecated MRAA fast GPIO functions
- * Several bug fixes and improvements around SWIG type maps and gcc8 support
- * New sensors: kx122, kxtj3, bh1792, bh1749
-
 ### v1.6.0
 
  * Extended LED library to support the new MRAA gpio-leds APIs

docs/images/LICENSE_CC_3_0.txt

@@ -0,0 +1,361 @@
+Creative Commons Legal Code
+
+Attribution-NonCommercial-ShareAlike 3.0 Unported
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR
+    DAMAGES RESULTING FROM ITS USE.
+
+License
+
+THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE
+COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY
+COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS
+AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
+
+BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE
+TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY
+BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS
+CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND
+CONDITIONS.
+
+1. Definitions
+
+ a. "Adaptation" means a work based upon the Work, or upon the Work and
+    other pre-existing works, such as a translation, adaptation,
+    derivative work, arrangement of music or other alterations of a
+    literary or artistic work, or phonogram or performance and includes
+    cinematographic adaptations or any other form in which the Work may be
+    recast, transformed, or adapted including in any form recognizably
+    derived from the original, except that a work that constitutes a
+    Collection will not be considered an Adaptation for the purpose of
+    this License. For the avoidance of doubt, where the Work is a musical
+    work, performance or phonogram, the synchronization of the Work in
+    timed-relation with a moving image ("synching") will be considered an
+    Adaptation for the purpose of this License.
+ b. "Collection" means a collection of literary or artistic works, such as
+    encyclopedias and anthologies, or performances, phonograms or
+    broadcasts, or other works or subject matter other than works listed
+    in Section 1(g) below, which, by reason of the selection and
+    arrangement of their contents, constitute intellectual creations, in
+    which the Work is included in its entirety in unmodified form along
+    with one or more other contributions, each constituting separate and
+    independent works in themselves, which together are assembled into a
+    collective whole. A work that constitutes a Collection will not be
+    considered an Adaptation (as defined above) for the purposes of this
+    License.
+ c. "Distribute" means to make available to the public the original and
+    copies of the Work or Adaptation, as appropriate, through sale or
+    other transfer of ownership.
+ d. "License Elements" means the following high-level license attributes
+    as selected by Licensor and indicated in the title of this License:
+    Attribution, Noncommercial, ShareAlike.
+ e. "Licensor" means the individual, individuals, entity or entities that
+    offer(s) the Work under the terms of this License.
+ f. "Original Author" means, in the case of a literary or artistic work,
+    the individual, individuals, entity or entities who created the Work
+    or if no individual or entity can be identified, the publisher; and in
+    addition (i) in the case of a performance the actors, singers,
+    musicians, dancers, and other persons who act, sing, deliver, declaim,
+    play in, interpret or otherwise perform literary or artistic works or
+    expressions of folklore; (ii) in the case of a phonogram the producer
+    being the person or legal entity who first fixes the sounds of a
+    performance or other sounds; and, (iii) in the case of broadcasts, the
+    organization that transmits the broadcast.
+ g. "Work" means the literary and/or artistic work offered under the terms
+    of this License including without limitation any production in the
+    literary, scientific and artistic domain, whatever may be the mode or
+    form of its expression including digital form, such as a book,
+    pamphlet and other writing; a lecture, address, sermon or other work
+    of the same nature; a dramatic or dramatico-musical work; a
+    choreographic work or entertainment in dumb show; a musical
+    composition with or without words; a cinematographic work to which are
+    assimilated works expressed by a process analogous to cinematography;
+    a work of drawing, painting, architecture, sculpture, engraving or
+    lithography; a photographic work to which are assimilated works
+    expressed by a process analogous to photography; a work of applied
+    art; an illustration, map, plan, sketch or three-dimensional work
+    relative to geography, topography, architecture or science; a
+    performance; a broadcast; a phonogram; a compilation of data to the
+    extent it is protected as a copyrightable work; or a work performed by
+    a variety or circus performer to the extent it is not otherwise
+    considered a literary or artistic work.
+ h. "You" means an individual or entity exercising rights under this
+    License who has not previously violated the terms of this License with
+    respect to the Work, or who has received express permission from the
+    Licensor to exercise rights under this License despite a previous
+    violation.
+ i. "Publicly Perform" means to perform public recitations of the Work and
+    to communicate to the public those public recitations, by any means or
+    process, including by wire or wireless means or public digital
+    performances; to make available to the public Works in such a way that
+    members of the public may access these Works from a place and at a
+    place individually chosen by them; to perform the Work to the public
+    by any means or process and the communication to the public of the
+    performances of the Work, including by public digital performance; to
+    broadcast and rebroadcast the Work by any means including signs,
+    sounds or images.
+ j. "Reproduce" means to make copies of the Work by any means including
+    without limitation by sound or visual recordings and the right of
+    fixation and reproducing fixations of the Work, including storage of a
+    protected performance or phonogram in digital form or other electronic
+    medium.
+
+2. Fair Dealing Rights. Nothing in this License is intended to reduce,
+limit, or restrict any uses free from copyright or rights arising from
+limitations or exceptions that are provided for in connection with the
+copyright protection under copyright law or other applicable laws.
+
+3. License Grant. Subject to the terms and conditions of this License,
+Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
+perpetual (for the duration of the applicable copyright) license to
+exercise the rights in the Work as stated below:
+
+ a. to Reproduce the Work, to incorporate the Work into one or more
+    Collections, and to Reproduce the Work as incorporated in the
+    Collections;
+ b. to create and Reproduce Adaptations provided that any such Adaptation,
+    including any translation in any medium, takes reasonable steps to
+    clearly label, demarcate or otherwise identify that changes were made
+    to the original Work. For example, a translation could be marked "The
+    original work was translated from English to Spanish," or a
+    modification could indicate "The original work has been modified.";
+ c. to Distribute and Publicly Perform the Work including as incorporated
+    in Collections; and,
+ d. to Distribute and Publicly Perform Adaptations.
+
+The above rights may be exercised in all media and formats whether now
+known or hereafter devised. The above rights include the right to make
+such modifications as are technically necessary to exercise the rights in
+other media and formats. Subject to Section 8(f), all rights not expressly
+granted by Licensor are hereby reserved, including but not limited to the
+rights described in Section 4(e).
+
+4. Restrictions. The license granted in Section 3 above is expressly made
+subject to and limited by the following restrictions:
+
+ a. You may Distribute or Publicly Perform the Work only under the terms
+    of this License. You must include a copy of, or the Uniform Resource
+    Identifier (URI) for, this License with every copy of the Work You
+    Distribute or Publicly Perform. You may not offer or impose any terms
+    on the Work that restrict the terms of this License or the ability of
+    the recipient of the Work to exercise the rights granted to that
+    recipient under the terms of the License. You may not sublicense the
+    Work. You must keep intact all notices that refer to this License and
+    to the disclaimer of warranties with every copy of the Work You
+    Distribute or Publicly Perform. When You Distribute or Publicly
+    Perform the Work, You may not impose any effective technological
+    measures on the Work that restrict the ability of a recipient of the
+    Work from You to exercise the rights granted to that recipient under
+    the terms of the License. This Section 4(a) applies to the Work as
+    incorporated in a Collection, but this does not require the Collection
+    apart from the Work itself to be made subject to the terms of this
+    License. If You create a Collection, upon notice from any Licensor You
+    must, to the extent practicable, remove from the Collection any credit
+    as required by Section 4(d), as requested. If You create an
+    Adaptation, upon notice from any Licensor You must, to the extent
+    practicable, remove from the Adaptation any credit as required by
+    Section 4(d), as requested.
+ b. You may Distribute or Publicly Perform an Adaptation only under: (i)
+    the terms of this License; (ii) a later version of this License with
+    the same License Elements as this License; (iii) a Creative Commons
+    jurisdiction license (either this or a later license version) that
+    contains the same License Elements as this License (e.g.,
+    Attribution-NonCommercial-ShareAlike 3.0 US) ("Applicable License").
+    You must include a copy of, or the URI, for Applicable License with
+    every copy of each Adaptation You Distribute or Publicly Perform. You
+    may not offer or impose any terms on the Adaptation that restrict the
+    terms of the Applicable License or the ability of the recipient of the
+    Adaptation to exercise the rights granted to that recipient under the
+    terms of the Applicable License. You must keep intact all notices that
+    refer to the Applicable License and to the disclaimer of warranties
+    with every copy of the Work as included in the Adaptation You
+    Distribute or Publicly Perform. When You Distribute or Publicly
+    Perform the Adaptation, You may not impose any effective technological
+    measures on the Adaptation that restrict the ability of a recipient of
+    the Adaptation from You to exercise the rights granted to that
+    recipient under the terms of the Applicable License. This Section 4(b)
+    applies to the Adaptation as incorporated in a Collection, but this
+    does not require the Collection apart from the Adaptation itself to be
+    made subject to the terms of the Applicable License.
+ c. You may not exercise any of the rights granted to You in Section 3
+    above in any manner that is primarily intended for or directed toward
+    commercial advantage or private monetary compensation. The exchange of
+    the Work for other copyrighted works by means of digital file-sharing
+    or otherwise shall not be considered to be intended for or directed
+    toward commercial advantage or private monetary compensation, provided
+    there is no payment of any monetary compensation in con-nection with
+    the exchange of copyrighted works.
+ d. If You Distribute, or Publicly Perform the Work or any Adaptations or
+    Collections, You must, unless a request has been made pursuant to
+    Section 4(a), keep intact all copyright notices for the Work and
+    provide, reasonable to the medium or means You are utilizing: (i) the
+    name of the Original Author (or pseudonym, if applicable) if supplied,
+    and/or if the Original Author and/or Licensor designate another party
+    or parties (e.g., a sponsor institute, publishing entity, journal) for
+    attribution ("Attribution Parties") in Licensor's copyright notice,
+    terms of service or by other reasonable means, the name of such party
+    or parties; (ii) the title of the Work if supplied; (iii) to the
+    extent reasonably practicable, the URI, if any, that Licensor
+    specifies to be associated with the Work, unless such URI does not
+    refer to the copyright notice or licensing information for the Work;
+    and, (iv) consistent with Section 3(b), in the case of an Adaptation,
+    a credit identifying the use of the Work in the Adaptation (e.g.,
+    "French translation of the Work by Original Author," or "Screenplay
+    based on original Work by Original Author"). The credit required by
+    this Section 4(d) may be implemented in any reasonable manner;
+    provided, however, that in the case of a Adaptation or Collection, at
+    a minimum such credit will appear, if a credit for all contributing
+    authors of the Adaptation or Collection appears, then as part of these
+    credits and in a manner at least as prominent as the credits for the
+    other contributing authors. For the avoidance of doubt, You may only
+    use the credit required by this Section for the purpose of attribution
+    in the manner set out above and, by exercising Your rights under this
+    License, You may not implicitly or explicitly assert or imply any
+    connection with, sponsorship or endorsement by the Original Author,
+    Licensor and/or Attribution Parties, as appropriate, of You or Your
+    use of the Work, without the separate, express prior written
+    permission of the Original Author, Licensor and/or Attribution
+    Parties.
+ e. For the avoidance of doubt:
+
+     i. Non-waivable Compulsory License Schemes. In those jurisdictions in
+        which the right to collect royalties through any statutory or
+        compulsory licensing scheme cannot be waived, the Licensor
+        reserves the exclusive right to collect such royalties for any
+        exercise by You of the rights granted under this License;
+    ii. Waivable Compulsory License Schemes. In those jurisdictions in
+        which the right to collect royalties through any statutory or
+        compulsory licensing scheme can be waived, the Licensor reserves
+        the exclusive right to collect such royalties for any exercise by
+        You of the rights granted under this License if Your exercise of
+        such rights is for a purpose or use which is otherwise than
+        noncommercial as permitted under Section 4(c) and otherwise waives
+        the right to collect royalties through any statutory or compulsory
+        licensing scheme; and,
+   iii. Voluntary License Schemes. The Licensor reserves the right to
+        collect royalties, whether individually or, in the event that the
+        Licensor is a member of a collecting society that administers
+        voluntary licensing schemes, via that society, from any exercise
+        by You of the rights granted under this License that is for a
+        purpose or use which is otherwise than noncommercial as permitted
+        under Section 4(c).
+ f. Except as otherwise agreed in writing by the Licensor or as may be
+    otherwise permitted by applicable law, if You Reproduce, Distribute or
+    Publicly Perform the Work either by itself or as part of any
+    Adaptations or Collections, You must not distort, mutilate, modify or
+    take other derogatory action in relation to the Work which would be
+    prejudicial to the Original Author's honor or reputation. Licensor
+    agrees that in those jurisdictions (e.g. Japan), in which any exercise
+    of the right granted in Section 3(b) of this License (the right to
+    make Adaptations) would be deemed to be a distortion, mutilation,
+    modification or other derogatory action prejudicial to the Original
+    Author's honor and reputation, the Licensor will waive or not assert,
+    as appropriate, this Section, to the fullest extent permitted by the
+    applicable national law, to enable You to reasonably exercise Your
+    right under Section 3(b) of this License (right to make Adaptations)
+    but not otherwise.
+
+5. Representations, Warranties and Disclaimer
+
+UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING AND TO THE
+FULLEST EXTENT PERMITTED BY APPLICABLE LAW, LICENSOR OFFERS THE WORK AS-IS
+AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE
+WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT
+LIMITATION, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS,
+ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT
+DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED
+WARRANTIES, SO THIS EXCLUSION MAY NOT APPLY TO YOU.
+
+6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE
+LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR
+ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES
+ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS
+BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. Termination
+
+ a. This License and the rights granted hereunder will terminate
+    automatically upon any breach by You of the terms of this License.
+    Individuals or entities who have received Adaptations or Collections
+    from You under this License, however, will not have their licenses
+    terminated provided such individuals or entities remain in full
+    compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will
+    survive any termination of this License.
+ b. Subject to the above terms and conditions, the license granted here is
+    perpetual (for the duration of the applicable copyright in the Work).
+    Notwithstanding the above, Licensor reserves the right to release the
+    Work under different license terms or to stop distributing the Work at
+    any time; provided, however that any such election will not serve to
+    withdraw this License (or any other license that has been, or is
+    required to be, granted under the terms of this License), and this
+    License will continue in full force and effect unless terminated as
+    stated above.
+
+8. Miscellaneous
+
+ a. Each time You Distribute or Publicly Perform the Work or a Collection,
+    the Licensor offers to the recipient a license to the Work on the same
+    terms and conditions as the license granted to You under this License.
+ b. Each time You Distribute or Publicly Perform an Adaptation, Licensor
+    offers to the recipient a license to the original Work on the same
+    terms and conditions as the license granted to You under this License.
+ c. If any provision of this License is invalid or unenforceable under
+    applicable law, it shall not affect the validity or enforceability of
+    the remainder of the terms of this License, and without further action
+    by the parties to this agreement, such provision shall be reformed to
+    the minimum extent necessary to make such provision valid and
+    enforceable.
+ d. No term or provision of this License shall be deemed waived and no
+    breach consented to unless such waiver or consent shall be in writing
+    and signed by the party to be charged with such waiver or consent.
+ e. This License constitutes the entire agreement between the parties with
+    respect to the Work licensed here. There are no understandings,
+    agreements or representations with respect to the Work not specified
+    here. Licensor shall not be bound by any additional provisions that
+    may appear in any communication from You. This License may not be
+    modified without the mutual written agreement of the Licensor and You.
+ f. The rights granted under, and the subject matter referenced, in this
+    License were drafted utilizing the terminology of the Berne Convention
+    for the Protection of Literary and Artistic Works (as amended on
+    September 28, 1979), the Rome Convention of 1961, the WIPO Copyright
+    Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996
+    and the Universal Copyright Convention (as revised on July 24, 1971).
+    These rights and subject matter take effect in the relevant
+    jurisdiction in which the License terms are sought to be enforced
+    according to the corresponding provisions of the implementation of
+    those treaty provisions in the applicable national law. If the
+    standard suite of rights granted under applicable copyright law
+    includes additional rights not granted under this License, such
+    additional rights are deemed to be included in the License; this
+    License is not intended to restrict the license of any rights under
+    applicable law.
+
+
+Creative Commons Notice
+
+    Creative Commons is not a party to this License, and makes no warranty
+    whatsoever in connection with the Work. Creative Commons will not be
+    liable to You or any party on any legal theory for any damages
+    whatsoever, including without limitation any general, special,
+    incidental or consequential damages arising in connection to this
+    license. Notwithstanding the foregoing two (2) sentences, if Creative
+    Commons has expressly identified itself as the Licensor hereunder, it
+    shall have all rights and obligations of Licensor.
+
+    Except for the limited purpose of indicating to the public that the
+    Work is licensed under the CCPL, Creative Commons does not authorize
+    the use by either party of the trademark "Creative Commons" or any
+    related trademark or logo of Creative Commons without the prior
+    written consent of Creative Commons. Any permitted use will be in
+    compliance with Creative Commons' then-current trademark usage
+    guidelines, as may be published on its website or otherwise made
+    available upon request from time to time. For the avoidance of doubt,
+    this trademark restriction does not form part of this License.
+
+    Creative Commons may be contacted at https://creativecommons.org/.
+   

docs/installing.md

@@ -54,18 +54,6 @@ sudo apt-get install libupm-dev libupm-java python-upm python3-upm node-upm upm-
 Running UPM applications on Ubuntu systems requires elevated permissions
 (e.g. run with `sudo`).
 
-### Fedora Linux
-
-MRAA and UPM are available through the default package repositories on Fedora and can be
-installed in the standard method using dnf.
-
-To install:
-
-```bash
-sudo dnf install upm
-sudo dnf install paython3-upm nodejs-upm upm-examples
-```
-
 ### Node.js bindings only (NPM)
 
 This option allows compiling MRAA/UPM on any system with npm and node-gyp.

doxy/README.npm.md

@@ -34,6 +34,13 @@ var lib = require('jsupm_<module-name>');
 ### Supported Sensors
 The full list is available on [Intel® IoT Developer Zone](https://software.intel.com/en-us/iot/hardware/sensors).
 
+### IDE Integration
+Intel® XDK IoT Edition is the recommended IDE for Node.js development. Visit
+the Intel® Developer Zone [IDE page](https://software.intel.com/iot/software/ide)
+for more information on how to get started.
+
+![Intel XDK](http://iotdk.intel.com/docs/master/upm/docs/icons/xdk.png)
+
 ### Building UPM
 See building documentation [here](https://github.com/intel-iot-devkit/upm/blob/master/docs/building.md).
 

doxy/index.rst

@@ -23,6 +23,15 @@ repository.
 
 Individual sensor usage examples for Python are available `here <https://github.com/intel-iot-devkit/upm/tree/master/examples/python>`_.
 
+``IDE Compatibility``
+################
+
+While there is no official IDE provided with our Python libraries, we do recommend the web-based IDE Wyliodrin. It can be used with multiple programming
+languages, including Python. More information can be found on the Intel Developer Zone IDE page.
+
+.. image:: ../docs/icons/wyliodrin.png
+   :target: https://software.intel.com/iot/software/ide
+
 ``Making your own UPM Module``
 ##############################
 

doxy/node/generators/yuidoc/tmpl/partials/index.handlebars

@@ -36,6 +36,19 @@
          href="https://github.com/intel-iot-devkit/upm/tree/master/examples/javascript">here</a>.</p>
       
     </div>
+    <div class="section" id="ide"> 
+      <h3><tt class="docutils literal"><span class="pre">IDE Compatibility</span> 
+      <span class="pre">UPM</span></tt><a class="headerlink"
+                                          href="#ide"
+                                          title="Permalink to this headline">*</a></h3>
+      
+
+      <p>Intel&reg; XDK IoT Edition is the recommended IDE for Node.js development.
+      Visit the Intel&reg; Developer Zone IDE page for more information on how to get
+      started.<br>
+      <a href="https://software.intel.com/iot/software/ide"><img src="../docs/icons/xdk.png"/></a>
+      </p>
+    </div>
     <div class="section" id="building-upm"> 
       <h3><tt class="docutils literal"><span class="pre">Building</span> 
       <span class="pre">UPM</span></tt><a class="headerlink"

doxy/samples.mapping.txt

@@ -3,9 +3,6 @@ a110x.cxx A110X_Example.java a110x.js a110x.py
 a110x-intr.cxx A110X_intr_Example.java a110x-intr.js a110x-intr.py
 adc121c021.cxx ADC121C021_Example.java adc121c021.js adc121c021.py
 adxl345.cxx Adxl345_Example.java adxl345.js adxl345.py
-bh1749.cxx BH1749_Example.java bh1749.js bh1749.py
-bh1750.cxx BH1750_Example.java bh1750.js bh1750.py
-bh1792.cxx BH1792_Example.java bh1792.js bh1792.py
 biss0001.cxx BISS0001_Example.java biss0001.js biss0001.py
 bmpx8x.cxx BMPX8X_Example.java bmpx8x.js bmpx8x.py
 bno055.cxx BNO055_Example.java bno055.js bno055.py

examples/c++/2jciebu01_ble.cxx

@@ -1,539 +0,0 @@
-/*
-* 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.
-*/
-
-/* standard headers */
-#include <iostream>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-
-/* omron sensor headers */
-#include "2jciebu01_ble.hpp"
-
-using namespace std;
-using namespace upm;
-
-#define PREVIOUS_MENU_CHOICE           8
-
-volatile sig_atomic_t flag = 1;
-
-
-upm::OM2JCIEBU_BLE::om2jciebuData_t om2jciebuSensorData;
-
-void
-sig_handler(int signum)
-{
-    if(signum == SIGABRT) {
-        std::cout << "Exiting..." << std::endl;
-    }
-    if(signum == SIGINT) {
-        flag = 0;
-    }
-}
-
-
-void getSensorData(OM2JCIEBU_BLE *p_om2jcieble)
-{
-
-    if(p_om2jcieble == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    uint16_t parameterChoice = 0;
-    int displayDelay = 0;
-    uint16_t sensorParamData = 0;
-    uint32_t pressureData = 0;
-    bool seconds_validate = false;
-
-    p_om2jcieble->getDiscoveredServices(OM2JCIEBU_BLE::ALL_PARAM);
-    while(true) {
-        printf("************************************************************\r\n");
-        printf("Please select sensor attribute for display\r\n");
-        printf("0) All parameter\r\n");
-        printf("1) Temperature data\r\n");
-        printf("2) Relative humidity data\r\n");
-        printf("3) Ambient light data\r\n");
-        printf("4) Barometric pressure data\r\n");
-        printf("5) Sound noise data\r\n");
-        printf("6) eTVOC data\r\n");
-        printf("7) eCO2 data\r\n");
-        printf("8) Return to main menu\r\n");
-        printf("Note :: Press Ctrl+C for sensor attribute display menu\r\n");
-        printf("************************************************************\r\n");
-        while(!(std::cin >> parameterChoice)) {
-            std::cin.clear(); //clear bad input flag
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-            std::cout << "Invalid input; please re-enter.\n";
-        }
-        if(parameterChoice >= OM2JCIEBU_BLE::ALL_PARAM && parameterChoice <= OM2JCIEBU_BLE::ECO2) {
-            flag = 1;
-            printf("Please enter time interval (in Seconds), for display sensor data\r\n");
-            while(!seconds_validate) {
-                cin >> displayDelay;
-                if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (displayDelay >= 1 && displayDelay <= 10)) {
-                    seconds_validate = true;
-                } else {
-                    cin.clear();
-                    cin.ignore();
-                    cout << "Error, enter an second between 1 to 10!" << endl;
-                }
-            }
-            while(flag) {
-                switch(parameterChoice) {
-                    case OM2JCIEBU_BLE::ALL_PARAM:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ALL_PARAM, &om2jciebuSensorData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Sensor Attribute Values ***************\r\n");
-                            printf("Sequence Number     :: %d \r\n", om2jciebuSensorData.sequence_number);
-                            printf("Temperature         :: %d degC\r\n", om2jciebuSensorData.temperature);
-                            printf("Relative humidity   :: %d RH\r\n", om2jciebuSensorData.relative_humidity);
-                            printf("Ambient light       :: %d lx\r\n", om2jciebuSensorData.ambient_light);
-                            printf("Barometric pressure :: %d hPa\r\n", om2jciebuSensorData.pressure);
-                            printf("Sound noise         :: %d dB\r\n", om2jciebuSensorData.noise);
-                            printf("eTVOC               :: %d ppb\r\n", om2jciebuSensorData.eTVOC);
-                            printf("eCO2                :: %d ppm\r\n", om2jciebuSensorData.eCO2);
-                            printf("**********************************************************\r\n");
-                            memset(&om2jciebuSensorData, 0, sizeof(om2jciebuSensorData));
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::TEMP:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::TEMP, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Temperature Attribute Values ***************\r\n");
-                            printf("Temperature         :: %d degC\r\n", sensorParamData);
-                            printf("************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::HUMIDITY:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::HUMIDITY, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Relative humidity Attribute Values ***************\r\n");
-                            printf("Relative humidity   :: %d RH\r\n", sensorParamData);
-                            printf("******************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::AMBIENT_LIGHT:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::AMBIENT_LIGHT, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Ambient light Attribute Values ***************\r\n");
-                            printf("Ambient light       :: %d lx\r\n", sensorParamData);
-                            printf("***************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::PRESSURE:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::PRESSURE, &pressureData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Barometric pressure Attribute Values ***************\r\n");
-                            printf("Barometric pressure :: %d hPa\r\n", pressureData);
-                            printf("********************************************************************\r\n");
-                        }
-                        break;
-
-                    case OM2JCIEBU_BLE::NOISE:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::NOISE, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Sound noise Attribute Values ***************\r\n");
-                            printf("Sound noise         :: %d dB\r\n", sensorParamData);
-                            printf("*************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-
-                    case OM2JCIEBU_BLE::ETVOC:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ETVOC, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  eTVOC Attribute Values ***************\r\n");
-                            printf("eTVOC               :: %d ppb\r\n", sensorParamData);
-                            printf("*******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::ECO2:
-                        if(p_om2jcieble->getSensorData(OM2JCIEBU_BLE::ECO2, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  eCO2 Attribute Values ***************\r\n");
-                            printf("eCO2                :: %d ppm\r\n\r\n", sensorParamData);
-                            printf("******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                }
-                printf("\r\n");
-                p_om2jcieble->delay(displayDelay);
-            }
-        } else if(parameterChoice == PREVIOUS_MENU_CHOICE) {
-            break;
-        } else {
-            printf("Invalid choice\r\n");
-        }
-        seconds_validate = false;
-    }
-}
-
-void getAdvSensorData(OM2JCIEBU_BLE *p_om2jcieble)
-{
-    if(p_om2jcieble == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-
-    uint16_t parameterChoice = 0, sensorParamData = 0;
-    int displayDelay = 0;
-    uint32_t pressureData = 0;
-    bool seconds_validate = false;
-
-    while(true) {
-        printf("************************************************************\r\n");
-        printf("Please select sensor attribute for display\r\n");
-        printf("0) All parameter\r\n");
-        printf("1) Temperature data\r\n");
-        printf("2) Relative humidity data\r\n");
-        printf("3) Ambient light data\r\n");
-        printf("4) Barometric pressure data\r\n");
-        printf("5) Sound noise data\r\n");
-        printf("6) eTVOC data\r\n");
-        printf("7) eCO2 data\r\n");
-        printf("8) Return to main menu\r\n");
-        printf("Note :: Press Ctrl+C for sensor attribute display menu\r\n");
-        printf("************************************************************\r\n");
-        while(!(std::cin >> parameterChoice)) {
-            std::cin.clear(); //clear bad input flag
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-            std::cout << "Invalid input; please re-enter.\n";
-        }
-        if(parameterChoice >= OM2JCIEBU_BLE::ALL_PARAM && parameterChoice <= OM2JCIEBU_BLE::ECO2) {
-            flag = 1;
-            printf("Please enter time interval (in Seconds), for display sensor data\r\n");
-            while(!seconds_validate) {
-                cin >> displayDelay;
-                if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (displayDelay >= 1 && displayDelay <= 10)) {
-                    seconds_validate = true;
-                } else {
-                    cin.clear();
-                    cin.ignore();
-                    cout << "Error, enter an second between 1 and 10!" << endl;
-                }
-            }
-            while(flag) {
-                switch(parameterChoice) {
-                    case OM2JCIEBU_BLE::ALL_PARAM:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ALL_PARAM, &om2jciebuSensorData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Advertisement Sensor Attribute Values ***************\r\n");
-                            printf("Sequence Number     :: %d \r\n", om2jciebuSensorData.sequence_number);
-                            printf("Temperature         :: %d degC\r\n", om2jciebuSensorData.temperature);
-                            printf("Relative humidity   :: %d RH\r\n", om2jciebuSensorData.relative_humidity);
-                            printf("Ambient light       :: %d lx\r\n", om2jciebuSensorData.ambient_light);
-                            printf("Barometric pressure :: %d hPa\r\n", om2jciebuSensorData.pressure);
-                            printf("Sound noise         :: %d dB\r\n", om2jciebuSensorData.noise);
-                            printf("eTVOC               :: %d ppb\r\n", om2jciebuSensorData.eTVOC);
-                            printf("eCO2                :: %d ppm\r\n", om2jciebuSensorData.eCO2);
-                            printf("*********************************************************************\r\n");
-                            memset(&om2jciebuSensorData, 0, sizeof(om2jciebuSensorData));
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::TEMP:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::TEMP, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Advertisement Temperature Attribute Values ***************\r\n");
-                            printf("Temperature         :: %d degC\r\n", sensorParamData);
-                            printf("**************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::HUMIDITY:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::HUMIDITY, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************  Advertisement Relative humidity Attribute Values ***************\r\n");
-                            printf("Relative humidity   :: %d RH\r\n", sensorParamData);
-                            printf("********************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::AMBIENT_LIGHT:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::AMBIENT_LIGHT, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("************** Advertisement Ambient light Attribute Values ***************\r\n");
-                            printf("Ambient light       :: %d lx\r\n", sensorParamData);
-                            printf("***************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::PRESSURE:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::PRESSURE, &pressureData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("************** Advertisement Barometric pressure Attribute Values ***************\r\n");
-                            printf("Barometric pressure :: %d hPa\r\n", pressureData);
-                            printf("*********************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-
-                    case OM2JCIEBU_BLE::NOISE:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::NOISE, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("************** Advertisement Sound noise Attribute Values ***************\r\n");
-                            printf("Sound noise         :: %d dB\r\n", sensorParamData);
-                            printf("*************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-
-                    case OM2JCIEBU_BLE::ETVOC:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ETVOC, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("**************** Advertisement eTVOC Attribute Values ******************\r\n");
-                            printf("eTVOC               :: %d ppb\r\n", sensorParamData);
-                            printf("************************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_BLE::ECO2:
-                        if(p_om2jcieble->getAdvSensorData(OM2JCIEBU_BLE::ECO2, &sensorParamData) == OM2JCIEBU_BLE::SUCCESS) {
-                            printf("************** Advertisement eCO2 Attribute Values ***************\r\n");
-                            printf("eCO2                :: %d ppm\r\n\r\n", sensorParamData);
-                            printf("******************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                }
-                printf("\r\n");
-                p_om2jcieble->delay(displayDelay);
-            }
-        } else if(parameterChoice == PREVIOUS_MENU_CHOICE) {
-            break;
-        } else {
-            printf("Invalid choice\r\n");
-        }
-        seconds_validate = false;
-    }
-}
-
-void configureLEDSetting(OM2JCIEBU_BLE *p_om2jcieble)
-{
-    if(p_om2jcieble == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    int led_choice = 0;
-    unsigned short int red_scale = 0, green_scale = 0, blue_scale = 0;
-    bool red_scale_validate = false, green_scale_validate = false, blue_scale_validate = false;
-    printf("**************  Sensor LED Configuration ***************\r\n");
-    printf("Please select a operation for LED\r\n");
-    printf("0) Normally OFF\r\n");
-    printf("1) Normally ON\r\n");
-    printf("2) Temperature value scales\r\n");
-    printf("3) Relative humidity value scales\r\n");
-    printf("4) Ambient light value scales\r\n");
-    printf("5) Barometric pressure value scales\r\n");
-    printf("6) Sound noise value scales\r\n");
-    printf("7) eTVOC value scales\r\n");
-    printf("8) SI vale scales\r\n");
-    printf("9) PGA value scales\r\n");
-    printf("**********************************************************\r\n");
-    while(!(std::cin >> led_choice)) {
-        std::cin.clear(); //clear bad input flag
-        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-        std::cout << "Invalid input; please re-enter.\n";
-    }
-
-    if(led_choice == OM2JCIEBU_BLE::NORMALLY_ON) {
-        printf("Please select a LED color scale\r\n");
-        printf("Please enter Red Color scale (scale range 0 to 255)\r\n");
-        while(!red_scale_validate) {
-            cin >> red_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (red_scale >= 0 && red_scale <= 255)) {
-                red_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an red color scale between 0 and 255!" << endl;
-            }
-        }
-        printf("Please enter Green Color scale(scale range 0 to 255)\r\n");
-        while(!green_scale_validate) {
-            cin >> green_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (green_scale >= 0 && green_scale <= 255)) {
-                green_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an green color scale between 0 and 255!" << endl;
-            }
-        }
-        printf("Please enter Blue Color scale(scale range 0 to 255)\r\n");
-        while(!blue_scale_validate) {
-            cin >> blue_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (blue_scale >= 0 && blue_scale <= 255)) {
-                blue_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an blue color scale between 0 and 255!" << endl;
-            }
-        }
-        p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NORMALLY_ON, red_scale, green_scale, blue_scale);
-    } else {
-        switch(led_choice) {
-            case OM2JCIEBU_BLE::NORMALLY_OFF:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NORMALLY_OFF, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::TEMP_SACLE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::TEMP_SACLE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::HUMIDITY_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::HUMIDITY_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::AMBIENT_LIGHT_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::AMBIENT_LIGHT_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::PRESSURE_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::PRESSURE_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::NOISE_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::NOISE_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::ETVOC_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::ETVOC_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::SI_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::SI_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_BLE::PGA_SCALE:
-                p_om2jcieble->configureSensorLedState(OM2JCIEBU_BLE::PGA_SCALE, 0, 0, 0);
-                break;
-            default:
-                std::cout << "Wrong LED scale choice please try again" << std::endl;
-        }
-    }
-}
-
-void configureAdvInterval(OM2JCIEBU_BLE *p_om2jcieble)
-{
-    if(p_om2jcieble == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    uint16_t millisecond = 0;
-    bool milisecond_validate = false;
-    int advertising_mode = 0;
-    printf("**************  Sensor Advertise Configuration ***************\r\n");
-    printf("Please enter time interval (in Milliseconds), for changing Advertise interval, between 100 to 10240 milliseconds\r\n");
-    while(!milisecond_validate) {
-        cin >> millisecond;
-        if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (millisecond >= 100 && millisecond <= 10240)) {
-            milisecond_validate = true;
-        } else {
-            cin.clear();
-            cin.ignore();
-            cout << "Error, enter an millisecond between 100 and 10240!" << endl;
-        }
-    }
-    printf("Please select an Advertise mode with the selected Advertise interval \r\n");
-    printf("1) Sensor data\r\n");
-    printf("2) Calculation data\r\n");
-    printf("3) Sensor data and Calculation data\r\n");
-    printf("4) Sensor flag and Calculation flag\r\n");
-    printf("5) Serial number\r\n");
-    while(!(std::cin >> advertising_mode)) {
-        std::cin.clear(); //clear bad input flag
-        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-        std::cout << "Invalid input; please re-enter.\n";
-    }
-    switch(advertising_mode) {
-        case OM2JCIEBU_BLE::SENSOR_DATA:
-            p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::SENSOR_DATA);
-            break;
-        case OM2JCIEBU_BLE::ACCELERATION_DATA:
-            p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_DATA);
-            break;
-        case OM2JCIEBU_BLE::ACCELERATION_SENSOR_DATA:
-            p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_SENSOR_DATA);
-            break;
-        case OM2JCIEBU_BLE::ACCELERATION_SENSOR_FLAG:
-            p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::ACCELERATION_SENSOR_FLAG);
-            break;
-        case OM2JCIEBU_BLE::SERIAL_NUMBER:
-            p_om2jcieble->configureSensorAdvSetting(millisecond, OM2JCIEBU_BLE::SERIAL_NUMBER);
-            break;
-        default:
-            std::cout << "Invalid choice\n";
-    }
-    printf("**************************************************************\r\n");
-}
-
-int
-main(int argc, char *argv[])
-{
-    int operation_choice = 0;
-    if(argc <= 1) {
-        std::cout << "usage ./a.out xx:xx:xx:xx:xx:xx" << std::endl;
-        return 0;
-    }
-    signal(SIGABRT, sig_handler);
-    signal(SIGINT, sig_handler);
-    upm::OM2JCIEBU_BLE om2jciebu_ble(argv[1]);
-    while(true) {
-        std::cout << "*************************************************************" << std::endl;
-        std::cout << "Please choose one option for Omron sensor operation" << std::endl;
-        std::cout << "1) Display Advertisement Sensor attriutes" << std::endl;
-        std::cout << "2) Display Sensor attriutes" << std::endl;
-        std::cout << "3) Configure LED setting " << std::endl;
-        std::cout << "4) Configure advertise setting" << std::endl;
-        std::cout << "5) Exit" << std::endl;
-        std::cout << "*************************************************************" << std::endl;
-        while(!(std::cin >> operation_choice)) {
-            std::cin.clear(); //clear bad input flag
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-            std::cout << "Invalid input; please re-enter.\n";
-        }
-
-        switch(operation_choice) {
-            case 1:
-                getAdvSensorData(&om2jciebu_ble);
-                break;
-            case 2:
-                getSensorData(&om2jciebu_ble);
-                break;
-            case 3:
-                configureLEDSetting(&om2jciebu_ble);
-                break;
-            case 4:
-                configureAdvInterval(&om2jciebu_ble);
-                break;
-            case 5:
-                std::cout << "Application Exited" << std::endl;
-                om2jciebu_ble.removeBleDevice();
-                exit(0);
-                break;
-            default:
-                std::cout << "Invalid choice" << std::endl;
-                break;
-        }
-    }
-}

examples/c++/2jciebu01_usb.cxx

@@ -1,414 +0,0 @@
-/*
-* 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.
-*/
-
-/* standard headers */
-#include <iostream>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-
-/* omron sensor headers */
-#include "2jciebu01_usb.hpp"
-
-using namespace std;
-using namespace upm;
-
-volatile sig_atomic_t flag = 1;
-#define PREVIOUS_MENU_CHOICE           10
-
-upm::OM2JCIEBU_UART::om2jciebuData_t om2jciebuSensorData;
-
-void
-sig_handler(int signum)
-{
-    if(signum == SIGABRT) { //check for Abort signal
-        std::cout << "Exiting..." << std::endl;
-    }
-    if(signum == SIGINT) { //check for Interrupt signal
-		std::cout << "Exiting..." << std::endl;
-        flag = 0;
-    }
-}
-
-
-void getSensorData(OM2JCIEBU_UART *p_om2jcieuart)
-{
-    if(p_om2jcieuart == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    uint16_t parameterChoice = 0;
-    int displayDelay = 0;
-    bool seconds_validate = false;
-    uint16_t sensorParamData = 0;
-    uint32_t pressureData = 0;
-
-    while(true) {
-        printf("************************************************************\r\n");
-        printf("Please select sensor attribute for display\r\n");
-        printf("0)  All parameter\r\n");
-        printf("1)  Temperature data\r\n");
-        printf("2)  Relative humidity data\r\n");
-        printf("3)  Ambient light data\r\n");
-        printf("4)  Barometric pressure data\r\n");
-        printf("5)  Sound noise data\r\n");
-        printf("6)  eTVOC data\r\n");
-        printf("7)  eCO2 data\r\n");
-        printf("8)  Discomfort index data\r\n");
-        printf("9)  Heat stroke data\r\n");
-        printf("10) Return to main menu\r\n");
-        printf("Note :: Press Ctrl+C for sensor attribute display menu\r\n");
-        printf("************************************************************\r\n");
-        while(!(std::cin >> parameterChoice)) {
-            std::cin.clear(); //clear bad input flag
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-            std::cout << "Invalid input; please re-enter.\n";
-        }
-        if(parameterChoice >= OM2JCIEBU_UART::ALL_PARAM && parameterChoice <= OM2JCIEBU_UART::HEAT_STROKE) {
-            flag = 1;
-            printf("Please enter time interval (in Seconds), for display sensor data\r\n");
-            while(!seconds_validate) { //validate user input values
-                cin >> displayDelay;
-                if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (displayDelay >= 1 && displayDelay <= 10)) {
-                    seconds_validate = true;
-                } else {
-                    cin.clear();
-                    cin.ignore();
-                    cout << "Error, enter an second between 1 to 10!" << endl;
-                }
-            }
-            while(flag) {
-                switch(parameterChoice) {
-                    case OM2JCIEBU_UART::ALL_PARAM:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::ALL_PARAM, &om2jciebuSensorData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Sensor Attribute Values ***************\r\n");
-                            printf("Sequence Number     :: %d \r\n", om2jciebuSensorData.sequence_number);
-                            printf("Temperature         :: %d degC\r\n", om2jciebuSensorData.temperature);
-                            printf("Relative humidity   :: %d RH\r\n", om2jciebuSensorData.relative_humidity);
-                            printf("Ambient light       :: %d lx\r\n", om2jciebuSensorData.ambient_light);
-                            printf("Barometric pressure :: %d hPa\r\n", om2jciebuSensorData.pressure);
-                            printf("Sound noise         :: %d dB\r\n", om2jciebuSensorData.noise);
-                            printf("eTVOC               :: %d ppb\r\n", om2jciebuSensorData.eTVOC);
-                            printf("eCO2                :: %d ppm\r\n", om2jciebuSensorData.eCO2);
-                            printf("Discomfort index    :: %d \r\n", om2jciebuSensorData.discomfort_index);
-                            printf("Heat stroke         :: %d degC\r\n", om2jciebuSensorData.heat_stroke);
-                            printf("**********************************************************\r\n");
-                            memset(&om2jciebuSensorData, 0, sizeof(om2jciebuSensorData));
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::TEMP:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::TEMP, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Temperature Attribute Values ***************\r\n");
-                            printf("Temperature         :: %d degC\r\n", sensorParamData);
-                            printf("************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::HUMIDITY:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::HUMIDITY, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Relative humidity Attribute Values ***************\r\n");
-                            printf("Relative humidity   :: %d RH\r\n", sensorParamData);
-                            printf("******************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::AMBIENT_LIGHT:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::AMBIENT_LIGHT, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Ambient light Attribute Values ***************\r\n");
-                            printf("Ambient light       :: %d lx\r\n", sensorParamData);
-                            printf("**************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::PRESSURE:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::PRESSURE, &pressureData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Barometric pressure Attribute Values ***************\r\n");
-                            printf("Barometric pressure :: %d hPa\r\n", pressureData);
-                            printf("********************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-
-                    case OM2JCIEBU_UART::NOISE:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::NOISE, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  Sound noise Attribute Values ***************\r\n");
-                            printf("Sound noise         :: %d dB\r\n", sensorParamData);
-                            printf("************************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-
-                    case OM2JCIEBU_UART::ETVOC:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::ETVOC, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  eTVOC Attribute Values ***************\r\n");
-                            printf("eTVOC               :: %d ppb\r\n", sensorParamData);
-                            printf("******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::ECO2:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::ECO2, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  eCO2 Attribute Values ***************\r\n");
-                            printf("eCO2                :: %d ppm\r\n\r\n", sensorParamData);
-                            printf("******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::DISCOMFORT_INDEX:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::DISCOMFORT_INDEX, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  eCO2 Attribute Values ***************\r\n");
-                            printf("Discomfort index                :: %d \r\n\r\n", sensorParamData);
-                            printf("******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                    case OM2JCIEBU_UART::HEAT_STROKE:
-                        if(p_om2jcieuart->getSensorData(OM2JCIEBU_UART::HEAT_STROKE, &sensorParamData) == OM2JCIEBU_UART::SUCCESS) {
-                            printf("**************  eCO2 Attribute Values ***************\r\n");
-                            printf("Heat stroke                :: %d degC\r\n\r\n", sensorParamData);
-                            printf("******************************************************\r\n");
-                        } else {
-                            flag = 0;
-                        }
-                        break;
-                }
-                printf("\r\n");
-                p_om2jcieuart->delay(displayDelay);
-            }
-        } else if(parameterChoice == PREVIOUS_MENU_CHOICE) {
-            break;
-        } else {
-            printf("Invalid choice\r\n");
-        }
-        seconds_validate = false;
-    }
-}
-
-void configureLEDSetting(OM2JCIEBU_UART *p_om2jcieuart)
-{
-    if(p_om2jcieuart == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    int led_choice = 0;
-    bool red_scale_validate = false, green_scale_validate = false, blue_scale_validate = false;
-    unsigned short int red_scale = 0, green_scale = 0, blue_scale = 0;
-    printf("**************  Sensor LED Configuration ***************\r\n");
-    printf("Please select a operation for LED\r\n");
-    printf("0) Normally OFF\r\n");
-    printf("1) Normally ON\r\n");
-    printf("2) Temperature value scales\r\n");
-    printf("3) Relative humidity value scales\r\n");
-    printf("4) Ambient light value scales\r\n");
-    printf("5) Barometric pressure value scales\r\n");
-    printf("6) Sound noise value scales\r\n");
-    printf("7) eTVOC value scales\r\n");
-    printf("8) SI vale scales\r\n");
-    printf("9) PGA value scales\r\n");
-    printf("**********************************************************\r\n");
-    while(!(std::cin >> led_choice)) {
-        std::cin.clear(); //clear bad input flag
-        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-        std::cout << "Invalid input; please re-enter.\n";
-    }
-
-    if(led_choice == OM2JCIEBU_UART::NORMALLY_ON) {
-        printf("Please Select a LED color scale\r\n");
-        printf("Please enter Red Color scale (scale range 0 to 255)\r\n");
-        while(!red_scale_validate) {
-            cin >> red_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (red_scale >= 0 && red_scale <= 255)) {
-                red_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an red color scale between 0 and 255!" << endl;
-            }
-        }
-        printf("Please enter Green Color scale(scale range 0 to 255)\r\n");
-        while(!green_scale_validate) {
-            cin >> green_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (green_scale >= 0 && green_scale <= 255)) {
-                green_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an green color scale between 0 and 255!" << endl;
-            }
-        }
-        printf("Please enter Blue Color scale(scale range 0 to 255)\r\n");
-        while(!blue_scale_validate) {
-            cin >> blue_scale;
-            if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (blue_scale >= 0 && blue_scale <= 255)) {
-                blue_scale_validate = true;
-            } else {
-                cin.clear();
-                cin.ignore();
-                cout << "Error, enter an blue color scale between 0 and 255!" << endl;
-            }
-        }
-        p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::NORMALLY_ON, red_scale, green_scale, blue_scale);
-    } else {
-        switch(led_choice) {
-            case OM2JCIEBU_UART::NORMALLY_OFF:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::NORMALLY_OFF, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::TEMP_SACLE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::TEMP_SACLE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::HUMIDITY_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::HUMIDITY_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::AMBIENT_LIGHT_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::AMBIENT_LIGHT_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::PRESSURE_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::PRESSURE_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::NOISE_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::NOISE_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::ETVOC_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::ETVOC_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::SI_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::SI_SCALE, 0, 0, 0);
-                break;
-            case OM2JCIEBU_UART::PGA_SCALE:
-                p_om2jcieuart->configureSensorLedState(OM2JCIEBU_UART::PGA_SCALE, 0, 0, 0);
-                break;
-            default:
-                std::cout << "Wrong LED scale choice please try again" << std::endl;
-        }
-    }
-}
-
-void configureAdvInterval(OM2JCIEBU_UART *p_om2jcieuart)
-{
-    if(p_om2jcieuart == NULL) {
-        std::cout << "Null pointer received..." << std::endl;
-        return;
-    }
-    bool millisecond_validate = false;
-    uint16_t millisecond = 0;
-    int advertising_mode = 0;
-    printf("**************  Sensor Advertise Configuration ***************\r\n");
-    printf("Please enter time interval (in Milliseconds), for changing Advertise interval, between 100 to 10240 milliseconds\r\n");
-    while(!millisecond_validate) {//validate millisecond
-        cin >> millisecond;
-        if(!cin.fail() && (cin.peek() == EOF || cin.peek() == '\n') && (millisecond >= 100 && millisecond <= 10240)) {
-            millisecond_validate = true;
-        } else {
-            cin.clear();
-            cin.ignore();
-            cout << "Error, enter an milisecond between 100 and 10240!" << endl;
-        }
-    }
-    printf("Please select an Advertise mode with the selected Advertise interval \r\n");
-    printf("1) Sensor data\r\n");
-    printf("2) Calculation data\r\n");
-    printf("3) Sensor data and Calculation data\r\n");
-    printf("4) Sensor flag and Calculation flag\r\n");
-    printf("5) Serial number\r\n");
-    while(!(std::cin >> advertising_mode)) {
-        std::cin.clear(); //clear bad input flag
-        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-        std::cout << "Invalid input; please re-enter.\n";
-    }
-    switch(advertising_mode) {
-        case OM2JCIEBU_UART::SENSOR_DATA:
-            p_om2jcieuart->configureSensorAdvSetting(millisecond, OM2JCIEBU_UART::SENSOR_DATA);
-            break;
-        case OM2JCIEBU_UART::ACCELERATION_DATA:
-            p_om2jcieuart->configureSensorAdvSetting(millisecond, OM2JCIEBU_UART::ACCELERATION_DATA);
-            break;
-        case OM2JCIEBU_UART::ACCELERATION_SENSOR_DATA:
-            p_om2jcieuart->configureSensorAdvSetting(millisecond, OM2JCIEBU_UART::ACCELERATION_SENSOR_DATA);
-            break;
-        case OM2JCIEBU_UART::ACCELERATION_SENSOR_FLAG:
-            p_om2jcieuart->configureSensorAdvSetting(millisecond, OM2JCIEBU_UART::ACCELERATION_SENSOR_FLAG);
-            break;
-        case OM2JCIEBU_UART::SERIAL_NUMBER:
-            p_om2jcieuart->configureSensorAdvSetting(millisecond, OM2JCIEBU_UART::SERIAL_NUMBER);
-            break;
-        default:
-            std::cout << "Invalid choice\n";
-    }
-    printf("**************************************************************\r\n");
-}
-
-int
-main(int argc, char *argv[])
-{
-    int operation_choice = 0;
-    if(argc <= 1) {
-        std::cout << "usage ./a.out /dev/ttyUSB*" << std::endl;
-        return 0;
-    }
-    signal(SIGABRT, sig_handler);
-    signal(SIGINT, sig_handler);
-    upm::OM2JCIEBU_UART om2jciebu_uart(argv[1], 115200);
-    om2jciebu_uart.setMode(8, mraa::UART_PARITY_NONE, 1);
-    om2jciebu_uart.setFlowControl(false, false);
-    while(true) {
-        std::cout << "*************************************************************" << std::endl;
-        std::cout << "Please choose one option for Omron sensor operation" << std::endl;
-        std::cout << "1) Display Sensor attriutes" << std::endl;
-        std::cout << "2) Configure LED setting " << std::endl;
-        std::cout << "3) Configure advertise setting" << std::endl;
-        std::cout << "4) Exit" << std::endl;
-        std::cout << "*************************************************************" << std::endl;
-        while(!(std::cin >> operation_choice)) { //validate operation choice from user input
-            std::cin.clear(); //clear bad input flag
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); //discard input
-            std::cout << "Invalid input; please re-enter.\n";
-        }
-        switch(operation_choice) {
-            case 1:
-                getSensorData(&om2jciebu_uart);
-                break;
-            case 2:
-                configureLEDSetting(&om2jciebu_uart);
-                break;
-            case 3:
-                configureAdvInterval(&om2jciebu_uart);
-                break;
-            case 4:
-                std::cout << "Application Exited" << std::endl;
-                exit(0);
-                break;
-            default:
-                std::cout << "Invalid choice" << std::endl;
-        }
-    }
-}

examples/c++/CMakeLists.txt

@@ -3,10 +3,16 @@ file (GLOB example_src_list RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cxx")
 
 # - Handle special cases here --------------------------------------------------
 
-# Test temperature interface for 2 sensor libraries
+# Test humidity interface for 2 sensor libraries
-add_example(iTemperature_sample.cxx TARGETS interfaces lm35 abp)
+add_example(core-humiditysensor.cxx TARGETS si7005 bmp280)
-# Test light interface for 3 sensor libraries
+# Test pressure interface for 2 sensor libraries
-add_example(iLight_sample.cxx TARGETS interfaces apds9002 bh1750 max44009)
+add_example(core-pressuresensor.cxx TARGETS bmp280 bmpx8x)
+# Test temperature interface for 3 sensor libraries
+add_example(core-temperaturesensor.cxx TARGETS bmp280 bmpx8x si7005)
+# Test light interface for 2 sensor libraries
+add_example(core-lightsensor.cxx TARGETS si1132 max44009)
+# Test light controller interface for 3 sensor libraries
+add_example(core-lightcontroller.cxx TARGETS lp8860 ds1808lc hlg150h)
 
 # - Create an executable for all other src files in this directory -------------
 foreach (_example_src ${example_src_list})

examples/c++/ads1x15-adc-sensor.cxx

@@ -27,6 +27,7 @@
 #include <stddef.h>
 
 #include "ads1015.hpp"
+#include "iADC.hpp"
 #include "mraa/gpio.hpp"
 #include "upm_utilities.h"
 
@@ -38,21 +39,24 @@ int
 main()
 {
     /* Create an instance of the ADS1015 sensor */
-    upm::ADS1015 adc(EDISON_I2C_BUS);
+    upm::ADS1015 sensor(EDISON_I2C_BUS);
     mraa::Gpio gpio(EDISON_GPIO_SI7005_CS);
     gpio.dir(mraa::DIR_OUT_HIGH);
 
-    // if (adc == NULL) {
+    /* Show usage from the iADC interface */
-    //     std::cout << "ADC not detected" << std::endl;
+    upm::iADC* adc = static_cast<upm::iADC*>(&sensor);
-    //     return 1;
+
-    // }
+    if (adc == NULL) {
-    std::cout << "ADC " << adc.getModuleName() << " detected. ";
+        std::cout << "ADC not detected" << std::endl;
-    std::cout << adc.getNumInputs() << " inputs available" << std::endl;
+        return 1;
+    }
+    std::cout << "ADC " << adc->Name() << " detected. ";
+    std::cout << adc->getNumInputs() << " inputs available" << std::endl;
     while (true) {
-        for (unsigned int i = 0; i < adc.getNumInputs(); ++i) {
+        for (unsigned int i = 0; i < adc->getNumInputs(); ++i) {
             std::cout << "Input " << i;
             try {
-                float voltage = adc.getVoltage(i);
+                float voltage = adc->getVoltage(i);
                 std::cout << ": Voltage = " << voltage << "V" << std::endl;
             } catch (std::exception& e) {
                 std::cerr << e.what() << std::endl;

examples/c++/bh1749.cxx

@@ -1,71 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <iostream>
-#include <unistd.h>
-#include <stdexcept>
-#include <signal.h>
-#include <vector>
-#include "bh1749.hpp"
-#include "upm_utilities.h"
-
-bool isStopped;
-upm::BH1749 dev;
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-//! [Interesting]
-void PrintData(void *args)
-{
-    std::vector<uint16_t> result = dev.GetMeasurements();
-    std::cout << "R: " << result.at(0) <<
-                ", G: " << result.at(1) <<
-                ", B: " << result.at(2) <<
-                ", IR: " << result.at(3) <<
-                ", G2: " << result.at(4) << std::endl;
-    dev.ResetInterrupt();
-}
-
-int main(int argc, char **argv)
-{
-    signal(SIGINT, signal_int_handler);
-    dev.SoftReset();
-    dev.SensorInit(INT_JUDGE_1, MEAS_240MS, RGB_GAIN_1X, IR_GAIN_1X, RED);
-    dev.SetThresholdHigh(511);
-    std::cout << "Installing ISR" << std::endl;
-    dev.InstallISR(MRAA_GPIO_EDGE_FALLING, 33, &PrintData, NULL);
-    dev.EnableInterrupt();
-    dev.Enable();
-
-    while(!isStopped) {
-        upm_delay_ms(1000);
-    }
-
-    return 0;
-}
-//! [Interesting]

examples/c++/bh1792.cxx

@@ -1,81 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <iostream>
-#include <signal.h>
-#include  <sys/time.h>
-#include "bh1792.hpp"
-#include "upm_utilities.h"
-
-bool isStopped;
-upm::BH1792 dev;
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-//! [Interesting]
-void PrintData(void *args)
-{
-    std::vector<std::vector<int>> fifo;
-    struct timespec now;
-
-    clock_gettime(CLOCK_MONOTONIC_RAW, &now);
-    try {
-        fifo = dev.GetFifoData();
-
-        std::cout << "\nHeart beat sensor FIFO data:" << std::endl;
-        for(int i = 0; i < 32; i++)
-            std::cout << i << ": off: " << fifo.at(i).at(0) << ", on: " <<
-                        fifo.at(i).at(1) << std::endl;
-
-        std::cout << "timestamp " << now.tv_sec << " sec, " << now.tv_nsec <<
-                    " nsec" << std::endl;
-    } catch (std::exception& e) {
-        std::cout << "Failed to read FIFO data" << std::endl;
-        throw;
-    }
-}
-
-int main(int argc, char **argv)
-{
-    float measTime;
-
-    signal(SIGINT, signal_int_handler);
-    dev.SoftReset();
-    dev.EnableSyncMode(256, 32);
-    std::cout << "Installing ISR" << std::endl;
-    dev.InstallISR(MRAA_GPIO_EDGE_FALLING, 33, &PrintData, NULL);
-    measTime = dev.GetMeasurementTimeMS();
-    dev.StartMeasurement();
-
-    while(!isStopped) {
-        usleep(measTime * 1000);
-    }
-
-    return 0;
-}
-//! [Interesting]

examples/c++/buzzer-initio.cxx

@@ -1,12 +0,0 @@
-#include <iostream>
-
-#include "buzzer.hpp"
-#include "buzzer_tones.h"
-#include "upm_utilities.h"
-
-int
-main(int argc, char** argv)
-{
-  upm::Buzzer buzzer("p:32,vol:0.01,play:3800:500000");
-  return 0;
-}

examples/c++/buzzer.cxx

@@ -35,7 +35,7 @@ main(int argc, char** argv)
     int chord[] = { BUZZER_DO, BUZZER_RE, BUZZER_MI, BUZZER_FA, BUZZER_SOL, BUZZER_LA, BUZZER_SI };
 
     // create Buzzer instance
-    upm::Buzzer sound(32);
+    upm::Buzzer sound(5);
     // print sensor name
     std::cout << sound.name() << std::endl;
 

examples/c++/core-humiditysensor.cxx

@@ -0,0 +1,92 @@
+/*
+ * Author: Henry Bruce <henry.bruce@intel.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <exception>
+#include <iostream>
+#include <stddef.h>
+
+#include "bme280.hpp"
+#include "iHumiditySensor.hpp"
+#include "mraa/common.h"
+#include "si7005.hpp"
+#include "upm_utilities.h"
+
+#define EDISON_I2C_BUS 1
+#define FT4222_I2C_BUS 0
+
+#define EDISON_GPIO_SI7005_CS 20
+
+//! [Interesting]
+// Simple example of using iHumiditySensor to determine
+// which sensor is present and return its name.
+// iHumiditySensor is then used to get readings from sensor
+
+upm::iHumiditySensor*
+getHumiditySensor()
+{
+    upm::iHumiditySensor* humiditySensor = NULL;
+
+    try {
+        humiditySensor = new upm::BME280(mraa_get_sub_platform_id(FT4222_I2C_BUS));
+        return humiditySensor;
+    } catch (std::exception& e) {
+        std::cerr << "BME280: " << e.what() << std::endl;
+    }
+
+    try {
+        humiditySensor = new upm::SI7005(EDISON_I2C_BUS, EDISON_GPIO_SI7005_CS);
+        return humiditySensor;
+    } catch (std::exception& e) {
+        std::cerr << "SI7005: " << e.what() << std::endl;
+    }
+    return humiditySensor;
+}
+
+int
+main()
+{
+    upm::iHumiditySensor* sensor = getHumiditySensor();
+
+    if (sensor == NULL) {
+        std::cout << "Humidity sensor not detected" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Humidity sensor " << sensor->Name() << " detected" << std::endl;
+
+    try {
+        std::map<std::string, float> values = sensor->HumidityAll();
+        for (std::map<std::string, float>::const_iterator it = values.begin();
+                it != values.end(); ++it)
+            std::cout << it->first << " = " << it->second
+                << sensor->Unit(it->first) << std::endl;
+    } catch (std::exception& e) {
+        std::cerr << e.what() << std::endl;
+    }
+
+    delete sensor;
+    return 0;
+}
+
+//! [Interesting]

examples/c++/core-lightcontroller.cxx

@@ -0,0 +1,98 @@
+#include <exception>
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+#include "ds1808lc.hpp"
+#include "hlg150h.hpp"
+#include "iLightController.hpp"
+#include "lp8860.hpp"
+
+#define EDISON_I2C_BUS 1  // Edison I2C-1
+#define GPIO_SI7005_CS 20 // Edison GP12
+#define HLG150H_GPIO_RELAY 21
+#define HLG150H_GPIO_PWM 22
+#define LP8860_GPIO_PWR 45         // Edison GP45
+#define DS1808_GPIO_PWR 15         // Edison GP165
+#define DS1808_GPIO_EDISON_LIVE 36 // Edison GP14
+
+//! [Interesting]
+// Simple example of using ILightController to determine
+// which controller is present and return its name.
+// ILightController is then used to get readings from sensor
+
+upm::ILightController*
+getLightController()
+{
+    upm::ILightController* lightController = NULL;
+    try {
+        lightController = new upm::LP8860(LP8860_GPIO_PWR, EDISON_I2C_BUS);
+        return lightController;
+    } catch (std::exception& e) {
+        std::cerr << "LP8860: " << e.what() << std::endl;
+    }
+    try {
+        lightController = new upm::DS1808LC(DS1808_GPIO_PWR, EDISON_I2C_BUS);
+        return lightController;
+    } catch (std::exception& e) {
+        std::cerr << "DS1808LC: " << e.what() << std::endl;
+    }
+    try {
+        lightController = new upm::HLG150H(HLG150H_GPIO_RELAY, HLG150H_GPIO_PWM);
+        return lightController;
+    } catch (std::exception& e) {
+        std::cerr << "HLG150H: " << e.what() << std::endl;
+    }
+    return lightController;
+}
+
+void
+printState(upm::ILightController* lightController)
+{
+    if (lightController->isPowered()) {
+        std::cout << "Light is powered, brightness = " << lightController->getBrightness()
+                  << std::endl;
+    } else {
+        std::cout << "Light is not powered." << std::endl;
+    }
+}
+
+int
+main(int argc, char** argv)
+{
+    int status = 0;
+    // MraaUtils::setGpio(GPIO_SI7005_CS, 1);
+
+    upm::ILightController* lightController = getLightController();
+    if (lightController != NULL) {
+        //std::cout << "Detected light controller " << lightController->getModuleName() << std::endl;
+    } else {
+        std::cerr << "Error. Unsupported platform." << std::endl;
+        return 1;
+    }
+
+    try {
+        std::cout << "Existing state: ";
+        printState(lightController);
+        if (argc == 2) {
+            std::string arg = argv[1];
+            int brightness = ::atoi(argv[1]);
+            if (brightness > 0) {
+                lightController->setPowerOn();
+                lightController->setBrightness(brightness);
+            } else
+                lightController->setPowerOff();
+        }
+        std::cout << "Now: ";
+        printState(lightController);
+    } catch (std::exception& e) {
+        std::cout << "Error: " << e.what() << std::endl;
+        status = 1;
+    }
+
+    delete lightController;
+    return status;
+}
+
+//! [Interesting]

examples/c++/core-lightsensor.cxx

@@ -0,0 +1,88 @@
+/*
+ * Author: Henry Bruce <henry.bruce@intel.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <exception>
+#include <iostream>
+#include <stddef.h>
+
+#include "iLightSensor.hpp"
+#include "max44009.hpp"
+#include "mraa/common.h"
+#include "si1132.hpp"
+#include "upm_utilities.h"
+
+#define EDISON_I2C_BUS 1
+#define FT4222_I2C_BUS 0
+
+//! [Interesting]
+// Simple example of using iLightSensor to determine
+// which sensor is present and return its name.
+// iLightSensor is then used to get readings from sensor
+
+upm::iLightSensor*
+getLightSensor()
+{
+    upm::iLightSensor* lightSensor = NULL;
+    try {
+        lightSensor = new upm::SI1132(mraa_get_sub_platform_id(FT4222_I2C_BUS));
+        return lightSensor;
+    } catch (std::exception& e) {
+        std::cerr << "SI1132: " << e.what() << std::endl;
+    }
+    try {
+        lightSensor = new upm::MAX44009(EDISON_I2C_BUS);
+        return lightSensor;
+    } catch (std::exception& e) {
+        std::cerr << "MAX44009: " << e.what() << std::endl;
+    }
+    return lightSensor;
+}
+
+int
+main()
+{
+    upm::iLightSensor* sensor = getLightSensor();
+
+    if (sensor == NULL) {
+        std::cout << "Light sensor not detected" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Light sensor " << sensor->Name() << " detected" << std::endl;
+
+    try {
+        std::map<std::string, float> values = sensor->LightAll();
+        for (std::map<std::string, float>::const_iterator it = values.begin();
+                it != values.end(); ++it)
+            std::cout << it->first << " = " << it->second
+                << sensor->Unit(it->first) << std::endl;
+    } catch (std::exception& e) {
+        std::cerr << e.what() << std::endl;
+    }
+
+    delete sensor;
+    return 0;
+}
+
+//! [Interesting]

examples/c++/core-pressuresensor.cxx

@@ -0,0 +1,89 @@
+/*
+ * Author: Henry Bruce <henry.bruce@intel.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <exception>
+#include <iostream>
+#include <stddef.h>
+
+#include "bme280.hpp"
+#include "bmpx8x.hpp"
+#include "iPressureSensor.hpp"
+#include "mraa/common.h"
+#include "upm_utilities.h"
+
+#define EDISON_I2C_BUS 1
+#define FT4222_I2C_BUS 0
+
+//! [Interesting]
+// Simple example of using iPressureSensor to determine
+// which sensor is present and return its name.
+// iPressureSensor is then used to get readings from sensor
+
+upm::iPressureSensor*
+getPressureSensor()
+{
+    upm::iPressureSensor* pressureSensor = NULL;
+    try {
+        pressureSensor = new upm::BME280(mraa_get_sub_platform_id(FT4222_I2C_BUS));
+        return pressureSensor;
+    } catch (std::exception& e) {
+        std::cerr << "BME280: " << e.what() << std::endl;
+    }
+
+    try {
+        pressureSensor = new upm::BMPX8X(EDISON_I2C_BUS);
+        return pressureSensor;
+    } catch (std::exception& e) {
+        std::cerr << "BMPX8X: " << e.what() << std::endl;
+    }
+    return pressureSensor;
+}
+
+int
+main()
+{
+    upm::iPressureSensor* sensor = getPressureSensor();
+
+    if (sensor == NULL) {
+        std::cout << "Pressure sensor not detected" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Pressure sensor " << sensor->Name() << " detected" << std::endl;
+
+    try {
+        std::map<std::string, float> values = sensor->PressureAll();
+        for (std::map<std::string, float>::const_iterator it = values.begin();
+                it != values.end(); ++it)
+            std::cout << it->first << " = " << it->second
+                << sensor->Unit(it->first) << std::endl;
+    } catch (std::exception& e) {
+        std::cerr << e.what() << std::endl;
+    }
+
+    delete sensor;
+    return 0;
+}
+
+//! [Interesting]

examples/c++/core-temperaturesensor.cxx

@@ -0,0 +1,99 @@
+/*
+ * Author: Henry Bruce <henry.bruce@intel.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <exception>
+#include <iostream>
+#include <stddef.h>
+
+#include "bme280.hpp"
+#include "bmpx8x.hpp"
+#include "iTemperatureSensor.hpp"
+#include "mraa/common.h"
+#include "si7005.hpp"
+#include "upm_utilities.h"
+
+#define EDISON_I2C_BUS 1
+#define FT4222_I2C_BUS 0
+
+#define EDISON_GPIO_SI7005_CS 20
+
+//! [Interesting]
+// Simple example of using iTemperatureSensor to determine
+// which sensor is present and return its name.
+// iTemperatureSensor is then used to get readings from sensor
+
+upm::iTemperatureSensor*
+getTemperatureSensor()
+{
+    upm::iTemperatureSensor* temperatureSensor = NULL;
+
+    try {
+        temperatureSensor = new upm::BME280(mraa_get_sub_platform_id(FT4222_I2C_BUS));
+        return temperatureSensor;
+    } catch (std::exception& e) {
+        std::cerr << "BME280: " << e.what() << std::endl;
+    }
+
+    try {
+        temperatureSensor = new upm::SI7005(EDISON_I2C_BUS, EDISON_GPIO_SI7005_CS);
+        return temperatureSensor;
+    } catch (std::exception& e) {
+        std::cerr << "SI7005: " << e.what() << std::endl;
+    }
+    try {
+        temperatureSensor = new upm::BMPX8X(EDISON_I2C_BUS);
+        return temperatureSensor;
+    } catch (std::exception& e) {
+        std::cerr << "BMPX8X: " << e.what() << std::endl;
+    }
+    return temperatureSensor;
+}
+
+int
+main()
+{
+    upm::iTemperatureSensor* sensor = getTemperatureSensor();
+
+    if (sensor == NULL) {
+        std::cout << "Temperature sensor not detected" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Temperature sensor " << sensor->Name() << " detected" << std::endl;
+
+    try {
+        std::map<std::string, float> values = sensor->TemperatureAll();
+        for (std::map<std::string, float>::const_iterator it = values.begin();
+                it != values.end(); ++it)
+            std::cout << it->first << " = " << it->second
+                << sensor->Unit(it->first) << std::endl;
+    } catch (std::exception& e) {
+        std::cerr << e.what() << std::endl;
+    }
+
+    delete sensor;
+    return 0;
+}
+
+//! [Interesting]

examples/c++/ds1808lc.cxx

@@ -8,7 +8,7 @@
 #define DS1808_GPIO_PWR 15 // Edison GP165
 
 void
-printState(upm::DS1808LC& lightController)
+printState(upm::ILightController& lightController)
 {
     if (lightController.isPowered()) {
         std::cout << "Light is powered, brightness = " << lightController.getBrightness()

examples/c++/grove-grovebutton.cxx

@@ -0,0 +1,50 @@
+/*
+ * Author: Sarah Knepper <sarah.knepper@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include "grovebutton.hpp"
+#include "upm_utilities.h"
+
+int
+main(int argc, char** argv)
+{
+    // This example uses GPIO 0
+    //! [Interesting]
+
+    // Create the button object using GPIO pin 0
+    upm::GroveButton button(0);
+
+    // Read the input and print, waiting one second between readings
+    while (1) {
+        std::cout << button.name() << " value is " << button.value() << std::endl;
+        upm_delay(1);
+    }
+
+    // Delete the button object
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grove-groveled-multi.cxx

@@ -0,0 +1,68 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014-2015 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "groveled.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+
+    // Instantiate a grove LED on D2.  Here we are controlling a Grove
+    // Multi-color flash LED.  We just just need to turn it on - it will
+    // then cycle through various colors (red, green, blue, purple) on it's
+    // own until turned off.
+    upm::GroveLed led(2);
+
+    // start the light show
+    led.on();
+
+    // just upm_delay until interrupted
+    while (shouldRun)
+        upm_delay(1);
+
+    //! [Interesting]
+
+    led.off();
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grove-groveled.cxx

@@ -0,0 +1,56 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Contributions: Sarah Knepper <sarah.knepper@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include "groveled.hpp"
+#include "upm_utilities.h"
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+
+    // Create the Grove LED object using GPIO pin 2
+    upm::GroveLed led(2);
+
+    // Print the name
+    std::cout << led.name() << std::endl;
+
+    // Turn the LED on and off 10 times, pausing one second
+    // between transitions
+    for (int i = 0; i < 10; i++) {
+        led.on();
+        upm_delay(1);
+        led.off();
+        upm_delay(1);
+    }
+
+    // Delete the Grove LED object
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grove-grovelight.cxx

@@ -0,0 +1,50 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Contributions: Sarah Knepper <sarah.knepper@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include "grovelight.hpp"
+#include "upm_utilities.h"
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+    // Create the light sensor object using AIO pin 0
+    upm::GroveLight light(0);
+
+    // Read the input and print both the raw value and a rough lux value,
+    // waiting one second between readings
+    while (1) {
+        std::cout << light.name() << " raw value is " << light.raw_value() << ", which is roughly "
+                  << light.value() << " lux" << std::endl;
+        upm_delay(1);
+    }
+
+    // Delete the light sensor object
+    //! [Interesting]
+    return 0;
+}

examples/c++/grove-groverelay.cxx

@@ -0,0 +1,59 @@
+/*
+ * Author: Sarah Knepper <sarah.knepper@intel.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include "groverelay.hpp"
+#include "upm_utilities.h"
+
+int
+main(int argc, char** argv)
+{
+    // This example uses GPIO 0
+    //! [Interesting]
+
+    // Create the relay switch object using GPIO pin 0
+    upm::GroveRelay relay(0);
+
+    // Close and then open the relay switch 3 times,
+    // waiting one second each time.  The LED on the relay switch
+    // will light up when the switch is on (closed).
+    // The switch will also make a noise between transitions.
+    for (int i = 0; i < 3; i++) {
+        relay.on();
+        if (relay.isOn())
+            std::cout << relay.name() << " is on" << std::endl;
+        upm_delay(1);
+        relay.off();
+        if (relay.isOff())
+            std::cout << relay.name() << " is off" << std::endl;
+        upm_delay(1);
+    }
+
+    // Delete the relay switch object
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grove-groverotary.cxx

@@ -0,0 +1,67 @@
+/*
+ * Author: Mihai Tudor Panu <mihai.tudor.panu@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+
+#include "groverotary.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int
+main()
+{
+    //! [Interesting]
+    // Instantiate a rotary sensor on analog pin A0
+    upm::GroveRotary knob(0);
+
+    // Print sensor name to confirm it initialized properly
+    cout << knob.name() << endl;
+
+    while (true) {
+        float abs_value = knob.abs_value(); // Absolute raw value
+        float abs_deg = knob.abs_deg();     // Absolute degrees
+        float abs_rad = knob.abs_rad();     // Absolute radians
+        float rel_value = knob.rel_value(); // Relative raw value
+        float rel_deg = knob.rel_deg();     // Relative degrees
+        float rel_rad = knob.rel_rad();     // Relative radians
+
+        fprintf(stdout,
+                "Absolute: %4d raw %5.2f deg = %3.2f rad Relative: %4d raw %5.2f "
+                "deg %3.2f rad\n",
+                (int16_t) abs_value,
+                abs_deg,
+                abs_rad,
+                (int16_t) rel_value,
+                rel_deg,
+                rel_rad);
+
+        upm_delay_us(2500000); // Sleep for 2.5s
+    }
+    //! [Interesting]
+    return 0;
+}

examples/c++/grove-groveslide.cxx

@@ -0,0 +1,52 @@
+/*
+ * Author: Mihai Tudor Panu <mihai.tudor.panu@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+
+#include "groveslide.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int
+main()
+{
+    //! [Interesting]
+    upm::GroveSlide slide(0);
+
+    cout << slide.name() << endl;
+
+    while (true) {
+        float adc_value = slide.raw_value(); // Read raw value
+        float volts = slide.voltage_value(); // Read voltage, board reference set at 5.0V
+        fprintf(stdout, "%4d = %.2f V\n", (uint16_t) adc_value, volts);
+
+        upm_delay_us(2500000); // Sleep for 2.5s
+    }
+    //! [Interesting]
+    return 0;
+}

examples/c++/grove-grovetemp.cxx

@@ -0,0 +1,55 @@
+/*
+ * Author: Brendan Le Foll <brendan.le.foll@intel.com>
+ * Contributions: Sarah Knepper <sarah.knepper@intel.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <stdio.h>
+#include <string>
+
+#include "grovetemp.hpp"
+#include "upm_utilities.h"
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+
+    // Create the temperature sensor object using AIO pin 0
+    upm::GroveTemp temp(0);
+    std::cout << temp.name() << std::endl;
+
+    // Read the temperature ten times, printing both the Celsius and
+    // equivalent Fahrenheit temperature, waiting one second between readings
+    for (int i = 0; i < 10; i++) {
+        int celsius = temp.value();
+        int fahrenheit = (int) (celsius * 9.0 / 5.0 + 32.0);
+        printf("%d degrees Celsius, or %d degrees Fahrenheit\n", celsius, fahrenheit);
+        upm_delay(1);
+    }
+
+    // Delete the temperature sensor object
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grovecollision.cxx

@@ -0,0 +1,66 @@
+/*
+* Author: Zion Orent <zorent@ics.com>
+* Copyright (c) 2015 Intel Corporation.
+*
+* 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 <iostream>
+#include <signal.h>
+
+#include "grovecollision.hpp"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the Grove Collision Sensor
+    // Instantiate a Grove Collision on digital pin D2
+    upm::GroveCollision collision(2);
+
+    bool collisionState = false;
+    cout << "No collision" << endl;
+    while (shouldRun) {
+        if (collision.isColliding() && !collisionState) {
+            cout << "Collision!" << endl;
+            collisionState = true;
+        } else if (collisionState) {
+            cout << "No collision" << endl;
+            collisionState = false;
+        }
+    }
+
+    //! [Interesting]
+    cout << "Exiting" << endl;
+
+    return 0;
+}

examples/c++/groveehr.cxx

@@ -0,0 +1,78 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "groveehr.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Ear-clip Heart Rate sensor on digital pin D2
+    upm::GroveEHR heart(2);
+
+    // set the beat counter to 0, init the clock and start counting beats
+    heart.clearBeatCounter();
+    heart.initClock();
+    heart.startBeatCounter();
+
+    while (shouldRun) {
+        // we grab these just for display purposes in this example
+        uint32_t millis = heart.getMillis();
+        uint32_t beats = heart.beatCounter();
+
+        // heartRate() requires that at least 5 seconds pass before
+        // returning anything other than 0
+        int hr = heart.heartRate();
+
+        // output milliseconds passed, beat count, and computed heart rate
+        cout << "Millis: " << millis << " Beats: " << beats;
+        cout << " Heart Rate: " << hr << endl;
+
+        upm_delay(1);
+    }
+
+    heart.stopBeatCounter();
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/groveeldriver.cxx

@@ -0,0 +1,67 @@
+/*
+* Author: Zion Orent <zorent@ics.com>
+* Copyright (c) 2015 Intel Corporation.
+*
+* 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 <iostream>
+#include <signal.h>
+
+#include "groveeldriver.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the Grove El Driver Module
+    // Instantiate a Grove El Driver on digital pin D2
+    upm::GroveElDriver eldriver(2);
+
+    bool lightState = true;
+
+    while (shouldRun) {
+        if (lightState)
+            eldriver.on();
+        else
+            eldriver.off();
+        lightState = !lightState;
+        upm_delay(1);
+    }
+
+    //! [Interesting]
+    eldriver.off();
+    cout << "Exiting" << endl;
+
+    return 0;
+}

examples/c++/groveelectromagnet.cxx

@@ -0,0 +1,81 @@
+/*
+* Author: Zion Orent <zorent@ics.com>
+* Copyright (c) 2015 Intel Corporation.
+*
+* 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 <iostream>
+#include <signal.h>
+#include <sys/time.h>
+#include <time.h>
+
+#include "groveelectromagnet.hpp"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+float
+get_time()
+{
+    return ((float) (clock())) / CLOCKS_PER_SEC;
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the Grove Electromagnetic Module
+    // Instantiate a Grove Electromagnet on digital pin D2
+    upm::GroveElectromagnet magnet(2);
+    cout << "Starting up magnet...." << endl;
+    magnet.off();
+
+    bool magnetState = false;
+    float time_passed = get_time();
+
+    // Turn magnet on and off every 5 seconds
+    while (shouldRun) {
+        if ((get_time() - time_passed) > 5.0) {
+            magnetState = !magnetState;
+            if (magnetState)
+                magnet.on();
+            else
+                magnet.off();
+            cout << "Turning magnet " << ((magnetState) ? "on" : "off") << endl;
+            time_passed = get_time();
+        }
+    }
+
+    //! [Interesting]
+    magnet.off();
+    cout << "Exiting" << endl;
+
+    return 0;
+}

examples/c++/groveemg.cxx

@@ -0,0 +1,61 @@
+/*
+* Author: Zion Orent <zorent@ics.com>
+* Copyright (c) 2015 Intel Corporation.
+*
+* 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 <iostream>
+#include <signal.h>
+
+#include "groveemg.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the GroveEMG Muscle Signal Reader Sensor Module
+    // Instantiate a GroveEMG on analog pin A0
+    upm::GroveEMG emg(0);
+    cout << "Calibrating...." << endl;
+    emg.calibrate();
+
+    while (shouldRun) {
+        cout << emg.value() << endl;
+        upm_delay_us(100000);
+    }
+
+    //! [Interesting]
+    cout << "Exiting" << endl;
+    return 0;
+}

examples/c++/grovegprs.cxx

@@ -0,0 +1,102 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <iostream>
+
+#include "grovegprs.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+using namespace upm;
+
+void
+printUsage(char* progname)
+{
+    cout << "Usage: " << progname << " [AT command]" << endl;
+    cout << endl;
+
+    cout << "If an argument is supplied on the command line, that argument is" << endl;
+    cout << "sent to the module and the response is printed out." << endl;
+    cout << endl;
+    cout << "If no argument is used, then the manufacturer and the current" << endl;
+    cout << "saved profiles are queried and the results printed out." << endl;
+    cout << endl;
+    cout << endl;
+}
+
+// simple helper function to send a command and wait for a response
+void
+sendCommand(upm::GroveGPRS& sensor, string cmd)
+{
+    // commands need to be terminated with a carriage return
+    cmd += "\r";
+
+    sensor.writeDataStr(cmd);
+
+    // wait up to 1 second
+    if (sensor.dataAvailable(1000)) {
+        cout << "Returned: " << sensor.readDataStr(1024) << endl;
+    } else {
+        cerr << "Timed out waiting for response" << endl;
+    }
+}
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+
+    // Instantiate a GroveGPRS Module on UART 0
+    upm::GroveGPRS sensor(0);
+
+    // Set the baud rate, 19200 baud is the default.
+    if (sensor.setBaudRate(19200) != 0) {
+        cerr << "Failed to set tty baud rate" << endl;
+        return 1;
+    }
+
+    printUsage(argv[0]);
+
+    if (argc > 1) {
+        cout << "Sending command line argument (" << argv[1] << ")..." << endl;
+        sendCommand(sensor, argv[1]);
+    } else {
+        // query the module manufacturer
+        cout << "Querying module manufacturer (AT+CGMI)..." << endl;
+        sendCommand(sensor, "AT+CGMI");
+
+        upm_delay(1);
+
+        // query the saved profiles
+        cout << "Querying the saved profiles (AT&V)..." << endl;
+        sendCommand(sensor, "AT&V");
+
+        // A comprehensive list is available from the datasheet at:
+        // http://www.seeedstudio.com/wiki/images/7/72/AT_Commands_v1.11.pdf
+    }
+
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grovegsr.cxx

@@ -0,0 +1,64 @@
+/*
+ * Author: Zion Orent <zorent@ics.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovegsr.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+bool shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the GroveGSR Galvanic Skin Response Sensor module.
+
+    // Instantiate a GroveGSR on analog pin A0
+    upm::GroveGSR gsr(0);
+    cout << "Calibrating...." << endl;
+    gsr.calibrate();
+
+    while (shouldRun) {
+        cout << gsr.value() << endl;
+        upm_delay_us(500000);
+    }
+    //! [Interesting]
+
+    cout << "Exiting" << endl;
+
+    return 0;
+}

examples/c++/grovelinefinder.cxx

@@ -0,0 +1,66 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovelinefinder.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Line Finder sensor on digital pin D2
+    upm::GroveLineFinder finder(2);
+
+    // check every second for the presence of white detection
+    while (shouldRun) {
+        bool val = finder.whiteDetected();
+        if (val)
+            cout << "White detected." << endl;
+        else
+            cout << "Black detected." << endl;
+
+        upm_delay(1);
+    }
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grovemd-stepper.cxx

@@ -0,0 +1,65 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <iostream>
+
+#include "grovemd.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+    // Instantiate an I2C Grove Motor Driver on I2C bus 0
+
+    upm::GroveMD motors(GROVEMD_I2C_BUS, GROVEMD_DEFAULT_I2C_ADDR);
+
+    // This example demonstrates using the GroveMD to drive a stepper motor
+
+    // configure it, for this example, we'll assume 200 steps per rev
+    motors.configStepper(200);
+
+    // set for half a rotation
+    motors.setStepperSteps(100);
+
+    // let it go - clockwise rotation, 10 RPM speed
+    motors.enableStepper(upm::GroveMD::STEP_DIR_CW, 10);
+
+    upm_delay(3);
+
+    // Now do it backwards...
+    motors.setStepperSteps(100);
+    motors.enableStepper(upm::GroveMD::STEP_DIR_CCW, 10);
+
+    // now disable
+    motors.disableStepper();
+
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grovemd.cxx

@@ -0,0 +1,59 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+
+#include "grovemd.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+    // Instantiate an I2C Grove Motor Driver on I2C bus 0
+
+    upm::GroveMD motors(GROVEMD_I2C_BUS, GROVEMD_DEFAULT_I2C_ADDR);
+
+    // set direction to CW and set speed to 50%
+    cout << "Spin M1 and M2 at half speed for 3 seconds" << endl;
+    motors.setMotorDirections(upm::GroveMD::DIR_CW, upm::GroveMD::DIR_CW);
+    motors.setMotorSpeeds(127, 127);
+
+    upm_delay(3);
+    // counter clockwise
+    cout << "Reversing M1 and M2 for 3 seconds" << endl;
+    motors.setMotorDirections(upm::GroveMD::DIR_CCW, upm::GroveMD::DIR_CCW);
+    upm_delay(3);
+
+    //! [Interesting]
+
+    cout << "Stopping motors" << endl;
+    motors.setMotorSpeeds(0, 0);
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grovemoisture.cxx

@@ -0,0 +1,75 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovemoisture.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Moisture sensor on analog pin A0
+    upm::GroveMoisture moisture(0);
+
+    // Values (approximate):
+    // 0-300, sensor in air or dry soil
+    // 300-600, sensor in humid soil
+    // 600+, sensor in wet soil or submerged in water.
+    // Read the value every second and print the corresponding moisture level
+    while (shouldRun) {
+        int val = moisture.value();
+        cout << "Moisture value: " << val << ", ";
+        if (val >= 0 && val < 300)
+            cout << "dry";
+        else if (val >= 300 && val < 600)
+            cout << "moist";
+        else
+            cout << "wet";
+
+        cout << endl;
+
+        upm_delay(1);
+    }
+    //! [Interesting]
+
+    cout << "Exiting" << endl;
+
+    return 0;
+}

examples/c++/groveo2.cxx

@@ -0,0 +1,58 @@
+/*
+* Author: Zion Orent <zorent@ics.com>
+* Copyright (c) 2015 Intel Corporation.
+*
+* 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 <iostream>
+#include <signal.h>
+
+#include "groveo2.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // The was tested with the O2 Oxygen Concentration Sensor Module
+    // Instantiate a GroveO2 on analog pin A0
+    upm::GroveO2 O2(0);
+    while (shouldRun) {
+        cout << "The output voltage is: " << O2.voltageValue() << "mV" << endl;
+        upm_delay_us(100000);
+    }
+
+    //! [Interesting]
+    cout << "Exiting" << endl;
+    return 0;
+}

examples/c++/grovescam.cxx

@@ -0,0 +1,73 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2015 Intel Corporation.
+ *
+ * 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 <iostream>
+
+#include "grovescam.hpp"
+
+using namespace std;
+using namespace upm;
+
+int
+main(int argc, char** argv)
+{
+    //! [Interesting]
+
+    // Instantiate a Grove Serial Camera on UART 0
+    upm::GROVESCAM camera(0);
+
+    // make sure port is initialized properly.  115200 baud is the default.
+    if (!camera.setupTty()) {
+        cerr << "Failed to setup tty port parameters" << endl;
+        return 1;
+    }
+
+    if (camera.init())
+        cout << "Initialized..." << endl;
+    else
+        cout << "init() failed" << endl;
+
+    if (camera.preCapture())
+        cout << "preCapture succeeded..." << endl;
+    else
+        cout << "preCapture failed." << endl;
+
+    if (camera.doCapture())
+        cout << "doCapture succeeded..." << endl;
+    else
+        cout << "doCapture failed." << endl;
+
+    cout << "Image size is " << camera.getImageSize() << " bytes" << endl;
+
+    if (camera.getImageSize() > 0) {
+        cout << "Storing image.jpg..." << endl;
+        if (camera.storeImage("image.jpg"))
+            cout << "storeImage succeeded..." << endl;
+        else
+            cout << "storeImage failed." << endl;
+    }
+    //! [Interesting]
+
+    return 0;
+}

examples/c++/grovespeaker.cxx

@@ -1,6 +1,6 @@
 /*
- * Author: Mihai Stefanescu <mihai.stefanescu@rinftech.com>
+ * Author: Jon Trulson <jtrulson@ics.com>
- * Copyright (c) 2018 Intel Corporation.
+ * Copyright (c) 2014 Intel Corporation.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -22,26 +22,27 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#pragma once
+#include <iostream>
 
-namespace upm
+#include "grovespeaker.hpp"
+
+using namespace std;
+
+int
+main()
 {
-/**
+    //! [Interesting]
- * @brief Interface for Electromagnet modules
+    // Instantiate a Grove Speaker on digital pin D2
-*/
+    upm::GroveSpeaker speaker(2);
-  class iElectromagnet
-  {
-  public:
-    virtual ~iElectromagnet() {}
 
-    /**
+    // Play all 7 of the lowest notes
-     * Turns the magnet on
+    speaker.playAll();
-     */
-     virtual void on() = 0;
-    /**
-     * Turns the magnet off
-     */
-     virtual void off() = 0;
 
-  };
+    // Play a medium C-sharp
+    speaker.playSound('c', true, "med");
+    //! [Interesting]
+
+    cout << "Exiting" << endl;
+
+    return 0;
 }

examples/c++/groveultrasonic.cxx

@@ -0,0 +1,59 @@
+/*
+ * Author: Jun Kato <i@junkato.jp>
+ * Copyright (c) 2015 Jun Kato.
+ *
+ * Thanks to Seeed Studio for a working arduino sketch
+ *
+ * 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 <signal.h>
+#include <stdio.h>
+
+#include "groveultrasonic.hpp"
+#include "upm_utilities.h"
+
+bool running = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT) {
+        running = false;
+    }
+}
+
+int
+main(int argc, char** argv)
+{
+    signal(SIGINT, sig_handler);
+    //! [Interesting]
+    // upm::GroveUltraSonic *sonar = NULL;
+    upm::GroveUltraSonic sonar(2);
+    while (running) {
+        int width = sonar.getDistance();
+        printf("Echo width = %d\n", width);
+        printf("Distance inches = %f.2\n\n", width / 148.0);
+        upm_delay(3);
+    }
+    //! [Interesting]
+    printf("exiting application\n");
+    return 0;
+}

examples/c++/grovevdiv.cxx

@@ -0,0 +1,67 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovevdiv.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+bool shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Voltage Divider sensor on analog pin A0
+    upm::GroveVDiv vDiv(0);
+
+    // collect data and output measured voltage according to the setting
+    // of the scaling switch (3 or 10)
+    while (shouldRun) {
+        unsigned int val = vDiv.value(100);
+        float gain3val = vDiv.computedValue(3, val);
+        float gain10val = vDiv.computedValue(10, val);
+        cout << "ADC value: " << val << " Gain 3: " << gain3val << "v Gain 10: " << gain10val << "v"
+             << endl;
+
+        upm_delay(1);
+    }
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grovewater.cxx

@@ -0,0 +1,65 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovewater.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Water sensor on digital pin D2
+    upm::GroveWater water(2);
+
+    while (shouldRun) {
+        bool val = water.isWet();
+        if (val)
+            cout << "Sensor is wet." << endl;
+        else
+            cout << "Sensor is dry." << endl;
+
+        upm_delay(1);
+    }
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/grovewfs.cxx

@@ -0,0 +1,78 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2014 Intel Corporation.
+ *
+ * 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 <iostream>
+#include <signal.h>
+
+#include "grovewfs.hpp"
+#include "upm_utilities.h"
+
+using namespace std;
+
+int shouldRun = true;
+
+void
+sig_handler(int signo)
+{
+    if (signo == SIGINT)
+        shouldRun = false;
+}
+
+int
+main()
+{
+    signal(SIGINT, sig_handler);
+
+    //! [Interesting]
+    // Instantiate a Grove Water Flow Sensor on digital pin D2
+    upm::GroveWFS flow(2);
+
+    // set the flow counter to 0 and start counting
+    flow.clearFlowCounter();
+    flow.startFlowCounter();
+
+    while (shouldRun) {
+        // we grab these (,illis and flowCount) just for display
+        // purposes in this example
+        uint32_t millis = flow.getMillis();
+        uint32_t flowCount = flow.flowCounter();
+
+        float fr = flow.flowRate();
+
+        // output milliseconds passed, flow count, and computed flow rate
+        cout << "Millis: " << millis << " Flow Count: " << flowCount;
+        cout << " Flow Rate: " << fr << " LPM" << endl;
+
+        // best to gather data for at least one second for reasonable
+        // results.
+        upm_delay(2);
+    }
+
+    flow.stopFlowCounter();
+    //! [Interesting]
+
+    cout << "Exiting..." << endl;
+
+    return 0;
+}

examples/c++/hlg150h.cxx

@@ -3,12 +3,13 @@
 #include <string>
 
 #include "hlg150h.hpp"
+#include "iLightController.hpp"
 
 #define HLG150H_GPIO_RELAY 21
 #define HLG150H_GPIO_PWM 22
 
 void
-printState(upm::HLG150H& lightController)
+printState(upm::ILightController& lightController)
 {
     if (lightController.isPowered()) {
         std::cout << "Light is powered, brightness = " << lightController.getBrightness()

examples/c++/iLight-sample.cxx

@@ -1,28 +0,0 @@
-#include <iostream>
-#include <list>
-
-#include "apds9002.hpp"
-#include "bh1750.hpp"
-#include "max44009.hpp"
-
-int
-main()
-{
-    std::list<upm::iLight*> lightSensors;
-
-    // Populate list of light sensors
-    lightSensors.push_back(new upm::APDS9002(0));
-    lightSensors.push_back(new upm::BH1750());
-    lightSensors.push_back(new upm::MAX44009(1));
-
-    // Measure luminance level from all 3 individual sensors
-    for (auto& sensor : lightSensors) {
-        sensor->getLuminance();
-    }
-
-    for (auto& sensor : lightSensors) {
-        delete sensor;
-    }
-
-    return 0;
-}

examples/c++/iTemperature-sample.cxx

@@ -1,26 +0,0 @@
-#include <iostream>
-#include <vector>
-
-#include "abp.hpp"
-#include "lm35.hpp"
-
-int
-main()
-{
-    std::vector<upm::iTemperature*> tempSensors{ new upm::LM35(0),
-                                                 new upm::ABP(0, ABP_DEFAULT_ADDRESS) };
-
-    for (auto& sensor : tempSensors) {
-        float celsiusTemp = sensor->getTemperature();
-        std::cout << "Temperature in Celsius degrees: " << celsiusTemp << std::endl;
-        std::cout << "Temperature in Kelvin: "
-                  << upm::iTemperature::convertCelsiusTo(celsiusTemp, upm::TemperatureUnit::KELVIN)
-                  << std::endl;
-    }
-
-    for (auto& sensor : tempSensors) {
-        delete sensor;
-    }
-
-    return 0;
-}

examples/c++/ims.cxx

@@ -47,7 +47,7 @@ main(int argc, char** argv)
     //! [Interesting]
 
     // Instantiate a IMS instance using i2c bus 0 and default address
-    upm::IMS sensor(0);
+    upm::IMS sensor("i:0:0x20");
 
     int i2c_addr_cur = IMS_ADDRESS_DEFAULT + 1;
     while (shouldRun) {

examples/c++/kxtj3.cxx

@@ -1,73 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <iostream>
-#include <iomanip>
-#include <unistd.h>
-#include <signal.h>
-#include "kxtj3.hpp"
-#include "upm_utilities.h"
-
-#define SENSOR_ADDR 0x0f
-#define I2C_BUS 0
-#define SAMPLE_COUNT 10
-
-bool isStopped = false;
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-void print_acceleration_data(upm::KXTJ3 &dev)
-{
-    float wait_time = dev.GetAccelerationSamplePeriod() * SECOND_IN_MICRO_S;
-    int sample_counter = SAMPLE_COUNT;
-    std::vector<float> xyz;
-    while ((sample_counter-- > 0) && !isStopped)
-    {
-        xyz = dev.GetAccelerationVector();
-        std::cout << std::fixed << std::setprecision(3)
-                  << xyz[0] << " | " << xyz[1] << " | " << xyz[2] << std::endl;
-        upm_delay_us(wait_time);
-    }
-}
-
-int main(int argc, char **argv)
-{
-    signal(SIGINT, signal_int_handler);
-
-    std::cout << "Sensor init" << std::endl;
-    upm::KXTJ3 dev(I2C_BUS, SENSOR_ADDR);
-
-    std::cout << "Setting settings:\nODR: 25 Hz\nResolution: "
-              << "High\nAcceleration range: 16g with 14bits" << std::endl;
-    dev.SensorInit(KXTJ3_ODR_25, HIGH_RES, KXTJ3_RANGE_16G_14);
-    std::cout << "Showing acceleration data:" << std::endl;
-    print_acceleration_data(dev);
-
-    std::cout << "Closing sensor" << std::endl;
-    return 0;
-}

examples/c++/lm35.cxx

@@ -48,12 +48,12 @@ main()
 
     // Instantiate a LM35 on analog pin A0, with a default analog
     // reference voltage of 5.0
-    upm::iTemperature* sensor = new upm::LM35(0);
+    upm::LM35 sensor(0);
 
     // Every half second, sample the sensor and output the temperature
 
     while (shouldRun) {
-        cout << "Temperature: " << sensor->getTemperature() << " C" << endl;
+        cout << "Temperature: " << sensor.getTemperature() << " C" << endl;
 
         upm_delay_us(500000);
     }
@@ -61,7 +61,6 @@ main()
     //! [Interesting]
 
     cout << "Exiting" << endl;
-    delete sensor;
 
     return 0;
 }

examples/c++/lp8860.cxx

@@ -2,13 +2,14 @@
 #include <stdlib.h>
 #include <string>
 
+#include "iLightController.hpp"
 #include "lp8860.hpp"
 
 #define EDISON_I2C_BUS 1   // Edison I2C-1
 #define LP8860_GPIO_PWR 45 // Edison GP45
 
 void
-printState(upm::LP8860& lightController)
+printState(upm::ILightController& lightController)
 {
     if (lightController.isPowered()) {
         std::cout << "Light is powered, brightness = " << lightController.getBrightness()

examples/c++/noelstemplightreader.cxx

@@ -0,0 +1,49 @@
+#include <iostream>
+#include <unistd.h>
+
+#include "core/iUpmObject.hpp"
+#include "noelstemplightreader.hpp"
+
+void printMap(upm::NoelsTempLightReader &sensor, std::map<std::string, float> &data)
+{
+    if (data.empty())
+        std::cout << "Empty map" << std::endl;
+    for (std::map<std::string, float>::const_iterator it = data.begin();
+            it != data.end(); ++it)
+    {
+        std::cout << "label: " << it->first << ", value: " << it->second
+            << ", unit: " << sensor.Unit(it->first) << std::endl;
+    }
+    std::cout << std::endl;
+}
+
+int main ()
+{
+    upm::NoelsTempLightReader sensor;
+    std::cout << "iUpmObject JsonDefinition..." << std::endl << ((upm::iUpmObject&)sensor).JsonDefinition() << std::endl << std::endl;
+    std::cout << "iSensorType JsonDefinition..." << std::endl << ((upm::iSensorType&)sensor).JsonDefinition() << std::endl << std::endl;
+    std::cout << "iMraa JsonDefinition..." << std::endl << ((upm::iMraa&)sensor).JsonDefinition() << std::endl << std::endl;
+    std::cout << "NoelsTempLightReader JsonDefinition..." << std::endl << sensor.JsonDefinition() << std::endl << std::endl;
+
+    std::cout << "Read all light values..." << std::endl;
+    std::map<std::string, float> values = sensor.LightAll();
+    printMap(sensor, values);
+
+    std::cout << "Read a single light value for light0..." << std::endl;
+    std::cout << "Single value = " << sensor.LightForSource("light0") << std::endl << std::endl;
+
+    try
+    {
+        std::cout << "Read a single light value for lightX (doesn't exist)..." << std::endl;
+        sensor.LightForSource("lightX");
+    }
+    catch (const std::exception& e) { std::cout << e.what() << std::endl << std::endl;}
+
+    std::cout << "Read a light value for lightX (doesn't exist)..." << std::endl;
+    values = sensor.LightForSources(std::vector<std::string>({"lightX"}));
+    printMap(sensor, values);
+
+    std::cout << "Read all values as JsonDefinition..." << std::endl << sensor.JsonValues() << std::endl;
+
+    return 0;
+}

examples/c++/servo-es08a.cxx

@@ -31,7 +31,7 @@ int
 main(int argc, char** argv)
 {
     //! [Interesting]
-    upm::ES08A servo(5);
+    upm::ES08A servo("p:5");
 
     // Sets the shaft to 180, then to 90, then to 0,
     // then back to 90, and finally back to 180,

examples/c++/t6713-co2-sensor.cxx

@@ -27,6 +27,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "iCO2Sensor.hpp"
 #include "mraa/common.h"
 #include "t6713.hpp"
 #include "upm_utilities.h"
@@ -39,17 +40,20 @@ int
 main()
 {
     /* Create an instance of the T6713 sensor */
-    upm::T6713 cO2Sensor(EDISON_I2C_BUS);
+    upm::T6713 sensor(EDISON_I2C_BUS);
 
-    // if (cO2Sensor == NULL) {
+    /* Show usage from the iCO2Sensor interface */
-    //     std::cout << "CO2 sensor not detected" << std::endl;
+    upm::iCO2Sensor* cO2Sensor = static_cast<upm::iCO2Sensor*>(&sensor);
-    //     return 1;
+
-    // }
+    if (cO2Sensor == NULL) {
-    std::cout << "CO2 sensor " << cO2Sensor.getModuleName() << " detected" << std::endl;
+        std::cout << "CO2 sensor not detected" << std::endl;
+        return 1;
+    }
+    std::cout << "CO2 sensor " << cO2Sensor->Name() << " detected" << std::endl;
     while (true) {
         try {
-            uint16_t value = cO2Sensor.getPpm();
+            uint16_t value = cO2Sensor->CO2ForSource(cO2Sensor->Sources()[0]);
-            std::cout << "CO2 level = " << value << " ppm" << std::endl;
+            std::cout << "CO2 level = " << value << cO2Sensor->Units()[0] << std::endl;
         } catch (std::exception& e) {
             std::cerr << e.what() << std::endl;
         }

examples/c++/tm1637.cxx

@@ -49,7 +49,7 @@ main(int argc, char** argv)
     int timezone = -7; // Your UTC offset
     time_t rawtime;
     struct tm* gmt;
-    char myTime[15];
+    char myTime[5];
 
     fprintf(stdout, "TM1637 Display Example\n");
     signal(SIGINT, sig_handler);
@@ -66,7 +66,7 @@ main(int argc, char** argv)
         int hour = (gmt) ? gmt->tm_hour : 0;
         int min = (gmt) ? gmt->tm_min : 0;
         // Format and store the time in 24 hour format
-        snprintf(myTime, 15, "%2d%02d", (hour + timezone + 24) % 24, min);
+        snprintf(myTime, 5, "%2d%02d", (hour + timezone + 24) % 24, min);
 
         myDisplay.write(myTime);           // Write to display as string
         myDisplay.setColon(point ^= true); // Toggle the dots on the display

examples/c/bh1749.c

@@ -1,73 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <stdio.h>
-#include <signal.h>
-#include "bh1749.h"
-#include "upm_utilities.h"
-
-bool isStopped;
-#define SENSOR_ADDR 0x39
-#define I2C_BUS 0
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-void print_data(void *dev)
-{
-	uint16_t result[5];
-	bh1749_get_measurements((bh1749_context)dev, result);
-	printf("R: %d, G: %d, B: %d, IR: %d, G2: %d\n", result[0],
-			result[1], result[2], result[3], result[4]);
-	bh1749_reset_interrupt(dev);
-}
-
-int main(int argc, char **argv)
-{
-	signal(SIGINT, signal_int_handler);
-
-	bh1749_context dev = bh1749_init(I2C_BUS, SENSOR_ADDR);
-	if (!dev) {
-        printf("bh1749_init() failed.\n");
-        return -1;
-    }
-
-	bh1749_soft_reset(dev);
-	bh1749_sensor_init(dev, INT_JUDGE_1, MEAS_240MS, RGB_GAIN_1X, IR_GAIN_1X, RED);
-	bh1749_set_threshold_high(dev, 511);
-	bh1749_enable_interrupt(dev);
-	printf("Installing ISR\n");
-	bh1749_install_isr(dev, MRAA_GPIO_EDGE_FALLING, 33, &print_data, (void *)dev);
-	bh1749_enable(dev);
-
-	while(!isStopped) {
-		upm_delay_ms(1000);
-	}
-
-	bh1749_close(dev);
-	return 0;
-}

examples/c/bh1792.c

@@ -1,86 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <stdio.h>
-#include <signal.h>
-#include "bh1792.h"
-#include  <sys/time.h>
-#include "upm_utilities.h"
-
-bool isStopped;
-#define SENSOR_ADDR 0x5b
-#define I2C_BUS 0
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-void print_data(void *args)
-{
-	bh1792_context dev = (bh1792_context)args;
-	uint16_t led_on[32], led_off[32];
-	struct timespec now;
-
-	clock_gettime(CLOCK_MONOTONIC_RAW, &now);
-
-	if(bh1792_get_fifo_data(dev, led_off, led_on) == UPM_SUCCESS) {
-		printf("\nFIFO data:\n");
-		for(int i = 0; i < 32; i++)
-			printf("%d: off: %d, on: %d\n", i, led_off[i], led_on[i]);
-			
-		printf("timestamp %ld sec, %ld nsec\n", now.tv_sec, now.tv_nsec);
-	}
-}
-
-int main(int argc, char **argv)
-{
-	float meas_time;
-
-	signal(SIGINT, signal_int_handler);
-
-	bh1792_context dev = bh1792_init(I2C_BUS, SENSOR_ADDR);
-	if (!dev) {
-        printf("bh1792_init() failed.\n");
-        return -1;
-    }
-
-	printf("Software reset\n");
-	bh1792_soft_reset(dev);
-
-	bh1792_enable_sync_mode(dev, 256, 32);
-	bh1792_install_isr(dev, MRAA_GPIO_EDGE_FALLING, 33, &print_data, dev);
-	bh1792_get_meas_time_ms(dev, &meas_time);
-	bh1792_start_measurement(dev);
-
-	printf("Heart beat sensor data\n");
-
-	while(!isStopped) {
-		usleep(meas_time * 1000);
-	}
-
-	bh1792_close(dev);
-	return 0;
-}

examples/c/bno055.c

@@ -49,7 +49,7 @@ int main(int argc, char **argv)
   // Initialize a BNO055 using default parameters (bus 0, addr
   // 0x28).  The default running mode is NDOF absolute orientation
   // mode.
-  bno055_context sensor = bno055_init(0, BNO055_DEFAULT_ADDR, NULL);
+  bno055_context sensor = bno055_init(0, BNO055_DEFAULT_ADDR);
 
   if (!sensor)
   {

examples/c/jhd1313m1.c

@@ -51,7 +51,7 @@ int main(int argc, char **argv)
     }
 
     int ndx = 0;
-    char str[23];
+    char str[20];
     uint8_t rgb[7][3] = {
         {0xd1, 0x00, 0x00},
         {0xff, 0x66, 0x22},

examples/c/kxtj3.c

@@ -1,75 +0,0 @@
-/*
-* The MIT License (MIT)
-*
-* Author: Assam Boudjelthia
-* Copyright (c) 2018 Rohm Semiconductor.
-*
-* 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 <unistd.h>
-#include <signal.h>
-#include "kxtj3.h"
-
-#define SENSOR_ADDR 0x0f
-#define I2C_BUS 0
-#define SAMPLE_COUNT 10
-
-bool isStopped = false;
-
-void signal_int_handler(int signo)
-{
-    if (signo == SIGINT)
-        isStopped = true;
-}
-
-void print_acceleration_data(kxtj3_context dev)
-{
-    float wait_time = kxtj3_get_acceleration_sampling_period(dev) * SECOND_IN_MICRO_S;
-    uint8_t sample_counter = 0;
-    float x, y, z;
-    while (sample_counter < SAMPLE_COUNT && !isStopped)
-    {
-        kxtj3_get_acceleration_data(dev, &x, &y, &z);
-        printf("%.02f | %.02f | %.02f\n", x, y, z);
-        usleep(wait_time);
-        sample_counter++;
-    }
-}
-
-int main(int argc, char **argv)
-{
-    signal(SIGINT, signal_int_handler);
-
-    printf("Sensor init\n");
-    kxtj3_context dev = kxtj3_init(I2C_BUS, SENSOR_ADDR);
-    if (!dev)
-    {
-        printf("kxtj3_init() failed.\n");
-        return -1;
-    }
-
-    printf("Setting settings:\nODR: 25 Hz\nResolution: High\nAcceleration range: 16g with 14bits");
-    kxtj3_sensor_init(dev, KXTJ3_ODR_25, HIGH_RES, KXTJ3_RANGE_16G_14);
-    printf("Showing acceleration data:\n");
-    print_acceleration_data(dev);
-
-    printf("Closing sensor\n");
-    kxtj3_close(dev);
-    return 0;
-}

examples/java/A110X_intr_Example.java

@@ -24,11 +24,8 @@
 
 public class A110X_intr_Example {
 	
-	private static int counter=0;
+	public static int counter=0;
 		
-    public static void incrementCounter() {
-        counter++;
-    }	
 	public static void main(String[] args) throws InterruptedException {
 		//! [Interesting]
 		// Instantiate an A110X sensor on digital pin D2
@@ -55,6 +52,6 @@ class A110XISR implements Runnable {
 		super();
 	}
 	public void run(){
-		A110X_intr_Example.incrementCounter();
+		A110X_intr_Example.counter++;
 	}
 }