Calibração em forma de magnetômetro

Em telefones celulares e outros dispositivos usando uma bússola eletrônica de 3 eixos, um movimento em forma de ∞ / 8 / S é usado para calibrar o magnetômetro, como mostrado nesses vídeos .

Por que esse movimento é realizado, qual é a teoria e alguém pode dar um exemplo de código C para implementá-lo?

Você deve ter que passar por minha outra pergunta semelhante contendo mais informações.

Algumas informações adicionais para esta pergunta em particular: A plataforma é o AtMega32 de 8 bits, usando o AVR Studio 5.

Até agora, tentei: tentei dividir a média por 2 dos valores vetoriais do magnetômetro que faz a forma. Pensar pode ajudar no cálculo de compensações. Eu acho que de alguma forma as duas partes / lados idênticos da forma estão cancelando o campo magnético da Terra e fornecendo os valores de deslocamento. Eu posso estar errado. Mas particularmente para a calibração baseada em formas, é onde estou atualmente. Eu acho que a calibração funciona dessa maneira. A idéia é descobrir se isso funciona dessa maneira?

Ok, o código pelo qual eu posso calcular as compensações e mais tarde simplesmente subtrair as do vetor 3D magnético Raw. Eu posso estar totalmente errado e não ter explicação sobre como isso funciona. Vendo o vídeo e os dados plotados na esfera, de alguma forma acelerou meu pensamento e usei esse pensamento na forma de equação. B)

Código:

As funções Read_accl();e Read_magnato(1);estão lendo os dados do sensor. Espero que o código seja auto-explicativo. Esperando que as pessoas sábias certamente usem isso de maneiras muito melhores. : \

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;

                } 
    }   
} 

Depois de obter essas compensações, usei-as da seguinte maneira:

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

Conforme mencionei.

O padrão em forma de 8 / S é usado para calibrar magnetômetros em telefones celulares e outros dispositivos.

fundo

Os magnetômetros típicos da era do telefone móvel medem a força do campo magnético ao longo de três eixos ortogonais, por exemplo:

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

Com a magnitude do campo dada por,

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

e o ângulo de rotação de cada eixo como

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

Calibração

Como o campo magenético da Terra é relativamente constante, a magnitude do campo as, medida pelo magnetômetro, também deve ser constante, independentemente da orientação do sensor. ou seja, se alguém girar o sensor e plotar , e em 3D, os caminhos devem plotar a superfície de uma esfera com raio constante.$m_x$$m_y$$m_z$

Idealmente, deve ser algo como isto:

No entanto, devido aos efeitos de ferro duro e macio e outras distorções, acaba parecendo uma esfera deformada:

Isso ocorre porque a magnitude do campo magnético, medida pelo sensor, está mudando com a orientação. O resultado é que a direção do campo magnético, quando calculada de acordo com as fórmulas acima, é diferente da direção verdadeira.

A calibração deve ser realizada para ajustar cada uma das leituras dos três eixos, de modo que a magnitude seja constante, independentemente da orientação - você pode pensar nisso como a esfera deformada deve ser deformada em uma esfera perfeita. A nota de aplicação do LSM303 possui muitas instruções detalhadas sobre como fazer isso.

E o padrão da figura 8 !?

A execução do padrão da figura 8 'rastreia' parte da esfera deformada acima. A partir das coordenadas obtidas, a deformação da esfera pode ser estimada e os coeficientes de calibração obtidos. Um bom padrão é aquele que rastreia a maior variedade de orientações e, portanto, estima o maior desvio da verdadeira magnitude constante.

Para estimar a forma da esfera deformada, o ajuste da elipse de mínimos quadrados pode ser usado. A nota de aplicação do LSM303 também possui informações sobre isso.

Um método simples para uma calibração básica

De acordo com a nota do aplicativo, se você não assumir nenhuma distorção de ferro macio, a esfera deformada não será inclinada. Portanto, um método simples para uma calibração básica pode ser possível:

• Encontre o valor máximo e mínimo para cada eixo e obtenha a faixa 1/2 e o ponto zero

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

$z_k = \max(m_k) - r_k$

• Deslocar e dimensionar cada medição de eixo

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

• Calcular valores como antes, exceto usando$m_k'$

Isso é baseado no código encontrado aqui.

Resolução usando mínimos quadrados

O código MATLAB para resolver usando mínimos quadrados é mostrado abaixo. O código assume uma variável em magque as colunas são os valores 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));

Para fazer uma calibração dinâmica da figura 8, você pode executar a rotina de mínimos quadrados a cada nova leitura e terminar quando os fatores de deslocamento e escala estiverem estabilizados.

Campo Magnético da Terra

Observe que o campo magnético da Terra geralmente não é paralelo à superfície e pode haver um grande componente descendente.