From 12c290de705be07be4d0a5398599416c2bcca3a9 Mon Sep 17 00:00:00 2001 From: Jon Trulson Date: Fri, 30 Jan 2015 18:43:10 -0700 Subject: [PATCH] mma7660: Initial implementation This was tested on the Grove I2C 3-axis digital accelerometer. Signed-off-by: Jon Trulson Signed-off-by: Zion Orent Signed-off-by: John Van Drasek --- examples/CMakeLists.txt | 3 + examples/javascript/mma7660.js | 83 ++++++++++ examples/mma7660.cxx | 86 +++++++++++ src/mma7660/CMakeLists.txt | 5 + src/mma7660/jsupm_mma7660.i | 13 ++ src/mma7660/mma7660.cxx | 249 ++++++++++++++++++++++++++++++ src/mma7660/mma7660.h | 273 +++++++++++++++++++++++++++++++++ src/mma7660/pyupm_mma7660.i | 13 ++ 8 files changed, 725 insertions(+) create mode 100644 examples/javascript/mma7660.js create mode 100644 examples/mma7660.cxx create mode 100644 src/mma7660/CMakeLists.txt create mode 100644 src/mma7660/jsupm_mma7660.i create mode 100644 src/mma7660/mma7660.cxx create mode 100644 src/mma7660/mma7660.h create mode 100644 src/mma7660/pyupm_mma7660.i diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index e1598489..d319d83c 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -80,6 +80,7 @@ add_executable (rotaryencoder-example rotaryencoder.cxx) add_executable (adxl345-example adxl345.cxx) add_executable (rpr220-example rpr220.cxx) add_executable (rpr220-intr-example rpr220-intr.cxx) +add_executable (mma7660-example mma7660.cxx) include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l) include_directories (${PROJECT_SOURCE_DIR}/src/grove) @@ -145,6 +146,7 @@ include_directories (${PROJECT_SOURCE_DIR}/src/my9221) include_directories (${PROJECT_SOURCE_DIR}/src/rotaryencoder) include_directories (${PROJECT_SOURCE_DIR}/src/adxl345) include_directories (${PROJECT_SOURCE_DIR}/src/rpr220) +include_directories (${PROJECT_SOURCE_DIR}/src/mma7660) target_link_libraries (hmc5883l-example hmc5883l ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (groveled-example grove ${CMAKE_THREAD_LIBS_INIT}) @@ -228,3 +230,4 @@ target_link_libraries (rotaryencoder-example rotaryencoder ${CMAKE_THREAD_LIBS_I target_link_libraries (adxl345-example adxl345 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (rpr220-example rpr220 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (rpr220-intr-example rpr220 ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (mma7660-example mma7660 ${CMAKE_THREAD_LIBS_INIT}) diff --git a/examples/javascript/mma7660.js b/examples/javascript/mma7660.js new file mode 100644 index 00000000..5a9e4b52 --- /dev/null +++ b/examples/javascript/mma7660.js @@ -0,0 +1,83 @@ +/*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 digitalAccelerometer = require('jsupm_mma7660'); + +// Instantiate an MMA7660 on I2C bus 0 +var myDigitalAccelerometer = new digitalAccelerometer.MMA7660( + digitalAccelerometer.MMA7660_I2C_BUS, + digitalAccelerometer.MMA7660_DEFAULT_I2C_ADDR + ); + +// place device in standby mode so we can write registers +myDigitalAccelerometer.setModeStandby(); + +// enable 64 samples per second +myDigitalAccelerometer.setSampleRate(digitalAccelerometer.MMA7660.AUTOSLEEP_64); + +// place device into active mode +myDigitalAccelerometer.setModeActive(); + +var myInterval = setInterval(function() +{ + var x, y, z; + x = digitalAccelerometer.new_intp(); + y = digitalAccelerometer.new_intp(); + z = digitalAccelerometer.new_intp(); + + myDigitalAccelerometer.getRawValues(x, y, z); + var outputStr = "Raw values: x = " + digitalAccelerometer.intp_value(x) + + " y = " + digitalAccelerometer.intp_value(y) + + " z = " + digitalAccelerometer.intp_value(z); + console.log(outputStr); + + var ax, ay, az; + ax = digitalAccelerometer.new_floatp(); + ay = digitalAccelerometer.new_floatp(); + az = digitalAccelerometer.new_floatp(); + + myDigitalAccelerometer.getAcceleration(ax, ay, az); + outputStr = "Acceleration: x = " + roundNum(digitalAccelerometer.floatp_value(ax), 6) + + "g y = " + roundNum(digitalAccelerometer.floatp_value(ay), 6) + + "g z = " + roundNum(digitalAccelerometer.floatp_value(az), 6) + "g"; + console.log(outputStr); +}, 500); + +// round off output to match C example, which has 6 decimal places +function roundNum(num, decimalPlaces) +{ + var extraNum = (1 / (Math.pow(10, decimalPlaces) * 1000)); + return (Math.round((num + extraNum) * (Math.pow(10, decimalPlaces))) / Math.pow(10, decimalPlaces)); +} + +// When exiting: clear interval and print message +process.on('SIGINT', function() +{ + clearInterval(myInterval); + console.log("Exiting..."); + process.exit(0); +}); diff --git a/examples/mma7660.cxx b/examples/mma7660.cxx new file mode 100644 index 00000000..c426db55 --- /dev/null +++ b/examples/mma7660.cxx @@ -0,0 +1,86 @@ +/* + * 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 "mma7660.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 MMA7660 on I2C bus 0 + + upm::MMA7660 *accel = new upm::MMA7660(MMA7660_I2C_BUS, + MMA7660_DEFAULT_I2C_ADDR); + + // place device in standby mode so we can write registers + accel->setModeStandby(); + + // enable 64 samples per second + accel->setSampleRate(upm::MMA7660::AUTOSLEEP_64); + + // place device into active mode + accel->setModeActive(); + + while (shouldRun) + { + int x, y, z; + + accel->getRawValues(&x, &y, &z); + cout << "Raw values: x = " << x + << " y = " << y + << " z = " << z + << endl; + + float ax, ay, az; + + accel->getAcceleration(&ax, &ay, &az); + cout << "Acceleration: x = " << ax + << "g y = " << ay + << "g z = " << az + << "g" << endl; + + usleep(500000); + } + +//! [Interesting] + + cout << "Exiting..." << endl; + + delete accel; + return 0; +} diff --git a/src/mma7660/CMakeLists.txt b/src/mma7660/CMakeLists.txt new file mode 100644 index 00000000..4748db55 --- /dev/null +++ b/src/mma7660/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "mma7660") +set (libdescription "upm mma7660 I2C 3-axis digital accelermeter (1.5g)") +set (module_src ${libname}.cxx) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/mma7660/jsupm_mma7660.i b/src/mma7660/jsupm_mma7660.i new file mode 100644 index 00000000..25adc073 --- /dev/null +++ b/src/mma7660/jsupm_mma7660.i @@ -0,0 +1,13 @@ +%module jsupm_mma7660 +%include "../upm.i" +%include "cpointer.i" + +/* Send "int *" and "float *" to JavaScript as intp and floatp */ +%pointer_functions(int, intp); +%pointer_functions(float, floatp); + +%{ + #include "mma7660.h" +%} + +%include "mma7660.h" diff --git a/src/mma7660/mma7660.cxx b/src/mma7660/mma7660.cxx new file mode 100644 index 00000000..723a78d6 --- /dev/null +++ b/src/mma7660/mma7660.cxx @@ -0,0 +1,249 @@ +/* + * 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 "mma7660.h" + +using namespace upm; +using namespace std; + + +MMA7660::MMA7660(int bus, uint8_t address) +{ + m_addr = address; + m_isrInstalled = false; + + // setup our i2c link + if ( !(m_i2c = mraa_i2c_init(bus)) ) + { + cerr << "MMA7660: mraa_i2c_init() failed." << endl; + return; + } + + mraa_result_t rv; + + if ( (rv = mraa_i2c_address(m_i2c, m_addr)) != MRAA_SUCCESS) + { + cerr << "MMA7660: Could not initialize i2c bus. " << endl; + mraa_result_print(rv); + return; + } +} + +MMA7660::~MMA7660() +{ + if (m_isrInstalled) + uninstallISR(); + + setModeStandby(); + mraa_i2c_stop(m_i2c); +} + +bool MMA7660::writeByte(uint8_t reg, uint8_t byte) +{ + mraa_result_t rv = mraa_i2c_write_byte_data(m_i2c, byte, reg); + + if (rv != MRAA_SUCCESS) + { + cerr << __FUNCTION__ << ": mraa_i2c_write_byte() failed." << endl; + mraa_result_print(rv); + return false; + } + + return true; +} + +uint8_t MMA7660::readByte(uint8_t reg) +{ + return mraa_i2c_read_byte_data(m_i2c, reg); +} + +void MMA7660::getRawValues(int *x, int *y, int *z) +{ + *x = getVerifiedAxis(REG_XOUT); + *y = getVerifiedAxis(REG_YOUT); + *z = getVerifiedAxis(REG_ZOUT); +} + +void MMA7660::setModeActive() +{ + uint8_t modeReg = readByte(REG_MODE); + + // The D2 (TON bit) should be cleared, and the MODE bit set + + modeReg &= ~MODE_TON; + modeReg |= MODE_MODE; + + writeByte(REG_MODE, modeReg); +} + +void MMA7660::setModeStandby() +{ + uint8_t modeReg = readByte(REG_MODE); + + // the D0 (mode bit) and D2 (TON bit) should be cleared. + + modeReg &= ~MODE_TON; + modeReg &= ~MODE_MODE; + + writeByte(REG_MODE, modeReg); +} + +// read an axis value, verifying it's validity +int MMA7660::getVerifiedAxis(MMA7660_REG_T axis) +{ + // We only want one of the 3 axes + + if (axis > 2) + { + cerr << __FUNCTION__ << ": axis must be 0, 1, or 2." << endl; + return 0; + } + + // we need to check the alert bit and sign bits if the alert bit is + // set, this means that the register was being updated when the + // register was read, so re-read until it's clear. + + uint8_t val; + do { + val = readByte(axis); + + // check alert bit + } while (val & 0x40); + + // shift the sign bit over, and compensate + return (char(val << 2) / 4); +} + +// read the tilt register, verifying it's validity +uint8_t MMA7660::getVerifiedTilt() +{ + // we need to check the alert bit and sign bits if the alert bit is + // set, this means that the register was being updated when the + // register was read, so re-read until it's clear. + + uint8_t val; + do { + val = readByte(REG_TILT); + + // check alert bit + } while (val & 0x40); + + // shift the sign bit over, and compensate + return val; +} + +uint8_t MMA7660::tiltBackFront() +{ + uint8_t val = getVerifiedTilt(); + + // mask off the bits we don't care about + val &= 0x03; + return val; +} + +uint8_t MMA7660::tiltLandscapePortrait() +{ + uint8_t val = getVerifiedTilt(); + + // mask off the bits we don't care about + val >>= 2; + val &= 0x07; + return val; +} + +bool MMA7660::tiltTap() +{ + uint8_t val = getVerifiedTilt(); + + if (val & 0x20) + return true; + else + return false; +} + +bool MMA7660::tiltShake() +{ + uint8_t val = getVerifiedTilt(); + + if (val & 0x80) + return true; + else + return false; +} + +void MMA7660::installISR(int pin, void (*isr)(void *), void *arg) +{ + if (m_isrInstalled) + uninstallISR(); + + if ( !(m_gpio = mraa_gpio_init(pin)) ) + { + cerr << __FUNCTION__ << ": mraa_gpio_init() failed" << endl; + return; + } + + mraa_gpio_dir(m_gpio, MRAA_GPIO_IN); + + // install our interrupt handler + mraa_gpio_isr(m_gpio, MRAA_GPIO_EDGE_RISING, + isr, arg); + m_isrInstalled = true; +} + +void MMA7660::uninstallISR() +{ + if (!m_isrInstalled) + return; + + mraa_gpio_isr_exit(m_gpio); + m_isrInstalled = false; + mraa_gpio_close(m_gpio); +} + +bool MMA7660::setInterruptBits(uint8_t ibits) +{ + return writeByte(REG_INTSU, ibits); +} + +bool MMA7660::setSampleRate(MMA7660_AUTOSLEEP_T sr) +{ + return writeByte(REG_SR, sr); +} + +void MMA7660::getAcceleration(float *ax, float *ay, float *az) +{ + int x, y, z; + + getRawValues(&x, &y, &z); + + // 21.33, typical counts/g + + *ax = x/21.33; + *ay = y/21.33; + *az = z/21.33; +} + diff --git a/src/mma7660/mma7660.h b/src/mma7660/mma7660.h new file mode 100644 index 00000000..0c73d84f --- /dev/null +++ b/src/mma7660/mma7660.h @@ -0,0 +1,273 @@ +/* + * 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 + +#define MMA7660_I2C_BUS 0 +#define MMA7660_DEFAULT_I2C_ADDR 0x4c + +namespace upm { + + /** + * @brief C++ API for the MMA7660 I2C 3-axis digital accelerometer + * + * UPM module for the MMA7660 I2C 3-axis digital accelerometer. + * This device supports a variety of capabilities, including the + * generation of interrupts for various conditions, tilt and basic + * gesture detection, and of course X/Y/Z measurements of g-forces + * being applied (up to 1.5g). + * + * This module was tested with the Grove 3-Axis Digital + * Accelerometer (1.5g) + * + * @ingroup i2c gpio mma7660 + * @snippet mma7660.cxx Interesting + */ + class MMA7660 { + public: + + // MMA7660 registers + typedef enum { REG_XOUT = 0x00, + REG_YOUT = 0x01, + REG_ZOUT = 0x02, + REG_TILT = 0x03, + REG_SRST = 0x04, // Sampling Rate Status + REG_SPCNT = 0x05, // sleep count + REG_INTSU = 0x06, // Interrupt setup + REG_MODE = 0x07, // operating mode + REG_SR = 0x08, // auto wake/sleep, SPS and debounce + REG_PDET = 0x09, // tap detection + REG_PD = 0x0a // tap debounce count + // 0x0b-0x1f reserved + } MMA7660_REG_T; + + // interrupt enable register bits + typedef enum { INTR_NONE = 0x00, // disabled + INTR_FBINT = 0x01, // front/back + INTR_PLINT = 0x02, // up/down/right/left + INTR_PDINT = 0x04, // tap detection + INTR_ASINT = 0x08, // exit autosleep + INTR_GINT = 0x10, // measurement intr + INTR_SHINTZ = 0x20, // shake on Z + INTR_SHINTY = 0x40, // shake on Y + INTR_SHINTX = 0x80 // shake on X + } MMA7660_INTR_T; + + // operating mode register bits + typedef enum { MODE_MODE = 0x01, // determines mode with MODE_TON + // 0x02 reserved + MODE_TON = 0x04, // determines mode with MODE_MODE + MODE_AWE = 0x08, // auto-wake + MODE_ASE = 0x10, // auto-sleep + MODE_SCPS = 0x20, // sleep count pre-scale + MODE_IPP = 0x40, // intr out push-pull/open drain + MODE_IAH = 0x80 // intr active low/high + } MMA7660_MODE_T; + + // tilt BackFront (BF) bits + typedef enum { BF_UNKNOWN = 0x00, + BF_LYING_FRONT = 0x01, + BF_LYING_BACK = 0x02 + } MMA7660_TILT_BF_T; + + // tilt LandscapePortrait (LP) bits + typedef enum { LP_UNKNOWN = 0x00, + LP_LANDSCAPE_LEFT = 0x01, + LP_LANDSCAPE_RIGHT = 0x02, + LP_VERT_DOWN = 0x05, + LP_VERT_UP = 0x06 + } MMA7660_TILT_LP_T; + + // sample rate (auto sleep) values + typedef enum { AUTOSLEEP_120 = 0x00, + AUTOSLEEP_64 = 0x01, + AUTOSLEEP_32 = 0x02, + AUTOSLEEP_16 = 0x03, + AUTOSLEEP_8 = 0x04, + AUTOSLEEP_4 = 0x05, + AUTOSLEEP_2 = 0x06, + AUTOSLEEP_1 = 0x07 + } MMA7660_AUTOSLEEP_T; + + /** + * mma7660 constructor + * + * @param bus i2c bus to use + * @param address the address for this sensor; default is 0x55 + */ + MMA7660(int bus, uint8_t address = MMA7660_DEFAULT_I2C_ADDR); + + /** + * MMA7660 Destructor + */ + ~MMA7660(); + + /** + * Write byte value into register + * + * @param reg register location to write into + * @param byte byte to write + * @return true if successful + */ + bool writeByte(uint8_t reg, uint8_t byte); + + /** + * Read byte value from register + * + * @param reg register location to read from + * @return value at specified register + */ + uint8_t readByte(uint8_t reg); + + /** + * Read current value of conversion + * + * @param x returned x value + * @param y returned y value + * @param z returned z value + */ + void getRawValues(int *x, int *y, int *z); + + /** + * Get the computed acceleration + * + * @param ax returned computed acceleration of X axis + * @param ay returned computed acceleration of Y axis + * @param az returned computed acceleration of Z axis + */ + void getAcceleration(float *ax, float *ay, float *az); + + /** + * Read an axis, verifying it's validity. The value passed must + * be one of REG_XOUT, REG_YOUT, or REG_ZOUT. + * + * @param axis axis to read + * @return axis value + */ + int getVerifiedAxis(MMA7660_REG_T axis); + + /** + * Read the tilt register, verifying it's validity. + * + * @return tilt value + */ + uint8_t getVerifiedTilt(); + + /** + * Put the device into active mode. In active mode, register + * write are not allowed. Place the device in Standby mode before + * attempting to write registers. + * + */ + void setModeActive(); + + /** + * Put the device into Standby (power saving) mode. Note, when in + * standby mode, there will be no valid data in the registers. In + * addition, the only way to write a register is to place the + * device in standby mode. + * + */ + void setModeStandby(); + + /** + * Read tilt BackFront bits + * + * The value returned will be one of the MMA7660_TILT_BF_T values + * + * @return the bits corresponding to the BackFront tilt status + */ + uint8_t tiltBackFront(); + + /** + * Read tilt LandscapePortrait bits + * + * The value returned will be one of the MMA7660_TILT_LP_T values + * + * @return the bits corresponding to the LandscapePortrait tilt status + */ + uint8_t tiltLandscapePortrait(); + + /** + * read the tilt Tap status + * + * @return true if a tap was detected + */ + bool tiltTap(); + + /** + * read the tilt Shake status + * + * @return true if a Shake was detected + */ + bool tiltShake(); + + /** + * Install an Interrupt Service Routine (ISR) to be called when + * an interrupt occurs + * + * @param pin gpio pin to use as interrupt pin + * @param fptr function pointer to function to be called on interrupt + * @param arg pointer to an object that will be supplied as an + * argument to the ISR. + */ + void installISR(int pin, void (*isr)(void *), void *arg); + + /** + * Uninstall the previously installed Interrupt Service Routine (ISR) + * + */ + void uninstallISR(); + + /** + * Enable interrupt generation based on the passed interrupt bits. + * The bits are a bit mask of the requested MMA7660_INTR_T values. + * Note: The device must be in standby mode to set this register. + * + * @param ibits set the requested interrupt bits + * @return true if successful + */ + bool setInterruptBits(uint8_t ibits); + + /** + * Set the sampling rate of the sensor. The value supplied must + * be one of the MMA7660_AUTOSLEEP_T values. + * + * @param sr one of the MMA7660_AUTOSLEEP_T values + * @return true if successful + */ + bool setSampleRate(MMA7660_AUTOSLEEP_T sr); + + private: + bool m_isrInstalled; + mraa_i2c_context m_i2c; + mraa_gpio_context m_gpio; + uint8_t m_addr; + }; +} + + diff --git a/src/mma7660/pyupm_mma7660.i b/src/mma7660/pyupm_mma7660.i new file mode 100644 index 00000000..7eebadf6 --- /dev/null +++ b/src/mma7660/pyupm_mma7660.i @@ -0,0 +1,13 @@ +%module pyupm_mma7660 +%include "../upm.i" + +%feature("autodoc", "3"); + +#ifdef DOXYGEN +%include "mma7660_doc.i" +#endif + +%include "mma7660.h" +%{ + #include "mma7660.h" +%}