WebSVN - FlightCtrl - Diff - Rev 701 and 898 - /branches/V0.68d CRK HexaLotte/spi.c


// ######################## SPI - FlightCtrl ###################
#include "main.h"
#include "spi.h"
 
 
struct str_ToNaviCtrl      ToNaviCtrl;
struct str_FromNaviCtrl    FromNaviCtrl;
unsigned char              SPI_BufferIndex;
volatile unsigned char     SPI_Buffer[sizeof(FromNaviCtrl)];
unsigned char *Ptr_buffer = (unsigned char *) &ToNaviCtrl;
 
unsigned char SPITransferCompleted, SPI_ChkSum;
#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<<SPIE);   // Enable SPI, Master, set clock rate fck/64
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
  SPITransferCompleted = 1;
 
  ToNaviCtrl.Sync1 = 0x81;
  ToNaviCtrl.Sync2 = 0x55;
 
  ToNaviCtrl.Comp = 12;
  ToNaviCtrl.IntegralPitch = 12345;
  ToNaviCtrl.IntegralRoll = 56789;
  ToNaviCtrl.StickPitch = 100;
  ToNaviCtrl.StickRoll = 150;//(char) StickRoll;
  ToNaviCtrl.StickYaw = 200;//(char) StickYaw;
 
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(void)
{
   //if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return;    // transfer of prev. packet not completed
   if (!SPITransferCompleted) return;
 
   SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
 
   SPITransferCompleted = 0;
   UpdateSPI_Buffer();                              // update buffer
   SPI_BufferIndex = 1;
   // DebugOut.Analog[16]++;
   // -- Debug-Output ---
/*         DebugOut.Analog[20] = FromNaviCtrl.Comp;
       DebugOut.Analog[21] = FromNaviCtrl.GPS_Pitch;
       DebugOut.Analog[22] = FromNaviCtrl.GPS_Roll;
       DebugOut.Analog[23] = FromNaviCtrl.CompassHeading;
*/
   //----
   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
   ToNaviCtrl.ChkSum = ToNaviCtrl.Sync1;
}
 
//------------------------------------------------------
//SIGNAL(SIG_SPI)
void SPI_TransmitByte(void)
{
   if (!(SPSR & (1 << SPIF))) return;
  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 
          if (SPI_BufferIndex < sizeof(FromNaviCtrl))
      {
            SPI_Buffer[SPI_BufferIndex]= SPDR;             // get data
 
//              if (SPI_BufferIndex < 32 ) DebugOut.Analog[26+SPI_BufferIndex] = SPI_Buffer[SPI_BufferIndex];
 
        //if(SPDR!= 0x00) DebugOut.Analog[19]++; ;
          }
 
   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
     {
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
           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");
 
           SPDR = Ptr_buffer[SPI_BufferIndex];
           ToNaviCtrl.ChkSum += Ptr_buffer[SPI_BufferIndex];
         }
   else
     {
           unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
 
       SPITransferCompleted = 1;
       memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
         }
 
         SPI_BufferIndex++;
}
 
//------------------------------------------------------
void UpdateSPI_Buffer(void)
{
  /*static unsigned char i =0;
  cli();
  ToNaviCtrl.Comp = SPI_PROTOCOL_COMP;
  ToNaviCtrl.IntegralPitch = (int) (IntegralPitch >> 4);
  ToNaviCtrl.IntegralRoll = (int) (IntegralRoll >> 4);
  ToNaviCtrl.StickPitch = 4;
  ToNaviCtrl.StickRoll = 5;//(char) StickRoll;
  ToNaviCtrl.StickYaw = 6;//(char) StickYaw;
  sei();
  */
}
 
#endif
 
 
 

Subversion Repositories FlightCtrl

(root)/branches/V0.68d CRK HexaLotte/spi.c @ 1194 - Rev 701 → 898

