IMU Brick¶

Features¶

• Voll ausgestattete IMU/AHRS mit 9 Freiheitsgraden (je 3-Achsen Beschleunigungssensor, Kompass, Gyroskop)
• Keine akkumulierenden Fehler, kein Gimbal Lock!
• Werkskalibriert, einfach anwendungsspezifisch zu kalibrieren
• Berechnet Quaternionen sowie Roll-, Nick- (Pitch) und Gier- (Yaw) Winkel
• Direkt auslesbar per USB, erweiterbar über zwei Bricklet Anschlüsse

Beschreibung¶

Der IMU Brick ist mit je einem 3-Achsen Beschleunigungssensor, Magnetfeldsensor (Kompass) und Gyroskop ausgestattet und arbeitet als USB Inertialsensor. Dieser kann 9 Freiheitsgrade messen und berechnet Quaternionen sowie auch Roll-, Nick- und Gier-Winkel. Es ist ein vollständiges Attitude and Heading Reference System.

Die API, verfügbar für viele Programmiersprachen, erlaubt den Zugriff auf die berechneten Daten sowie auf die Beschleunigung, Magnetfeld und Winkelgeschwindigkeiten für die drei Achsen. Wenn die Quaternionen-Darstellung benutzt wird, ist der IMU Brick Gimbal Lock frei (im Gegensatz zur Euler-Winkel Darstellung).

Über zwei Anschlüsse können Bricklets angeschlossen werden, die die Fähigkeiten des Bricks erweitern. Als Beispiel kann ein GPS Bricklet angeschlossen werden um Positionsdaten zu ermitteln. Ein Youtube Video zeigt, wie der Brick zusammen mit einem Barometer Bricklet genutzt werden kann um die Höhe zu bestimmen.

Der IMU Brick kann aber auch mit anderen Bricks in einem Stapel genutzt werden. Zum Beispiel kann ein zusätzlicher Master Brick mit Master Extensions genutzt werden, um die USB Verbindung durch andere kabelgebundene Schnittstellen (RS485, Ethernet) oder drahtlose Schnittstellen (WLAN) zu ersetzen.

Technische Spezifikation¶

Ressourcen¶

• LSM303 (3-Achsen Beschleunigungssensor/Kompass) Datenblatt (Download)
• ITG-3200 (3-Achsen Gyroskop) Datenblatt (Download)
• Schaltplan (Download)
• Umriss und Bohrplan (Download)
• Quelltexte und Platinenlayout (Download)

Anschlussmöglichkeit¶

Das folgende Bild zeigt die verschiedenen Anschlussmöglichkeit des IMU Bricks.

Erster Test¶

Um einen IMU Brick testen zu können, müssen zuerst Brick Daemon und Brick Viewer installiert werden. Brick Daemon arbeitet als Proxy zwischen der USB Schnittstelle der Bricks und den API Bindings. Brick Viewer kann sich mit Brick Daemon verbinden, gibt Informationen über die angeschlossenen Bricks und Bricklets aus und ermöglicht es diese zu testen.

Wenn der Brick per USB an den PC angeschlossen wird sollte einen Moment später im Brick Viewer ein neuer Tab namens "IMU Brick" auftauchen. Wähle diesen Tab aus.

Alle verfügbaren Daten des IMU Bricks werden angezeigt. Wenn der IMU Brick wie dargestellt gehalten und dann der "Save Orientation" Knopf geklickt wird sollten die Bewegungen des IMU Bricks entsprechend im Brick Viewer widergespiegelt werden. Bevor allerdings der "Save Orientation" Knopf geklickt sollte der Brick 15 Sekunden ruhig gehalten werden, damit die Lageberechnung zur richtigen Position konvergieren kann.

Nun kann ein eigenes Programm geschrieben werden. Der Abschnitt Programmierschnittstelle listet die API des IMU Brick und Beispiele in verschiedenen Programmiersprachen auf.

Kalibrierung¶

Der IMU Brick wird fertig kalibriert ausgeliefert und sollte daher direkt nach dem Auspacken funktionieren. Falls es nötig sein sollte ist eine Neukalibrierung leicht zu bewerkstelligen.

