Tag:

accelerometer

ESP32 and MMA8452 accelerometer example

by shedboy71 25th June 2019

In this example we will connect a MMA8452Q accelerometer to an ESP32 – in this case

Lets look at the sensor

The MMA8452Q is a smart, low-power, three-axis, capacitive, micromachined accelerometer with 12 bits of resolution. This accelerometer is packed with embedded functions with flexible user programmable options, configurable to two interrupt pins. Embedded interrupt functions allow for overall power savings relieving the host processor from continuously polling data.

The MMA8452Q has user selectable full scales of ±2 g/±4 g/±8 g with high-pass filtered data as well as non-filtered data available real-time. The device can be configured to generate inertial wakeup interrupt signals from any combination of the configurable embedded functions allowing the MMA8452Q to monitor events and remain in a low-power mode during periods of inactivity

Connection

Here is a layout, its an easy device to connect

esp32 and mma8452

Parts List

Here are the parts I used

Part name	Link
ESP32 – Lolin32	New ESP-32 esp32 Lite V1.0.0 For Rev1 wifi Module + bluetooth board 4MB FLASH

MMA8452 sensor	GY-45 MMA8452 Module Digital Triaxial Accelerometer Precision Tilt 3-Axis
Dupont cable	Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire Dupont cablefor Arduino

Code

This example does not require any libraries

[codesyntax lang=”cpp”]

// Distributed with a free-will license.
// Use it any way you want, profit or free, provided it fits in the licenses of its associated works.
// MMA8452Q
// This code is designed to work with the MMA8452Q_I2CS I2C Mini Module available from ControlEverything.com.
// https://www.controleverything.com/content/Accelorometer?sku=MMA8452Q_I2CS#tabs-0-product_tabset-2

#include <Wire.h>

// MMA8452Q I2C address is 0x1C(28)
#define Addr 0x1C

void setup()
{
  // Initialise I2C communication as MASTER
  Wire.begin();
  // Initialise Serial Communication, set baud rate = 9600
  Serial.begin(9600);

  // Start I2C Transmission
  Wire.beginTransmission(Addr);
  // Select control register
  Wire.write(0x2A);
  // StandBy mode
  Wire.write((byte)0x00);
  // Stop I2C Transmission
  Wire.endTransmission();

  // Start I2C Transmission
  Wire.beginTransmission(Addr);
  // Select control register
  Wire.write(0x2A);
  // Active mode
  Wire.write(0x01);
  // Stop I2C Transmission
  Wire.endTransmission();

  // Start I2C Transmission
  Wire.beginTransmission(Addr);
  // Select control register
  Wire.write(0x0E);
  // Set range to +/- 2g
  Wire.write((byte)0x00);
  // Stop I2C Transmission
  Wire.endTransmission();
  delay(300);
}

void loop()
{
  unsigned int data[7];

  // Request 7 bytes of data
  Wire.requestFrom(Addr, 7);
  
  // Read 7 bytes of data
  // staus, xAccl lsb, xAccl msb, yAccl lsb, yAccl msb, zAccl lsb, zAccl msb
  if(Wire.available() == 7) 
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
    data[2] = Wire.read();
    data[3] = Wire.read();
    data[4] = Wire.read();
    data[5] = Wire.read();
    data[6] = Wire.read();
  }

  // Convert the data to 12-bits
  int xAccl = ((data[1] * 256) + data[2]) / 16;
  if (xAccl > 2047)
  {
    xAccl -= 4096;
  }
    
  int yAccl = ((data[3] * 256) + data[4]) / 16;
  if (yAccl > 2047)
  {
    yAccl -= 4096;
  }
    
  int zAccl = ((data[5] * 256) + data[6]) / 16;
  if (zAccl > 2047)
  {
    zAccl -= 4096;
  }

  // Output data to serial monitor
  Serial.print("Acceleration in X-Axis : ");
  Serial.println(xAccl);
  Serial.print("Acceleration in Y-Axis : ");
  Serial.println(yAccl);
  Serial.print("Acceleration in Z-Axis : ");
  Serial.println(zAccl);
  delay(500);
}

