Creative Commons images are CC BY-NC-SA 3.0

Description: The Intel® Edison is an ultra small computing platform that will change the way you look at embedded electronics. Each Edison is packed with a huge amount of tech goodies into a tiny package while still providing the same robust strength of your go-to single board computer. Powered by the Intel® Atom™ SoC dual-core CPU and including an integrated WiFi, Bluetooth LE, and a 70-pin connector to attach a veritable slew of shield-like “Blocks” which can be stacked on top of each other. It’s no wonder how this little guy is lowering the barrier of entry on the world of electronics!

The 9 Degrees of Freedom Block for the Intel® Edison uses the LSM9DS0 9DOF IMU for full-range motion sensing. This chip combines a 3-axis accelerometer, a 3-axis gyroscope, and a 3-axis magnetometer. By default, the IMU is connected to the Edison through the I2C bus. Each sensor in the LSM9DS0 supports a wide range of, well, ranges: the accelerometer’s scale can be set to ± 2, 4, 6, 8, or 16 g, the gyroscope supports ± 245, 500, and 2000 °/s, and the magnetometer has full-scale ranges of ± 2, 4, 8, or 12 gauss. Additionally, the LSM9DS0 includes an I2C serial bus interface supporting standard and fast mode (100 kHz and 400 kHz) and an SPI serial standard interface.

If you are looking to add a little more stability to your Intel® Edison stack, check out this Hardware Pack. It will provide you with increased mechanical strength for stacking Blocks on your Edison!

Note: We are currently working on a Hookup Guide for this kit. Check back later for more updates.

Note: While there are jumpers for SPI, it is not supported.

Documents:

Recommended Products

