Subversion Repositories FlightCtrl

Rev

Rev 2341 | Rev 2344 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2341 Rev 2342
1 
// ######################## SPI - FlightCtrl ###################
 1 
// ######################## SPI - FlightCtrl ###################
2 
#include "main.h"
 2 
#include "main.h"
3 
#include "eeprom.h"
 3 
#include "eeprom.h"
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 NC_Version;
 10 
struct str_SPI_VersionInfo NC_Version;
11 
struct str_GPSInfo GPSInfo;
 11 
struct str_GPSInfo GPSInfo;
12 
 
 12 
 
13 
unsigned char SPI_BufferIndex;
 13 
unsigned char SPI_BufferIndex;
14 
unsigned char SPI_RxBufferIndex;
 14 
unsigned char SPI_RxBufferIndex;
15 
signed char FromNC_Rotate_C = 32, FromNC_Rotate_S = 0;
 15 
signed char FromNC_Rotate_C = 32, FromNC_Rotate_S = 0;
16 
 
 16 
 
17 
volatile unsigned char     SPI_Buffer[sizeof(FromNaviCtrl)];
 17 
volatile unsigned char     SPI_Buffer[sizeof(FromNaviCtrl)];
18 
unsigned char *SPI_TX_Buffer;
 18 
unsigned char *SPI_TX_Buffer;
19 
 
 19 
 
20 
unsigned char SPITransferCompleted, SPI_ChkSum;
 20 
unsigned char SPITransferCompleted, SPI_ChkSum;
21 
unsigned char SPI_RxDataValid,NaviDataOkay = 250;
 21 
unsigned char SPI_RxDataValid,NaviDataOkay = 250;
22 
 
 22 
 
23 
unsigned char SPI_CommandSequence[] = { SPI_FCCMD_STICK, SPI_FCCMD_USER, SPI_FCCMD_PARAMETER1,
 23 
unsigned char SPI_CommandSequence[] = { SPI_FCCMD_STICK, SPI_FCCMD_USER, SPI_FCCMD_PARAMETER1,
24 
                                                                                SPI_FCCMD_STICK, SPI_FCCMD_VERSION, SPI_FCCMD_BL_ACCU,
 24 
                                                                                SPI_FCCMD_STICK, SPI_FCCMD_VERSION, SPI_FCCMD_BL_ACCU,
25 
                                        SPI_FCCMD_STICK, SPI_FCCMD_MISC,SPI_FCCMD_SERVOS,  
 25 
                                        SPI_FCCMD_STICK, SPI_FCCMD_MISC,SPI_FCCMD_SERVOS,  
26 
                                                                                SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER2, SPI_FCCMD_BL_ACCU
 26 
                                                                                SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER2, SPI_FCCMD_BL_ACCU
27 
                                                                                };
 27 
                                                                                };
28 
unsigned char SPI_CommandCounter = 0;
 28 
unsigned char SPI_CommandCounter = 0;
29 
unsigned char NC_ErrorCode = 0;
 29 
unsigned char NC_ErrorCode = 0;
30 
unsigned char NC_GPS_ModeCharacter = ' ';
 30 
unsigned char NC_GPS_ModeCharacter = ' ';
31 
unsigned char EarthMagneticField = 0;
 31 
unsigned char EarthMagneticField = 0;
32 
unsigned char EarthMagneticInclination = 0, EarthMagneticInclinationTheoretic = 0;
 32 
unsigned char EarthMagneticInclination = 0, EarthMagneticInclinationTheoretic = 0;
33 
unsigned char NC_To_FC_Flags = 0;
 33 
unsigned char NC_To_FC_Flags = 0;
34 
unsigned char NC_To_FC_MaxAltitude = 0; // this is a Parameter on the SD-card
 34 
unsigned char NC_To_FC_MaxAltitude = 0; // this is a Parameter on the SD-card
35 
signed int POI_KameraNick = 0; // in 0,1°
 35 
signed int POI_KameraNick = 0; // in 0,1°
36 
vector16_t MagVec = {0,0,0};
 36 
vector16_t MagVec = {0,0,0};
37 
 
 37 
 
38 
#ifdef USE_SPI_COMMUNICATION
 38 
#ifdef USE_SPI_COMMUNICATION
39 
 
 39 
 
40 
//------------------------------------------------------
 40 
//------------------------------------------------------
41 
void SPI_MasterInit(void)
 41 
void SPI_MasterInit(void)
42 
{
 42 
{
43 
  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input
 43 
  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input
44 
  SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
 44 
  SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
45 
 
 45 
 
46 
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64
 46 
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64
47 
  SPSR = 0;//(1<<SPI2X);
 47 
  SPSR = 0;//(1<<SPI2X);
48 
 
 48 
 
49 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
 49 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
50 
  SPITransferCompleted = 1;
 50 
  SPITransferCompleted = 1;
51 
 
 51 
 
52 
  //SPDR = 0x00;  // dummy write
 52 
  //SPDR = 0x00;  // dummy write
53 
 
 53 
 
54 
  ToNaviCtrl.Sync1 = 0xAA;
 54 
  ToNaviCtrl.Sync1 = 0xAA;
55 
  ToNaviCtrl.Sync2 = 0x83;
 55 
  ToNaviCtrl.Sync2 = 0x83;
56 
 
 56 
 
57 
  ToNaviCtrl.Command = SPI_FCCMD_USER;
 57 
  ToNaviCtrl.Command = SPI_FCCMD_USER;
58 
  ToNaviCtrl.IntegralNick = 0;
 58 
  ToNaviCtrl.IntegralNick = 0;
59 
  ToNaviCtrl.IntegralRoll = 0;
 59 
  ToNaviCtrl.IntegralRoll = 0;
60 
  FromNaviCtrl_Value.SerialDataOkay = 0;
 60 
  FromNaviCtrl_Value.SerialDataOkay = 0;
61 
  SPI_RxDataValid = 0;
 61 
  SPI_RxDataValid = 0;
62 
 
 62 
 
63 
}
 63 
}
64 
 
 64 
 
