You can easily wire this breakout to any microcontroller, we'll be using an Arduino. For another kind of microcontroller, as long as you have 4 available pins it is possible to 'bit-bang SPI' or you can use two I2C pins, but usually those pins are fixed in hardware. Just check out the library, then port the code.

I2C Wiring

Use this wiring if you want to connect via I2C interface

  • Connect Vin to the power supply, 3-5V is fine. (red wire on STEMMA QT version) Use the same voltage that the microcontroller logic is based off of. For most Arduinos, that is 5V
  • Connect GND to common power/data ground (black wire on STEMMA QT version)
  • Connect the SCL pin to the I2C clock SCL pin on your Arduino. (yellow wire on STEMMA QT version) On an UNO & '328 based Arduino, this is also known as A5, on a Mega it is also known as digital 21 and on a Leonardo/Micro, digital 3
  • Connect the SDA pin to the I2C data SDA pin on your Arduino. (blue wire on STEMMA QT version) On an UNO & '328 based Arduino, this is also known as A4, on a Mega it is also known as digital 20 and on a Leonardo/Micro, digital 2

SPI Wiring

Since this is also an SPI-capable sensor, we can use hardware or 'software' SPI. To make wiring identical on all Arduinos, we'll begin with 'software' SPI. The following pins should be used:

  • Connect Vin to the power supply, 3V or 5V is fine. Use the same voltage that the microcontroller logic is based off of. For most Arduinos, that is 5V
  • Connect GND to common power/data ground
  • Connect the SCL (SCK) pin to Digital #13 but any pin can be used later
  • Connect the SDO pin to Digital #12 but any pin can be used later
  • Connect the SDA (SDI) pin to Digital #11 but any pin can be used later
  • Connect the CS pin Digital #10 but any pin can be used later

Later on, once we get it working, we can adjust the library to use hardware SPI if you desire, or change the pins to other pins.

Download Adafruit_LIS3DH library

To begin reading sensor data, you will need to download Adafruit LIS3DH and Adafruit Unified Sensor from the Arduino Library Manager.

Open up the Arduino Library Manager:

Search for the Adafruit LIS3DH library and install it

Search for the Adafruit Unified Sensor library and install it

We also have a great tutorial on Arduino library installation at:

Accelerometer Demo

Open up File->Examples->Adafruit_LIS3DH->acceldemo and upload to your Arduino wired up to the sensor

Depending on whether you are using I2C or SPI, change the pin names and comment or uncomment the following lines.

// Used for software SPI
#define LIS3DH_CLK 13
#define LIS3DH_MISO 12
#define LIS3DH_MOSI 11
// Used for hardware & software SPI
#define LIS3DH_CS 10

// software SPI
// hardware SPI
//Adafruit_LIS3DH lis = Adafruit_LIS3DH(LIS3DH_CS);
// I2C
Adafruit_LIS3DH lis = Adafruit_LIS3DH();

Once uploaded to your Arduino, open up the serial console at 9600 baud speed to see data being printed out

Normally, sitting on a table, you'll see X and Y are close to 0 and Z will be about 1 g or ~9.8 m/s^2 because the accelerometer is measuring the force of gravity!

You can also move around the board to measure your movements and also try tilting it to see how the gravity 'force' appears at different axes.

Not that you'll see there's two sets of data!

Accelerometer ranges

Accelerometers don't 'naturally' spit out a "meters per second squared" value. Instead, they give you a raw value. In this sensor's case, its a number ranging from -32768 and 32767 (a full 16-bit range). Depending on the sensor range, this number scales between the min and max of the range. E.g. if the accelerometer is set to +-2g then 32767 is +2g of force, and -32768 is -2g. If the range is set to +-16g, then those two number correlate to +16g and -16g respectively. So knowing the range is key to deciphering the data!

You can set, and get the range with:

lis.setRange(LIS3DH_RANGE_4_G);   // 2, 4, 8 or 16 G!
Serial.print("Range = "); Serial.print(2 << lis.getRange());  

In the first line, you can use LIS3DH_RANGE_2_GLIS3DH_RANGE_4_GLIS3DH_RANGE_8_G, or LIS3DH_RANGE_16_G

