upm: v1.0.1

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

.gitignore

@@ -1,4 +1,4 @@
-build/
+build*/
 
 # Object files
 *.o

.travis.yml

@@ -1,38 +1,48 @@
 language: cpp
 env:
-  - CC=gcc CXX=gcc
-  - CC=clang CXX=clang++
-  - NODE4=true
-  - NODE5=true
-  - NODE012=true
+  global:
+    - MRAA_ROOT=/tmp/mraa
+    - MRAA_BUILD=$MRAA_ROOT/build
+    - UPM_ROOT=$TRAVIS_BUILD_DIR
+    - UPM_BUILD=$UPM_ROOT/build
+    - JAVA_HOME=/usr/lib/jvm/java-8-oracle
+  matrix:
+    - NODE010=true
+    - NODE012=true
+    - NODE4=true
+    - NODE5=true
+compiler:
+  - clang
+  - gcc
 install:
-  - sudo add-apt-repository --yes ppa:fenics-packages/fenics-exp/swig
+  - sudo add-apt-repository --yes ppa:fenics-packages/fenics-dev/swig
   - sudo apt-get update -qq
-  - sudo apt-get install -y -qq swig3.0 git
+  - sudo apt-get install -y --force-yes -qq swig3.0 git
   - sudo ln -s /usr/bin/swig3.0 /usr/bin/swig
   - sudo update-java-alternatives -s java-8-oracle
 before_script:
-  - export NODE_ROOT_DIR="/home/travis/.nvm/v0.10.36"
-  - if [ "$CC" = "gcc" ]; then export BUILDJAVA=ON; else export BUILDJAVA=OFF; fi
-  - export JAVA_HOME=/usr/lib/jvm/java-8-oracle
-  - if [ "${NODE4}" ]; then nvm install 4.1; export CC=gcc-4.8; export CXX=g++-4.8; export NODE_ROOT_DIR="/home/travis/.nvm/versions/node/`nvm version`"; fi
-  - if [ "${NODE5}" ]; then nvm install 5; export CC=gcc-4.8; export CXX=g++-4.8; export NODE_ROOT_DIR="/home/travis/.nvm/versions/node/`nvm version`"; fi
-  - if [ "${NODE012}" ]; then nvm install 0.12; export NODE_ROOT_DIR="/home/travis/.nvm/versions/node/`nvm version`"; fi
+  # Turn off JAVA SWIG for clang++, use 4.8 for all g++ builds
+  - if [ "$CC" == "gcc" ]; then export BUILDJAVA=ON; export CC=gcc-4.8; export CXX=g++-4.8; else export BUILDJAVA=OFF; fi
+  - if [ "${NODE012}" ]; then nvm install 0.12; fi
+  - if [ "${NODE4}" ]; then nvm install 4.1; fi
+  - if [ "${NODE5}" ]; then nvm install 5; fi
+  # Handle 0.10 NODE_ROOT_DIR differently than other versions
+  - if [ -z ${NODE010} ]; then export NODE_ROOT_DIR="/home/travis/.nvm/versions/node/`nvm version`"; else export NODE_ROOT_DIR=/home/travis/.nvm/v0.10.36; fi
 script:
-  - git clone https://github.com/intel-iot-devkit/mraa.git
-  - cd mraa && mkdir build && cd build && cmake -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDSWIGNODE=OFF -DBUILDSWIGPYTHON=OFF -DFIRMATA=ON -DENABLEEXAMPLES=OFF -DCMAKE_INSTALL_PREFIX:PATH=. .. && make && make install
-  - export PKG_CONFIG_PATH=$PWD/lib/pkgconfig:$PWD/lib/x86_64-linux-gnu/pkgconfig
-  - export CPLUS_INCLUDE_PATH=$PWD/include
-  - export LIBRARY_PATH=$PWD/lib:$PWD/lib/x86_64-linux-gnu
-  - cd ../.. && mkdir build && cd build && cmake -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDEXAMPLES=ON -DBUILDJAVAEXAMPLES=$BUILDJAVA .. && make
+  # Build/install MRAA
+  - echo "CC=$CC BUILDJAVA=$BUILDJAVA NODE010=$NODE010 NODE012=$NODE012 NODE4=$NODE4 NODE5=$NODE5 NODE_ROOT_DIR=$NODE_ROOT_DIR"
+  - git clone https://github.com/intel-iot-devkit/mraa.git $MRAA_ROOT
+  - mkdir -p $MRAA_BUILD && cd $_ && cmake -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDSWIGNODE=OFF -DBUILDSWIGPYTHON=ON -DFIRMATA=ON -DENABLEEXAMPLES=OFF $MRAA_ROOT
+  - sudo make install
+  - sudo ldconfig
+  # Build/install UPM
+  - cd $UPM_ROOT && mkdir $UPM_BUILD && cd $_ && cmake -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDEXAMPLES=ON -DBUILDJAVAEXAMPLES=$BUILDJAVA -DBUILDTESTS=ON .. && sudo make install && sudo ldconfig && ctest --output-on-failure -E examplenames_js
 addons:
   apt:
     sources:
-      - llvm-toolchain-precise-3.6
       - ubuntu-toolchain-r-test
       - george-edison55-precise-backports
     packages:
-      - clang-3.6
-      - g++-4.8
       - cmake
       - cmake-data
+      - g++-4.8

CMakeLists.txt

@@ -1,20 +1,182 @@
 cmake_minimum_required (VERSION 2.8.11)
 project (upm)
 
+# Before going any further, define build options
+option (BUILDDOC "Build all doc" OFF)
+option (BUILDCPP "Build CPP sensor libraries" ON)
+option (BUILDFTI "Build Funtion Table Interface (FTI) in C sensor libraries" OFF)
+option (BUILDSWIGPYTHON "Build swig python modules" ON)
+option (BUILDSWIGNODE "Build swig node modules" ON)
+option (BUILDSWIGJAVA "Build swig java modules" OFF)
+option (BUILDEXAMPLES "Build C/C++ example binaries" OFF)
+option (BUILDJAVAEXAMPLES "Build java example jars" 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)
+
+# Warn if building in source root
 if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-message("WARNING: building into sources dir can be risky, prefer other directory")
+  message (WARNING "Building into sources dir can be risky, prefer other directory")
 endif ()
 