65 
//------------------------------------------------------
 65 
//------------------------------------------------------
66 
void SPI_StartTransmitPacket(void)
 66 
void SPI_StartTransmitPacket(void)
67 
{
 67 
{
68 
   if (!SPITransferCompleted) return;
 68 
   if (!SPITransferCompleted) return;
69 
   SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
 69 
   SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
70 
   SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
 70 
   SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
71 
 
 71 
 
72 
   ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
 72 
   ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
73 
   if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
 73 
   if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
74 
 
 74 
 
75 
   SPITransferCompleted = 0;
 75 
   SPITransferCompleted = 0;
76 
   UpdateSPI_Buffer();                              // update buffer
 76 
   UpdateSPI_Buffer();                              // update buffer
77 
   SPI_BufferIndex = 1;
 77 
   SPI_BufferIndex = 1;
78 
   ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
 78 
   ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
79 
   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
 79 
   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
80 
}
 80 
}
81 
 
 81 
 
82 
//------------------------------------------------------
 82 
//------------------------------------------------------
83 
//SIGNAL(SIG_SPI)
 83 
//SIGNAL(SIG_SPI)
84 
void SPI_TransmitByte(void)
 84 
void SPI_TransmitByte(void)
85 
{
 85 
{
86 
   static unsigned char SPI_RXState = 0;
 86 
   static unsigned char SPI_RXState = 0;
87 
   unsigned char rxdata;
 87 
   unsigned char rxdata;
88 
   static unsigned char rxchksum;
 88 
   static unsigned char rxchksum;
89 
 
 89 
 
90 
   if (SPITransferCompleted) return;
 90 
   if (SPITransferCompleted) return;
91 
   if (!(SPSR & (1 << SPIF))) return;
 91 
   if (!(SPSR & (1 << SPIF))) return;
92 
  SendSPI = SPI_BYTEGAP;
 92 
  SendSPI = SPI_BYTEGAP;
93 
//   _delay_us(30);
 93 
//   _delay_us(30);
94 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 94 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
95 
 
 95 
 
96 
  rxdata = SPDR;
 96 
  rxdata = SPDR;
97 
  switch ( SPI_RXState)
 97 
  switch ( SPI_RXState)
98 
  {
 98 
  {
99 
  case 0:
 99 
  case 0:
100 
                        SPI_RxBufferIndex = 0;
 100 
                        SPI_RxBufferIndex = 0;
101 
                        rxchksum = rxdata;
 101 
                        rxchksum = rxdata;
102 
                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok
 102 
                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok
103 
 
 103 
 
104 
           break;
 104 
           break;
105 
 
 105 
 
106 
   case 1:
 106 
   case 1:
107 
                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok
 107 
                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok
108 
                 else SPI_RXState  = 0;
 108 
                 else SPI_RXState  = 0;
109 
           break;
 109 
           break;
110 
 
 110 
 
111 
   case 2:
 111 
   case 2:
112 
                   SPI_Buffer[SPI_RxBufferIndex++]= rxdata;             // get data
 112 
                   SPI_Buffer[SPI_RxBufferIndex++]= rxdata;             // get data
113 
           //DebugOut.Analog[19]++;
 113 
           //DebugOut.Analog[19]++;
114 
           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
 114 
           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
115 
                   {
 115 
                   {
116 
                if (rxdata == rxchksum)
 116 
                if (rxdata == rxchksum)
117 
                        {
 117 
                        {
118 
                  unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
 118 
                  unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
119 
                          memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
 119 
                          memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
120 
                          SPI_RxDataValid = 1;
 120 
                          SPI_RxDataValid = 1;
121 
                        }
 121 
                        }
122 
                        else
 122 
                        else
123 
                         {
 123 
                         {
124 
                          SPI_RxDataValid = 0;
 124 
                          SPI_RxDataValid = 0;
125 
                         }
 125 
                         }
126 
                        SPI_RXState  = 0;
 126 
                        SPI_RXState  = 0;
127 
                   }
 127 
                   }
128 
                  else rxchksum += rxdata;
 128 
                  else rxchksum += rxdata;
129 
        break;
 129 
        break;
130 
 
 130 
 
131 
  }
 131 
  }
132 
 
 132 
 
133 
   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
 133 
   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
134 
     {
 134 
     {
135 
           SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
 135 
           SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
136 
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
 136 
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
137 
           SPDR = SPI_TX_Buffer[SPI_BufferIndex];
 137 
           SPDR = SPI_TX_Buffer[SPI_BufferIndex];
138 
           ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
 138 
           ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
139 
         }
 139 
         }
140 
         else SPITransferCompleted = 1;
 140 
         else SPITransferCompleted = 1;
141 
 
 141 
 
142 
         SPI_BufferIndex++;
 142 
         SPI_BufferIndex++;
143 
}
 143 
}
144 
 
 144 
 