[/codesyntax]

Output

Open the serial monitor – this is what you should expect to see

Acceleration in X-Axis : -809
Acceleration in Y-Axis : -111
Acceleration in Z-Axis : 1508
Acceleration in X-Axis : -1696
Acceleration in Y-Axis : 346
Acceleration in Z-Axis : 1319
Acceleration in X-Axis : -458
Acceleration in Y-Axis : -851
Acceleration in Z-Axis : 2047
Acceleration in X-Axis : -31
Acceleration in Y-Axis : -813
Acceleration in Z-Axis : 2047
Acceleration in X-Axis : 235
Acceleration in Y-Axis : 46
Acceleration in Z-Axis : 1315

Links

https://www.nxp.com/docs/en/data-sheet/MMA8452Q.pdf

Code

LIS3DSH accelerometer sensor and an ESP32

by shedboy71 14th March 2019

In this example we connect a LIS3DSH sensor to an ESP32.

The LIS3DSH is an ultra-low-power high-performance three-axis linear accelerometer belonging to the “nano” family with an embedded state machine that can be programmed to implement autonomous applications.

The LIS3DSH has dynamically selectable full scales of ±2g/±4g/±6g/±8g/±16g and is capable of measuring accelerations with output data rates from 3.125 Hz to 1.6 kHz. The self-test capability allows the user to check the functioning of the sensor in the final application. The device can be configured to generate interrupt signals activated by user-defined motion patterns.

The LIS3DSH has an integrated first-in, first-out (FIFO) buffer allowing the user to store data in order to limit intervention by the host processor. The LIS3DSH is available in a small thin plastic land grid array package (LGA) and is guaranteed to operate over an extended temperature range from -40 °C to +85 °C.

Key Features

Wide supply voltage, 1.71 V to 3.6 V
Independent IOs supply (1.8 V) and supply voltage compatible
Ultra-low power consumption
±2g/±4g/±6g/±8g/±16g dynamically selectable full scale
I²C/SPI digital output interface
16-bit data output
Programmable embedded state machines
Embedded temperature sensor
Embedded self-test
Embedded FIFO
10000 g high shock survivability

Parts List

Part	Link
ESP32	New ESP-32 esp32 Lite V1.0.0 For Rev1 wifi Module + bluetooth board 4MB FLASH
LIS3DSH module	CJMCU- LIS3DSH High-resolution Three-axis Accelerometer Triaxial Accelerometer Module LIS3DH
Connecting Wire	Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Connection

ESP32 and LIS3DSH

Code

You need to download and install the https://github.com/yazug/LIS3DSH library

<pre>#include <Wire.h>
#include <LIS3DSH.h>

LIS3DSH accel;

void setup() 
{
  Serial.begin(9600);
  Wire.begin();
  accel.enableDefault();
}

void loop() 
{
  int16_t x, y, z;
  int8_t temperature;

  accel.readAccel(&x, &y, &z);
  accel.readTemperature(&temperature);

  Serial.print("Accel ");
  Serial.print("X: ");
  Serial.print(x);
  Serial.print(" Y: ");
  Serial.print(y);
  Serial.print(" Z: ");
  Serial.print(z);
  Serial.print(" T: ");
  Serial.println(temperature);

  delay(100);
}</pre>

Output

Open the serial monitor and you should see something like this – move the module around

