FreeIMU

Dear friends, it's been three months since the death of Fabio, and until now we had to make sure on the way in which we want to keep his work alive.

We're his friends at FabLab Torino and Officine Arduino, with us are his girlfriend, his family, and the guys who flew with FreeIMU.

Before setting out the news about Fabio’s website and the continuation of his work, the family would like you to know that most of the organs donated by Fabio at the time of death have given a second chance to many people. And this is already good news.

As for the rest, here's the news:

I'm happy to finally publish the code for drawing nice 3D scatter plots of the incoming accelerometer and magnetometer data for the Ellipsoid into Sphere calibration available in the FreeIMU GUI. This will be soon released in upcoming v0.3 of the FreeIMU GUI but for now is available only on the repository.

This will allow users to have a direct realtime feedback on the performed motions and how good/wrong their sensors are calibrated.

Below a couple of screenshots. Note how screwed up was this magnetometer on it's Z axis, compared to the calibrated sphere output.

This is Wired Italia documentary Arduino: Creation is Child’s Play. I'm interviewed around minute 9:50 and I talk about my FreeIMU project and I fly my quadcopter.

Thanks to Wired Italia, Arduino and Opificio Ciclope for the opportunity.

This is a presentation video I recorded some time ago which presents the FreeIMU project as of Autumn 2012. Hope you like it!

I'm happy to inform you that I've finally created a community website for the FreeIMU project. You can see it at freeimu.varesano.net.

Right now, it's a simple forum website built on top of Drupal with still a pretty crude graphic.. I decided to use Drupal instead of other forum specific platforms (SMF, phpBB, vBulletin, etc..) because ideally this website will evolve to the main source of information for the FreeIMU project thus a simple forum wouldn't have been enough.

In the future, I'll be slowly moving the content of the FreeIMU webpage there and possibly extend it. I'll also add other features like wiki, documentation pages, etc..

So, if you are using FreeIMU and you wanna join the discussion, please join me and register at freeimu.varesano.net!

(Please post something: it's really depressing all empty like that!)

Testing the FreeIMU framework orientation sensing after using the new FreeIMU calibration GUI to calibrate Accelerometer and Magnetometer.

As you should see, this is pretty accurate and drift free estimation.

I'm happy to finally publish a first working version of the FreeIMU Magnetometer and Accelerometer Calibration GUI. Currently, it should allow you to visually calibrate your accelerometer and magnetometer after you connected your IMU to a microcontroller running the FreeIMU_serial example in the FreeIMU library. NOTE: You have to use the FreeIMU_library available on the repository, not the one on the project webpage.

The program is written in Python, using PyQT4 as GUI library, using PySerial to communicate with Arduino, pyqtgraph for the graphs generation and PyOpenGL as backend for graph generation. Numpy and Scipi are instead used in the calibration algorithm.

Right now only 2D graphs and saving to calibration.h features work. 3D graphs and save to microcontroller EEPROM are being developed right now. Still, what's already available should be enough for starting properly calibrating your IMUs.

The software has been designed with flexibility in mind.. Ideally in the future it will evolve and let you test different calibration algorithms and various serial protocols will be implemented to use it with your favorite firmwares (eg: MultiWii, FreeIMU, etc..)

Please consider this release as very alpha software. Bugged and bad, but still nice to have a look. Any suggestion and comments welcome. I'm currently looking for a MacOS tester to try help me package it for Mac as well.

• Windows version: FreeIMU_GUI-0.2-win32-r23.zip
• Linux users are encouraged to test the software directly from the Python sources available on the FreeIMU repository.
• Mac not supported at the moment. I don't have a Mac so I can't test it. Help needed.

Here are a couple of pictures of the GUI..

I'm working on a user friendly calibration program, since I'm completely aware that what I released some time ago using a python script and Octave is very complex to use for FreeIMU library users.

So, I'm creating a new calibration software which will use Python, Numpy and its linalg component to provide an easy to use libre calibration software.

I started by trying what Nirav Patel suggested but wasn't much successful with it. So, I simply ported the Matlab/Octave code into Python+Numpy+linalg.

Below is the code for you to enjoy and here a sample input file.

"""
cal_lib.py - Ellipsoid into Sphere calibration library based upon numpy and linalg
Copyright (C) 2012 Fabio Varesano 

Development of this code has been supported by the Department of Computer Science,
Universita' degli Studi di Torino, Italy within the Piemonte Project
http://www.piemonte.di.unito.it/


This program is free software: you can redistribute it and/or modify
it under the terms of the version 3 GNU General Public License as
published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see .

"""

import numpy
from numpy import linalg

def calibrate(x, y, z):
  H = numpy.array([x, y, z, -y**2, -z**2, numpy.ones([len(x), 1])])
  H = numpy.transpose(H)
  w = x**2
  
  (X, residues, rank, shape) = linalg.lstsq(H, w)
  
  OSx = X[0] / 2
  OSy = X[1] / (2 * X[3])
  OSz = X[2] / (2 * X[4])
  
  A = X[5] + OSx**2 + X[3] * OSy**2 + X[4] * OSz**2
  B = A / X[3]
  C = A / X[4]
  
  SCx = numpy.sqrt(A)
  SCy = numpy.sqrt(B)
  SCz = numpy.sqrt(C)
  
  return ([OSx, OSy, OSz], [SCx, SCy, SCz])


if __name__ == "__main__":
  acc_f = open("acc.txt", 'r')
  acc_x = []
  acc_y = []
  acc_z = []
  for line in acc_f:
    reading = line.split()
    acc_x.append(int(reading[0]))
    acc_y.append(int(reading[1]))
    acc_z.append(int(reading[2]))

  (offsets, scale) = calibrate(numpy.array(acc_x), numpy.array(acc_y), numpy.array(acc_z))
  print offsets
  print scale

I'm happy to finally disclose our work on PALLA, a spherical wireless device designed for usage in videogames and computer based leisure activities. I just opened its project page where you find all the details about it, including some publications on it.

The device has been presented officially at the Fun and Games 2012 conference at the beginning of this month and now I finally have demonstration videos and a project webpage.

Our work has been also featured today on newscientist.com in their article Smart ball lets you play video games intuitively which is also in their first page right now.

Here is a video which explains more about the device:

For more informations on PALLA, please visit the project webpage.

This is a simple example of some of the stuff I've been working on recently. This is a demonstration of the soon to be released filtering capabilities of the FreeIMU library using the FreeIMU v0.4.3 as sensor board.

The sensor fusion algorithm estimates the orientation of the board and from that an estimation of the dynamic acceleration is computed by subtracting the gravity from the accelerometer readings. The dynamic acceleration is the fused with the high resolution barometer readings coming from the MS5611 through a complementary filter.

The result, as seen in the graphs is an extremely reliable altitude estimation which can go up to 5-10 cm of precision with almost immediate response to motion.

Graphs programmed in python with pyqtgraph.