+# Appends the cmake/modules path to MAKE_MODULE_PATH variable.
+set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
+
+# Check if provided compiler supports target flag
+# usage:
+#       compiler_flag_supported(C/CXX is_supported flag)
+#
+# The result of output_variable is set to the sanitized flag name if supported
+# or cleared if the flag is not supported.
+function (compiler_flag_supported compiler output_variable flag)
+  # Currently only C and CXX compile flags, clear and return if not supported
+  if (NOT ${compiler} MATCHES "C|CXX")
+    message (WARNING "Unknown compiler: ${compiler}")
+    set ("${output_variable}" "" PARENT_SCOPE)
+    return ()
+  endif (NOT ${compiler} MATCHES "C|CXX")
+
+  string (REPLACE "-" "_" SANITIZED_FLAG_NAME "${flag}")
+  string (REPLACE "/" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
+  string (REPLACE "=" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
+  string (REPLACE " " "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
+
+  # Disable messages from CHECK_C/XX_COMPILER_FLAGS macros
+  set (CMAKE_REQUIRED_QUIET_SAVED ${CMAKE_REQUIRED_QUIET})
+  set (CMAKE_REQUIRED_QUIET ON)
+
+  # C or CXX?
+  if (${compiler} STREQUAL C)
+    CHECK_C_COMPILER_FLAG("${flag}" HAS_${SANITIZED_FLAG_NAME})
+  elseif (${compiler} STREQUAL CXX)
+    CHECK_CXX_COMPILER_FLAG("${flag}" HAS_${SANITIZED_FLAG_NAME})
+  endif ()
+
+  # Restore previous CMAKE_REQUIRED_QUIET state
+  set (CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVED})
+
+  # Does the compiler support this flag?
+  if (HAS_${SANITIZED_FLAG_NAME})
+    set ("${output_variable}" "${SANITIZED_FLAG_NAME}" PARENT_SCOPE)
+  else ()
+    set ("${output_variable}" "" PARENT_SCOPE)
+  endif()
+endfunction ()
+
+include (CheckCCompilerFlag)
+include (CheckCXXCompilerFlag)
+# Add scoped compile flag/s using add_compile_options.
+# This function checks to see if each flag is supported
+# by the compiler before setting the compile option.
+function (upm_add_compile_flags compiler)
+  set (_TMP_COMPILER_FLAGS "")
+  # Iterate the flags, check if supported
+  foreach (flag ${ARGN})
+    # Check if this compile flag is supported
+    compiler_flag_supported(${compiler} is_supported ${flag})
+
+    # Add if supported, warn and skip if not supported
+    if (is_supported)
+      set (_TMP_COMPILER_FLAGS "${_TMP_COMPILER_FLAGS} ${flag}")
+    else ()
+      message (WARNING "${compiler} compiler does not support flag \"${flag}\"")
+    endif ()
+  endforeach (flag ${ARGN})
+
+  # Set the variable in the parent scope
+  set (CMAKE_${compiler}_FLAGS "${CMAKE_${compiler}_FLAGS} ${_TMP_COMPILER_FLAGS}" PARENT_SCOPE)
+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)
+
+# Warnings as errors?
+if (WERROR)
+  set (C_CXX_WARNING_FLAGS "-Werror ${C_CXX_WARNING_FLAGS}")
+  message (STATUS "Warnings as errors enabled (-Werror), disable with -DWERROR=off")
+endif (WERROR)
+
+# Set C compiler warning flags at top-level scope and emit a warning about
+# unsupported flags
+upm_add_compile_flags(C ${C_CXX_WARNING_FLAGS}
+  -Winit-self
+  -Wimplicit
+  -Wmissing-parameter-type)
+
+# Set CXX compiler warning flags at top-level scope and emit a warning about
+# unsupported flags
+upm_add_compile_flags(CXX ${C_CXX_WARNING_FLAGS}
+  -Wnon-virtual-dtor
+  -Woverloaded-virtual
+  -Wreorder)
+
 find_package (Threads REQUIRED)
 find_package (PkgConfig REQUIRED)
 
 # Force a libmraa search and minimum required version every time a config is generated
 unset(MRAA_FOUND CACHE)
-pkg_check_modules (MRAA REQUIRED mraa>=0.9.1)
-message (INFO " found mraa version: ${MRAA_VERSION}")
+set(MRAA_MINIMUM 1.1.1)
+pkg_check_modules (MRAA REQUIRED mraa>=${MRAA_MINIMUM})
 
-# Appends the cmake/modules path to MAKE_MODULE_PATH variable.
-set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
+# Check for BACNET
+pkg_check_modules (BACNET libbacnet)
+
+# Check for MODBUS
+pkg_check_modules (MODBUS libmodbus>=3.1.2)
+
+# Check for OPENZWAVE
+pkg_check_modules (OPENZWAVE libopenzwave)
+
+# Find JPEG
+find_package (JPEG)
+
+# Find nodejs
+if (BUILDSWIGNODE)
+  find_package (Node REQUIRED)
+endif (BUILDSWIGNODE)
+
+# Find swig if any wrapper is enabled
+if (BUILDSWIGPYTHON OR BUILDSWIGNODE OR BUILDSWIGJAVA)
+  find_package (SWIG 3.0.5 REQUIRED)
+  include (${SWIG_USE_FILE})
+endif ()
+
+# Python is required for swig generated python and for UPM tests.
+# The UPM build can generated modules for both python2 AND python3
+# with the corresponding PYTHONLIBS.  Currently, BUILDTESTS has a
+# hard dependency on the PYTHON2INTERP.
+# OpenCV python detect will attempt to find python2/3
+if (BUILDSWIGPYTHON OR BUILDTESTS)
+  include (cmake/modules/OpenCVDetectPython.cmake)
+
+  # Fail if building tests but no python interpreter was found
+  if (BUILDTESTS AND NOT PYTHON2INTERP_FOUND)
+      message(FATAL_ERROR "BUILDTESTS=ON requires the python2 interpreter")
+  endif (BUILDTESTS AND NOT PYTHON2INTERP_FOUND)
+
+  # Fail if no LIBS were found
+  if (NOT PYTHON2LIBS_FOUND AND NOT PYTHON3LIBS_FOUND)
+      message(FATAL_ERROR "At least one python lib is required")
+  endif (NOT PYTHON2LIBS_FOUND AND NOT PYTHON3LIBS_FOUND)
+endif (BUILDSWIGPYTHON OR BUILDTESTS)
+
+# Which versions of python were found?
+if (PYTHON2LIBS_FOUND AND BUILDSWIGPYTHON)
+  message(STATUS "Building python2 modules with python-${PYTHON2LIBS_VERSION_STRING}")
+endif (PYTHON2LIBS_FOUND AND BUILDSWIGPYTHON)
+if (PYTHON3LIBS_FOUND AND BUILDSWIGPYTHON)
+  message(STATUS "Building python3 modules with python-${PYTHON3LIBS_VERSION_STRING}")
+endif (PYTHON3LIBS_FOUND AND BUILDSWIGPYTHON)
+
+# Python2 is currently required for python documentation
+if (BUILDSWIGPYTHON AND BUILDDOC AND NOT PYTHON2INTERP_FOUND)
+  message(FATAL_ERROR "Failed to find python2 interpreter which is required "
+      "to build python documentation.")
+endif (BUILDSWIGPYTHON AND BUILDDOC AND NOT PYTHON2INTERP_FOUND)
 
 # Set CMAKE_INSTALL_LIBDIR if not defined
 include(GNUInstallDirs)
@@ -23,12 +185,14 @@ set (LIB_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Installation path for
 # Make a version file containing the current version from git.
 include (GetGitRevisionDescription)
 git_describe (VERSION "--tags")
-if ("x_${VERSION}" STREQUAL "x_GIT-NOTFOUND" OR "x_${VERSION}" STREQUAL "x_-128-NOTFOUND")
-  message (WARNING " - Install git to compile a production UPM!")
-  set (VERSION "v0.6.2-dirty")
+# If git_describe fails, use a dirty version
+if (${VERSION} MATCHES -NOTFOUND)
+  set (VERSION "v1.0.1-dirty")
+  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 ()
 
-message (INFO " - UPM Version ${VERSION}")
+message (STATUS "UPM Version ${VERSION}")
 
 # Parse the version information into pieces.
 string (REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${VERSION}")
@@ -46,86 +210,103 @@ 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})
 
-set (CMAKE_SWIG_FLAGS "")
-
-option (BUILDDOC "Build all doc." OFF)
-option (BUILDSWIG "Build swig modules." ON)
-option (BUILDSWIGPYTHON "Build swig python modules." ON)
-option (BUILDPYTHON3 "Use python3 for building/installing/testing" OFF)
-option (BUILDSWIGNODE "Build swig node modules." ON)
-option (BUILDEXAMPLES "Build C++ example binaries" OFF)
-option (BUILDJAVAEXAMPLES "Build java example jars" OFF)
-option (BUILDSWIGJAVA "Build swig java modules" OFF)
-option (IPK "Generate IPK using CPack" OFF)
-option (RPM "Generate RPM using CPack" OFF)
-option (BUILDTESTS "Generate check-ups for upm" ON)
-option (ENABLECXX11 "Enable C++11 standards support" ON)
-
-# Find swig
-if (BUILDSWIG)
-    if (BUILDSWIGNODE)
-        find_package (SWIG 3.0.5 REQUIRED)
-    else ()
-        find_package (SWIG REQUIRED)
-    endif ()
-    if (SWIG_FOUND)
-        include (${SWIG_USE_FILE})
-    endif ()
-endif ()
-
 # Detect arch
 include (TargetArch)
 target_architecture (DETECTED_ARCH)
-message( INFO " - Target arch is ${DETECTED_ARCH}")
+message (STATUS "Target arch is ${DETECTED_ARCH}")
 
-# enable c++11 standards support
-if (ENABLECXX11)
-  include(CheckCXXCompilerFlag)
-  if (CMAKE_VERSION VERSION_LESS "3.1")
-    CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
-    CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-    if (COMPILER_SUPPORTS_CXX11)
-      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-    elseif (COMPILER_SUPPORTS_CXX0X)
-      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-    else()
-      message(WARNING "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please update your C++ compiler.")
-    endif()
-  else()
-    # 3.1+ uses this generic method to enable c++11
-    set (CMAKE_CXX_STANDARD 11)
-  endif()
-else()
-  message(WARNING "Some modules require C++11 support, and may not build without it.")
+#-march=native for ARM when not defined/forced
+if (DETECTED_ARCH MATCHES "arm.*" AND NOT CMAKE_CXX_FLAGS MATCHES "-march")
+  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
 endif()
 
+# enable c++11 standards support unconditionally
+include(CheckCXXCompilerFlag)
+if (CMAKE_VERSION VERSION_LESS "3.1")
+  CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+  CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+  if (COMPILER_SUPPORTS_CXX11)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+  elseif (COMPILER_SUPPORTS_CXX0X)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+  else()
+    message(FATAL_ERROR "A C++11 compliant compiler is required to build UPM.")
+  endif()
+else()
+  # 3.1+ uses this generic method to enable c++11
+  set (CMAKE_CXX_STANDARD 11)
+  set (CXX_STANDARD_REQUIRED ON)
+  set (CXX_EXTENSIONS OFF)
+endif()
+
+include(CheckCCompilerFlag)
+if (CMAKE_VERSION VERSION_LESS "3.1")
+  CHECK_C_COMPILER_FLAG("-std=c11" COMPILER_SUPPORTS_C11)
+  if (COMPILER_SUPPORTS_C11)
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11")
+  else()
+    message(FATAL_ERROR "A C11 compliant C compiler is required to build UPM.")
+  endif()
+else()
+  # 3.1+ uses this generic method to enable c11
+  set (CMAKE_C_STANDARD 11)
+  set (C_STANDARD_REQUIRED ON)
+  set (C_EXTENSIONS OFF)
+endif()
+
+# The doc target depends on each sensor target
+#
+# doc
+#   ├──> libupm_sensor0
+#   ├──> libupm_sensor1
+#   ├──> libupm_sensor2
+#   └──> libupm_sensor_n
+#
+# The pydoc target builds documentation with sphinx via inspection by loading
+# each python module.  Those modules must include the CXX documentation via
+# a monolithic swig file generated by doxy2swig
+#
+# pydoc
+#  └──> _pyupm_sensor0_python2
+#        ├──────> libupm_sensor0
+#        └──────> doxy2swig
+#
+# The doxy2swig target is dependent upon the doc target IF BUILDDOC=ON,
+# otherwise doxy2swig uses an empty file.  Doxy2swig also depends on each
+# sensor target
+#
+# doxy2swig
+#  ├──> BUILDDOC=ON───> doc
+#  └──> libupm_sensor0
+#
+# The jsdoc target builds js documentation via yuidoc and only requires
+# the doc target
+#
+# jsdoc ─> doc
+#
 if (BUILDDOC)
   # Add a target to generate API documentation with Doxygen
-  find_package (Doxygen)
-  if (DOXYGEN_FOUND)
-    configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-    if (BUILDSWIGJAVA)
-        configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.java.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-java @ONLY)
-    endif()
-    file(GLOB PNG_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/docs docs/icons/*.png)
-    foreach(PNG_FILE ${PNG_FILES})
-      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docs/${PNG_FILE} ${CMAKE_CURRENT_BINARY_DIR}/html/docs/${PNG_FILE} COPYONLY)
-    endforeach()
-    add_custom_target (doc
-      ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-      COMMAND tar -czf html/xml.tar.gz -C xml .
-      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-      COMMENT "Generating API documentation with Doxygen" VERBATIM
-    )
-  endif (DOXYGEN_FOUND)
-  # Check if Sphinx is installed and add target to generate API documentation
-  find_package (Sphinx)
-  if(SPHINX_FOUND AND BUILDSWIG AND BUILDSWIGPYTHON)
-    # Python required for Sphinx build
-    find_package (PythonLibs ${PYTHONBUILD_VERSION} REQUIRED)
-    string (REPLACE "." ";" PYTHON_VERSION_LIST ${PYTHONLIBS_VERSION_STRING})
-    list (GET PYTHON_VERSION_LIST 0 PYTHON_VERSION_MAJOR)
-    list (GET PYTHON_VERSION_LIST 1 PYTHON_VERSION_MINOR)
+  find_package (Doxygen REQUIRED)
+  configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+  if (BUILDSWIGJAVA)
+      configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.java.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-java @ONLY)
+  endif()
+  file(GLOB PNG_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/docs docs/icons/*.png)
+  foreach(PNG_FILE ${PNG_FILES})
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docs/${PNG_FILE} ${CMAKE_CURRENT_BINARY_DIR}/html/docs/${PNG_FILE} COPYONLY)
+  endforeach()
+  add_custom_target (doc
+    ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+    COMMAND tar -czf html/xml.tar.gz -C xml .
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Generating API documentation with Doxygen" VERBATIM
+  )
+
+  # Check if Sphinx is installed and add target to generate API documentationa
+  # Currently, the per-module documentation for python is generated from the
+  # python2 modules.
+  if(BUILDSWIGPYTHON)
+    find_package (Sphinx REQUIRED)
     configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/conf.py.in ${CMAKE_CURRENT_BINARY_DIR}/pydoc/conf.py @ONLY)
     configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/index.rst ${CMAKE_CURRENT_BINARY_DIR}/pydoc/index.rst COPYONLY)
     add_custom_target (pydoc ALL
@@ -141,12 +322,11 @@ if (BUILDDOC)
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Generating API documentation with Sphinx" VERBATIM
     )
-  endif ()
+  endif(BUILDSWIGPYTHON)
+
   # Check if Yuidoc is installed and add target for API documentation
-  find_package(Yuidoc)
-  if(YUIDOC_FOUND AND BUILDSWIGNODE)
-    # Node required for Yuidoc documentation
-    find_package(Node)
+  if(BUILDSWIGNODE)
+    find_package(Yuidoc REQUIRED)
     file(GLOB_RECURSE JSDOC_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/doxy/node doxy/node/*)
     foreach(JSDOC_FILE ${JSDOC_FILES})
       configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doxy/node/${JSDOC_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${JSDOC_FILE} COPYONLY)
@@ -159,11 +339,10 @@ if (BUILDDOC)
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Generating API documentation with Yuidoc" VERBATIM
     )
-  endif()
-endif()
+  endif(BUILDSWIGNODE)
+endif (BUILDDOC)
 
 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)
@@ -176,7 +355,7 @@ if (IPK)
       set (TARGET_ARCH ${DETECTED_ARCH})
     endif ()
   endif ()
-  message (INFO " - Package arch is ${TARGET_ARCH}")
+  message (STATUS "Package arch is ${TARGET_ARCH}")
 
   set(CPACK_GENERATOR "DEB")
   set(OPKG_ARCH ${TARGET_ARCH})
@@ -201,7 +380,7 @@ if (IPK)
 endif()
 
 if (RPM)
-  message (INFO " - RPM packaging enabled for ${DETECTED_ARCH}")
+  message (STATUS "RPM packaging enabled for ${DETECTED_ARCH}")
   set(CPACK_PACKAGE_VERSION ${VERSION})
   set(CPACK_GENERATOR "RPM")
   set(CPACK_PACKAGE_NAME "upm")
@@ -226,26 +405,29 @@ if (RPM)
   include(CPack)
 endif()
 
-add_subdirectory (src)
+# UPM common headers
+set (UPM_COMMON_HEADER_DIRS
+    ${CMAKE_HOME_DIRECTORY}/include
+    ${CMAKE_HOME_DIRECTORY}/include/fti)
 
+add_subdirectory (src)
 if(BUILDEXAMPLES)
-  add_subdirectory (examples/c++)
+  add_subdirectory (examples/c)
+  if(BUILDCPP)
+    add_subdirectory (examples/c++)
+  endif(BUILDCPP)
 endif()
 
 if(BUILDJAVAEXAMPLES)
   add_subdirectory (examples/java)
 endif()
 
-if (BUILDSWIGPYTHON OR BUILDTESTS)
-  if (BUILDPYTHON3)
-    set (PYTHONBUILD_VERSION 3)
-  else ()
-    set (PYTHONBUILD_VERSION 2.7)
-  endif ()
-endif ()
-
+# Python interp is previously found if BUILDTESTS=ON
 if (BUILDTESTS)
-  find_package (PythonInterp ${PYTHONBUILD_VERSION} REQUIRED)
   enable_testing ()
   add_subdirectory (tests)
 endif()
+
+# Install C headers
+install(DIRECTORY include/ DESTINATION include/upm
+    FILES_MATCHING PATTERN "*.h")

README.md

@@ -1,29 +1,29 @@
 UPM (Useful Packages & Modules) Sensor/Actuator repository for MRAA
 ==============
 
-UPM is a high level repository for sensors that use MRAA. Each sensor links
-to MRAA and are not meant to be interlinked although some groups of sensors
-may be. Each sensor contains a header which allows to interface with it.
-Typically a sensor is represented as a class and instantiated.
+The UPM repository provides software drivers for a wide variety of commonly
+used sensors and actuators. These software drivers interact with the
+underlying hardware platform (or microcontroller), as well as with the attached
+sensors, through calls to [MRAA](https://github.com/intel-iot-devkit/mraa) APIs.
 
-The constructor is expected to initialise the sensor and parameters may be used
-to provide identification/pin location on the board.
+Programmers can access the interfaces for each sensor by including the sensor’s
+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.
 
-Typically an update() function will be called in order to get new data from the
-sensor in order to reduce load when doing multiple reads to sensor data.
-
-Although implementation and API design is up to the developer, C++ interfaces have
-been defined for the following sensor/actuator types and developers are encouraged to
-implement them. Interface header files are in the src/upm folder.
+C++ interfaces have been defined for the following sensor/actuator types, but
+they are subject to change:
 
 * Light controller 
 * Light sensor
 * Temperature sensor
 * Humidity sensor
 * Pressure sensor
+* Gas sensor
 * Analog to digital converter
 
-Feedback on interface design and additions for new types are welcome
+The developer community is encouraged to help expand the list of supported
+sensors and actuators and provide feedback on interface design.
 
 ### Example
 
@@ -73,7 +73,7 @@ Multi-sensor samples for the starter and specialized kits can be found in the
 
 Supported [sensor list](http://iotdk.intel.com/docs/master/upm/modules.html) from API documentation.
 
-You can also refer to the [Intel® IoT Developer Zone](https://software.intel.com/iot/sensors).
+You can also refer to the [Intel® IoT Developer Zone](https://software.intel.com/iot/hardware/sensors).
 
 ### IDE Integration
 
@@ -86,6 +86,8 @@ please refer to the Intel Developer Zone IDE page.
 
 See building documentation [here](docs/building.md).
 
+[![Build Status](https://travis-ci.org/intel-iot-devkit/upm.svg?branch=master)](https://travis-ci.org/intel-iot-devkit/upm)
+
 ### Making your own UPM module
 
 Porting [link](docs/porting.md) has more information on making new UPM modules.
@@ -120,8 +122,7 @@ 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** - Our **C++ header files** will change their extension from *.h* to
-*.hpp* in the upcoming version.
+**NOTE** - Our **C++ header files** changed extension from *.h* to *.hpp*!
 
 ### Changelog
 Version changelog [here](docs/changelog.md).

cmake/modules/CPackDeb.cmake

@@ -95,7 +95,7 @@ IF(NOT CPACK_DEBIAN_PACKAGE_ARCHITECTURE)
   # $ dpkg --print-architecture
   FIND_PROGRAM(DPKG_CMD dpkg)
   IF(NOT DPKG_CMD)
-    MESSAGE(STATUS "Can not find dpkg in your path, default to i386.")
+    MESSAGE(WARNING "Can not find dpkg in your path, default to i386.")
     SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE i386)
   ENDIF(NOT DPKG_CMD)
   EXECUTE_PROCESS(COMMAND "${DPKG_CMD}" --print-architecture

cmake/modules/FindNode.cmake

@@ -89,8 +89,8 @@ if (NODEJS_EXECUTABLE)
     endif ()
     string (REGEX REPLACE "\n" "" NODE_VERSION_STRING ${NODE_VERSION_STRING})
     string (REGEX REPLACE "\n" "" V8_VERSION_STRING ${V8_VERSION_STRING})
-    message ("INFO - Node version is " ${NODE_VERSION_STRING})
-    message ("INFO - Node using v8 " ${V8_VERSION_STRING})
+    message (STATUS "Node version is ${NODE_VERSION_STRING}")
+    message (STATUS "Node using v8 ${V8_VERSION_STRING}")
     mark_as_advanced (NODEJS_EXECUTABLE)
 endif ()
 

cmake/modules/FindSphinx.cmake

@@ -23,7 +23,7 @@ if (SPHINX_EXECUTABLE)
                     OUTPUT_VARIABLE SPHINX_VERSION)
     if(SPHINX_VERSION)
       string(REGEX MATCH "([0-9]\\.[0-9]\\.[0-9])" SPHINX_VERSION_STR ${SPHINX_VERSION})
-      message ("INFO - Sphinx version is " ${SPHINX_VERSION_STR})
+      message (STATUS "Sphinx version is ${SPHINX_VERSION_STR}")
     endif()
 endif ()
 

cmake/modules/FindYuidoc.cmake

@@ -14,9 +14,11 @@ find_package_handle_standard_args (Yuidoc DEFAULT_MSG
 # Get Yuidoc version
 if (YUIDOC_EXECUTABLE)
     execute_process(COMMAND ${YUIDOC_EXECUTABLE} --version
-                    ERROR_VARIABLE YUIDOC_VERSION)
+                    ERROR_VARIABLE YUIDOC_VERSION
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    ERROR_STRIP_TRAILING_WHITESPACE)
     if(YUIDOC_VERSION)
-      message ("INFO - Yuidoc version is " ${YUIDOC_VERSION})
+      message (STATUS "Yuidoc version is ${YUIDOC_VERSION}")
     endif()
 endif ()
 

cmake/modules/OpenCVDetectPython.cmake

@@ -0,0 +1,160 @@
+# Find specified Python version
+# Arguments:
+#   preferred_version (value): Version to check for first
+#   min_version (value): Minimum supported version
+#   library_env (value): Name of Python library ENV variable to check
+#   include_dir_env (value): Name of Python include directory ENV variable to check
+#   found (variable): Set if interpreter found
+#   executable (variable): Output of executable found
+#   version_string (variable): Output of found version
+#   version_major (variable): Output of found major version
+#   version_minor (variable): Output of found minor version
+#   libs_found (variable): Set if libs found
+#   libs_version_string (variable): Output of found libs version
+#   libraries (variable): Output of found Python libraries
+#   library (variable): Output of found Python library
+#   debug_libraries (variable): Output of found Python debug libraries
+#   debug_library (variable): Output of found Python debug library
+#   include_path (variable): Output of found Python include path
+#   include_dir (variable): Output of found Python include dir
+#   include_dir2 (variable): Output of found Python include dir2
+#   packages_path (variable): Output of found Python packages path
+function(find_python preferred_version min_version library_env include_dir_env
+         found executable version_string version_major version_minor
+         libs_found libs_version_string libraries library debug_libraries
+         debug_library include_path include_dir include_dir2 packages_path)
+if(NOT ${found})
+  if(${executable})
+    set(PYTHON_EXECUTABLE "${${executable}}")
+  endif()
+
+  find_package(PythonInterp "${preferred_version}")
+  if(NOT PYTHONINTERP_FOUND)
+    find_package(PythonInterp "${min_version}")
+  endif()
+
+  if(PYTHONINTERP_FOUND)
+    # Copy outputs
+    set(_found ${PYTHONINTERP_FOUND})
+    set(_executable ${PYTHON_EXECUTABLE})
+    set(_version_string ${PYTHON_VERSION_STRING})
+    set(_version_major ${PYTHON_VERSION_MAJOR})
+    set(_version_minor ${PYTHON_VERSION_MINOR})
+    set(_version_patch ${PYTHON_VERSION_PATCH})
+
+    # Clear find_host_package side effects
+    unset(PYTHONINTERP_FOUND)
+    unset(PYTHON_EXECUTABLE CACHE)
+    unset(PYTHON_VERSION_STRING)
+    unset(PYTHON_VERSION_MAJOR)
+    unset(PYTHON_VERSION_MINOR)
+    unset(PYTHON_VERSION_PATCH)
+  endif()
+
+  if(_found)
+    set(_version_major_minor "${_version_major}.${_version_minor}")
+
+    if(NOT ANDROID AND NOT APPLE_FRAMEWORK)
+      # not using _version_string here, because it might not conform to the CMake version format
+      if(CMAKE_CROSSCOMPILING)
+        # builder version can differ from target, matching base version (e.g. 2.7)
+        find_package(PythonLibs "${_version_major_minor}")
+      else()
+        find_package(PythonLibs "${_version_major_minor}.${_version_patch}" EXACT)
+      endif()
+
+      if(PYTHONLIBS_FOUND)
+        # Copy outputs
+        set(_libs_found ${PYTHONLIBS_FOUND})
+        set(_libraries ${PYTHON_LIBRARIES})
+        set(_include_path ${PYTHON_INCLUDE_PATH})
+        set(_include_dirs ${PYTHON_INCLUDE_DIRS})
+        set(_debug_libraries ${PYTHON_DEBUG_LIBRARIES})
+        set(_libs_version_string ${PYTHONLIBS_VERSION_STRING})
+        set(_debug_library ${PYTHON_DEBUG_LIBRARY})
+        set(_library ${PYTHON_LIBRARY})
+        set(_library_debug ${PYTHON_LIBRARY_DEBUG})
+        set(_library_release ${PYTHON_LIBRARY_RELEASE})
+        set(_include_dir ${PYTHON_INCLUDE_DIR})
+        set(_include_dir2 ${PYTHON_INCLUDE_DIR2})
+
+        # Clear find_package side effects
+        unset(PYTHONLIBS_FOUND)
+        unset(PYTHON_LIBRARIES)
+        unset(PYTHON_INCLUDE_PATH)
+        unset(PYTHON_INCLUDE_DIRS)
+        unset(PYTHON_DEBUG_LIBRARIES)
+        unset(PYTHONLIBS_VERSION_STRING)
+        unset(PYTHON_DEBUG_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY)
+        unset(PYTHON_LIBRARY_DEBUG)
+        unset(PYTHON_LIBRARY_RELEASE)
+        unset(PYTHON_LIBRARY CACHE)
+        unset(PYTHON_LIBRARY_DEBUG CACHE)
+        unset(PYTHON_LIBRARY_RELEASE CACHE)
+        unset(PYTHON_INCLUDE_DIR CACHE)
+        unset(PYTHON_INCLUDE_DIR2 CACHE)
+      endif()
+    endif()
+
+    execute_process(COMMAND ${_executable} -c "from distutils.sysconfig import *; print(get_python_lib())"
+                    RESULT_VARIABLE _cvpy_process
+                    OUTPUT_VARIABLE _std_packages_path
+                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if("${_std_packages_path}" MATCHES "site-packages")
+      set(_packages_path "python${_version_major_minor}/site-packages")
+    else() #debian based assumed, install to the dist-packages.
+      set(_packages_path "python${_version_major_minor}/dist-packages")
+    endif()
+      if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${${packages_path}}")
+        set(_packages_path "lib${LIB_SUFFIX}/${_packages_path}")
+      else()
+        set(_packages_path "lib/${_packages_path}")
+    endif()
+  endif()
+
+  # Export return values
+  set(${found} "${_found}" CACHE INTERNAL "")
+  set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpretor")
+  set(${version_string} "${_version_string}" CACHE INTERNAL "")
+  set(${version_major} "${_version_major}" CACHE INTERNAL "")
+  set(${version_minor} "${_version_minor}" CACHE INTERNAL "")
+  set(${libs_found} "${_libs_found}" CACHE INTERNAL "")
+  set(${libs_version_string} "${_libs_version_string}" CACHE INTERNAL "")
+  set(${libraries} "${_libraries}" CACHE INTERNAL "Python libraries")
+  set(${library} "${_library}" CACHE FILEPATH "Path to Python library")
+  set(${debug_libraries} "${_debug_libraries}" CACHE INTERNAL "")
+  set(${debug_library} "${_debug_library}" CACHE FILEPATH "Path to Python debug")
+  set(${include_path} "${_include_path}" CACHE INTERNAL "")
+  set(${include_dir} "${_include_dir}" CACHE PATH "Python include dir")
+  set(${include_dir2} "${_include_dir2}" CACHE PATH "Python include dir 2")
+  set(${packages_path} "${_packages_path}" CACHE PATH "Where to install the python packages.")
+endif()
+endfunction(find_python)
+
+set(MIN_VER_PYTHON2 2.7)
+set(MIN_VER_PYTHON3 3.2)
+
+find_python(2.7 "${MIN_VER_PYTHON2}" PYTHON2_LIBRARY PYTHON2_INCLUDE_DIR
+    PYTHON2INTERP_FOUND PYTHON2_EXECUTABLE PYTHON2_VERSION_STRING
+    PYTHON2_VERSION_MAJOR PYTHON2_VERSION_MINOR PYTHON2LIBS_FOUND
+    PYTHON2LIBS_VERSION_STRING PYTHON2_LIBRARIES PYTHON2_LIBRARY
+    PYTHON2_DEBUG_LIBRARIES PYTHON2_LIBRARY_DEBUG PYTHON2_INCLUDE_PATH
+    PYTHON2_INCLUDE_DIR PYTHON2_INCLUDE_DIR2 PYTHON2_PACKAGES_PATH)
+
+find_python(3 "${MIN_VER_PYTHON3}" PYTHON3_LIBRARY PYTHON3_INCLUDE_DIR
+    PYTHON3INTERP_FOUND PYTHON3_EXECUTABLE PYTHON3_VERSION_STRING
+    PYTHON3_VERSION_MAJOR PYTHON3_VERSION_MINOR PYTHON3LIBS_FOUND
+    PYTHON3LIBS_VERSION_STRING PYTHON3_LIBRARIES PYTHON3_LIBRARY
+    PYTHON3_DEBUG_LIBRARIES PYTHON3_LIBRARY_DEBUG PYTHON3_INCLUDE_PATH
+    PYTHON3_INCLUDE_DIR PYTHON3_INCLUDE_DIR2 PYTHON3_PACKAGES_PATH)
+
+if(PYTHON_DEFAULT_EXECUTABLE)
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+elseif(PYTHON2INTERP_FOUND) # Use Python 2 as default Python interpreter
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+    set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON2_EXECUTABLE}")
+elseif(PYTHON3INTERP_FOUND) # Use Python 2 as fallback Python interpreter (if there is no Python 2)
+    set(PYTHON_DEFAULT_AVAILABLE "TRUE")
+    set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON3_EXECUTABLE}")
+endif()

docs/apichanges.md

@@ -1,20 +1,37 @@
 API Changes                       {#apichanges}
 ===============
 
-**IMPORTANT NOTICE**
-
-Our **C++ header files** will change their extension from *.h* to *.hpp*. This
-change is anticipated in the upcoming version and unfortunately will break
-source compatibility with previous versions of UPM for every library. You will
-need to update your code and change to the new extension format in your
-`#include` directives.
-
 Here's a list of other API changes made to the library that break source/binary
 compatibility between releases:
 
+ * **grove<name>** Starting with UPM 1.0 the Grove libraries have been renamed
+ from *upm-grove<name>* to simply *upm-<name>*. Class names also match this new
+ format, with old classes marked as deprecated throughout the documentation.
+ List of affected libraries: grovecollision, groveehr, groveeldriver,
+ groveelectromagnet, groveemg, grovegprs, grovegsr, grovelinefinder, grovemd,
+ grovemoisture, groveo2, grovescam, grovespeaker, groveultrasonic, grovevdiv,
+ grovewater, grovewfs.
+ * **grove** As of UPM 1.0 the Grove classes for sensors in the starter kit are
+ being separated into individual libraries. The old classes will be deprecated
+ over time and eventually removed. Corresponding libraries have the grove
+ prefix removed. Affected classes are GroveButton, GroveLed, GroveLight,
+ GroveRelay, GroveRotary, GroveSlide and GroveTemp.
+ * The **ublox6** driver has been replaced with a generic implementation called
+ nmea_gps as of UPM 1.0. This driver should handle all generic serial GPS
+ devices that output NMEA data going forward.  This new driver has been tested
+ with ublox6, DFRobot VK2828U7 (ublox7) and ublox LEA-6H GPS devices.
+ * **grove** Binary compatibility was broken for the GroveTemp class as of UPM
+ v0.7.3. C++ code using this class has to be recompiled.
+ * There were frequent misspellings of the word *Celsius* in the UPM
+ code.  In some cases, these were in method names, which will cause
+ some API compatibility issues.  These have all been corrected for UPM
+ versions after v.0.7.2.
+ * Our **C++ header files** changed their extension from *.h* to *.hpp* in
+ version 0.7.0, Intel provided examples and code samples also reflect this
+ change but you will need to modify your `#include` directives in existing
+ code.
  * **my9221**, **groveledbar** and **grovecircularled** are now all part of the
- same library (my9221) and new functionality was added going to v.0.5.1
- * **stepmotor** driver API was changed significantly from v.0.4.1 to v.0.5.0
+ same library (my9221) and new functionality was added going to v.0.5.1.
+ * **stepmotor** driver API was changed significantly from v.0.4.1 to v.0.5.0.
  * **eboled** library was greatly improved in version 0.4.0 and the `draw()`
- function was removed in favor of a more complete GFX library implementation
- 
+ function was removed in favor of a more complete GFX library implementation.

docs/building.md

@@ -5,10 +5,21 @@ UPM uses cmake in order to make compilation relatively painless. Cmake runs
 build out of tree so the recommended way is to clone from git and make a build/
 directory.
 
+**Dependencies**
+ * basic: libmraa, cmake, swig, pkgconfig, pthreads, librt
+ * bindings: python-dev, nodejs-dev, openjdk
+ * documentation: doxygen, graphviz, sphinx, yuidoc
+ * sensor specific: bacnet-mstp, modbus, openzwave, jpeg
+
 This project depends on libmraa, so that needs to be installed first. Append
 the install location of mraa pkgconfig to the following environment variable:
 
-    PKG_CONFIG_PATH=$PKG_CONFIG_PATH:.../mraa/build/lib/pkgconfig
+~~~~~~~~~~~~~
+PKG_CONFIG_PATH=$PKG_CONFIG_PATH:.../mraa/build/lib/pkgconfig
+~~~~~~~~~~~~~
+
+If you are building the Java or Node.js bindings make sure you set the
+`JAVA_HOME` and `NODE_PATH` environment variables respectively.
 
 UPM will attempt to build all directories inside src/ and they must contain
 individual CMakeLists.txt files.
@@ -45,10 +56,18 @@ Cross-compiling on a different system:
 -DCMAKE_CXX_FLAGS:STRING=-m32 -march=i586
 -DCMAKE_C_FLAGS:STRING=-m32 -march=i586
 ~~~~~~~~~~~~~
+Enabling Java module building
+~~~~~~~~~~~~~
+-DBUILDSWIGJAVA=ON
+~~~~~~~~~~~~~
 Building with an older version of swig (swig 2.0+) requires the disabling of javascript:
 ~~~~~~~~~~~~~
 -DBUILDSWIGNODE=OFF
 ~~~~~~~~~~~~~
+Generating python3 modules instead of python2.7
+~~~~~~~~~~~~~
+-DBUILDPYTHON3=ON
+~~~~~~~~~~~~~
 Disabling python module building
 ~~~~~~~~~~~~~
 -DBUILDSWIGPYTHON=OFF
@@ -57,7 +76,7 @@ Setting the python library to use:
 ~~~~~~~~~~~~~
 -DPYTHON_LIBRARY:FILEPATH=/usr/lib/libpython2.7.so.1.0
 ~~~~~~~~~~~~~
-Building doxygen doc
+Building documentation
 ~~~~~~~~~~~~~
 -DBUILDDOC=ON
 ~~~~~~~~~~~~~
@@ -65,12 +84,16 @@ Build C++ example binaries
 ~~~~~~~~~~~~~
 -DBUILDEXAMPLES=ON
 ~~~~~~~~~~~~~
+Build Java examples
+~~~~~~~~~~~~~
+-DBUILDJAVAEXAMPLES=ON
+~~~~~~~~~~~~~
 
-If you intend to turn on all the options and build everything at once (C++,
-Node, Python and Documentation) you will have to edit the src/doxy2swig.py file
-and change the line endings from Windows style to Linux format. This has to be
-repeated every time to sync with the master branch since our Github repository
-stores files using CR LF line breaks.
+If you intend to turn on all the options and build everything at once
+(C++, Java, Node, Python and Documentation) you will have to edit the
+src/doxy2swig.py file and change the line endings from Windows style to Linux
+format. This has to be repeated every time to sync with the master branch since
+our Github repository stores files using CR LF line breaks.
 
 You can also generate the include and lib directories containing all the sensor
 headers and library files respectively with *make install*. Further, you may

docs/changelog.md

@@ -4,6 +4,80 @@ Changelog                         {#changelog}
 Here's a list summarizing some of the key undergoing changes to our library
 from earlier versions:
 
+### v1.0.1
+
+ * Warnings as errors enabled for C/CXX (fixed warnings from -Wall and others)
+ * Fix for C/CXX compile flag append issue #485
+ * C sensor libraries for: my9221, otp538u, guvas12d, ppd42ns
+ * New sensor: ms5803
+
+### v1.0.0
+
+ * Added approximately 50 C sources for UPM drivers that can be used on both
+ Unix and RTOS boards
+ * Provided generic alternatives to the Grove set of classes as they will be
+ deprecated over time and eventually removed
+ * UPM modules are now being packed and published on NPM as sources rather than
+ binaries to enhance compatibility with various boards and systems
+ * Build both python2 and python3 modules if the corresponding python libs are
+ available and removed cmake BUILDPYTHON3 switch
+ * Converted python examples to run on both python2 and python3
+ * Added 'upm' hierarchy to python module install path which changes the way
+ UPM modules are imported
+    Example:
+        old: import pyupm_dfrph
+        new: from upm import pyupm_dfrph
+             or
+             import upm.pyupm_dfrph
+ * Added ctests for consistancy checking UPM repo as well as sanity checking
+ for python2/3 modules and examples
+ * Various documentation and driver fixes throughout
+ * New sensors: nmea_gps, mma7361, bh1750, hka5, dfrorp, dfrec, sht1x
+
+### v0.8.0
+
+ * Extended l3gd20 driver to support I2C connections in addition to IIO
+ * Updated ads1x15, mcp9808 and ssd1306 I2C drivers to not throw a fatal
+ exception if they fail to set a different I2C speed
+ * Added extra functionality to apa102 driver, backlight control to jhd1313m1
+ LCDs and fixed htu21d
+ * Improved documentation with build dependencies, refreshed the list of known
+ limitations and simplified the component name for a few sensors
+
+### v0.7.3
+
+ * Fixed several existing drivers and updated Grove Temperature sensor to use
+ new formula for v1.1+ by default
+ * Separated codebase for upm_grove module that bundles some of the starter kit
+ sensors into individual source files
+ * Documentation and doxygen tag updates with correct spelling for Celsius in
+ several places, this also affects API compatibility
+ * Removed superfluous BUILDSWIG option, some build recipes might be impacted
+ * New sensor: ms5611
+
+### v0.7.2
+
+ * Mraa 1.1.1 required changes to UPM drivers and examples for IIO core
+ kernel support
+ * Rev'ed libmraa requirement to 1.1.1
+
+### v0.7.1
+
+ * Fix for building python2 vs python3 bindings
+ * Fixes for jhd1313m1 row/font size and reset
+ * Added bacnet utility class
+ * New sensors: bmx055, bmi055, bmc160, bma250e, bmg150, bmm150, t8100, tb7300
+
+### v0.7.0
+
+ * C++ header files have been renamed from *.h to *.hpp along with all Intel
+ provided examples and code samples to allow for native C drivers
+ * Updated driver compatibility to new MRAA 1.0 API
+ * First sensor implementations for our newly added Dallas One Wire support
+ * Several fixes based on issues reported on Github
+ * Changed SWIG linking strategy, more robust Travis CI build checks
+ * New sensors: ds2413, ds18b20, bmp280, bno055, l3gd20
+
 ### v0.6.2
 
  * Added a generic driver for taking snapshots from an USB camera device

docs/documentation.md

@@ -66,7 +66,7 @@ Here's an example (disregard the "@verbatim" tags in your actual code):
 - `<component-kit>` Specifies if the sensor is part of a kit. *Optional*
 
 Existing groups that can be used for the manufacturer, connection, category and
-kit tags are found in the src/upm.h file.
+kit tags are found in the *src/groups.md* file.
 
 Optionally, a small representative image can be placed in the "docs/images"
 subfolder and linked with the "@image" tag.