Subversion Repositories FlightCtrl

/*

This program (files spi.c and spi.h) is free software; you can redistribute it and/or modify

it under the terms of the GNU 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 General Public License for more details. You should have received a copy of the GNU 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

*/

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Patrick Kögel

Micromag3 Auswertung beta

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

//*****************************************************************************

//

// File Name    : 'spi.c'

// Title                : SPI interface driver

// Author               : Pascal Stang - Copyright (C) 2000-2002

// Created              : 11/22/2000

// Revised              : 06/06/2002

// Version              : 0.6

// Target MCU   : Atmel AVR series

// Editor Tabs  : 4

//

// NOTE: This code is currently below version 1.0, and therefore is considered

// to be lacking in some functionality or documentation, or may not be fully

// tested.  Nonetheless, you can expect most functions to work.

//

// This code is distributed under the GNU Public License

//              which can be found at http://www.gnu.org/licenses/gpl.txt

//

//*****************************************************************************

#include "main.h"

// Define the SPI_USEINT key if you want SPI bus operation to be

// interrupt-driven.  The primary reason for not using SPI in

// interrupt-driven mode is if the SPI send/transfer commands

// will be used from within some other interrupt service routine

// or if interrupts might be globally turned off due to of other

// aspects of your program

//

// Comment-out or uncomment this line as necessary

//#define SPI_USEINT

// global variables

volatile unsigned char spiTransferComplete,MessungFertig=0,KompassInUse =0,KompassInUseCal=0,NewX= 0,NewY= 0,NewZ= 0,EEPROMWrite=0;

volatile signed char nickgrad=0,rollgrad=0,nickgradkomp=0,rollgradkomp=0;

volatile double XE= 0,YE=0,nick=0,roll=0;

volatile double richtungorgd=0,richtungorgr=0;

volatile int iXsf=0,iYsf=0,iZsf=0;

volatile int Xoffset=0, Yoffset=0, Zoffset=0;

volatile signed int Xmax=-32768 , Xmin=32767, Ymax=-32768, Ymin=32767, Zmin=32767, Zmax=-32768; // where you store max and min X and Ys

volatile int XrawOld=0, YrawOld=0, ZrawOld=0; // save values you get from the ASIC

volatile int Xraw=0, Yraw=0, Zraw=0; // values you get from the ASIC

volatile double XrawCal=0, YrawCal=0, ZrawCal=0; // values you get from the ASIC

double XEx=0,XEy=0,XEz=0,YEy=0,YEz=0;

int MagnetG=0;

typedef struct

{

        int Xoffsetm;

        int Yoffsetm;

        int Zoffsetm;

        int iXsfm;

        int iYsfm;

        int iZsfm;

        int dummy;

} CALPARAKOMPASS ;

CALPARAKOMPASS CalParaKompass;

volatile int azimuthgrad= 0,azimuthold = 0;

// SPI interrupt service handler

#ifdef SPI_USEINT

SIGNAL(SIG_SPI)

{

        spiTransferComplete = 1;

}

#endif

// access routines

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

void spiInit(void)

