WebSVN - NaviCtrl - Diff - Rev 328 and 329


/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + FOR NON COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
// + bzgl. der Nutzungsbedingungen aufzunehmen.
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
// + Verkauf von Luftbildaufnahmen, usw.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
// + eindeutig als Ursprung verlinkt werden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
// + this list of conditions and the following disclaimer.
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
// +     from this software without specific prior written permission.
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
// +     for non-commercial use (directly or indirectly)
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
// +     with our written permission
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
// +     clearly linked as origin
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
//
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// +  POSSIBILITY OF SUCH DAMAGE.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
#include <string.h>
#include "91x_lib.h"
#include "led.h"
#include "gps.h"
#include "uart1.h"
#include "spi_slave.h"
#include "compass.h"
#include "timer1.h"
#include "timer2.h"
#include "config.h"
#include "main.h"
#include "compass.h"
#include "params.h"
 
#define SPI_RXSYNCBYTE1 0xAA
#define SPI_RXSYNCBYTE2 0x83
#define SPI_TXSYNCBYTE1 0x81
#define SPI_TXSYNCBYTE2 0x55
 
//communication packets
FromFlightCtrl_t   FromFlightCtrl;
ToFlightCtrl_t     ToFlightCtrl;
#define SPI0_TIMEOUT 500 // 500ms
volatile u32 SPI0_Timeout = 0;
 
// tx packet buffer
#define SPI_TXBUFFER_LEN (2 + sizeof(ToFlightCtrl)) // 2 bytes at start are for synchronization
volatile u8 SPI_TxBuffer[SPI_TXBUFFER_LEN];
volatile u8 SPI_TxBufferIndex = 0;
u8 *Ptr_TxChksum = NULL ;  // pointer to checksum in TxBuffer
 
// rx packet buffer
#define SPI_RXBUFFER_LEN sizeof(FromFlightCtrl)
volatile u8 SPI_RxBuffer[SPI_RXBUFFER_LEN];
volatile u8 SPI_RxBufferIndex = 0;
volatile u8 SPI_RxBuffer_Request = 0;
#define SPI_COMMAND_INDEX 0
 
s32 Kalman_K = 32;
s32 Kalman_MaxDrift = 5 * 16;
s32 Kalman_MaxFusion = 64;
s32 ToFcGpsZ = 0;
 
u8 SPI_CommandSequence[] = { SPI_NCCMD_VERSION, SPI_NCCMD_KALMAN, SPI_NCCMD_GPSINFO ,SPI_NCCMD_KALMAN, SPI_NCCMD_HOTT_INFO, SPI_NCCMD_KALMAN};
u8 SPI_CommandCounter = 0;
s32 ToFC_Rotate_C = 64, ToFC_Rotate_S = 0;
s32 HeadFreeStartAngle = 0;
s16 FC_WP_EventChannel = 0; // gibt einen Schaltkanal an die FC weiter, wenn der Wegpunkt erreicht wurde
u32 ToFC_AltitudeRate = 0;
s32 ToFC_AltitudeSetpoint = 0;
u8  FromFC_VarioCharacter = ' ';
u8 DisableFC_Sticks = 0;
u8 NC_GPS_ModeCharacter = ' ';
u8 FCCalibActive = 0;
 
SPI_Version_t FC_Version;
 
//--------------------------------------------------------------
void SSP0_IRQHandler(void)
{
        static u8 rxchksum = 0;
        u8 rxdata;
 
        #define SPI_SYNC1       0
        #define SPI_SYNC2       1
        #define SPI_DATA        2
        static u8 SPI_State = SPI_SYNC1;
 
        IENABLE;
 
        // clear pending bits
        SSP_ClearITPendingBit(SSP0, SSP_IT_RxTimeOut);
        SSP_ClearITPendingBit(SSP0, SSP_IT_RxFifo);
 
        // while RxFIFO not empty
        while (SSP_GetFlagStatus(SSP0, SSP_FLAG_RxFifoNotEmpty) == SET)
        {
                rxdata =  SSP0->DR; // catch the received byte
                // Fill TxFIFO while its not full or end of packet is reached
                while (SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoNotFull) == SET)
                {
                        if (SPI_TxBufferIndex  < SPI_TXBUFFER_LEN)   // still data to send ?
                        {
                                SSP0->DR = SPI_TxBuffer[SPI_TxBufferIndex];       // send a byte
                                *Ptr_TxChksum += SPI_TxBuffer[SPI_TxBufferIndex]; // update checksum
                                SPI_TxBufferIndex++; // pointer to next byte
                        }
                        else // end of packet is reached reset and copy data to tx buffer
                        {
                                SPI_TxBufferIndex = 0;  // reset buffer index
                                ToFlightCtrl.Chksum = 0;  // initialize checksum
                                ToFlightCtrl.BeepTime = BeepTime;  // set beeptime
                                BeepTime = 0; // reset local beeptime
                                // copy contents of ToFlightCtrl->SPI_TxBuffer
                                memcpy((u8 *) &(SPI_TxBuffer[2]), (u8 *) &ToFlightCtrl, sizeof(ToFlightCtrl));
                        }
                }
                switch (SPI_State)
                {
                        case SPI_SYNC1:
                                SPI_RxBufferIndex = 0; // reset buffer index
                                rxchksum = rxdata;     // init checksum
                                if (rxdata == SPI_RXSYNCBYTE1)
                                {   // 1st syncbyte ok
                                        SPI_State = SPI_SYNC2;  // step to sync2
                                }
                                break;
                        case SPI_SYNC2:
                                if (rxdata == SPI_RXSYNCBYTE2)
                                {  // 2nd Syncbyte ok
                                        rxchksum += rxdata;
                                        SPI_State = SPI_DATA;
                                }  // 2nd Syncbyte does not match
                                else
                                {
                                        SPI_State  = SPI_SYNC1; //jump back to sync1
                                }
                                break;
                        case SPI_DATA:
                                SPI_RxBuffer[SPI_RxBufferIndex++]= rxdata; // copy databyte to rx buffer
                                if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) // end of packet is reached
                                {
                                        if (rxdata == rxchksum) // verify checksum byte
                                        {
                                                // copy SPI_RxBuffer -> FromFlightCtrl
                                                if(!SPI_RxBuffer_Request) // block writing to FromFlightCtrl on reading access
                                                {
                                                        memcpy((u8 *) &FromFlightCtrl, (u8 *) SPI_RxBuffer, sizeof(FromFlightCtrl));
                                                        SPI_RxBuffer_Request = 1;
                                                }
                                                // reset timeout counter on good packet
                                                SPI0_Timeout = SetDelay(SPI0_TIMEOUT);
                                                DebugOut.Analog[13]++;
                                        }
                                        else // bad checksum byte
                                        {
                                                DebugOut.Analog[12]++; // increase SPI chksum error counter
                                        }
                                        SPI_State  = SPI_SYNC1; // reset state
                                }
                                else // end of packet not reached
                                {
                                        rxchksum += rxdata;      // update checksum
                                }
                                break;
                        default:
                                SPI_State  = SPI_SYNC1;
                                break;
                }
        }
 
        IDISABLE;
}
 