Accel X: 361 Y: 5144 Z: 15700 T: -9
Accel X: 409 Y: 5094 Z: 15698 T: -9
Accel X: 365 Y: 5166 Z: 15672 T: -9
Accel X: 377 Y: 5157 Z: 15667 T: -9
Accel X: 1787 Y: -6196 Z: 31329 T: -9
Accel X: 8636 Y: 2808 Z: 15889 T: -9
Accel X: -12408 Y: 5444 Z: -16233 T: -9
Accel X: 8588 Y: 27588 Z: 19617 T: -9
Accel X: 9702 Y: 25909 Z: 522 T: -9
Accel X: -15119 Y: 6115 Z: -19391 T: -9
Accel X: 12926 Y: -3281 Z: 5542 T: -9
Accel X: 4313 Y: -32032 Z: 32757 T: -9
Accel X: -7917 Y: 8240 Z: 20966 T: -9

Link

Code

ESP32 and ADXL335 accelerometer example

by shedboy71 6th February 2018

The ADXL335 is a small, thin, low power, complete 3-axis accelerometer with signal conditioned voltage outputs. The product measures acceleration with a minimum full-scale range of ±3 g. It can measure the static acceleration of gravity in tiltsensing applications, as well as dynamic acceleration resulting from motion, shock, or vibration.

The user selects the bandwidth of the accelerometer using the CX, CY, and CZ capacitors at the XOUT, YOUT, and ZOUT pins. Bandwidths can be selected to suit the application, with a range of 0.5 Hz to 1600 Hz for X and Y axes, and a range of 0.5 Hz to 550 Hz for the Z axis.

Here is a typical module that makes it easy to work with the ADXL335

Features:

Name: ADXL335 module (triaxial accelerometer analog output)
Model: GY-61
Power supply :3-5v
Analog X, Y, Z three-axis output

Schematic

The following layout shows how to wire the ADXL335 module up to an ESP32 (LOLIN32)

esp32 and ADXL335

Code

const int xpin = A0; // x-axis of the accelerometer
const int ypin = A3; // y-axis
const int zpin = A4; // z-axis

void setup()
{
Serial.begin(9600);
}

void loop()
{
int x = analogRead(xpin); //read from xpin
delay(1); //
int y = analogRead(ypin); //read from ypin
delay(1);
int z = analogRead(zpin); //read from zpin

float zero_G = 512.0; //ADC is 0~1023 the zero g output equal to Vs/2
float scale = 102.3; //ADXL335330 Sensitivity is 330mv/g
//330 * 1024/3.3/1000
Serial.print(((float)x - 331.5)/65*9.8); //print x value on serial monitor
Serial.print("\t");
Serial.print(((float)y - 329.5)/68.5*9.8); //print y value on serial monitor
Serial.print("\t");
Serial.print(((float)z - 340)/68*9.8); //print z value on serial monitor
Serial.print("\n");
delay(1000); //wait for 1 second
}

Output

Open the serial monitor and you should see something like this

281.56 190.49 227.99
282.16 188.63 227.56
241.91 172.47 268.92
285.33 230.55 247.74
234.97 260.45 197.73
209.04 263.74 249.76
214.62 150.43 242.41
322.57 165.74 211.56
264.98 170.75 222.09
260.76 168.17 216.32

Links

http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL335.pdf

The sensor costs under $2

GY-61 ADXL335 Module Triaxial Acceleration Gravity Angle Sensor

Code

ESP32 and BMI160 sensor example

by shedboy71 26th November 2017

The BMI160 is a small, low power, low noise 16-bit inertial measurement unit designed for use in mobile applications like augmented reality or indoor navigation which require highly accurate, real-time sensor data.

bmi160 module

In full operation mode, with both the accelerometer and gyroscope enabled, the current consumption is typically 950 μA, enabling always-on applications in battery driven devices. It is available in a compact 14-pin 2.5 x 3.0 x 0.8 mm³ LGA package.

Features

