WebSVN - FlightCtrl - Diff - Rev 717 and 720


// ######################## SPI - FlightCtrl ###################
#include "main.h"
 
 
struct str_ToNaviCtrl_Version   ToNaviCtrl_Version;
struct str_FromNaviCtrl_Version   FromNaviCtrl_Version;
struct str_ToNaviCtrl_Value   ToNaviCtrl_Value;
struct str_FromNaviCtrl_Value   FromNaviCtrl_Value;
 
unsigned char              SPI_BufferIndex;
unsigned char              SPI_RxBufferIndex;
 
volatile unsigned char     SPI_Buffer[sizeof(FromNaviCtrl_Value)];
unsigned char *SPI_TX_Buffer, *ToNaviCtrl_Chksum;
 
unsigned char SPITransferCompleted, SPI_ChkSum;
unsigned char SPI_RxDataValid;
 
#ifdef USE_SPI_COMMUNICATION
 
//------------------------------------------------------
void SPI_MasterInit(void)
{
  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input 
  SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
   
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64 
  SPSR = 0;  // SPI2X
 
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
  SPITransferCompleted = 1;
 
  //SPDR = 0x00;  // dummy write
 
  ToNaviCtrl_Value.Sync1 = 0xAA;
  ToNaviCtrl_Value.Sync2 = 0x83;
 
  ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
  ToNaviCtrl_Value.IntegralNick = 12345;
  ToNaviCtrl_Value.IntegralRoll = 56789;
  ToNaviCtrl_Value.StickNick = 100;
  ToNaviCtrl_Value.StickRoll = 150;//(char) StickRoll;
  ToNaviCtrl_Value.StickGier = 200;//(char) StickGier;
   
  SPI_RxDataValid = 0;
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(unsigned char command)
{
   //if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return;    // transfer of prev. packet not completed
   if (!SPITransferCompleted) return;
   //if (!(SPSR & (1 << SPIF))) return;
   _delay_us(30);
   
   SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
   
   switch(command)
   {
     case SPI_CMD_VERSION: SPI_TX_Buffer  = (unsigned char *) &ToNaviCtrl_Version;
                                                   ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Version.Chksum;
            break;       
       
         case SPI_CMD_VALUE: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Value;
                             ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Value.Chksum;
            break;
 
   }
   
   
   SPITransferCompleted = 0;
   UpdateSPI_Buffer();                              // update buffer
   SPI_BufferIndex = 1;
  //ebugOut.Analog[16]++; 
   // -- Debug-Output ---
   //----
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
   SPDR = ToNaviCtrl_Value.Sync1;                  // Start transmission 
   *ToNaviCtrl_Chksum = ToNaviCtrl_Value.Sync1;
//     SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
}
 
//------------------------------------------------------
//SIGNAL(SIG_SPI)
void SPI_TransmitByte(void)
{
   static unsigned char SPI_RXState = 0;
   unsigned char rxdata;
   static unsigned char rxchksum;
   
   if (SPITransferCompleted) return;
   if (!(SPSR & (1 << SPIF))) return;
   
  _delay_us(30);
   
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
  rxdata = SPDR;
  switch ( SPI_RXState)
  {
  case 0:
           
                        SPI_RxBufferIndex = 0;
                        //DebugOut.Analog[17]++;
                        rxchksum = rxdata;  
                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok 
                       
           break;
 
   case 1:
                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok 
                 else SPI_RXState  = 0;    
                        //DebugOut.Analog[18]++;
           break;      
           
   case 2:
                   SPI_Buffer[SPI_RxBufferIndex++]= rxdata;             // get data
           //DebugOut.Analog[19]++;
           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl_Value))
                   {  
                         
                if (rxdata == rxchksum)
                        {
                  unsigned char *ptr = (unsigned char *)&FromNaviCtrl_Value;
     
                          memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
                         
                          SPI_RxDataValid = 1;
                        }
                        else SPI_RxDataValid = 0;
                       
                        SPI_RXState  = 0;  
                   }
                  else rxchksum += rxdata;
        break;   
         
  }            
 
   if (SPI_BufferIndex < sizeof(ToNaviCtrl_Value))  
     {
           SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           
           SPDR = SPI_TX_Buffer[SPI_BufferIndex];
           *ToNaviCtrl_Chksum += SPI_TX_Buffer[SPI_BufferIndex];
        //   SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
         }
         else SPITransferCompleted = 1;  
       
         SPI_BufferIndex++;
}
 
 
//------------------------------------------------------
void UpdateSPI_Buffer(void)
{
  static unsigned char i =0;
  cli();
  ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
  ToNaviCtrl_Value.IntegralNick = (int) ( IntegralNick / 1024);
  ToNaviCtrl_Value.IntegralRoll = (int) (IntegralRoll / 1024);
  ToNaviCtrl_Value.StickNick = 4;
  ToNaviCtrl_Value.StickRoll = 5;//(char) StickRoll;
  ToNaviCtrl_Value.StickGier = 6;//(char) StickGier;
  ToNaviCtrl_Value.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
  ToNaviCtrl_Value.User1 = Parameter_UserParam1;
  ToNaviCtrl_Value.User2 = Parameter_UserParam2;
  ToNaviCtrl_Value.User3 = Parameter_UserParam3;
  ToNaviCtrl_Value.User4 = Parameter_UserParam4;
  ToNaviCtrl_Value.User5 = Parameter_UserParam5;
  ToNaviCtrl_Value.User6 = Parameter_UserParam6;
  ToNaviCtrl_Value.User7 = Parameter_UserParam7;
  ToNaviCtrl_Value.User8 = Parameter_UserParam8;
  sei();
 
  if (SPI_RxDataValid)
  {
    GPS_Nick = FromNaviCtrl_Value.GPS_Nick;
    GPS_Roll = FromNaviCtrl_Value.GPS_Roll;
    KompassValue = FromNaviCtrl_Value.CompassValue;
    KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
 
    if (FromNaviCtrl_Value.BeepTime != 0) beeptime = FromNaviCtrl_Value.BeepTime;
  }
  else
  {
    KompassValue = 0;
    KompassRichtung = 0;
       
        GPS_Nick = 0;
    GPS_Roll = 0;
  }
}
 
