travis.yml: Install mraa to /usr

Signed-off-by: Brendan Le Foll <brendan.le.foll@intel.com>

.gitignore

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

.travis.yml

@@ -1,48 +1,34 @@
 language: cpp
 env:
-  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
+  - CC=gcc CXX=gcc
+  - CC=clang CXX=clang++
   - NODE4=true
   - NODE5=true
-compiler:
-  - clang
-  - gcc
+  - NODE012=true
 install:
-  - sudo add-apt-repository --yes ppa:fenics-packages/fenics-dev/swig
+  - if [ "${NODE4}" ]; then export CC=gcc-4.8 CXX=g++-4.8; fi
+  - sudo add-apt-repository --yes ppa:kalakris/cmake
+  - sudo add-apt-repository --yes ppa:fenics-packages/fenics-exp/swig
   - sudo apt-get update -qq
-  - sudo apt-get install -y --force-yes -qq swig3.0 git
+  - sudo apt-get install -y -qq swig3.0 python git cmake
   - sudo ln -s /usr/bin/swig3.0 /usr/bin/swig
   - sudo update-java-alternatives -s java-8-oracle
 before_script:
-  # 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
+  - 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
 script:
-  # 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
+  - 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=/usr .. && make && sudo make install
+  - cd ../.. && mkdir build && cd build && cmake -DNODE_ROOT_DIR:PATH="${NODE_ROOT_DIR}" -DBUILDSWIGJAVA=$BUILDJAVA -DBUILDEXAMPLES=ON -DBUILDJAVAEXAMPLES=$BUILDJAVA .. && make
 addons:
   apt:
     sources:
+      - llvm-toolchain-precise-3.6
       - ubuntu-toolchain-r-test
-      - george-edison55-precise-backports
     packages:
-      - cmake
-      - cmake-data
+      - clang-3.6
       - g++-4.8

CMakeLists.txt

@@ -1,195 +1,34 @@
 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." OFF)
-
-# 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)
-  # 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 ${_TMP_COMPILER_FLAGS} PARENT_SCOPE)
-endfunction ()
-
-# Compiler flags common to both C and CXX
-set (C_CXX_WARNING_FLAGS -Wall)
-
-# Errors as warnings?
-if (WERROR)
-  list (APPEND C_CXX_WARNING_FLAGS -Werror)
-  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)
-set(MRAA_MINIMUM 1.1.1)
-pkg_check_modules (MRAA REQUIRED mraa>=${MRAA_MINIMUM})
+pkg_check_modules (MRAA REQUIRED mraa>=0.9.1)
+message (INFO " found mraa version: ${MRAA_VERSION}")
 
-# 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)
+# Appends the cmake/modules path to MAKE_MODULE_PATH variable.
+set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 set (LIB_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Installation path for libraries")
 
+# Set CMAKE_LIB_INSTALL_DIR if not defined
+include(GNUInstallDirs)
+
 # Make a version file containing the current version from git.
 include (GetGitRevisionDescription)
 git_describe (VERSION "--tags")
-# If git_describe fails, use a dirty version
-if (${VERSION} MATCHES -NOTFOUND)
-  set (VERSION "v1.0.0-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.")
+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.5.1-dirty")
 endif ()
 
-message (STATUS "UPM Version ${VERSION}")
+message (INFO " - UPM Version ${VERSION}")
 
 # Parse the version information into pieces.
 string (REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${VERSION}")
@@ -207,83 +46,41 @@ 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" OFF)
+
+# 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 (STATUS "Target arch is ${DETECTED_ARCH}")
+message( INFO " - Target arch is ${DETECTED_ARCH}")
 
-#-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 REQUIRED)
+  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)
@@ -298,12 +95,16 @@ if (BUILDDOC)
       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)