{

        // setup SPI I/O pins

        sbi(PORTB, 7);  // set SCK hi

        sbi(DDRB, 7);   // set SCK as output

        cbi(DDRB, 6);   // set MISO as input

        sbi(DDRB, 5);   // set MOSI as output

        sbi(DDRD, 5);   // SS must be output for Master mode to work

        sbi(DDRD, 3);   // Reset output

        cbi(DDRD, 4);   // DataReady as input

        // setup SPI interface :

        // master mode

        sbi(SPCR, MSTR);

        // clock = f/32  -> 20 MHZ /32

        sbi(SPCR, SPR0);

        sbi(SPCR, SPR1);

        cbi(SPSR,SPI2X);

        // select clock phase positive-going in middle of data

        cbi(SPCR, CPOL);

        // Data order MSB first

        cbi(SPCR,DORD);

        // enable SPI

        sbi(SPCR, SPE);

        // clear status

        inb(SPSR);

        sbi(SPSR,SPI2X);

        spiTransferComplete = 1;

        // enable SPI interrupt

        #ifdef SPI_USEINT

        sbi(SPCR, SPIE);

        #endif

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

void spiSendByte(unsigned char data)

{

        // send a byte over SPI and ignore reply

        #ifdef SPI_USEINT

                while(!spiTransferComplete);

                spiTransferComplete = FALSE;

        #else

                while(!(inb(SPSR) & (1<<SPIF)));

        #endif

        outb(SPDR, data);

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

unsigned char spiTransferByte(unsigned char data)

{

        #ifdef SPI_USEINT

        // send the given data

        spiTransferComplete = FALSE;

        outb(SPDR, data);

        // wait for transfer to complete

        while(!spiTransferComplete);

        #else

        // send the given data

        outb(SPDR, data);

        // wait for transfer to complete

        while(!(inb(SPSR) & (1<<SPIF)));

        #endif

        // return the received data

        return inb(SPDR);

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

unsigned int spiTransferWord(unsigned int data)

{

        unsigned int rxData = 0;

        // send MS byte of given data

        rxData = (spiTransferByte((data>>8) & 0x00FF))<<8;

        // send LS byte of given data

        rxData |= (spiTransferByte(data & 0x00FF));

        // return the received data

        return rxData;

}

 //------------------------------------------------------------------------------

 //---[ compassFilter ]----------------------------------------------------------

 //------------------------------------------------------------------------------

 /** Digital filter for the compass readings

  *  \n Filter by Vadym Grygorenko

  *  \n fn = (1/4)*(cn + 2*c_(n-1) + c_(n-2)) + (f_(n-1)) - (1/4)*f_(n-2)

  *

  *  \param   axiss     The axis this measurement is for

  *  \param   reading   The latest reading from the compass

  *  \return            The newest output from the filter

  *

  */

 int compassFilter(unsigned char axiss, int reading)

 {

    static int input[3][3]={{0,0,0},{0,0,0},{0,0,0}};       //[n, n-1, n-2][axis]

    static int output[3][3]={{0,0,0},{0,0,0},{0,0,0}};

    input[0][axiss]  = reading;

    output[0][axiss] = ((input[0][axiss] + 2*input[1][axiss] + input[2][axiss]) / 4);

    input[2][axiss]  = input[1][axiss];

    input[1][axiss]  = input[0][axiss];

    output[2][axiss] = output[1][axiss];

    output[1][axiss] = output[0][axiss];

   return output[0][axiss];

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

int MAG_READ(char axis)

{

        int t;

        int Data;

        char dontCare;              // For a reading we don't care about

        if (MessungFertig == 0)

        {

                PORTD &= ~(1<<PB3);                     //SS auf low

                PORTD |= (1<<PB8);                      //Reset auf high

                for(t=0;t<5;t++);                       //5 Zyklen warten

                PORTD &= ~(1<<PB8);                     //Reset auf low

                dontCare = (int)spiTransferByte(0x40+axis);     // Achse + Mess. Kommando /512

                PORTD |= (1<<PB3);                      //SS auf high

                MessungFertig = 1;

        }

        if (bit_is_set(PIND,PINB4) && MessungFertig == 1) // Warten bis Messung fertig

        {

                PORTD &= ~(1<<PB3);                     //SS auf low

                Data=spiTransferWord(0x00);

                PORTD |= (1<<PB3);                      //SS auf high

                MessungFertig = 0;

                return (Data);

        }

        else return -32000;

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

int MAG_READ_CAL(char axis)

{

        int t;

        int Data=0;

        char dontCare;              // For a reading we don't care about

        PORTD &= ~(1<<PB3);                     //SS auf low

        PORTD |= (1<<PB8);                      //Reset auf high

        for(t=0;t<5;t++);                       //5 Zyklen warten

        PORTD &= ~(1<<PB8);                     //Reset auf low

        dontCare = (int)spiTransferByte(0x40+axis);     // Achse + Mess. Kommando /512

        PORTD |= (1<<PB3);                      //SS auf high

        while(!bit_is_set(PIND,PINB4)) // Warten bis Messung fertig

        PORTD &= ~(1<<PB3);                     //SS auf low

        Data=spiTransferWord(0x00);

        PORTD |= (1<<PB5);                      //SS auf high

        return (Data);

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

void ReadEepromKompassValues(void)

{

        eeprom_read_block(&CalParaKompass, &EEPromArray[4], sizeof(CALPARAKOMPASS));

        Xoffset = CalParaKompass.Xoffsetm;

        Yoffset = CalParaKompass.Yoffsetm;

        Zoffset = CalParaKompass.Zoffsetm;

        iXsf = CalParaKompass.iXsfm;

        iYsf = CalParaKompass.iYsfm;

        iZsf = CalParaKompass.iZsfm;

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

void KalibrierKompass(void)

{

        // The numbers here will be 16-bit signed values.

        // Positive = 0x0000 to 0x7FFF

        // Negative = 0x8000 to 0xFFFF

        int t = 0;

        int tempx=0,tempy=0,tempz=0;

        if(Poti4 > 70 && Poti4 < 100)

        {

                LED1_OFF;

                LED2_OFF;

                EEPROMWrite = 0;

/*

                Xmax = -32768;

                Ymax = -32768; // start with lowest possible value

                Zmax = -32768;

                Xmin = 32767;

                Ymin = 32767; // start with highest possible value

                Zmin = 32767;

*/

        }

        if(Poti4 > 70)  // wenn Schalter ausgeschaltet, dann werden die LED ausgeschaltet und das GPS Steuerkommando gelöscht // (199797Kö)

        {

                if(Poti4 > 100 && Poti4 < 150)  // X-Y Achse Kalibrieren

                {

                        LED1_ON;

                        Xraw=MAG_READ_CAL(1);  //Kompass x-Achse auslesen

                        Xraw = -Xraw;

                        if(((Xraw > (XrawOld + 200)) || (Xraw < (XrawOld - 200)))) Xraw = XrawOld; //Filter gegen Spikes

                        tempx = Xraw;

                        Xraw = compassFilter(0,tempx);

                        XrawOld = Xraw;

                        Yraw=MAG_READ_CAL(2);  //Kompass y-Achse auslesen

                        Yraw =-Yraw;

                        if(((Yraw > (YrawOld + 200)) || (Yraw < (YrawOld - 200)))) Yraw = YrawOld; //Filter gegen Spikes

                        tempy = Yraw;

                        Yraw = compassFilter(1,tempy);

                        YrawOld = Yraw;

                        if( Xraw > Xmax ) Xmax = Xraw;

                        if( Xraw < Xmin ) Xmin = Xraw;

                        if( Yraw > Ymax ) Ymax = Yraw;

                        if( Yraw < Ymin ) Ymin = Yraw;

                        Xoffset = ( abs(Xmax) - abs(Xmin) ) / 2; // calculate offsets

                        Yoffset = ( abs(Ymax) - abs(Ymin) ) / 2;

                        iXsf = ( abs(Xmax) + abs(Xmin)) / 2; // calculate the range

                        iYsf = ( abs(Ymax) + abs(Ymin)) / 2;

                        XrawCal = (double)(Xraw - Xoffset)/(double)iXsf;

                        YrawCal = (double)(Yraw - Yoffset) /(double)iYsf;

                }

                if(Poti4 > 150)

                {

                        LED1_OFF;

                        LED2_ON;

                        Zraw=MAG_READ_CAL(3);  //Kompass Z-Achse auslesen

                        Zraw = -Zraw;

                        if(((Zraw > (ZrawOld + 200)) || (Zraw < (ZrawOld - 200)))) Zraw = ZrawOld; //Filter gegen Spikes

                        tempz = Zraw;

                        Zraw = compassFilter(2,tempz);

                        ZrawOld = Zraw;

                        if( Zraw > Zmax ) Zmax = Zraw;

                        if( Zraw < Zmin ) Zmin = Zraw;

                        Zoffset = ( abs(Zmax) - abs(Zmin) ) / 2;

                        iZsf = ( abs(Zmax) + abs(Zmin)) / 2;

                        ZrawCal = (double)(Zraw- Zoffset) / (double)iZsf;

                }

        }

        if(Poti4 > 170)

        {

                if (EEPROMWrite == 0)

                {

                        LED2_ON;

                        LED1_ON;

                        CalParaKompass.Xoffsetm = Xoffset;

                        CalParaKompass.Yoffsetm = Yoffset;

                        CalParaKompass.Zoffsetm = Zoffset;

                        CalParaKompass.iXsfm = iXsf;

                        CalParaKompass.iYsfm = iYsf;

                        CalParaKompass.iZsfm = iZsf;

                        eeprom_write_block(&CalParaKompass, &EEPromArray[4], sizeof(CALPARAKOMPASS));

                        Xmax = -32768;

                        Ymax = -32768; // start with lowest possible value

                        Zmax = -32768;

                        Xmin = 32767;

                        Ymin = 32767; // start with highest possible value

                        Zmin = 32767;

                        EEPROMWrite = 1;

                }

        }

}

//------------------------------------------------------------------------------

// Name:

// Function:

//

// Parameter:

// Return:

//------------------------------------------------------------------------------

int KompassRead(void)

{

/*

Declination = 1,209° changing by 0,118 °/year

Inclination = 64,779° changing by 0,004 °/year

X component = 20.529,42 changing by 10,87 nT/year

Y component = 433,23 changing by 42,54 nT/year

Z component = 43.596,06 changing by 32,61 nT/year

Horizontal Intensity = 20.533,99 changing by 11,8 nT/year

Total Intensity = 48.189,85 changing by 34,53 nT/year

*/

/*

Messung Real Nick

14              10

30              20

40              30

52              40

61              50

30              20 roll

39              28

19              12

50              35

*/

        double  azimuthrad = 0;

        double magnet = 68 /180 * M_PI;

        //Look-Up Tabelle für Korrekturfaktoren

        //float winkelkorr[5]={0.5,0.6,0.65,0.65,0.7};

        int lookup_nick =0,lookup_roll=0;

        int tempx=0,tempy=0,tempz=0;

        nickgrad = -(IntegralNick / 1430); //Teiler ermittelt durch Test bestätigung durch Holger

        rollgrad = -(IntegralRoll / 1430); //Teiler ermittelt durch Test bestätigung durch Holger

/*      if(nickgrad > 45) nickgradkomp = 45;

        else nickgradkomp = nickgrad;

        if(nickgrad < -45) nickgradkomp = -45;

        else nickgradkomp = nickgrad;

        if(rollgrad > 45) rollgradkomp = 45;

        else rollgradkomp = rollgrad;

        if(rollgrad < -45) rollgradkomp = -45;

        else rollgradkomp = rollgrad;

        if(abs(nickgrad) > 5 && abs(nickgrad) <= 15) lookup_nick = 0;

        if(abs(nickgrad) > 15 && abs(nickgrad) <= 25) lookup_nick = 1;

        if(abs(nickgrad) > 25 && abs(nickgrad) <= 35) lookup_nick = 2;

        if(abs(nickgrad) > 35 && abs(nickgrad) <= 45) lookup_nick = 3;

        if(abs(nickgrad) > 45) lookup_nick = 4;

        if(abs(rollgrad) > 5 && abs(rollgrad) <= 15) lookup_roll = 0;

        if(abs(rollgrad) > 15 && abs(rollgrad) <= 25) lookup_roll = 1;

        if(abs(rollgrad) > 25 && abs(rollgrad) <= 35) lookup_roll = 2;

        if(abs(rollgrad) > 35 && abs(rollgrad) <= 45) lookup_roll = 3;

        if(abs(rollgrad) > 45) lookup_roll = 4;

*/

        nick = (float)nickgrad/180 * M_PI;// * (float)winkelkorr[lookup_nick]*(float);

        roll = (float)rollgrad/180 * M_PI;// * (float)winkelkorr[lookup_roll]*(float);

        if(Poti4 > 70)  // wenn Schalter ausgeschaltet, dann werden die LED ausgeschaltet und das GPS Steuerkommando gelöscht // (199797Kö)

        {

                KalibrierKompass();

        }

        else

        {

                switch(KompassInUse)

                {

                case 0:

                        Xraw=MAG_READ(1);  //Kompass x-Achse auslesen

                        Xraw = -Xraw;

                        if (Xraw == 32000) Xraw = XrawOld;

                        else

                        {

                                //if(((Xraw > (XrawOld + 200)) || (Xraw < (XrawOld - 200)))) Xraw = XrawOld; //Filter gegen Spikes

                                XrawOld = Xraw;

                                tempx = Xraw;

                                Xraw = compassFilter(0, tempx);

                                NewX = 1;

                                KompassInUse = 1;

                        }

                        break;

                case 1:

                        Yraw=MAG_READ(2);  //Kompass y-Achse auslesen

                        Yraw = -Yraw;

                        if (Yraw == 32000) Yraw = YrawOld;

                        else

                        {

                                //if(((Yraw > (YrawOld + 200)) || (Yraw < (YrawOld - 200)))) Yraw = YrawOld; //Filter gegen Spikes

                                YrawOld = Yraw;

                                tempy = Yraw;

                                Yraw = compassFilter(1, tempy);

                                NewY = 1;

                                KompassInUse = 2;

                        }

                        break;

                case 2:

                        Zraw=MAG_READ(3);  //Kompass z-Achse auslesen

                        Zraw = -Zraw;

                        if (Zraw == 32000) Zraw = ZrawOld;

                        else

                        {

                                //if(((Zraw > (ZrawOld + 200)) || (Zraw < (ZrawOld - 200)))) Zraw = ZrawOld; //Filter gegen Spikes

                                ZrawOld = Zraw;

                                tempz = Zraw;

                                Zraw = compassFilter(2, tempz);

                                NewZ = 1;

                                KompassInUse = 0;

                        }

                        break;

                }

        /*      Xoffset =-44;

                Yoffset =-36;

                Zoffset =35;

                iXsf =242;

                iYsf =256;

                iZsf =265;

*/

                if(NewX == 1 && NewY == 1 && NewZ == 1)

                {

                        // Kalibrierung

                        XrawCal = (double)(Xraw - Xoffset)/ (double)iXsf;

                        YrawCal = (double)(Yraw - Yoffset) / (double)iYsf;

                        ZrawCal = (double)(Zraw- Zoffset) / (double)iZsf;

                        // 1.2 Grad Missweisung durch Geographischer und Magnetischer Nordpol

                        //MagnetG = (int)sqrt((long)(XrawCal * XrawCal) + (long)(YrawCal * YrawCal) + (long)(ZrawCal * ZrawCal));

                        //Kompensationsroutine

                        XEx = XrawCal * (double)cos(nick);

                        XEy = YrawCal * (double)sin(nick) * (double)sin(roll);

                        XEz = ZrawCal * (double)sin(nick) * (double)cos(roll);

                        YEy = YrawCal * (double)cos(roll);

                        YEz = ZrawCal * (double)sin(roll);

                        XE = XEx + XEy - XEz;

                        YE = YEy +  YEz;

                        if(XE==0 && YE <0) azimuthgrad = 90;

                        if(XE==0 && YE >0) azimuthgrad = 270;

                        if(XE < 0) azimuthgrad = 180-(atan(YE/XE)*180/M_PI);

                        if(XE > 0 && YE < 0) azimuthgrad = -(atan(YE/XE)*180/M_PI);

                        if(XE > 0 && YE > 0) azimuthgrad = 360 - (atan(YE/XE)*180/M_PI);

                        azimuthold = azimuthgrad;

                        NewX = 0;

                        NewY = 0;

                        NewZ = 0;

                        return azimuthgrad;

                }

                else return azimuthold;

        }

}