Overview
This tutorial explains how to interface the ADXL375 Accelerometer module with the ESP32 Microcontroller to measure acceleration in the X, Y, and Z axes.
Today, we will introduce you to a very powerful and highly advanced accelerometer called ADXL375, which can measure acceleration up to ±200 g. You might be familiar with accelerometer modules like ADXL335 or ADXL345, as well as MPU6050. Well, these modules are good for simpler projects but fail miserably when working on applications that require high precision, high resolution, and extreme ranges.
This is the ADXL375 module, which is a digital MEMS accelerometer from Analog Devices. The sensor is small and thin, with ultra-low power consumption as low as 35 µA in measurement mode. The best thing about this sensor is that it can measure acceleration up to ±200 g. Imagine reading such a high gravitational pull of the Earth or measuring the acceleration of a very fast-moving object—here, the ADXL375 is perfect.
In this tutorial, we will first go through the ADXL375 features, capabilities, pinout, and other details. Then, we will show you how you can use this sensor with ESP32o using C++ code. You may follow the ADXL375 Arduino guide as well as ADXL375 Raspberry Pi Pico guide.
Components Required
The following are the components required for this tutorial.
| S.N. | Components Name | Quantity | Purchase Link |
|---|---|---|---|
| 1 | ESP32 Board | 1 | Amazon | AliExpress |
| 2 | ADXL375 Accelerometer | 1 | Amazon | AliExpress |
| 3 | Connecting Wires | 10 | Amazon | AliExpress |
| 4 | Breadboard | 1 | Amazon | AliExpress |
ADXL375 Accelerometer
The ADXL375 is a small, thin, 3-axis accelerometer that provides low power consumption and high resolution measurement up to ±200 g.
The digital output data is formatted as 16-bit, two’s complement data and is accessible through a SPI or I2C digital interface. It supports a bandwidth of up to 1 Kilo Hertz. The bandwidth is selectable via Serial Command. An integrated memory management system with a 32-level FIFO buffer can be used to store data to minimize host processor activity and lower overall system power consumption.
The sensor has the ability to determine shock, even, or could be used in an activity or inactivity monitoring system. One shocking thing to notice about this module is, it has a 10,000g shock survival, which is amazing. According to the datasheet, it could be used for concussion and head trauma detection, and also for high-force event detection. To learn more about the ADXL375 Module, you may go through the ADXL375 Datasheet.
ADXL375 Features & Specifications
- Measurement Range: ±200 g (fixed) with 13-bit two ’s-complement output
- Sensitivity: 49 mg/LSB (0.049 g/LSB) → ~0.4805 mg resolution when converted to m/s²
- Power Consumption:
- Measurement mode: 35 µA typical
- Standby mode: 0.1 µA typical (VS = 2.5 V)
- Note: Supply current varies with output data rate/bandwidth setting
- Output Data Rate / Bandwidth:
- User-selectable via serial registers
- Bandwidth up to 1 kHz (ODR up to 1 kHz)
- FIFO Buffer: 32-sample watermark FIFO reduces host-processor load
- Event Detection:
- Single-tap / double-tap (impulse) detection
- Activity/inactivity monitoring with programmable thresholds & durations
- Digital Interfaces:
- I²C (7-bit address = 0x53 when ALT_ADDRESS = LOW)
- SPI (3- or 4-wire)
- Supply Voltage: 2.0 V to 3.6 V
- I/O Voltage Range: 1.7 V to VS
- Operating Temperature: –40 °C to +85 °C
- Shock Survivability: 10,000 g (non-operating)
- Package / RoHS: 3 × 5 × 1 mm LGA, RoHS-compliant
Hardware Connection between ESP32 & ADXL375 Accelerometer
First, let’s perform basic testing of ADXL375 with the ESP32 Microcontroller Board. Here is the simple schematic
We can connect the ADXL375 to the ESP32 via the I²C interface. In most of the ESP32 board, the SDA and SCL pins are D21 and D22 respectively.
We can simplify the breadboard wiring with jumper cables and ensure the ADXL375 is oriented as shown on the breakout board.
Source Code/Program: Getting ADXL325 ESP32 Acceleration Readings
To develop firmware, we can use the well-written ADXL375 Adafruit library/a>. You can download the repository from GitHub and add it to the Arduino IDE via the Library Manager.
Next, the following code is the modified example sketch for I²C mode.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
#include <Wire.h> #include <Adafruit_Sensor.h> #include <Adafruit_ADXL375.h> // ——— I²C SETUP ——— // Use the “default Wire” constructor (just the sensor ID) Adafruit_ADXL375 accel = Adafruit_ADXL375(12345); // If you ever need to override the address, you can call begin(0x53) below. // ALT_ADDRESS pin tied to GND → 0x53. void displayDataRate(void) { Serial.print("Data Rate: "); switch (accel.getDataRate()) { case ADXL343_DATARATE_3200_HZ: Serial.print("3200 "); break; case ADXL343_DATARATE_1600_HZ: Serial.print("1600 "); break; case ADXL343_DATARATE_800_HZ: Serial.print("800 "); break; case ADXL343_DATARATE_400_HZ: Serial.print("400 "); break; case ADXL343_DATARATE_200_HZ: Serial.print("200 "); break; case ADXL343_DATARATE_100_HZ: Serial.print("100 "); break; case ADXL343_DATARATE_50_HZ: Serial.print("50 "); break; case ADXL343_DATARATE_25_HZ: Serial.print("25 "); break; case ADXL343_DATARATE_12_5_HZ: Serial.print("12.5 "); break; case ADXL343_DATARATE_6_25HZ: Serial.print("6.25 "); break; case ADXL343_DATARATE_3_13_HZ: Serial.print("3.13 "); break; case ADXL343_DATARATE_1_56_HZ: Serial.print("1.56 "); break; case ADXL343_DATARATE_0_78_HZ: Serial.print("0.78 "); break; case ADXL343_DATARATE_0_39_HZ: Serial.print("0.39 "); break; case ADXL343_DATARATE_0_20_HZ: Serial.print("0.20 "); break; case ADXL343_DATARATE_0_10_HZ: Serial.print("0.10 "); break; default: Serial.print("???? "); break; } Serial.println("Hz"); } void setup(void) { Serial.begin(115200); while (!Serial) delay(10); Serial.println("ADXL375 I²C Accelerometer Test"); // Initialize I2C Wire.begin(); // Try to start the sensor on address 0x53 if (!accel.begin(0x53)) { Serial.println("Ooops, no ADXL375 detected ... Check your wiring!"); while (1) delay(10); } // (Optional) change data rate — default is 100 Hz accel.setDataRate(ADXL343_DATARATE_100_HZ); // Note: range is fixed at ±200 g on the ADXL375 Serial.println(); accel.printSensorDetails(); displayDataRate(); Serial.println(); } void loop(void) { sensors_event_t event; accel.getEvent(&event); 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.println(" m/s^2"); delay(500); } |
Upload this code to the ESP32 Board and then open the Serial monitor. You will see the Acceleration data on the serial monitor for all the x, y, and z axes.
The x and y data should be almost zero as the sensor is placed on a flat surface. The z-axis data should be almost 9.8 m/s2 due to the gravitational pull of the Earth. But it’s showing some offset readings. That’s why you modified the code for auto calibration.
Source Code/Program: Read ADXL375 Acceleration with Auto Calibration
Here is another code for reading the correct values of acceleration in the x, y, and z axis using the ESP32 and ADXL375
We first average 100 readings with the board held flat to compute x_offset, y_offset, and z_offset = avg_z – 9.80665 m/s². Then, on each loop, we subtract those offsets from the raw readings so that X/Y read ~0 and Z reads ~9.8 m/s² when the sensor is level.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
#include <Wire.h> #include <Adafruit_Sensor.h> #include <Adafruit_ADXL375.h> // I²C constructor; we’ll call begin(0x53) below. Adafruit_ADXL375 accel = Adafruit_ADXL375(12345); // Offsets computed at startup: float x_offset = 0, y_offset = 0, z_offset = 0; // Helper to print current data rate void displayDataRate() { Serial.print("Data Rate: "); switch (accel.getDataRate()) { case ADXL343_DATARATE_3200_HZ: Serial.print("3200"); break; case ADXL343_DATARATE_1600_HZ: Serial.print("1600"); break; case ADXL343_DATARATE_800_HZ: Serial.print("800"); break; case ADXL343_DATARATE_400_HZ: Serial.print("400"); break; case ADXL343_DATARATE_200_HZ: Serial.print("200"); break; case ADXL343_DATARATE_100_HZ: Serial.print("100"); break; case ADXL343_DATARATE_50_HZ: Serial.print("50"); break;<span data-mce-type="bookmark" style="display: inline-block; width: 0px; overflow: hidden; line-height: 0;" class="mce_SELRES_start"></span> case ADXL343_DATARATE_25_HZ: Serial.print("25"); break; case ADXL343_DATARATE_12_5_HZ: Serial.print("12.5"); break; default: Serial.print("?"); break; } Serial.println(" Hz"); } void setup() { Serial.begin(115200); while (!Serial) delay(10); Serial.println("ADXL375 I²C Auto-Cal Accelerometer"); // --- I²C on custom ESP32 pins SDA=21, SCL=22 --- Wire.begin(); // Start the sensor at address 0x53 if (!accel.begin(0x53)) { Serial.println("ERROR: ADXL375 not found. Check wiring!"); while (1) delay(10); } // Optional: change from default 100 Hz accel.setDataRate(ADXL343_DATARATE_100_HZ); Serial.println(); accel.printSensorDetails(); displayDataRate(); Serial.println(); // --- AUTO CALIBRATION --- Serial.println("Calibrating... keep sensor FLAT and STILL"); const int SAMPLES = 100; float sum_x = 0, sum_y = 0, sum_z = 0; sensors_event_t evt; for (int i = 0; i < SAMPLES; i++) { accel.getEvent(&evt); sum_x += evt.acceleration.x; sum_y += evt.acceleration.y; sum_z += evt.acceleration.z; delay(20); } float avg_x = sum_x / SAMPLES; float avg_y = sum_y / SAMPLES; float avg_z = sum_z / SAMPLES; // X/Y → zero; Z → 1 g x_offset = avg_x; y_offset = avg_y; z_offset = avg_z - SENSORS_GRAVITY_STANDARD; Serial.print("X offset = "); Serial.println(x_offset, 4); Serial.print("Y offset = "); Serial.println(y_offset, 4); Serial.print("Z offset = "); Serial.println(z_offset, 4); Serial.println("Calibration done!\n"); } void loop() { sensors_event_t evt; accel.getEvent(&evt); // apply offsets float x = evt.acceleration.x - x_offset; float y = evt.acceleration.y - y_offset; float z = evt.acceleration.z - z_offset; Serial.print("X: "); Serial.print(x, 2); Serial.print(" Y: "); Serial.print(y, 2); Serial.print(" Z: "); Serial.print(z, 2); Serial.println(" m/s^2"); delay(500); } |
Upload this code again to the ESP32 Board. The reading will be correct now.
To observe the change in reading, shake the sensor or move the sensor, or jerk it. You will see a massive change in the reading.
