Subversion Repositories FlightCtrl

/*

Copyright 2007, Niklas Nold

This program (files compass.c and compass.h) is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation;
either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

Please note: All the other files for the project "Mikrokopter" by H. Buss are under the license (license_buss.txt) published by www.mikrokopter.de
*/

#include "main.h"

MM3_struct MM3;

#define long int m;

//############################################################################
//Initialisierung der SPI-Schnittstelle
void init_spi(void)
//############################################################################
{
        SPCR = (1<<SPIE)|(1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);        //Interrupt an, Master, 156 kHz Oszillator
        //SPSR = (1<<SPI2X);
       
    DDRB |= (1<<PB7)|(1<<PB5)|(1<<PB2); // J8, MOSI, SCK Ausgang
       
        PORTD &= ~(1<<PD3);     // J5 auf Low
       
        MM3.AXIS = MM3_X;
        MM3.STATE = MM3_RESET;
}


//############################################################################
//Wird in der SIGNAL (SIG_OVERFLOW0) aufgerufen
void MM3_timer0(void)
//############################################################################
{
        switch (MM3.STATE)
        {
        case MM3_RESET:                        
                PORTB |= (1<<PB2);      // J8 auf High, MM3 Reset
                MM3.STATE = MM3_START_TRANSFER;
                return;
               
        case MM3_START_TRANSFER:
                PORTB &= ~(1<<PB2);     // J8 auf Low (war ~125 µs auf High)           
               
                if (MM3.AXIS == MM3_X) SPDR = 0x51;                     // Schreiben ins SPDR löst automatisch Übertragung (MOSI und MISO) aus
                else if (MM3.AXIS == MM3_Y) SPDR = 0x52;                // Micromag Period Select ist auf 1024 (0x50)
                else if (MM3.AXIS == MM3_Z) SPDR = 0x53;                // 1: x-Achse, 2: Y-Achse, 3: Z-Achse
               
                MM3.DRDY = SetDelay(15);                // 15 Laut Datenblatt max. Zeit bis Messung fertig (bei PS 1024)
                MM3.STATE = MM3_WAIT_DRDY;
                return;
       
        case MM3_WAIT_DRDY:
                if (CheckDelay(MM3.DRDY)) {SPDR = 0x00;MM3.STATE = MM3_DRDY;} // Irgendwas ins SPDR, damit Übertragung ausgelöst wird, wenn Wartezeit vorbei
                return;         // Jetzt gehts weiter in SIGNAL (SIG_SPI)
       
        case MM3_TILT:          // Zeitnahe Speicherung der aktuellen Neigung in °
                MM3.NickGrad = asin_i((float)Aktuell_ax/215*200);
                MM3.RollGrad = asin_i((float)Aktuell_ay/205*200);
               
                MM3.AXIS = MM3_X;
                MM3.STATE = MM3_RESET;
                return;
        }
}
 

