Subversion Repositories FlightCtrl

Rev

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

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