From 56a01322b5defa05e60efd082845cffaefb5f708 Mon Sep 17 00:00:00 2001 From: Jon Trulson Date: Tue, 24 Mar 2015 14:03:15 -0600 Subject: [PATCH] mhz16: Initial implementation This library implements support for the MHZ16 CO2 sensor. Signed-off-by: Jon Trulson Signed-off-by: Zion Orent Signed-off-by: John Van Drasek --- examples/c++/CMakeLists.txt | 9 ++ examples/c++/apds9002.cxx | 62 +++++++++ examples/c++/mhz16.cxx | 83 +++++++++++ examples/c++/waterlevel.cxx | 62 +++++++++ examples/javascript/apds9002.js | 47 +++++++ examples/javascript/mhz16.js | 77 +++++++++++ examples/javascript/waterlevel.js | 50 +++++++ examples/python/apds9002.py | 50 +++++++ examples/python/mhz16.py | 71 ++++++++++ examples/python/waterlevel.py | 54 ++++++++ src/apds9002/CMakeLists.txt | 5 + src/apds9002/apds9002.cxx | 46 +++++++ src/apds9002/apds9002.h | 77 +++++++++++ src/apds9002/jsupm_apds9002.i | 8 ++ src/apds9002/pyupm_apds9002.i | 9 ++ src/mhz16/CMakeLists.txt | 5 + src/mhz16/jsupm_mhz16.i | 13 ++ src/mhz16/mhz16.cxx | 219 ++++++++++++++++++++++++++++++ src/mhz16/mhz16.h | 161 ++++++++++++++++++++++ src/mhz16/pyupm_mhz16.i | 14 ++ src/waterlevel/CMakeLists.txt | 5 + src/waterlevel/jsupm_waterlevel.i | 8 ++ src/waterlevel/pyupm_waterlevel.i | 9 ++ src/waterlevel/waterlevel.cxx | 44 ++++++ src/waterlevel/waterlevel.h | 70 ++++++++++ 25 files changed, 1258 insertions(+) create mode 100644 examples/c++/apds9002.cxx create mode 100644 examples/c++/mhz16.cxx create mode 100644 examples/c++/waterlevel.cxx create mode 100644 examples/javascript/apds9002.js create mode 100644 examples/javascript/mhz16.js create mode 100644 examples/javascript/waterlevel.js create mode 100644 examples/python/apds9002.py create mode 100644 examples/python/mhz16.py create mode 100644 examples/python/waterlevel.py create mode 100644 src/apds9002/CMakeLists.txt create mode 100644 src/apds9002/apds9002.cxx create mode 100644 src/apds9002/apds9002.h create mode 100644 src/apds9002/jsupm_apds9002.i create mode 100644 src/apds9002/pyupm_apds9002.i create mode 100644 src/mhz16/CMakeLists.txt create mode 100644 src/mhz16/jsupm_mhz16.i create mode 100644 src/mhz16/mhz16.cxx create mode 100644 src/mhz16/mhz16.h create mode 100644 src/mhz16/pyupm_mhz16.i create mode 100644 src/waterlevel/CMakeLists.txt create mode 100644 src/waterlevel/jsupm_waterlevel.i create mode 100644 src/waterlevel/pyupm_waterlevel.i create mode 100644 src/waterlevel/waterlevel.cxx create mode 100644 src/waterlevel/waterlevel.h diff --git a/examples/c++/CMakeLists.txt b/examples/c++/CMakeLists.txt index 6864a90f..4b3ea7d7 100644 --- a/examples/c++/CMakeLists.txt +++ b/examples/c++/CMakeLists.txt @@ -105,6 +105,9 @@ add_executable (adafruitms1438-stepper-example adafruitms1438-stepper.cxx) add_executable (hx711-example hx711.cxx) add_executable (flex-example flex.cxx) add_executable (a110x-intr-example a110x-intr.cxx) +add_executable (mhz16-example mhz16.cxx) +add_executable (apds9002-example apds9002.cxx) +add_executable (waterlevel-example waterlevel.cxx) include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l) include_directories (${PROJECT_SOURCE_DIR}/src/grove) @@ -189,6 +192,9 @@ include_directories (${PROJECT_SOURCE_DIR}/src/adafruitss) include_directories (${PROJECT_SOURCE_DIR}/src/adafruitms1438) include_directories (${PROJECT_SOURCE_DIR}/src/hx711) include_directories (${PROJECT_SOURCE_DIR}/src/flex) +include_directories (${PROJECT_SOURCE_DIR}/src/mhz16) +include_directories (${PROJECT_SOURCE_DIR}/src/apds9002) +include_directories (${PROJECT_SOURCE_DIR}/src/waterlevel) target_link_libraries (hmc5883l-example hmc5883l ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (groveled-example grove ${CMAKE_THREAD_LIBS_INIT}) @@ -295,3 +301,6 @@ target_link_libraries (adafruitms1438-stepper-example adafruitms1438 ${CMAKE_THR target_link_libraries (hx711-example hx711 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (flex-example flex ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (a110x-intr-example a110x ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (mhz16-example mhz16 ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (apds9002-example apds9002 ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (waterlevel-example waterlevel ${CMAKE_THREAD_LIBS_INIT}) diff --git a/examples/c++/apds9002.cxx b/examples/c++/apds9002.cxx new file mode 100644 index 00000000..87b50709 --- /dev/null +++ b/examples/c++/apds9002.cxx @@ -0,0 +1,62 @@ +/* + * Author: Zion Orent + * 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 +#include +#include +#include "apds9002.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 Luminance sensor on analog pin A0 + upm::APDS9002* luminance = new upm::APDS9002(0); + + while (shouldRun) + { + int val = luminance->value(); + cout << "Luminance value is " << val << endl; + + sleep(1); + } +//! [Interesting] + + cout << "Exiting" << endl; + + delete luminance; + return 0; +} diff --git a/examples/c++/mhz16.cxx b/examples/c++/mhz16.cxx new file mode 100644 index 00000000..bb46ae26 --- /dev/null +++ b/examples/c++/mhz16.cxx @@ -0,0 +1,83 @@ +/* + * Author: Jon Trulson + * 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 +#include +#include +#include "mhz16.h" + +using namespace std; + +bool shouldRun = true; + +void sig_handler(int signo) +{ + if (signo == SIGINT) + shouldRun = false; +} + +int main (int argc, char **argv) +{ + signal(SIGINT, sig_handler); + +//! [Interesting] + // Instantiate a MHZ16 serial CO2 sensor on uart 0. + // This example was tested on the Grove CO2 sensor module. + + upm::MHZ16* co2 = new upm::MHZ16(0); + + // make sure port is initialized properly. 9600 baud is the default. + if (!co2->setupTty(B9600)) + { + cerr << "Failed to setup tty port parameters" << endl; + return 1; + } + + cout << "Make sure that the sensor has had at least 3 minutes to warm up" + << endl; + cout << "or you will not get valid results." << endl; + cout << "The temperature reported is not the ambient temperature, " << endl; + cout << "but rather the temperature of the sensor elements." << endl; + + sleep(1); + + int gas; + int temp; + + while (shouldRun) + { + co2->getData(&gas, &temp); + cout << "CO2 concentration: " << gas << " PPM, " + << "Temperature (in C): " << temp < +* 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 +#include +#include +#include "waterlevel.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 Water Level Sensor + // Instantiate a Water Level Sensor on digital pin D2 + upm::WaterLevel* waterlevel = new upm::WaterLevel(2); + + while (shouldRun) + { + if (waterlevel->isSubmerged()) + cout << "Sensor is submerged in liquid" << endl; + else + cout << "Liquid is below water level sensor" << endl; + sleep(1); + } + +//! [Interesting] + cout << "Exiting" << endl; + + delete waterlevel; + return 0; +} diff --git a/examples/javascript/apds9002.js b/examples/javascript/apds9002.js new file mode 100644 index 00000000..829584f5 --- /dev/null +++ b/examples/javascript/apds9002.js @@ -0,0 +1,47 @@ +/*jslint node:true, vars:true, bitwise:true, unparam:true */ +/*jshint unused:true */ +/* +* Author: Zion Orent +* 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. +*/ + +// Load Grove Luminance sensor module +var luminanceSensor_lib = require('jsupm_apds9002'); + +// Instantiate a Grove Luminance sensor on analog pin A0 +var myLuminanceSensor_obj = new luminanceSensor_lib.APDS9002(0); + +var myInterval = setInterval(function() +{ + console.log("Luminance value is " + myLuminanceSensor_obj.value()); +}, 1000); + +// On exit: clear interval and memory, print message +process.on('SIGINT', function() +{ + clearInterval(myInterval); + myLuminanceSensor_obj = null; + luminanceSensor_lib.cleanUp(); + luminanceSensor_lib = null; + console.log("Exiting"); + process.exit(0); +}); diff --git a/examples/javascript/mhz16.js b/examples/javascript/mhz16.js new file mode 100644 index 00000000..cfa410fd --- /dev/null +++ b/examples/javascript/mhz16.js @@ -0,0 +1,77 @@ +/*jslint node:true, vars:true, bitwise:true, unparam:true */ +/*jshint unused:true */ +/* +* Author: Zion Orent +* 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. +*/ + +var CO2_lib = require('jsupm_mhz16'); + +// Instantiate a MHZ16 serial CO2 sensor on uart 0. +// This example was tested on the Grove CO2 sensor module. +var myCO2_obj = new CO2_lib.MHZ16(0); + +// make sure port is initialized properly. 9600 baud is the default. +if (!myCO2_obj.setupTty(CO2_lib.int_B9600)) +{ + console.log("Failed to setup tty port parameters"); + process.exit(0); +} + +outputStr = "Make sure that the sensor has had " + + "at least 3 minutes to warm up"; +console.log(outputStr); +outputStr = "or you will not get valid results."; +console.log(outputStr); +outputStr = "The temperature reported is not the ambient temperature,"; +console.log(outputStr); +outputStr = "but rather the temperature of the sensor elements."; +console.log(outputStr); + +var gas = CO2_lib.new_intp(); +var temp = CO2_lib.new_intp(); + +function writeCO2data() +{ + myCO2_obj.getData(gas, temp); + outputStr = "CO2 concentration: " + CO2_lib.intp_value(gas) + + " PPM, " + + "Temperature (in C): " + CO2_lib.intp_value(temp); + console.log(outputStr); +} +var myInterval; +setTimeout(function() +{ + myInterval = setInterval(writeCO2data, 2000); +}, 1000); + + +// Print message, clear memory when exiting +process.on('SIGINT', function() +{ + clearInterval(myInterval); + myCO2_obj = null; + CO2_lib.cleanUp(); + CO2_lib = null; + console.log("Exiting"); + process.exit(0); +}); diff --git a/examples/javascript/waterlevel.js b/examples/javascript/waterlevel.js new file mode 100644 index 00000000..bb4d0af2 --- /dev/null +++ b/examples/javascript/waterlevel.js @@ -0,0 +1,50 @@ +/*jslint node:true, vars:true, bitwise:true, unparam:true */ +/*jshint unused:true */ +/* +* Author: Zion Orent +* 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. +*/ + +var waterlevel_lib = require("jsupm_waterlevel"); + +// The was tested with the Water Level Sensor +// Instantiate a Water Level Sensor on digital pin D2 +var waterlevel_obj = new waterlevel_lib.WaterLevel(2); + +var myInterval = setInterval(function() +{ + if (waterlevel_obj.isSubmerged()) + console.log("Sensor is submerged in liquid"); + else + console.log("Liquid is below water level sensor"); +}, 1000); + +// When exiting: clear interval, clean up memory, and print message +process.on('SIGINT', function() +{ + clearInterval(myInterval); + waterlevel_obj = null; + waterlevel_lib.cleanUp(); + waterlevel_lib = null; + console.log("Exiting"); + process.exit(0); +}); diff --git a/examples/python/apds9002.py b/examples/python/apds9002.py new file mode 100644 index 00000000..f9ea3cb9 --- /dev/null +++ b/examples/python/apds9002.py @@ -0,0 +1,50 @@ +#!/usr/bin/python +# Author: Zion Orent +# 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. + +import time, sys, signal, atexit +import pyupm_apds9002 as upmApds9002 + +# Instantiate a Grove Luminance sensor on analog pin A0 +myLuminance = upmApds9002.APDS9002(0) + + +## Exit handlers ## +# This stops python from printing a stacktrace when you hit control-C +def SIGINTHandler(signum, frame): + raise SystemExit + +# This lets you run code on exit, including functions from myLuminance +def exitHandler(): + print "Exiting" + sys.exit(0) + +# Register exit handlers +atexit.register(exitHandler) +signal.signal(signal.SIGINT, SIGINTHandler) + + +while(1): + print "Luminance value is {0}".format( + myLuminance.value()) + + time.sleep(1) diff --git a/examples/python/mhz16.py b/examples/python/mhz16.py new file mode 100644 index 00000000..33f5ac98 --- /dev/null +++ b/examples/python/mhz16.py @@ -0,0 +1,71 @@ +#!/usr/bin/python +# Author: Zion Orent +# 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. + +import time, sys, signal, atexit +import pyupm_mhz16 as upmMhz16 + +# Instantiate a MHZ16 serial CO2 sensor on uart 0. +# This example was tested on the Grove CO2 sensor module. +myCO2 = upmMhz16.MHZ16(0) + + +## Exit handlers ## +# This stops python from printing a stacktrace when you hit control-C +def SIGINTHandler(signum, frame): + raise SystemExit + +# This function lets you run code on exit, +# including functions from myCO2 +def exitHandler(): + print "Exiting" + sys.exit(0) + +# Register exit handlers +atexit.register(exitHandler) +signal.signal(signal.SIGINT, SIGINTHandler) + + +# make sure port is initialized properly. 9600 baud is the default. +if (not myCO2.setupTty(upmMhz16.cvar.int_B9600)): + print "Failed to setup tty port parameters" + sys.exit(0) + +print ("Make sure that the sensor has had " +"at least 3 minutes to warm up\n" +"or you will not get valid results.\n" +"The temperature reported is not the ambient temperature,\n" +"but rather the temperature of the sensor elements.") + +gas = upmMhz16.new_intp() +temp = upmMhz16.new_intp() + +time.sleep(1) + +while(1): + myCO2.getData(gas, temp) + outputStr = ("CO2 concentration: {0} PPM, " + "Temperature (in C): {1}".format( + upmMhz16.intp_value(gas), upmMhz16.intp_value(temp))) + print outputStr + + time.sleep(2) diff --git a/examples/python/waterlevel.py b/examples/python/waterlevel.py new file mode 100644 index 00000000..18309e48 --- /dev/null +++ b/examples/python/waterlevel.py @@ -0,0 +1,54 @@ +#!/usr/bin/python +# Author: Zion Orent +# 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. + +import time, sys, signal, atexit +import pyupm_waterlevel as upmWaterlevel + +# The was tested with the Water Level Sensor +# Instantiate a Water Level Sensor on digital pin D2 +myWaterLevel = upmWaterlevel.WaterLevel(2) + + +## Exit handlers ## +# This stops python from printing a stacktrace when you hit control-C +def SIGINTHandler(signum, frame): + raise SystemExit + +# This function lets you run code on exit, +# including functions from myWaterLevel +def exitHandler(): + print "Exiting" + sys.exit(0) + +# Register exit handlers +atexit.register(exitHandler) +signal.signal(signal.SIGINT, SIGINTHandler) + + +while(1): + if (myWaterLevel.isSubmerged()): + print "Sensor is submerged in liquid" + else: + print "Liquid is below water level sensor" + + time.sleep(1) diff --git a/src/apds9002/CMakeLists.txt b/src/apds9002/CMakeLists.txt new file mode 100644 index 00000000..e006f8fe --- /dev/null +++ b/src/apds9002/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "apds9002") +set (libdescription "upm apds9002 luminance module") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/apds9002/apds9002.cxx b/src/apds9002/apds9002.cxx new file mode 100644 index 00000000..2e958cd5 --- /dev/null +++ b/src/apds9002/apds9002.cxx @@ -0,0 +1,46 @@ +/* + * Author: Zion Orent + * 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 + +#include "apds9002.h" + +using namespace upm; + +APDS9002::APDS9002(int pin) +{ + mraa_init(); + + m_aio = mraa_aio_init(pin); +} + +APDS9002::~APDS9002() +{ + mraa_aio_close(m_aio); +} + +int APDS9002::value() +{ + return mraa_aio_read(m_aio); +} diff --git a/src/apds9002/apds9002.h b/src/apds9002/apds9002.h new file mode 100644 index 00000000..b3a302d1 --- /dev/null +++ b/src/apds9002/apds9002.h @@ -0,0 +1,77 @@ +/* + * Author: Zion Orent + * 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. + */ +#pragma once + +#include +#include + +namespace upm { + /** + * @brief C++ API for the Grove Luminance Sensor + * + * This sensor transforms luminous intensity to output analog values. + * It uses the APDS-9002 ambient light sensor. + * + * @defgroup apds9002 libupm-apds9002 + * @ingroup seeed analog light + */ + + /** + * @sensor APDS-9002 + * @library libupm-apds9002 + * @comname APDS9002 + * @type light ainput + * @man seeed + * @con analog + * + * @brief UPM module for the Grove Luminance Sensor + * + * @snippet apds9002.cxx Interesting + */ + + class APDS9002 { + public: + /** + * Grove luminance sensor constructor + * + * @param pin analog pin to use + */ + APDS9002(int pin); + /** + * APDS9002 Destructor + */ + ~APDS9002(); + /** + * Get the luminance value from the sensor + * + * @return the luminance reading + */ + int value(); + + private: + mraa_aio_context m_aio; + }; +} + + diff --git a/src/apds9002/jsupm_apds9002.i b/src/apds9002/jsupm_apds9002.i new file mode 100644 index 00000000..383f5682 --- /dev/null +++ b/src/apds9002/jsupm_apds9002.i @@ -0,0 +1,8 @@ +%module jsupm_apds9002 +%include "../upm.i" + +%{ + #include "apds9002.h" +%} + +%include "apds9002.h" diff --git a/src/apds9002/pyupm_apds9002.i b/src/apds9002/pyupm_apds9002.i new file mode 100644 index 00000000..5101d21d --- /dev/null +++ b/src/apds9002/pyupm_apds9002.i @@ -0,0 +1,9 @@ +%module pyupm_apds9002 +%include "../upm.i" + +%feature("autodoc", "3"); + +%include "apds9002.h" +%{ + #include "apds9002.h" +%} diff --git a/src/mhz16/CMakeLists.txt b/src/mhz16/CMakeLists.txt new file mode 100644 index 00000000..b032acb6 --- /dev/null +++ b/src/mhz16/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "mhz16") +set (libdescription "upm grove CO2 sensor") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/mhz16/jsupm_mhz16.i b/src/mhz16/jsupm_mhz16.i new file mode 100644 index 00000000..2b3f9d8e --- /dev/null +++ b/src/mhz16/jsupm_mhz16.i @@ -0,0 +1,13 @@ +%module jsupm_mhz16 +%include "../upm.i" +%include "cpointer.i" + +/* Send "int *" to JavaScript as intp */ +%pointer_functions(int, intp); +%{ + #include "mhz16.h" + speed_t int_B9600 = B9600; +%} + +%include "mhz16.h" +speed_t int_B9600 = B9600; diff --git a/src/mhz16/mhz16.cxx b/src/mhz16/mhz16.cxx new file mode 100644 index 00000000..46826ff4 --- /dev/null +++ b/src/mhz16/mhz16.cxx @@ -0,0 +1,219 @@ +/* + * Author: Jon Trulson + * 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 + +#include "mhz16.h" + +using namespace upm; +using namespace std; + +static const int defaultDelay = 100; // max wait time for read + +MHZ16::MHZ16(int uart) +{ + m_ttyFd = -1; + + if ( !(m_uart = mraa_uart_init(uart)) ) + { + cerr << __FUNCTION__ << ": mraa_uart_init() failed" << endl; + return; + } + + // This requires a recent MRAA (1/2015) + char *devPath = mraa_uart_get_dev_path(m_uart); + + if (!devPath) + { + cerr << __FUNCTION__ << ": mraa_uart_get_dev_path() failed" << endl; + return; + } + + // now open the tty + if ( (m_ttyFd = open(devPath, O_RDWR)) == -1) + { + cerr << __FUNCTION__ << ": open of " << devPath << " failed: " + << strerror(errno) << endl; + return; + } +} + +MHZ16::~MHZ16() +{ + if (m_ttyFd != -1) + close(m_ttyFd); + + mraa_deinit(); +} + +bool MHZ16::dataAvailable(unsigned int millis) +{ + if (m_ttyFd == -1) + return false; + + struct timeval timeout; + + // no waiting + timeout.tv_sec = 0; + timeout.tv_usec = millis * 1000; + + int nfds; + fd_set readfds; + + FD_ZERO(&readfds); + + FD_SET(m_ttyFd, &readfds); + + if (select(m_ttyFd + 1, &readfds, NULL, NULL, &timeout) > 0) + return true; // data is ready + else + return false; +} + +int MHZ16::readData(char *buffer, size_t len) +{ + if (m_ttyFd == -1) + return(-1); + + if (!dataAvailable(defaultDelay)) + return 0; // timed out + + int rv = read(m_ttyFd, buffer, len); + + if (rv < 0) + cerr << __FUNCTION__ << ": read failed: " << strerror(errno) << endl; + + return rv; +} + +int MHZ16::writeData(char *buffer, size_t len) +{ + if (m_ttyFd == -1) + return(-1); + + // first, flush any pending but unread input + tcflush(m_ttyFd, TCIFLUSH); + + int rv = write(m_ttyFd, buffer, len); + + if (rv < 0) + { + cerr << __FUNCTION__ << ": write failed: " << strerror(errno) << endl; + return rv; + } + + tcdrain(m_ttyFd); + + return rv; +} + +bool MHZ16::setupTty(speed_t baud) +{ + if (m_ttyFd == -1) + return(false); + + struct termios termio; + + // get current modes + tcgetattr(m_ttyFd, &termio); + + // setup for a 'raw' mode. 81N, no echo or special character + // handling, such as flow control. + cfmakeraw(&termio); + + // set our baud rates + cfsetispeed(&termio, baud); + cfsetospeed(&termio, baud); + + // make it so + if (tcsetattr(m_ttyFd, TCSAFLUSH, &termio) < 0) + { + cerr << __FUNCTION__ << ": tcsetattr failed: " << strerror(errno) << endl; + return false; + } + + return true; +} + +bool MHZ16::verifyPacket(unsigned char *pkt) +{ + if (pkt[0] != 0xff || pkt[1] != 0x86) + { + cerr << __FUNCTION__ << ": Inavlid packet header." << endl; + return false; + } + + return true; +} + +bool MHZ16::getData(int *gas, int *temp) +{ + // the query command + const unsigned char cmd[9] = + {0xff, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79}; + + writeData((char *)cmd, 9); + + // wait up to one second for a response + if (!dataAvailable(1000)) + { + cerr << __FUNCTION__ << ": Timed out waiting for response." << endl; + return false; + } + + // read the packet + unsigned char packet[9]; + int rv; + + if ((rv = readData((char *)packet, 9)) != 9) + { + cerr << __FUNCTION__ << ": Invalid packet read, rv = " << rv + << ", expected 9." << endl; + return false; + } + + if (!verifyPacket(packet)) + { + cerr << __FUNCTION__ << ": Packet verify failed." << endl; + return false; + } + + // pull out the data and return it. + *gas = (packet[2] << 8) | packet[3]; + *temp = packet[4] - 40; + + return true; +} + +void MHZ16::calibrateZeroPoint() +{ + // the query command + const unsigned char cmd[9] = + {0xff, 0x01, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78}; + + writeData((char *)cmd, 9); + + // no response +} + diff --git a/src/mhz16/mhz16.h b/src/mhz16/mhz16.h new file mode 100644 index 00000000..1a79b053 --- /dev/null +++ b/src/mhz16/mhz16.h @@ -0,0 +1,161 @@ +/* + * Author: Jon Trulson + * 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. + */ +#pragma once + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +const int MHZ16_DEFAULT_UART = 0; + +// protocol start and end codes +const uint8_t MHZ16_START = 0x7e; +const uint8_t MHZ16_END = 0x7e; + +namespace upm { + /** + * @brief UPM support for the MHZ16 Serial CO2 sensor + * @defgroup mhz16 libupm-mhz16 + * @ingroup seeed serial gas + */ + + /** + * @sensor mhz16 + * @library mhz16 + * @name Grove CO2 sensor + * @category gaseous + * @manufacturer seeed + * @connection uart + * + * @brief C++ API support for the Grove CO2 sensor + * + * This class implements support for the Grove CO2 sensor. + * + * It's CO2 detection ranges from 0PPM to 2000PPM. It requires a + * 2-3 minute warm up time before reporting valid data. + * + * @snippet mhz16.cxx Interesting + */ + class MHZ16 { + public: + + + /** + * MHZ16 module constructor + * + * @param uart default uart to use (0 or 1) + */ + MHZ16(int uart); + + /** + * MHZ16 module Destructor + */ + ~MHZ16(); + + /** + * Check to see if there is data available for reading + * + * @param millis number of milliseconds to wait, 0 means no wait. + * @return true if there is data available to be read + */ + bool dataAvailable(unsigned int millis); + + /** + * read any available data into a user-supplied buffer. Note, the + * call will block until data is available to be read. Use + * dataAvailable() to determine whether there is data available + * beforehand, to avoid blocking. + * + * @param buffer the buffer to hold the data read + * @param len the length of the buffer + * @return the number of bytes read + */ + int readData(char *buffer, size_t len); + + /** + * write the data in buffer to the device + * + * @param buffer the buffer to hold the data read + * @param len the length of the buffer + * @return the number of bytes written + */ + int writeData(char *buffer, size_t len); + + /** + * setup the proper tty i/o modes and the baudrate. The default + * baud rate is 9600 (B9600). + * + * @param baud the desired baud rate. + * @return true if successful + */ + bool setupTty(speed_t baud=B9600); + + /** + * verify the packet header and indicate it's validity + * + * @param pkt the packet to check + * @return true if valid checksum, false otherwise + */ + bool verifyPacket(unsigned char *pkt); + + /** + * Query the sensor and return gas (CO2) concentration and + * temperature data. + * + * @param gas the returned gas concentration + * @param temp the returned temperature in celsius + * @return true if successful + */ + bool getData(int *gas, int *temp); + + /** + * Set the zero point of the sensor + * + */ + void calibrateZeroPoint(); + + protected: + int ttyFd() { return m_ttyFd; }; + int setTtyFd(int fd) { m_ttyFd = fd; }; + + private: + mraa_uart_context m_uart; + int m_ttyFd; + }; +} + + diff --git a/src/mhz16/pyupm_mhz16.i b/src/mhz16/pyupm_mhz16.i new file mode 100644 index 00000000..708b67be --- /dev/null +++ b/src/mhz16/pyupm_mhz16.i @@ -0,0 +1,14 @@ +%module pyupm_mhz16 +%include "../upm.i" +%include "cpointer.i" + +%feature("autodoc", "3"); + +/* Send "int *" to JavaScript as intp */ +%pointer_functions(int, intp); +%{ + #include "mhz16.h" + speed_t int_B9600 = B9600; +%} +%include "mhz16.h" +speed_t int_B9600 = B9600; diff --git a/src/waterlevel/CMakeLists.txt b/src/waterlevel/CMakeLists.txt new file mode 100644 index 00000000..4f985e26 --- /dev/null +++ b/src/waterlevel/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "waterlevel") +set (libdescription "upm waterlevel sensor module") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init("-lrt") diff --git a/src/waterlevel/jsupm_waterlevel.i b/src/waterlevel/jsupm_waterlevel.i new file mode 100644 index 00000000..44a715e8 --- /dev/null +++ b/src/waterlevel/jsupm_waterlevel.i @@ -0,0 +1,8 @@ +%module jsupm_waterlevel +%include "../upm.i" + +%{ + #include "waterlevel.h" +%} + +%include "waterlevel.h" diff --git a/src/waterlevel/pyupm_waterlevel.i b/src/waterlevel/pyupm_waterlevel.i new file mode 100644 index 00000000..d507dc07 --- /dev/null +++ b/src/waterlevel/pyupm_waterlevel.i @@ -0,0 +1,9 @@ +%module pyupm_waterlevel +%include "../upm.i" + +%feature("autodoc", "3"); + +%include "waterlevel.h" +%{ + #include "waterlevel.h" +%} diff --git a/src/waterlevel/waterlevel.cxx b/src/waterlevel/waterlevel.cxx new file mode 100644 index 00000000..ce3991d9 --- /dev/null +++ b/src/waterlevel/waterlevel.cxx @@ -0,0 +1,44 @@ +/* + * Author: Zion Orent + * 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 "waterlevel.h" + +using namespace upm; + +WaterLevel::WaterLevel(int pin) +{ + m_gpio = mraa_gpio_init(pin); + mraa_gpio_dir(m_gpio, MRAA_GPIO_IN); +} + +WaterLevel::~WaterLevel() +{ + mraa_gpio_close(m_gpio); +} + +bool WaterLevel::isSubmerged() +{ + // Submerged causes 0; being above water is 1 + return (!(bool)mraa_gpio_read(m_gpio)); +} diff --git a/src/waterlevel/waterlevel.h b/src/waterlevel/waterlevel.h new file mode 100644 index 00000000..4abce4fb --- /dev/null +++ b/src/waterlevel/waterlevel.h @@ -0,0 +1,70 @@ +/* + * Author: Zion Orent + * 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. + */ +#pragma once + +#include + +namespace upm { + /** + * @brief C++ API for the Water Level Sensor + * + * The Water Level Sensor senses the water level. + * When the level rises, a ball with a magnet floats up and causes a switch to open. + * When the level falls, the magnet also falls and the switch closes. + * + * @defgroup waterlevel libupm-waterlevel + * @ingroup gpio waterlevel + */ + /** + * @library libupm-waterlevel + * @sensor waterlevel + * @comname waterlevel + * @type liquid + * @man seeed + * @con gpio + * + * @brief UPM module for the Grove Luminance Sensor + * + * @snippet apds9002.cxx Interesting + */ class WaterLevel { + public: + /** + * Water Level Constructor + * + * @param pin digital pin to use + */ + WaterLevel(int pin); + /** + * Water Level Destructor + */ + ~WaterLevel(); + /** + * @return bool returns whether liquid has gone above sensor + */ + bool isSubmerged(); + + private: + mraa_gpio_context m_gpio; + }; +}