//--------------------------------------------------------------
void SPI0_Init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        SSP_InitTypeDef   SSP_InitStructure;
 
        UART1_PutString("\r\n SPI init...");
 
        SCU_APBPeriphClockConfig(__GPIO2 ,ENABLE);
        SCU_APBPeriphClockConfig(__SSP0 ,ENABLE);
 
        GPIO_DeInit(GPIO2);
        //SSP0_CLK, SSP0_MOSI, SSP0_NSS pins
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
        GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
        GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; //SSP0_SCLK, SSP0_MOSI, SSP0_NSS
        GPIO_Init (GPIO2, &GPIO_InitStructure);
 
        // SSP0_MISO pin GPIO2.6
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
        GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
        GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
        GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //SSP0_MISO
        GPIO_Init (GPIO2, &GPIO_InitStructure);
 
        SSP_DeInit(SSP0);
        SSP_StructInit(&SSP_InitStructure);
        SSP_InitStructure.SSP_FrameFormat = SSP_FrameFormat_Motorola;
        SSP_InitStructure.SSP_Mode = SSP_Mode_Slave;
        SSP_InitStructure.SSP_SlaveOutput = SSP_SlaveOutput_Enable;
        SSP_InitStructure.SSP_CPHA = SSP_CPHA_1Edge;
        SSP_InitStructure.SSP_CPOL = SSP_CPOL_Low;
        SSP_InitStructure.SSP_ClockRate = 0;
 
        SSP_Init(SSP0, &SSP_InitStructure);
        SSP_ITConfig(SSP0, SSP_IT_RxFifo | SSP_IT_RxTimeOut, ENABLE);
 
        SSP_Cmd(SSP0, ENABLE);
        // initialize the syncbytes in the tx buffer
        SPI_TxBuffer[0] = SPI_TXSYNCBYTE1;
        SPI_TxBuffer[1] = SPI_TXSYNCBYTE2;
        // set the pointer to the checksum byte in the tx buffer
        Ptr_TxChksum = (u8 *) &(((ToFlightCtrl_t *) &(SPI_TxBuffer[2]))->Chksum);
 
        ToFlightCtrl.GPSStick.Nick = 0;
        ToFlightCtrl.GPSStick.Roll = 0;
        ToFlightCtrl.GPSStick.Yaw = 0;
 
        VIC_Config(SSP0_ITLine, VIC_IRQ, PRIORITY_SPI0);
        VIC_ITCmd(SSP0_ITLine, ENABLE);
 
        SPI0_Timeout = SetDelay(4*SPI0_TIMEOUT);
 
        UART1_PutString("ok");
}
 
 
//------------------------------------------------------
void SPI0_UpdateBuffer(void)
{
        static u32 timeout = 0;
        static u8 counter = 50,hott_index = 0;
        static u8 CompassCalState = 0;
 
        s16 tmp;
        s32 i1,i2;
 
        if (SPI_RxBuffer_Request)
        {
                // avoid sending data via SPI during the update of the  ToFlightCtrl structure
                VIC_ITCmd(SSP0_ITLine, DISABLE); // disable SPI interrupt
                ToFlightCtrl.CompassHeading = Compass_Heading;
                DebugOut.Analog[10] = ToFlightCtrl.CompassHeading;
                if(ToFlightCtrl.CompassHeading >= 0) ToFlightCtrl.CompassHeading = (360 + ToFlightCtrl.CompassHeading + FromFlightCtrl.GyroYaw / 12) % 360;
//              ToFlightCtrl.MagVecX = MagVector.X;
//              ToFlightCtrl.MagVecY = MagVector.Y;
                ToFlightCtrl.MagVecZ = MagVector.Z;
                ToFlightCtrl.NCStatus = 0;
                // cycle spi commands
                ToFlightCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
                // restart command cycle at the end
                if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
#define FLAG_GPS_AID 0x01
                switch (ToFlightCtrl.Command)
                {
                        case  SPI_NCCMD_KALMAN:  // wird am häufigsten betätigt
                                CalcHeadFree();
                                ToFlightCtrl.Param.sByte[0] = (s8) Kalman_K;
                                ToFlightCtrl.Param.sByte[1] = (s8) Kalman_MaxFusion;
                                ToFlightCtrl.Param.sByte[2] = (s8) Kalman_MaxDrift;
                                ToFlightCtrl.Param.Byte[3]      = (u8) SerialLinkOkay;
                                ToFlightCtrl.Param.sByte[4] = (s8) ToFcGpsZ;
                                ToFlightCtrl.Param.Byte[5] = (s8) ToFC_Rotate_C;
                                ToFlightCtrl.Param.Byte[6] = (s8) ToFC_Rotate_S;
                if(DisableFC_Sticks) ToFlightCtrl.Param.Byte[7] = FLAG_GPS_AID; else ToFlightCtrl.Param.Byte[7] = 0x00;
                                if(CAM_Orientation.UpdateMask & CAM_UPDATE_AZIMUTH)
                                {
                                        ToFlightCtrl.Param.sInt[4] = CAM_Orientation.Azimuth;
                                        CAM_Orientation.UpdateMask &= ~CAM_UPDATE_AZIMUTH;
                                }
                                else
                                {
                                        ToFlightCtrl.Param.sInt[4] = -1;
                                }
 
                                if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_NEW_CAMERA_ELEVATION, &tmp))  // Elevation set via 'j' command
                                {
                                        ToFlightCtrl.Param.sInt[5] = tmp;
                                }
                                else
                                {
                                        if(FC.StatusFlags2 & FC_STATUS2_CAREFREE) ToFlightCtrl.Param.sInt[5] = CAM_Orientation.Elevation; // only, if carefree is active
                                        else ToFlightCtrl.Param.sInt[5] = 0;
                                }
                                break;
 
                        case SPI_NCCMD_VERSION:
                                ToFlightCtrl.Param.Byte[0] = VERSION_MAJOR;
                                ToFlightCtrl.Param.Byte[1] = VERSION_MINOR;
                                ToFlightCtrl.Param.Byte[2] = VERSION_PATCH;
                                ToFlightCtrl.Param.Byte[3] = FC_SPI_COMPATIBLE;
                                ToFlightCtrl.Param.Byte[4] = Version_HW;
                                ToFlightCtrl.Param.Byte[5] = DebugOut.Status[0];
                                ToFlightCtrl.Param.Byte[6] = DebugOut.Status[1];
                                ToFlightCtrl.Param.Byte[7] = ErrorCode;
                                ToFlightCtrl.Param.Byte[8] = NC_GPS_ModeCharacter;
                                break;
 
                        case SPI_NCCMD_GPSINFO:
                                ToFlightCtrl.Param.Byte[0] = GPSData.Flags;
                                ToFlightCtrl.Param.Byte[1] = GPSData.NumOfSats;
                                ToFlightCtrl.Param.Byte[2] = GPSData.SatFix;
                                ToFlightCtrl.Param.Byte[3] = GPSData.Speed_Ground / 100; // m/s
                                ToFlightCtrl.Param.Int[2]  = NaviData.HomePositionDeviation.Distance; // dm   //4&5
                                ToFlightCtrl.Param.sInt[3] = NaviData.HomePositionDeviation.Bearing;  // deg  //6&7
                                if(FC_WP_EventChannel > 254) FC_WP_EventChannel = 254;
                                ToFlightCtrl.Param.Byte[8] = (s8)(FC_WP_EventChannel - 127);
                                if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_RATE, &tmp))
                                {
                                        ToFlightCtrl.Param.Byte[9] = (u8)tmp;
                                }
                                else
                                {
                                        ToFlightCtrl.Param.Byte[9] = (u8)ToFC_AltitudeRate;
                                }
                                if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_SETPOINT, &tmp))
                                {
                                        ToFlightCtrl.Param.sInt[5] = tmp;
                                }
                                else
                                {
                                        ToFlightCtrl.Param.sInt[5] = (s16)ToFC_AltitudeSetpoint;
                                }
//                              DebugOut.Analog[25] = (s16)ToFlightCtrl.Param.Byte[9];
//                              DebugOut.Analog[20] = ToFlightCtrl.Param.sInt[5];
                                break;
                        case SPI_NCCMD_HOTT_INFO:
                                switch(hott_index++)
                                {
/*
typedef struct
{
  unsigned char StartByte;  //0         // 0x7C
  unsigned char Packet_ID;  //1         // 0x89  - Vario ID
  unsigned char WarnBeep;   //2         // Anzahl der Töne 0..36
  unsigned char Heading;        //3     // 1 = 2°
  unsigned int Speed;           //4+5   // in km/h
  unsigned char Lat_North;      //6    
  unsigned char Lat_G;      //7
  unsigned char Lat_M;      //8
  unsigned char Lat_Sek1;       //9    
  unsigned char Lat_Sek2;       //10    
  unsigned char Lon_East;       //11    
  unsigned char Lon_G;      //12
  unsigned char Lon_M;      //13
  unsigned char Lon_Sek1;       //14    
  unsigned char Lon_Sek2;       //15    
  unsigned int Distance;        //16+17    // 9000 = 0m
  unsigned int Altitude;        //18+19    // 500 = 0m
  unsigned int m_sec;           //20+21    // 3000 = 0
  unsigned int m_3sec;          //22+23    // 3000 = 0
  unsigned int m_10sec;         //24+25    // 3000 = 0
  unsigned char NullByte;       // 0x00
  unsigned char NullByte1;      // 0x00
  unsigned char EndByte;                // 0x7D
} GPSPacket_t;
*/
                                case 0:
                                        //Dezimalgrad            --> Grad mit Dezimalminuten     --> Grad, Minuten, Sekunden
                                        //53.285788 7.4847269    --> N53° 17.14728 E7° 29.08362  --> N53° 17' 8.837" E7° 29' 5.017" 
                                        ToFlightCtrl.Param.Byte[11] = HOTT_GPS_PACKET_ID;
                                        ToFlightCtrl.Param.Byte[0] = 3; // index
                                        ToFlightCtrl.Param.Byte[1] = 9-1;       // how many
                                        //-----------------------------
                                        ToFlightCtrl.Param.Byte[2] = NaviData.HomePositionDeviation.Bearing / 2;
                                        i1 = GPSData.Speed_Ground; // in cm/sec
                                        i1 *= 36;
                                        i1 /= 1000;
                                        ToFlightCtrl.Param.Byte[3] = i1 % 256;
                                        ToFlightCtrl.Param.Byte[4] = i1 / 256;
                                        //-----------------------------
                                        if(GPSData.Position.Latitude < 0) ToFlightCtrl.Param.Byte[2]  = 1; // 1 = S
                                        else ToFlightCtrl.Param.Byte[5]  = 0; // 1 = S
                                        i1 = abs(GPSData.Position.Latitude)/10000000L;
                                        i2 = abs(GPSData.Position.Latitude)%10000000L;
                                        i1 *= 100;
                                        i1 += i2 / 100000;
                                        i2  = i2 % 100000;
                                        i2 /= 10;
                                        ToFlightCtrl.Param.Byte[6]  = i1 % 256;
                                        ToFlightCtrl.Param.Byte[7]  = i1 / 256;
                                        ToFlightCtrl.Param.Byte[8]  = i2 % 256;
                                        ToFlightCtrl.Param.Byte[9]  = i2 / 256;
 
                                        break;
                                case 1:
                                        ToFlightCtrl.Param.Byte[11] = HOTT_GPS_PACKET_ID;
                                        ToFlightCtrl.Param.Byte[0] = 11;        // index
                                        ToFlightCtrl.Param.Byte[1] = 8-1;       // how many
                                        //-----------------------------
                                        if(GPSData.Position.Longitude < 0) ToFlightCtrl.Param.Byte[2]  = 1; // 1 = E
                                        else ToFlightCtrl.Param.Byte[2]  = 0; // 1 = S
                                        i1 = abs(GPSData.Position.Longitude)/10000000L;
                                        i2 = abs(GPSData.Position.Longitude)%10000000L;
                                        i1 *= 100;
                                        i1 += i2 / 100000;
                                        i2  = i2 % 100000;
                                        i2 /= 10;
                                        ToFlightCtrl.Param.Byte[3]  = i1 % 256;
                                        ToFlightCtrl.Param.Byte[4]  = i1 / 256;
                                        ToFlightCtrl.Param.Byte[5]  = i2 % 256;
                                        ToFlightCtrl.Param.Byte[6]  = i2 / 256;
                                        //-----------------------------
                                        i1 = NaviData.HomePositionDeviation.Distance / 10; // dann in m 
                                        ToFlightCtrl.Param.Byte[7]  = i1 % 256;
                                        ToFlightCtrl.Param.Byte[8]  = i1 / 256;
                                        hott_index = 0;
                                        break;
                                   default:
                                                ToFlightCtrl.Param.Byte[0] = 255;
                                                hott_index = 0;
                                                break;
                                }
                                break;
                        default:
                                break;
