Michel2/ESPEasy
1
0
Fork 0
mirror of https://github.com/letscontrolit/ESPEasy.git synced 2026-09-12 17:45:49 +00:00
Code Issues Releases Activity
Files
8d0f0dc35fcdf4cf1b0724c404fcb3704cbe4dfa
ESPEasy/lib/SparkFun_ADXL345_Arduino_Library/src/SparkFun_ADXL345.cpp
T

929 lines
25 KiB
C++
Raw Blame History

/*
Sparkfun's ADXL345 Library Main Source File
SparkFun_ADXL345.cpp
E.Robert @ SparkFun Electronics
Created: Jul 13, 2016
Updated: Sep 06, 2016
Modified Bildr ADXL345 Source File @ http://code.bildr.org/download/959.zip
to support both I2C and SPI Communication
Hardware Resources:
- Arduino Development Board
- SparkFun Triple Access Accelerometer ADXL345
Development Environment Specifics:
Arduino 1.6.8
SparkFun Triple Axis Accelerometer Breakout - ADXL345
Arduino Uno
*/
#include "Arduino.h"
#include "SparkFun_ADXL345.h"
#include <Wire.h>
#include <SPI.h>
#define ADXL345_DEVICE_DEFAULT (0x53) // Device Address for ADXL345
#define ADXL345_DEVICE (_i2c_addr) // Device Address for ADXL345
#define ADXL345_TO_READ (6) // Number of Bytes Read - Two Bytes Per Axis
ADXL345::ADXL345(uint8_t i2c_addr = ADXL345_DEVICE_DEFAULT) : _i2c_addr(i2c_addr) {
status = ADXL345_OK;
error_code = ADXL345_NO_ERROR;
gains[0] = 0.00376390; // Original gain 0.00376390
gains[1] = 0.00376009; // Original gain 0.00376009
gains[2] = 0.00349265; // Original gain 0.00349265
I2C = true;
}
ADXL345::ADXL345(int CS) {
status = ADXL345_OK;
error_code = ADXL345_NO_ERROR;
gains[0] = 0.00376390;
gains[1] = 0.00376009;
gains[2] = 0.00349265;
_CS = CS;
I2C = false;
// tonhuisman: disabled as SPI is already initialized in ESPEasy core.
// SPI.begin();
// SPI.setDataMode(SPI_MODE3);
pinMode(_CS, OUTPUT);
digitalWrite(_CS, HIGH);
}
void ADXL345::powerOn() {
if (I2C) {
Wire.begin(); // If in I2C Mode Only
}
// ADXL345 TURN ON
writeTo(ADXL345_POWER_CTL, 0); // Wakeup
writeTo(ADXL345_POWER_CTL, 16); // Auto_Sleep
writeTo(ADXL345_POWER_CTL, 8); // Measure
}
void ADXL345::powerOff() {
byte _b;
readFrom(ADXL345_POWER_CTL, 1, &_b);
_b &= ~(0b00001000); // Measure bit
writeTo(ADXL345_POWER_CTL, _b);
}
int ADXL345::getDevID() {
byte _b;
readFrom(ADXL345_DEVID, 1, &_b);
return int(_b);
}
/*********************** READING ACCELERATION ***********************/
/* Reads Acceleration into Three Variables: x, y and z */
void ADXL345::readAccel(int *xyz) {
readAccel(xyz, xyz + 1, xyz + 2);
}
void ADXL345::readAccel(int *x, int *y, int *z) {
readFrom(ADXL345_DATAX0, ADXL345_TO_READ, _buff); // Read Accel Data from ADXL345
// Each Axis @ All g Ranges: 10 Bit Resolution (2 Bytes)
*x = (int16_t)((((int)_buff[1]) << 8) | _buff[0]);
*y = (int16_t)((((int)_buff[3]) << 8) | _buff[2]);
*z = (int16_t)((((int)_buff[5]) << 8) | _buff[4]);
}
void ADXL345::get_Gxyz(double *xyz) {
int i;
int xyz_int[3];
readAccel(xyz_int);
for (i = 0; i < 3; i++) {
xyz[i] = xyz_int[i] * gains[i];
}
}
/***************** WRITES VALUE TO ADDRESS REGISTER *****************/
void ADXL345::writeTo(byte address, byte val) {
if (I2C) {
writeToI2C(address, val);
}
else {
writeToSPI(address, val);
}
}
/************************ READING NUM BYTES *************************/
/* Reads Num Bytes. Starts from Address Reg to _buff Array */
void ADXL345::readFrom(byte address, int num, byte _buff[]) {
if (I2C) {
readFromI2C(address, num, _buff); // If I2C Communication
}
else {
readFromSPI(address, num, _buff); // If SPI Communication
}
}
/*************************** WRITE TO I2C ***************************/
/* Start; Send Register Address; Send Value To Write; End */
void ADXL345::writeToI2C(byte _address, byte _val) {
Wire.beginTransmission(ADXL345_DEVICE);
Wire.write(_address);
Wire.write(_val);
Wire.endTransmission();
}
/*************************** READ FROM I2C **************************/
/* Start; Send Address To Read; End */
void ADXL345::readFromI2C(byte address, int num, byte _buff[]) {
Wire.beginTransmission(ADXL345_DEVICE);
Wire.write(address);
Wire.endTransmission();
// Wire.beginTransmission(ADXL345_DEVICE);
// Wire.reqeustFrom contains the beginTransmission and endTransmission in it.
Wire.requestFrom(ADXL345_DEVICE, (uint8_t)num); // Request num Bytes
int i = 0;
while (Wire.available())
{
_buff[i] = Wire.read(); // Receive Byte
i++;
}
if (i != num) {
status = ADXL345_ERROR;
error_code = ADXL345_READ_ERROR;
}
// Wire.endTransmission();
}
/************************** WRITE FROM SPI **************************/
/* Point to Destination; Write Value; Turn Off */
void ADXL345::writeToSPI(byte __reg_address, byte __val) {
digitalWrite(_CS, LOW);
SPI.transfer(__reg_address);
SPI.transfer(__val);
digitalWrite(_CS, HIGH);
}
/*************************** READ FROM SPI **************************/
/* */
void ADXL345::readFromSPI(byte __reg_address, int num, byte _buff[]) {
// Read: Most Sig Bit of Reg Address Set
char _address = 0x80 | __reg_address;
// If Multi-Byte Read: Bit 6 Set
if (num > 1) {
_address = _address | 0x40;
}
digitalWrite(_CS, LOW);
SPI.transfer(_address); // Transfer Starting Reg Address To Be Read
for (int i = 0; i < num; i++) {
_buff[i] = SPI.transfer(0x00);
}
digitalWrite(_CS, HIGH);
}
/*************************** RANGE SETTING **************************/
/* ACCEPTABLE VALUES: 2g, 4g, 8g, 16g ~ GET & SET */
void ADXL345::getRangeSetting(byte *rangeSetting) {
byte _b;
readFrom(ADXL345_DATA_FORMAT, 1, &_b);
*rangeSetting = _b & 0b00000011;
}
void ADXL345::setRangeSetting(int val) {
byte _s;
byte _b;
switch (val) {
case 2:
_s = 0b00000000;
break;
case 4:
_s = 0b00000001;
break;
case 8:
_s = 0b00000010;
break;
case 16:
_s = 0b00000011;
break;
default:
_s = 0b00000000;
}
readFrom(ADXL345_DATA_FORMAT, 1, &_b);
_s |= (_b & 0b11101100);
writeTo(ADXL345_DATA_FORMAT, _s);
}
/*************************** SELF_TEST BIT **************************/
/* ~ GET & SET */
bool ADXL345::getSelfTestBit() {
return getRegisterBit(ADXL345_DATA_FORMAT, 7);
}
// If Set (1) Self-Test Applied. Electrostatic Force exerted on the sensor
// causing a shift in the output data.
// If Set (0) Self-Test Disabled.
void ADXL345::setSelfTestBit(bool selfTestBit) {
setRegisterBit(ADXL345_DATA_FORMAT, 7, selfTestBit);
}
/*************************** SPI BIT STATE **************************/
/* ~ GET & SET */
bool ADXL345::getSpiBit() {
return getRegisterBit(ADXL345_DATA_FORMAT, 6);
}
// If Set (1) Puts Device in 3-wire Mode
// If Set (0) Puts Device in 4-wire SPI Mode
void ADXL345::setSpiBit(bool spiBit) {
setRegisterBit(ADXL345_DATA_FORMAT, 6, spiBit);
}
/*********************** INT_INVERT BIT STATE ***********************/
/* ~ GET & SET */
bool ADXL345::getInterruptLevelBit() {
return getRegisterBit(ADXL345_DATA_FORMAT, 5);
}
// If Set (0) Sets the Interrupts to Active HIGH
// If Set (1) Sets the Interrupts to Active LOW
void ADXL345::setInterruptLevelBit(bool interruptLevelBit) {
setRegisterBit(ADXL345_DATA_FORMAT, 5, interruptLevelBit);
}
/************************* FULL_RES BIT STATE ***********************/
/* ~ GET & SET */
bool ADXL345::getFullResBit() {
return getRegisterBit(ADXL345_DATA_FORMAT, 3);
}
// If Set (1) Device is in Full Resolution Mode: Output Resolution Increase with G Range
// Set by the Range Bits to Maintain a 4mg/LSB Scale Factor
// If Set (0) Device is in 10-bit Mode: Range Bits Determine Maximum G Range
// And Scale Factor
void ADXL345::setFullResBit(bool fullResBit) {
setRegisterBit(ADXL345_DATA_FORMAT, 3, fullResBit);
}
/*************************** JUSTIFY BIT STATE **************************/
/* ~ GET & SET */
bool ADXL345::getJustifyBit() {
return getRegisterBit(ADXL345_DATA_FORMAT, 2);
}
// If Set (1) Selects the Left Justified Mode
// If Set (0) Selects Right Justified Mode with Sign Extension
void ADXL345::setJustifyBit(bool justifyBit) {
setRegisterBit(ADXL345_DATA_FORMAT, 2, justifyBit);
}
/*********************** THRESH_TAP BYTE VALUE **********************/
/* ~ SET & GET */
// Should Set Between 0 and 255
// Scale Factor is 62.5 mg/LSB
// A Value of 0 May Result in Undesirable Behavior
void ADXL345::setTapThreshold(int tapThreshold) {
tapThreshold = constrain(tapThreshold, 0, 255);
byte _b = byte(tapThreshold);
writeTo(ADXL345_THRESH_TAP, _b);
}
// Return Value Between 0 and 255
// Scale Factor is 62.5 mg/LSB
int ADXL345::getTapThreshold() {
byte _b;
readFrom(ADXL345_THRESH_TAP, 1, &_b);
return int(_b);
}
/****************** GAIN FOR EACH AXIS IN Gs / COUNT *****************/
/* ~ SET & GET */
void ADXL345::setAxisGains(double *_gains) {
int i;
for (i = 0; i < 3; i++) {
gains[i] = _gains[i];
}
}
void ADXL345::getAxisGains(double *_gains) {
int i;
for (i = 0; i < 3; i++) {
_gains[i] = gains[i];
}
}
/********************* OFSX, OFSY and OFSZ BYTES ********************/
/* ~ SET & GET */
// OFSX, OFSY and OFSZ: User Offset Adjustments in Twos Complement Format
// Scale Factor of 15.6mg/LSB
void ADXL345::setAxisOffset(int x, int y, int z) {
writeTo(ADXL345_OFSX, byte(x));
writeTo(ADXL345_OFSY, byte(y));
writeTo(ADXL345_OFSZ, byte(z));
}
void ADXL345::getAxisOffset(int *x, int *y, int *z) {
byte _b;
readFrom(ADXL345_OFSX, 1, &_b);
*x = int(_b);
readFrom(ADXL345_OFSY, 1, &_b);
*y = int(_b);
readFrom(ADXL345_OFSZ, 1, &_b);
*z = int(_b);
}
/****************************** DUR BYTE ****************************/
/* ~ SET & GET */
// DUR Byte: Contains an Unsigned Time Value Representing the Max Time
// that an Event must be Above the THRESH_TAP Threshold to qualify
// as a Tap Event
// The scale factor is 625µs/LSB
// Value of 0 Disables the Tap/Double Tap Funcitons. Max value is 255.
void ADXL345::setTapDuration(int tapDuration) {
tapDuration = constrain(tapDuration, 0, 255);
byte _b = byte(tapDuration);
writeTo(ADXL345_DUR, _b);
}
int ADXL345::getTapDuration() {
byte _b;
readFrom(ADXL345_DUR, 1, &_b);
return int(_b);
}
/************************** LATENT REGISTER *************************/
/* ~ SET & GET */
// Contains Unsigned Time Value Representing the Wait Time from the Detection
// of a Tap Event to the Start of the Time Window (defined by the Window
// Register) during which a possible Second Tap Even can be Detected.
// Scale Factor is 1.25ms/LSB.
// A Value of 0 Disables the Double Tap Function.
// It Accepts a Maximum Value of 255.
void ADXL345::setDoubleTapLatency(int doubleTapLatency) {
byte _b = byte(doubleTapLatency);
writeTo(ADXL345_LATENT, _b);
}
int ADXL345::getDoubleTapLatency() {
byte _b;
readFrom(ADXL345_LATENT, 1, &_b);
return int(_b);
}
/************************** WINDOW REGISTER *************************/
/* ~ SET & GET */
// Contains an Unsigned Time Value Representing the Amount of Time
// After the Expiration of the Latency Time (determined by Latent register)
// During which a Second Valid Tape can Begin.
// Scale Factor is 1.25ms/LSB.
// Value of 0 Disables the Double Tap Function.
// It Accepts a Maximum Value of 255.
void ADXL345::setDoubleTapWindow(int doubleTapWindow) {
doubleTapWindow = constrain(doubleTapWindow, 0, 255);
byte _b = byte(doubleTapWindow);
writeTo(ADXL345_WINDOW, _b);
}
int ADXL345::getDoubleTapWindow() {
byte _b;
readFrom(ADXL345_WINDOW, 1, &_b);
return int(_b);
}
/*********************** THRESH_ACT REGISTER ************************/
/* ~ SET & GET */
// Holds the Threshold Value for Detecting Activity.
// Data Format is Unsigned, so the Magnitude of the Activity Event is Compared
// with the Value is Compared with the Value in the THRESH_ACT Register.
// The Scale Factor is 62.5mg/LSB.
// Value of 0 may Result in Undesirable Behavior if the Activity Interrupt Enabled.
// It Accepts a Maximum Value of 255.
void ADXL345::setActivityThreshold(int activityThreshold) {
activityThreshold = constrain(activityThreshold, 0, 255);
byte _b = byte(activityThreshold);
writeTo(ADXL345_THRESH_ACT, _b);
}
// Gets the THRESH_ACT byte
int ADXL345::getActivityThreshold() {
byte _b;
readFrom(ADXL345_THRESH_ACT, 1, &_b);
return int(_b);
}
/********************** THRESH_INACT REGISTER ***********************/
/* ~ SET & GET */
// Holds the Threshold Value for Detecting Inactivity.
// The Data Format is Unsigned, so the Magnitude of the INactivity Event is
// Compared with the value in the THRESH_INACT Register.
// Scale Factor is 62.5mg/LSB.
// Value of 0 May Result in Undesirable Behavior if the Inactivity Interrupt Enabled.
// It Accepts a Maximum Value of 255.
void ADXL345::setInactivityThreshold(int inactivityThreshold) {
inactivityThreshold = constrain(inactivityThreshold, 0, 255);
byte _b = byte(inactivityThreshold);
writeTo(ADXL345_THRESH_INACT, _b);
}
int ADXL345::getInactivityThreshold() {
byte _b;
readFrom(ADXL345_THRESH_INACT, 1, &_b);
return int(_b);
}
/*********************** TIME_INACT RESIGER *************************/
/* ~ SET & GET */
// Contains an Unsigned Time Value Representing the Amount of Time that
// Acceleration must be Less Than the Value in the THRESH_INACT Register
// for Inactivity to be Declared.
// Uses Filtered Output Data* unlike other Interrupt Functions
// Scale Factor is 1sec/LSB.
// Value Must Be Between 0 and 255.
void ADXL345::setTimeInactivity(int timeInactivity) {
timeInactivity = constrain(timeInactivity, 0, 255);
byte _b = byte(timeInactivity);
writeTo(ADXL345_TIME_INACT, _b);
}
int ADXL345::getTimeInactivity() {
byte _b;
readFrom(ADXL345_TIME_INACT, 1, &_b);
return int(_b);
}
/*********************** THRESH_FF Register *************************/
/* ~ SET & GET */
// Holds the Threshold Value, in Unsigned Format, for Free-Fall Detection
// The Acceleration on all Axes is Compared with the Value in THRES_FF to
// Determine if a Free-Fall Event Occurred.
// Scale Factor is 62.5mg/LSB.
// Value of 0 May Result in Undesirable Behavior if the Free-Fall interrupt Enabled.
// Accepts a Maximum Value of 255.
void ADXL345::setFreeFallThreshold(int freeFallThreshold) {
freeFallThreshold = constrain(freeFallThreshold, 0, 255);
byte _b = byte(freeFallThreshold);
writeTo(ADXL345_THRESH_FF, _b);
}
int ADXL345::getFreeFallThreshold() {
byte _b;
readFrom(ADXL345_THRESH_FF, 1, &_b);
return int(_b);
}
/************************ TIME_FF Register **************************/
/* ~ SET & GET */
// Stores an Unsigned Time Value Representing the Minimum Time that the Value
// of all Axes must be Less Than THRES_FF to Generate a Free-Fall Interrupt.
// Scale Factor is 5ms/LSB.
// Value of 0 May Result in Undesirable Behavior if the Free-Fall Interrupt Enabled.
// Accepts a Maximum Value of 255.
void ADXL345::setFreeFallDuration(int freeFallDuration) {
freeFallDuration = constrain(freeFallDuration, 0, 255);
byte _b = byte(freeFallDuration);
writeTo(ADXL345_TIME_FF, _b);
}
int ADXL345::getFreeFallDuration() {
byte _b;
readFrom(ADXL345_TIME_FF, 1, &_b);
return int(_b);
}
/************************** ACTIVITY BITS ***************************/
/* */
bool ADXL345::isActivityXEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 6);
}
bool ADXL345::isActivityYEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 5);
}
bool ADXL345::isActivityZEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 4);
}
bool ADXL345::isInactivityXEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 2);
}
bool ADXL345::isInactivityYEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 1);
}
bool ADXL345::isInactivityZEnabled() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 0);
}
void ADXL345::setActivityX(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 6, state);
}
void ADXL345::setActivityY(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 5, state);
}
void ADXL345::setActivityZ(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 4, state);
}
void ADXL345::setActivityXYZ(bool stateX, bool stateY, bool stateZ) {
setActivityX(stateX);
setActivityY(stateY);
setActivityZ(stateZ);
}
void ADXL345::setInactivityX(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 2, state);
}
void ADXL345::setInactivityY(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 1, state);
}
void ADXL345::setInactivityZ(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 0, state);
}
void ADXL345::setInactivityXYZ(bool stateX, bool stateY, bool stateZ) {
setInactivityX(stateX);
setInactivityY(stateY);
setInactivityZ(stateZ);
}
bool ADXL345::isActivityAc() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 7);
}
bool ADXL345::isInactivityAc() {
return getRegisterBit(ADXL345_ACT_INACT_CTL, 3);
}
void ADXL345::setActivityAc(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 7, state);
}
void ADXL345::setInactivityAc(bool state) {
setRegisterBit(ADXL345_ACT_INACT_CTL, 3, state);
}
/************************* SUPPRESS BITS ****************************/
/* */
bool ADXL345::getSuppressBit() {
return getRegisterBit(ADXL345_TAP_AXES, 3);
}
void ADXL345::setSuppressBit(bool state) {
setRegisterBit(ADXL345_TAP_AXES, 3, state);
}
/**************************** TAP BITS ******************************/
/* */
bool ADXL345::isTapDetectionOnX() {
return getRegisterBit(ADXL345_TAP_AXES, 2);
}
void ADXL345::setTapDetectionOnX(bool state) {
setRegisterBit(ADXL345_TAP_AXES, 2, state);
}
bool ADXL345::isTapDetectionOnY() {
return getRegisterBit(ADXL345_TAP_AXES, 1);
}
void ADXL345::setTapDetectionOnY(bool state) {
setRegisterBit(ADXL345_TAP_AXES, 1, state);
}
bool ADXL345::isTapDetectionOnZ() {
return getRegisterBit(ADXL345_TAP_AXES, 0);
}
void ADXL345::setTapDetectionOnZ(bool state) {
setRegisterBit(ADXL345_TAP_AXES, 0, state);
}
void ADXL345::setTapDetectionOnXYZ(bool stateX, bool stateY, bool stateZ) {
setTapDetectionOnX(stateX);
setTapDetectionOnY(stateY);
setTapDetectionOnZ(stateZ);
}
bool ADXL345::isActivitySourceOnX() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 6);
}
bool ADXL345::isActivitySourceOnY() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 5);
}
bool ADXL345::isActivitySourceOnZ() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 4);
}
bool ADXL345::isTapSourceOnX() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 2);
}
bool ADXL345::isTapSourceOnY() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 1);
}
bool ADXL345::isTapSourceOnZ() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 0);
}
/*************************** ASLEEP BIT *****************************/
/* */
bool ADXL345::isAsleep() {
return getRegisterBit(ADXL345_ACT_TAP_STATUS, 3);
}
/************************** LOW POWER BIT ***************************/
/* */
bool ADXL345::isLowPower() {
return getRegisterBit(ADXL345_BW_RATE, 4);
}
void ADXL345::setLowPower(bool state) {
setRegisterBit(ADXL345_BW_RATE, 4, state);
}
/*************************** RATE BITS ******************************/
/* */
double ADXL345::getRate() {
byte _b;
readFrom(ADXL345_BW_RATE, 1, &_b);
_b &= 0b00001111;
return (pow(2, ((int)_b) - 6)) * 6.25;
}
void ADXL345::setRate(double rate) {
byte _b, _s;
int v = (int)(rate / 6.25);
int r = 0;
while (v >>= 1)
{
r++;
}
if (r <= 9) {
readFrom(ADXL345_BW_RATE, 1, &_b);
_s = (byte)(r + 6) | (_b & 0b11110000);
writeTo(ADXL345_BW_RATE, _s);
}
}
/*************************** BANDWIDTH ******************************/
/* ~ SET & GET */
void ADXL345::set_bw(byte bw_code) {
if ((bw_code < ADXL345_BW_0_05) || (bw_code > ADXL345_BW_1600)) {
status = false;
error_code = ADXL345_BAD_ARG;
}
else {
writeTo(ADXL345_BW_RATE, bw_code);
}
}
byte ADXL345::get_bw_code() {
byte bw_code;
readFrom(ADXL345_BW_RATE, 1, &bw_code);
return bw_code;
}
/************************* TRIGGER CHECK ***************************/
/* */
// Check if Action was Triggered in Interrupts
// Example triggered(interrupts, ADXL345_SINGLE_TAP);
bool ADXL345::triggered(byte interrupts, int mask) {
return (interrupts >> mask) & 1;
}
/*
ADXL345_DATA_READY
ADXL345_SINGLE_TAP
ADXL345_DOUBLE_TAP
ADXL345_ACTIVITY
ADXL345_INACTIVITY
ADXL345_FREE_FALL
ADXL345_WATERMARK
ADXL345_OVERRUNY
*/
byte ADXL345::getInterruptSource() {
byte _b;
readFrom(ADXL345_INT_SOURCE, 1, &_b);
return _b;
}
bool ADXL345::getInterruptSource(byte interruptBit) {
return getRegisterBit(ADXL345_INT_SOURCE, interruptBit);
}
bool ADXL345::getInterruptMapping(byte interruptBit) {
return getRegisterBit(ADXL345_INT_MAP, interruptBit);
}
/*********************** INTERRUPT MAPPING **************************/
/* Set the Mapping of an Interrupt to pin1 or pin2 */
// eg: setInterruptMapping(ADXL345_INT_DOUBLE_TAP_BIT,ADXL345_INT2_PIN);
void ADXL345::setInterruptMapping(byte interruptBit, bool interruptPin) {
setRegisterBit(ADXL345_INT_MAP, interruptBit, interruptPin);
}
void ADXL345::setImportantInterruptMapping(int single_tap, int double_tap, int free_fall, int activity, int inactivity) {
if (single_tap == 1) {
setInterruptMapping(ADXL345_INT_SINGLE_TAP_BIT, ADXL345_INT1_PIN);
}
else if (single_tap == 2) {
setInterruptMapping(ADXL345_INT_SINGLE_TAP_BIT, ADXL345_INT2_PIN);
}
if (double_tap == 1) {
setInterruptMapping(ADXL345_INT_DOUBLE_TAP_BIT, ADXL345_INT1_PIN);
}
else if (double_tap == 2) {
setInterruptMapping(ADXL345_INT_DOUBLE_TAP_BIT, ADXL345_INT2_PIN);
}
if (free_fall == 1) {
setInterruptMapping(ADXL345_INT_FREE_FALL_BIT, ADXL345_INT1_PIN);
}
else if (free_fall == 2) {
setInterruptMapping(ADXL345_INT_FREE_FALL_BIT, ADXL345_INT2_PIN);
}
if (activity == 1) {
setInterruptMapping(ADXL345_INT_ACTIVITY_BIT, ADXL345_INT1_PIN);
}
else if (activity == 2) {
setInterruptMapping(ADXL345_INT_ACTIVITY_BIT, ADXL345_INT2_PIN);
}
if (inactivity == 1) {
setInterruptMapping(ADXL345_INT_INACTIVITY_BIT, ADXL345_INT1_PIN);
}
else if (inactivity == 2) {
setInterruptMapping(ADXL345_INT_INACTIVITY_BIT, ADXL345_INT2_PIN);
}
}
bool ADXL345::isInterruptEnabled(byte interruptBit) {
return getRegisterBit(ADXL345_INT_ENABLE, interruptBit);
}
void ADXL345::setInterrupt(byte interruptBit, bool state) {
setRegisterBit(ADXL345_INT_ENABLE, interruptBit, state);
}
void ADXL345::singleTapINT(bool status) {
if (status) {
setInterrupt(ADXL345_INT_SINGLE_TAP_BIT, 1);
}
else {
setInterrupt(ADXL345_INT_SINGLE_TAP_BIT, 0);
}
}
void ADXL345::doubleTapINT(bool status) {
if (status) {
setInterrupt(ADXL345_INT_DOUBLE_TAP_BIT, 1);
}
else {
setInterrupt(ADXL345_INT_DOUBLE_TAP_BIT, 0);
}
}
void ADXL345::FreeFallINT(bool status) {
if (status) {
setInterrupt(ADXL345_INT_FREE_FALL_BIT, 1);
}
else {
setInterrupt(ADXL345_INT_FREE_FALL_BIT, 0);
}
}
void ADXL345::ActivityINT(bool status) {
if (status) {
setInterrupt(ADXL345_INT_ACTIVITY_BIT, 1);
}
else {
setInterrupt(ADXL345_INT_ACTIVITY_BIT, 0);
}
}
void ADXL345::InactivityINT(bool status) {
if (status) {
setInterrupt(ADXL345_INT_INACTIVITY_BIT, 1);
}
else {
setInterrupt(ADXL345_INT_INACTIVITY_BIT, 0);
}
}
void ADXL345::setRegisterBit(byte regAdress, int bitPos, bool state) {
byte _b;
readFrom(regAdress, 1, &_b);
if (state) {
_b |= (1 << bitPos); // Forces nth Bit of _b to 1. Other Bits Unchanged.
}
else {
_b &= ~(1 << bitPos); // Forces nth Bit of _b to 0. Other Bits Unchanged.
}
writeTo(regAdress, _b);
}
bool ADXL345::getRegisterBit(byte regAdress, int bitPos) {
byte _b;
readFrom(regAdress, 1, &_b);
return (_b >> bitPos) & 1;
}
/********************************************************************/
/* */
// Print Register Values to Serial Output =
// Can be used to Manually Check the Current Configuration of Device
void ADXL345::printAllRegister() {
byte _b;
Serial.print("0x00: ");
readFrom(0x00, 1, &_b);
print_byte(_b);
Serial.println("");
int i;
for (i = 29; i <= 57; i++) {
Serial.print("0x");
Serial.print(i, HEX);
Serial.print(": ");
readFrom(i, 1, &_b);
print_byte(_b);
Serial.println("");
}
}
void print_byte(byte val) {
int i;
Serial.print("B");
for (i = 7; i >= 0; i--) {
Serial.print(val >> i & 1, BIN);
}
}
View Git Blame Copy Permalink