mirror of
https://github.com/letscontrolit/ESPEasy.git
synced 2026-07-28 04:07:47 +00:00
[P120] Add Sparkfun ADXL345 library to enable secondary I2C address
This commit is contained in:
Ton Huisman
@@ -0,0 +1,60 @@
|
||||
# ADXL345
|
||||
Sparkfun's I2C/SPI Arduino Library for ADXL345
|
||||
|
||||
Using this Arduino Library, you have the option of using either SPI or I2C to communicate with the ADXL345.
|
||||
|
||||
It is fairly reasonable to use and straight forward.
|
||||
|
||||
You will also be able to calibrate the ADXL345 whenever necessary as shown in the example.
|
||||
|
||||
SparkFun ADXL345 Arduino Library
|
||||
========================================
|
||||
|
||||
[](https://www.sparkfun.com/products/9836)
|
||||
|
||||
[*SparkFun Triple Axis Accelerometer Breakout - ADXL345*](https://www.sparkfun.com/products/9836)
|
||||
|
||||
The ADXL345 is a small, thin, low power, 3-axis MEMS accelerometer with high resolution (13-bit) measurement at up to +-16 g. Digital output data is formatted as 16-bit twos complement and is accessible through either a SPI (3- or 4-wire) or I2C digital interface.
|
||||
|
||||
The ADXL345 is well suited to measures the static acceleration of gravity in tilt-sensing applications, as well as dynamic acceleration resulting from motion or shock. Its high resolution (4 mg/LSB) enables measurement of inclination changes less than 1.0 degrees.
|
||||
|
||||
This Arduino library allows for both SPI or I2C communication. It also gives the user the ability to explore the following customizable features: tap/double tap detection, acvitivty/inactivity monitoring, and free fall detection.
|
||||
|
||||
Repository Contents
|
||||
-------------------
|
||||
|
||||
* **/examples** - Example sketches for the library (**SparkFun_ADXL345_Example.ino** and **SparkFun_ADXL345_Calibration.ino**). Run these from the Arduino IDE.
|
||||
* Source files for the library (**SparkFun_ADXL345.cpp** and **SparkFun_ADXL345.h**).
|
||||
* **keywords.txt** - Keywords from this library that will be highlighted in the Arduino IDE.
|
||||
|
||||
Documentation
|
||||
--------------
|
||||
|
||||
* **[Installing an Arduino Library Guide](https://learn.sparkfun.com/tutorials/installing-an-arduino-library)** - Basic information on how to install an Arduino library.
|
||||
* **[Product Repository](https://github.com/sparkfun/ADXL345_Breakout)** - Main repository (including hardware files) for the SparkFun Triple Axis Accelerometer Breakout - ADXL345.
|
||||
* **[Hookup Guide](https://learn.sparkfun.com/tutorials/adxl345-hookup-guide)** - Basic hookup guide for the SparkFun Triple Axis Accelerometer Breakout - ADXL345.
|
||||
|
||||
Products that use this Library
|
||||
---------------------------------
|
||||
|
||||
* [SparkFun Triple Axis Accelerometer Breakout - ADXL345 - PRT-9836](https://www.sparkfun.com/products/9836)- The ADXL345 is a small, thin, low power, 3-axis MEMS accelerometer with high resolution (13-bit) measurement at up to +-16 g. Digital output data is formatted as 16-bit twos complement and is accessible through either a SPI (3- or 4-wire) or I2C digital interface.
|
||||
|
||||
Version History
|
||||
---------------
|
||||
|
||||
* [1.0.0](https://github.com/sparkfun/SparkFun_ADXL345_Arduino_Library/releases/tag/V_1.0.0) - Initial release of the Triple Axis Accelerometer Breakout - ADXL345 SparkFun Library.
|
||||
|
||||
License Information
|
||||
-------------------
|
||||
|
||||
This product is _**open source**_!
|
||||
|
||||
Please review the LICENSE.md file for license information.
|
||||
|
||||
If you have any questions or concerns on licensing, please contact techsupport@sparkfun.com.
|
||||
|
||||
Distributed as-is; no warranty is given.
|
||||
|
||||
- Your friends at SparkFun.
|
||||
|
||||
_<COLLABORATION CREDIT>_
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
/* *****************************************
|
||||
* ADXL345_Calibration
|
||||
* ADXL345 Hook Up Guide Calibration Example
|
||||
*
|
||||
* Utilizing Sparkfun's ADXL345 Library
|
||||
* Bildr ADXL345 source file modified to support
|
||||
* both I2C and SPI Communication
|
||||
*
|
||||
* E.Robert @ SparkFun Electronics
|
||||
* Created: Jul 13, 2016
|
||||
* Updated: Sep 13, 2016
|
||||
*
|
||||
* Development Environment Specifics:
|
||||
* Arduino 1.6.11
|
||||
*
|
||||
* Hardware Specifications:
|
||||
* SparkFun ADXL345
|
||||
* Arduino Uno
|
||||
* *****************************************/
|
||||
|
||||
#include <SparkFun_ADXL345.h>
|
||||
|
||||
/*********** COMMUNICATION SELECTION ***********/
|
||||
/* Comment Out The One You Are Not Using */
|
||||
ADXL345 adxl = ADXL345(10); // USE FOR SPI COMMUNICATION, ADXL345(CS_PIN);
|
||||
//ADXL345 adxl = ADXL345(); // USE FOR I2C COMMUNICATION
|
||||
|
||||
/****************** VARIABLES ******************/
|
||||
/* */
|
||||
int AccelMinX = 0;
|
||||
int AccelMaxX = 0;
|
||||
int AccelMinY = 0;
|
||||
int AccelMaxY = 0;
|
||||
int AccelMinZ = 0;
|
||||
int AccelMaxZ = 0;
|
||||
|
||||
int accX = 0;
|
||||
int accY = 0;
|
||||
int accZ = 0;
|
||||
|
||||
/************** DEFINED VARIABLES **************/
|
||||
/* */
|
||||
#define offsetX -123 // OFFSET values
|
||||
#define offsetY -16
|
||||
#define offsetZ -10
|
||||
|
||||
#define gainX 133 // GAIN factors
|
||||
#define gainY 261
|
||||
#define gainZ 248
|
||||
|
||||
/******************** SETUP ********************/
|
||||
/* Configure ADXL345 Settings */
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600); // Start the serial terminal
|
||||
Serial.println("SparkFun ADXL345 Accelerometer Breakout Calibration");
|
||||
Serial.println();
|
||||
|
||||
adxl.powerOn(); // Power on the ADXL345
|
||||
|
||||
adxl.setRangeSetting(2); // Give the range settings
|
||||
// Accepted values are 2g, 4g, 8g or 16g
|
||||
// Higher Values = Wider Measurement Range
|
||||
// Lower Values = Greater Sensitivity
|
||||
|
||||
adxl.setSpiBit(0); // Configure the device: 4 wire SPI mode = '0' or 3 wire SPI mode = 1
|
||||
// Default: Set to 1
|
||||
// SPI pins on the ATMega328: 11, 12 and 13 as reference in SPI Library
|
||||
}
|
||||
|
||||
/****************** MAIN CODE ******************/
|
||||
/* Accelerometer Readings and Min/Max Values */
|
||||
void loop()
|
||||
{
|
||||
Serial.println("Send any character to display values.");
|
||||
while (!Serial.available()){} // Waiting for character to be sent to Serial
|
||||
Serial.println();
|
||||
|
||||
// Get the Accelerometer Readings
|
||||
int x,y,z; // init variables hold results
|
||||
adxl.readAccel(&x, &y, &z); // Read the accelerometer values and store in variables x,y,z
|
||||
|
||||
if(x < AccelMinX) AccelMinX = x;
|
||||
if(x > AccelMaxX) AccelMaxX = x;
|
||||
|
||||
if(y < AccelMinY) AccelMinY = y;
|
||||
if(y > AccelMaxY) AccelMaxY = y;
|
||||
|
||||
if(z < AccelMinZ) AccelMinZ = z;
|
||||
if(z > AccelMaxZ) AccelMaxZ = z;
|
||||
|
||||
Serial.print("Accel Minimums: "); Serial.print(AccelMinX); Serial.print(" ");Serial.print(AccelMinY); Serial.print(" "); Serial.print(AccelMinZ); Serial.println();
|
||||
Serial.print("Accel Maximums: "); Serial.print(AccelMaxX); Serial.print(" ");Serial.print(AccelMaxY); Serial.print(" "); Serial.print(AccelMaxZ); Serial.println();
|
||||
Serial.println();
|
||||
|
||||
|
||||
/* Note: Must perform offset and gain calculations prior to seeing updated results
|
||||
/ Refer to SparkFun ADXL345 Hook Up Guide: https://learn.sparkfun.com/tutorials/adxl345-hookup-guide
|
||||
/ offsetAxis = 0.5 * (Acel+1g + Accel-1g)
|
||||
/ gainAxis = 0.5 * ((Acel+1g - Accel-1g)/1g) */
|
||||
|
||||
// UNCOMMENT SECTION TO VIEW NEW VALUES
|
||||
//accX = (x - offsetX)/gainX; // Calculating New Values for X, Y and Z
|
||||
//accY = (y - offsetY)/gainY;
|
||||
//accZ = (z - offsetZ)/gainZ;
|
||||
|
||||
//Serial.print("New Calibrated Values: "); Serial.print(accX); Serial.print(" "); Serial.print(accY); Serial.print(" "); Serial.print(accZ);
|
||||
//Serial.println();
|
||||
|
||||
while (Serial.available())
|
||||
{
|
||||
Serial.read(); // Clear buffer
|
||||
}
|
||||
}
|
||||
+149
@@ -0,0 +1,149 @@
|
||||
/* *********************************************
|
||||
* SparkFun_ADXL345_Example
|
||||
* Triple Axis Accelerometer Breakout - ADXL345
|
||||
* Hook Up Guide Example
|
||||
*
|
||||
* Utilizing Sparkfun's ADXL345 Library
|
||||
* Bildr ADXL345 source file modified to support
|
||||
* both I2C and SPI Communication
|
||||
*
|
||||
* E.Robert @ SparkFun Electronics
|
||||
* Created: Jul 13, 2016
|
||||
* Updated: Sep 06, 2016
|
||||
*
|
||||
* Development Environment Specifics:
|
||||
* Arduino 1.6.11
|
||||
*
|
||||
* Hardware Specifications:
|
||||
* SparkFun ADXL345
|
||||
* Arduino Uno
|
||||
* *********************************************/
|
||||
|
||||
#include <SparkFun_ADXL345.h> // SparkFun ADXL345 Library
|
||||
|
||||
/*********** COMMUNICATION SELECTION ***********/
|
||||
/* Comment Out The One You Are Not Using */
|
||||
ADXL345 adxl = ADXL345(10); // USE FOR SPI COMMUNICATION, ADXL345(CS_PIN);
|
||||
//ADXL345 adxl = ADXL345(); // USE FOR I2C COMMUNICATION
|
||||
|
||||
/****************** INTERRUPT ******************/
|
||||
/* Uncomment If Attaching Interrupt */
|
||||
//int interruptPin = 2; // Setup pin 2 to be the interrupt pin (for most Arduino Boards)
|
||||
|
||||
|
||||
/******************** SETUP ********************/
|
||||
/* Configure ADXL345 Settings */
|
||||
void setup(){
|
||||
|
||||
Serial.begin(9600); // Start the serial terminal
|
||||
Serial.println("SparkFun ADXL345 Accelerometer Hook Up Guide Example");
|
||||
Serial.println();
|
||||
|
||||
adxl.powerOn(); // Power on the ADXL345
|
||||
|
||||
adxl.setRangeSetting(16); // Give the range settings
|
||||
// Accepted values are 2g, 4g, 8g or 16g
|
||||
// Higher Values = Wider Measurement Range
|
||||
// Lower Values = Greater Sensitivity
|
||||
|
||||
adxl.setSpiBit(0); // Configure the device to be in 4 wire SPI mode when set to '0' or 3 wire SPI mode when set to 1
|
||||
// Default: Set to 1
|
||||
// SPI pins on the ATMega328: 11, 12 and 13 as reference in SPI Library
|
||||
|
||||
adxl.setActivityXYZ(1, 0, 0); // Set to activate movement detection in the axes "adxl.setActivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
|
||||
adxl.setActivityThreshold(75); // 62.5mg per increment // Set activity // Inactivity thresholds (0-255)
|
||||
|
||||
adxl.setInactivityXYZ(1, 0, 0); // Set to detect inactivity in all the axes "adxl.setInactivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
|
||||
adxl.setInactivityThreshold(75); // 62.5mg per increment // Set inactivity // Inactivity thresholds (0-255)
|
||||
adxl.setTimeInactivity(10); // How many seconds of no activity is inactive?
|
||||
|
||||
adxl.setTapDetectionOnXYZ(0, 0, 1); // Detect taps in the directions turned ON "adxl.setTapDetectionOnX(X, Y, Z);" (1 == ON, 0 == OFF)
|
||||
|
||||
// Set values for what is considered a TAP and what is a DOUBLE TAP (0-255)
|
||||
adxl.setTapThreshold(50); // 62.5 mg per increment
|
||||
adxl.setTapDuration(15); // 625 μs per increment
|
||||
adxl.setDoubleTapLatency(80); // 1.25 ms per increment
|
||||
adxl.setDoubleTapWindow(200); // 1.25 ms per increment
|
||||
|
||||
// Set values for what is considered FREE FALL (0-255)
|
||||
adxl.setFreeFallThreshold(7); // (5 - 9) recommended - 62.5mg per increment
|
||||
adxl.setFreeFallDuration(30); // (20 - 70) recommended - 5ms per increment
|
||||
|
||||
// Setting all interupts to take place on INT1 pin
|
||||
//adxl.setImportantInterruptMapping(1, 1, 1, 1, 1); // Sets "adxl.setEveryInterruptMapping(single tap, double tap, free fall, activity, inactivity);"
|
||||
// Accepts only 1 or 2 values for pins INT1 and INT2. This chooses the pin on the ADXL345 to use for Interrupts.
|
||||
// This library may have a problem using INT2 pin. Default to INT1 pin.
|
||||
|
||||
// Turn on Interrupts for each mode (1 == ON, 0 == OFF)
|
||||
adxl.InactivityINT(1);
|
||||
adxl.ActivityINT(1);
|
||||
adxl.FreeFallINT(1);
|
||||
adxl.doubleTapINT(1);
|
||||
adxl.singleTapINT(1);
|
||||
|
||||
//attachInterrupt(digitalPinToInterrupt(interruptPin), ADXL_ISR, RISING); // Attach Interrupt
|
||||
|
||||
}
|
||||
|
||||
/****************** MAIN CODE ******************/
|
||||
/* Accelerometer Readings and Interrupt */
|
||||
void loop(){
|
||||
|
||||
// Accelerometer Readings
|
||||
int x,y,z;
|
||||
adxl.readAccel(&x, &y, &z); // Read the accelerometer values and store them in variables declared above x,y,z
|
||||
|
||||
// Output Results to Serial
|
||||
/* UNCOMMENT TO VIEW X Y Z ACCELEROMETER VALUES */
|
||||
//Serial.print(x);
|
||||
//Serial.print(", ");
|
||||
//Serial.print(y);
|
||||
//Serial.print(", ");
|
||||
//Serial.println(z);
|
||||
|
||||
ADXL_ISR();
|
||||
// You may also choose to avoid using interrupts and simply run the functions within ADXL_ISR();
|
||||
// and place it within the loop instead.
|
||||
// This may come in handy when it doesn't matter when the action occurs.
|
||||
|
||||
}
|
||||
|
||||
/********************* ISR *********************/
|
||||
/* Look for Interrupts and Triggered Action */
|
||||
void ADXL_ISR() {
|
||||
|
||||
// getInterruptSource clears all triggered actions after returning value
|
||||
// Do not call again until you need to recheck for triggered actions
|
||||
byte interrupts = adxl.getInterruptSource();
|
||||
|
||||
// Free Fall Detection
|
||||
if(adxl.triggered(interrupts, ADXL345_FREE_FALL)){
|
||||
Serial.println("*** FREE FALL ***");
|
||||
//add code here to do when free fall is sensed
|
||||
}
|
||||
|
||||
// Inactivity
|
||||
if(adxl.triggered(interrupts, ADXL345_INACTIVITY)){
|
||||
Serial.println("*** INACTIVITY ***");
|
||||
//add code here to do when inactivity is sensed
|
||||
}
|
||||
|
||||
// Activity
|
||||
if(adxl.triggered(interrupts, ADXL345_ACTIVITY)){
|
||||
Serial.println("*** ACTIVITY ***");
|
||||
//add code here to do when activity is sensed
|
||||
}
|
||||
|
||||
// Double Tap Detection
|
||||
if(adxl.triggered(interrupts, ADXL345_DOUBLE_TAP)){
|
||||
Serial.println("*** DOUBLE TAP ***");
|
||||
//add code here to do when a 2X tap is sensed
|
||||
}
|
||||
|
||||
// Tap Detection
|
||||
if(adxl.triggered(interrupts, ADXL345_SINGLE_TAP)){
|
||||
Serial.println("*** TAP ***");
|
||||
//add code here to do when a tap is sensed
|
||||
}
|
||||
}
|
||||
|
||||
+225
@@ -0,0 +1,225 @@
|
||||
/* *********************************************
|
||||
* SparkFun_BabyBlynkMonitorThing
|
||||
* Baby Monitor Thing Project Example Code
|
||||
* Blog Post: https://www.sparkfun.com/news/2185
|
||||
*
|
||||
* Utilizing
|
||||
* Sparkfun's ADXL345 Library
|
||||
* Blynk Library is licensed under MIT license
|
||||
* ESP8266WiFi Library
|
||||
* BlynkSimpleEsp8266 Library
|
||||
*
|
||||
* E.Robert @ SparkFun Electronics
|
||||
* Created: Sep 12, 2016
|
||||
* Updated: Sep 13, 2016
|
||||
*
|
||||
* Development Environment Specifics:
|
||||
* Arduino 1.6.11
|
||||
* Blynk App
|
||||
*
|
||||
* Blynk is a platform with iOS and Android apps to control
|
||||
* Arduino, Raspberry Pi and the likes over the Internet.
|
||||
* You can easily build graphic interfaces for all your
|
||||
* projects by simply dragging and dropping widgets.
|
||||
*
|
||||
* Downloads, docs, tutorials: http://www.blynk.cc
|
||||
* Blynk community: http://community.blynk.cc
|
||||
* Social networks: http://www.fb.com/blynkapp
|
||||
* http://twitter.com/blynk_app
|
||||
*
|
||||
* Hardware Specifications:
|
||||
* SparkFun Triple Axis Accelerometer ADXL345
|
||||
* SparkFun ESP8266 Thing
|
||||
* *********************************************/
|
||||
|
||||
#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
|
||||
#include <ESP8266WiFi.h>
|
||||
#include <BlynkSimpleEsp8266.h>
|
||||
#include <SparkFun_ADXL345.h>
|
||||
#include <SimpleTimer.h>
|
||||
|
||||
/*********** COMMUNICATION SELECTION ***********/
|
||||
/* */
|
||||
//ADXL345 adxl = ADXL345(10); // USE FOR SPI COMMUNICATION, ADXL345(CS_PIN);
|
||||
ADXL345 adxl = ADXL345(); // USE FOR I2C COMMUNICATION
|
||||
|
||||
/****************** VARIABLES ******************/
|
||||
/* */
|
||||
int gotUpFlag = 0; // Flags first occurance
|
||||
int wentDownFlag = 0; // Flags first occurance
|
||||
int gotUp = 0; // Variable for number of times baby up
|
||||
unsigned long babyMovingStartTime = 0; // Will store time when baby starts moving
|
||||
unsigned long babySleepingStartTime = 0; // Will store time when baby starts sleeping
|
||||
unsigned long babySleepingEndTime = 0; // Will store time when baby wakes up
|
||||
long TimeLimit = 180000; // Notification in 3 minutes when awake
|
||||
double minutesTimeS = 0; // For minute conversion
|
||||
double minutesTimeA = 0; // For minute conversion
|
||||
|
||||
|
||||
/******************** BLYNK ********************/
|
||||
/* Communication with your BLYNK app */
|
||||
// You should get Auth Token in the Blynk App.
|
||||
// Go to the Project Settings (nut icon).
|
||||
char auth[] = "b6873bbab8fa449dbd0c4d8bfa3b38ca";
|
||||
#define XValue V0
|
||||
#define YValue V1
|
||||
#define ZValue V2
|
||||
#define VIRTUAL_LCD V3
|
||||
#define babyMoving V4
|
||||
#define awakeTime V5
|
||||
#define asleepTime V6
|
||||
#define awakeLED V7
|
||||
#define asleepLED V8
|
||||
WidgetLCD lcd(VIRTUAL_LCD);
|
||||
|
||||
// Your WiFi credentials.
|
||||
// Set password to "" for open networks.
|
||||
char ssid[] = "INSERT NETWORK HERE";
|
||||
char pass[] = "INSERT PASSWORD HERE";
|
||||
|
||||
SimpleTimer timer;
|
||||
|
||||
/*********** REFRESH APPLICATION NAME **********/
|
||||
/* Communication with your BLYNK app */
|
||||
void refreshTime()
|
||||
{
|
||||
long uptime = millis() / 60000L;
|
||||
|
||||
// Output the following every minute:
|
||||
lcd.clear(); // Clear LCD Screen on Blynk
|
||||
lcd.print(0, 0, " BABY BLYNK "); // Outputs Application Name
|
||||
lcd.print(0, 1, " MONITOR THING ");
|
||||
}
|
||||
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
Blynk.begin(auth, ssid, pass); // Give us access!
|
||||
|
||||
while (Blynk.connect() == false) { // Be patient.
|
||||
// Wait for Blynk to come online
|
||||
}
|
||||
|
||||
// Notify immediately on startup
|
||||
Blynk.notify("Device Started"); // Notification to smartphone
|
||||
|
||||
// Setup a function to be called every minute
|
||||
timer.setInterval(60000L, refreshTime);
|
||||
|
||||
adxl.powerOn(); // Power on the ADXL345
|
||||
|
||||
adxl.setRangeSetting(8); // Give the range settings
|
||||
// Accepted values are 2g, 4g, 8g or 16g
|
||||
// Higher Values = Wider Measurement Range
|
||||
// Lower Values = Greater Sensitivity
|
||||
|
||||
// Set values to zero
|
||||
gotUpFlag = 0;
|
||||
wentDownFlag = 0;
|
||||
gotUp = 0;
|
||||
Blynk.virtualWrite(awakeTime, 0);
|
||||
Blynk.virtualWrite(asleepTime, 0);
|
||||
Blynk.virtualWrite(awakeLED, LOW);
|
||||
Blynk.virtualWrite(asleepLED, LOW);
|
||||
|
||||
// Print a splash screen:
|
||||
lcd.clear();
|
||||
lcd.print(0, 0, " BABY MONITOR ");
|
||||
lcd.print(0, 1, " THING ");
|
||||
}
|
||||
|
||||
/******************* MAIN CODE *****************/
|
||||
/* */
|
||||
void loop()
|
||||
{
|
||||
Blynk.run();
|
||||
timer.run();
|
||||
|
||||
// ADXL345 Accelerometer Readings
|
||||
int x,y,z;
|
||||
adxl.readAccel(&x, &y, &z); // Read the accelerometer values in variables x,y,z
|
||||
|
||||
// Write the values to Blynk:
|
||||
Blynk.virtualWrite(XValue, x);
|
||||
Blynk.virtualWrite(YValue, y);
|
||||
Blynk.virtualWrite(ZValue, z);
|
||||
|
||||
// Monitoring Up and Down Time
|
||||
if (y >= 50 && y <= 200) {
|
||||
if (wentDownFlag == 1){
|
||||
babySleepingEndTime = millis(); // Stopped sleeping time
|
||||
}
|
||||
Blynk.virtualWrite(awakeLED, 1023); // Awake LED lit
|
||||
Blynk.virtualWrite(asleepLED, 0); // Asleep LED out
|
||||
|
||||
if (gotUpFlag == 0) { // If first time baby has gotten up
|
||||
babyMovingStartTime = millis(); // Baby moving start time
|
||||
gotUpFlag = 1;
|
||||
gotUp = gotUp + 1; // Count the number of times the baby gets up
|
||||
// in the middle of the night
|
||||
} else {
|
||||
checkBaby();
|
||||
}
|
||||
} else if (y <= 30) {
|
||||
Blynk.virtualWrite(awakeLED, 0); // Awake LED out
|
||||
Blynk.virtualWrite(asleepLED, 1023); // Asleep LED lit
|
||||
|
||||
// Print to VIRTUAL_LCD:
|
||||
lcd.clear();
|
||||
lcd.print(0, 0, " BABY SLEEPING ");
|
||||
lcd.print(0, 1, " SHHH!!! ");
|
||||
|
||||
if (wentDownFlag == 0) {
|
||||
babySleepingStartTime = millis(); // Baby sleeping start time
|
||||
wentDownFlag = 1;
|
||||
} else {
|
||||
babySleepingEndTime = millis(); // Stopped sleeping time
|
||||
}
|
||||
|
||||
if (gotUpFlag == 1) {
|
||||
wentDownFlag = 0; // Reset flag if baby went back down
|
||||
gotUpFlag = 0;
|
||||
}
|
||||
sleepTime(); // Time asleep
|
||||
} else {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
// Write number of times baby has gotten up to Blynk
|
||||
Blynk.virtualWrite(babyMoving, gotUp);
|
||||
}
|
||||
|
||||
/***************** BABY IS AWAKE ***************/
|
||||
/* Time to get them yet? */
|
||||
void checkBaby() {
|
||||
long currentTime = millis(); // Current time
|
||||
long upTime = currentTime - babyMovingStartTime; // Time baby awake
|
||||
minutesTimeA = upTime * 1.6667E-5; // Time conversion to minutes
|
||||
|
||||
// Print to VIRTUAL_LCD:
|
||||
lcd.clear();
|
||||
lcd.print(0, 0, " BABY MOVING ");
|
||||
lcd.print(0, 1, " AROUND ");
|
||||
|
||||
// Check to see if baby has been awake for a while
|
||||
if (upTime >= TimeLimit) {
|
||||
Blynk.notify("BABY IS AWAKE!"); // Notification to smartphone
|
||||
} else {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
// Baby awake time
|
||||
Blynk.virtualWrite(awakeTime, minutesTimeA);
|
||||
}
|
||||
|
||||
/***************** BABY IS Asleep ***************/
|
||||
/* But for how long? */
|
||||
void sleepTime(){
|
||||
// Calculat down time in millis and minutes
|
||||
long downTime = babySleepingEndTime - babySleepingStartTime;
|
||||
minutesTimeS = downTime * 1.6667E-5;
|
||||
|
||||
// Baby sleeping time
|
||||
Blynk.virtualWrite(asleepTime, minutesTimeS);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
#######################################
|
||||
# Syntax Coloring Map For ADXL345
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
# Library (KEYWORD1)
|
||||
#######################################
|
||||
|
||||
ADXL345 KEYWORD1
|
||||
SparkFunADXL345 KEYWORD1
|
||||
|
||||
#######################################
|
||||
# Datatypes (KEYWORD1)
|
||||
#######################################
|
||||
|
||||
#Nothing here yet
|
||||
|
||||
#######################################
|
||||
# Methods and Functions (KEYWORD2)
|
||||
#######################################
|
||||
|
||||
powerOn KEYWORD2
|
||||
setActivityXYZ KEYWORD2
|
||||
setActivityThreshold KEYWORD2
|
||||
setInactivityXYZ KEYWORD2
|
||||
setInactivityThreshold KEYWORD2
|
||||
setTimeInactivity KEYWORD2
|
||||
setTapDetectionOnXYZ KEYWORD2
|
||||
setTapThreshold KEYWORD2
|
||||
setTapDuration KEYWORD2
|
||||
setDoubleTapLatency KEYWORD2
|
||||
setDoubleTapWindow KEYWORD2
|
||||
setFreeFallThreshold KEYWORD2
|
||||
setFreeFallDuration KEYWORD2
|
||||
setImportantInterruptMapping KEYWORD2
|
||||
InactivityINT KEYWORD2
|
||||
ActivityINT KEYWORD2
|
||||
FreeFallINT KEYWORD2
|
||||
doubleTapINT KEYWORD2
|
||||
singleTapINT KEYWORD2
|
||||
readAccel KEYWORD2
|
||||
triggered KEYWORD2
|
||||
getInterruptSource KEYWORD2
|
||||
|
||||
#######################################
|
||||
# Constants (LITERAL1)
|
||||
#######################################
|
||||
|
||||
ADXL345_FREE_FALL LITERAL1
|
||||
ADXL345_INACTIVITY LITERAL1
|
||||
ADXL345_ACTIVITY LITERAL1
|
||||
ADXL345_DOUBLE_TAP LITERAL1
|
||||
ADXL345_SINGLE_TAP LITERAL1
|
||||
@@ -0,0 +1,9 @@
|
||||
name=SparkFun ADXL345 Arduino Library
|
||||
version=1.0.0
|
||||
author=SparkFun Electronics
|
||||
maintainer=SparkFun Electronics
|
||||
sentence=An Arduino library for interfacing with the SparkFun Triple Axis Accelerometer Breakout - ADXL345
|
||||
paragraph=An Arduino library for interfacing with the SparkFun Triple Axis Accelerometer Breakout - ADXL345
|
||||
category=Sensors
|
||||
url=https://github.com/sparkfun/SparkFun_ADXL345_Arduino_Library
|
||||
architectures=*
|
||||
@@ -0,0 +1,833 @@
|
||||
/*
|
||||
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() : _i2c_addr(ADXL345_DEVICE) {
|
||||
// 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(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;
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
/*********************** 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, num); // Request 6 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 & B00000011;
|
||||
}
|
||||
|
||||
void ADXL345::setRangeSetting(int val) {
|
||||
byte _s;
|
||||
byte _b;
|
||||
|
||||
switch (val) {
|
||||
case 2:
|
||||
_s = B00000000;
|
||||
break;
|
||||
case 4:
|
||||
_s = B00000001;
|
||||
break;
|
||||
case 8:
|
||||
_s = B00000010;
|
||||
break;
|
||||
case 16:
|
||||
_s = B00000011;
|
||||
break;
|
||||
default:
|
||||
_s = B00000000;
|
||||
}
|
||||
readFrom(ADXL345_DATA_FORMAT, 1, &_b);
|
||||
_s |= (_b & B11101100);
|
||||
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 &= B00001111;
|
||||
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 & B11110000);
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
/*
|
||||
Sparkfun's ADXL345 Library Main Header File
|
||||
ADXL345.h
|
||||
|
||||
E.Robert @ SparkFun Electronics
|
||||
Created: Jul 13, 2016
|
||||
Updated: Sep 06, 2016
|
||||
|
||||
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"
|
||||
|
||||
#ifndef ADXL345_h
|
||||
#define ADXL345_h
|
||||
|
||||
/*************************** REGISTER MAP ***************************/
|
||||
#define ADXL345_DEVID 0x00 // Device ID
|
||||
#define ADXL345_RESERVED1 0x01 // Reserved. Do Not Access.
|
||||
#define ADXL345_THRESH_TAP 0x1D // Tap Threshold.
|
||||
#define ADXL345_OFSX 0x1E // X-Axis Offset.
|
||||
#define ADXL345_OFSY 0x1F // Y-Axis Offset.
|
||||
#define ADXL345_OFSZ 0x20 // Z- Axis Offset.
|
||||
#define ADXL345_DUR 0x21 // Tap Duration.
|
||||
#define ADXL345_LATENT 0x22 // Tap Latency.
|
||||
#define ADXL345_WINDOW 0x23 // Tap Window.
|
||||
#define ADXL345_THRESH_ACT 0x24 // Activity Threshold
|
||||
#define ADXL345_THRESH_INACT 0x25 // Inactivity Threshold
|
||||
#define ADXL345_TIME_INACT 0x26 // Inactivity Time
|
||||
#define ADXL345_ACT_INACT_CTL 0x27 // Axis Enable Control for Activity and Inactivity Detection
|
||||
#define ADXL345_THRESH_FF 0x28 // Free-Fall Threshold.
|
||||
#define ADXL345_TIME_FF 0x29 // Free-Fall Time.
|
||||
#define ADXL345_TAP_AXES 0x2A // Axis Control for Tap/Double Tap.
|
||||
#define ADXL345_ACT_TAP_STATUS 0x2B // Source of Tap/Double Tap
|
||||
#define ADXL345_BW_RATE 0x2C // Data Rate and Power mode Control
|
||||
#define ADXL345_POWER_CTL 0x2D // Power-Saving Features Control
|
||||
#define ADXL345_INT_ENABLE 0x2E // Interrupt Enable Control
|
||||
#define ADXL345_INT_MAP 0x2F // Interrupt Mapping Control
|
||||
#define ADXL345_INT_SOURCE 0x30 // Source of Interrupts
|
||||
#define ADXL345_DATA_FORMAT 0x31 // Data Format Control
|
||||
#define ADXL345_DATAX0 0x32 // X-Axis Data 0
|
||||
#define ADXL345_DATAX1 0x33 // X-Axis Data 1
|
||||
#define ADXL345_DATAY0 0x34 // Y-Axis Data 0
|
||||
#define ADXL345_DATAY1 0x35 // Y-Axis Data 1
|
||||
#define ADXL345_DATAZ0 0x36 // Z-Axis Data 0
|
||||
#define ADXL345_DATAZ1 0x37 // Z-Axis Data 1
|
||||
#define ADXL345_FIFO_CTL 0x38 // FIFO Control
|
||||
#define ADXL345_FIFO_STATUS 0x39 // FIFO Status
|
||||
|
||||
#define ADXL345_BW_1600 0xF // 1111 IDD = 40uA
|
||||
#define ADXL345_BW_800 0xE // 1110 IDD = 90uA
|
||||
#define ADXL345_BW_400 0xD // 1101 IDD = 140uA
|
||||
#define ADXL345_BW_200 0xC // 1100 IDD = 140uA
|
||||
#define ADXL345_BW_100 0xB // 1011 IDD = 140uA
|
||||
#define ADXL345_BW_50 0xA // 1010 IDD = 140uA
|
||||
#define ADXL345_BW_25 0x9 // 1001 IDD = 90uA
|
||||
#define ADXL345_BW_12_5 0x8 // 1000 IDD = 60uA
|
||||
#define ADXL345_BW_6_25 0x7 // 0111 IDD = 50uA
|
||||
#define ADXL345_BW_3_13 0x6 // 0110 IDD = 45uA
|
||||
#define ADXL345_BW_1_56 0x5 // 0101 IDD = 40uA
|
||||
#define ADXL345_BW_0_78 0x4 // 0100 IDD = 34uA
|
||||
#define ADXL345_BW_0_39 0x3 // 0011 IDD = 23uA
|
||||
#define ADXL345_BW_0_20 0x2 // 0010 IDD = 23uA
|
||||
#define ADXL345_BW_0_10 0x1 // 0001 IDD = 23uA
|
||||
#define ADXL345_BW_0_05 0x0 // 0000 IDD = 23uA
|
||||
|
||||
|
||||
/************************** INTERRUPT PINS **************************/
|
||||
#define ADXL345_INT1_PIN 0x00 //INT1: 0
|
||||
#define ADXL345_INT2_PIN 0x01 //INT2: 1
|
||||
|
||||
|
||||
/********************** INTERRUPT BIT POSITION **********************/
|
||||
#define ADXL345_INT_DATA_READY_BIT 0x07
|
||||
#define ADXL345_INT_SINGLE_TAP_BIT 0x06
|
||||
#define ADXL345_INT_DOUBLE_TAP_BIT 0x05
|
||||
#define ADXL345_INT_ACTIVITY_BIT 0x04
|
||||
#define ADXL345_INT_INACTIVITY_BIT 0x03
|
||||
#define ADXL345_INT_FREE_FALL_BIT 0x02
|
||||
#define ADXL345_INT_WATERMARK_BIT 0x01
|
||||
#define ADXL345_INT_OVERRUNY_BIT 0x00
|
||||
|
||||
#define ADXL345_DATA_READY 0x07
|
||||
#define ADXL345_SINGLE_TAP 0x06
|
||||
#define ADXL345_DOUBLE_TAP 0x05
|
||||
#define ADXL345_ACTIVITY 0x04
|
||||
#define ADXL345_INACTIVITY 0x03
|
||||
#define ADXL345_FREE_FALL 0x02
|
||||
#define ADXL345_WATERMARK 0x01
|
||||
#define ADXL345_OVERRUNY 0x00
|
||||
|
||||
|
||||
/****************************** ERRORS ******************************/
|
||||
#define ADXL345_OK 1 // No Error
|
||||
#define ADXL345_ERROR 0 // Error Exists
|
||||
|
||||
#define ADXL345_NO_ERROR 0 // Initial State
|
||||
#define ADXL345_READ_ERROR 1 // Accelerometer Reading Error
|
||||
#define ADXL345_BAD_ARG 2 // Bad Argument
|
||||
|
||||
|
||||
class ADXL345
|
||||
{
|
||||
public:
|
||||
bool status; // Set When Error Exists
|
||||
|
||||
byte error_code; // Initial State
|
||||
double gains[3]; // Counts to Gs
|
||||
|
||||
// ADXL345();
|
||||
ADXL345(uint8_t i2c_addr);
|
||||
ADXL345(int CS);
|
||||
void powerOn();
|
||||
void readAccel(int* xyx);
|
||||
void readAccel(int* x, int* y, int* z);
|
||||
void get_Gxyz(double *xyz);
|
||||
|
||||
void setTapThreshold(int tapThreshold);
|
||||
int getTapThreshold();
|
||||
void setAxisGains(double *_gains);
|
||||
void getAxisGains(double *_gains);
|
||||
void setAxisOffset(int x, int y, int z);
|
||||
void getAxisOffset(int* x, int* y, int*z);
|
||||
void setTapDuration(int tapDuration);
|
||||
int getTapDuration();
|
||||
void setDoubleTapLatency(int doubleTapLatency);
|
||||
int getDoubleTapLatency();
|
||||
void setDoubleTapWindow(int doubleTapWindow);
|
||||
int getDoubleTapWindow();
|
||||
void setActivityThreshold(int activityThreshold);
|
||||
int getActivityThreshold();
|
||||
void setInactivityThreshold(int inactivityThreshold);
|
||||
int getInactivityThreshold();
|
||||
void setTimeInactivity(int timeInactivity);
|
||||
int getTimeInactivity();
|
||||
void setFreeFallThreshold(int freeFallthreshold);
|
||||
int getFreeFallThreshold();
|
||||
void setFreeFallDuration(int freeFallDuration);
|
||||
int getFreeFallDuration();
|
||||
|
||||
bool isActivityXEnabled();
|
||||
bool isActivityYEnabled();
|
||||
bool isActivityZEnabled();
|
||||
bool isInactivityXEnabled();
|
||||
bool isInactivityYEnabled();
|
||||
bool isInactivityZEnabled();
|
||||
bool isActivityAc();
|
||||
bool isInactivityAc();
|
||||
void setActivityAc(bool state);
|
||||
void setInactivityAc(bool state);
|
||||
|
||||
bool getSuppressBit();
|
||||
void setSuppressBit(bool state);
|
||||
bool isTapDetectionOnX();
|
||||
void setTapDetectionOnX(bool state);
|
||||
bool isTapDetectionOnY();
|
||||
void setTapDetectionOnY(bool state);
|
||||
bool isTapDetectionOnZ();
|
||||
void setTapDetectionOnZ(bool state);
|
||||
void setTapDetectionOnXYZ(bool stateX, bool stateY, bool stateZ);
|
||||
|
||||
void setActivityX(bool state);
|
||||
void setActivityY(bool state);
|
||||
void setActivityZ(bool state);
|
||||
void setActivityXYZ(bool stateX, bool stateY, bool stateZ);
|
||||
void setInactivityX(bool state);
|
||||
void setInactivityY(bool state);
|
||||
void setInactivityZ(bool state);
|
||||
void setInactivityXYZ(bool stateX, bool stateY, bool stateZ);
|
||||
|
||||
bool isActivitySourceOnX();
|
||||
bool isActivitySourceOnY();
|
||||
bool isActivitySourceOnZ();
|
||||
bool isTapSourceOnX();
|
||||
bool isTapSourceOnY();
|
||||
bool isTapSourceOnZ();
|
||||
bool isAsleep();
|
||||
|
||||
bool isLowPower();
|
||||
void setLowPower(bool state);
|
||||
double getRate();
|
||||
void setRate(double rate);
|
||||
void set_bw(byte bw_code);
|
||||
byte get_bw_code();
|
||||
|
||||
bool triggered(byte interrupts, int mask);
|
||||
|
||||
byte getInterruptSource();
|
||||
bool getInterruptSource(byte interruptBit);
|
||||
bool getInterruptMapping(byte interruptBit);
|
||||
void setInterruptMapping(byte interruptBit, bool interruptPin);
|
||||
bool isInterruptEnabled(byte interruptBit);
|
||||
void setInterrupt(byte interruptBit, bool state);
|
||||
void setImportantInterruptMapping(int single_tap, int double_tap, int free_fall, int activity, int inactivity);
|
||||
void InactivityINT(bool status);
|
||||
void ActivityINT(bool status);
|
||||
void FreeFallINT(bool status);
|
||||
void doubleTapINT(bool status);
|
||||
void singleTapINT(bool status);
|
||||
|
||||
void getRangeSetting(byte* rangeSetting);
|
||||
void setRangeSetting(int val);
|
||||
bool getSelfTestBit();
|
||||
void setSelfTestBit(bool selfTestBit);
|
||||
bool getSpiBit();
|
||||
void setSpiBit(bool spiBit);
|
||||
bool getInterruptLevelBit();
|
||||
void setInterruptLevelBit(bool interruptLevelBit);
|
||||
bool getFullResBit();
|
||||
void setFullResBit(bool fullResBit);
|
||||
bool getJustifyBit();
|
||||
void setJustifyBit(bool justifyBit);
|
||||
void printAllRegister();
|
||||
|
||||
private:
|
||||
void writeTo(byte address, byte val);
|
||||
void writeToI2C(byte address, byte val);
|
||||
void writeToSPI(byte address, byte val);
|
||||
void readFrom(byte address, int num, byte buff[]);
|
||||
void readFromI2C(byte address, int num, byte buff[]);
|
||||
void readFromSPI(byte address, int num, byte buff[]);
|
||||
void setRegisterBit(byte regAdress, int bitPos, bool state);
|
||||
bool getRegisterBit(byte regAdress, int bitPos);
|
||||
byte _buff[6] ; // 6 Bytes Buffer
|
||||
int _CS = 10;
|
||||
bool I2C = true;
|
||||
unsigned long SPIfreq = 5000000;
|
||||
uint8_t _i2c_addr;
|
||||
};
|
||||
void print_byte(byte val);
|
||||
#endif
|
||||
@@ -10,7 +10,7 @@ lib_ignore = ESP8266WiFi, ESP8266Ping, ESP8266WebServer, ESP8266H
|
||||
|
||||
[esp32_common]
|
||||
extends = common, core_esp32_3_3_0
|
||||
lib_deps = td-er/ESPeasySerial @ 2.0.7, adafruit/Adafruit ILI9341 @ ^1.5.6, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO, VL53L0X @ 1.3.0, SparkFun VL53L1X 4m Laser Distance Sensor @ 1.2.9, td-er/SparkFun MAX1704x Fuel Gauge Arduino Library @ ^1.0.1, ArduinoOTA, ESP32HTTPUpdateServer
|
||||
lib_deps = td-er/ESPeasySerial @ 2.0.7, adafruit/Adafruit ILI9341 @ ^1.5.6, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO, VL53L0X @ 1.3.0, SparkFun VL53L1X 4m Laser Distance Sensor @ 1.2.9, td-er/SparkFun MAX1704x Fuel Gauge Arduino Library @ ^1.0.1, ArduinoOTA, ESP32HTTPUpdateServer, SparkFun ADXL345 Arduino Library
|
||||
lib_ignore = ${esp32_always.lib_ignore}, ESP32_ping, IRremoteESP8266, HeatpumpIR
|
||||
board_build.f_flash = 80000000L
|
||||
board_build.flash_mode = dout
|
||||
|
||||
@@ -52,7 +52,7 @@ extends = common
|
||||
board_build.f_cpu = 80000000L
|
||||
build_flags = ${debug_flags.build_flags} ${mqtt_flags.build_flags} -DHTTPCLIENT_1_1_COMPATIBLE=0
|
||||
build_unflags = -DDEBUG_ESP_PORT
|
||||
lib_deps = td-er/ESPeasySerial @ 2.0.7, adafruit/Adafruit ILI9341 @ ^1.5.6, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO, bblanchon/ArduinoJson @ ^6.17.2, VL53L0X @ 1.3.0, SparkFun VL53L1X 4m Laser Distance Sensor @ 1.2.9, td-er/RABurton ESP8266 Mutex @ ^1.0.2, td-er/SparkFun MAX1704x Fuel Gauge Arduino Library @ ^1.0.1, ESP8266HTTPUpdateServer
|
||||
lib_deps = td-er/ESPeasySerial @ 2.0.7, adafruit/Adafruit ILI9341 @ ^1.5.6, Adafruit GFX Library, LOLIN_EPD, Adafruit BusIO, bblanchon/ArduinoJson @ ^6.17.2, VL53L0X @ 1.3.0, SparkFun VL53L1X 4m Laser Distance Sensor @ 1.2.9, td-er/RABurton ESP8266 Mutex @ ^1.0.2, td-er/SparkFun MAX1704x Fuel Gauge Arduino Library @ ^1.0.1, ESP8266HTTPUpdateServer, SparkFun ADXL345 Arduino Library
|
||||
lib_ignore = ${esp82xx_defaults.lib_ignore}, IRremoteESP8266, HeatpumpIR, LittleFS(esp8266), ServoESP32, TinyWireM
|
||||
board = esp12e
|
||||
monitor_filters = esp8266_exception_decoder
|
||||
|
||||
Reference in New Issue
Block a user