Customer Comments

  • ——————– Tech Support Tips/Troubleshooting/Common Issues ——————–

    Having issues using the 9DOF block? Check here for more information on tips/troubleshooting/common issues => https://learn.sparkfun.com/tutorials/sparkfun-blocks-for-intel-edison—9-degrees-of-freedom-block-/discuss#comment-57e2a5daf3b1a8d3038b456b .

  • There is a LSM9DS0 Arduino library [ https://github.com/sparkfun/LSM9DS0_Breakout/blob/master/Libraries/Arduino/examples/SparkFun_LSM9DS0_Simple/SparkFun_LSM9DS0_Simple.ino ] that you could use with the Intel Edison and the Arduino IDE. You would need to modify a board file in order to get it working on the correct I2C Line. Check this comment for more information [ https://learn.sparkfun.com/tutorials/sparkfun-blocks-for-intel-edison—9-degrees-of-freedom-block-/discuss#comment-57e2a5daf3b1a8d3038b456b ].

    • I am unable to get this block work with your base block. I compiled and uploaded the example code for the 9DOF breakout - but there is no output on the serial monitor at all. Obviously you must have tested this block - otherwise it would not be released. So how did you test that this block actually works? In Arduino IDE? Or in some other (C/C++, Python, etc.) language?

      Your help is greatly appreciated.

  • I wrapped the c++ library given by SparkFun to Node.js.

    The npm package is called ‘edison_imu’ and may be found here, or just: require(‘edison_imu’); in XDK.

    Cheers

  • The initial setting of accelerometer is 100Hz sample rate, but why the results showing in the Console are not updated at such a rate? And how to change the output rate of readings?

  • Is this connected to the I2C_8 or I2C_6 bus on the edison?

    • It’s connected to I2C_1 on the Edison.

      • Thanks Shawn! I see I2C jumper pads on the bottom - can I jump it to I2C_6? I may be mis-reading this tutorial - but I would like to be able to access the IMU from the MCU on the Edison https://communities.intel.com/thread/76439

        • Not at this time. We assumed (incorrectly) that I2C_1 would be connected to the MCU. Updating the Blocks to support I2C_6 is definitely on our to-do list.

  • Just curious, will readings be affected if the board is near - about 3 cm - to the couple of DC motors (6V)?

  • I’m gradually collecting a library of simple python code for using these blocks in conjunction with the MRAA library. Just requires linux running on the Edison and the MRAA library installed.

    Might be helpful to someone who is as confused as I was(am):

    https://github.com/Einse57/SSTM-Edison-Python

    • Here is everything you need to start reading the sensor data using Node.js without a bunch of extra crap:

      http://www.instructables.com/id/Smart-Helmet-Intel-Edison-Sparkfun-9DOF/

      Please, please be a friend and vote for us!

    • I’m working on a similar project using Python to control a balancing robot. Code is here, but it’s very much a work in progress: https://github.com/WRadigan/PyEddieControl

      I’d also recommend the RTIMULib from Richards Tech. The Python bindings are great! https://richardstechnotes.wordpress.com/category/rtimulib/

      Keep in mind that the pin numbers are different in the Python MRAA than in the C-version! http://iotdk.intel.com/docs/master/mraa/edison.html –> Pinmode0

    • Awesome! Thank you for posting this!

  • I only found the library for the Sparkfun 9 DOF IMU breakout so I tried that, but it always reads the same value from this block. It turned out that the Arduino expander board is hard-coded to I2C6, while the Sparkfun board in on I2C1. However, both I2C6 and I2C1 are present on the breakout board.

    This issue is discussed here,

    https://communities.intel.com/message/253549#253549

    I modified the hardware\intel\i686\variants\edison_fab_c\variant.h file and changed

    define LINUX_I2C_ADAPTER 6

    to

    define LINUX_I2C_ADAPTER 1

    This solved the problem!

  • I’m not a mpu9150/9250 fanboy or anything , but what was the reasoning behind using this and not the 9150? (and for the bmp85 comment below, … yes it would be great to have – let’s say – the sda/scl and power pins broken out onto a .1 spacing header row on the back so that someone could kludge in a bunch of i2c sensors on the back). Thanks, Y

  • Is there any space left on this board design to add a BMP180 (or similar) barometer?

    With a 10 DoF block like that you wouldn’t need to connect a standalone barometer sensor if you wanted to make an R/C flight controller or something like that. :-) One possible downside might be that any block stacked on top might interfere with the pressure readings if it gets too close…?

    • This is a great idea. Probably not for this release, but we’ll definitely keep it in mind for the next version :)

      • Well, I want to second the barometer addition as well. If the barometer is on the “outside” side of the board, pressure readings should be fine. Ideal stack for a flight controller: a base block for power input and USB OTG for XBEE and GPS communication; the PWM output block; this 10DOF input block.

      • I want to second that. Would love to see this with a Barometer. On the notion of using this as a flight controller, would also love to see a GPS breakout Block

  • Here is some source to get the parameters in Python https://richardstechnotes.wordpress.com/2015/01/13/intel-edison-and-sparkfun-lsm9ds0-imu-block/

  • Does having a powerhouse CPU/micro/WiFi/Bluetooth on top of the magnetometer induce any noise?

    • Maybe. We’ll check it out and let you know.

      • Anything to report? If there is any interference, could you offer an EMF Shield Block with pass-through connectors and a large ground plane? Would that cut down on some of the noise?

  • Here is everything you need to start reading the sensor data without a bunch of extra crap:

    http://www.instructables.com/id/Smart-Helmet-Intel-Edison-Sparkfun-9DOF/

    Please, please be a friend and vote for us!

  • Did anybody try to use SPI interface? I am using LSM9DS0_Simple.ino sketch. I commented out the following code,

    /*

    define LSM9DS0_XM 0x1D // Would be 0x1E if SDO_XM is LOW

    define LSM9DS0_G 0x6B // Would be 0x6A if SDO_G is LOW

    LSM9DS0 dof(MODE_I2C, LSM9DS0_G, LSM9DS0_XM); */

    And uncommented the follwoing code,

    define LSM9DS0_CSG 9 // CSG connected to Arduino pin 9

    define LSM9DS0_CSXM 10 // CSXM connected to Arduino pin 10

    LSM9DS0 dof(MODE_SPI, LSM9DS0_CSG, LSM9DS0_CSXM);

    It always returns 0 values. Do I need to do configuration on Edison? Any input is welcome!

  • I’m looking for 3D mechanical CAD (I.e. SOLIDWORKS) models of the Edison blocks. It would also be awesome if Sparkfun could export IDF models of the EagleCAD board drawings on GitHub. (It would make ME’s like me very, very happy.)

  • I got this block from SparkFun but didn’t find any library for Arduino IDE.

    So I downloaded the arduino library for the following breakout. I compiled and uploaded LSM9DS0_Simple.ino to Edison and it read data back. The problem is the data doesn’t change, always the same values. Any code change is needed? Any input is welcome, thanks a lot!

  • Is this block able to communicate directly with the the arduino block ?

  • Does anyone know the weight of this board?

  • Does anyone know how to use it with mraa and node.js ?

  • Anyone happen to have a driver for Cylon.js for this board?

  • any news regarding this board?

  • The schematic will be available ? I would like to merge this board with the battery board.

  • Will this stack with the Edison breakout from Intel?

    • Yes, sort of. There are a couple of 0.1" pins on the breakout used for power supply selection. You have to remove them and make a suitable short in order to get this to fit.

  • Will this work with the Mini Breakout Kit?

    • It should work with the Mini Breakout. Note that you will have to modify the Mini Breakout to attach most of the Blocks. You will need to cut off or desolder 2 sets of jumper pins and solder one set of those together.

  • Are all your pictures of the Blocks showing the board’s bottom side? IE the edison would go underneath the shown board?

  • Seeing as how light-weight, fast, and low-power the Edison is, this, paired with a bigger battery and a few other boards and bits, could be used to build one of the few x86 drones around!

  • Are you guys going to release the schematics/layout as you usually do? if so, when?

    • Yes, the plan is to keep these boards open source as much as possible. We plan to release the schematics and layout as soon as the boards go live (e.g. no longer just pre-order).

  • The second product image shows several stacked blocks. Is the stacking interface the 70 pin connector? Is that really a through hole connector?

    • It’s not through hole; we have a male on one side and a female on the other.

      We’ll be releasing a bare board design with the rest of our files when we finish working the kinks out, so you can roll your own boards with the headers properly oriented.

    • here they shown ardu pro block from both sides : http://www.youtube.com/watch?v=GY8kaaFzbTE#t=211 it looks like all, except battery and screen blocks, can handle another block

    • that is how the shields stack. there is a connector on the top and on the bottom.