145 
 
 145 
 
146 
//------------------------------------------------------
 146 
//------------------------------------------------------
147 
void UpdateSPI_Buffer(void)
 147 
void UpdateSPI_Buffer(void)
148 
{
 148 
{
149 
  signed int tmp;
 149 
  signed int tmp;
150 
  static unsigned char motorindex, oldcommand = SPI_NCCMD_VERSION;
 150 
  static unsigned char motorindex, oldcommand = SPI_NCCMD_VERSION;
151 
  ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4));
 151 
  ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4));
152 
  ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4));
 152 
  ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4));
153 
  ToNaviCtrl.GyroCompass = (10 * ErsatzKompass) / GIER_GRAD_FAKTOR;
 153 
  ToNaviCtrl.GyroCompass = (10 * ErsatzKompass) / GIER_GRAD_FAKTOR;
154 
  ToNaviCtrl.GyroGier = (signed int) AdNeutralGier - AdWertGier;
 154 
  ToNaviCtrl.GyroGier = (signed int) AdNeutralGier - AdWertGier;
155 
  ToNaviCtrl.AccNick = ((int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc))/4;
 155 
  ToNaviCtrl.AccNick = ((int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc))/4;
156 
  ToNaviCtrl.AccRoll = ((int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc))/4;
 156 
  ToNaviCtrl.AccRoll = ((int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc))/4;
157 
  NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
 157 
  NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
158 
//  ToNaviCtrl.User8 = Parameter_UserParam8;
 158 
//  ToNaviCtrl.User8 = Parameter_UserParam8;
159 
//  ToNaviCtrl.CalState = WinkelOut.CalcState;
 159 
//  ToNaviCtrl.CalState = WinkelOut.CalcState;
160 
   switch(ToNaviCtrl.Command)  //
 160 
   switch(ToNaviCtrl.Command)  //