Rev 701		Rev 898
1	// ######################## SPI - FlightCtrl ###################	1	// ######################## SPI - FlightCtrl ###################
2	#include "main.h"	2	#include "main.h"
3	#include "spi.h"	3	#include "spi.h"
4		4
5		5
6	struct str_ToNaviCtrl ToNaviCtrl;	6	struct str_ToNaviCtrl ToNaviCtrl;
7	struct str_FromNaviCtrl FromNaviCtrl;	7	struct str_FromNaviCtrl FromNaviCtrl;
8	unsigned char SPI_BufferIndex;	8	unsigned char SPI_BufferIndex;
9	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl)];	9	volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl)];
10	unsigned char Ptr_buffer = (unsigned char ) &ToNaviCtrl;	10	unsigned char Ptr_buffer = (unsigned char ) &ToNaviCtrl;
11		11
12	unsigned char SPITransferCompleted, SPI_ChkSum;	12	unsigned char SPITransferCompleted, SPI_ChkSum;
13	#ifdef USE_SPI_COMMUNICATION	13	#ifdef USE_SPI_COMMUNICATION
14	//------------------------------------------------------	14	//------------------------------------------------------
15	void SPI_MasterInit(void)	15	void SPI_MasterInit(void)
16	{	16	{
17	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input	17	DDR_SPI \|= (1<<DD_MOSI)\|(1<<DD_SCK); // Set MOSI and SCK output, all others input
18	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);	18	SLAVE_SELECT_DDR_PORT \|= (1 << SPI_SLAVE_SELECT);
19		19
20	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64	20	SPCR = (1<<SPE)\|(1<<MSTR)\|(1<<SPR1)\|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64
21	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);	21	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT);
22	SPITransferCompleted = 1;	22	SPITransferCompleted = 1;
23		23
24	ToNaviCtrl.Sync1 = 0x81;	24	ToNaviCtrl.Sync1 = 0x81;
25	ToNaviCtrl.Sync2 = 0x55;	25	ToNaviCtrl.Sync2 = 0x55;
26		26
27	ToNaviCtrl.Comp = 12;	27	ToNaviCtrl.Comp = 12;
28	ToNaviCtrl.IntegralPitch = 12345;	28	ToNaviCtrl.IntegralPitch = 12345;
29	ToNaviCtrl.IntegralRoll = 56789;	29	ToNaviCtrl.IntegralRoll = 56789;
30	ToNaviCtrl.StickPitch = 100;	30	ToNaviCtrl.StickPitch = 100;
31	ToNaviCtrl.StickRoll = 150;//(char) StickRoll;	31	ToNaviCtrl.StickRoll = 150;//(char) StickRoll;
32	ToNaviCtrl.StickYaw = 200;//(char) StickYaw;	32	ToNaviCtrl.StickYaw = 200;//(char) StickYaw;
33		33
34	}	34	}
35		35
36	//------------------------------------------------------	36	//------------------------------------------------------
37	void SPI_StartTransmitPacket(void)	37	void SPI_StartTransmitPacket(void)
38	{	38	{
39	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed	39	//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
40	if (!SPITransferCompleted) return;	40	if (!SPITransferCompleted) return;
41		41
42	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	42	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
43		43
44	SPITransferCompleted = 0;	44	SPITransferCompleted = 0;
45	UpdateSPI_Buffer(); // update buffer	45	UpdateSPI_Buffer(); // update buffer
46	SPI_BufferIndex = 1;	46	SPI_BufferIndex = 1;
47	DebugOut.Analog[16]++;	47	// DebugOut.Analog[16]++;
48	// -- Debug-Output ---	48	// -- Debug-Output ---
49	/* DebugOut.Analog[20] = FromNaviCtrl.Comp;	49	/* DebugOut.Analog[20] = FromNaviCtrl.Comp;
50	DebugOut.Analog[21] = FromNaviCtrl.GPS_Pitch;	50	DebugOut.Analog[21] = FromNaviCtrl.GPS_Pitch;
51	DebugOut.Analog[22] = FromNaviCtrl.GPS_Roll;	51	DebugOut.Analog[22] = FromNaviCtrl.GPS_Roll;
52	DebugOut.Analog[23] = FromNaviCtrl.CompassHeading;	52	DebugOut.Analog[23] = FromNaviCtrl.CompassHeading;
53	*/	53	*/
54	//----	54	//----
55	SPDR = ToNaviCtrl.Sync1; // Start transmission	55	SPDR = ToNaviCtrl.Sync1; // Start transmission
56	ToNaviCtrl.ChkSum = ToNaviCtrl.Sync1;	56	ToNaviCtrl.ChkSum = ToNaviCtrl.Sync1;
57	}	57	}
58		58
59	//------------------------------------------------------	59	//------------------------------------------------------
60	//SIGNAL(SIG_SPI)	60	//SIGNAL(SIG_SPI)
61	void SPI_TransmitByte(void)	61	void SPI_TransmitByte(void)
62	{	62	{
63	if (!(SPSR & (1 << SPIF))) return;	63	if (!(SPSR & (1 << SPIF))) return;
64	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave	64	SLAVE_SELECT_PORT \|= (1 << SPI_SLAVE_SELECT); // DeselectSlave
65		65
66	if (SPI_BufferIndex < sizeof(FromNaviCtrl))	66	if (SPI_BufferIndex < sizeof(FromNaviCtrl))
67	{	67	{
68	SPI_Buffer[SPI_BufferIndex]= SPDR; // get data	68	SPI_Buffer[SPI_BufferIndex]= SPDR; // get data
69		69
70	// if (SPI_BufferIndex < 32 ) DebugOut.Analog[26+SPI_BufferIndex] = SPI_Buffer[SPI_BufferIndex];	70	// if (SPI_BufferIndex < 32 ) DebugOut.Analog[26+SPI_BufferIndex] = SPI_Buffer[SPI_BufferIndex];
71		71
72	//if(SPDR!= 0x00) DebugOut.Analog[19]++; ;	72	//if(SPDR!= 0x00) DebugOut.Analog[19]++; ;
73	}	73	}
74		74
75	if (SPI_BufferIndex < sizeof(ToNaviCtrl))	75	if (SPI_BufferIndex < sizeof(ToNaviCtrl))
76	{	76	{
77	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");
78	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");
79	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave	79	SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
80	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	80	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
81	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");	81	asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
82		82
83	SPDR = Ptr_buffer[SPI_BufferIndex];	83	SPDR = Ptr_buffer[SPI_BufferIndex];
84	ToNaviCtrl.ChkSum += Ptr_buffer[SPI_BufferIndex];	84	ToNaviCtrl.ChkSum += Ptr_buffer[SPI_BufferIndex];
85	}	85	}
86	else	86	else
87	{	87	{
88	unsigned char ptr = (unsigned char )&FromNaviCtrl;	88	unsigned char ptr = (unsigned char )&FromNaviCtrl;
89		89
90	SPITransferCompleted = 1;	90	SPITransferCompleted = 1;
91	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));	91	memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
92	}	92	}
93		93
94	SPI_BufferIndex++;	94	SPI_BufferIndex++;
95	}	95	}
96		96
97	//------------------------------------------------------	97	//------------------------------------------------------
98	void UpdateSPI_Buffer(void)	98	void UpdateSPI_Buffer(void)
99	{	99	{
100	/*static unsigned char i =0;	100	/*static unsigned char i =0;
101	cli();	101	cli();
102	ToNaviCtrl.Comp = SPI_PROTOCOL_COMP;	102	ToNaviCtrl.Comp = SPI_PROTOCOL_COMP;
103	ToNaviCtrl.IntegralPitch = (int) (IntegralPitch >> 4);	103	ToNaviCtrl.IntegralPitch = (int) (IntegralPitch >> 4);
104	ToNaviCtrl.IntegralRoll = (int) (IntegralRoll >> 4);	104	ToNaviCtrl.IntegralRoll = (int) (IntegralRoll >> 4);
105	ToNaviCtrl.StickPitch = 4;	105	ToNaviCtrl.StickPitch = 4;
106	ToNaviCtrl.StickRoll = 5;//(char) StickRoll;	106	ToNaviCtrl.StickRoll = 5;//(char) StickRoll;
107	ToNaviCtrl.StickYaw = 6;//(char) StickYaw;	107	ToNaviCtrl.StickYaw = 6;//(char) StickYaw;
108	sei();	108	sei();
109	*/	109	*/
110	}	110	}
111		111
112	#endif	112	#endif
113		113
114		114
115		115