LIS3DH Triple-Axis Accelerometer Breakout Datasheet by Adafruit Industries LLC

fr adafrull learning system

Adafruit LIS3DH Triple-Axis Accelerometer Breakout

Created by lady ada

Last updated on 2019-08-22 11:52:26 PM UTC

* adafruit learning system

Overview

The LIS3DH is a very popular low power triple-axis accelerometer. It's low-cost, but has just about every 'extra' you'd

want in an accelerometer:

Three axis sensing

±2g/±4g/±8g/±16g selectable scaling

Both I2C (2 possible addresses) and SPI interface options

Interrupt output

Multiple data rate options 1 Hz to 5Khz

As low as 2uA current draw (just the chip itself, not including any supporting circuitry)

Tap, Double-tap, orientation & freefall detection

3 additional ADC inputs you can read over I2C

We kept seeing this accelerometer in teardowns of commercial products and figured that if it's the most-commonly

used accelerometer, its worth having a breakout board!

>111 111111111“ 71 [771717711177117171] 1111111111111111111111111111111

This sensor communicates over I2C

or

SPI (our library code supports both) so you can share it with a bunch of other

sensors on the same I2C bus. There's an address selection pin so you can have two accelerometers share an I2C bus.

To get you going fast, we spun up a breakout board for this little guy. Since it's a 3V sensor, we add a low-dropout

3.3V regulator and level shifting circuitry on board. That means its perfectly safe for use with 3V or 5V power and logic.

It's fully assembled and tested. Comes with a bit of 0.1" standard header in case you want to use it with a breadboard