161 
   {
 161 
   {
162 
         case SPI_FCCMD_USER:
 162 
         case SPI_FCCMD_USER:
163 
                                ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
 163 
                                ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
164 
                                ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
 164 
                                ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
165 
                                ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
 165 
                                ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
166 
                                ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;
 166 
                                ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;
167 
                                ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;
 167 
                                ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;
168 
                                ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;
 168 
                                ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;
169 
                                ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;
 169 
                                ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;
170 
                                ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;
 170 
                                ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;
171 
                                ToNaviCtrl.Param.Byte[8] = FC_StatusFlags;
 171 
                                ToNaviCtrl.Param.Byte[8] = FC_StatusFlags;
172 
//if(FC_StatusFlags2 & FC_STATUS2_WAIT_FOR_TAKEOFF) ToNaviCtrl.Param.Byte[8] &= ~FC_STATUS_FLY;
 172 
//if(FC_StatusFlags2 & FC_STATUS2_WAIT_FOR_TAKEOFF) ToNaviCtrl.Param.Byte[8] &= ~FC_STATUS_FLY;
173 
                FC_StatusFlags &= ~(FC_STATUS_CALIBRATE | FC_STATUS_START);
 173 
                FC_StatusFlags &= ~(FC_STATUS_CALIBRATE | FC_STATUS_START);
174 
                    ToNaviCtrl.Param.Byte[9] = ActiveParamSet;
 174 
                    ToNaviCtrl.Param.Byte[9] = ActiveParamSet;
175 
                                ToNaviCtrl.Param.Byte[10] = EE_Parameter.ComingHomeAltitude;
 175 
                                ToNaviCtrl.Param.Byte[10] = EE_Parameter.ComingHomeAltitude;
176 
                                ToNaviCtrl.Param.Byte[11] = FC_StatusFlags2;
 176 
                                ToNaviCtrl.Param.Byte[11] = FC_StatusFlags2;
177 
        break;
 177 
        break;
178 
 
 178 
 
179 
     case SPI_FCCMD_BL_ACCU:
 179 
     case SPI_FCCMD_BL_ACCU:
180 
                        ToNaviCtrl.Param.Int[0] = Capacity.ActualCurrent; // 0.1A
 180 
                        ToNaviCtrl.Param.Int[0] = Capacity.ActualCurrent; // 0.1A
181 
                        ToNaviCtrl.Param.Int[1] = Capacity.UsedCapacity; // mAh
 181 
                        ToNaviCtrl.Param.Int[1] = Capacity.UsedCapacity; // mAh
182 
                        ToNaviCtrl.Param.Byte[4] = (unsigned char) UBat; // 0.1V
 182 
                        ToNaviCtrl.Param.Byte[4] = (unsigned char) UBat; // 0.1V
183 
                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsModeControl;  // GPS-Mode  
 183 
                                ToNaviCtrl.Param.Byte[5] = GetChannelValue(EE_Parameter.NaviGpsModeChannel);  // GPS-Mode control
184 
                                ToNaviCtrl.Param.Byte[6] = VarioCharacter;
 184 
                                ToNaviCtrl.Param.Byte[6] = VarioCharacter;
185 
                                ToNaviCtrl.Param.Byte[7] = motorindex;
 185 
                                ToNaviCtrl.Param.Byte[7] = motorindex;
186 
                                ToNaviCtrl.Param.Byte[8] = Motor[motorindex].MaxPWM;
 186 
                                ToNaviCtrl.Param.Byte[8] = Motor[motorindex].MaxPWM;
187 
                                ToNaviCtrl.Param.Byte[9] = Motor[motorindex].State;
 187 
                                ToNaviCtrl.Param.Byte[9] = Motor[motorindex].State;
188 
                                ToNaviCtrl.Param.Byte[10] = Motor[motorindex].Temperature;
 188 
                                ToNaviCtrl.Param.Byte[10] = Motor[motorindex].Temperature;
189 
                                ToNaviCtrl.Param.Byte[11] = Motor[motorindex++].Current;
 189 
                                ToNaviCtrl.Param.Byte[11] = Motor[motorindex++].Current;
190 
                                motorindex %= 12;
 190 
                                motorindex %= 12;
191 
        break;
 191 
        break;
192 
         case SPI_FCCMD_PARAMETER1:
 192 
         case SPI_FCCMD_PARAMETER1:
193 
                                ToNaviCtrl.Param.Byte[0] = (unsigned char) BattLowVoltageWarning; //0.1V
 193 
                                ToNaviCtrl.Param.Byte[0] = (unsigned char) BattLowVoltageWarning; //0.1V
194 
                                ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;           // Parameters for the Naviboard
 194 
                                ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;           // Parameters for the Naviboard
195 
                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
 195 
                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
196 
                                ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
 196 
                                ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
197 
                                ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
 197 
                                ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
198 
                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
 198 
                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
199 
                                ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
 199 
                                ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
200 
                ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
 200 
                ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
201 
                ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;
 201 
                ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;
202 
                ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;
 202 
                ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;
203 
                ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviAccCompensation;
 203 
                ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviAccCompensation;
204 
                                ToNaviCtrl.Param.Byte[11] = EE_Parameter.NaviAngleLimitation;
 204 
                                ToNaviCtrl.Param.Byte[11] = EE_Parameter.NaviAngleLimitation;
205 
            break;
 205 
            break;
206 
         case SPI_FCCMD_PARAMETER2:
 206 
         case SPI_FCCMD_PARAMETER2:
207 
                                ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviOut1Parameter;     // Distance between Photo releases
 207 
                                ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviOut1Parameter;     // Distance between Photo releases
208 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
 208 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
209 
                                // create the ToNC_SpeakHoTT
 209 
                                // create the ToNC_SpeakHoTT
210 
                                if(EE_Parameter.Receiver != RECEIVER_HOTT)
 210 
                                if(EE_Parameter.Receiver != RECEIVER_HOTT)
211 
                                 {
 211 
                                 {
212 
                                  if(JetiBeep != 'B') JetiBeep = pgm_read_byte(&JETI_CODE[HoTT_Waring()]);
 212 
                                  if(JetiBeep != 'B') JetiBeep = pgm_read_byte(&JETI_CODE[HoTT_Waring()]);
213 
                                  else HoTT_Waring();
 213 
                                  else HoTT_Waring();
214 
                                 }
 214 
                                 }
215 
                                ToNaviCtrl.Param.Byte[1] = ToNC_SpeakHoTT;
 215 
                                ToNaviCtrl.Param.Byte[1] = ToNC_SpeakHoTT;
216 
#else
 216 
#else
217 
                                ToNaviCtrl.Param.Byte[1] = 0;
 217 
                                ToNaviCtrl.Param.Byte[1] = 0;
218 
#endif
 218 
#endif
219 
                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.LandingSpeed;
 219 
                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.LandingSpeed;
220 
            break;
 220 
            break;
221 
         case SPI_FCCMD_STICK:
 221 
         case SPI_FCCMD_STICK:
222 
              cli();
 222 
              cli();
223 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];  if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
 223 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];  if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
224 
                                ToNaviCtrl.Param.Byte[0] = (char) tmp;
 224 
                                ToNaviCtrl.Param.Byte[0] = (char) tmp;
225 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
 225 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
226 
                                ToNaviCtrl.Param.Byte[1] = (char) tmp;
 226 
                                ToNaviCtrl.Param.Byte[1] = (char) tmp;
227 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
 227 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
228 
                                ToNaviCtrl.Param.Byte[2] = (char) tmp;
 228 
                                ToNaviCtrl.Param.Byte[2] = (char) tmp;
229 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
 229 
                tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
230 
              sei();
 230 
              sei();
231 
                                ToNaviCtrl.Param.Byte[3] = (char) tmp;
 231 
                                ToNaviCtrl.Param.Byte[3] = (char) tmp;
232 
                                ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];
 232 
                                ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];
233 
                                ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];
 233 
                                ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];
234 
                                ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];
 234 
                                ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];
235 
                    ToNaviCtrl.Param.Byte[7] = (unsigned char) Poti[3];
 235 
                    ToNaviCtrl.Param.Byte[7] = (unsigned char) Poti[3];
236 
                                ToNaviCtrl.Param.Byte[8] = (unsigned char) Poti[4];
 236 
                                ToNaviCtrl.Param.Byte[8] = (unsigned char) Poti[4];
237 
                                ToNaviCtrl.Param.Byte[9] = (unsigned char) Poti[5];
 237 
                                ToNaviCtrl.Param.Byte[9] = (unsigned char) Poti[5];
238 
                                ToNaviCtrl.Param.Byte[10] = (unsigned char) Poti[6];
 238 
                                ToNaviCtrl.Param.Byte[10] = (unsigned char) Poti[6];