#endif
 
 
 

Rev 717	Rev 720
1	// ######################## SPI - FlightCtrl ###################	1	// ######################## SPI - FlightCtrl ###################
2	#include "main.h"	2	#include "main.h"
3		3
4		4
5	struct str_ToNaviCtrl_Version ToNaviCtrl_Version;	5	struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
6	struct str_FromNaviCtrl_Version FromNaviCtrl_Version;	6	struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
7	struct str_ToNaviCtrl_Value ToNaviCtrl_Value;	7	struct str_ToNaviCtrl_Value ToNaviCtrl_Value;
8	struct str_FromNaviCtrl_Value FromNaviCtrl_Value;	8	struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
9		9
10	unsigned char SPI_BufferIndex;	10	unsigned char SPI_BufferIndex;
11	unsigned char SPI_RxBufferIndex;	11	unsigned char SPI_RxBufferIndex;
12		12
13	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl_Value)];	13	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl_Value)];
14	unsigned char SPI_TX_Buffer, ToNaviCtrl_Chksum;	14	unsigned char SPI_TX_Buffer, ToNaviCtrl_Chksum;
15		15
16	unsigned char SPITransferCompleted, SPI_ChkSum;	16	unsigned char SPITransferCompleted, SPI_ChkSum;
-		17	unsigned char SPI_RxDataValid;
-		18
17	#ifdef USE_SPI_COMMUNICATION	19	#ifdef USE_SPI_COMMUNICATION
18		20
19	//------------------------------------------------------	21	//------------------------------------------------------
20	void SPI_MasterInit(void)	22	void SPI_MasterInit(void)
21	{	23	{
22	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input	24	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input
23	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);	25	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);
24		26
25	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPR0)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64	27	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPR0)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64
26	SPSR = 0; // SPI2X	28	SPSR = 0; // SPI2X
27		29
28	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);	30	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);
29	SPITransferCompleted = 1;	31	SPITransferCompleted = 1;
30		32
31	//SPDR = 0x00; // dummy write	33	//SPDR = 0x00; // dummy write
32		34
33	ToNaviCtrl_Value.Sync1 = 0x81;	35	ToNaviCtrl_Value.Sync1 = 0xAA;
34	ToNaviCtrl_Value.Sync2 = 0x55;	36	ToNaviCtrl_Value.Sync2 = 0x83;
35		37
36	ToNaviCtrl_Value.Command = SPI_CMD_VALUE;	38	ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
37	ToNaviCtrl_Value.IntegralNick = 12345;	39	ToNaviCtrl_Value.IntegralNick = 12345;
38	ToNaviCtrl_Value.IntegralRoll = 56789;	40	ToNaviCtrl_Value.IntegralRoll = 56789;
39	ToNaviCtrl_Value.StickNick = 100;	41	ToNaviCtrl_Value.StickNick = 100;
40	ToNaviCtrl_Value.StickRoll = 150;//(char) StickRoll;	42	ToNaviCtrl_Value.StickRoll = 150;//(char) StickRoll;
41	ToNaviCtrl_Value.StickGier = 200;//(char) StickGier;	43	ToNaviCtrl_Value.StickGier = 200;//(char) StickGier;
42		44
-		45	SPI_RxDataValid = 0;
43	}	46	}
44		47
45	//------------------------------------------------------	48	//------------------------------------------------------
46	void SPI_StartTransmitPacket(unsigned char command)	49	void SPI_StartTransmitPacket(unsigned char command)
47	{	50	{
48	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed	51	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
49	if (!SPITransferCompleted) return;	52	if (!SPITransferCompleted) return;
50	//if (!(SPSR & (1 << SPIF))) return;	53	//if (!(SPSR & (1 << SPIF))) return;
51	_delay_us(30);	54	_delay_us(30);
52		55
53	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	56	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
54		57
55	switch(command)	58	switch(command)
56	{	59	{
57	case SPI_CMD_VERSION: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Version;	60	case SPI_CMD_VERSION: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Version;
58	ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Version.Chksum;	61	ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Version.Chksum;
59	break;	62	break;
60		63
61	case SPI_CMD_VALUE: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Value;	64	case SPI_CMD_VALUE: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Value;
62	ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Value.Chksum;	65	ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Value.Chksum;
63	break;	66	break;
64		67
65	}	68	}
66		69
67		70
68	SPITransferCompleted = 0;	71	SPITransferCompleted = 0;
69	UpdateSPI_Buffer(); // update buffer	72	UpdateSPI_Buffer(); // update buffer
70	SPI_BufferIndex = 1;	73	SPI_BufferIndex = 1;
71	//ebugOut.Analog[16]++;	74	//ebugOut.Analog[16]++;
72	// -- Debug-Output ---	75	// -- Debug-Output ---
73	//----	76	//----
74	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	77	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
75	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	78	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
76	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	79	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
77	SPDR = ToNaviCtrl_Value.Sync1; // Start transmission	80	SPDR = ToNaviCtrl_Value.Sync1; // Start transmission
78	*ToNaviCtrl_Chksum = ToNaviCtrl_Value.Sync1;	81	*ToNaviCtrl_Chksum = ToNaviCtrl_Value.Sync1;
79	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	82	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
80		83
81	}	84	}
82		85
83	//------------------------------------------------------	86	//------------------------------------------------------
84	//SIGNAL(SIG_SPI)	87	//SIGNAL(SIG_SPI)
85	void SPI_TransmitByte(void)	88	void SPI_TransmitByte(void)
86	{	89	{
87	static unsigned char SPI_RXState = 0;	90	static unsigned char SPI_RXState = 0;
88	unsigned char rxdata;	91	unsigned char rxdata;
89	static unsigned char rxchksum;	92	static unsigned char rxchksum;
90		93
91	if (SPITransferCompleted) return;	94	if (SPITransferCompleted) return;
92	if (!(SPSR & (1 << SPIF))) return;	95	if (!(SPSR & (1 << SPIF))) return;
93		96
94	_delay_us(30);	97	_delay_us(30);
95		98
96	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	99	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
97		100
98	rxdata = SPDR;	101	rxdata = SPDR;
99	switch ( SPI_RXState)	102	switch ( SPI_RXState)
100	{	103	{
101	case 0:	104	case 0:
102		105
103	SPI_RxBufferIndex = 0;	106	SPI_RxBufferIndex = 0;
104	//DebugOut.Analog[17]++;	107	//DebugOut.Analog[17]++;
105	rxchksum = rxdata;	108	rxchksum = rxdata;
106	if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok	109	if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok
107		110
108	break;	111	break;
109		112
110	case 1:	113	case 1:
111	if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState = 2; } // 2. Syncbyte ok	114	if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState = 2; } // 2. Syncbyte ok
112	else SPI_RXState = 0;	115	else SPI_RXState = 0;
113	//DebugOut.Analog[18]++;	116	//DebugOut.Analog[18]++;
114	break;	117	break;
115		118
116	case 2:	119	case 2:
117	SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data	120	SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data
118	//DebugOut.Analog[19]++;	121	//DebugOut.Analog[19]++;
119	if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl_Value))	122	if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl_Value))
120	{	123	{
121		124
122	if (rxdata == rxchksum)	125	if (rxdata == rxchksum)
123	{	126	{
124	unsigned char ptr = (unsigned char )&FromNaviCtrl_Value;	127	unsigned char ptr = (unsigned char )&FromNaviCtrl_Value;
125		128
126	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));	129	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
127		130
128	DebugOut.Analog[20]++;	131	SPI_RxDataValid = 1;
129	}	132	}
130	else DebugOut.Analog[21]++;	133	else SPI_RxDataValid = 0;
131		134
132	SPI_RXState = 0;	135	SPI_RXState = 0;
133	}	136	}
134	else rxchksum += rxdata;	137	else rxchksum += rxdata;
135	break;	138	break;
136		139
137	}	140	}
138		141
139	if (SPI_BufferIndex < sizeof(ToNaviCtrl_Value))	142	if (SPI_BufferIndex < sizeof(ToNaviCtrl_Value))
140	{	143	{
141	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	144	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
142	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	145	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
143	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	146	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
144	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	147	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
145		148
146	SPDR = SPI_TX_Buffer[SPI_BufferIndex];	149	SPDR = SPI_TX_Buffer[SPI_BufferIndex];
147	*ToNaviCtrl_Chksum += SPI_TX_Buffer[SPI_BufferIndex];	150	*ToNaviCtrl_Chksum += SPI_TX_Buffer[SPI_BufferIndex];
148	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	151	// SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
149		152
150	}	153	}
151	else SPITransferCompleted = 1;	154	else SPITransferCompleted = 1;
152		155
153	SPI_BufferIndex++;	156	SPI_BufferIndex++;
154	}	157	}
155		158
156		159
157	//------------------------------------------------------	160	//------------------------------------------------------
158	void UpdateSPI_Buffer(void)	161	void UpdateSPI_Buffer(void)
159	{	162	{
160	static unsigned char i =0;	163	static unsigned char i =0;
161	cli();	164	cli();
162	ToNaviCtrl_Value.Command = SPI_CMD_VALUE;	165	ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
163	ToNaviCtrl_Value.IntegralNick = (int) ( IntegralNick / 1024);	166	ToNaviCtrl_Value.IntegralNick = (int) ( IntegralNick / 1024);
164	ToNaviCtrl_Value.IntegralRoll = (int) (IntegralRoll / 1024);	167	ToNaviCtrl_Value.IntegralRoll = (int) (IntegralRoll / 1024);
165	ToNaviCtrl_Value.StickNick = 4;	168	ToNaviCtrl_Value.StickNick = 4;
166	ToNaviCtrl_Value.StickRoll = 5;//(char) StickRoll;	169	ToNaviCtrl_Value.StickRoll = 5;//(char) StickRoll;
167	ToNaviCtrl_Value.StickGier = 6;//(char) StickGier;	170	ToNaviCtrl_Value.StickGier = 6;//(char) StickGier;
168	ToNaviCtrl_Value.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;	171	ToNaviCtrl_Value.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
169	ToNaviCtrl_Value.User1 = EE_Parameter.UserParam1;	172	ToNaviCtrl_Value.User1 = Parameter_UserParam1;
170	ToNaviCtrl_Value.User2 = EE_Parameter.UserParam2;	173	ToNaviCtrl_Value.User2 = Parameter_UserParam2;
171	ToNaviCtrl_Value.User3 = EE_Parameter.UserParam3;	174	ToNaviCtrl_Value.User3 = Parameter_UserParam3;
172	ToNaviCtrl_Value.User4 = EE_Parameter.UserParam4;	175	ToNaviCtrl_Value.User4 = Parameter_UserParam4;
173	ToNaviCtrl_Value.User5 = EE_Parameter.UserParam5;	176	ToNaviCtrl_Value.User5 = Parameter_UserParam5;
174	ToNaviCtrl_Value.User6 = EE_Parameter.UserParam6;	177	ToNaviCtrl_Value.User6 = Parameter_UserParam6;
175	ToNaviCtrl_Value.User7 = EE_Parameter.UserParam7;	178	ToNaviCtrl_Value.User7 = Parameter_UserParam7;
176	ToNaviCtrl_Value.User8 = EE_Parameter.UserParam8;	179	ToNaviCtrl_Value.User8 = Parameter_UserParam8;
177	sei();	180	sei();
-		181
-		182	if (SPI_RxDataValid)
178		183	{
179	DebugOut.Analog[30] = FromNaviCtrl_Value.GPS_Nick;	184	GPS_Nick = FromNaviCtrl_Value.GPS_Nick;
180	DebugOut.Analog[31] = FromNaviCtrl_Value.GPS_Roll;	185	GPS_Roll = FromNaviCtrl_Value.GPS_Roll;
181	KompassValue = FromNaviCtrl_Value.CompassValue;	186	KompassValue = FromNaviCtrl_Value.CompassValue;
-		187	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
-		188
-		189	if (FromNaviCtrl_Value.BeepTime != 0) beeptime = FromNaviCtrl_Value.BeepTime;
-		190	}
-		191	else
-		192	{
-		193	KompassValue = 0;
-		194	KompassRichtung = 0;
-		195
-		196	GPS_Nick = 0;
-		197	GPS_Roll = 0;
182	KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;	198	}
183	}	199	}
184		200
185	#endif	201	#endif
186		202
187		203
188		204

Subversion Repositories FlightCtrl

(root)/tags/V0.73d/spi.c @ 2089 - Rev 717 → 720