Parameter	Technical data
Digital resolution	Accelerometer (A): 16 bit Gyroscope (G): 16bit
Measurement ranges (programmable)	(A): ± 2 g, ± 4 g, ± 8 g, ± 16 g (G): ± 125°/s, ± 250°/s, ± 500°/s, ± 1000°/s, ± 2000°/s
Sensitivity (calibrated)	(A): ±2g: 16384LSB/g ±4g: 8192LSB/g ±8g: 4096LSB/g ±16g: 2048LSB/g (G): ±125°/s: 262.4 LSB/°/s ±250°/s: 131.2 LSB/°/s ±500°/s: 65.6 LSB/°/s ±1000°/s: 32.8 LSB/°/s ±2000°/s: 16.4 LSB/°/s
Zero-g offset (typ., over life-time)	(A): ±40mg (G): ± 10°/s
Noise density (typ.)	(A): 180 μg/√Hz (G): 0.008 °/s/√Hz
Bandwidths (programmable)	1600 Hz … 25/32 Hz
Digital inputs/outputs	SPI, I²C, 4x digital interrupts
Supply voltage (VDD)	1.71 … 3.6 V
I/0 supply voltage (VDDIO)	1.2 … 3.6 V
Temperature range	-40 … +85°C
Current consumption – full operation – low-power mode	950 μA 3 μA
FIFO data buffer	1024 byte
LGA package	2.5 × 3.0 × 0.8 mm³
Shock resistance	10,000 g x 200 μs

Connection

LOLIn32 pin	Module Pin
3v3	3v3
Gnd	Gnd
SDA/22	SDA
SCL/21	SCL

Code

This example used the following library – https://github.com/hanyazou/BMI160-Arduino

[codesyntax lang=”cpp”]

#include <BMI160Gen.h>

const int select_pin = 10;
const int i2c_addr = 0x69;

void setup() {
  Serial.begin(9600); // initialize Serial communication
  while (!Serial);    // wait for the serial port to open

  // initialize device
  //BMI160.begin(BMI160GenClass::SPI_MODE, select_pin);
  BMI160.begin(BMI160GenClass::I2C_MODE, i2c_addr);
}

void loop() {
  int gx, gy, gz;         // raw gyro values

  // read raw gyro measurements from device
  BMI160.readGyro(gx, gy, gz);

  // display tab-separated gyro x/y/z values
  Serial.print("g:\t");
  Serial.print(gx);
  Serial.print("\t");
  Serial.print(gy);
  Serial.print("\t");
  Serial.print(gz);
  Serial.println();

  delay(500);
}

[/codesyntax]

Output

Open the serial monitor

g: 90 86 9
g: 69 69 40
g: 35 97 -9
g: -7370 3961 -1786
g: -31829 -2652 32767
g: -3221 25109 32767
g: 26020 31878 -26125
g: -20332 -21698 -15712
g: -7297 3463 -1723
g: -1137 1521 420
g: -203 305 96
g: 144 -102 54
g: 77 116 35

Links

https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMI160-DS000-07.pdf
CJMCU-160I BMI160 latest inertial measurement sensor attitude module 6DOF

Code

ESP32 and MMA7361 accelerometer example

by shedboy71 19th November 2017

The MMA7361L is a low power, low profile capacitive micromachined accelerometer featuring signal conditioning, a 1-pole low pass filter, temperature compensation, self test, 0g-Detect which detects linear freefall, and g-Select which allows for the selection between 2 sensitivities. Zero-g offset and sensitivity are factory set and require no external devices. The MMA7361L includes a Sleep Mode that makes it ideal for handheld battery powered electronics.

Features
• 3mm x 5mm x 1.0mm LGA-14 Package
• Low Current Consumption: 400 μA
• Sleep Mode: 3 μA
• Low Voltage Operation: 2.2 V – 3.6 V
• High Sensitivity (800 mV/g @ 1.5g)
• Selectable Sensitivity (±1.5g, ±6g)
• Fast Turn On Time (0.5 ms Enable Response Time)
• Self Test for Freefall Detect Diagnosis
• 0g-Detect for Freefall Protection
• Signal Conditioning with Low Pass Filter
• Robust Design, High Shocks Survivability
• RoHS Compliant
• Environmentally Preferred Product
• Low Cost