When reading the range back from the sensor, 0 is ±2g, 1 is ±4g, 2 is ±8g and 3 is ±16g range

Raw data readings

You can get these raw readings by calling which will take a snapshot at that moment in time. You can then grab the x, y and z data by reading the signed 16-bit values from lis.x, lis.y and lis.z. When you are done with that data, call read() again to get another snapshot.

Normalized readings

If you dont want to noodle around with range readings and scalings, you can use Adafruit_Sensor to do the normalization for you. Its a nice way to have consistant readings betwixt multiple types of accelerometers.

Adafruit_Sensor uses event (sensors_event_t) objects to 'snapshot' the data:

/* Get a new sensor event */ 
sensors_event_t event; 

Once you've getEvent'd the data, read it out from the event object with event.acceleration.x, event.acceleration.y & event.acceleration.z

The key point is that those values are floating point, and are going to be in m/s2 No matter the range!

It's up to you whether you want the raw numbers or normalized data - there's times you want to keep it simple and avoid floating point numbers, and other times you may want to avoid doing the math for force conversion.

Tap & Double tap detection

One of the neat extras in the LIS3DH is tap & double-tap detection. By tapping the accelerometer or the PCB or something the PCB is attached to you can create a type of interface.

Open up the tapdemo demo to run it! It defaults to I2C so change to SPI if you're using that interface.

The tap detection works by looking for when one of the axes has an acceleration higher than a certain threshhold for longer than a certain timelimit. The threshhold is in 'raw' values so you have to adjust it based on the scale/range you've configured for the sensor:

// Adjust this number for the sensitivity of the 'click' force
// this strongly depend on the range! for 16G, try 5-10
// for 8G, try 10-20. for 4G try 20-40. for 2G try 40-80

Larger numbers are less sensitive, you'll really need to just tweak as necessary for your project.

You'll also have to turn on click detection. This will also se the INT pin to pulse high whenever a tap or double tap is detected. If you turn on double tap detection it will still 'decode' single taps but the INT pin wont pulse on them.

  // 0 = turn off click detection & interrupt
  // 1 = single click only interrupt output
  // 2 = double click only interrupt output, detect single click
  // Adjust threshhold, higher numbers are less sensitive
  lis.setClick(2, CLICKTHRESHHOLD);

setClick can actually take many more arguments, the full list is:

  void setClick(uint8_t c, uint8_t clickthresh, uint8_t timelimit = 10, uint8_t timelatency = 20, uint8_t timewindow = 255);

The timelimit timelatency and timewindow are in units of "ODR" so if you change the sample frequency of the LIS3DH you'll  have to adjust these as necessary. The App note has way more details on this, with pretty graphs & eveything!

You can get the current click status register with lis.getClick(). Note that will return the raw 8-bit reg known as LIS3DH_REG_CLICKSRC

Even though that register has 'axis' bits that theoretically tell you which axis the click is from, unless you bolt the breakout to a huge thing like a table and thwack the table, any 'direct hits' to the sensor itself will register on any/all axes because of the small scale.

Reading the 3 ADC pins

Finally, there are 3 extra 10-bit analog-digital-converter pins available. The details on these pins is scarce but we do have code for reading data for them. This might be handy if you have a device without any ADC's

While you can put 0-3.3V into the ADC pins, the valid reading range is only ~0.9V to 1.8V

You can load the readadc demo sketch to start reading

I connected a trimpot from ground (left pin) to 3.3V (right pin) and conneted the wiper (center pin) to ADC1

For pins that don't have anything connected, such as ADC2 and ADC3 you'll notice the values flicker around a lot. If you don't like this, just tie the pins to GND and it will keep the values 'steady'

The values of the ADC range from -32512 to 32512 but note that they correspond to ~1.8V to ~0.9V. You can map the raw values to an approx voltage using

 volt = map(adc, -32512, 32512, 1800, 900);

Which will convert the raw adc value into volt in units of millivolts

This guide was first published on Nov 16, 2015. It was last updated on Nov 16, 2015.

This page (Arduino) was last updated on Nov 15, 2015.

Text editor powered by tinymce.