WebSVN - FlightCtrl - Diff - Rev 1420 and 1448 - /branches/MartinW


// ######################## SPI - FlightCtrl ###################
#include "main.h"
 
 
//struct str_ToNaviCtrl_Version   ToNaviCtrl_Version;
//struct str_FromNaviCtrl_Version   FromNaviCtrl_Version;
struct str_ToNaviCtrl   ToNaviCtrl;
struct str_FromNaviCtrl   FromNaviCtrl;
struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
struct str_SPI_VersionInfo NC_Version;
 
unsigned char              SPI_BufferIndex;
unsigned char              SPI_RxBufferIndex;
 
volatile unsigned char     SPI_Buffer[sizeof(FromNaviCtrl)];
unsigned char *SPI_TX_Buffer;
 
unsigned char SPITransferCompleted, SPI_ChkSum;
unsigned char SPI_RxDataValid,NaviDataOkay = 0;
 
unsigned char SPI_CommandSequence[] = { SPI_FCCMD_USER, SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER1, SPI_FCCMD_STICK, SPI_FCCMD_MISC, SPI_FCCMD_VERSION, SPI_FCCMD_SERVOS };
unsigned char SPI_CommandCounter = 0;
 
#ifdef USE_SPI_COMMUNICATION
 
//------------------------------------------------------
void SPI_MasterInit(void)
{
  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input
  SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
 
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64
  SPSR = 0;//(1<<SPI2X);
 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
  SPITransferCompleted = 1;
 
  //SPDR = 0x00;  // dummy write
 
  ToNaviCtrl.Sync1 = 0xAA;
  ToNaviCtrl.Sync2 = 0x83;
 
  ToNaviCtrl.Command = SPI_FCCMD_USER;
  ToNaviCtrl.IntegralNick = 0;
  ToNaviCtrl.IntegralRoll = 0;
  FromNaviCtrl_Value.SerialDataOkay = 0;
  SPI_RxDataValid = 0;
 
 
 
 
 
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(void)
{
   //if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return;    // transfer of prev. packet not completed
   if (!SPITransferCompleted) return;
//   _delay_us(30);
 
   SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
   SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
 
   ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
   if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
 
   SPITransferCompleted = 0;
   UpdateSPI_Buffer();                              // update buffer
 
   SPI_BufferIndex = 1;
  //ebugOut.Analog[16]++;
   // -- Debug-Output ---
   //----
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
//     SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
}
 
//------------------------------------------------------
//SIGNAL(SIG_SPI)
void SPI_TransmitByte(void)
{
   static unsigned char SPI_RXState = 0;
   unsigned char rxdata;
   static unsigned char rxchksum;
 
   if (SPITransferCompleted) return;
   if (!(SPSR & (1 << SPIF))) return;
  SendSPI = 4;
 
//   _delay_us(30);
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
  rxdata = SPDR;
  switch ( SPI_RXState)
  {
  case 0:
 
                        SPI_RxBufferIndex = 0;
                        //DebugOut.Analog[17]++;
                        rxchksum = rxdata;
                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok
 
           break;
 
   case 1:
                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok
                 else SPI_RXState  = 0;
                        //DebugOut.Analog[18]++;
           break;
 
   case 2:
                   SPI_Buffer[SPI_RxBufferIndex++]= rxdata;             // get data
           //DebugOut.Analog[19]++;
           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
                   {
 
                if (rxdata == rxchksum)
                        {
                  unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
 
                          memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
 
                          SPI_RxDataValid = 1;
                        }
                        else SPI_RxDataValid = 0;
 
                        SPI_RXState  = 0;
                   }
                  else rxchksum += rxdata;
        break;
 
  }
 
   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
     {
           SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
 
           SPDR = SPI_TX_Buffer[SPI_BufferIndex];
           ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
        //   SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
         }
         else SPITransferCompleted = 1;
 
         SPI_BufferIndex++;
}
 
 
//------------------------------------------------------
void UpdateSPI_Buffer(void)
{
  signed int tmp;
  ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4));
  ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4));
  ToNaviCtrl.GyroCompass = (10 * ErsatzKompass) / GIER_GRAD_FAKTOR;
  ToNaviCtrl.AccNick = ((int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc))/4;
  ToNaviCtrl.AccRoll = ((int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc))/4;
  NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
