Dan Bryant
first try tap on rig
Dependencies: BLE_API PinDetect mbed-src-bmd-200
Diff: MMA845x.cpp
- Revision:
- 0:e3f0057448f0
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MMA845x.cpp Tue Jul 21 00:22:23 2015 +0000
@@ -0,0 +1,379 @@
+/**
+ * @file MMA845x.cpp
+ * @brief Device driver - MMA845X 3-axis accelerometer IC
+ * @author sam grove
+ * @version 1.0
+ * @see http://cache.freescale.com/files/sensors/doc/data_sheet/MMA8451Q.pdf
+ * @see http://cache.freescale.com/files/sensors/doc/data_sheet/MMA8452Q.pdf
+ * @see http://cache.freescale.com/files/sensors/doc/data_sheet/MMA8453Q.pdf
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MMA845x.h"
+#include "mbed.h"
+
+
+void MMA845x::disable(void)
+{
+ uint8_t reg_val = 0;
+ // Reset all registers to POR values
+ MMA845x::writeRegister(CTRL_REG2, 0xF0); //REG 0x2B
+ wait(0.05);
+ do{
+ // wait for the reset bit to clear
+ reg_val = MMA845x::readRegister(CTRL_REG2) & 0x40;
+ }while(reg_val);
+ MMA845x::writeRegister(CTRL_REG1, 0x00); //REG 0x2A 0x98 = ASLP_RATE: 6.25hz Data Rate: 50hz
+}
+
+void MMA845x::setIntMode(int intMode)
+{
+ _intMode = intMode;
+}
+
+void MMA845x::interrupt_1(void)
+{
+ //_int1_waiting = true;
+
+ uint8_t reg_int_sts;
+ uint8_t reg_sts;
+ uint8_t reg_pulse_sts;
+ uint8_t reg_motion_sts;
+ char reg_data[3][2] = { 0 };
+ int16_t values[3] = { 0 };
+ float g_values[3] = { 0 };
+ reg_int_sts = MMA845x::readRegister(INT_SOURCE); //REG 0x0C
+ if((reg_int_sts & 0x01)) //Mask register read with SRC_DRDY bit
+ {
+ printf("Int1:");
+ printf(" Data Ready");
+ reg_sts = MMA845x::readRegister(STATUS); //REG 0x00
+
+ reg_pulse_sts = MMA845x::readRegister(PULSE_SRC); //REG 0x22
+
+ reg_data[0][0] = MMA845x::readRegister(OUT_X_MSB); //REG 0x01
+ reg_data[0][1] = MMA845x::readRegister(OUT_X_LSB); //REG 0x02
+ reg_data[1][0] = MMA845x::readRegister(OUT_Y_MSB); //REG 0x03
+ reg_data[1][1] = MMA845x::readRegister(OUT_Y_LSB); //REG 0x04
+ reg_data[2][0] = MMA845x::readRegister(OUT_Z_MSB); //REG 0x05
+ reg_data[2][1] = MMA845x::readRegister(OUT_Z_LSB); //REG 0x06
+ //printf(" STATUS: 0x%02X X: %d %d Y: %d %d Z: %d %d\n\r", reg_sts, reg_data[0][0], reg_data[0][1], reg_data[1][0], reg_data[1][1], reg_data[2][0], reg_data[2][1]);
+
+ values[0] = ((reg_data[0][0] * 256) + ((unsigned short) reg_data[0][1]));
+ values[1] = ((reg_data[1][0] * 256) + ((unsigned short) reg_data[1][1]));
+ values[2] = ((reg_data[2][0] * 256) + ((unsigned short) reg_data[2][1]));
+
+ g_values[0] = ((float) values[0]) / 16384.0;
+ g_values[1] = ((float) values[1]) / 16384.0;
+ g_values[2] = ((float) values[2]) / 16384.0;
+
+ //printf(" STATUS: 0x%02X X: %d Y: %d Z: %d\n\r", reg_sts, values[0], values[1], values[2]);
+
+ if (_intMode == 1)
+ {
+ printf(" STATUS: 0x%02X X: %.3f Y: %.3f Z: %.3f", reg_sts, g_values[0], g_values[1], g_values[2]);
+ }
+ else
+ {
+ int bars = abs( values[0] / 512 );
+ printf(" X: ");
+ for( int i = 0; i < bars; i++ )
+ {
+ printf(">");
+ }
+ }
+
+ if (reg_pulse_sts & 0x10)
+ {
+ printf(" ***********************************************");
+ _callbackZAxisPulse.call();
+ if (reg_pulse_sts & 0x01)
+ {
+ printf("--------------");
+ }
+ }
+ printf("\n\r");
+ }
+ if (reg_int_sts & 0x08) //Pulse interrupt
+ {
+
+ reg_pulse_sts = MMA845x::readRegister(PULSE_SRC); //REG 0x22
+ if (reg_pulse_sts & 0x40) //Z-axis event
+ {
+
+ if (reg_pulse_sts & 0x08) //Pulse event was double pulse
+ {
+
+
+ }
+ if (reg_pulse_sts & 0x04)//Z-axis pulse direction
+ {
+
+ }
+ _callbackZAxisPulse.call();
+
+ }
+ }
+ if (reg_int_sts & 0x04) //Motion interrupt
+ {
+
+ reg_motion_sts = MMA845x::readRegister(FF_MT_SRC); //REG 0x16
+ if (reg_motion_sts & 0x02) //
+ {
+ /*
+ if (reg_motion_sts & 0x08) //
+ {
+
+
+ }
+ if (reg_motion_sts & 0x04)//
+ {
+
+ }
+ */
+ _callbackZAxisPulse.call();
+
+ }
+ }
+}
+
+ /* Call this function when a Z-axis pulse detected
+ * @param function A C function pointer
+ */
+void MMA845x::attachZAxisPulse( void (*function)(void) )
+{
+ _callbackZAxisPulse.attach( function );
+}
+
+void MMA845x::interrupt_handler(void)
+{
+
+ uint8_t reg_int_sts;
+ uint8_t reg_sts;
+ int reg_data[3] = { 0x00, 0x00, 0x00 };
+ printf("Int1:");
+ reg_int_sts = MMA845x::readRegister(INT_SOURCE); //REG 0x0C
+ if((reg_int_sts & 0x01)) //Mask register read with SRC_DRDY bit
+ {
+ printf(" Data Ready");
+ reg_sts = MMA845x::readRegister(STATUS); //REG 0x00
+ reg_data[0] = MMA845x::readRegister(OUT_X_MSB); //REG 0x01
+ reg_data[1] = MMA845x::readRegister(OUT_Y_MSB); //REG 0x03
+ reg_data[2] = MMA845x::readRegister(OUT_Z_MSB); //REG 0x05
+ printf(" STATUS: 0x%02X X: %d Y: %d Z: %d\n\r", reg_sts, reg_data[0], reg_data[1], reg_data[2]);
+ }
+}
+
+void MMA845x::init(void) const
+{
+ uint8_t reg_val = 0;
+
+ _i2c->frequency(400000);
+
+ // Reset all registers to POR values
+ MMA845x::writeRegister(CTRL_REG2, 0x40); //REG 0x2B
+ do{
+ // wait for the reset bit to clear
+ reg_val = MMA845x::readRegister(CTRL_REG2) & 0x40;
+ }while(reg_val);
+
+ // setup the registers that are common among modes
+ MMA845x::writeRegister(CTRL_REG1, 0xA0); //REG 0x2A 0x98 = ASLP_RATE: 6.25hz Data Rate: 50hz
+ MMA845x::writeRegister(CTRL_REG2, 0x18); //REG 0x2B Setup for low-power, no auto-sleep
+ MMA845x::writeRegister(CTRL_REG3, 0x00); //REG 0x2C No interrupts wake device, active low int, push-pull
+ MMA845x::writeRegister(CTRL_REG4, 0x00); //REG 0x2D
+ MMA845x::writeRegister(CTRL_REG5, 0xFD); //REG 0x2E All interrupt sources to INT1
+
+ MMA845x::writeRegister(XYZ_DATA_CFG, 0x11); //REG 0x0E HPF / scale +/-2,4,8g
+ MMA845x::writeRegister(HP_FILTER_CUTOFF, 0x00); //REG 0x0F HPF settings
+
+ return;
+}
+
+void MMA845x::enableDataReadyMode(void) const
+{
+ MMA845x::init();
+ //MMA845x::writeRegister(SYSMOD, 0x01); //REG 0x0B This register is read only
+ //MMA845x::writeRegister(INT_SOURCE, 0x01); //REG 0x0C This register is read only
+ MMA845x::writeRegister(CTRL_REG4, 0x09); //REG 0x2D Enable data ready interrupt
+
+
+
+ //MMA845x::writeRegister(CTRL_REG1, 0xA3); //REG 0x2A 0xA3 = ASLP_RATE: 6.25hz Data Rate: 50hz, Fast Read, Active mode
+
+ MMA845x::writeRegister(XYZ_DATA_CFG, 0x11); //REG 0x0E HPF / scale +/-2,4,8g - Enable HPF
+ MMA845x::writeRegister(HP_FILTER_CUTOFF, 0x10); //REG 0x0F HPF settings - HPF for pulse on, 0.25Hz cutoff for 12.5rate
+
+
+ MMA845x::writeRegister(PULSE_CFG, 0x41); //REG 0x21 Setup single pulse in x axis
+ MMA845x::writeRegister(PULSE_THSX, 0x09); //REG 0x21 Setup pulse threshold in x axis
+ MMA845x::writeRegister(PULSE_TMLT, 0x14); //REG 0x21 Setup single pulse in x axis
+ MMA845x::writeRegister(PULSE_LTCY, 0x04); //REG 0x21 Setup single latency in x axis
+
+
+ MMA845x::writeRegister(CTRL_REG1, 0xA1); //REG 0x2A 0x98 = ASLP_RATE: 6.25hz Data Rate: 12.5hz, Normal Read, Active mode
+
+}
+
+void MMA845x::enableMotionMode(void) const
+{
+ MMA845x::init();
+
+ MMA845x::writeRegister(CTRL_REG4, 0x04); //REG 0x2D Enable pulse interrupt
+
+ MMA845x::writeRegister(XYZ_DATA_CFG, 0xF1); //REG 0x0E HPF / scale +/-4g, Enable HPF for output data
+ MMA845x::writeRegister(HP_FILTER_CUTOFF, 0x00); //REG 0x0F HPF settings - HPF for pulse on, 4Hz cutoff for 100Hz rate
+
+ MMA845x::writeRegister(FF_MT_CFG, 0xC8); //REG 0x21 Setup
+ MMA845x::writeRegister(FF_MT_THS, 0x01); //REG 0x21 Setup
+ MMA845x::writeRegister(FF_MT_COUNT, 0x5); //REG 0x21 Setup
+
+ MMA845x::writeRegister(CTRL_REG2, 0x03); //REG 0x2B Setup for low power mode, no auto-sleep
+ MMA845x::writeRegister(CTRL_REG1, 0xA1); //REG 0x2A 0x98 = ASLP_RATE: 6.25hz Data Rate: 12.5Hz, Normal Read, Active mode
+
+}
+
+void MMA845x::enablePulseMode(void) const
+{
+ MMA845x::init();
+
+ MMA845x::writeRegister(CTRL_REG4, 0x08); //REG 0x2D Enable pulse interrupt
+
+ MMA845x::writeRegister(XYZ_DATA_CFG, 0xF1); //REG 0x0E HPF / scale +/-2,4,8g - Enable HPF
+ MMA845x::writeRegister(HP_FILTER_CUTOFF, 0x00); //REG 0x0F HPF settings - HPF for pulse on, 4Hz cutoff for 100Hz rate
+
+ MMA845x::writeRegister(PULSE_CFG, 0x50); //REG 0x21 Setup single pulse in z axis
+ MMA845x::writeRegister(PULSE_THSX, 0x06); //REG 0x21 Setup pulse threshold in x axis
+ MMA845x::writeRegister(PULSE_THSZ, 0x2F); //REG 0x21 Setup pulse threshold in z axis
+ MMA845x::writeRegister(PULSE_TMLT, 0x28); //REG 0x21 Setup single pulse
+ MMA845x::writeRegister(PULSE_LTCY, 0x0D); //REG 0x21 Setup single latency
+ MMA845x::writeRegister(PULSE_WIND, 0x2D); //REG 0x21 Setup double pulse window
+
+ MMA845x::writeRegister(CTRL_REG2, 0x00); //REG 0x2B Setup for normal power mode, no auto-sleep
+ MMA845x::writeRegister(CTRL_REG1, 0x99); //REG 0x2A 0x98 = ASLP_RATE: 6.25hz Data Rate: 100Hz, Normal Read, Active mode
+
+}
+
+void MMA845x::enableOrientationMode(void) const
+{
+ uint16_t who_am_i = MMA845x::readRegister(WHO_AM_I);
+ if(who_am_i != MMA8451)
+ {
+ error("%s %d: Feature not compatible with the connected device.\n", __FILE__, __LINE__);
+ }
+
+ return;
+}
+
+void MMA845x::enableTransitMode(void) const{}
+void MMA845x::enableAutoSleepMode(void) const{}
+
+void MMA845x::enableFIFOMode(void) const
+{
+ uint16_t who_am_i = MMA845x::readRegister(WHO_AM_I);
+ if(who_am_i != MMA8451)
+ {
+ error("%s %d: Feature not compatible with the connected device.\n", __FILE__, __LINE__);
+ }
+
+ //MMA845x::writeRegister(
+
+ return;
+}
+
+uint16_t MMA845x::getX(void) const
+{
+ return _data._x;
+}
+
+uint16_t MMA845x::getY(void) const
+{
+ return _data._y;
+}
+
+uint16_t MMA845x::getZ(void) const
+{
+ return _data._z;
+}
+
+MMA845x_DATA MMA845x::getXYZ(void) const
+{
+ return _data;
+}
+
+void MMA845x::writeRegister(uint8_t const reg, uint8_t const data) const
+{
+ char buf[2] = {reg, data};
+ uint8_t result = 0;
+
+ /*
+ __disable_irq(); // Tickers and other timebase events can jack up the I2C bus for some devices
+ result = _i2c->write(_i2c_addr, buf, 2);
+ __enable_irq(); // Just need to block during the transaction
+ */
+
+ result = _i2c->write(_i2c_addr, (const char *)&buf, 2, false);
+
+ if(0 != result)
+ {
+ error("%s %d: I2c write failed\n", __FILE__, __LINE__);
+ }
+
+ return;
+}
+
+uint8_t MMA845x::readRegister(uint8_t const reg) const
+{
+ uint8_t result = 1, data = 0;
+ /*
+ __disable_irq(); // Tickers and other timebase events can jack up the I2C bus
+ _i2c->start();
+ result &= _i2c->write(_i2c_addr);
+ result &= _i2c->write(reg);
+ // issue a repeated start...
+ _i2c->start();
+ result &= _i2c->write(_i2c_addr | 0x01);
+ // read with nak
+ data = _i2c->read(0);
+ _i2c->stop();
+ __enable_irq(); // Just need to block during the transaction
+ */
+
+ result &= _i2c->write(_i2c_addr, (const char *)®, 1, true);
+ result &= _i2c->read(_i2c_addr, (char *)&data, 1);
+
+ if(1 != result)
+ {
+ //error("%s %d: I2C read failed\n", __FILE__, __LINE__);
+ }
+
+ return data;
+}
+
+void MMA845x::registerDump(void) const
+{
+ uint8_t reg_val = 0;
+ printf("Starting register dump...\n\r");
+
+ for(int i=0; i<0x31; i++)
+ {
+ reg_val = MMA845x::readRegister(i);
+ printf("Reg 0x%02x: 0x%02x \n\r", i, reg_val);
+ }
+
+ return;
+}
+