Typical Applications
• 3D Gaming: Tilt and Motion Sensing, Event Recorder
• HDD MP3 Player: Freefall Detection
• Laptop PC: Freefall Detection, Anti-Theft
• Cell Phone: Image Stability, Text Scroll, Motion Dialing, E-Compass
• Pedometer: Motion Sensing
• PDA: Text Scroll
• Navigation and Dead Reckoning: E-Compass Tilt Compensation
• Robotics: Motion Sensing

Schematic and connection

esp32 and mma7361

Code


int x;
int y;
int z;

void setup()
{
Serial.begin(9600);
}

void loop()
{
x = analogRead(A4); // read A5 input pin
y = analogRead(A3); // read A4 input pin
z = analogRead(A0); // read A3 input pin
Serial.print("X = "); // print x value
Serial.println(x);
Serial.print("Y = "); // print y value
Serial.println(y);
Serial.print("Z = "); // print z value
Serial.println(z);
delay(1000);
}

Output

Open the serial monitor and move the sensor around, you should see soemthing like this

X = 86
Y = 82
Z = 656
X = 68
Y = 80
Z = 640
X = 76
Y = 80
Z = 657
X = 422
Y = 96
Z = 653
X = 354
Y = 80
Z = 656
X = 1573
Y = 216
Z = 857

Links

http://www.nxp.com/files/sensors/doc/data_sheet/MMA7361L.pdf

MMA7361 Angle Sensor Inclination Accelerometer Module For Arduino

Code

ESP32 and LSM303 sensor example

by shedboy71 13th November 2017

The LSM303 3D Accelerometers/Magnetometer Models are a system-in-package featuring a 3D digital linear acceleration sensor and a 3D digital magnetic sensor. These best-in-class eCompass devices enable superior PDR or unique use cases in emerging applications, including drones and personal navigation systems.

All full-scales available are fully selectable by the user. The device includes an I²C serial bus interface that supports standard and fast mode 100kHz and 400kHz.

Advanced magnetic-sensing and MEMS technologies enable benchmark accuracy, with superior stability, power-saving and integration
3 magnetic field channels and 3 acceleration channels
16-bit data output
SPI and/or I²C serial interfaces
Analog supply voltage 2.16V to 3.6V
Power-down mode / low-power mode
Programmable interrupt generators for freefall, motion detection and magnetic field detection
Embedded temperature sensor

Here is a picture of the module I bought

LSM303 module

This is a schematic of a typical module such as the one above

lsm303 module schematic

Now lets look at a layout showing how to connect the module to our Wemos Mini

Schematic and layout

Quite a straightforward connection being an I2C device, here is what you need to connect

lolin32 and lsm303

Code

You need to import the https://github.com/pololu/lsm303-arduino library, this is the example code

#include <Wire.h>
#include <LSM303.h>

LSM303 compass;

char report[80];

void setup()
{
Serial.begin(9600);
Wire.begin();
compass.init();
compass.enableDefault();
}

void loop()
{
compass.read();

snprintf(report, sizeof(report), "A: %6d %6d %6d M: %6d %6d %6d",
compass.a.x, compass.a.y, compass.a.z,
compass.m.x, compass.m.y, compass.m.z);
Serial.println(report);

delay(500);
}

Testing

Open the Serial Monitor window and you should see something like this, move the module about to see the values change

A: 11760 -10560 -3648 M: -177 599 341
A: 8192 -256 -12224 M: -290 155 512
A: -6352 -2288 592 M: -240 609 133
A: 13424 3312 -9952 M: -458 168 343
A: 8848 -816 -9088 M: -398 152 431
A: 11104 4848 -7776 M: -457 75 355
A: 12896 6992 -7104 M: -465 60 348
A: 12720 7152 -6960 M: -462 53 348
A: 12752 7312 -6784 M: -459 48 343
A: 12800 7408 -6656 M: -459 44 342
A: 12816 7472 -6592 M: -464 41 337
A: 12864 7616 -6496 M: -466 36 337
A: 12896 7680 -6416 M: -464 35 336
A: 12864 7712 -6272 M: -465 34 333