//  ToNaviCtrl.User8 = Parameter_UserParam8;
//  ToNaviCtrl.CalState = WinkelOut.CalcState;
   switch(ToNaviCtrl.Command)  //
   {
         case SPI_FCCMD_USER:
                                ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
                                ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
                                ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
                                ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;
                                ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;
                                ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;
                                ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;
                                ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;
                                ToNaviCtrl.Param.Byte[8] = (unsigned char) FCFlags;
                FCFlags &= ~(FCFLAG_CALIBRATE | FCFLAG_START);
                    ToNaviCtrl.Param.Byte[9] = (unsigned char) UBat;
                    ToNaviCtrl.Param.Byte[10] =(unsigned char) BattLowVoltageWarning;
                    ToNaviCtrl.Param.Byte[11] =(unsigned char) eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
        break;
 
         case SPI_FCCMD_PARAMETER1:
                                ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl;     // Parameters for the Naviboard
                                ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;
                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
                                ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
                                ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
                                ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
                ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
                ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;
                ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;
                ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviSpeedCompensation;
                                ToNaviCtrl.Param.Byte[11] = EE_Parameter.NaviAngleLimitation;
            break;
 
         case SPI_FCCMD_STICK:
              cli();
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];  if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
                                ToNaviCtrl.Param.Byte[0] = (char) tmp;
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
                                ToNaviCtrl.Param.Byte[1] = (char) tmp;
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
                                ToNaviCtrl.Param.Byte[2] = (char) tmp;
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
              sei();
                                ToNaviCtrl.Param.Byte[3] = (char) tmp;
                                ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];
                                ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];
                                ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];
                    ToNaviCtrl.Param.Byte[7] = (unsigned char) Poti[3];
                                ToNaviCtrl.Param.Byte[8] = (unsigned char) Poti[4];
                                ToNaviCtrl.Param.Byte[9] = (unsigned char) Poti[5];
                                ToNaviCtrl.Param.Byte[10] = (unsigned char) Poti[6];
                                ToNaviCtrl.Param.Byte[11] = (unsigned char) Poti[7];
                        break;
                case SPI_FCCMD_MISC:
                        if(WinkelOut.CalcState > 5)
                        {
                                WinkelOut.CalcState = 0;
                                ToNaviCtrl.Param.Byte[0] = 5;
                        }
                        else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviPH_LoginTime;
                        ToNaviCtrl.Param.Int[1] = DebugOut.Analog[5];// = HoehenWert/5;
                        ToNaviCtrl.Param.Int[2] = (int)(SollHoehe/5);
                        ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsPLimit;
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit;
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit;
            ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay;
            ToNaviCtrl.Param.Byte[10] = (unsigned char) SenderRSSI;
                        ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil
                        break;
                case SPI_FCCMD_VERSION:
                        ToNaviCtrl.Param.Byte[0] = VERSION_MAJOR;
                        ToNaviCtrl.Param.Byte[1] = VERSION_MINOR;
                        ToNaviCtrl.Param.Byte[2] = VERSION_PATCH;
                        ToNaviCtrl.Param.Byte[3] = NC_SPI_COMPATIBLE;
                        ToNaviCtrl.Param.Byte[4] = PlatinenVersion;
                break;
 
            case SPI_FCCMD_SERVOS:
                ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh;     // Parameters for the Servo Control
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.ServoCompInvert;
                        ToNaviCtrl.Param.Byte[2] = Parameter_ServoNickControl;
                        ToNaviCtrl.Param.Byte[3] = EE_Parameter.ServoNickComp;
                        ToNaviCtrl.Param.Byte[4] = EE_Parameter.ServoNickMin;
                        ToNaviCtrl.Param.Byte[5] = EE_Parameter.ServoNickMax;
                        ToNaviCtrl.Param.Byte[6] = Parameter_ServoRollControl;
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.ServoRollComp;
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.ServoRollMin;
                        ToNaviCtrl.Param.Byte[9] = EE_Parameter.ServoRollMax;
                break;
        }
 
  if(SPI_RxDataValid)
  {
   if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))
   {
    GPS_Nick = FromNaviCtrl.GPS_Nick;
    GPS_Roll = FromNaviCtrl.GPS_Roll;
        NaviDataOkay = 250;
   }
    if(FromNaviCtrl.CompassValue <= 360)   KompassValue = FromNaviCtrl.CompassValue;
    KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
 
    if(FromNaviCtrl.BeepTime > beeptime && !WinkelOut.CalcState) beeptime = FromNaviCtrl.BeepTime;
 
          switch (FromNaviCtrl.Command)
          {
            case SPI_NCCMD_KALMAN:
                        FromNaviCtrl_Value.Kalman_K = FromNaviCtrl.Param.sByte[0];
                        FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.sByte[1];
                        FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.sByte[2];
                        FromNaviCtrl_Value.SerialDataOkay = FromNaviCtrl.Param.Byte[3];
                        FromNaviCtrl_Value.GpsZ = FromNaviCtrl.Param.Byte[4];
                        break;
 
                case SPI_NCCMD_VERSION:
                        NC_Version.Major = FromNaviCtrl.Param.Byte[0];
                        NC_Version.Minor = FromNaviCtrl.Param.Byte[1];
                        NC_Version.Patch = FromNaviCtrl.Param.Byte[2];
                        NC_Version.Compatible = FromNaviCtrl.Param.Byte[3];
                        NC_Version.Hardware = FromNaviCtrl.Param.Byte[4];
                        break;
                default:
                  break;
          }
  }
  else
  {
//    KompassValue = 0;
//    KompassRichtung = 0;
        GPS_Nick = 0;
    GPS_Roll = 0;
  }
}
 