// 0 = 0,1
// 1 = 2,3
// 2 = 4,5
// 3 = 6,7
// 4 = 8,9
// 5 = 10,11
                }
                VIC_ITCmd(SSP0_ITLine, ENABLE);         // enable SPI interrupt
 
 
                switch(FromFlightCtrl.Command)
                {
                        case SPI_FCCMD_USER:
                                Parameter.User1 = FromFlightCtrl.Param.Byte[0];
                                Parameter.User2 = FromFlightCtrl.Param.Byte[1];
                                Parameter.User3 = FromFlightCtrl.Param.Byte[2];
                                Parameter.User4 = FromFlightCtrl.Param.Byte[3];
                                Parameter.User5 = FromFlightCtrl.Param.Byte[4];
                                Parameter.User6 = FromFlightCtrl.Param.Byte[5];
                                Parameter.User7 = FromFlightCtrl.Param.Byte[6];
                                Parameter.User8 = FromFlightCtrl.Param.Byte[7];
                                if(ClearFCStatusFlags)
                                {
                                        FC.StatusFlags = 0;
                                        ClearFCStatusFlags = 0;
                                }
                                FC.StatusFlags |= FromFlightCtrl.Param.Byte[8];
                                if(FC.StatusFlags & FC_STATUS_CALIBRATE && !FCCalibActive)
                                {
                                        HeadFreeStartAngle = Compass_Heading * 10;
                                        Compass_Init();
                                        FCCalibActive = 1;
                                }
                                else
                                {
                                        FCCalibActive = 0;
                                }
                                if(FC.StatusFlags & FC_STATUS_START)
                             {
                                   if(Compass_Heading != -1) HeadFreeStartAngle = Compass_Heading * 10; else
                                   HeadFreeStartAngle = FromFlightCtrl.GyroHeading;
                                 }
 
                                 if((Parameter.ExtraConfig & CFG_TEACHABLE_CAREFREE))
                                  {
                                   if(!(FC.StatusFlags2 & FC_STATUS2_CAREFREE)) // CF ist jetzt ausgeschaltet -> neue Richtung lernen
                                    {
                                         if((NaviData.HomePositionDeviation.Distance > 200) && (NCFlags & NC_FLAG_GPS_OK))       // nur bei ausreichender Distance -> 20m
                                         {
                                          HeadFreeStartAngle = (10 * NaviData.HomePositionDeviation.Bearing + 1800 + 3600 -  Parameter.OrientationAngle * 150) % 3600; // in 0.1°
                                         }
                                         else                                                                                            // Ansonsten die aktuelle Richtung übernehmen
                                          HeadFreeStartAngle = (3600 + FromFlightCtrl.GyroHeading /*+ Parameter.OrientationAngle * 150*/) % 3600; // in 0.1°      
                                        }
                                }
 
//DebugOut.Analog[16] = HeadFreeStartAngle;
 
                                Parameter.ActiveSetting = FromFlightCtrl.Param.Byte[9];
                                DebugOut.Analog[5] = FC.StatusFlags;
                                FC.StatusFlags2 = FromFlightCtrl.Param.Byte[11];
                                NaviData.FCStatusFlags = FC.StatusFlags;
                                NaviData.FCStatusFlags2 = FC.StatusFlags2;
                                Parameter.ComingHomeAltitude = FromFlightCtrl.Param.Byte[10];
                                break;
 
                        case SPI_FCCMD_ACCU:
                                FC.BAT_Current = FromFlightCtrl.Param.Int[0];
                                FC.BAT_UsedCapacity = FromFlightCtrl.Param.Int[1];
                                FC.BAT_Voltage = FromFlightCtrl.Param.Byte[4];
                                Parameter.LowVoltageWarning = FromFlightCtrl.Param.Byte[5];
                                FromFC_VarioCharacter = FromFlightCtrl.Param.Byte[6];
                                Parameter.GlobalConfig = FromFlightCtrl.Param.Byte[7];
                                Parameter.ExtraConfig = FromFlightCtrl.Param.Byte[8];
                                if(FromFC_VarioCharacter == '+' || FromFC_VarioCharacter == '-') // manual setpoint clears the NC-Parameter command
                                 {
                                  NCParams_ClearValue(NCPARAMS_ALTITUDE_RATE);
                                 }
                                NaviData.UBat = FC.BAT_Voltage;
                                NaviData.Current = FC.BAT_Current;
                                NaviData.UsedCapacity = FC.BAT_UsedCapacity;
                                break;
 
#define CHK_POTI(b,a) { if(a < 248) b = a; else b = FC.Poti[255 - a]; }
#define CHK_POTI_MM(b,a,min,max) {CHK_POTI(b,a); LIMIT_MIN_MAX(b, min, max); }
 
                        case SPI_FCCMD_PARAMETER1:
                                CHK_POTI_MM(Parameter.NaviGpsModeControl,FromFlightCtrl.Param.Byte[0],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsGain,FromFlightCtrl.Param.Byte[1],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsP,FromFlightCtrl.Param.Byte[2],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsI,FromFlightCtrl.Param.Byte[3],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsD,FromFlightCtrl.Param.Byte[4],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsACC,FromFlightCtrl.Param.Byte[5],0,255);
                                Parameter.NaviGpsMinSat = FromFlightCtrl.Param.Byte[6];
                                Parameter.NaviStickThreshold = FromFlightCtrl.Param.Byte[7];
                                CHK_POTI_MM(Parameter.NaviOperatingRadius,FromFlightCtrl.Param.Byte[8],0,255);
                                CHK_POTI_MM(Parameter.NaviWindCorrection,FromFlightCtrl.Param.Byte[9],0,255);
                                CHK_POTI_MM(Parameter.NaviAccCompensation,FromFlightCtrl.Param.Byte[10],0,255);
                                CHK_POTI_MM(Parameter.NaviAngleLimitation,FromFlightCtrl.Param.Byte[11],0,255);
                                break;
 
                        case SPI_FCCMD_STICK:
                                FC.StickGas     = FromFlightCtrl.Param.sByte[0];
                                FC.StickYaw     = FromFlightCtrl.Param.sByte[1];
                                FC.StickRoll    = FromFlightCtrl.Param.sByte[2];
                                FC.StickNick    = FromFlightCtrl.Param.sByte[3];
                                FC.Poti[0]              = FromFlightCtrl.Param.Byte[4];
                                FC.Poti[1]              = FromFlightCtrl.Param.Byte[5];
                                FC.Poti[2]              = FromFlightCtrl.Param.Byte[6];
                                FC.Poti[3]              = FromFlightCtrl.Param.Byte[7];
                                FC.Poti[4]              = FromFlightCtrl.Param.Byte[8];
                                FC.Poti[5]              = FromFlightCtrl.Param.Byte[9];
                                FC.Poti[6]              = FromFlightCtrl.Param.Byte[10];
                                FC.Poti[7]              = FromFlightCtrl.Param.Byte[11];
                                break;
 
                        case SPI_FCCMD_MISC:
                                if(CompassCalState != FromFlightCtrl.Param.Byte[0])
                                {       // put only new CompassCalState into queue to send via I2C
                                        CompassCalState = FromFlightCtrl.Param.Byte[0];
                                        Compass_SetCalState(CompassCalState);
                                }
                                Parameter.NaviPH_LoginTime = FromFlightCtrl.Param.Byte[1];
                                NaviData.Variometer = (NaviData.Variometer + 2 * (FromFlightCtrl.Param.sInt[1] - NaviData.Altimeter)) / 2; // provisorisch
                                NaviData.Altimeter = FromFlightCtrl.Param.sInt[1]; // in 5cm
                                NaviData.SetpointAltitude = FromFlightCtrl.Param.sInt[2]; // in 5cm
                                CHK_POTI_MM(Parameter.NaviGpsPLimit,FromFlightCtrl.Param.Byte[6],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsILimit,FromFlightCtrl.Param.Byte[7],0,255);
                                CHK_POTI_MM(Parameter.NaviGpsDLimit,FromFlightCtrl.Param.Byte[8],0,255);
                                FC.RC_Quality   = FromFlightCtrl.Param.Byte[9];
                                FC.RC_RSSI              = FromFlightCtrl.Param.Byte[10];
                                if(!FC.RC_RSSI) NaviData.RC_Quality = FC.RC_Quality; else NaviData.RC_Quality = FC.RC_RSSI;
//                              NaviData.RC_RSSI = FC.RC_RSSI;
                                NaviData.Gas    = (FC.BAT_Voltage * (u32) FromFlightCtrl.Param.Byte[11]) / (u32) Parameter.LowVoltageWarning;
                                break;
 
                        case SPI_FCCMD_SERVOS:
                                ServoParams.Refresh             = FromFlightCtrl.Param.Byte[0];
                                ServoParams.CompInvert  = FromFlightCtrl.Param.Byte[1];
                                ServoParams.NickControl = FromFlightCtrl.Param.Byte[2];
                                ServoParams.NickComp    = FromFlightCtrl.Param.Byte[3];
                                ServoParams.NickMin             = FromFlightCtrl.Param.Byte[4];
                                ServoParams.NickMax             = FromFlightCtrl.Param.Byte[5];
                                ServoParams.RollControl = FromFlightCtrl.Param.Byte[6];
                                ServoParams.RollComp    = FromFlightCtrl.Param.Byte[7];
                                ServoParams.RollMin             = FromFlightCtrl.Param.Byte[8];
                                ServoParams.RollMax             = FromFlightCtrl.Param.Byte[9];
                                break;
 
                        case SPI_FCCMD_VERSION:
                                FC_Version.Major                = FromFlightCtrl.Param.Byte[0];
                                FC_Version.Minor                = FromFlightCtrl.Param.Byte[1];
                                FC_Version.Patch                = FromFlightCtrl.Param.Byte[2];
                                FC_Version.Compatible   = FromFlightCtrl.Param.Byte[3];
                                FC_Version.Hardware             = FromFlightCtrl.Param.Byte[4];
                                FC.Error[0]                     |= FromFlightCtrl.Param.Byte[5];
                                FC.Error[1]                     |= FromFlightCtrl.Param.Byte[6];
                                FC.Error[2]                     |= FromFlightCtrl.Param.Byte[7];
                                FC.Error[3]                     |= FromFlightCtrl.Param.Byte[8];
                                FC.Error[4]                     |= FromFlightCtrl.Param.Byte[9];
                                Parameter.OrientationAngle = FromFlightCtrl.Param.Byte[10];
                                DebugOut.Status[0] |= 0x01; // status of FC Present
                                DebugOut.Status[0] |= 0x02; // status of BL Present
                                if(FC.Error[0] || FC.Error[1] || FC.Error[2] || FC.Error[3] || FC.Error[4]) DebugOut.Status[1] |= 0x01;
                                else DebugOut.Status[1] &= ~0x01;
                                break;
                        default:
                                break;
                }
 
                // every time we got new data from the FC via SPI call the navigation routine
                // and update GPSStick that are returned to FC
                GPS_Navigation(&GPSData, &(ToFlightCtrl.GPSStick));
                ClearFCStatusFlags = 1;
 
                if(counter)
                {
                        counter--;                                       // count down to enable servo
                        if(!counter) TIMER2_Init();  // enable Servo Output
                }
 
                SPI_RxBuffer_Request = 0;
                timeout = SetDelay(80); // 80 ms, new data are send every 20 ms
 
                DebugOut.Analog[0] = FromFlightCtrl.AngleNick;
                DebugOut.Analog[1] = FromFlightCtrl.AngleRoll;
                DebugOut.Analog[2] = FromFlightCtrl.AccNick;
                DebugOut.Analog[3] = FromFlightCtrl.AccRoll;
                DebugOut.Analog[11] = FromFlightCtrl.GyroHeading/10;// in deg
                Data3D.AngleNick = FromFlightCtrl.AngleNick;            // in 0.1 deg
                Data3D.AngleRoll = FromFlightCtrl.AngleRoll;            // in 0.1 deg
                Data3D.Heading   = FromFlightCtrl.GyroHeading;          // in 0.1 deg
        }       // EOF if(SPI_RxBuffer_Request)
        else // no new SPI data
        {
                if(CheckDelay(timeout) && (counter == 0))
                {
                        TIMER2_Deinit();  // disable Servo Output
                        counter = 50;     // reset counter for enabling Servo Output
                }
        }
}
 