Customer Reviews

3.8 out of 5

Based on 11 ratings:

5 star
1
4 star
7
3 star
3
2 star
0
1 star
0

3 of 3 found this helpful:

Works with RTIMULib

This works perfectly with RTIMULib of richard-tech which is open source. This library is so good that you can work without difficult configurations (i2c bus, address, chip type, registers etc..) .

Project top https://github.com/richards-tech/RTIMULib

Document for Linux (Including instruction for Intel Edison) https://github.com/richards-tech/RTIMULib/tree/master/Linux


2 of 2 found this helpful:

Couldn't find software library so we made our own

This is everything you need to start reading the sensor data without a bunch of extra crap:

http://www.instructables.com/id/Smart-Helmet-Intel-Edison-Sparkfun-9DOF/

Please, please be a friend and vote for us!


2 of 2 found this helpful:

Working fine

I received this board last week along with the PWM board, I now have a working Intel Edison based quadcopter.

I have just one remark about the mechanic: the mounting holes of the Sparkfun boards are not the same as the Intel breakout board. I will have to buy specific screws to mount all the boards.


5 of 5 found this helpful:

Quite nice so far, docs a bit lacking

The hardware appears nice so far, and the options for power management, data capture modes and especially the programmable interrupts seem quite professional (at least to a software guy like me).

The complexity leads to the downside: the apparent lack of libraries / documentation is not making it easier to get started. At least getting links to the datasheet (1) and the code for a similar Arduino breakout(2) would have been appreciated.

Still, the block itself has exceeded expectations so far. If anyone is interested in very rough C code that uses the block, see my hacks here: https://github.com/jku/LSM9DS0 .

  1. http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00087365.pdf

  2. https://github.com/sparkfun/LSM9DS0_Breakout


0 of 1 found this helpful:

it has worked well

good working system


Limited to Only one IMU per device

Too bad this device is hardcoded to one of two address. It limits any device to one (or two) IMU per project. When one thinks of a robot arm, it is useful to know the orientation of EVERY part and thus I have a need for one IMU per element. Unfortunately this is impossible with this device.


Edison 9 Dof

The product has a good form factor. However, I’m not able to use it as I cannot find well-documented APIs and programs for it. Furthermore, Edison supports a number of platforms like python, javascript/cylon, c. It would be a lot better if links to these could be provided?


