From 878ca5538573e319b51cfe03baac8dcb90b89c7a Mon Sep 17 00:00:00 2001 From: Jon Trulson Date: Mon, 15 Dec 2014 17:17:19 -0700 Subject: [PATCH] adc121c021: Initial implementation Tested on the Grove I2C ADC. Signed-off-by: Jon Trulson Signed-off-by: Sarah Knepper --- examples/CMakeLists.txt | 3 + examples/adc121c021.cxx | 66 +++++++ examples/javascript/adc121c021.js | 68 +++++++ src/adc121c021/CMakeLists.txt | 5 + src/adc121c021/adc121c021.cxx | 250 +++++++++++++++++++++++++ src/adc121c021/adc121c021.h | 295 ++++++++++++++++++++++++++++++ src/adc121c021/jsupm_adc121c021.i | 9 + src/adc121c021/pyupm_adc121c021.i | 13 ++ 8 files changed, 709 insertions(+) create mode 100644 examples/adc121c021.cxx create mode 100644 examples/javascript/adc121c021.js create mode 100644 src/adc121c021/CMakeLists.txt create mode 100644 src/adc121c021/adc121c021.cxx create mode 100644 src/adc121c021/adc121c021.h create mode 100644 src/adc121c021/jsupm_adc121c021.i create mode 100644 src/adc121c021/pyupm_adc121c021.i diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index c2b7957b..b1c46d1d 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -53,6 +53,7 @@ add_executable (ldt0028-example ldt0028.cxx) add_executable (am2315-example am2315.cxx) add_executable (itg3200-example itg3200.cxx) add_executable (enc03r-example enc03r.cxx) +add_executable (adc121c021-example adc121c021.cxx) include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l) include_directories (${PROJECT_SOURCE_DIR}/src/grove) @@ -93,6 +94,7 @@ include_directories (${PROJECT_SOURCE_DIR}/src/ldt0028) include_directories (${PROJECT_SOURCE_DIR}/src/am2315) include_directories (${PROJECT_SOURCE_DIR}/src/itg3200) include_directories (${PROJECT_SOURCE_DIR}/src/enc03r) +include_directories (${PROJECT_SOURCE_DIR}/src/adc121c021) target_link_libraries (hmc5883l-example hmc5883l ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (groveled-example grove ${CMAKE_THREAD_LIBS_INIT}) @@ -149,3 +151,4 @@ target_link_libraries (ldt0028-example ldt0028 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (am2315-example am2315 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (itg3200-example itg3200 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (enc03r-example enc03r ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (adc121c021-example adc121c021 ${CMAKE_THREAD_LIBS_INIT}) diff --git a/examples/adc121c021.cxx b/examples/adc121c021.cxx new file mode 100644 index 00000000..18288adf --- /dev/null +++ b/examples/adc121c021.cxx @@ -0,0 +1,66 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include +#include "adc121c021.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] + // Instantiate an ADC121C021 on I2C bus 0 + + upm::ADC121C021 *adc = new upm::ADC121C021(ADC121C021_I2C_BUS, + ADC121C021_DEFAULT_I2C_ADDR); + + // An analog sensor, such as a Grove light sensor, + // must be attached to the adc + // Prints the value and corresponding voltage every 50 milliseconds + while (shouldRun) + { + uint16_t val = adc->value(); + cout << "ADC value: " << val << " Volts = " + << adc->valueToVolts(val) << endl; + usleep(50000); + } +//! [Interesting] + + cout << "Exiting..." << endl; + + delete adc; + return 0; +} diff --git a/examples/javascript/adc121c021.js b/examples/javascript/adc121c021.js new file mode 100644 index 00000000..c7f8ac4d --- /dev/null +++ b/examples/javascript/adc121c021.js @@ -0,0 +1,68 @@ +/*jslint node:true, vars:true, bitwise:true, unparam:true */ +/*jshint unused:true */ +/*global */ +/* +* Author: Zion Orent +* Copyright (c) 2014 Intel Corporation. +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +// Load ADC121C021 module +var I2C_ADC = require('jsupm_adc121c021'); +// Instantiate an ADC121C021 on I2C bus 0 +var myI2C_ADC = new I2C_ADC.ADC121C021(I2C_ADC.ADC121C021_I2C_BUS, + I2C_ADC.ADC121C021_DEFAULT_I2C_ADDR); +var g_sum, g_iteration, g_intervalObj; +var g_total_iteration_count = 30; +// An analog sensor, such as a Grove light sensor, +// must be attached to the adc +main(); + +// this function will be called by itself +function main() +{ + g_sum = 0; + g_iteration = 0; + // Sum the value every 50 milliseconds for g_total_iteration_count times + // Then print the average value and corresponding voltage + g_intervalObj = setInterval(function(I2CADC_val) + { + g_sum += I2CADC_val; + if (g_iteration >= g_total_iteration_count) + { + g_iteration = 0; + var val = (g_sum / g_total_iteration_count); + console.log("ADC value: " + val + " Volts = " + + myI2C_ADC.valueToVolts(val)); + clearInterval(g_intervalObj); + // Now that we're done with this iteration, go to the next iteration + main(); + } + g_iteration++; + }, 50, myI2C_ADC.value()); +} + +// Print message when exiting +process.on('SIGINT', function() +{ + console.log("Exiting..."); + process.exit(0); +}); diff --git a/src/adc121c021/CMakeLists.txt b/src/adc121c021/CMakeLists.txt new file mode 100644 index 00000000..1c198fd8 --- /dev/null +++ b/src/adc121c021/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "adc121c021") +set (libdescription "upm adc121c021 I2C ADC converter module") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/adc121c021/adc121c021.cxx b/src/adc121c021/adc121c021.cxx new file mode 100644 index 00000000..95567ccf --- /dev/null +++ b/src/adc121c021/adc121c021.cxx @@ -0,0 +1,250 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include "adc121c021.h" + +using namespace upm; +using namespace std; + + +ADC121C021::ADC121C021(int bus, uint8_t address, float vref) +{ + // setup our i2c link + m_i2c = mraa_i2c_init(bus); + + m_addr = address; + + mraa_result_t ret = mraa_i2c_address(m_i2c, m_addr); + + if (ret != MRAA_SUCCESS) + cerr << "ADC121C021: Could not initialize i2c bus. " << endl; + + m_vref = vref; +} + +ADC121C021::~ADC121C021() +{ + mraa_i2c_stop(m_i2c); +} + +mraa_result_t ADC121C021::writeByte(uint8_t reg, uint8_t byte) +{ + return mraa_i2c_write_byte_data(m_i2c, byte, reg); +} + +mraa_result_t ADC121C021::writeWord(uint8_t reg, uint16_t word) +{ + // We need to swap the bytes + uint8_t b1 = (word & 0xff00) >> 8; + word <<= 8; + word |= b1; + + return mraa_i2c_write_word_data(m_i2c, word, reg); +} + +uint8_t ADC121C021::readByte(uint8_t reg) +{ + return mraa_i2c_read_byte_data(m_i2c, reg); +} + +uint16_t ADC121C021::readWord(uint8_t reg) +{ + uint16_t val = mraa_i2c_read_word_data(m_i2c, reg); + uint8_t b1; + + // The value returned is in the wrong byte order, so we need to swap them + b1 = (val & 0xff00) >> 8; + val <<= 8; + val |= b1; + + return val; +} + +uint16_t ADC121C021::value() +{ + // mask off alert flag and reserved bits + return (readWord(ADC121C021_REG_RESULT) & 0x0fff); +} + +float ADC121C021::valueToVolts(uint16_t val) +{ + // The arduino example multiplies this by 2, which seems wrong. If + // the reference voltage is 3.0, then you should never get a voltage + // value higher than that. + // + // val * m_vref * 2.0 / ADC121C021_RESOLUTION + return (val * m_vref / ADC121C021_RESOLUTION); +} + +bool ADC121C021::getAlertStatus() +{ + // high order bit is the alert flag, mask off the rest + bool rv = (readWord(ADC121C021_REG_RESULT) & 0x8000) ? true : false; + + if (rv) + { + // read the alert low and high values and set the appropriate + // member variables + uint8_t astatus = readByte(ADC121C021_REG_ALERT_STATUS); + if (astatus & 0x01) + m_alertLow = true; + else + m_alertLow = false; + + if (astatus & 0x02) + m_alertHigh = true; + else + m_alertHigh = false; + } + + return rv; +} + +void ADC121C021::clearAlertStatus() +{ + // zero out both the low and high alert flags + writeByte(ADC121C021_REG_ALERT_STATUS, 0x03); + + m_alertHigh = false; + m_alertLow = false; +} + +void ADC121C021::enableAlertFlag(bool enable) +{ + // read the current config register + uint8_t val = readByte(ADC121C021_REG_CONFIG); + + if (enable) + val |= 0x08; + else + val &= ~0x08; + + // write the register back + writeByte(ADC121C021_REG_CONFIG, val); +} + +void ADC121C021::enableAlertPin(bool enable) +{ + // read the current config register + uint8_t val = readByte(ADC121C021_REG_CONFIG); + + if (enable) + val |= 0x04; + else + val &= ~0x04; + + // write the register back + writeByte(ADC121C021_REG_CONFIG, val); +} + +void ADC121C021::enableAlertHold(bool enable) +{ + // read the current config register + uint8_t val = readByte(ADC121C021_REG_CONFIG); + + if (enable) + val |= 0x10; + else + val &= ~0x10; + + // write the register back + writeByte(ADC121C021_REG_CONFIG, val); +} + +void ADC121C021::enableAlertPinPolarityHigh(bool enable) +{ + // read the current config register + uint8_t val = readByte(ADC121C021_REG_CONFIG); + + if (enable) + val |= 0x01; + else + val &= ~0x01; + + // write the register back + writeByte(ADC121C021_REG_CONFIG, val); +} + +void ADC121C021::setAutomaticConversion(ADC121C021_CYCLE_TIME_T cycleTime) +{ + // first we + + // read the current config register, masking off the cycle time bits + uint8_t val = readByte(ADC121C021_REG_CONFIG) & 0x1f; + + val |= ((uint8_t)cycleTime << 5); + + // write the register back + writeByte(ADC121C021_REG_CONFIG, val); +} + +mraa_result_t ADC121C021::setAlertLowLimit(uint16_t limit) +{ + // mask off the invalid bits in case they were set + limit &= 0x0fff; + + // write it + return writeWord(ADC121C021_REG_ALERT_LIM_UNDER, limit); +} + +mraa_result_t ADC121C021::setAlertHighLimit(uint16_t limit) +{ + // mask off the invalid bits in case they were set + limit &= 0x0fff; + + // write it + return writeWord(ADC121C021_REG_ALERT_LIM_OVER, limit); +} + +mraa_result_t ADC121C021::setHysteresis(uint16_t limit) +{ + // mask off the invalid bits in case they were set + limit &= 0x0fff; + + // write it + return writeWord(ADC121C021_REG_ALERT_HYS, limit); +} + +uint16_t ADC121C021::getHighestConversion() +{ + return readWord(ADC121C021_REG_HIGHEST_CONV); +} + +uint16_t ADC121C021::getLowestConversion() +{ + return readWord(ADC121C021_REG_LOWEST_CONV); +} + +mraa_result_t ADC121C021::clearHighestConversion() +{ + return writeWord(ADC121C021_REG_HIGHEST_CONV, 0x0000); +} + +mraa_result_t ADC121C021::clearLowestConversion() +{ + return writeWord(ADC121C021_REG_LOWEST_CONV, 0x0fff); +} diff --git a/src/adc121c021/adc121c021.h b/src/adc121c021/adc121c021.h new file mode 100644 index 00000000..f0520e4f --- /dev/null +++ b/src/adc121c021/adc121c021.h @@ -0,0 +1,295 @@ +/* + * Author: Jon Trulson + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +#pragma once + +#include +#include + +#define ADC121C021_I2C_BUS 0 +#define ADC121C021_DEFAULT_I2C_ADDR 0x55 + +#define ADC121C021_RESOLUTION 4096 // 12 bits + +/** + * ADC121C021 registers + */ + +#define ADC121C021_REG_RESULT 0x00 +#define ADC121C021_REG_ALERT_STATUS 0x01 +#define ADC121C021_REG_CONFIG 0x02 +#define ADC121C021_REG_ALERT_LIM_UNDER 0x03 +#define ADC121C021_REG_ALERT_LIM_OVER 0x04 +#define ADC121C021_REG_ALERT_HYS 0x05 +#define ADC121C021_REG_LOWEST_CONV 0x06 +#define ADC121C021_REG_HIGHEST_CONV 0x07 + +// For the Grove I2C ADC +#define ADC121C021_DEFAULT_VREF 3.0 + +namespace upm { + + /** + * valid cycle times for automatic conversion mode + */ + + typedef enum { ADC121C021_CYCLE_NONE = 0, // disabled + ADC121C021_CYCLE_32 = 1, // 27 ksps + ADC121C021_CYCLE_64 = 2, // 13.5 + ADC121C021_CYCLE_128 = 3, // 6.7 + ADC121C021_CYCLE_256 = 4, // 3.4 + ADC121C021_CYCLE_512 = 5, // 1.7 + ADC121C021_CYCLE_1024 = 6, // 0.9 + ADC121C021_CYCLE_2048 = 7 // 0.4 + } ADC121C021_CYCLE_TIME_T; + + /** + * @brief C++ API for the ADC121C021 I2C ADC + * + * UPM module for the ADC121C021 12 bit Analog to Digital (ADC) converter. + * By providing a constant reference voltage, this sensor helps + * to increase the accuracy of a value collected from an analog sensor. + * + * @ingroup i2c adc121c021 + * @snippet adc121c021.cxx Interesting + */ + class ADC121C021 { + public: + /** + * adc121c021 ADC constructor + * + * @param bus i2c bus to use + * @param address the address for this sensor; default is 0x55 + * @param vref reference voltage for this sensor; default is 3.0 + */ + ADC121C021(int bus, uint8_t address = ADC121C021_DEFAULT_I2C_ADDR, + float vref = ADC121C021_DEFAULT_VREF); + + /** + * ADC121C021 Destructor + */ + ~ADC121C021(); + + /** + * Write byte value into register + * + * @param reg register location to write into + * @param byte byte to write + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t writeByte(uint8_t reg, uint8_t byte); + + /** + * Write word value into register + * + * @param reg register location to write into + * @param word word to write + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t writeWord(uint8_t reg, uint16_t word); + + /** + * Read byte value from register + * + * @param reg register location to read from + * @return value at specified register + */ + uint8_t readByte(uint8_t reg); + + /** + * Read word value from register + * + * @param reg register location to read from + * @return value at specified register + */ + uint16_t readWord(uint8_t reg); + + /** + * Read current value of conversion + * + * @return current conversion value + */ + uint16_t value(); + + /** + * Convert a supplied value to voltage based on set VREF + * + * @param val value of conversion (from value()) + * @return conversion value in volts + */ + float valueToVolts(uint16_t val); + + /** + * Read current status of the alert flag. If the flag is set, the + * lower or upper alert indicators will be set as appropriate, and + * you can access these values with alertLowTriggered() or + * alertHighTriggered(). + * + * @return true if the alert flag is set + */ + bool getAlertStatus(); + + /** + * Return the current value of m_alertLow. You must call + * getAlertStatus() to update this value. + * + * @return current alert low status + */ + bool alertLowTriggered() { return m_alertLow; }; + + /** + * Return the current value of m_alertHigh. You must call + * getAlertStatus() to update this value. + * + * @return current alert high status + */ + bool alertHighTriggered() { return m_alertHigh; }; + + /** + * Clear the alert low and high flags. This will also clear the + * last stored alert values. + */ + void clearAlertStatus(); + + /** + * Enable or disable the Alert Flag functionality. If enabled, + * then when the measured value exceeds the low or high limits + * configured, the alert flag will be set. Use getAlertStatus() + * to access these values. + * + * @param enable if true, enables Alert Flag; otherwise, disables Alert Flag + */ + void enableAlertFlag(bool enable); + + /** + * Enable or disable the Alert Pin functionality. + * + * @param enable if true, enables Alert Pin; otherwise, disables Alert Pin + */ + void enableAlertPin(bool enable); + + /** + * Enable or disable the Alert Hold functionality. When Alert + * Hold is enabled, the alert status remains until manually + * cleared via clearAlertStatus(). Otherwise, the alert will self + * clear when the value moves into the defined limits if alerts + * are enabled via enableAlertFlag(). + * + * @param enable if true, enables Alert Hold; otherwise, disables Alert Hold + */ + void enableAlertHold(bool enable); + + /** + * If the Alert Pin fnctionality is enabled, define the active + * polarity of the pin in an alert condition. Enabling this sets + * the pin to active high in an alert condition, otherwise an + * active low is used. + * + * @param enable if true, Alert Pin is active high, else active low + */ + void enableAlertPinPolarityHigh(bool enable); + + /** + * Enable or disable Automatic Conversion mode. When enabled, the + * ADC will sample and update the conversion value independently. + * This is disabled by default, and a conversion is only done by + * calling value(). + * + * @param cycleTime set the Cycle Time for automatic conversion + */ + void setAutomaticConversion(ADC121C021_CYCLE_TIME_T cycleTime); + + /** + * Set the Alert Low Limit. If Alerts are enabled and the + * measured conversion value is lower than this, an alert will be + * triggered. + * + * @param limit the Low Alert Limit + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t setAlertLowLimit(uint16_t limit); + + /** + * Set the Alert High Limit. If Alerts are enabled and the + * measured conversion value is higher than this, an alert will be + * triggered. + * + * @param limit the High Alert Limit + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t setAlertHighLimit(uint16_t limit); + + /** + * Set the Hysteresis value. If a high or low alert condition is + * triggered, the conversion result must move within the high or + * low limit by more than this value to clear the alert condition. + * If the Alert Hold bit is set, then the alert will not self + * clear regardless of this value. + * + * @param limit Hysteresis Limit + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t setHysteresis(uint16_t limit); + + /** + * Return the Highest Conversion value sampled so far. This value + * is only updated by the converter when automatic conversion mode + * is enabled. + * + * @return the highest conversion value recorded + */ + uint16_t getHighestConversion(); + + /** + * Return the Lowest Conversion value sampled so far. This value + * is only updated by the converter when automatic conversion mode + * is enabled. + * + * @return the lowest conversion value recorded + */ + uint16_t getLowestConversion(); + + /** + * Clear the Highest Conversion value sampled so far. + * + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t clearHighestConversion(); + + /** + * Clear the Lowest Conversion value sampled so far. + * + * @return 0 (MRAA_SUCCESS) if successful; non-zero otherwise + */ + mraa_result_t clearLowestConversion(); + + private: + mraa_i2c_context m_i2c; + uint8_t m_addr; + float m_vref; + bool m_alertLow; + bool m_alertHigh; + }; +} + + diff --git a/src/adc121c021/jsupm_adc121c021.i b/src/adc121c021/jsupm_adc121c021.i new file mode 100644 index 00000000..83c2893b --- /dev/null +++ b/src/adc121c021/jsupm_adc121c021.i @@ -0,0 +1,9 @@ +%module jsupm_adc121c021 +%include "../upm.i" +%include "../carrays_uint16_t.i" + +%{ + #include "adc121c021.h" +%} + +%include "adc121c021.h" diff --git a/src/adc121c021/pyupm_adc121c021.i b/src/adc121c021/pyupm_adc121c021.i new file mode 100644 index 00000000..d6bb17a9 --- /dev/null +++ b/src/adc121c021/pyupm_adc121c021.i @@ -0,0 +1,13 @@ +%module pyupm_adc121c021 +%include "../upm.i" + +%feature("autodoc", "3"); + +#ifdef DOXYGEN +%include "adc121c021_doc.i" +#endif + +%include "adc121c021.h" +%{ + #include "adc121c021.h" +%}