+  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)
+    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)
+    set (SITE_PACKAGES ${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
     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
@@ -319,27 +120,29 @@ if (BUILDDOC)
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Generating API documentation with Sphinx" VERBATIM
     )
-  endif(BUILDSWIGPYTHON)
-
+  endif ()
   # Check if Yuidoc is installed and add target for API documentation
-  if(BUILDSWIGNODE)
-    find_package(Yuidoc REQUIRED)
+  find_package(Yuidoc)
+  if(YUIDOC_FOUND AND BUILDSWIGNODE)
+    # Node required for Yuidoc documentation
+    find_package(Node)
     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)
     endforeach()
     add_custom_target(jsdoc ALL
-      COMMAND ${NODEJS_EXECUTABLE} docgen -m upm -i xml -t ${CMAKE_CURRENT_SOURCE_DIR}/src -g ../../
+      COMMAND ${NODE_EXECUTABLE} docgen -m upm -i xml -t ${CMAKE_CURRENT_SOURCE_DIR}/src -g ../../
       COMMAND ${YUIDOC_EXECUTABLE} -C --no-sort --helpers generators/yuidoc/helper.js --themedir generators/yuidoc/tmpl -o html/node jsdoc/yuidoc/upm
-      COMMAND ${NODEJS_EXECUTABLE} tolower -i html/node
+      COMMAND ${NODE_EXECUTABLE} tolower -i html/node
       DEPENDS doc
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Generating API documentation with Yuidoc" VERBATIM
     )
-  endif(BUILDSWIGNODE)
-endif (BUILDDOC)
+  endif()
+endif()
 
 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)
@@ -352,7 +155,7 @@ if (IPK)
       set (TARGET_ARCH ${DETECTED_ARCH})
     endif ()
   endif ()
-  message (STATUS "Package arch is ${TARGET_ARCH}")
+  message (INFO " - Package arch is ${TARGET_ARCH}")
 
   set(CPACK_GENERATOR "DEB")
   set(OPKG_ARCH ${TARGET_ARCH})
@@ -377,54 +180,49 @@ if (IPK)
 endif()
 
 if (RPM)
-  message (STATUS "RPM packaging enabled for ${DETECTED_ARCH}")
+  message (INFO " - RPM packaging enabled for ${DETECTED_ARCH}")
   set(CPACK_PACKAGE_VERSION ${VERSION})
   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_NAME "libupm${upm_VERSION_MAJOR}")
+  set(CPACK_PACKAGE_RELEASE 1)
   set(CPACK_PACKAGE_VERSION
-      "${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH}${upm_PACKAGE_ON_TAG}${VERSION_COMMIT}")
+      "${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}")
+  set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_PACKAGE_RELEASE}.${DIST_TAG}.${DETECTED_ARCH}")
   include(CPack)
 endif()
 
-# 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)
-  if(BUILDCPP)
   add_subdirectory (examples/c++)
-  endif(BUILDCPP)
 endif()
 
 if(BUILDJAVAEXAMPLES)
   add_subdirectory (examples/java)
 endif()
 
-# Python interp is previously found if BUILDTESTS=ON
+if (BUILDSWIGPYTHON OR BUILDTESTS)
+  if (BUILDPYTHON3)
+    set (PYTHONBUILD_VERSION 3)
+  else ()
+    set (PYTHONBUILD_VERSION 2.7)
+  endif ()
+  find_package (PythonInterp ${PYTHONBUILD_VERSION} REQUIRED)
+  find_package (PythonLibs ${PYTHONBUILD_VERSION} REQUIRED)
+  include_directories(${PYTHON_INCLUDE_PATH})
+endif ()
+
 if (BUILDTESTS)
   enable_testing ()
   add_subdirectory (tests)
 endif()
-
-# Install C headers
-install(DIRECTORY include/ DESTINATION include/upm
-    FILES_MATCHING PATTERN "*.h")

README.md

@@ -1,29 +1,16 @@
 UPM (Useful Packages & Modules) Sensor/Actuator repository for MRAA
 ==============
 
-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.
+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.
 
-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.
+The constructor is expected to initialise the sensor and parameters may be used
+to provide identification/pin location on the board.
 
-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
-
-The developer community is encouraged to help expand the list of supported
-sensors and actuators and provide feedback on interface design.
+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.
 
 ### Example
 