or perfboard. Two 2.5mm (0.1") mounting holes for easy attachment.

* adafruil learning system

Pinouts

The little chip in the middle of the PCB is the actual LIS3DH sensor that does all the motion sensing. We add all the

extra components you need to get started, and 'break out' all the other pins you may want to connect to onto the PCB.

For more details you can check out the schematics in the Downloads page.

Power Pins

The sensor on the breakout requires 3V power. Since many customers have 5V microcontrollers like Arduino, we

tossed a 3.3V regulator on the board. Its ultra-low dropout so you can power it from 3.3V-5V just fine.

Vin - this is the power pin. Since the chip uses 3 VDC, we have included a voltage regulator on board that will

take 3-5VDC and safely convert it down. To power the board, give it the same power as the logic level of your

microcontroller - e.g. for a 5V micro like Arduino, use 5V

3Vo - this is the 3.3V output from the voltage regulator, you can grab up to 100mA from this if you like

GND - common ground for power and logic

I2C Pins

SCL - I2C clock pin, connect to your microcontrollers I2C clock line. Has a 10K pullup already on it.

SDA - I2C data pin, connect to your microcontrollers I2C data line. Has a 10K pullup already on it.

To use I2C, keep the CS pin either disconnected or tied to a high (3-5V) logic level.

SDO - When in I2C mode, this pin can be used for address selection. When connected to GND or left open, the

address is 0x18 - it can also be connected to 3.3V to set the address to 0x19

SPI pins:

All pins going into the breakout have level shifting circuitry to make them 3-5V logic level safe. Use whatever logic

level is on Vin!

SCL - this is the SPI Clock pin, its an input to the chip

SDA - this is the Serial Data In / Master Out Slave In pin, for data sent from your processor to the LIS3DH

SDO - this is the Serial Data Out / Master In Slave Out pin, for data sent from the LIS3DH to your processor. It's

3.3V logic level out

CS - this is the Chip Select pin, drop it low to start an SPI transaction. Its an input to the chip

If you want to connect multiple LIS3DH's to one microcontroller, have them share the SDI, SDO and SCK pins. Then

assign each one a unique CS pin.

Other Pins

INT is the interrupt output pin. You can configure the interupt to trigger for various 'reasons' such as motion, tilt,

taps, data ready etc. This pin is 3.3V logic output.

I‘IIIH IIHHIHHHH IIII II!II|I III II II II II II II II II II II II II II II

Assembly

Prepare the header strip:

Cut/break the header strip into two pieces, one 3 pin

and one 8 pin. It will be easier to solder if you insert it

into a breadboard - long pins down

.u- an. un- ﬁl- all on. 3- :v- ,,L1

Add the breakout board:

Place the breakout board over the pins so that the short

pins poke through the breakout pads

And Solder!

Be sure to solder all pins for reliable electrical contact.

We'll start with the main 8 pins for power & the I2C/SPI

interface.

(For tips on soldering, be sure to check out our Guide to

Excellent Soldering

(https://adafru.it/aTk)

).

u‘ - ‘ .. eta-.1“. L!" nu

If you want to have the board be more mechanically

stable, or want to use the ADC pins, solder in the 3 ADC

pads too

u 0 a I a I 3' :3 3' 3' ii ad 3. 3i 3i .5- ma. Ni. uni Nu. n53 X I I I I I

You're done! Check your solder joints visually and

continue onto the next steps

* adafruit learning system

Arduino

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. 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 pin to the I2C clock SCL pin on your Arduino. 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. 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

l , V iqhx dhcce

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.

Note: Photo below incorrectly shows GND to 3Vo. The correct connection is GND to GND as listed above!

Download Adafruit_LIS3DH library

To begin reading sensor data, you will need to download Adafruit_LIS3DH from our github

repository (https://adafru.it/jzb). You can do that by visiting the github repo and manually downloading or, easier, just

click this button to download the zip

https://adafru.it/jzc

Rename the uncompressed folder Adafruit_LIS3DH and check that the Adafruit_LIS3DH folder contains

Adafruit_LIS3DH.cpp and Adafruit_LIS3DH.h

Place the Adafruit_LIS3DH library folder your

arduinosketchfolder

/libraries/ folder.

You may need to create the libraries subfolder if its your first library. Restart the IDE.

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

http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use (https://adafru.it/aYM)

Download Adafruit_Sensor

The LIS3DH library uses the Adafruit_Sensor support backend so that readings can be normalized between sensors.

You can grab Adafruit_Sensor from the github repo (https://adafru.it/aZm) or just click the button below.

https://adafru.it/cMO

Install it just like you did with the Adafruit_LIS3DH library above!

17 // 11c // :1.“an m as Ilmfmxcillsaml n: Wham! Wm'ILDGDE mummy WMLW mummm¢ Mimiuﬁim WMLISMIB mumsmm mummxzmo mmmmm Mammucm mam MafnﬂLmnMLlel El 3105!, usana_mso, LISSIIILCLKII vvvvvvveﬁvvvvv mm mm- nu; = m x: 7111 an Al I an x 435 ran an zgau ms 3551 3641: ms 3695 um um ‘nu 1 mu x 1112 x. mu x 1715 x mu 1 w m E] mm ~

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.

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

// 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

//Adafruit_LIS3DH lis = Adafruit_LIS3DH(LIS3DH_CS, LIS3DH_MOSI, LIS3DH_MISO, LIS3DH_CLK);

// hardware SPI

//Adafruit_LIS3DH lis = Adafruit_LIS3DH(LIS3DH_CS);

// I2C

Adafruit_LIS3DH lis = Adafruit_LIS3DH();

rmn m-x 4.19 ./. 2 7.1.91 w“ 41,95 .h-z 70.71 .IN 7mm mm 1. n.1a mu mum: V sum-A .

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

Accelerometeres 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:

In the first line, you can use LIS3DH_RANGE_2_G, LIS3DH_RANGE_4_G, LIS3DH_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 lis.read() 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:

lis.setRange(LIS3DH_RANGE_4_G); // 2, 4, 8 or 16 G!

Serial.print("Range = "); Serial.print(2 << lis.getRange());

oooulss = |:I[E mum: Luann up Test! . usann fauna! Inna: = 26 and: ammo (mu : zinglk and: um dam (mu : aim]: click cud: 42mm (mu : 51591: click um detected (0x641 damn click cud: 42mm (mu : .1591: click ﬂick deceased (0x641 damn click Click magma (mu : sum: click ﬂick deceased (ml) single click click menu (mall . mm: click cud: dtcecced (0x151: anal: click Em-

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/s 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:

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.

/* Get a new sensor event */

sensors_event_t event;

lis.getEvent(&event);

2

// 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

#define CLICKTHRESHHOLD 80

Flguve 15‘ Slngle and douhle cllck recognlﬂun (a); — — M. (b); Flgure 15 Iiluslrates a slngle click event (a) and a double cllck eveni (b). The devlce is able in distinguish between (a) and (b) by changing the sailings oi ms TAF_CFG regislel irom single to double click recognition.

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

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! (https://adafru.it/jwf)

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

// 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);

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

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



42512 [1mm IV] 42512 [1mm .v; 42512 moo IV) 42512 [1mm IV) 42512 mm: IV) 42512 moo IV) 42512 mm: IV) 42592 [155: IV) 4532): [1576 IV) 4605: [157: IV) -s1n4 (141: IV) 23:2: 45:0 [um-u) 4021)) (1492 In 21):: 49:3 [1379 In 4952; (1153 In m. 3mm (1:09.11; 4224 (nag-w) 21):: 5553 (1273 .v; 4154 (um IV) ms: 1:2 (1:39 In -9116 m7: IV) ma: 45:6 [11-2 IV) —12n (1352 IV) Ma: 31:71 (1am) IV) 5952 (126! IV) mm: 5215 (1223 IV) 29“ (1a1nIV) mm: 1m: (1531 IV) 255 (1517 IV) mt: 4:416 nus-V) 716m) (1157 IV) 2m: 1921) (1324 IV) Anca: 5529 (15:12 IV) 1561); (1131 IV) nncz 1936 (1241 IV) mm: mm (12:11 II) 52512 (9m: IV) m: 1.355 (1152 IV) was: 51:55 (1251 IV) 52512 (9m: IV) m 15:24 (1155 IV) not: 575 (15:: IV) m2 m mm mu m. m m m mcz m

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

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

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

* adafruit learning system fmtzmg

Python &

CircuitPython

It's easy to use the LIS3DH sensor with Python or CircuitPython, and the Adafruit CircuitPython

LIS3DH (https://adafru.it/uBs) module. This module allows you to easily write Python code that reads acceleration from

the sensor.

You can use this sensor with any CircuitPython microcontroller board or with a computer that has GPIO and Python

thanks to Adafruit_Blinka, our CircuitPython-for-Python compatibility library (https://adafru.it/BSN).

CircuitPython Microcontroller Wiring

First wire up a LIS3DH to your board exactly as shown on the previous pages for Arduino. You can use either I2C or

SPI wiring, although it's recommended to use I2C for simplicity. Here's an example of wiring a Feather M0 to the

sensor with I2C:

Board 3V to sensor Vin

Board GND to sensor GND

Board SCL to sensor SCL

Board SDA to sensor SDA

Board D6 to sensor INT (or use any other free

digital I/O pin)

And an example of a Feather M0 wired with hardware SPI:

Board 3V to sensor Vin

Board GND to sensor GND

Board SCK to sensor SCL

Board MOSI to sensor SDA

Board MISO to sensor SDO

Board D5 to sensor CS (or use any other free

digital I/O pin)

Board D6 to sensor INT (or use any other free

digital I/O pin)

The INT pin is used for tap detection, if you aren't planning on using the tap detection capability, you can

pm ‘5 usec or ap 9 ac won,| you aren panning on USng we ap ec Ion capam I y, you can on... .00...

Python Computer Wiring

Since there's

dozens

of Linux computers/boards you can use we will show wiring for Raspberry Pi. For other platforms,

please visit the guide for CircuitPython on Linux to see whether your platform is supported (https://adafru.it/BSN).

Here's the Raspberry Pi wired with I2C:

Pi 3V3 to sensor Vin

Pi GND to sensor GND

Pi SCL to sensor SCL

Pi SDA to sensor SDA

Pi GPIO6 to sensor INT (or use any other free

digital I/O pin)

And an example on the Raspberry Pi 3 Model B wired with SPI:

Pi 3V3 to sensor Vin

Pi GND to sensor GND

Pi SCLK to sensor SCL

Pi MOSI to sensor SDA

Pi MISO to sensor SDO

Pi GPIO5 to sensor CS (or use any other free

digital I/O pin)

Pi GPIO6 to sensor INT (or use any other free

digital I/O pin)

CircuitPython Installation of LIS3DH Library

The INT pin is used for tap detection, if you aren't planning on using the tap detection capability, you can

leave that pin disconnected



The INT pin is used for tap detection, if you aren't planning on using the tap detection capability, you can

leave that pin disconnected



Next you'll need to install the Adafruit CircuitPython LIS3DH (https://adafru.it/uBs) library on your CircuitPython board.

First make sure you are running the latest version of Adafruit CircuitPython (https://adafru.it/tBa) for your board.

Next you'll need to install the necessary libraries to use the hardware--carefully follow the steps to find and install these

libraries from Adafruit's CircuitPython library bundle (https://adafru.it/zdx). For example the Circuit Playground Express

guide has a great page on how to install the library bundle (https://adafru.it/ABU) for both express and non-express

boards.

Remember for non-express boards like the Trinket M0, Gemma M0, and Feather/Metro M0 basic you'll need to

manually install the necessary libraries from the bundle:

adafruit_lis3dh.mpy

adafruit_bus_device

Before continuing make sure your board's lib folder or root filesystem has

the adafruit_lis3dh.mpy, and adafruit_bus_device files and folders copied over.

Next connect to the board's serial REPL (https://adafru.it/Awz) so you are at the CircuitPython >>> prompt.

Python Installation of LIS3DH Library

You'll need to install the Adafruit_Blinka library that provides the CircuitPython support in Python. This may also

require enabling I2C on your platform and verifying you are running Python 3. Since each platform is a little different,

and Linux changes often, please visit the CircuitPython on Linux guide to get your computer

ready (https://adafru.it/BSN)!

Once that's done, from your command line run the following command:

sudo pip3 install adafruit-circuitpython-lis3dh

If your default Python is version 3 you may need to run 'pip' instead. Just make sure you aren't trying to use

CircuitPython on Python 2.x, it isn't supported!

CircuitPython & Python Usage

To demonstrate the usage of the sensor we'll initialize it and read the acceleration from the board's Python REPL.

If you're using an I2C connection run the following code to import the necessary modules and initialize the I2C

connection with the sensor:

Or if you're using a SPI connection run this code instead to setup the SPI connection and sensor:

import time

import board

import digitalio

import busio

import adafruit_lis3dh

i2c = busio.I2C(board.SCL, board.SDA)

int1 = digitalio.DigitalInOut(board.D6) # Set this to the correct pin for the interrupt!

lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)

Now you're ready to read values from the sensor using any of these properties:

acceleration - The x, y, z acceleration values returned in a 3-tuple and are in m / s ^ 2.

shake - Detect when the accelerometer is shaken.

tapped - Detect when the accelerometer is tapped.

For example, to print acceleration:

To use shake, we've set the optional shake_threshold=15 . The default is 30 , but lower numbers make it easier to get

the shake response. Try the following code. Enter it into the REPL and then shake the board.

To use tapped, you need to use lis3dh.set_tap to tell it whether to look for a single- (1) or double-tap ( 2), and

provide a threshold. We've chosen to look for a double tap ( 2) and set the threshold to 60 . Enter the following code

into the REPL and then tap the board twice.

import time

import board

import digitalio

import busio

import adafruit_lis3dh

spi = busio.SPI(board.SCK, board.MOSI, board.MISO)

cs = digitalio.DigitalInOut(board.D5) # Set to appropriate CS pin!

int1 = digitalio.DigitalInOut(board.D6) # Set to correct pin for interrupt!

lis3dh = adafruit_lis3dh.LIS3DH_SPI(spi, cs, int1=int1)

x, y, z = lis3dh.acceleration

print(x, y, z)

while True:

if lis3dh.shake(shake_threshold=15):

print("Shaken!")

lis3dh.set_tap(2, 60)

while True:

if lis3dh.tapped:

print("Tapped!")

time.sleep(0.01)

That's all there is to using the LIS3DH sensor with CircuitPython!

Full Example Code

import time

import board

import digitalio

import busio

import adafruit_lis3dh

# Hardware I2C setup. Use the CircuitPlayground built-in accelerometer if available;

# otherwise check I2C pins.

if hasattr(board, 'ACCELEROMETER_SCL'):

i2c = busio.I2C(board.ACCELEROMETER_SCL, board.ACCELEROMETER_SDA)

int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)

lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19, int1=int1)

else:

i2c = busio.I2C(board.SCL, board.SDA)

int1 = digitalio.DigitalInOut(board.D6) # Set to correct pin for interrupt!

lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)

# Hardware SPI setup:

# spi = busio.SPI(board.SCK, board.MOSI, board.MISO)

# cs = digitalio.DigitalInOut(board.D5) # Set to correct CS pin!

# int1 = digitalio.DigitalInOut(board.D6) # Set to correct pin for interrupt!

# lis3dh = adafruit_lis3dh.LIS3DH_SPI(spi, cs, int1=int1)

#PyGamer I2C Setup:

#i2c = busio.I2C(board.SCL, board.SDA)

#int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)

#lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, address=0x19, int1=int1)

# Set range of accelerometer (can be RANGE_2_G, RANGE_4_G, RANGE_8_G or RANGE_16_G).

lis3dh.range = adafruit_lis3dh.RANGE_2_G

# Loop forever printing accelerometer values

while True:

# Read accelerometer values (in m / s ^ 2). Returns a 3-tuple of x, y,

# z axis values. Divide them by 9.806 to convert to Gs.

x, y, z = [value / adafruit_lis3dh.STANDARD_GRAVITY for value in lis3dh.acceleration]

print("x = %0.3f G, y = %0.3f G, z = %0.3f G" % (x, y, z))

# Small delay to keep things responsive but give time for interrupt processing.

time.sleep(0.1)

* adafruit learning system

Python Docs

Python Docs (https://adafru.it/C6d)

* adafruit learning system m/vzm: Snpu: m manna: nuwuh mmms ‘ a 4 s

Downloads

Datasheets

LIS3DH datasheet (https://adafru.it/jwe)

LIS3DH app note (https://adafru.it/jwf)

ST design resources (https://adafru.it/mQc)

Fritzing object available in the Adafruit Fritzing Library (https://adafru.it/aP3)

EagleCAD PCB files on GitHub (https://adafru.it/quF)

Schematic

click to enlarge

Fabrication Print

Dimensions in inches

LIS3DH Triple-Axis Accelerometer Breakout Datasheet by Adafruit Industries LLC

Products related to this Datasheet