Die Werkskalibrierung wurde in einem Raum ohne signifikante magnetische Störfelder durchgeführt. Wenn der IMU Brick in der nähe eines magnetische Feldes (z.B. das eines Motors) betrieben werden soll, dann sollte das Magnetometer in der Position, in der der IMU Brick später verwendet werden soll, neu kalibriert werden!

Um das Magnetometer neu zu kalibrieren muss das Kalibrierungsfenster über den "Calibrate" Knopf auf dem "IMU Brick" Tab im Brick Viewer aufgerufen werden. Wähle dann denn "Magnetometer" Tab aus und klicke "Start Calibration". Bewege nun den IMU Brick bis sich die angezeigten Gain und Bias Werte nicht mehr ändern. Sobald dies der Fall ist kann der "Ready" Knopf geklickt werden und die Kalibrierung des Magnetometers ist abgeschlossen.

Beschleunigungssensor und Gyroskop werden ähnlich kalibriert, folge dazu den Anweisungen im Kalibrierungsfenster. Wir empfehlen zuerst die bestehende Kalibrierung zu exportieren, bevor der Beschleunigungssensor und das Gyroskop neu kalibriert werden, sodass im Notfall die alten Kalibrierung wieder eingespielt werden kann.

Wir empfehlen den Gyroskop Gain nicht neu zu kalibrieren, da dies ohne geeignete externe Maschinen nicht möglich ist.

Die Werkskalibrierung für jeden IMU Brick kann hier abgerufen werden:

https://download.tinkerforge.com/imu_calibration/YOUR_IMU_UID.txt

Dazu muss YOUR_IMU_UID durch die UID des IMU Bricks ersetzt werden. Falls ein Sensor verkalibriert ist oder eine neue Firmwareversion geflasht wurde, dann kann die Werkskalibrierung wieder importiert werden. Dazu muss das Kalibrierungsfenster über den "Calibrate" Knopf auf dem "IMU Brick" Tab im Brick Viewer aufgerufen und der "Im/Export" Tab ausgewählt werden. Zum Abschluss muss der Inhalt der YOUR_IMU_UID.txt Datei in das Textfeld kopiert und auf den "Import" Knopf geklickt werden.

Seit Brick Viewer Version 1.1.13 kann auch der "Restore Factory Calibration" Knopf verwendet werden. Dadurch wird die entsprechende Werkskalibrierung automatisch heruntergeladen und importiert.

Ein Video, das zeigt wie wir die IMU Bricks kalibieren gibt es auf Youtube.

Quaternionen vs Eulerwinkel¶

Wir empfehlen Quaternion anstatt Eulerwinkel (Roll-, Nick- und Gier-Winkel) zu verwenden, da die letzteren einen Gimbal Lock erleiden können.

Eine Formel um eine Quaternion in eine Rotationsmatrix umzurechnen findet sich in der API Dokumentation. Beachte, dass Eulerwinkel immer eine definierte Reihenfolge haben in der sie angewendet werden müssen. Im Falle des IMU Bricks gilt folgenden Reihenfolge: erst Roll-Winkel, dann Gier-Winkel, zuletzt Nick-Winkel.

Berechnung unabhängiger Winkel¶

Es ist nicht möglich Winkel für alle 3 Achsen zu berechnen die vollständig unabhängig sind. Zumindest an den Gimbal Lock Positionen werden Sprünge von 180° auftreten für gewisse Winkel. Dies ist grundsätzlich nicht anders möglich.

Wenn Rotationswinkel für die X, Y und Z Achse in Abhängigkeit zu einer definierten Grundposition benötigt werden, dann muss das Quaternion zuerst im Bezug auf diese Grundposition rotiert werden bevor die Winkel berechnet werden.

Das folgende Python Beispiel tut exakt dies und es sollte einfach zu verstehen und auf andere Programmiersprachen übertragbar sein. Beachte, dass Gimbal Locks bei +90° und -90° für jede der Achsen auftreten. Die Grundposition ist (0,0,0):

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from tinkerforge.ip_connection import IPConnection
from tinkerforge.brick_imu import IMU

import math
import time