//------------------------------------------------------
void SPI0_GetFlightCtrlVersion(void)
{
        u32 timeout;
        u8 repeat;
        u8 msg[64];
 
        UART1_PutString("\r\n Looking for FlightControl");
        FC_Version.Major = 0xFF;
        FC_Version.Minor = 0xFF;
        FC_Version.Patch = 0xFF;
        FC_Version.Compatible = 0xFF;
 
        // polling FC version info
        repeat = 0;
        do
        {
                timeout = SetDelay(250);
                do
                {
                        SPI0_UpdateBuffer();
                        if (FC_Version.Major != 0xFF)  break;
                }while (!CheckDelay(timeout));
                UART1_PutString(".");
                repeat++;
                FCCalibActive = 1;
        }while((FC_Version.Major == 0xFF) && (repeat < 40)); // 40*250ms = 10s
        // if we got it
        if (FC_Version.Major != 0xFF)
        {
                sprintf(msg, " FC V%d.%d%c HW:%d.%d", FC_Version.Major, FC_Version.Minor, 'a'+FC_Version.Patch, FC_Version.Hardware/10,FC_Version.Hardware%10);
                UART1_PutString(msg);
        }
        else UART1_PutString("\n\r not found!");
}
 
 
 

Rev 328	Rev 329
1	/#######################################################################################/	1	/#######################################################################################/
2	/* !!! THIS IS NOT FREE SOFTWARE !!! */	2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
3	/#######################################################################################/	3	/#######################################################################################/
4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5	// + Copyright (c) 2008 Ingo Busker, Holger Buss	5	// + Copyright (c) 2008 Ingo Busker, Holger Buss
6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY	6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
7	// + FOR NON COMMERCIAL USE ONLY	7	// + FOR NON COMMERCIAL USE ONLY
8	// + www.MikroKopter.com	8	// + www.MikroKopter.com
9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),	10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.	11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt	12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
13	// + bzgl. der Nutzungsbedingungen aufzunehmen.	13	// + bzgl. der Nutzungsbedingungen aufzunehmen.
14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,	14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
15	// + Verkauf von Luftbildaufnahmen, usw.	15	// + Verkauf von Luftbildaufnahmen, usw.
16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,	17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen	18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts	20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"	21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
22	// + eindeutig als Ursprung verlinkt werden	22	// + eindeutig als Ursprung verlinkt werden
23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion	24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
25	// + Benutzung auf eigene Gefahr	25	// + Benutzung auf eigene Gefahr
26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden	26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur	28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
29	// + mit unserer Zustimmung zulässig	29	// + mit unserer Zustimmung zulässig
30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen	31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,	33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
34	// + this list of conditions and the following disclaimer.	34	// + this list of conditions and the following disclaimer.
35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived	35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36	// + from this software without specific prior written permission.	36	// + from this software without specific prior written permission.
37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted	37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
38	// + for non-commercial use (directly or indirectly)	38	// + for non-commercial use (directly or indirectly)
39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted	39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40	// + with our written permission	40	// + with our written permission
41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be	41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
42	// + clearly linked as origin	42	// + clearly linked as origin
43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed	43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
44	//	44	//
45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55	// + POSSIBILITY OF SUCH DAMAGE.	55	// + POSSIBILITY OF SUCH DAMAGE.
56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57		57
58	#include <string.h>	58	#include <string.h>
59	#include "91x_lib.h"	59	#include "91x_lib.h"
60	#include "led.h"	60	#include "led.h"
61	#include "gps.h"	61	#include "gps.h"
62	#include "uart1.h"	62	#include "uart1.h"
63	#include "spi_slave.h"	63	#include "spi_slave.h"
64	#include "compass.h"	64	#include "compass.h"
65	#include "timer1.h"	65	#include "timer1.h"
66	#include "timer2.h"	66	#include "timer2.h"
67	#include "config.h"	67	#include "config.h"
68	#include "main.h"	68	#include "main.h"
69	#include "compass.h"	69	#include "compass.h"
70	#include "params.h"	70	#include "params.h"
71		71
72	#define SPI_RXSYNCBYTE1 0xAA	72	#define SPI_RXSYNCBYTE1 0xAA
73	#define SPI_RXSYNCBYTE2 0x83	73	#define SPI_RXSYNCBYTE2 0x83
74	#define SPI_TXSYNCBYTE1 0x81	74	#define SPI_TXSYNCBYTE1 0x81
75	#define SPI_TXSYNCBYTE2 0x55	75	#define SPI_TXSYNCBYTE2 0x55
76		76
77	//communication packets	77	//communication packets
78	FromFlightCtrl_t FromFlightCtrl;	78	FromFlightCtrl_t FromFlightCtrl;
79	ToFlightCtrl_t ToFlightCtrl;	79	ToFlightCtrl_t ToFlightCtrl;
80	#define SPI0_TIMEOUT 500 // 500ms	80	#define SPI0_TIMEOUT 500 // 500ms
81	volatile u32 SPI0_Timeout = 0;	81	volatile u32 SPI0_Timeout = 0;
82		82
83	// tx packet buffer	83	// tx packet buffer
84	#define SPI_TXBUFFER_LEN (2 + sizeof(ToFlightCtrl)) // 2 bytes at start are for synchronization	84	#define SPI_TXBUFFER_LEN (2 + sizeof(ToFlightCtrl)) // 2 bytes at start are for synchronization
85	volatile u8 SPI_TxBuffer[SPI_TXBUFFER_LEN];	85	volatile u8 SPI_TxBuffer[SPI_TXBUFFER_LEN];
86	volatile u8 SPI_TxBufferIndex = 0;	86	volatile u8 SPI_TxBufferIndex = 0;
87	u8 *Ptr_TxChksum = NULL ; // pointer to checksum in TxBuffer	87	u8 *Ptr_TxChksum = NULL ; // pointer to checksum in TxBuffer
88		88
89	// rx packet buffer	89	// rx packet buffer
90	#define SPI_RXBUFFER_LEN sizeof(FromFlightCtrl)	90	#define SPI_RXBUFFER_LEN sizeof(FromFlightCtrl)
91	volatile u8 SPI_RxBuffer[SPI_RXBUFFER_LEN];	91	volatile u8 SPI_RxBuffer[SPI_RXBUFFER_LEN];
92	volatile u8 SPI_RxBufferIndex = 0;	92	volatile u8 SPI_RxBufferIndex = 0;
93	volatile u8 SPI_RxBuffer_Request = 0;	93	volatile u8 SPI_RxBuffer_Request = 0;
94	#define SPI_COMMAND_INDEX 0	94	#define SPI_COMMAND_INDEX 0
95		95
96	s32 Kalman_K = 32;	96	s32 Kalman_K = 32;
97	s32 Kalman_MaxDrift = 5 * 16;	97	s32 Kalman_MaxDrift = 5 * 16;
98	s32 Kalman_MaxFusion = 64;	98	s32 Kalman_MaxFusion = 64;
99	s32 ToFcGpsZ = 0;	99	s32 ToFcGpsZ = 0;
100		100
101	u8 SPI_CommandSequence[] = { SPI_NCCMD_VERSION, SPI_NCCMD_KALMAN, SPI_NCCMD_GPSINFO ,SPI_NCCMD_KALMAN, SPI_NCCMD_KALMAN};	101	u8 SPI_CommandSequence[] = { SPI_NCCMD_VERSION, SPI_NCCMD_KALMAN, SPI_NCCMD_GPSINFO ,SPI_NCCMD_KALMAN, SPI_NCCMD_HOTT_INFO, SPI_NCCMD_KALMAN};
102	u8 SPI_CommandCounter = 0;	102	u8 SPI_CommandCounter = 0;
103	s32 ToFC_Rotate_C = 64, ToFC_Rotate_S = 0;	103	s32 ToFC_Rotate_C = 64, ToFC_Rotate_S = 0;
104	s32 HeadFreeStartAngle = 0;	104	s32 HeadFreeStartAngle = 0;
105	s16 FC_WP_EventChannel = 0; // gibt einen Schaltkanal an die FC weiter, wenn der Wegpunkt erreicht wurde	105	s16 FC_WP_EventChannel = 0; // gibt einen Schaltkanal an die FC weiter, wenn der Wegpunkt erreicht wurde
106	u32 ToFC_AltitudeRate = 0;	106	u32 ToFC_AltitudeRate = 0;
107	s32 ToFC_AltitudeSetpoint = 0;	107	s32 ToFC_AltitudeSetpoint = 0;
108	u8 FromFC_VarioCharacter = ' ';	108	u8 FromFC_VarioCharacter = ' ';
109	u8 DisableFC_Sticks = 0;	109	u8 DisableFC_Sticks = 0;
110	u8 NC_GPS_ModeCharacter = ' ';	110	u8 NC_GPS_ModeCharacter = ' ';
-		111	u8 FCCalibActive = 0;
111		112
112	SPI_Version_t FC_Version;	113	SPI_Version_t FC_Version;
113		114
114	//--------------------------------------------------------------	115	//--------------------------------------------------------------
115	void SSP0_IRQHandler(void)	116	void SSP0_IRQHandler(void)
116	{	117	{
117	static u8 rxchksum = 0;	118	static u8 rxchksum = 0;
118	u8 rxdata;	119	u8 rxdata;
119		120
120	#define SPI_SYNC1 0	121	#define SPI_SYNC1 0
121	#define SPI_SYNC2 1	122	#define SPI_SYNC2 1
122	#define SPI_DATA 2	123	#define SPI_DATA 2
123	static u8 SPI_State = SPI_SYNC1;	124	static u8 SPI_State = SPI_SYNC1;
124		125
125	IENABLE;	126	IENABLE;
126		127
127	// clear pending bits	128	// clear pending bits
128	SSP_ClearITPendingBit(SSP0, SSP_IT_RxTimeOut);	129	SSP_ClearITPendingBit(SSP0, SSP_IT_RxTimeOut);
129	SSP_ClearITPendingBit(SSP0, SSP_IT_RxFifo);	130	SSP_ClearITPendingBit(SSP0, SSP_IT_RxFifo);
130		131
131	// while RxFIFO not empty	132	// while RxFIFO not empty
132	while (SSP_GetFlagStatus(SSP0, SSP_FLAG_RxFifoNotEmpty) == SET)	133	while (SSP_GetFlagStatus(SSP0, SSP_FLAG_RxFifoNotEmpty) == SET)
133	{	134	{
134	rxdata = SSP0->DR; // catch the received byte	135	rxdata = SSP0->DR; // catch the received byte
135	// Fill TxFIFO while its not full or end of packet is reached	136	// Fill TxFIFO while its not full or end of packet is reached
136	while (SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoNotFull) == SET)	137	while (SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoNotFull) == SET)
137	{	138	{
138	if (SPI_TxBufferIndex < SPI_TXBUFFER_LEN) // still data to send ?	139	if (SPI_TxBufferIndex < SPI_TXBUFFER_LEN) // still data to send ?
139	{	140	{
140	SSP0->DR = SPI_TxBuffer[SPI_TxBufferIndex]; // send a byte	141	SSP0->DR = SPI_TxBuffer[SPI_TxBufferIndex]; // send a byte
141	*Ptr_TxChksum += SPI_TxBuffer[SPI_TxBufferIndex]; // update checksum	142	*Ptr_TxChksum += SPI_TxBuffer[SPI_TxBufferIndex]; // update checksum
142	SPI_TxBufferIndex++; // pointer to next byte	143	SPI_TxBufferIndex++; // pointer to next byte
143	}	144	}
144	else // end of packet is reached reset and copy data to tx buffer	145	else // end of packet is reached reset and copy data to tx buffer
145	{	146	{
146	SPI_TxBufferIndex = 0; // reset buffer index	147	SPI_TxBufferIndex = 0; // reset buffer index
147	ToFlightCtrl.Chksum = 0; // initialize checksum	148	ToFlightCtrl.Chksum = 0; // initialize checksum
148	ToFlightCtrl.BeepTime = BeepTime; // set beeptime	149	ToFlightCtrl.BeepTime = BeepTime; // set beeptime
149	BeepTime = 0; // reset local beeptime	150	BeepTime = 0; // reset local beeptime
150	// copy contents of ToFlightCtrl->SPI_TxBuffer	151	// copy contents of ToFlightCtrl->SPI_TxBuffer
151	memcpy((u8 ) &(SPI_TxBuffer[2]), (u8 ) &ToFlightCtrl, sizeof(ToFlightCtrl));	152	memcpy((u8 ) &(SPI_TxBuffer[2]), (u8 ) &ToFlightCtrl, sizeof(ToFlightCtrl));
152	}	153	}
153	}	154	}
154	switch (SPI_State)	155	switch (SPI_State)
155	{	156	{
156	case SPI_SYNC1:	157	case SPI_SYNC1:
157	SPI_RxBufferIndex = 0; // reset buffer index	158	SPI_RxBufferIndex = 0; // reset buffer index
158	rxchksum = rxdata; // init checksum	159	rxchksum = rxdata; // init checksum
159	if (rxdata == SPI_RXSYNCBYTE1)	160	if (rxdata == SPI_RXSYNCBYTE1)
160	{ // 1st syncbyte ok	161	{ // 1st syncbyte ok
161	SPI_State = SPI_SYNC2; // step to sync2	162	SPI_State = SPI_SYNC2; // step to sync2
162	}	163	}
163	break;	164	break;
164	case SPI_SYNC2:	165	case SPI_SYNC2:
165	if (rxdata == SPI_RXSYNCBYTE2)	166	if (rxdata == SPI_RXSYNCBYTE2)
166	{ // 2nd Syncbyte ok	167	{ // 2nd Syncbyte ok
167	rxchksum += rxdata;	168	rxchksum += rxdata;
168	SPI_State = SPI_DATA;	169	SPI_State = SPI_DATA;
169	} // 2nd Syncbyte does not match	170	} // 2nd Syncbyte does not match
170	else	171	else
171	{	172	{
172	SPI_State = SPI_SYNC1; //jump back to sync1	173	SPI_State = SPI_SYNC1; //jump back to sync1
173	}	174	}
174	break;	175	break;
175	case SPI_DATA:	176	case SPI_DATA:
176	SPI_RxBuffer[SPI_RxBufferIndex++]= rxdata; // copy databyte to rx buffer	177	SPI_RxBuffer[SPI_RxBufferIndex++]= rxdata; // copy databyte to rx buffer
177	if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) // end of packet is reached	178	if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) // end of packet is reached
178	{	179	{
179	if (rxdata == rxchksum) // verify checksum byte	180	if (rxdata == rxchksum) // verify checksum byte
180	{	181	{
181	// copy SPI_RxBuffer -> FromFlightCtrl	182	// copy SPI_RxBuffer -> FromFlightCtrl
182	if(!SPI_RxBuffer_Request) // block writing to FromFlightCtrl on reading access	183	if(!SPI_RxBuffer_Request) // block writing to FromFlightCtrl on reading access
183	{	184	{
184	memcpy((u8 ) &FromFlightCtrl, (u8 ) SPI_RxBuffer, sizeof(FromFlightCtrl));	185	memcpy((u8 ) &FromFlightCtrl, (u8 ) SPI_RxBuffer, sizeof(FromFlightCtrl));
185	SPI_RxBuffer_Request = 1;	186	SPI_RxBuffer_Request = 1;
186	}	187	}
187	// reset timeout counter on good packet	188	// reset timeout counter on good packet
188	SPI0_Timeout = SetDelay(SPI0_TIMEOUT);	189	SPI0_Timeout = SetDelay(SPI0_TIMEOUT);
189	DebugOut.Analog[13]++;	190	DebugOut.Analog[13]++;
190	}	191	}
191	else // bad checksum byte	192	else // bad checksum byte
192	{	193	{
193	DebugOut.Analog[12]++; // increase SPI chksum error counter	194	DebugOut.Analog[12]++; // increase SPI chksum error counter
194	}	195	}
195	SPI_State = SPI_SYNC1; // reset state	196	SPI_State = SPI_SYNC1; // reset state
196	}	197	}
197	else // end of packet not reached	198	else // end of packet not reached
198	{	199	{
199	rxchksum += rxdata; // update checksum	200	rxchksum += rxdata; // update checksum
200	}	201	}
201	break;	202	break;
202	default:	203	default:
203	SPI_State = SPI_SYNC1;	204	SPI_State = SPI_SYNC1;
204	break;	205	break;
205	}	206	}
206	}	207	}
207		208
208	IDISABLE;	209	IDISABLE;
209	}	210	}
210		211
211	//--------------------------------------------------------------	212	//--------------------------------------------------------------
212	void SPI0_Init(void)	213	void SPI0_Init(void)
213	{	214	{
214	GPIO_InitTypeDef GPIO_InitStructure;	215	GPIO_InitTypeDef GPIO_InitStructure;
215	SSP_InitTypeDef SSP_InitStructure;	216	SSP_InitTypeDef SSP_InitStructure;
216		217
217	UART1_PutString("\r\n SPI init...");	218	UART1_PutString("\r\n SPI init...");
218		219
219	SCU_APBPeriphClockConfig(__GPIO2 ,ENABLE);	220	SCU_APBPeriphClockConfig(__GPIO2 ,ENABLE);
220	SCU_APBPeriphClockConfig(__SSP0 ,ENABLE);	221	SCU_APBPeriphClockConfig(__SSP0 ,ENABLE);
221		222
222	GPIO_DeInit(GPIO2);	223	GPIO_DeInit(GPIO2);
223	//SSP0_CLK, SSP0_MOSI, SSP0_NSS pins	224	//SSP0_CLK, SSP0_MOSI, SSP0_NSS pins
224	GPIO_StructInit(&GPIO_InitStructure);	225	GPIO_StructInit(&GPIO_InitStructure);
225	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;	226	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
226	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 \| GPIO_Pin_5 \| GPIO_Pin_7;	227	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 \| GPIO_Pin_5 \| GPIO_Pin_7;
227	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;	228	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
228	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	229	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
229	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; //SSP0_SCLK, SSP0_MOSI, SSP0_NSS	230	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; //SSP0_SCLK, SSP0_MOSI, SSP0_NSS
230	GPIO_Init (GPIO2, &GPIO_InitStructure);	231	GPIO_Init (GPIO2, &GPIO_InitStructure);
231		232
232	// SSP0_MISO pin GPIO2.6	233	// SSP0_MISO pin GPIO2.6
233	GPIO_StructInit(&GPIO_InitStructure);	234	GPIO_StructInit(&GPIO_InitStructure);
234	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	235	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
235	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;	236	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
236	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;	237	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
237	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	238	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
238	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //SSP0_MISO	239	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; //SSP0_MISO
239	GPIO_Init (GPIO2, &GPIO_InitStructure);	240	GPIO_Init (GPIO2, &GPIO_InitStructure);
240		241
241	SSP_DeInit(SSP0);	242	SSP_DeInit(SSP0);
242	SSP_StructInit(&SSP_InitStructure);	243	SSP_StructInit(&SSP_InitStructure);
243	SSP_InitStructure.SSP_FrameFormat = SSP_FrameFormat_Motorola;	244	SSP_InitStructure.SSP_FrameFormat = SSP_FrameFormat_Motorola;
244	SSP_InitStructure.SSP_Mode = SSP_Mode_Slave;	245	SSP_InitStructure.SSP_Mode = SSP_Mode_Slave;
245	SSP_InitStructure.SSP_SlaveOutput = SSP_SlaveOutput_Enable;	246	SSP_InitStructure.SSP_SlaveOutput = SSP_SlaveOutput_Enable;
246	SSP_InitStructure.SSP_CPHA = SSP_CPHA_1Edge;	247	SSP_InitStructure.SSP_CPHA = SSP_CPHA_1Edge;
247	SSP_InitStructure.SSP_CPOL = SSP_CPOL_Low;	248	SSP_InitStructure.SSP_CPOL = SSP_CPOL_Low;
248	SSP_InitStructure.SSP_ClockRate = 0;	249	SSP_InitStructure.SSP_ClockRate = 0;
249		250
250	SSP_Init(SSP0, &SSP_InitStructure);	251	SSP_Init(SSP0, &SSP_InitStructure);
251	SSP_ITConfig(SSP0, SSP_IT_RxFifo \| SSP_IT_RxTimeOut, ENABLE);	252	SSP_ITConfig(SSP0, SSP_IT_RxFifo \| SSP_IT_RxTimeOut, ENABLE);
252		253
253	SSP_Cmd(SSP0, ENABLE);	254	SSP_Cmd(SSP0, ENABLE);
254	// initialize the syncbytes in the tx buffer	255	// initialize the syncbytes in the tx buffer
255	SPI_TxBuffer[0] = SPI_TXSYNCBYTE1;	256	SPI_TxBuffer[0] = SPI_TXSYNCBYTE1;
256	SPI_TxBuffer[1] = SPI_TXSYNCBYTE2;	257	SPI_TxBuffer[1] = SPI_TXSYNCBYTE2;
257	// set the pointer to the checksum byte in the tx buffer	258	// set the pointer to the checksum byte in the tx buffer
258	Ptr_TxChksum = (u8 ) &(((ToFlightCtrl_t ) &(SPI_TxBuffer[2]))->Chksum);	259	Ptr_TxChksum = (u8 ) &(((ToFlightCtrl_t ) &(SPI_TxBuffer[2]))->Chksum);
259		260
260	ToFlightCtrl.GPSStick.Nick = 0;	261	ToFlightCtrl.GPSStick.Nick = 0;
261	ToFlightCtrl.GPSStick.Roll = 0;	262	ToFlightCtrl.GPSStick.Roll = 0;
262	ToFlightCtrl.GPSStick.Yaw = 0;	263	ToFlightCtrl.GPSStick.Yaw = 0;
263		264
264	VIC_Config(SSP0_ITLine, VIC_IRQ, PRIORITY_SPI0);	265	VIC_Config(SSP0_ITLine, VIC_IRQ, PRIORITY_SPI0);
265	VIC_ITCmd(SSP0_ITLine, ENABLE);	266	VIC_ITCmd(SSP0_ITLine, ENABLE);
266		267
267	SPI0_Timeout = SetDelay(4*SPI0_TIMEOUT);	268	SPI0_Timeout = SetDelay(4*SPI0_TIMEOUT);
268		269
269	UART1_PutString("ok");	270	UART1_PutString("ok");
270	}	271	}
271		272
272		273
273	//------------------------------------------------------	274	//------------------------------------------------------
274	void SPI0_UpdateBuffer(void)	275	void SPI0_UpdateBuffer(void)
275	{	276	{
276	static u32 timeout = 0;	277	static u32 timeout = 0;
277	static u8 counter = 50;	278	static u8 counter = 50,hott_index = 0;
278	static u8 CompassCalState = 0;	279	static u8 CompassCalState = 0;
279	static u8 FCCalibActive = 0;	-
280	s16 tmp;	280	s16 tmp;
-		281	s32 i1,i2;
281		282
282	if (SPI_RxBuffer_Request)	283	if (SPI_RxBuffer_Request)
283	{	284	{
284	// avoid sending data via SPI during the update of the ToFlightCtrl structure	285	// avoid sending data via SPI during the update of the ToFlightCtrl structure
285	VIC_ITCmd(SSP0_ITLine, DISABLE); // disable SPI interrupt	286	VIC_ITCmd(SSP0_ITLine, DISABLE); // disable SPI interrupt
286	ToFlightCtrl.CompassHeading = Compass_Heading;	287	ToFlightCtrl.CompassHeading = Compass_Heading;
287	DebugOut.Analog[10] = ToFlightCtrl.CompassHeading;	288	DebugOut.Analog[10] = ToFlightCtrl.CompassHeading;
288	if(ToFlightCtrl.CompassHeading >= 0) ToFlightCtrl.CompassHeading = (360 + ToFlightCtrl.CompassHeading + FromFlightCtrl.GyroYaw / 12) % 360;	289	if(ToFlightCtrl.CompassHeading >= 0) ToFlightCtrl.CompassHeading = (360 + ToFlightCtrl.CompassHeading + FromFlightCtrl.GyroYaw / 12) % 360;
289	// ToFlightCtrl.MagVecX = MagVector.X;	290	// ToFlightCtrl.MagVecX = MagVector.X;
290	// ToFlightCtrl.MagVecY = MagVector.Y;	291	// ToFlightCtrl.MagVecY = MagVector.Y;
291	ToFlightCtrl.MagVecZ = MagVector.Z;	292	ToFlightCtrl.MagVecZ = MagVector.Z;
292	ToFlightCtrl.NCStatus = 0;	293	ToFlightCtrl.NCStatus = 0;
293	// cycle spi commands	294	// cycle spi commands
294	ToFlightCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];	295	ToFlightCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
295	// restart command cycle at the end	296	// restart command cycle at the end
296	if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;	297	if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
297	#define FLAG_GPS_AID 0x01	298	#define FLAG_GPS_AID 0x01
298	switch (ToFlightCtrl.Command)	299	switch (ToFlightCtrl.Command)
299	{	300	{
300	case SPI_NCCMD_KALMAN:	301	case SPI_NCCMD_KALMAN: // wird am häufigsten betätigt
301	CalcHeadFree();	302	CalcHeadFree();
302	ToFlightCtrl.Param.sByte[0] = (s8) Kalman_K;	303	ToFlightCtrl.Param.sByte[0] = (s8) Kalman_K;
303	ToFlightCtrl.Param.sByte[1] = (s8) Kalman_MaxFusion;	304	ToFlightCtrl.Param.sByte[1] = (s8) Kalman_MaxFusion;
304	ToFlightCtrl.Param.sByte[2] = (s8) Kalman_MaxDrift;	305	ToFlightCtrl.Param.sByte[2] = (s8) Kalman_MaxDrift;
305	ToFlightCtrl.Param.Byte[3] = (u8) SerialLinkOkay;	306	ToFlightCtrl.Param.Byte[3] = (u8) SerialLinkOkay;
306	ToFlightCtrl.Param.sByte[4] = (s8) ToFcGpsZ;	307	ToFlightCtrl.Param.sByte[4] = (s8) ToFcGpsZ;
307	ToFlightCtrl.Param.Byte[5] = (s8) ToFC_Rotate_C;	308	ToFlightCtrl.Param.Byte[5] = (s8) ToFC_Rotate_C;
308	ToFlightCtrl.Param.Byte[6] = (s8) ToFC_Rotate_S;	309	ToFlightCtrl.Param.Byte[6] = (s8) ToFC_Rotate_S;
309	if(DisableFC_Sticks) ToFlightCtrl.Param.Byte[7] = FLAG_GPS_AID; else ToFlightCtrl.Param.Byte[7] = 0x00;	310	if(DisableFC_Sticks) ToFlightCtrl.Param.Byte[7] = FLAG_GPS_AID; else ToFlightCtrl.Param.Byte[7] = 0x00;
310	if(CAM_Orientation.UpdateMask & CAM_UPDATE_AZIMUTH)	311	if(CAM_Orientation.UpdateMask & CAM_UPDATE_AZIMUTH)
311	{	312	{
312	ToFlightCtrl.Param.sInt[4] = CAM_Orientation.Azimuth;	313	ToFlightCtrl.Param.sInt[4] = CAM_Orientation.Azimuth;
313	CAM_Orientation.UpdateMask &= ~CAM_UPDATE_AZIMUTH;	314	CAM_Orientation.UpdateMask &= ~CAM_UPDATE_AZIMUTH;
314	}	315	}
315	else	316	else
316	{	317	{
317	ToFlightCtrl.Param.sInt[4] = -1;	318	ToFlightCtrl.Param.sInt[4] = -1;
318	}	319	}
319		320
320	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_NEW_CAMERA_ELEVATION, &tmp)) // Elevation set via 'j' command	321	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_NEW_CAMERA_ELEVATION, &tmp)) // Elevation set via 'j' command
321	{	322	{
322	ToFlightCtrl.Param.sInt[5] = tmp;	323	ToFlightCtrl.Param.sInt[5] = tmp;
323	}	324	}
324	else	325	else
325	{	326	{
326	if(FC.StatusFlags2 & FC_STATUS2_CAREFREE) ToFlightCtrl.Param.sInt[5] = CAM_Orientation.Elevation; // only, if carefree is active	327	if(FC.StatusFlags2 & FC_STATUS2_CAREFREE) ToFlightCtrl.Param.sInt[5] = CAM_Orientation.Elevation; // only, if carefree is active
327	else ToFlightCtrl.Param.sInt[5] = 0;	328	else ToFlightCtrl.Param.sInt[5] = 0;
328	}	329	}
329	break;	330	break;
330		331
331	case SPI_NCCMD_VERSION:	332	case SPI_NCCMD_VERSION:
332	ToFlightCtrl.Param.Byte[0] = VERSION_MAJOR;	333	ToFlightCtrl.Param.Byte[0] = VERSION_MAJOR;
333	ToFlightCtrl.Param.Byte[1] = VERSION_MINOR;	334	ToFlightCtrl.Param.Byte[1] = VERSION_MINOR;
334	ToFlightCtrl.Param.Byte[2] = VERSION_PATCH;	335	ToFlightCtrl.Param.Byte[2] = VERSION_PATCH;
335	ToFlightCtrl.Param.Byte[3] = FC_SPI_COMPATIBLE;	336	ToFlightCtrl.Param.Byte[3] = FC_SPI_COMPATIBLE;
336	ToFlightCtrl.Param.Byte[4] = Version_HW;	337	ToFlightCtrl.Param.Byte[4] = Version_HW;
337	ToFlightCtrl.Param.Byte[5] = DebugOut.Status[0];	338	ToFlightCtrl.Param.Byte[5] = DebugOut.Status[0];
338	ToFlightCtrl.Param.Byte[6] = DebugOut.Status[1];	339	ToFlightCtrl.Param.Byte[6] = DebugOut.Status[1];
339	ToFlightCtrl.Param.Byte[7] = ErrorCode;	340	ToFlightCtrl.Param.Byte[7] = ErrorCode;
340	ToFlightCtrl.Param.Byte[8] = NC_GPS_ModeCharacter;	341	ToFlightCtrl.Param.Byte[8] = NC_GPS_ModeCharacter;
341	break;	342	break;
342		343
343	case SPI_NCCMD_GPSINFO:	344	case SPI_NCCMD_GPSINFO:
344	ToFlightCtrl.Param.Byte[0] = GPSData.Flags;	345	ToFlightCtrl.Param.Byte[0] = GPSData.Flags;
345	ToFlightCtrl.Param.Byte[1] = GPSData.NumOfSats;	346	ToFlightCtrl.Param.Byte[1] = GPSData.NumOfSats;
346	ToFlightCtrl.Param.Byte[2] = GPSData.SatFix;	347	ToFlightCtrl.Param.Byte[2] = GPSData.SatFix;
347	ToFlightCtrl.Param.Byte[3] = GPSData.Speed_Ground / 100; // m/s	348	ToFlightCtrl.Param.Byte[3] = GPSData.Speed_Ground / 100; // m/s
348	ToFlightCtrl.Param.Int[2] = NaviData.HomePositionDeviation.Distance; // dm //4&5	349	ToFlightCtrl.Param.Int[2] = NaviData.HomePositionDeviation.Distance; // dm //4&5
349	ToFlightCtrl.Param.sInt[3] = NaviData.HomePositionDeviation.Bearing; // deg //6&7	350	ToFlightCtrl.Param.sInt[3] = NaviData.HomePositionDeviation.Bearing; // deg //6&7
350	if(FC_WP_EventChannel > 254) FC_WP_EventChannel = 254;	351	if(FC_WP_EventChannel > 254) FC_WP_EventChannel = 254;
351	ToFlightCtrl.Param.Byte[8] = (s8)(FC_WP_EventChannel - 127);	352	ToFlightCtrl.Param.Byte[8] = (s8)(FC_WP_EventChannel - 127);
352	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_RATE, &tmp))	353	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_RATE, &tmp))
353	{	354	{
354	ToFlightCtrl.Param.Byte[9] = (u8)tmp;	355	ToFlightCtrl.Param.Byte[9] = (u8)tmp;
355	}	356	}
356	else	357	else
357	{	358	{
358	ToFlightCtrl.Param.Byte[9] = (u8)ToFC_AltitudeRate;	359	ToFlightCtrl.Param.Byte[9] = (u8)ToFC_AltitudeRate;
359	}	360	}
360	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_SETPOINT, &tmp))	361	if(NCRARAM_STATE_VALID == NCParams_GetValue(NCPARAMS_ALTITUDE_SETPOINT, &tmp))
361	{	362	{
362	ToFlightCtrl.Param.sInt[5] = tmp;	363	ToFlightCtrl.Param.sInt[5] = tmp;
363	}	364	}
364	else	365	else
365	{	366	{
366	ToFlightCtrl.Param.sInt[5] = (s16)ToFC_AltitudeSetpoint;	367	ToFlightCtrl.Param.sInt[5] = (s16)ToFC_AltitudeSetpoint;
367	}	368	}
368	// DebugOut.Analog[25] = (s16)ToFlightCtrl.Param.Byte[9];	369	// DebugOut.Analog[25] = (s16)ToFlightCtrl.Param.Byte[9];
369	// DebugOut.Analog[20] = ToFlightCtrl.Param.sInt[5];	370	// DebugOut.Analog[20] = ToFlightCtrl.Param.sInt[5];
370	break;	371	break;
-		372	case SPI_NCCMD_HOTT_INFO:
-		373	switch(hott_index++)
-		374	{
-		375	/*
-		376	typedef struct
-		377	{
-		378	unsigned char StartByte; //0 // 0x7C
-		379	unsigned char Packet_ID; //1 // 0x89 - Vario ID
-		380	unsigned char WarnBeep; //2 // Anzahl der Töne 0..36
-		381	unsigned char Heading; //3 // 1 = 2°
-		382	unsigned int Speed; //4+5 // in km/h
-		383	unsigned char Lat_North; //6
-		384	unsigned char Lat_G; //7
-		385	unsigned char Lat_M; //8
-		386	unsigned char Lat_Sek1; //9
-		387	unsigned char Lat_Sek2; //10
-		388	unsigned char Lon_East; //11
-		389	unsigned char Lon_G; //12
-		390	unsigned char Lon_M; //13
-		391	unsigned char Lon_Sek1; //14
-		392	unsigned char Lon_Sek2; //15
-		393	unsigned int Distance; //16+17 // 9000 = 0m
-		394	unsigned int Altitude; //18+19 // 500 = 0m
-		395	unsigned int m_sec; //20+21 // 3000 = 0
-		396	unsigned int m_3sec; //22+23 // 3000 = 0
-		397	unsigned int m_10sec; //24+25 // 3000 = 0
-		398	unsigned char NullByte; // 0x00
-		399	unsigned char NullByte1; // 0x00
-		400	unsigned char EndByte; // 0x7D
-		401	} GPSPacket_t;
-		402	*/
-		403	case 0:
-		404	//Dezimalgrad --> Grad mit Dezimalminuten --> Grad, Minuten, Sekunden
-		405	//53.285788 7.4847269 --> N53° 17.14728 E7° 29.08362 --> N53° 17' 8.837" E7° 29' 5.017"
-		406	ToFlightCtrl.Param.Byte[11] = HOTT_GPS_PACKET_ID;
-		407	ToFlightCtrl.Param.Byte[0] = 3; // index
-		408	ToFlightCtrl.Param.Byte[1] = 9-1; // how many
-		409	//-----------------------------
-		410	ToFlightCtrl.Param.Byte[2] = NaviData.HomePositionDeviation.Bearing / 2;
-		411	i1 = GPSData.Speed_Ground; // in cm/sec
-		412	i1 *= 36;
-		413	i1 /= 1000;
-		414	ToFlightCtrl.Param.Byte[3] = i1 % 256;
-		415	ToFlightCtrl.Param.Byte[4] = i1 / 256;
-		416	//-----------------------------
-		417	if(GPSData.Position.Latitude < 0) ToFlightCtrl.Param.Byte[2] = 1; // 1 = S
-		418	else ToFlightCtrl.Param.Byte[5] = 0; // 1 = S
-		419	i1 = abs(GPSData.Position.Latitude)/10000000L;
-		420	i2 = abs(GPSData.Position.Latitude)%10000000L;
-		421	i1 *= 100;
-		422	i1 += i2 / 100000;
-		423	i2 = i2 % 100000;
-		424	i2 /= 10;
-		425	ToFlightCtrl.Param.Byte[6] = i1 % 256;
-		426	ToFlightCtrl.Param.Byte[7] = i1 / 256;
-		427	ToFlightCtrl.Param.Byte[8] = i2 % 256;
-		428	ToFlightCtrl.Param.Byte[9] = i2 / 256;
371		429
-		430	break;
-		431	case 1:
-		432	ToFlightCtrl.Param.Byte[11] = HOTT_GPS_PACKET_ID;
-		433	ToFlightCtrl.Param.Byte[0] = 11; // index
-		434	ToFlightCtrl.Param.Byte[1] = 8-1; // how many
-		435	//-----------------------------
-		436	if(GPSData.Position.Longitude < 0) ToFlightCtrl.Param.Byte[2] = 1; // 1 = E
-		437	else ToFlightCtrl.Param.Byte[2] = 0; // 1 = S
-		438	i1 = abs(GPSData.Position.Longitude)/10000000L;
-		439	i2 = abs(GPSData.Position.Longitude)%10000000L;
-		440	i1 *= 100;
-		441	i1 += i2 / 100000;
-		442	i2 = i2 % 100000;
-		443	i2 /= 10;
-		444	ToFlightCtrl.Param.Byte[3] = i1 % 256;
-		445	ToFlightCtrl.Param.Byte[4] = i1 / 256;
-		446	ToFlightCtrl.Param.Byte[5] = i2 % 256;
-		447	ToFlightCtrl.Param.Byte[6] = i2 / 256;
-		448	//-----------------------------
-		449	i1 = NaviData.HomePositionDeviation.Distance / 10; // dann in m
-		450	ToFlightCtrl.Param.Byte[7] = i1 % 256;
-		451	ToFlightCtrl.Param.Byte[8] = i1 / 256;
-		452	hott_index = 0;
-		453	break;
-		454	default:
-		455	ToFlightCtrl.Param.Byte[0] = 255;
-		456	hott_index = 0;
-		457	break;
-		458	}
-		459	break;
372	default:	460	default:
373	break;	461	break;
374	// 0 = 0,1	462	// 0 = 0,1
375	// 1 = 2,3	463	// 1 = 2,3
376	// 2 = 4,5	464	// 2 = 4,5
377	// 3 = 6,7	465	// 3 = 6,7
378	// 4 = 8,9	466	// 4 = 8,9
379	// 5 = 10,11	467	// 5 = 10,11
380	}	468	}
381	VIC_ITCmd(SSP0_ITLine, ENABLE); // enable SPI interrupt	469	VIC_ITCmd(SSP0_ITLine, ENABLE); // enable SPI interrupt
382		-
383		470
384	switch(FromFlightCtrl.Command)	471	switch(FromFlightCtrl.Command)
385	{	472	{
386	case SPI_FCCMD_USER:	473	case SPI_FCCMD_USER:
387	Parameter.User1 = FromFlightCtrl.Param.Byte[0];	474	Parameter.User1 = FromFlightCtrl.Param.Byte[0];
388	Parameter.User2 = FromFlightCtrl.Param.Byte[1];	475	Parameter.User2 = FromFlightCtrl.Param.Byte[1];
389	Parameter.User3 = FromFlightCtrl.Param.Byte[2];	476	Parameter.User3 = FromFlightCtrl.Param.Byte[2];
390	Parameter.User4 = FromFlightCtrl.Param.Byte[3];	477	Parameter.User4 = FromFlightCtrl.Param.Byte[3];
391	Parameter.User5 = FromFlightCtrl.Param.Byte[4];	478	Parameter.User5 = FromFlightCtrl.Param.Byte[4];
392	Parameter.User6 = FromFlightCtrl.Param.Byte[5];	479	Parameter.User6 = FromFlightCtrl.Param.Byte[5];
393	Parameter.User7 = FromFlightCtrl.Param.Byte[6];	480	Parameter.User7 = FromFlightCtrl.Param.Byte[6];
394	Parameter.User8 = FromFlightCtrl.Param.Byte[7];	481	Parameter.User8 = FromFlightCtrl.Param.Byte[7];
395	if(ClearFCStatusFlags)	482	if(ClearFCStatusFlags)
396	{	483	{
397	FC.StatusFlags = 0;	484	FC.StatusFlags = 0;
398	ClearFCStatusFlags = 0;	485	ClearFCStatusFlags = 0;
399	}	486	}
400	FC.StatusFlags \|= FromFlightCtrl.Param.Byte[8];	487	FC.StatusFlags \|= FromFlightCtrl.Param.Byte[8];
401	if(FC.StatusFlags & FC_STATUS_CALIBRATE && !FCCalibActive)	488	if(FC.StatusFlags & FC_STATUS_CALIBRATE && !FCCalibActive)
402	{	489	{
403	HeadFreeStartAngle = Compass_Heading * 10;	490	HeadFreeStartAngle = Compass_Heading * 10;
404	Compass_Init();	491	Compass_Init();
405	FCCalibActive = 1;	492	FCCalibActive = 1;
406	}	493	}
407	else	494	else
408	{	495	{
409	FCCalibActive = 0;	496	FCCalibActive = 0;
410	}	497	}
411	if(FC.StatusFlags & FC_STATUS_START)	498	if(FC.StatusFlags & FC_STATUS_START)

Subversion Repositories NaviCtrl

(root)/tags/V2.10b/spi_slave.c @ 779 - Rev 328 → 329