Links
AliExpress.com Product – Accelerometer + 3 Axis Magnetometer Module Sensor

Code

ESP32 and ADXL345 sensor example

by shedboy71 12th November 2017

The ADXL345 is a small, thin, low power, 3-axis accelerometer with high resolution (13-bit) measurement at up to ±16g. Digital output data is formatted as 16-bit twos complement and is accessible through either a SPI (3- or 4-wire) or I²C digital interface.

The ADXL345 is well suited for mobile device applications. It 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°.

Several special sensing functions are provided. Activity and inactivity sensing detect the presence or lack of motion and if the acceleration on any axis exceeds a user-set level. Tap sensing detects single and double taps. Free-fall sensing detects if the device is falling. These functions can be mapped to one of two interrupt output pins. An integrated, patent pending 32-level first in, first out (FIFO) buffer can be used to store data to minimize host processor intervention.

adxl345 module

Connection and layout

I used the following connection from the module above to my Wemos Mini

LOLIN32 Connection	Module Connection
3v3	VCC
Gnd	Gnd
SDA 21	SDA
SCL 22	SCL

Here is a layout for reference

lolin32 and adxl345

Code

This needs the Adafruit library – https://github.com/adafruit/Adafruit_ADXL345

This is just the sensor test code from the library above

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>

/* Assign a unique ID to this sensor at the same time */
Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);

void displaySensorDetails(void)
{
sensor_t sensor;
accel.getSensor(&sensor);
Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name);
Serial.print ("Driver Ver: "); Serial.println(sensor.version);
Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println(" m/s^2");
Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println(" m/s^2");
Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println(" m/s^2");
Serial.println("------------------------------------");
Serial.println("");
delay(500);
}

void displayDataRate(void)
{
Serial.print ("Data Rate: ");

switch(accel.getDataRate())
{
case ADXL345_DATARATE_3200_HZ:
Serial.print ("3200 ");
break;
case ADXL345_DATARATE_1600_HZ:
Serial.print ("1600 ");
break;
case ADXL345_DATARATE_800_HZ:
Serial.print ("800 ");
break;
case ADXL345_DATARATE_400_HZ:
Serial.print ("400 ");
break;
case ADXL345_DATARATE_200_HZ:
Serial.print ("200 ");
break;
case ADXL345_DATARATE_100_HZ:
Serial.print ("100 ");
break;
case ADXL345_DATARATE_50_HZ:
Serial.print ("50 ");
break;
case ADXL345_DATARATE_25_HZ:
Serial.print ("25 ");
break;
case ADXL345_DATARATE_12_5_HZ:
Serial.print ("12.5 ");
break;
case ADXL345_DATARATE_6_25HZ:
Serial.print ("6.25 ");
break;
case ADXL345_DATARATE_3_13_HZ:
Serial.print ("3.13 ");
break;
case ADXL345_DATARATE_1_56_HZ:
Serial.print ("1.56 ");
break;
case ADXL345_DATARATE_0_78_HZ:
Serial.print ("0.78 ");
break;
case ADXL345_DATARATE_0_39_HZ:
Serial.print ("0.39 ");
break;
case ADXL345_DATARATE_0_20_HZ:
Serial.print ("0.20 ");
break;
case ADXL345_DATARATE_0_10_HZ:
Serial.print ("0.10 ");
break;
default:
Serial.print ("???? ");
break;
}
Serial.println(" Hz");
}

void displayRange(void)
{
Serial.print ("Range: +/- ");

switch(accel.getRange())
{
case ADXL345_RANGE_16_G:
Serial.print ("16 ");
break;
case ADXL345_RANGE_8_G:
Serial.print ("8 ");
break;
case ADXL345_RANGE_4_G:
Serial.print ("4 ");
break;
case ADXL345_RANGE_2_G:
Serial.print ("2 ");
break;
default:
Serial.print ("?? ");
break;
}
Serial.println(" g");
}