#endif
 
 
 

Rev 1420	Rev 1448
1	// ######################## SPI - FlightCtrl ###################	1	// ######################## SPI - FlightCtrl ###################
2	#include "main.h"	2	#include "main.h"
3		3
4		4
5	//struct str_ToNaviCtrl_Version ToNaviCtrl_Version;	5	//struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
6	//struct str_FromNaviCtrl_Version FromNaviCtrl_Version;	6	//struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
7	struct str_ToNaviCtrl ToNaviCtrl;	7	struct str_ToNaviCtrl ToNaviCtrl;
8	struct str_FromNaviCtrl FromNaviCtrl;	8	struct str_FromNaviCtrl FromNaviCtrl;
9	struct str_FromNaviCtrl_Value FromNaviCtrl_Value;	9	struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
10	struct str_SPI_VersionInfo SPI_VersionInfo;	10	struct str_SPI_VersionInfo NC_Version;
11		11
12	unsigned char SPI_BufferIndex;	12	unsigned char SPI_BufferIndex;
13	unsigned char SPI_RxBufferIndex;	13	unsigned char SPI_RxBufferIndex;
14		14
15	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl)];	15	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl)];
16	unsigned char *SPI_TX_Buffer;	16	unsigned char *SPI_TX_Buffer;
17		17
18	unsigned char SPITransferCompleted, SPI_ChkSum;	18	unsigned char SPITransferCompleted, SPI_ChkSum;
19	unsigned char SPI_RxDataValid,NaviDataOkay = 0;	19	unsigned char SPI_RxDataValid,NaviDataOkay = 0;
20		20
21	unsigned char SPI_CommandSequence[] = { SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_PARAMETER1, SPI_CMD_STICK, SPI_CMD_MISC, SPI_CMD_VERSION, SPI_CMD_SERVOS };	21	unsigned char SPI_CommandSequence[] = { SPI_FCCMD_USER, SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER1, SPI_FCCMD_STICK, SPI_FCCMD_MISC, SPI_FCCMD_VERSION, SPI_FCCMD_SERVOS };
22	unsigned char SPI_CommandCounter = 0;	22	unsigned char SPI_CommandCounter = 0;
23		23
24	#ifdef USE_SPI_COMMUNICATION	24	#ifdef USE_SPI_COMMUNICATION
25		25
26	//------------------------------------------------------	26	//------------------------------------------------------
27	void SPI_MasterInit(void)	27	void SPI_MasterInit(void)
28	{	28	{
29	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input	29	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input
30	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);	30	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);
31		31
32	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPR0)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64	32	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPR0)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64
33	SPSR = 0;//(1<<SPI2X);	33	SPSR = 0;//(1<<SPI2X);
34		34
35	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);	35	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);
36	SPITransferCompleted = 1;	36	SPITransferCompleted = 1;
37		37
38	//SPDR = 0x00; // dummy write	38	//SPDR = 0x00; // dummy write
39		39
40	ToNaviCtrl.Sync1 = 0xAA;	40	ToNaviCtrl.Sync1 = 0xAA;
41	ToNaviCtrl.Sync2 = 0x83;	41	ToNaviCtrl.Sync2 = 0x83;
42		42
43	ToNaviCtrl.Command = SPI_CMD_USER;	43	ToNaviCtrl.Command = SPI_FCCMD_USER;
44	ToNaviCtrl.IntegralNick = 0;	44	ToNaviCtrl.IntegralNick = 0;
45	ToNaviCtrl.IntegralRoll = 0;	45	ToNaviCtrl.IntegralRoll = 0;
46	FromNaviCtrl_Value.SerialDataOkay = 0;	46	FromNaviCtrl_Value.SerialDataOkay = 0;
47	SPI_RxDataValid = 0;	47	SPI_RxDataValid = 0;
48		-
49	SPI_VersionInfo.Major = VERSION_MAJOR;	-
50	SPI_VersionInfo.Minor = VERSION_MINOR;	-
51	SPI_VersionInfo.Patch = VERSION_PATCH;	-
52	SPI_VersionInfo.Compatible = NC_SPI_COMPATIBLE;	48
53	}	49	}
54		50
55	//------------------------------------------------------	51	//------------------------------------------------------
56	void SPI_StartTransmitPacket(void)	52	void SPI_StartTransmitPacket(void)
57	{	53	{
58	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed	54	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
59	if (!SPITransferCompleted) return;	55	if (!SPITransferCompleted) return;
60	// _delay_us(30);	56	// _delay_us(30);
61		57
62	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	58	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
63	SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;	59	SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
64		60
65	ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];	61	ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
66	if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;	62	if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
67		63
68	SPITransferCompleted = 0;	64	SPITransferCompleted = 0;
69	UpdateSPI_Buffer(); // update buffer	65	UpdateSPI_Buffer(); // update buffer
70		66
71	SPI_BufferIndex = 1;	67	SPI_BufferIndex = 1;
72	//ebugOut.Analog[16]++;	68	//ebugOut.Analog[16]++;
73	// -- Debug-Output ---	69	// -- Debug-Output ---
74	//----	70	//----
75	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	71	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
76	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	72	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
77	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	73	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
78	ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;	74	ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
79	SPDR = ToNaviCtrl.Sync1; // Start transmission	75	SPDR = ToNaviCtrl.Sync1; // Start transmission
80	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	76	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
81		77
82	}	78	}
83		79
84	//------------------------------------------------------	80	//------------------------------------------------------
85	//SIGNAL(SIG_SPI)	81	//SIGNAL(SIG_SPI)
86	void SPI_TransmitByte(void)	82	void SPI_TransmitByte(void)
87	{	83	{
88	static unsigned char SPI_RXState = 0;	84	static unsigned char SPI_RXState = 0;
89	unsigned char rxdata;	85	unsigned char rxdata;
90	static unsigned char rxchksum;	86	static unsigned char rxchksum;
91		87
92	if (SPITransferCompleted) return;	88	if (SPITransferCompleted) return;
93	if (!(SPSR & (1 << SPIF))) return;	89	if (!(SPSR & (1 << SPIF))) return;
94	SendSPI = 4;	90	SendSPI = 4;
95		91
96	// _delay_us(30);	92	// _delay_us(30);
97	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	93	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
98		94
99	rxdata = SPDR;	95	rxdata = SPDR;
100	switch ( SPI_RXState)	96	switch ( SPI_RXState)
101	{	97	{
102	case 0:	98	case 0:
103		99
104	SPI_RxBufferIndex = 0;	100	SPI_RxBufferIndex = 0;
105	//DebugOut.Analog[17]++;	101	//DebugOut.Analog[17]++;
106	rxchksum = rxdata;	102	rxchksum = rxdata;
107	if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok	103	if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok
108		104
109	break;	105	break;
110		106
111	case 1:	107	case 1:
112	if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState = 2; } // 2. Syncbyte ok	108	if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState = 2; } // 2. Syncbyte ok
113	else SPI_RXState = 0;	109	else SPI_RXState = 0;
114	//DebugOut.Analog[18]++;	110	//DebugOut.Analog[18]++;
115	break;	111	break;
116		112
117	case 2:	113	case 2:
118	SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data	114	SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data
119	//DebugOut.Analog[19]++;	115	//DebugOut.Analog[19]++;
120	if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))	116	if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
121	{	117	{
122		118
123	if (rxdata == rxchksum)	119	if (rxdata == rxchksum)
124	{	120	{
125	unsigned char ptr = (unsigned char )&FromNaviCtrl;	121	unsigned char ptr = (unsigned char )&FromNaviCtrl;
126		122
127	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));	123	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
128		124
129	SPI_RxDataValid = 1;	125	SPI_RxDataValid = 1;
130	}	126	}
131	else SPI_RxDataValid = 0;	127	else SPI_RxDataValid = 0;
132		128
133	SPI_RXState = 0;	129	SPI_RXState = 0;
134	}	130	}
135	else rxchksum += rxdata;	131	else rxchksum += rxdata;
136	break;	132	break;
137		133
138	}	134	}
139		135
140	if (SPI_BufferIndex < sizeof(ToNaviCtrl))	136	if (SPI_BufferIndex < sizeof(ToNaviCtrl))
141	{	137	{
142	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	138	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
143	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	139	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
144	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	140	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
145	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	141	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
146		142
147	SPDR = SPI_TX_Buffer[SPI_BufferIndex];	143	SPDR = SPI_TX_Buffer[SPI_BufferIndex];
148	ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];	144	ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
149	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	145	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
150		146
151	}	147	}
152	else SPITransferCompleted = 1;	148	else SPITransferCompleted = 1;
153		149
154	SPI_BufferIndex++;	150	SPI_BufferIndex++;
155	}	151	}
156		152
157		153
158	//------------------------------------------------------	154	//------------------------------------------------------
159	void UpdateSPI_Buffer(void)	155	void UpdateSPI_Buffer(void)
160	{	156	{
161	signed int tmp;	157	signed int tmp;
162	ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4));	158	ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4));
163	ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4));	159	ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4));
164	ToNaviCtrl.GyroCompass = (10 * ErsatzKompass) / GIER_GRAD_FAKTOR;	160	ToNaviCtrl.GyroCompass = (10 * ErsatzKompass) / GIER_GRAD_FAKTOR;
165	ToNaviCtrl.AccNick = ((int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc))/4;	161	ToNaviCtrl.AccNick = ((int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc))/4;
166	ToNaviCtrl.AccRoll = ((int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc))/4;	162	ToNaviCtrl.AccRoll = ((int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc))/4;
167	NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;	163	NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
168	// ToNaviCtrl.User8 = Parameter_UserParam8;	164	// ToNaviCtrl.User8 = Parameter_UserParam8;
169	// ToNaviCtrl.CalState = WinkelOut.CalcState;	165	// ToNaviCtrl.CalState = WinkelOut.CalcState;
170	switch(ToNaviCtrl.Command) //	166	switch(ToNaviCtrl.Command) //
171	{	167	{
172	case SPI_CMD_USER:	168	case SPI_FCCMD_USER:
173	ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;	169	ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
174	ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;	170	ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
175	ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;	171	ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
176	ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;	172	ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;
177	ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;	173	ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;
178	ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;	174	ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;
179	ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;	175	ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;
180	ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;	176	ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;
181	ToNaviCtrl.Param.Byte[8] = (unsigned char) FCFlags;	177	ToNaviCtrl.Param.Byte[8] = (unsigned char) FCFlags;
182	FCFlags &= ~(FCFLAG_CALIBRATE \| FCFLAG_START);	178	FCFlags &= ~(FCFLAG_CALIBRATE \| FCFLAG_START);
183	ToNaviCtrl.Param.Byte[9] = (unsigned char) UBat;	179	ToNaviCtrl.Param.Byte[9] = (unsigned char) UBat;
184	ToNaviCtrl.Param.Byte[10] =(unsigned char) BattLowVoltageWarning;	180	ToNaviCtrl.Param.Byte[10] =(unsigned char) BattLowVoltageWarning;
185	ToNaviCtrl.Param.Byte[11] =(unsigned char) eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);	181	ToNaviCtrl.Param.Byte[11] =(unsigned char) eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
186	break;	182	break;
187		183
188	case SPI_CMD_PARAMETER1:	184	case SPI_FCCMD_PARAMETER1:
189	ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl; // Parameters for the Naviboard	185	ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl; // Parameters for the Naviboard
190	ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;	186	ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;
191	ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;	187	ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
192	ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;	188	ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
193	ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;	189	ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
194	ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;	190	ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
195	ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;	191	ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
196	ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;	192	ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
197	ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;	193	ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;
198	ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;	194	ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;
199	ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviSpeedCompensation;	195	ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviSpeedCompensation;
200	ToNaviCtrl.Param.Byte[11] = EE_Parameter.NaviAngleLimitation;	196	ToNaviCtrl.Param.Byte[11] = EE_Parameter.NaviAngleLimitation;
201	break;	197	break;
202		198
203	case SPI_CMD_STICK:	199	case SPI_FCCMD_STICK:
204	cli();	200	cli();
205	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;	201	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
206	ToNaviCtrl.Param.Byte[0] = (char) tmp;	202	ToNaviCtrl.Param.Byte[0] = (char) tmp;
207	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;	203	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
208	ToNaviCtrl.Param.Byte[1] = (char) tmp;	204	ToNaviCtrl.Param.Byte[1] = (char) tmp;
209	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;	205	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
210	ToNaviCtrl.Param.Byte[2] = (char) tmp;	206	ToNaviCtrl.Param.Byte[2] = (char) tmp;
211	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;	207	tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
212	sei();	208	sei();
213	ToNaviCtrl.Param.Byte[3] = (char) tmp;	209	ToNaviCtrl.Param.Byte[3] = (char) tmp;
214	ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];	210	ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];
215	ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];	211	ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];
216	ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];	212	ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];
217	ToNaviCtrl.Param.Byte[7] = (unsigned char) Poti[3];	213	ToNaviCtrl.Param.Byte[7] = (unsigned char) Poti[3];
218	ToNaviCtrl.Param.Byte[8] = (unsigned char) Poti[4];	214	ToNaviCtrl.Param.Byte[8] = (unsigned char) Poti[4];
219	ToNaviCtrl.Param.Byte[9] = (unsigned char) Poti[5];	215	ToNaviCtrl.Param.Byte[9] = (unsigned char) Poti[5];
220	ToNaviCtrl.Param.Byte[10] = (unsigned char) Poti[6];	216	ToNaviCtrl.Param.Byte[10] = (unsigned char) Poti[6];
221	ToNaviCtrl.Param.Byte[11] = (unsigned char) Poti[7];	217	ToNaviCtrl.Param.Byte[11] = (unsigned char) Poti[7];
222	break;	218	break;
223	case SPI_CMD_MISC:	219	case SPI_FCCMD_MISC:
224	if(WinkelOut.CalcState > 5)	220	if(WinkelOut.CalcState > 5)
225	{	221	{
226	WinkelOut.CalcState = 0;	222	WinkelOut.CalcState = 0;
227	ToNaviCtrl.Param.Byte[0] = 5;	223	ToNaviCtrl.Param.Byte[0] = 5;
228	}	224	}
229	else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;	225	else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
230	ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviPH_LoginTime;	226	ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviPH_LoginTime;
231	ToNaviCtrl.Param.Int[1] = DebugOut.Analog[5];// = HoehenWert/5;	227	ToNaviCtrl.Param.Int[1] = DebugOut.Analog[5];// = HoehenWert/5;
232	ToNaviCtrl.Param.Int[2] = (int)(SollHoehe/5);	228	ToNaviCtrl.Param.Int[2] = (int)(SollHoehe/5);
233	ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsPLimit;	229	ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsPLimit;
234	ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit;	230	ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit;
235	ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit;	231	ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit;
236	ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay;	232	ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay;
237	ToNaviCtrl.Param.Byte[10] = (unsigned char) SenderRSSI;	233	ToNaviCtrl.Param.Byte[10] = (unsigned char) SenderRSSI;
238	ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil	234	ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil
239	break;	235	break;
240	case SPI_CMD_VERSION:	236	case SPI_FCCMD_VERSION:
241	ToNaviCtrl.Param.Byte[0] = SPI_VersionInfo.Major;	237	ToNaviCtrl.Param.Byte[0] = VERSION_MAJOR;
242	ToNaviCtrl.Param.Byte[1] = SPI_VersionInfo.Minor;	238	ToNaviCtrl.Param.Byte[1] = VERSION_MINOR;
243	ToNaviCtrl.Param.Byte[2] = SPI_VersionInfo.Patch;	239	ToNaviCtrl.Param.Byte[2] = VERSION_PATCH;
244	ToNaviCtrl.Param.Byte[3] = SPI_VersionInfo.Compatible;	240	ToNaviCtrl.Param.Byte[3] = NC_SPI_COMPATIBLE;
245	ToNaviCtrl.Param.Byte[4] = PlatinenVersion;	241	ToNaviCtrl.Param.Byte[4] = PlatinenVersion;
246	break;	242	break;
247		243
248	case SPI_CMD_SERVOS:	244	case SPI_FCCMD_SERVOS:
249	ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh; // Parameters for the Servo Control	245	ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh; // Parameters for the Servo Control
250	ToNaviCtrl.Param.Byte[1] = EE_Parameter.ServoCompInvert;	246	ToNaviCtrl.Param.Byte[1] = EE_Parameter.ServoCompInvert;
251	ToNaviCtrl.Param.Byte[2] = Parameter_ServoNickControl;	247	ToNaviCtrl.Param.Byte[2] = Parameter_ServoNickControl;
252	ToNaviCtrl.Param.Byte[3] = EE_Parameter.ServoNickComp;	248	ToNaviCtrl.Param.Byte[3] = EE_Parameter.ServoNickComp;
253	ToNaviCtrl.Param.Byte[4] = EE_Parameter.ServoNickMin;	249	ToNaviCtrl.Param.Byte[4] = EE_Parameter.ServoNickMin;
254	ToNaviCtrl.Param.Byte[5] = EE_Parameter.ServoNickMax;	250	ToNaviCtrl.Param.Byte[5] = EE_Parameter.ServoNickMax;
255	ToNaviCtrl.Param.Byte[6] = Parameter_ServoRollControl;	251	ToNaviCtrl.Param.Byte[6] = Parameter_ServoRollControl;
256	ToNaviCtrl.Param.Byte[7] = EE_Parameter.ServoRollComp;	252	ToNaviCtrl.Param.Byte[7] = EE_Parameter.ServoRollComp;
257	ToNaviCtrl.Param.Byte[8] = EE_Parameter.ServoRollMin;	253	ToNaviCtrl.Param.Byte[8] = EE_Parameter.ServoRollMin;
258	ToNaviCtrl.Param.Byte[9] = EE_Parameter.ServoRollMax;	254	ToNaviCtrl.Param.Byte[9] = EE_Parameter.ServoRollMax;
259	break;	255	break;
260	}	256	}
261		257
262	if(SPI_RxDataValid)	258	if(SPI_RxDataValid)
263	{	259	{
264	if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))	260	if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))
265	{	261	{
266	GPS_Nick = FromNaviCtrl.GPS_Nick;	262	GPS_Nick = FromNaviCtrl.GPS_Nick;
267	GPS_Roll = FromNaviCtrl.GPS_Roll;	263	GPS_Roll = FromNaviCtrl.GPS_Roll;
268	NaviDataOkay = 250;	264	NaviDataOkay = 250;
269	}	265	}
270	if(FromNaviCtrl.CompassValue <= 360) KompassValue = FromNaviCtrl.CompassValue;	266	if(FromNaviCtrl.CompassValue <= 360) KompassValue = FromNaviCtrl.CompassValue;
271	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;	267	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
272		268
273	if(FromNaviCtrl.BeepTime > beeptime && !WinkelOut.CalcState) beeptime = FromNaviCtrl.BeepTime;	269	if(FromNaviCtrl.BeepTime > beeptime && !WinkelOut.CalcState) beeptime = FromNaviCtrl.BeepTime;
274		270
275	switch (FromNaviCtrl.Command)	271	switch (FromNaviCtrl.Command)
276	{	272	{
277	case SPI_KALMAN:	273	case SPI_NCCMD_KALMAN:
278	FromNaviCtrl_Value.Kalman_K = FromNaviCtrl.Param.sByte[0];	274	FromNaviCtrl_Value.Kalman_K = FromNaviCtrl.Param.sByte[0];
279	FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.sByte[1];	275	FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.sByte[1];
280	FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.sByte[2];	276	FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.sByte[2];
281	FromNaviCtrl_Value.SerialDataOkay = FromNaviCtrl.Param.Byte[3];	277	FromNaviCtrl_Value.SerialDataOkay = FromNaviCtrl.Param.Byte[3];
282	FromNaviCtrl_Value.GpsZ = FromNaviCtrl.Param.Byte[4];	278	FromNaviCtrl_Value.GpsZ = FromNaviCtrl.Param.Byte[4];
283	break;	279	break;
-		280
-		281	case SPI_NCCMD_VERSION:
-		282	NC_Version.Major = FromNaviCtrl.Param.Byte[0];
-		283	NC_Version.Minor = FromNaviCtrl.Param.Byte[1];
-		284	NC_Version.Patch = FromNaviCtrl.Param.Byte[2];
-		285	NC_Version.Compatible = FromNaviCtrl.Param.Byte[3];
-		286	NC_Version.Hardware = FromNaviCtrl.Param.Byte[4];
-		287	break;
284	default:	288	default:
285	break;	289	break;
286	}	290	}
287	}	291	}
288	else	292	else
289	{	293	{
290	// KompassValue = 0;	294	// KompassValue = 0;
291	// KompassRichtung = 0;	295	// KompassRichtung = 0;
292	GPS_Nick = 0;	296	GPS_Nick = 0;
293	GPS_Roll = 0;	297	GPS_Roll = 0;
294	}	298	}
295	}	299	}
296		300
297	#endif	301	#endif
298		302
299		303
300		304

Subversion Repositories FlightCtrl

(root)/branches/MartinW_Jeti+/spi.c @ 2153 - Rev 1420 → 1448