239 
                                ToNaviCtrl.Param.Byte[11] = (unsigned char) Poti[7];
 239 
                                ToNaviCtrl.Param.Byte[11] = (unsigned char) Poti[7];
240 
                        break;
 240 
                        break;
241 
                case SPI_FCCMD_MISC:
 241 
                case SPI_FCCMD_MISC:
242 
                        if(WinkelOut.CalcState > 5)
 242 
                        if(WinkelOut.CalcState > 5)
243 
                        {
 243 
                        {
244 
                                WinkelOut.CalcState = 0;
 244 
                                WinkelOut.CalcState = 0;
245 
                                ToNaviCtrl.Param.Byte[0] = 5;
 245 
                                ToNaviCtrl.Param.Byte[0] = 5;
246 
                        }
 246 
                        }
247 
                        else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
 247 
                        else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
248 
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviPH_LoginTime;
 248 
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviPH_LoginTime;
249 
                        ToNaviCtrl.Param.Int[1] = (int)(HoehenWert/5);
 249 
                        ToNaviCtrl.Param.Int[1] = (int)(HoehenWert/5);
250 
                        ToNaviCtrl.Param.Int[2] = (int)(SollHoehe/5);
 250 
                        ToNaviCtrl.Param.Int[2] = (int)(SollHoehe/5);
251 
                        ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsPLimit;
 251 
                        ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsPLimit;
252 
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit;
 252 
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit;
253 
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit;
 253 
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit;
254 
            ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay;
 254 
            ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay;
255 
//            ToNaviCtrl.Param.Byte[10] = (unsigned char) PPM_in[0]; // ACT RSSI
 255 
//            ToNaviCtrl.Param.Byte[10] = (unsigned char) PPM_in[0]; // ACT RSSI
256 
ToNaviCtrl.Param.Byte[10] = 0;
 256 
ToNaviCtrl.Param.Byte[10] = 0;
257 
                        ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil
 257 
                        ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil
258 
                        break;
 258 
                        break;
259 
                case SPI_FCCMD_VERSION:
 259 
                case SPI_FCCMD_VERSION:
260 
                        ToNaviCtrl.Param.Byte[0] = VERSION_MAJOR;
 260 
                        ToNaviCtrl.Param.Byte[0] = VERSION_MAJOR;
261 
                        ToNaviCtrl.Param.Byte[1] = VERSION_MINOR;
 261 
                        ToNaviCtrl.Param.Byte[1] = VERSION_MINOR;
262 
                        ToNaviCtrl.Param.Byte[2] = VERSION_PATCH;
 262 
                        ToNaviCtrl.Param.Byte[2] = VERSION_PATCH;
263 
                        ToNaviCtrl.Param.Byte[3] = NC_SPI_COMPATIBLE;
 263 
                        ToNaviCtrl.Param.Byte[3] = NC_SPI_COMPATIBLE;
264 
                        ToNaviCtrl.Param.Byte[4] = PlatinenVersion;
 264 
                        ToNaviCtrl.Param.Byte[4] = PlatinenVersion;
265 
                        ToNaviCtrl.Param.Byte[5] = VersionInfo.HardwareError[0];
 265 
                        ToNaviCtrl.Param.Byte[5] = VersionInfo.HardwareError[0];
266 
                        ToNaviCtrl.Param.Byte[6] = VersionInfo.HardwareError[1];
 266 
                        ToNaviCtrl.Param.Byte[6] = VersionInfo.HardwareError[1];
267 
                        VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; //                         VersionInfo.HardwareError[0] = 0;
 267 
                        VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; //                         VersionInfo.HardwareError[0] = 0;
268 
                        VersionInfo.HardwareError[1] &= FC_ERROR1_MIXER;
 268 
                        VersionInfo.HardwareError[1] &= FC_ERROR1_MIXER;
269 
                        ToNaviCtrl.Param.Byte[7] = VersionInfo.HardwareError[2]; // unused
 269 
                        ToNaviCtrl.Param.Byte[7] = VersionInfo.HardwareError[2]; // unused
270 
                        ToNaviCtrl.Param.Byte[8] = Parameter_GlobalConfig;
 270 
                        ToNaviCtrl.Param.Byte[8] = Parameter_GlobalConfig;
271 
                        ToNaviCtrl.Param.Byte[9] = Parameter_ExtraConfig;
 271 
                        ToNaviCtrl.Param.Byte[9] = Parameter_ExtraConfig;
272 
                        ToNaviCtrl.Param.Byte[10] = EE_Parameter.OrientationAngle;
 272 
                        ToNaviCtrl.Param.Byte[10] = EE_Parameter.OrientationAngle;
273 
                        ToNaviCtrl.Param.Byte[11] = EE_Parameter.GlobalConfig3;
 273 
                        ToNaviCtrl.Param.Byte[11] = EE_Parameter.GlobalConfig3;
274 
                break;
 274 
                break;
275 
            case SPI_FCCMD_SERVOS:
 275 
            case SPI_FCCMD_SERVOS:
276 
                ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh;     // Parameters for the Servo Control
 276 
                ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh;     // Parameters for the Servo Control
277 
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.ServoCompInvert;
 277 
                        ToNaviCtrl.Param.Byte[1] = EE_Parameter.ServoCompInvert;
