I found a lot of libraries for the ADXL345. But I felt they were all either not complete or written in such a way that you still have to go deep into the data sheet to use them. This motivated me to write a library myself, which – at least from my point of view – is convenient to use. To make it easy to use more complex functions such as FIFO, I have added 15 example sketches to the library. Due to this large scope, I had to split the article into two parts (click here for part 2<\/a>). <\/p>\n Update 04\/16\/2025:<\/strong> I have added a separate class for the ADXL343 to the library. The same applies to the \u201cdefines\u201d such as ADXL343_RANGE_8G. Since the ADXL343 and ADXL345 have identical registers, the ADXL345 sketches also work unchanged on the ADXL343. <\/p>\n\n I had already described the operating principle of accelerometers in detail in my post about the MPU6050<\/a>.<\/p>\n As with other sensors, I did not use the bare ADXL345 IC for simplicity, but rather a module. These usually have:<\/p>\n The disadvantage of the module compared to the IC is that the power consumption is slightly higher. In the normal operating mode at measuring frequencies below 10 Hz, the consumption of the actual IC should be at 30 \u00b5A. I measured 100 \u00b5A at 5 V supply voltage, and at 3.3 V it was 50 \u00b5A.<\/p>\n\n The best way to explain the features of the ADXL345 is to go through the example sketches.<\/p>\n\n The wiring shown above was used for all example sketches.<\/p>\n The underlying ADXL345 IC can only handle 2.0 – 3.6 volts. This applies to both the power supply and the data pins. Many modules only regulate the supply voltage down, but do not take care of the data pins. The Adafruit modules are one of the laudable exceptions (see here<\/a>). If necessary, add a level shifter. Normally, 3.3 volt components do not break so quickly even at 5 volts on the data lines, but it can affect the service life. <\/p>\n\n And this is what the connection via SPI looks like (here with an Arduino Nano):<\/p>\n\n Here too, you may need to place a level shifter between the microcontroller and the ADXL345.<\/p>\n SPI (4-wire) does not work out of the box with this module:<\/p>\n\n The problem is that SDO is pulled to GND via the 0 \u03a9 resistor R4. SPI 3-Wire would work, but I have not implemented it. Simple remedy: Remove the resistor (desolder or use “careful force”). <\/p>\n\n You can download the library ADXL345_WE here<\/a> from Github. For installation, unzip the ZIP file in the Arduino Library folder. Alternatively, you can install it via the Arduino IDE Library Manager. <\/p>\n As mentioned at the beginning, I tried to make the library user-friendly. Nevertheless, it has become very extensive. This is simply due to the many features of the ADXL345.<\/p>\n I will now guide you through the library using the example sketches. The sketches can be grouped according to the following themes:<\/p>\n I have added lots of comments in all sketches and inserted parameter lists for the functions. But since this can also distract from the essentials, I only print the first sketch completely here. For the others, I take out many comments. If you want to try out the sketches or build on them, take the detailed versions you download with the library. <\/p>\n The post is quite long. Impatient people can also simply try the sample sketches and return here if something should be unclear.<\/strong><\/p>\n\n The ADXL345 stores the determined acceleration values as raw data, which are provided in the data registers for the x, y and z axes. You get the latest values there. The maximum “age” of these depends on the measurement frequency (data rate). A high frequency leads to increased noise and power consumption. So don’t overdo it unnecessarily.<\/p>\n The raw values are converted into acceleration values in g by the library. As a first approximation, the conversion factor in full resolution is 3.9 mg (= milli-g, not milligrams!) per LSB (= Least Significant Bit). In other words:<\/p>\n <\/span> <\/span> For result data, such as raw data, g-values or angles, I have defined the structure (struct) xyzFloat. An xyzFloat consists of three float variables. The raw data “raw” includes, for example, the axis values raw.x, raw.y and raw.z. <\/p>\n\n Let’s get started. In the first example sketch, you will learn about the following features:<\/p>\n As an alternative to the “get as string” functions, you can also use the following functions:<\/p>\n But then you will only get numerical values returned, which you have to “translate”. Look at the library file ADXL345_WE.h for the details of the corresponding enum definitions.<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n For the following output, I tried to position the ADXL345 flat. The raw- and g-values for the x- and y-axes should therefore be zero. The g-value of the z-axis should be 1.<\/p>\n\n You can see small deviations for the x- and y-values and a not insignificant deviation for the z-value. The deviations vary from module to module. The accelerometer is a micromechanical component with certain tolerances.<\/p>\n You may have noticed that the first set of values differs more. It is advisable to discard these first values at program startup, when returning from stand-by mode and some other states. In this specific case, you could simply insert a small delay at the end of the setup.<\/p>\n\n This sketch is a guide to calibrating the ADXL345. Start the sketch and do not change the resolution. Rotat the ADXL345 slowly and try to find the maximum and minimum raw values for the axes. Support your arms because trembling distorts the values. It does not matter one or two units. Write down the values and then use them in the further sketches. How you do this, you will learn see in the example sketch 3.<\/p>\n The maximum and minimum values are +1 g and -1 g respectively (if you perform calibration on our home planet!). For the zero points, according to this method, the following applies:<\/p>\n <\/span> <\/span> Accordingly, an offset is calculated from it. The following applies to the slope:<\/p>\n <\/span> <\/span> \u00a0<\/p>\n<\/div>\n \n\n The values I determined were: xmin<\/sub> = -266.0, xmax<\/sub> = 285.0, ymin<\/sub> = -268.0, ymax<\/sub> = 278.0, zmin<\/sub> = -291.0, zmax<\/sub> = 214.0.<\/p>\n Despite the calibration, you will see some deviations because the zero point is not necessarily really in the middle between the min and max values.<\/p>\n Others suggest attaching the ADXL345 to a cube- or square-shaped body to better align it for calibration. However, this assumes that the ADXL345 has been soldered truly flat to the module and that the module is mounted equally flat to the auxiliary body.<\/p>\n\n Here you can now apply the calibration by entering the values just obtained in the following function:<\/p>\n The function The sketch also calculates the angles of the axes to the horizontal from the g values. Up to angles of 60\u00b0 this works well for x and y. In the next section, you’ll learn about another function that covers higher angles. Here, however, the following simple function is used:<\/p>\n <\/span> <\/span> I explained why this is so and why values close to 90\u00b0 are particularly erroneous in my last post<\/a>. You get the angles via the function If you want to measure angles up to 60\u00b0 quite accurately and want to start at 0\u00b0, you can eliminate the offset that still exists despite calibration. For this purpose, you position the ADXL345 as flat and steady as possible and execute the function The last function I want to introduce for this sketch is \u00a0<\/p>\n<\/div>\n \n\n You can see that the corrected g-values for the z-axis now look much better. The angles have a certain deviation due to the remaining offset. The corrected angles, on the other hand, fluctuate close to zero. <\/p>\n\n I have taken the method of angular calculation described here from other libraries, such as MPU6050 light<\/a> or Arduino-ADXL345<\/a>. The advantage of this method is that it includes several axes and thus compensates for errors. To delineate the method, I have adopted the nomenclature of others and referred to the tilt angle of the x-axis as “pitch” and that of the y-axis as “roll”. You can find a definition for the “pitch” and “roll” angles here<\/a>, for example.<\/p>\n <\/span> <\/span> <\/span> <\/span> Again, of course, the angle determination is only valid in the static state. Additional accelerations distort the result.<\/p>\n Here is the example sketch, or more precisely its main components. As a reminder: the original sample sketches are provided with many more comments.<\/p>\n For comparison, the method from the previous sketch is also used.<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n For the above output, I slowly rotated the ADXL345. I measured the values using simple tools (a protractor). For small to medium angles, the values called “Angle” are closer to reality, at large angles the pitch\/roll method is better.<\/p>\n\n To save power, you can send the ADXL345 to sleep. The function to do this (and to wake it up) is:<\/p>\n Sleep is interrupted by short waking phases. That cannot be stopped. But you can set the wake-up frequency to 1, 2, 4 or 8 Hz. To control the sleep mode together of the wake-up frequency, you can alternatively call the function with two parameters:<\/p>\n If you don’t retrieve new data too often, you won’t notice any difference to the permanent wake mode. Only when the frequency of your readings is greater than the wake-up frequency will you see the effect.<\/p>\n In the example sketch, 10 readings are retrieved in wake and sleep mode. I have set the wake-up frequency to one second, and the readings are sampled at 300 millisecond intervals. Here is the (shortened) sketch:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n For the above output I moved the ADXL345 permanently. You can see that the values in normal mode are different for each query. In Sleep Mode, as expected, 3 to 4 values are identical.<\/p>\n\n Actually, it would be a good time to introduce the Auto Sleep mode next. But for the Auto Sleep mode we need interrupts and therefore we treat this topic first. I’ll come back to the Auto Sleep mode a little later.<\/p>\n\n The ADXL345 distinguishes eight interrupts:<\/p>\n You activate interrupts with the function It is important to note that the interrupts for Overrun, Watermark and Data Ready are always enabled.<\/strong> So, you can’t disable them, just change the output pin. Default is INT1. You have to activate all other interrupts first. You deactivate them with In the interrupt register, in the case of an interrupt, the interrupt type is stored. Reading this register deletes the interrupt so that a new interrupt can be triggered. The function for this is There is another general function, namely First, let’s take a look at the Free Fall interrupt. In the example sketch, it is activated with \u00a0<\/p>\n<\/div>\n \n\n I still have one example sketch for this part 1, then it’s half-time. Here we use the Data Ready interrupt to control the data output. First, I set the measuring frequency with The Data Ready Interrupt is always active. But to not interfere with the other “always-enabled” interrupts, I assigned it to INT2 with The rest is simple. The Data Ready interrupt triggers an interrupt on Arduino Pin 2. This is the signal for reading the measured values. After that, the interrupt is deleted and the next interrupt is expected.<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n In the next article<\/a>, we will come to the example sketches for<\/p>\n The utensils I attached to the ADXL345 module in the post image are from the image of a Swiss Army Knife by Clker-Free-Vector-Images<\/a> on Pixabay<\/a>.<\/p>\nFeatures \/ Technical specifications of the ADXL345 (and ADXL343)<\/h2>\n
![\"ADXL345](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/12\/ADXL345_small.jpg\")
<\/a><\/figure>\n<\/div>\n\n
The most important data at a glance<\/h3>\n\n
\n
\n
\n
\n
Wiring the ADXL345 to the Arduino (I2C)<\/h3>\n\n
![\"Connecting](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/12\/ADXL345__module_wiring-1024x589.png\")
<\/a>\n
Using SPI<\/h3>\n\n
![\"ADXL345](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2024\/04\/ADXL345_SPI_module_wiring-1024x504.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2024\/04\/ADXL345_alt_module-300x157.jpg\")
<\/a>Operation with the library ADXL345_WE<\/h2>\n\n
\n
Basic functions of the ADXL345<\/h2>\n\n
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-f3b412a4ed23e8f9561a8db7328a7348_l3.png\" "\\"Rendered")
<\/p>\n\nExample sketch 1: ADXL345_basic_data.ino<\/h3>\n\n
\n
ADXL345_WE myAcc = ADXL345_WE( )<\/code> creates the object myAcc (stands for “my Accelerometer”). You can pass the I2C address and \/ or a TwoWire object. The latter option allows you to use both I2C buses on one ESP32. <\/li>\ninit()<\/code> initializes the ADXL345 with some default values. The function returns true if the ADXL345 responds as expected.<\/li>\nsetDataRate(range)<\/code> sets the measuring frequency. Select from the parameter list.<\/li>\nsetRange(range)<\/code> sets the g-range. Select from the parameter list.<\/li>\nsetFullRange(true\/false)<\/code> sets the full resolution (10-13 bits) or the reduced resolution (10 bits). The full resolution is preset. I see no reason to change that.<\/li>\ngetDataRateAsString()<\/code> returns the set measuring frequency as a string.<\/li>\ngetRangeAsString()<\/code> returns the g-range as a string.<\/li>\nsetLowPower(true\/false)<\/code> sets the Low Power Mode. It provides power savings for certain data rates at the price of slightly higher noise. <\/li>\n<\/ul>\n\n
getRange()<\/code> \n\/\n getDataRate()<\/code><\/li>\n<\/ul>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n Serial.println(\"ADXL345_Sketch - Basic Data\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n \n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/\n myAcc.setDataRate(ADXL345_DATA_RATE_50);\n delay(100);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n\n\/* In full resolution the size of the raw values depend on the range:\n 2g = 10 bit; 4g = 11 bit; 8g = 12 bit; 16g =13 bit;\n uncomment to change to 10 bit for all ranges. \n *\/\n \/\/ myAcc.setFullRes(false);\n\n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/ \n myAcc.setRange(ADXL345_RANGE_4G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println();\n\n\/* Uncomment to enable Low Power Mode. It saves power but slightly\n increases noise. LowPower only affetcs Data Rates 12.5 Hz to 400 Hz.\n*\/\n \/\/ myAcc.setLowPower(true);\n}\n\n\/* The LSB of the Data registers is 3.9 mg (milli-g, not milligramm).\n This value is used calculating g from raw. However, this is an ideal\n value which you might want to calibrate. \n*\/\n\nvoid loop() {\n xyzFloat raw;\n xyzFloat g;\n myAcc.getRawValues(&raw);\n myAcc.getGValues(&g);\n \n Serial.print(\"Raw-x = \");\n Serial.print(raw.x);\n Serial.print(\" | Raw-y = \");\n Serial.print(raw.y);\n Serial.print(\" | Raw-z = \");\n Serial.println(raw.z);\n\n Serial.print(\"g-x = \");\n Serial.print(g.x);\n Serial.print(\" | g-y = \");\n Serial.print(g.y);\n Serial.print(\" | g-z = \");\n Serial.println(g.z);\n\n Serial.println();\n \n delay(1000);\n}<\/pre>\nOutput of ADXL345_basic_data.ino<\/h4>\n\n
![\"ADXL345](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/12\/basic_data_sketch__output.png\")
<\/a>Example sketch 2: ADXL345_calibration.ino<\/h3>\n\n
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-8cfc65b6504ae96254ab3dde31a110bb_l3.png\" "\\"Rendered")
<\/p>\n\n![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-506069c96f4541c0178587f1b110ce4c_l3.png\" "\\"Rendered")
<\/p>\n<\/p>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n Serial.println(F(\"ADXL345_Sketch - Calibration\"));\n Serial.println();\n if(!myAcc.init()){\n Serial.println(F(\"ADXL345 not connected!\"));\n }\n Serial.println(F(\"Calibration procedure:\"));\n Serial.println(F(\" - stay in full resolution\"));\n Serial.println(F(\" - supply voltage has influence (at least for the modules)\"));\n Serial.println(F(\" -> choose the same voltage you will use in your project!\")); \n Serial.println(F(\" - turn your ADXL slowly (!) to find the min and max raw x,y and z values\"));\n Serial.println(F(\" - deviations of one or two units don't matter much\"));\n Serial.println(F(\" - the calibration changes the slope of g vs raw and assumes zero is (min+max)\/2 \"));\n Serial.println(F(\" - write down the six values \"));\n Serial.println(F(\" - you can try the calibration values in ADXL345_angles_tilt_orientation.ino example sketch\"));\n Serial.println(F(\" - ready to go? Then type in any key and send. \"));\n while(!Serial.available());\n Serial.read();\n Serial.println(); Serial.println(); Serial.println(); \n}\n\nvoid loop() {\n xyzFloat raw;\n myAcc.getRawValues(&raw);\n Serial.print(F(\"Raw-x = \"));\n Serial.print(raw.x);\n Serial.print(F(\" | Raw-y = \"));\n Serial.print(raw.y);\n Serial.print(F(\" | Raw-z = \"));\n Serial.println(raw.z);\n \n delay(1000); \n}\n<\/pre>\nSample sketch 3: ADXL345_angles_orientation.ino<\/h3>\n\n
\n
setCorrFactors(xmin, xmax, ymin, ymax, zmin, zmax)<\/code><\/li>\n<\/ul>\ngetRawValues()<\/code> still provides the uncorrected raw data. getGValues()<\/code>, on the other hand, uses the corrected values. This also applies to all other sketches.<\/p>\n![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-a76b62d93d8b9efaa5aeaa0f0346d9c0_l3.png\" "\\"Rendered")
<\/p>\n\ngetAngles()<\/code>. Since the arcsin function is not defined for values greater than 1, I simply cut g-values greater than 1.<\/p>\nmeasureAngleOffsets()<\/code>. After that, you will receive the additionally corrected values via getCorrAngles()<\/code>.<\/p>\ngetOrientationAsString()<\/code>. This determines which axis is most upwards. Depending on the orientation, it returns: x up, x down, y up, y down, z up or z down as a string.<\/p>\n<\/p>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n Serial.println(\"ADXL345_Sketch\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n \n\/* Add your min and max raw values you found with ADXL345_calibration.ino. \n * The order is: setCorrFactors(min x, max x, min y, max y, min z, max z).\n * setCorrFactors calibrates the slope and assumes the zero point \n * is (min+max)\/2. You have to add the setCorrFactors function to all sketches \n * in which you want to use it.\n*\/\n\/\/ myAcc.setCorrFactors(-266.0, 285.0, -268.0, 278.0, -291.0, 214.0);\n\n\/* In this next step the offset for angles is corrected to get quite precise corrected \n * angles for x and y up to ~60\u00b0. The additional offsetCorrection is only used for \n * corrected angles measurements. The procedure just ensures to start at 0\u00b0.\n*\/\n Serial.println(\"Position your ADXL345 flat and don't move it\");\n delay(2000);\n myAcc.measureAngleOffsets();\n Serial.println(\"....done\");\n \n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/\n myAcc.setDataRate(ADXL345_DATA_RATE_50);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n\n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/\n myAcc.setRange(ADXL345_RANGE_2G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println(); \n}\n\nvoid loop() {\n xyzFloat raw, g, angle, corrAngle;\n myAcc.getRawValues(&raw);\n myAcc.getGValues(&g);\n myAcc.getAngles(&angle);\n myAcc.getCorrAngles(&corrAngle);\n \n\/* Still the uncorrected raw values!! *\/ \n Serial.print(\"Raw-x = \");\n Serial.print(raw.x);\n Serial.print(\" | Raw-y = \");\n Serial.print(raw.y);\n Serial.print(\" | Raw-z = \");\n Serial.println(raw.z);\n\n\/* g values use the corrected raws *\/\n Serial.print(\"g-x = \");\n Serial.print(g.x);\n Serial.print(\" | g-y = \");\n Serial.print(g.y);\n Serial.print(\" | g-z = \");\n Serial.println(g.z);\n\n\/* Angles use the corrected raws. Angles are simply calculated by\n angle = arcsin(g Value) *\/\n Serial.print(\"Angle x = \");\n Serial.print(angle.x);\n Serial.print(\" | Angle y = \");\n Serial.print(angle.y);\n Serial.print(\" | Angle z = \");\n Serial.println(angle.z);\n\n\/* Corrected angles use corrected raws and an extra angle \n offsets to ensure they start at 0\u00b0 \n*\/\n Serial.print(\"cAngle x = \");\n Serial.print(corrAngle.x);\n Serial.print(\" | cAngle y = \");\n Serial.print(corrAngle.y);\n Serial.print(\" | cAngle z = \");\n Serial.println(corrAngle.z);\n\n Serial.print(\"Orientation of the module: \");\n Serial.println(myAcc.getOrientationAsString());\n\n Serial.println();\n \n delay(1000);\n}\n<\/pre>\nOutput of ADXL_angles_orientation <\/h4>\n\n
![\"ADXL345](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/12\/angles_orientation__output.png\")
<\/a>Example sketch 4: ADXL345_pitch_roll_corrected_angles.ino<\/h3>\n\n
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-be8f8dd16b2c7d25cdc636ad3bc340ed_l3.png\" "\\"Rendered")
<\/p>\n![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-985ee479406f587fe4196dc2994b0edc_l3.png\" "\\"Rendered")
<\/p>\n\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n Serial.println(\"ADXL345 Sketch - Pitch and Roll vs. Corrected Angles\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n \n\/* Add your min and max raw values you found with ADXL345_calibration.ino. \n The order is: setCorrFactors(min x, max x, min y, max y, min z, max z).\n setCorrFactors calibrates the slope and assumes the zero point \n is (min+max)\/2. You have to add the setCorrFactors function to all sketches \n in which you want to use it.\n*\/\n myAcc.setCorrFactors(-266.0, 285.0, -268.0, 278.0, -291.0, 214.0);\n\n\/* In this next step the offset for angles is corrected to get quite precise corrected \n angles x and y up to ~60\u00b0. The additional offsetCorrection is only for corrected \n angle measurements, not for pitch and roll. The procedure just ensures to start at 0\u00b0.\n*\/\n Serial.println(\"Position your ADXL345 flat and don't move it\");\n delay(2000);\n myAcc.measureAngleOffsets();\n Serial.println(\"....done\");\n \n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/\n myAcc.setDataRate(ADXL345_DATA_RATE_50);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n\n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/\n myAcc.setRange(ADXL345_RANGE_2G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println(); \n}\n\nvoid loop() {\n \/\/xyzFloat g;\n \/\/myAcc.getGValues(&g);\n xyzFloat corrAngles;\n myAcc.getCorrAngles(&corrAngles);\n \n\/* Corrected angles use corrected raws and an extra angle\n offset. The method provides quite precise values for x\/y \n angles up 60\u00b0.\n*\/\n Serial.print(\"Angle x = \");\n Serial.print(corrAngles.x);\n Serial.print(\" | Angle y = \");\n Serial.print(corrAngles.y);\n Serial.print(\" | Angle z = \");\n Serial.println(corrAngles.z);\n\n\/* Pitch and roll use corrected slope, but no additional offset. \n All axes are considered for calculation. \n*\/\n float pitch = myAcc.getPitch();\n float roll = myAcc.getRoll();\n \n Serial.print(\"Pitch = \"); \n Serial.print(pitch); \n Serial.print(\" | Roll = \"); \n Serial.println(roll); \n \n Serial.println();\n \n delay(1000);\n}<\/pre>\nOutput of ADXL345_pitch_roll_corrected_angles.ino<\/h4>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/07\/pitch_roll_corrected_angles_output_II.png\")
<\/a>Example sketch 5: ADXL345_sleep.ino<\/h3>\n\n
\n
setSleep(true\/false)<\/code><\/li>\n<\/ul>\n\n
setSleep(true\/false, frequency)<\/code><\/li>\n<\/ul>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n Serial.println(\"ADXL345_Sketch - Sleep\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n\n\/* Insert your data from ADXL345_calibration.ino and uncomment for more precise results *\/\n \/\/ myAcc.setCorrFactors(-266.0, 285.0, -268.0, 278.0, -291.0, 214.0);\n \n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/ \n myAcc.setDataRate(ADXL345_DATA_RATE_50);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n\n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/\n myAcc.setRange(ADXL345_RANGE_2G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println();\n}\n\nvoid loop(){\n\/* Switch on (true) or switch off (false) sleep mode. Choose the wake up \n frequency:\n ADXL345_WUP_FQ_1 = 1 Hz\n ADXL345_WUP_FQ_2 = 2 Hz\n ADXL345_WUP_FQ_4 = 4 Hz \n ADXL345_WUP_FQ_8 = 8 Hz\n\n In this specific example you will see (provided you move the ADXL345) that\n in sleep mode the values are updated every third to fourth request. In awake\n mode the values are updated steadily. Sleep Mode saves significant power. \n*\/\n myAcc.setSleep(true, ADXL345_WUP_FQ_1);\n Serial.println(\"Measure in Sleep Mode:\");\n doMeasurements();\n \n myAcc.setSleep(false);\n Serial.println(\"Measure in Normal Mode:\");\n doMeasurements();\n}\n \n\nvoid doMeasurements(){\n for(int i=0; i<10; i++){\n xyzFloat g;\n myAcc.getGValues(&g);\n \n Serial.print(\"g-x = \");\n Serial.print(g.x);\n Serial.print(\" | g-y = \");\n Serial.print(g.y);\n Serial.print(\" | g-z = \");\n Serial.println(g.z);\n \n delay(300);\n }\n}<\/pre>\nOutput of ADXL345_sleep.ino<\/h4>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/12\/sleep_output.png\")
<\/a>Interrupt Features of the ADXL345<\/h2>\n\n
General information about the interrupt features<\/h3>\n\n
\n
setInterrupt(type, pin1\/pin2)<\/code>. The first parameter is the interrupt type, with the second parameter you determine at which pin the interrupt is output. See the example sketches that use interrupts for a list of allowed parameters.<\/p>\ndeleteInterrupt(type)<\/code>.<\/p>\n\nreadAndClearInterrupts()<\/code>. It returns the interrupt type as a byte. How to “translate” this can be found in the library file ADXL345_WE.h. Alternatively, you check with checkInterrupt(source, type)<\/code> for a specific type.<\/p>\nsetInterruptPolarity(polarity)<\/code>. This sets whether the interrupt pins are active-low or active-high (default). <\/p>\n\nExample sketch 6: ADXL345_free_fall_interrupt.ino<\/h3>\n\n
setInterrupt(ADXL345_FREEFALL, INT_PIN_2)<\/code> and assigned to INT2.<\/p>\nsetFreeFallThresholds (0.4, 100)<\/code> sets the acceleration limit to 0.4 g and the minimum duration for which it must be lower to 100 milliseconds. Limits for parameters and recommended values can be found in the example sketch. It is best to play around a little with the parameters to get to know this function better.<\/p>\n<\/p>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\nconst int int2Pin = 2;\nvolatile bool freeFall = false;\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n pinMode(int2Pin, INPUT);\n Serial.println(\"ADXL345_Sketch - Free Fall Interrupt\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n\n\/* Insert your data from ADXL345_calibration.ino and uncomment for more precise results *\/\n \/\/ myAcc.setCorrFactors(-266.0, 285.0, -268.0, 278.0, -291.0, 214.0);\n\n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/\n myAcc.setDataRate(ADXL345_DATA_RATE_25);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n \n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/ \n myAcc.setRange(ADXL345_RANGE_2G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println();\n\n\/* The parameters of the setFreeFallThresholds function are: \n - g threshold - do not choose a parameter which is too low. 0.3 - 0.6 g is fine.\n - time threshold in ms, maximum is 1275. Recommended is 100 - 350;\n If time threshold is too low, vibrations can be detected as free fall. \n *\/\n myAcc.setFreeFallThresholds(0.4, 100);\n \n\/* You can choose the following interrupts:\n Variable name: Triggered, if:\n ADXL345_OVERRUN - new data replaces unread data\n ADXL345_WATERMARK - the number of samples in FIFO equals the number defined in FIFO_CTL\n ADXL345_FREEFALL - acceleration values of all axes are below the threshold defined in THRESH_FF \n ADXL345_INACTIVITY - acc. value of all included axes are < THRESH_INACT for period > TIME_INACT\n ADXL345_ACTIVITY - acc. value of included axes are > THRESH_ACT\n ADXL345_DOUBLE_TAP - double tap detected on one incl. axis and various defined conditions are met\n ADXL345_SINGLE_TAP - single tap detected on one incl. axis and various defined conditions are met\n ADXL345_DATA_READY - new data available\n\n Assign the interrupts to INT1 (INT_PIN_1) or INT2 (INT_PIN_2). Data ready, watermark and overrun are \n always enabled. You can only change the assignment of these which is INT1 by default.\n\n You can delete interrupts with deleteInterrupt(type);\n*\/\n myAcc.setInterrupt(ADXL345_FREEFALL, INT_PIN_2);\n \n attachInterrupt(digitalPinToInterrupt(int2Pin), freeFallISR, RISING); \n myAcc.readAndClearInterrupts();\n}\n\nvoid loop() {\n xyzFloat raw, g;\n myAcc.getRawValues(&raw);\n myAcc.getGValues(&g);\n \n Serial.print(\"Raw-x = \");\n Serial.print(raw.x);\n Serial.print(\" | Raw-y = \");\n Serial.print(raw.y);\n Serial.print(\" | Raw-z = \");\n Serial.println(raw.z);\n\n Serial.print(\"g-x = \");\n Serial.print(g.x);\n Serial.print(\" | g-y = \");\n Serial.print(g.y);\n Serial.print(\" | g-z = \");\n Serial.println(g.z);\n\n Serial.println();\n \n if(freeFall==true){\n Serial.println(\"Aaaaaaaaah!!!!! - I'm faaaaallllling!\");\n delay(1000);\n freeFall = false;\n \/* by reading the interrupt register the interrupt is cleared *\/\n myAcc.readAndClearInterrupts();\n \n \/* if you expect also other interrupts you can check the type. For this comment the previous line, \n and replace by the following four lines: *\/\n \/\/byte intType = myAcc.readAndClearInterrupts();\n \/\/if(myAcc.checkInterrupt(intType, ADXL345_FREEFALL)){\n \/\/ Serial.println(\"FREEFALL confirmed\");\n \/\/}\n }\n\n delay(500);\n}\n\nvoid freeFallISR(){\n freeFall = true;\n}\n<\/pre>\nExample sketch 7: ADXL345_data_ready_interrupt.ino <\/h3>\n\n
setDataRate(ADXL345_DATA_RATE_0_20)<\/code> to a slow 0.2 Hz.<\/p>\nsetInterrupt(ADXL345_DATA_READY, INT_PIN_2)<\/code>.<\/p>\n#include<Wire.h>\n#include<ADXL345_WE.h>\n#define ADXL345_I2CADDR 0x53 \/\/ 0x1D if SDO = HIGH\nconst int int2Pin = 2; \/\/ interrupt pin\nvolatile bool dataReady = false;\n\n\/* There are several ways to create your ADXL345 object:\n * ADXL345_WE myAcc = ADXL345_WE() -> uses Wire \/ I2C Address = 0x53\n * ADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR) -> uses Wire \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2) -> uses the TwoWire object wire2 \/ ADXL345_I2CADDR\n * ADXL345_WE myAcc = ADXL345_WE(&wire2, ADXL345_I2CADDR) -> all together\n *\/\nADXL345_WE myAcc = ADXL345_WE(ADXL345_I2CADDR);\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n pinMode(int2Pin, INPUT);\n Serial.println(\"ADXL345_Sketch - Data Ready Interrupt\");\n Serial.println();\n if(!myAcc.init()){\n Serial.println(\"ADXL345 not connected!\");\n }\n\n\/* Insert your data from ADXL345_calibration.ino and uncomment for more precise results *\/\n \/\/ myAcc.setCorrFactors(-266.0, 285.0, -268.0, 278.0, -291.0, 214.0);\n\n\/* Choose the data rate Hz\n ADXL345_DATA_RATE_3200 3200\n ADXL345_DATA_RATE_1600 1600\n ADXL345_DATA_RATE_800 800\n ADXL345_DATA_RATE_400 400\n ADXL345_DATA_RATE_200 200\n ADXL345_DATA_RATE_100 100\n ADXL345_DATA_RATE_50 50\n ADXL345_DATA_RATE_25 25\n ADXL345_DATA_RATE_12_5 12.5 \n ADXL345_DATA_RATE_6_25 6.25\n ADXL345_DATA_RATE_3_13 3.13\n ADXL345_DATA_RATE_1_56 1.56\n ADXL345_DATA_RATE_0_78 0.78\n ADXL345_DATA_RATE_0_39 0.39\n ADXL345_DATA_RATE_0_20 0.20\n ADXL345_DATA_RATE_0_10 0.10\n*\/\n\/\/ Choose a low frequency to showcase the data rate controlled output\n myAcc.setDataRate(ADXL345_DATA_RATE_0_20);\n Serial.print(\"Data rate: \");\n Serial.print(myAcc.getDataRateAsString());\n\n\/* Choose the measurement range\n ADXL345_RANGE_16G 16g \n ADXL345_RANGE_8G 8g \n ADXL345_RANGE_4G 4g \n ADXL345_RANGE_2G 2g\n*\/\n myAcc.setRange(ADXL345_RANGE_2G);\n Serial.print(\" \/ g-Range: \");\n Serial.println(myAcc.getRangeAsString());\n Serial.println();\n \n attachInterrupt(digitalPinToInterrupt(int2Pin), dataReadyISR, RISING);\n\n\/* Default Interrupt Pin Polarity is active high. Change if you like *\/ \n \/\/ myAcc.setInterruptPolarity(ADXL345_ACT_LOW);\n\n\/* You can choose the following interrupts:\n Variable name: Triggered, if:\n ADXL345_OVERRUN - new data replaces unread data\n ADXL345_WATERMARK - the number of samples in FIFO equals the number defined in FIFO_CTL\n ADXL345_FREEFALL - acceleration values of all axes are below the threshold defined in THRESH_FF \n ADXL345_INACTIVITY - acc. value of all included axes are < THRESH_INACT for period > TIME_INACT\n ADXL345_ACTIVITY - acc. value of included axes are > THRESH_ACT\n ADXL345_DOUBLE_TAP - double tap detected on one incl. axis and various defined conditions are met\n ADXL345_SINGLE_TAP - single tap detected on one incl. axis and various defined conditions are met\n ADXL345_DATA_READY - new data available\n\n Assign the interrupts to INT1 (INT_PIN_1) or INT2 (INT_PIN_2). Data ready, watermark and overrun are \n always enabled. You can only change the assignment of these which is INT1 by default.\n\n You can delete interrupts with deleteInterrupt(type);\n*\/\n myAcc.setInterrupt(ADXL345_DATA_READY, INT_PIN_2); \n myAcc.readAndClearInterrupts();\n}\n\n\/* In the following loop there is only one interrupt type that can occur on INT2.\n In cases where you expect more candidates, you can check as follows:\n uint8_t intType = myAcc.readAndClearInterrupts();\n if(myAcc.checkInterrupt(intType, ADXL345_DATA_READY)){\n Serial.println(\"DATA READY confirmed\");\n }\n*\/\nvoid loop() {\n \/\/ you see here is no delay to control the output rate\n if(dataReady==true){\n xyzFloat g;\n myAcc.getGValues(&g);\n \/\/ dataReady = false; \/\/ uncomment, if you want capture next interrupts\n \n Serial.print(\"g-x = \");\n Serial.print(g.x);\n Serial.print(\" | g-y = \");\n Serial.print(g.y);\n Serial.print(\" | g-z = \");\n Serial.println(g.z);\n \n dataReady = false; \/\/ comment, if you have set dataReady to false before\n } \n}\n\nvoid dataReadyISR(){\n dataReady = true;\n}<\/pre>\nOutlook<\/h2>\n\n
\n
Acknowledgement<\/h2>\n\n