Kalibracja magnetometru ∞

W telefonach komórkowych i innych urządzeniach korzystających z 3-osiowego kompasu elektronicznego do kalibracji magnetometru służy ruch w kształcie ∞ / 8 / S, jak pokazano na tych filmach .

Dlaczego ten ruch jest wykonywany, jaka jest teoria i czy ktoś może podać przykładowy kod C, aby go zaimplementować?

Musisz przejść przez moje kolejne podobne pytanie zawierające więcej informacji.

Kilka dodatkowych informacji na temat tego konkretnego pytania: Platforma to 8-bitowy AtMega32, korzystający z AVR Studio 5.

Do tej pory próbowałem: próbowałem podzielić średnią przez 2 wartości wektorowe magnetometru tworzącego kształt. Myślenie może pomóc w obliczaniu przesunięć. Myślę, że niektóre z dwóch identycznych części / boków kształtu niwelują pole magnetyczne ziemi i podają wartości przesunięcia. Mogę się mylić. Ale szczególnie w przypadku kalibracji opartej na kształcie właśnie tu jestem. Myślę, że kalibracja działa w ten sposób. Chodzi o to, aby dowiedzieć się, czy to działa w ten sposób?

Ok kod, za pomocą którego mogę obliczyć przesunięcia, a później po prostu odjąć je od surowego wektora magnetycznego 3D. Mogę się całkowicie mylić i nie mam wyjaśnienia, jak to działa. Widząc wideo i dane wykreślone na kuli, jakoś przyspieszyło moją myśl i wykorzystałem ją w formie równania. B)

Kod:

Funkcje Read_accl();i Read_magnato(1);odczytują dane czujnika. Mam nadzieję, że kod jest zrozumiały. Mam nadzieję, że mądry ppl z pewnością użyje tego na znacznie lepsze sposoby. : \

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;

                } 
    }   
} 

Po uzyskaniu tych przesunięć użyłem ich w następujący sposób:

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

Jak wspomniałem.

Wzór w kształcie 8 / S służy do kalibracji magnetometrów w telefonach komórkowych i innych urządzeniach.

tło

Typowe magnetometry z epoki telefonu komórkowego mierzą natężenie pola magnetycznego wzdłuż trzech osi ortogonalnych, np .:

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

Przy wielkości pola podanej przez

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

oraz kąt obrotu od każdej osi jako

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

Kalibrowanie

$m_x$$m_y$$m_z$

Idealnie powinien wyglądać mniej więcej tak:

Jednak z powodu twardego i miękkiego efektu żelaza i innych zniekształceń, wygląda to jak zdeformowana kula:

Wynika to z tego, że wielkość pola magnetycznego mierzona przez czujnik zmienia się wraz z orientacją. W rezultacie kierunek pola magnetycznego obliczany zgodnie z powyższymi wzorami różni się od prawdziwego kierunku.

Należy przeprowadzić kalibrację, aby wyregulować każdy z trzech odczytów osi, tak aby wielkość była stała niezależnie od orientacji - można myśleć o tym, że zdeformowana kula musi zostać wypaczona w idealną kulę. LSM303 aplikacja uwaga ma wiele szczegółowe instrukcje dotyczące sposobu wykonania tego.

A co powiesz na wzór 8?

Wykonanie wzoru z rysunku 8 „wykreśla” część zdeformowanej sfery powyżej. Na podstawie uzyskanych współrzędnych można oszacować odkształcenie kuli i uzyskać współczynniki kalibracji. Dobry wzór to taki, który śledzi największy zakres orientacji i dlatego szacuje największe odchylenie od prawdziwej stałej wielkości.

Aby oszacować kształt zdeformowanej kuli, można zastosować elipsę o najmniejszych kwadratach . Nota aplikacyjna LSM303 zawiera również informacje na ten temat.

Prosta metoda podstawowej kalibracji

Zgodnie z notatką aplikacji, jeśli nie przyjmiesz odkształcenia miękkiego żelaza, zdeformowana kula nie zostanie przechylona. Dlatego możliwa może być prosta metoda podstawowej kalibracji:

• Znajdź maksymalną i minimalną wartość dla każdej osi i uzyskaj zakres 1/2 i punkt zerowy

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

$z_k = \max(m_k) - r_k$

• Przesuwaj i skaluj każdy pomiar osi

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

• Oblicz wartości jak poprzednio, z wyjątkiem używania$m_k'$

Jest to oparte na kodzie znalezionym tutaj.

Rozwiązywanie przy użyciu najmniejszych kwadratów

Kod MATLAB do rozwiązania przy użyciu najmniejszych kwadratów pokazano poniżej. Kod zakłada zmienną, w magktórej kolumny są wartościami 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));

Aby wykonać dynamiczną kalibrację liczby 8, można uruchomić procedurę najmniejszych kwadratów przy każdym nowym odczycie i zakończyć, gdy ustabilizują się współczynniki przesunięcia i skali.

Ziemskie pole magnetyczne

Uwaga: pole magnetyczne Ziemi zwykle nie jest równoległe do powierzchni i może występować duży element skierowany w dół.