@@ -64,6 +51,10 @@ A sensor/actuator is expected to work as such (here is the MMA7660 accelerometer
     }
 ```
 
+However implementation and API design is completely up to the developer, some
+enumerable sensors for example may provide much clever instantiation. Displays
+may also create more complex structures in order to interface with them.
+
 Browse through the list of all [examples](https://github.com/intel-iot-devkit/upm/tree/master/examples).
 
 Multi-sensor samples for the starter and specialized kits can be found in the
@@ -73,7 +64,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/hardware/sensors).
+You can also refer to the [Intel® IoT Developer Zone](https://software.intel.com/iot/sensors).
 
 ### IDE Integration
 
@@ -86,13 +77,11 @@ 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.
 
-There is also an example available gfor max31855 [sensor](docs/max31855.md).
+There is also an example available for max31855 [sensor](docs/max31855.md).
 
 Guide on creating Java [bindings](docs/creating_java_bindings.md).
 
@@ -116,14 +105,6 @@ API Documentation
 <a href="http://iotdk.intel.com/docs/master/upm/python"><img src="docs/icons/python.png"/></a>
 <a href="http://iotdk.intel.com/docs/master/upm/node"><img src="docs/icons/node.png"/></a>
 
-### API Compatibility
-Even if we try our best not to, every once in a while we are forced to modify
-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** 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(WARNING "Can not find dpkg in your path, default to i386.")
+    MESSAGE(STATUS "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,9 +89,9 @@ 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 (STATUS "Node version is ${NODE_VERSION_STRING}")
-    message (STATUS "Node using v8 ${V8_VERSION_STRING}")
+    message ("INFO - Node version is " ${NODE_VERSION_STRING})
+    message ("INFO - Node using v8 " ${V8_VERSION_STRING})
     mark_as_advanced (NODEJS_EXECUTABLE)
 endif ()
 
-mark_as_advanced (NODEJS_EXECUTABLE)
+mark_as_advanced (NODE_EXECUTABLE)

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 (STATUS "Sphinx version is ${SPHINX_VERSION_STR}")
+      message ("INFO - Sphinx version is " ${SPHINX_VERSION_STR})
     endif()
 endif ()
 

cmake/modules/FindYuidoc.cmake

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

cmake/modules/OpenCVDetectPython.cmake

@@ -1,160 +0,0 @@
-# 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,37 +0,0 @@
-API Changes                       {#apichanges}
-===============
-
-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.
- * **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.

docs/building.md

@@ -5,21 +5,10 @@ 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
-~~~~~~~~~~~~~
-
-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.
@@ -56,18 +45,10 @@ 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
@@ -76,7 +57,7 @@ Setting the python library to use:
 ~~~~~~~~~~~~~
 -DPYTHON_LIBRARY:FILEPATH=/usr/lib/libpython2.7.so.1.0
 ~~~~~~~~~~~~~
-Building documentation
+Building doxygen doc
 ~~~~~~~~~~~~~
 -DBUILDDOC=ON
 ~~~~~~~~~~~~~
@@ -84,16 +65,12 @@ 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++, 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.
+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.
 
 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,105 +4,6 @@ Changelog                         {#changelog}
 Here's a list summarizing some of the key undergoing changes to our library
 from earlier versions:
 
-### 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
- * New API changes section in documentation to let users know when the UPM API
- gets modified
- * Fixed some spelling errors and improved JavaScript documentation builds with
- newer versions of YUI and Node
- * Enhanced Cmake scripts and the build process
- * New sensors: vcap, e50hx
-
-### v0.6.1
-
- * Fixed library build process for different configurations across multiple
- environments reported by users.
- * Fixed multiple GFX library header clash and improved SSD1351 compatibility
- by changing SPI mode
- * Added Node and Python array typemaps for nrf24l01
- * Added 2 new JAVA examples
-
-### v0.6.0
-
- * Introduced C++ Interfaces for several sensor categories that will help
- consolidate the sensor APIs with uniform function names upon implementation
- * Greatly improved Node.js detection and handling during build and install,
- and should be now compatible with all major versions
- * Added a driver for the Curie IMU (accelerometer + gyroscope) that works with
- the new Firmata support implemented by MRAA
- * Continued to provide several JAVA fixes and examples
- * Many new industrial and maker sensors: cwlsxxa, teams, tex00, h803x, apa102,
- smartdrive, bmi160, bme280, ds1808lc, hlg150, lp8860, max44009, si1132, t6713,
- si7005, ssd1351
-
 ### v0.5.1
 
  * Updated the API and added new functionality for the MY9221 class and derived

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/groups.md* file.
+kit tags are found in the src/upm.h file.
 
 Optionally, a small representative image can be placed in the "docs/images"
 subfolder and linked with the "@image" tag.