void setup(void)
{
Serial.begin(9600);
Serial.println("Accelerometer Test"); Serial.println("");

/* Initialise the sensor */
if(!accel.begin())
{
/* There was a problem detecting the ADXL345 ... check your connections */
Serial.println("Ooops, no ADXL345 detected ... Check your wiring!");
while(1);
}

/* Set the range to whatever is appropriate for your project */
accel.setRange(ADXL345_RANGE_16_G);
// displaySetRange(ADXL345_RANGE_8_G);
// displaySetRange(ADXL345_RANGE_4_G);
// displaySetRange(ADXL345_RANGE_2_G);

/* Display some basic information on this sensor */
displaySensorDetails();

/* Display additional settings (outside the scope of sensor_t) */
displayDataRate();
displayRange();
Serial.println("");
}

void loop(void)
{
/* Get a new sensor event */
sensors_event_t event;
accel.getEvent(&event);

/* Display the results (acceleration is measured in m/s^2) */
Serial.print("X: "); Serial.print(event.acceleration.x); Serial.print(" ");
Serial.print("Y: "); Serial.print(event.acceleration.y); Serial.print(" ");
Serial.print("Z: "); Serial.print(event.acceleration.z); Serial.print(" ");Serial.println("m/s^2 ");
delay(500);
}

Output

Open the serial monitor and you should get something like this

X: 4.55 Y: -0.90 Z: -6.67 m/s^2
X: -9.30 Y: 3.96 Z: -4.55 m/s^2
X: -10.43 Y: 2.47 Z: 5.92 m/s^2
X: -1.69 Y: 2.04 Z: -9.96 m/s^2
X: -2.59 Y: 7.96 Z: -4.20 m/s^2
X: -14.20 Y: 6.71 Z: -2.16 m/s^2
X: 3.30 Y: -2.90 Z: -8.04 m/s^2
X: 4.43 Y: -0.16 Z: -8.47 m/s^2
X: 1.45 Y: -2.63 Z: 15.38 m/s^2

Links

AliExpress.com Product – Free shipping GY-291 ADXL345 digital three-axis acceleration of gravity tilt module IIC / SPI transmission

Code

ESP32 and MMA8451 accelerometer example

by shedboy71 12th November 2017

The MMA8451 is a low-power accelerometer with 14 bits of resolution, with the following features:

Embedded functions with flexible user-programmable options, configurable to two interrupt pins
Embedded interrupt functions for overall power savings relieving the host processor from continuously polling data
Access to both low-pass filtered data as well as high-pass filtered data, which minimizes the data analysis required for jolt detection and faster transitions
Inertial wake-up interrupt signals from any combination of the configurable embedded functions allowing the MMA8451Q to monitor events and remain in a low-power mode during periods of inactivity

Features

1.95 to 3.6-volt supply voltage
1.6 to 3.6-volt interface voltage
±2g/±4g/±8g dynamically selectable full-scale
Output data rates (ODR) from 1.56 Hz to 800 Hz
99 μg/√Hz noise
14-bit and 8-bit digital output
I²C digital output interface (operates to 2.25 MHz with 4.7 kΩ pull-up)
Two programmable interrupt pins for seven interrupt sources
Three embedded channels of motion detection
- Freefall or motion detection: one channel
- Pulse detection: one channel
- Jolt detection: one channel
Orientation (portrait/landscape) detection with programmable hysteresis
Automatic ODR change for auto-wake and return to sleep
32 sample FIFO
High pass filter data available per sample and through the FIFO
Self-test

Again due to the size and package of the module its easier to buy a module, here is one that I purchased.

MMA8451

Connection

I used the following connection from the module above to my Lolin 32 module