//############################################################################
//SPI byte ready
SIGNAL (SIG_SPI)
//############################################################################
{      
        switch (MM3.STATE)
        {      
        case MM3_DRDY:          // 1. Byte ist da, abspeichern, an die MSB-Stelle rücken               
                if (MM3.AXIS == MM3_X)
                {
                        MM3.x_axis = SPDR;
                        MM3.x_axis <<= 8;
                }
                else if (MM3.AXIS == MM3_Y)
                {
                        MM3.y_axis = SPDR;
                        MM3.y_axis <<= 8;
                }
                else            // if (MM3.AXIS == MM3_Z)
                {
                        MM3.z_axis = SPDR;
                        MM3.z_axis <<= 8;
                }
               
                SPDR=0x00;              // Übertragung von 2. Byte auslösen
                MM3.STATE=MM3_BYTE2;
                return;
               
        case MM3_BYTE2:         // 2. Byte der entsprechenden Achse ist da             
                if (MM3.AXIS == MM3_X)
                {
                        MM3.x_axis |= SPDR;
                        MM3.x_axis -= OFF_X;    // Sofort Offset aus der Kalibrierung berücksichtigen
                        MM3.AXIS = MM3_Y;
                        MM3.STATE = MM3_RESET;
                }
                else if (MM3.AXIS == MM3_Y)
                {
                        MM3.y_axis |= SPDR;            
                        MM3.y_axis -= OFF_Y;
                        MM3.AXIS = MM3_Z;
                        MM3.STATE = MM3_RESET;
                }
                else            // if (MM3.AXIS == MM3_Z)
                {
                        MM3.z_axis |= SPDR;
                        MM3.z_axis -= OFF_Z;
                        MM3.STATE = MM3_TILT;
                }
                               
                // versuch die werte nicht über min und max steigen zu lassen um so die spikes zu verhindern
                // verhindert hats nicht aber deutlich minimiert. Evtl kommen die restlichen
               
                        if (MM3.x_axis > MM3_Xmax || MM3.x_axis < MM3_Xmin)
                        {
                                MM3.x_axis = MM3.x_axis_last_valid;
                        }              
                        else
                        if (MM3.x_axis_last_valid *1,10 < MM3.x_axis || MM3.x_axis_last_valid *0,90 > MM3.x_axis)
                        {
                                MM3.x_axis = MM3.x_axis_last_valid;
                        }
                        else
                        {
                         //m = (MM3.x_axis + MM3.x_axis_last_valid) /2;
                         MM3.x_axis_last_valid = MM3.x_axis;
                         //MM3.x_axis = m;
                        }




                        if (MM3.y_axis > MM3_Ymax || MM3.y_axis < MM3_Ymin)
                        {
                                MM3.y_axis = MM3.y_axis_last_valid;
                        }              
                        else
                        if (MM3.y_axis_last_valid *1,10 < MM3.y_axis || MM3.y_axis_last_valid *0,90 > MM3.y_axis)
                        {
                                MM3.y_axis = MM3.y_axis_last_valid;
                        }
                        else
                        {
                         //m = (MM3.y_axis + MM3.y_axis_last_valid) /2;
                         MM3.y_axis_last_valid = MM3.y_axis;
                         //MM3.y_axis = m;
                         
                        }



                        if (MM3.z_axis > MM3_Zmax || MM3.z_axis < MM3_Zmin)
                        {
                                MM3.z_axis = MM3.z_axis_last_valid;
                        }              
                        else
                        if (MM3.z_axis_last_valid *1,10 < MM3.z_axis || MM3.z_axis_last_valid *0,90 > MM3.z_axis)
                        {
                                MM3.z_axis = MM3.z_axis_last_valid;
                        }      
                        else
                        {
                                //m = (MM3.z_axis + MM3.z_axis_last_valid) /2;
                                MM3.z_axis_last_valid = MM3.z_axis;
                                //MM3.z_axis = m;
                        }
                       
                       



               
                return;
        }
}

signed int MM3_heading(void)
{
        float sin_nick, cos_nick, sin_roll, cos_roll;
        signed int x_corr, y_corr;
        signed int heading;


               
        // Berechung von sinus und cosinus
        sin_nick = sin_f(MM3.NickGrad);
        cos_nick = cos_f(MM3.NickGrad);
        sin_roll = sin_f(MM3.RollGrad);
        cos_roll = cos_f(MM3.RollGrad);      
       
    // Neigungskompensation
        //x_corr = (cos_nick * MM3.x_axis) + (((sin_roll *  MM3.y_axis) - (cos_roll * MM3.z_axis)) * sin_nick);
       
        x_corr = (cos_nick * MM3.x_axis) - (((sin_roll *  MM3.y_axis) - (cos_roll * MM3.z_axis)) * sin_nick);
        y_corr = ((cos_roll * MM3.y_axis) + (sin_roll * MM3.z_axis));
       
        // Winkelberechnung
        heading = atan2_i(x_corr, y_corr);

return (heading);
}