278 
                        ToNaviCtrl.Param.Byte[2] = Parameter_ServoNickControl;
 278 
                        ToNaviCtrl.Param.Byte[2] = Parameter_ServoNickControl;
279 
                        ToNaviCtrl.Param.Byte[3] = EE_Parameter.ServoNickComp;
 279 
                        ToNaviCtrl.Param.Byte[3] = EE_Parameter.ServoNickComp;
280 
                        ToNaviCtrl.Param.Byte[4] = EE_Parameter.ServoNickMin;
 280 
                        ToNaviCtrl.Param.Byte[4] = EE_Parameter.ServoNickMin;
281 
                        ToNaviCtrl.Param.Byte[5] = EE_Parameter.ServoNickMax;
 281 
                        ToNaviCtrl.Param.Byte[5] = EE_Parameter.ServoNickMax;
282 
                        ToNaviCtrl.Param.Byte[6] = Parameter_ServoRollControl;
 282 
                        ToNaviCtrl.Param.Byte[6] = Parameter_ServoRollControl;
283 
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.ServoRollComp;
 283 
                        ToNaviCtrl.Param.Byte[7] = EE_Parameter.ServoRollComp;
284 
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.ServoRollMin;
 284 
                        ToNaviCtrl.Param.Byte[8] = EE_Parameter.ServoRollMin;
285 
                        ToNaviCtrl.Param.Byte[9] = EE_Parameter.ServoRollMax;
 285 
                        ToNaviCtrl.Param.Byte[9] = EE_Parameter.ServoRollMax;
286 
                        ToNaviCtrl.Param.Byte[10] = Capacity.MinOfMaxPWM;
 286 
                        ToNaviCtrl.Param.Byte[10] = Capacity.MinOfMaxPWM;
287 
                        ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[28]; // I2C-Error counter
 287 
                        ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[28]; // I2C-Error counter
288 
                break;
 288 
                break;
289 
        }
 289 
        }
290 
     
 290 
     
291 
  if(SPI_RxDataValid)
 291 
  if(SPI_RxDataValid)
292 
  {
 292 
  {
293 
        if(FromNaviCtrl.Command != oldcommand) NaviDataOkay = 250;
 293 
        if(FromNaviCtrl.Command != oldcommand) NaviDataOkay = 250;
294 
        oldcommand = FromNaviCtrl.Command;
 294 
        oldcommand = FromNaviCtrl.Command;
295 
        CalculateCompassTimer = 1;
 295 
        CalculateCompassTimer = 1;
296 
        if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))
 296 
        if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))
297 
        {
 297 
        {
298 
                GPS_Nick = FromNaviCtrl.GPS_Nick;
 298 
                GPS_Nick = FromNaviCtrl.GPS_Nick;
299 
                GPS_Roll = FromNaviCtrl.GPS_Roll;
 299 
                GPS_Roll = FromNaviCtrl.GPS_Roll;
300 
        }
 300 
        }
301 
 
 301 
 
302 
        // update compass readings
 302 
        // update compass readings
303 
//      MagVec.x = FromNaviCtrl.MagVecX;
 303 
//      MagVec.x = FromNaviCtrl.MagVecX;
304 
//      MagVec.y = FromNaviCtrl.MagVecY;
 304 
//      MagVec.y = FromNaviCtrl.MagVecY;
305 
//      MagVec.z = FromNaviCtrl.MagVecZ;
 305 
//      MagVec.z = FromNaviCtrl.MagVecZ;
306 
 
 306 
 
307 
        if(FromNaviCtrl.CompassValue <= 360)   KompassValue = FromNaviCtrl.CompassValue;
 307 
        if(FromNaviCtrl.CompassValue <= 360)   KompassValue = FromNaviCtrl.CompassValue;
308 
//    KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
 308 
//    KompassRichtung = ((540 + KompassValue - KompassSollWert) % 360) - 180;
309 
 
 309 
 
310 
    if(FromNaviCtrl.BeepTime > beeptime && !DisableRcOffBeeping) beeptime = FromNaviCtrl.BeepTime;
 310 
    if(FromNaviCtrl.BeepTime > beeptime && !DisableRcOffBeeping) beeptime = FromNaviCtrl.BeepTime;
311 
          switch (FromNaviCtrl.Command)
 311 
          switch (FromNaviCtrl.Command)