Lolin32 Connection	Module Connection
3v3	VCC_IN
Gnd	Gnd
SDA 21	SDA
SCL 22	SCL

Here is a layout showing this

lolin32 and mma8451

Code

This requires the Adafruit library from https://github.com/adafruit/Adafruit_MMA8451_Library/archive/master.zip

I had to edit the Adafruit header file called Adafruit_MMA8451.h as my device was address 0x1c (28), I discovered this using an I2C scanner

#define MMA8451_DEFAULT_ADDRESS (0x1C)

#include <Wire.h>
#include "Adafruit_MMA8451.h"
#include <Adafruit_Sensor.h>

Adafruit_MMA8451 mma = Adafruit_MMA8451();

void setup(void) {
Serial.begin(9600);

Serial.println("Adafruit MMA8451 test!");

if (! mma.begin()) {
Serial.println("Couldnt start");
while (1);
}
Serial.println("MMA8451 found!");

mma.setRange(MMA8451_RANGE_2_G);

Serial.print("Range = "); Serial.print(2 << mma.getRange());
Serial.println("G");

}

void loop() {
// Read the 'raw' data in 14-bit counts
mma.read();
Serial.print("X:\t"); Serial.print(mma.x);
Serial.print("\tY:\t"); Serial.print(mma.y);
Serial.print("\tZ:\t"); Serial.print(mma.z);
Serial.println();

/* Get a new sensor event */
sensors_event_t event;
mma.getEvent(&event);

/* Display the results (acceleration is measured in m/s^2) */
Serial.print("X: \t"); Serial.print(event.acceleration.x); Serial.print("\t");
Serial.print("Y: \t"); Serial.print(event.acceleration.y); Serial.print("\t");
Serial.print("Z: \t"); Serial.print(event.acceleration.z); Serial.print("\t");
Serial.println("m/s^2 ");

/* Get the orientation of the sensor */
uint8_t o = mma.getOrientation();

switch (o) {
case MMA8451_PL_PUF:
Serial.println("Portrait Up Front");
break;
case MMA8451_PL_PUB:
Serial.println("Portrait Up Back");
break;
case MMA8451_PL_PDF:
Serial.println("Portrait Down Front");
break;
case MMA8451_PL_PDB:
Serial.println("Portrait Down Back");
break;
case MMA8451_PL_LRF:
Serial.println("Landscape Right Front");
break;
case MMA8451_PL_LRB:
Serial.println("Landscape Right Back");
break;
case MMA8451_PL_LLF:
Serial.println("Landscape Left Front");
break;
case MMA8451_PL_LLB:
Serial.println("Landscape Left Back");
break;
}
Serial.println();
delay(500);

}

Output

Open the serial monitor and you will see something like this, I was moving the sensor about hence the various readings

X: -2166 Y: 1872 Z: 2186X: -2166 Y: 1872 Z: 2186
X: -4.92 Y: 5.99 Z: 4.87 m/s^2
Landscape Left Front

X: -224 Y: -2020 Z: 3188
X: -5.10 Y: -3.19 Z: 7.00 m/s^2
Portrait Up Front

X: -1244 Y: -2208 Z: 788
X: -5.88 Y: -3.77 Z: 2.74 m/s^2
Landscape Left Front

X: 514 Y: -1170 Z: -3436
X: 1.34 Y: -2.83 Z: -8.53 m/s^2
Portrait Up Back

X: 1858 Y: 1258 Z: -2694
X: 3.91 Y: 3.21 Z: -1.56 m/s^2
Landscape Right Back

Links

Here is a link to the module

AliExpress.com Product – GY-45 MMA8451 Modules Digital Triaxial Accelerometer High-precision Inclination Module

Cookie	Duration	Description
cookielawinfo-checkbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.

accelerometer

Connection

Parts List

Code

Output

Links

Parts List

Connection

Code

Output

Link

Connection

Code

Output

Links

Output

Links

Features

Code

Output

Links

Adblock Detected