Magnetometer ∞-förmige Kalibrierung

Bei Mobiltelefonen und anderen Geräten, die einen elektronischen 3-Achsen-Kompass verwenden, wird das in diesen Videos gezeigte Magnetometer mit einer Bewegung in shaped / 8 / S-Form kalibriert .

Warum wird diese Bewegung ausgeführt, wie lautet die Theorie, und kann jemand einen Beispiel-C-Code angeben, um sie zu implementieren?

Sie müssen meine andere ähnliche Frage durchgehen , die mehr Informationen enthält.

Einige zusätzliche Informationen zu dieser Frage: Die Plattform ist 8-Bit-AtMega32 mit AVR Studio 5.

Bis jetzt habe ich versucht: Ich habe versucht, den Durchschnitt durch 2 der Vektorwerte des Magnetometers zu teilen , um die Form zu erhalten. Denken könnte bei der Berechnung von Offsets helfen. Ich denke, wie die zwei identischen Teile / Seiten der Form das Erdmagnetfeld aufheben und die Versatzwerte ausgeben. Ich könnte falsch liegen. Aber gerade für die formbasierte Kalibrierung bin ich gerade hier. Ich denke, die Kalibrierung funktioniert so. Die Idee ist herauszufinden, ob das so funktioniert.

Ok, der Code, mit dem ich die Offsets berechnen und später einfach vom rohen magnetischen 3D-Vektor subtrahieren kann. Ich könnte völlig falsch liegen und keine Erklärung haben, wie es funktioniert. Nachdem ich das Video und die auf der Kugel aufgezeichneten Daten gesehen habe, hat sich mein Denken irgendwie beschleunigt, und ich habe diesen Gedanken in Form einer Gleichung verwendet. B)

Code:

Die Read_accl();und Read_magnato(1);Funktionen lesen die Sensordaten. Ich hoffe, der Code ist selbsterklärend. In der Hoffnung, dass ppl dies auf viel bessere Weise nutzen wird. : \

void InfinityShapedCallibration()
{
    unsigned char ProcessStarted = 0;
    unsigned long cnt = 0; 

    while (1)
    {

            Read_accl();

            // Keep reading Acc data
            // Detect Horizontal position
            // Detect Upside down position
            // Then detect the Horizontal position again.
            // Meanwhile an infinity shaped movement will be created.
            // Sum up all the data, divide by the count, divide by 2 .
            // !We've offsets.          

                if (ProcessStarted!=3)
                {
                //
                    //USART_Transmit_String("\r");
                    //rprintfFloat(4, g_structAccelerometerData.accx_RAW);
                    //USART_Transmit_String(",");
                    //rprintfFloat(4, g_structAccelerometerData.accy_RAW);
                    //USART_Transmit_String(",");
                    //rprintfFloat(4, g_structAccelerometerData.accz_RAW);

                }


            if (
             abs( g_structAccelerometerData.accx_RAW) < 100 
            && abs(g_structAccelerometerData.accy_RAW) < 100 
            && g_structAccelerometerData.accz_RAW < -350 
            && ProcessStarted != 2 && ProcessStarted != 3 && ProcessStarted != 1 )
            {
                ProcessStarted = 1; 
            }   

            if (ProcessStarted==1)
            { 

            Read_magnato(1);

                structMagnetometerOffsetDataToEEPROM.Off_X += g_structMegnetometerData.magx_RAW;
                structMagnetometerOffsetDataToEEPROM.Off_Y += g_structMegnetometerData.magy_RAW;
                structMagnetometerOffsetDataToEEPROM.Off_Z += g_structMegnetometerData.magz_RAW;

                cnt++;

            }               
                if ( g_structAccelerometerData.accz_RAW > 350 
                && ProcessStarted==1)
                {
                    ProcessStarted = 2; 
                }

                if ( g_structAccelerometerData.accz_RAW < -350 
                && ProcessStarted == 2 )
                {
                    ProcessStarted=3; 
                    structMagnetometerOffsetDataToEEPROM.Off_X /= cnt;
                    structMagnetometerOffsetDataToEEPROM.Off_X /= 2;

                    structMagnetometerOffsetDataToEEPROM.Off_Y /= cnt;
                    structMagnetometerOffsetDataToEEPROM.Off_Y /= 2;

                    structMagnetometerOffsetDataToEEPROM.Off_Z /= cnt;
                    structMagnetometerOffsetDataToEEPROM.Off_Z /= 2;  

                    UpdateOFFSETDATAinEEPROM();  

                    break;

                } 
    }   
} 

Nachdem ich diese Offsets erhalten hatte, benutzte ich sie wie folgt:

void main()
{
...

Read_magnato(1);
        g_structMegnetometerData.magx_RAW -= structMagnetometerOffsetDataToEEPROM.Off_X ;
        g_structMegnetometerData.magy_RAW -= structMagnetometerOffsetDataToEEPROM.Off_Y ;
        g_structMegnetometerData.magz_RAW -= structMagnetometerOffsetDataToEEPROM.Off_Z ;
...
}

Wie ich schon sagte.

Das 8 / S-förmige Muster wird zum Kalibrieren von Magnetometern in Mobiltelefonen und anderen Geräten verwendet.

Hintergrund

Typische Handy-Magnetometer messen die Magnetfeldstärke entlang dreier orthogonaler Achsen, z.

$\textbf{m} = m_x\boldsymbol{\hat{\imath}} + m_y\boldsymbol{\hat{\jmath}} + m_z\boldsymbol{\hat{k}}$

Mit der Größe des Feldes gegeben durch,

$\|\textbf{m}\| = \sqrt{m_x^2 +m_y^2 + m_z^2}$

und der Drehwinkel von jeder Achse als

$\theta_k = \cos^{-1} \frac{m_k}{ \| \textbf{m} \| }, \text{ where } k \in [x,y,z]$

Kalibrierung

$m_x$$m_y$$m_z$

Im Idealfall sollte es so aussehen:

Aufgrund von Hart- und Weicheiseneffekten und anderen Verzerrungen sieht es jedoch wie eine deformierte Kugel aus:

Dies liegt daran, dass sich die Stärke des vom Sensor gemessenen Magnetfelds mit der Ausrichtung ändert. Das Ergebnis ist, dass die Richtung des Magnetfelds bei Berechnung nach den obigen Formeln von der tatsächlichen Richtung abweicht.

Es muss eine Kalibrierung durchgeführt werden, um jeden der drei Achsenmesswerte so anzupassen, dass die Größe unabhängig von der Ausrichtung konstant ist. Sie können sich das so vorstellen, als ob die deformierte Kugel zu einer perfekten Kugel verzogen werden muss. Der Anwendungshinweis zum LSM303 enthält viele detaillierte Anweisungen zur Durchführung.

Was ist also mit dem 8er-Muster?

Durch Ausführen des Musters in Abbildung 8 wird ein Teil der darüber liegenden deformierten Kugel nachgezeichnet. Aus den erhaltenen Koordinaten kann die Verformung der Kugel geschätzt und die Kalibrierungskoeffizienten erhalten werden. Ein gutes Muster zeichnet den größten Orientierungsbereich auf und schätzt daher die größte Abweichung von der tatsächlichen konstanten Größe.

Um die Form der deformierten Kugel abzuschätzen , kann eine Ellipsenanpassung mit den kleinsten Quadraten verwendet werden. Informationen hierzu enthält auch der Application Note LSM303.

Eine einfache Methode zur Grundkalibrierung

Wenn Sie laut App-Hinweis von keiner Weicheisenverzerrung ausgehen, wird die deformierte Kugel nicht gekippt. Daher kann eine einfache Methode zur Grundkalibrierung möglich sein:

• Finden Sie den Maximal- und Minimalwert für jede Achse und erhalten Sie den 1/2 Bereich und den Nullpunkt

$r_k = \tfrac{1}{2} (\max(m_k) - \min(m_k))$

$z_k = \max(m_k) - r_k$

• Verschieben und skalieren Sie jede Achsmessung

$m_k' = \frac{m_k - z_k}{r_k}$

• $m_k'$

Dies basiert auf dem hier gefundenen Code .

Lösen mit kleinsten Quadraten

Der MATLAB-Code zum Lösen mit den kleinsten Quadraten ist unten dargestellt. Der Code nimmt eine Variable an, magbei der die Spalten die xyz-Werte sind.

H = [mag(:,1), mag(:,2), mag(:,3), - mag(:,2).^2, - mag(:,3).^2, ones(size(mag(:,1)))];
w = mag(:,1).^2;
X = (H'*H)\H'*w;
offX = X(1)/2;
offY = X(2)/(2*X(4));
offZ = X(3)/(2*X(5));
temp = X(6) + offX^2 + X(4)*offY^2 + X(5)*offZ^2;
scaleX = sqrt(temp);
scaleY = sqrt(temp / X(4));
scaleZ= sqrt(temp / X(5));

Um eine dynamische 8-Kalibrierung durchzuführen, können Sie bei jedem neuen Messwert die Routine der kleinsten Fehlerquadrate ausführen und beenden, wenn sich der Offset- und der Skalierungsfaktor stabilisiert haben.

Erdmagnetfeld

Beachten Sie, dass das Erdmagnetfeld normalerweise nicht parallel zur Oberfläche verläuft und möglicherweise eine große Abwärtskomponente vorliegt.