Étalonnage en forme de magnétomètre

Dans les téléphones mobiles et autres appareils utilisant une boussole électronique à 3 axes, un mouvement en forme de ∞ / 8 / S est utilisé pour calibrer le magnétomètre comme indiqué dans ces vidéos .

Pourquoi ce mouvement est-il effectué, quelle est la théorie, et quelqu'un peut-il donner un exemple de code C pour l'implémenter?

Vous devez avoir à passer par ma autre question similaire contenant plus d'informations.

Quelques informations supplémentaires pour cette question particulière: La plate-forme est AtMega32 8 bits, utilisant AVR Studio 5.

Jusqu'à présent, j'ai essayé: j'ai essayé de diviser la moyenne par 2 des valeurs vectorielles du magnétomètre faisant la forme. La réflexion pourrait aider à calculer les décalages. Je pense que certains comment les deux parties / côtés identiques de la forme annulent le champ magnétique terrestre et donnent les valeurs de décalage. J'ai peut être tort. Mais en particulier pour l'étalonnage basé sur la forme, c'est là que je suis actuellement. Je pense que l'étalonnage fonctionne de cette façon. L'idée est de savoir si cela fonctionne de cette façon?

Ok le code par lequel je peux calculer les décalages et plus tard simplement soustraire ceux du vecteur 3D magnétique brut. Je me trompe peut-être totalement et je n'ai aucune explication sur le fonctionnement. Voir la vidéo et les données tracées sur la sphère a quelque peu accéléré ma pensée et j'ai utilisé cette pensée sous forme d'équation. B)

Code:

Les fonctions Read_accl();et Read_magnato(1);lisent les données du capteur. J'espère que le code est explicite. En espérant que ppl sage l'utilisera sûrement bien mieux. : \

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;

                } 
    }   
} 

Après avoir obtenu ces décalages, je les ai utilisés comme suit:

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 ;
...
}

Comme je l'ai mentionné.

Le modèle en forme de 8 / S est utilisé pour étalonner les magnétomètres dans les téléphones mobiles et autres appareils.

Contexte

Les magnétomètres typiques de l'ère des téléphones portables mesurent la force du champ magnétique le long de trois axes orthogonaux, par exemple:

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

Avec l'amplitude du champ donnée par,

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

et l'angle de rotation de chaque axe comme

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

Étalonnage

$m_x$$m_y$$m_z$

Idéalement, cela devrait ressembler à ceci:

Cependant, en raison des effets du fer dur et mou et d'autres distorsions, il finit par ressembler à une sphère déformée:

En effet, la magnitude du champ magnétique mesurée par le capteur change avec l'orientation. Le résultat étant que la direction du champ magnétique, calculée selon les formules ci-dessus, est différente de la vraie direction.

L'étalonnage doit être effectué pour ajuster chacune des lectures des trois axes afin que la magnitude soit constante quelle que soit l'orientation - vous pouvez la considérer comme la sphère déformée doit être déformée en une sphère parfaite. La note d' application du LSM303 contient de nombreuses instructions détaillées sur la façon de procéder.

Alors qu'en est-il du motif de la figure 8!?

L'exécution du motif de la figure 8 `` trace '' une partie de la sphère déformée ci-dessus. A partir des coordonnées obtenues, la déformation de la sphère peut être estimée, et les coefficients d'étalonnage obtenus. Un bon modèle est celui qui parcourt la plus grande gamme d'orientations et estime donc la plus grande déviation par rapport à la véritable amplitude constante.

Pour estimer la forme de la sphère déformée, un ajustement par ellipse des moindres carrés peut être utilisé. La note d'application LSM303 contient également des informations à ce sujet.

Une méthode simple pour un étalonnage de base

Selon la note de l'application, si vous ne supposez aucune distorsion du fer doux, la sphère déformée ne sera pas inclinée. Par conséquent, une méthode simple pour un étalonnage de base peut être possible:

• Trouvez la valeur maximale et minimale pour chaque axe et obtenez la plage 1/2 et le point zéro

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

$z_k = \max(m_k) - r_k$

• Décaler et mettre à l'échelle chaque mesure d'axe

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

• $m_k'$

Ceci est basé sur le code trouvé ici.

Résolution à l'aide des moindres carrés

Le code MATLAB à résoudre à l'aide des moindres carrés est illustré ci-dessous. Le code suppose une variable magoù les colonnes sont les valeurs xyz.

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

Pour effectuer un étalonnage dynamique de la figure 8, vous pouvez exécuter la routine des moindres carrés à chaque nouvelle lecture et terminer lorsque les facteurs de décalage et d'échelle se sont stabilisés.

Champ magnétique terrestre

Notez que le champ magnétique terrestre n'est généralement pas parallèle à la surface et il peut y avoir une grande composante descendante.