Has one simple and irritating issue, besides that, have not tried to use it

I’m using it with the Edison Mini Breakout. The Mini-breakout has some headers (J1 and J2, I think) that get in the way and disallow the board from stacking. The headers would go through roughly where the X/Y/Z diagram is.

Would any Sparkfun tech mind telling me if it’s okay to file away that spot until it fits? I don’t see any PCB traces there, but I want to be sure before I go at it with any tools.

Shawn wanted me to pass this along to you - “ If there are no traces present, you should be able to file away PCB without hurting anything. Alternatively, you can de-solder J1 and J2 in order to stack the Block.”

Happy hacking!


Powerful, adaptable and robust!

The performance of this tiny little chip’s performance exceeds expectations, having survived a sustained acceleration of over 30G’s for over an hour in a centrifuge. Real time communication was still possible, even without the external antenna for the Edison - through a foot of reinforced concrete.
Even with (relatively inefficient) Python program logging the data, sampling rates of 1200Hz per axis of the accelerometer is possible. Highly recommended for just about any application or project!


Elegant design but...

Calibration is tough. I seem to get pretty stable readings on the x axis and plane, but y and z tend to be erratic. I even tried to replicate what was done the arduino example code for the other 9dof board with the same chip, but it still doesn’t zero out and set a bias. I am wondering if the wifi signals from the Edison affect the readings. Still working on it


Noisy data and could use a little more software support

I used RTIMULib to get up and running. I am not sure I like how RTIMULib is handling the compass data as it seems to neglect magnetic inclination, but I can deal with that.

I debated 2 stars, but I’m curious what other’s have noticed. Some of the sensor data is quite noisy. To quantify, with the system running only on battery power (no outside charger) and sampling at about 350hz and a moving average filter to 50hz (7 sample moving average) below is the standard deviation I get for each sensor: AccX = 0.0042 G / AccY = 0.0027 G / AccZ = 0.0097 G / GyroX = 0.264 deg/s (average = 0.0015 deg/s) / GyroY = 0.352 deg/s (average = 0.0023 deg/s) / GyroZ = 0.272 deg/s (average = 0.0030 deg/s) / CompassX = 3.2 / CompassY = 0.58 / Compass Z = 0.96

I can live with the Z axis accel being 2-3X as noisy as I’m putting it in a car to measure dynamics with a GPS and we can live without vertical motion. The X axis of the compass being 3-5X more noisy than the other axes is a problem and I can’t really use it to filter the gyros or differentiate heading (GPS) from orientation (compass + gyro). Note that I did the RTEllipsiod calibration of the compass per RTIMULib but I don’t see anything in the calibration that would create such an issue. Additionally the angle appears to be correct as the average points towards magnetic north (including inclination)

Though I am pleasantly surprised at the zero accuracy of the MEMS gyros. I haven’t put it on a turn table so not sure how accurate the dynamics are…

Maybe I got a busted sensor? Is there any QC program

update: further experimentation on orientation I think the magnetic sensor isn’t going to work well buried in an edison stack. The battery is right next to it and that’s likely having a big impact on the magnetic reading. I can get very different numbers for magnetic dip (angle to horizontal) depending on orientation which I think is due to the battery and other components in the stack. Maybe responsible for the noise, maybe not…


Related Tutorials

SparkFun Blocks for Intel® Edison - 9 Degrees of Freedom Block

August 19, 2015

A quick overview of the features of the 9 Degrees of Freedom Block.

Programming the Intel® Edison: Beyond the Arduino IDE

January 7, 2015

Intel's Edison module goes beyond being just another Arduino clone. Check this tutorial for advice on how to get the most out of your Edison by writing code in C++!

Loading Debian (Ubilinux) on the Edison

December 5, 2014

How to load a Debian distribution (specifically Ubilinux) onto the Edison.

General Guide to SparkFun Blocks for Intel® Edison

January 5, 2015

A general guide for using SparkFun Blocks for Intel® Edison in your next project!

Edison Getting Started Guide

December 5, 2014

An introduction to the Intel® Edison. Then a quick walk through on interacting with the console, connecting to WiFi, and doing...stuff.

Installing libmraa on Ubilinux for Edison

January 5, 2015

libmraa is a tool kit for interacting with various Intel single board computers.