class Q:
    HOST = "localhost"
    PORT = 4223
    UID = "XXYYZZ" # Change XXYYZZ to the UID of your Stepper Brick

    def __init__(self):
        self.base_x = 0.0
        self.base_y = 0.0
        self.base_z = 0.0
        self.base_w = 0.0

        self.ipcon = IPConnection() # Create IPconnection
        self.imu = IMU(self.UID, self.ipcon) # Create device object
        self.ipcon.connect(self.HOST, self.PORT) # Connect to brickd

        # Wait for IMU to settle
        print 'Set IMU to base position and wait for 10 seconds'
        print 'Base position will be 0 for all angles'
        time.sleep(10)
        q = self.imu.get_quaternion()
        self.set_base_coordinates(q.x, q.y, q.z, q.w)

        # Set period for quaternion callback to 10ms
        self.imu.set_quaternion_period(10)

        # Register quaternion callback
        self.imu.register_callback(self.imu.CALLBACK_QUATERNION, self.quaternion_cb)

    def quaternion_cb(self, x, y, z, w):
        # Use conjugate of quaternion to rotate coordinates according to base system
        x, y, z, w = self.make_relative_coordinates(-x, -y, -z, w)

        x_angle = int(math.atan2( 2.0*(y*z - w*x), 1.0 - 2.0*(x*x + y*y))*180/math.pi)
        y_angle = int(math.atan2(-2.0*(x*z + w*y), 1.0 - 2.0*(x*x + y*y))*180/math.pi)
        z_angle = int(math.atan2(-2.0*(x*y + w*z), 1.0 - 2.0*(x*x + z*z))*180/math.pi)

        print 'x: {0}, y: {1}, z: {2}'.format(x_angle, y_angle, z_angle)

    def set_base_coordinates(self, x, y, z, w):
        self.base_x = x
        self.base_y = y
        self.base_z = z
        self.base_w = w

    def make_relative_coordinates(self, x, y, z, w):
        # Multiply base quaternion with current quaternion
        return (
            w * self.base_x + x * self.base_w + y * self.base_z - z * self.base_y,
            w * self.base_y - x * self.base_z + y * self.base_w + z * self.base_x,
            w * self.base_z + x * self.base_y - y * self.base_x + z * self.base_w,
            w * self.base_w - x * self.base_x - y * self.base_y - z * self.base_z
        )

if __name__ == "__main__":
    q = Q()

    raw_input('Press key to exit\n') # Use input() in Python 3
    q.ipcon.disconnect()

Paul Balzer von MechLab Engineering hat zusätzlich Code auf GitHub bereit gestellt der die Quaternionen in das Fahrzeugkoordinatensystem nach DIN70000 umwandelt. Insbesondere wird dort durchgängig ein rechtshändiges Koordinatensystem verwendet. Mehr Informationen dazu gibt es im Blog von MachLab Engineering.

Funktionsweise¶

Auf Basis der Sensordaten die der IMU Brick sammelt (Winkelgeschwindigkeit, Beschleunigung und Magnetfeld) ist es möglich Sensorfusion zu betreiben, um eine absolute Orientierung im Raum zu ermitteln.

Häufig wird für diesen Berechnungsprozess ein Kalman Filter verwendet. Der IMU Brick verwendet allerdings einen Filter der auf diesem Paper von S. O. Madgwick basiert. Unsere Tests haben gezeigt, dass dieser neuartige Filter signifikant bessere Ergebnisse als ein Kalman Filter erzielt. Madgwick beschreibt die Arbeitsweise seines Filter so:

[...] the filter calculates the orientation by numerically integrating the estimated orientation rate. It is computed as the rate of change of orientation measured by the gyroscopes. The magnitude of the gyroscope measurement error is removed in the direction of the estimated error, which is computed from accelerometer and magnetometer measurements.

Das folgende Bild zeigt die verschiedenen Schritte des Filters:

Bild und Erklärung stammen aus S. O. Madgwick: "An efficient orientation filter for inertial and inertial/magnetic sensor arrays", University of Bristol, April 2010.

Programmierschnittstelle¶

Siehe Programmierschnittstelle für eine detaillierte Beschreibung.