312 
          {
 312 
          {
313 
            case SPI_NCCMD_KALMAN:
 313 
            case SPI_NCCMD_KALMAN:
314 
                        FromNaviCtrl_Value.Kalman_K = FromNaviCtrl.Param.sByte[0];
 314 
                        FromNaviCtrl_Value.Kalman_K = FromNaviCtrl.Param.sByte[0];
315 
                        FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.sByte[1];
 315 
                        FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.sByte[1];
316 
                        FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.sByte[2];
 316 
                        FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.sByte[2];
317 
                        KompassFusion = FromNaviCtrl.Param.sByte[3];
 317 
                        KompassFusion = FromNaviCtrl.Param.sByte[3];
318 
                        FromNaviCtrl_Value.GpsZ = FromNaviCtrl.Param.Byte[4];
 318 
                        FromNaviCtrl_Value.GpsZ = FromNaviCtrl.Param.Byte[4];
319 
                        FromNC_Rotate_C = FromNaviCtrl.Param.Byte[5];
 319 
                        FromNC_Rotate_C = FromNaviCtrl.Param.Byte[5];
320 
                        FromNC_Rotate_S = FromNaviCtrl.Param.Byte[6];
 320 
                        FromNC_Rotate_S = FromNaviCtrl.Param.Byte[6];
321 
                        GPS_Aid_StickMultiplikator = FromNaviCtrl.Param.Byte[7];
 321 
                        GPS_Aid_StickMultiplikator = FromNaviCtrl.Param.Byte[7];
322 
                        if(CareFree && FromNaviCtrl.Param.sInt[4] >= 0)
 322 
                        if(CareFree && FromNaviCtrl.Param.sInt[4] >= 0)
323 
                         {
 323 
                         {
324 
                          KompassSollWert = FromNaviCtrl.Param.sInt[4]; // bei Carefree kann NC den Kompass-Sollwinkel vorgeben
 324 
                          KompassSollWert = FromNaviCtrl.Param.sInt[4]; // bei Carefree kann NC den Kompass-Sollwinkel vorgeben
325 
                          if(EE_Parameter.CamOrientation)  // Kamera angle is not front
 325 
                          if(EE_Parameter.CamOrientation)  // Kamera angle is not front
326 
                           {
 326 
                           {
327 
                            KompassSollWert += 360 - ((unsigned int) EE_Parameter.CamOrientation * 15);
 327 
                            KompassSollWert += 360 - ((unsigned int) EE_Parameter.CamOrientation * 15);
328 
                                KompassSollWert %= 360;
 328 
                                KompassSollWert %= 360;
329 
                           }   
 329 
                           }   
330 
                         }
 330 
                         }
331 
                        POI_KameraNick = (POI_KameraNick + FromNaviCtrl.Param.sInt[5]) / 2; // FromNaviCtrl.Param.sInt[5]; // Nickwinkel
 331 
                        POI_KameraNick = (POI_KameraNick + FromNaviCtrl.Param.sInt[5]) / 2; // FromNaviCtrl.Param.sInt[5]; // Nickwinkel
332 
                        break;
 332 
                        break;
333 
                case SPI_NCCMD_VERSION:
 333 
                case SPI_NCCMD_VERSION:
334 
                        NC_Version.Major = FromNaviCtrl.Param.Byte[0];
 334 
                        NC_Version.Major = FromNaviCtrl.Param.Byte[0];
335 
                        NC_Version.Minor = FromNaviCtrl.Param.Byte[1];
 335 
                        NC_Version.Minor = FromNaviCtrl.Param.Byte[1];
336 
                        NC_Version.Patch = FromNaviCtrl.Param.Byte[2];
 336 
                        NC_Version.Patch = FromNaviCtrl.Param.Byte[2];
337 
                        NC_Version.Compatible = FromNaviCtrl.Param.Byte[3];
 337 
                        NC_Version.Compatible = FromNaviCtrl.Param.Byte[3];
338 
                        NC_Version.Hardware = FromNaviCtrl.Param.Byte[4];
 338 
                        NC_Version.Hardware = FromNaviCtrl.Param.Byte[4];
339 
                        DebugOut.Status[0] |= FromNaviCtrl.Param.Byte[5];
 339 
                        DebugOut.Status[0] |= FromNaviCtrl.Param.Byte[5];
340 
                        DebugOut.Status[1] = (DebugOut.Status[1] & (0x01|0x02)) | (FromNaviCtrl.Param.Byte[6] & (0x04 | 0x08));
 340 
                        DebugOut.Status[1] = (DebugOut.Status[1] & (0x01|0x02)) | (FromNaviCtrl.Param.Byte[6] & (0x04 | 0x08));
341 
                        NC_ErrorCode = FromNaviCtrl.Param.Byte[7];
 341 
                        NC_ErrorCode = FromNaviCtrl.Param.Byte[7];
342 
                        NC_GPS_ModeCharacter = FromNaviCtrl.Param.Byte[8];
 342 
                        NC_GPS_ModeCharacter = FromNaviCtrl.Param.Byte[8];
343 
                        FromNaviCtrl_Value.SerialDataOkay = FromNaviCtrl.Param.Byte[9];
 343 
                        FromNaviCtrl_Value.SerialDataOkay = FromNaviCtrl.Param.Byte[9];
344 
                        NC_To_FC_Flags = FromNaviCtrl.Param.Byte[10];
 344 
                        NC_To_FC_Flags = FromNaviCtrl.Param.Byte[10];
345 
                        NC_To_FC_MaxAltitude = FromNaviCtrl.Param.Byte[11];
 345 
                        NC_To_FC_MaxAltitude = FromNaviCtrl.Param.Byte[11];
346 
                        break;
 346 
                        break;
347 
                case SPI_NCCMD_GPSINFO:
 347 
                case SPI_NCCMD_GPSINFO:
348 
                        GPSInfo.Flags = FromNaviCtrl.Param.Byte[0];
 348 
                        GPSInfo.Flags = FromNaviCtrl.Param.Byte[0];
349 
                        GPSInfo.NumOfSats = FromNaviCtrl.Param.Byte[1];
 349 
                        GPSInfo.NumOfSats = FromNaviCtrl.Param.Byte[1];
350 
                        GPSInfo.SatFix = FromNaviCtrl.Param.Byte[2];
 350 
                        GPSInfo.SatFix = FromNaviCtrl.Param.Byte[2];
351 
                        GPSInfo.Speed = FromNaviCtrl.Param.Byte[3];
 351 
                        GPSInfo.Speed = FromNaviCtrl.Param.Byte[3];
352 
                        GPSInfo.HomeDistance = FromNaviCtrl.Param.Int[2];
 352 
                        GPSInfo.HomeDistance = FromNaviCtrl.Param.Int[2];
353 
                        GPSInfo.HomeBearing = FromNaviCtrl.Param.sInt[3];
 353 
                        GPSInfo.HomeBearing = FromNaviCtrl.Param.sInt[3];
354 
                        PPM_in[WP_EVENT_PPM_IN] = (signed char) FromNaviCtrl.Param.Byte[8]; // WP_EVENT-Channel-Value (FromNC_WP_EventChannel)
 354 
                        PPM_in[WP_EVENT_PPM_IN] = (signed char) FromNaviCtrl.Param.Byte[8]; // WP_EVENT-Channel-Value (FromNC_WP_EventChannel)
355 
            FromNC_AltitudeSpeed = FromNaviCtrl.Param.Byte[9];
 355 
            FromNC_AltitudeSpeed = FromNaviCtrl.Param.Byte[9];
356 
                FromNC_AltitudeSetpoint = (long) FromNaviCtrl.Param.sInt[5] * 10;  // in cm
 356 
                FromNC_AltitudeSetpoint = (long) FromNaviCtrl.Param.sInt[5] * 10;  // in cm
357 
                        break;
 357 
                        break;
358 
                case SPI_MISC:
 358 
                case SPI_MISC:
359 
                        EarthMagneticField = FromNaviCtrl.Param.Byte[0];
 359 
                        EarthMagneticField = FromNaviCtrl.Param.Byte[0];
360 
                        EarthMagneticInclination = FromNaviCtrl.Param.Byte[1];
 360 
                        EarthMagneticInclination = FromNaviCtrl.Param.Byte[1];
361 
                        EarthMagneticInclinationTheoretic = FromNaviCtrl.Param.Byte[2];
 361 
                        EarthMagneticInclinationTheoretic = FromNaviCtrl.Param.Byte[2];
362 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
 362 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
363 
                        if(FromNaviCtrl.Param.Byte[3])
 363 
                        if(FromNaviCtrl.Param.Byte[3])
364 
            if(!SpeakHoTT || (SpeakHoTT >= SPEAK_GPS_HOLD && SpeakHoTT <= SPEAK_GPS_OFF)) SpeakHoTT = FromNaviCtrl.Param.Byte[3];
 364 
            if(!SpeakHoTT || (SpeakHoTT >= SPEAK_GPS_HOLD && SpeakHoTT <= SPEAK_GPS_OFF)) SpeakHoTT = FromNaviCtrl.Param.Byte[3];
365 
                        NaviData_WaypointIndex = FromNaviCtrl.Param.Byte[4];
 365 
                        NaviData_WaypointIndex = FromNaviCtrl.Param.Byte[4];
366 
                        NaviData_WaypointNumber = FromNaviCtrl.Param.Byte[5];
 366 
                        NaviData_WaypointNumber = FromNaviCtrl.Param.Byte[5];
367 
                        NaviData_TargetDistance = FromNaviCtrl.Param.Int[3];
 367 
                        NaviData_TargetDistance = FromNaviCtrl.Param.Int[3];
368 
                        NaviData_TargetHoldTime = FromNaviCtrl.Param.Byte[8];
 368 
                        NaviData_TargetHoldTime = FromNaviCtrl.Param.Byte[8];
369 
#endif
 369 
#endif
370 
                        break;    
 370 
                        break;    
371 
 
 371 
 
372 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
 372 
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
373 
                case SPI_NCCMD_HOTT_DATA:
 373 
                case SPI_NCCMD_HOTT_DATA:
374 
                        if(EE_Parameter.Receiver == RECEIVER_HOTT) NC_Fills_HoTT_Telemety();
 374 
                        if(EE_Parameter.Receiver == RECEIVER_HOTT) NC_Fills_HoTT_Telemety();
375 
                        break;
 375 
                        break;
376 
#endif
 376 
#endif
377 
 
 377 
 
378 
// 0 = 0,1
 378 
// 0 = 0,1
379 
// 1 = 2,3
 379 
// 1 = 2,3
380 
// 2 = 4,5
 380 
// 2 = 4,5
381 
// 3 = 6,7
 381 
// 3 = 6,7
382 
// 4 = 8,9
 382 
// 4 = 8,9
383 
// 5 = 10,11
 383 
// 5 = 10,11
384 
                default:
 384 
                default:
385 
                        break;
 385 
                        break;
386 
          }
 386 
          }
387 
  }
 387 
  }
388 
  else
 388 
  else
389 
  {
 389 
  {
390 
//    KompassValue = 0;
 390 
//    KompassValue = 0;
391 
//    KompassRichtung = 0;
 391 
//    KompassRichtung = 0;
392 
        GPS_Nick = 0;
 392 
        GPS_Nick = 0;
393 
    GPS_Roll = 0;
 393 
    GPS_Roll = 0;
394 
  }
 394 
  }
395 
}
 395 
}
396 
 
 396 
 
397 
#endif
 397 
#endif
398 
 
 398 
 
399 
 
 399 
 
400 
 
 400