Rev 935 | Rev 942 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 935 | Rev 936 | ||
---|---|---|---|
1 | // ######################## SPI - FlightCtrl ################### |
1 | // ######################## SPI - FlightCtrl ################### |
2 | #include <avr/io.h> |
2 | #include <avr/io.h> |
3 | #include <avr/interrupt.h> |
3 | #include <avr/interrupt.h> |
4 | #include <string.h> |
4 | #include <string.h> |
5 | #include <stdlib.h> |
5 | #include <stdlib.h> |
6 | #include "_Settings.h" |
6 | #include "_Settings.h" |
7 | #include "spi.h" |
7 | #include "spi.h" |
8 | #include "fc.h" |
8 | #include "fc.h" |
9 | #include "rc.h" |
9 | #include "rc.h" |
10 | #include "eeprom.h" |
10 | #include "eeprom.h" |
11 | #include "uart.h" |
11 | #include "uart.h" |
12 | #include "timer0.h" |
12 | #include "timer0.h" |
- | 13 | #include "analog.h" |
|
13 | 14 | ||
14 | #define SPI_TXSYNCBYTE1 0xAA |
15 | #define SPI_TXSYNCBYTE1 0xAA |
15 | #define SPI_TXSYNCBYTE2 0x83 |
16 | #define SPI_TXSYNCBYTE2 0x83 |
16 | #define SPI_RXSYNCBYTE1 0x81 |
17 | #define SPI_RXSYNCBYTE1 0x81 |
17 | #define SPI_RXSYNCBYTE2 0x55 |
18 | #define SPI_RXSYNCBYTE2 0x55 |
18 | 19 | ||
19 | typedef enum |
20 | typedef enum |
20 | { |
21 | { |
21 | SPI_SYNC1, |
22 | SPI_SYNC1, |
22 | SPI_SYNC2, |
23 | SPI_SYNC2, |
23 | SPI_DATA |
24 | SPI_DATA |
24 | } SPI_RXState_t; |
25 | } SPI_RXState_t; |
25 | 26 | ||
26 | 27 | ||
27 | // data exchange packets to and From NaviCtrl |
28 | // data exchange packets to and From NaviCtrl |
28 | ToNaviCtrl_t ToNaviCtrl; |
29 | ToNaviCtrl_t ToNaviCtrl; |
29 | FromNaviCtrl_t FromNaviCtrl; |
30 | FromNaviCtrl_t FromNaviCtrl; |
30 | 31 | ||
31 | // rx packet buffer |
32 | // rx packet buffer |
32 | #define SPI_RXBUFFER_LEN sizeof(FromNaviCtrl) |
33 | #define SPI_RXBUFFER_LEN sizeof(FromNaviCtrl) |
33 | uint8_t SPI_RxBuffer[SPI_RXBUFFER_LEN]; |
34 | uint8_t SPI_RxBuffer[SPI_RXBUFFER_LEN]; |
34 | uint8_t SPI_RxBufferIndex = 0; |
35 | uint8_t SPI_RxBufferIndex = 0; |
35 | uint8_t SPI_RxBuffer_Request = 0; |
36 | uint8_t SPI_RxBuffer_Request = 0; |
36 | 37 | ||
37 | // tx packet buffer |
38 | // tx packet buffer |
38 | #define SPI_TXBUFFER_LEN sizeof(ToNaviCtrl) |
39 | #define SPI_TXBUFFER_LEN sizeof(ToNaviCtrl) |
39 | uint8_t *SPI_TxBuffer; |
40 | uint8_t *SPI_TxBuffer; |
40 | uint8_t SPI_TxBufferIndex = 0; |
41 | uint8_t SPI_TxBufferIndex = 0; |
41 | 42 | ||
42 | uint8_t SPITransferCompleted, SPI_ChkSum; |
43 | uint8_t SPITransferCompleted, SPI_ChkSum; |
43 | uint8_t SPI_RxDataValid; |
44 | uint8_t SPI_RxDataValid; |
44 | 45 | ||
45 | uint8_t SPI_CommandSequence[] = { SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_CAL_COMPASS }; |
46 | uint8_t SPI_CommandSequence[] = { SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_PARAMETER1, SPI_CMD_STICK, SPI_CMD_CAL_COMPASS }; |
46 | uint8_t SPI_CommandCounter = 0; |
- | |
47 | - | ||
48 | #ifdef USE_SPI_COMMUNICATION |
47 | uint8_t SPI_CommandCounter = 0; |
49 | 48 | ||
50 | /*********************************************/ |
49 | /*********************************************/ |
51 | /* Initialize SPI interface to NaviCtrl */ |
50 | /* Initialize SPI interface to NaviCtrl */ |
52 | /*********************************************/ |
51 | /*********************************************/ |
53 | void SPI_MasterInit(void) |
52 | void SPI_MasterInit(void) |
54 | { |
53 | { |
55 | DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK); // Set MOSI and SCK output, all others input |
54 | DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK); // Set MOSI and SCK output, all others input |
56 | SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT); // set Slave select port as output port |
55 | SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT); // set Slave select port as output port |
57 | 56 | ||
58 | SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64 |
57 | SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64 |
59 | SPSR = 0;//(1<<SPI2X); |
58 | SPSR = 0;//(1<<SPI2X); |
60 | 59 | ||
61 | SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // Deselect Slave |
60 | SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // Deselect Slave |
62 | 61 | ||
63 | SPI_TxBuffer = (uint8_t *) &ToNaviCtrl; // set pointer to tx-buffer |
62 | SPI_TxBuffer = (uint8_t *) &ToNaviCtrl; // set pointer to tx-buffer |
64 | SPITransferCompleted = 1; |
63 | SPITransferCompleted = 1; |
65 | // initialize data packet to NaviControl |
64 | // initialize data packet to NaviControl |
66 | ToNaviCtrl.Sync1 = SPI_TXSYNCBYTE1; |
65 | ToNaviCtrl.Sync1 = SPI_TXSYNCBYTE1; |
67 | ToNaviCtrl.Sync2 = SPI_TXSYNCBYTE2; |
66 | ToNaviCtrl.Sync2 = SPI_TXSYNCBYTE2; |
68 | 67 | ||
69 | ToNaviCtrl.Command = SPI_CMD_USER; |
68 | ToNaviCtrl.Command = SPI_CMD_USER; |
70 | ToNaviCtrl.IntegralNick = 0; |
69 | ToNaviCtrl.IntegralNick = 0; |
71 | ToNaviCtrl.IntegralRoll = 0; |
70 | ToNaviCtrl.IntegralRoll = 0; |
72 | SPI_RxDataValid = 0; |
71 | SPI_RxDataValid = 0; |
73 | } |
72 | } |
74 | 73 | ||
75 | 74 | ||
76 | /**********************************************************/ |
75 | /**********************************************************/ |
77 | /* Update Data transferd by the SPI from/to NaviCtrl */ |
76 | /* Update Data transferd by the SPI from/to NaviCtrl */ |
78 | /**********************************************************/ |
77 | /**********************************************************/ |
79 | void UpdateSPI_Buffer(void) |
78 | void UpdateSPI_Buffer(void) |
80 | { |
79 | { |
81 | int16_t tmp; |
80 | int16_t tmp; |
82 | cli(); // stop all interrupts to avoid writing of new data during update of that packet. |
81 | cli(); // stop all interrupts to avoid writing of new data during update of that packet. |
83 | 82 | ||
84 | // update content of packet to NaviCtrl |
83 | // update content of packet to NaviCtrl |
85 | ToNaviCtrl.IntegralNick = (int16_t) (IntegralNick / 108); |
84 | ToNaviCtrl.IntegralNick = (int16_t) (IntegralNick / 108); |
86 | ToNaviCtrl.IntegralRoll = (int16_t) (IntegralRoll / 108); |
85 | ToNaviCtrl.IntegralRoll = (int16_t) (IntegralRoll / 108); |
87 | ToNaviCtrl.GyroHeading = YawGyroHeading / YAW_GYRO_DEG_FACTOR; |
86 | ToNaviCtrl.GyroHeading = YawGyroHeading / YAW_GYRO_DEG_FACTOR; |
88 | ToNaviCtrl.GyroNick = Reading_GyroNick; |
87 | ToNaviCtrl.GyroNick = Reading_GyroNick; |
89 | ToNaviCtrl.GyroRoll = Reading_GyroRoll; |
88 | ToNaviCtrl.GyroRoll = Reading_GyroRoll; |
90 | ToNaviCtrl.GyroYaw = Reading_GyroYaw; |
89 | ToNaviCtrl.GyroYaw = Reading_GyroYaw; |
91 | ToNaviCtrl.AccNick = (int16_t) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc); |
90 | ToNaviCtrl.AccNick = (int16_t) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc); |
92 | ToNaviCtrl.AccRoll = (int16_t) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc); |
91 | ToNaviCtrl.AccRoll = (int16_t) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc); |
93 | NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0; |
92 | NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0; |
94 | 93 | ||
95 | switch(ToNaviCtrl.Command) |
94 | switch(ToNaviCtrl.Command) |
96 | { |
95 | { |
97 | case SPI_CMD_USER: |
96 | case SPI_CMD_USER: |
98 | ToNaviCtrl.Param.Byte[0] = FCParam.UserParam1; |
97 | ToNaviCtrl.Param.Byte[0] = FCParam.UserParam1; |
99 | ToNaviCtrl.Param.Byte[1] = FCParam.UserParam2; |
98 | ToNaviCtrl.Param.Byte[1] = FCParam.UserParam2; |
100 | ToNaviCtrl.Param.Byte[2] = FCParam.UserParam3; |
99 | ToNaviCtrl.Param.Byte[2] = FCParam.UserParam3; |
101 | ToNaviCtrl.Param.Byte[3] = FCParam.UserParam4; |
100 | ToNaviCtrl.Param.Byte[3] = FCParam.UserParam4; |
102 | ToNaviCtrl.Param.Byte[4] = FCParam.UserParam5; |
101 | ToNaviCtrl.Param.Byte[4] = FCParam.UserParam5; |
103 | ToNaviCtrl.Param.Byte[5] = FCParam.UserParam6; |
102 | ToNaviCtrl.Param.Byte[5] = FCParam.UserParam6; |
104 | ToNaviCtrl.Param.Byte[6] = FCParam.UserParam7; |
103 | ToNaviCtrl.Param.Byte[6] = FCParam.UserParam7; |
105 | ToNaviCtrl.Param.Byte[7] = FCParam.UserParam8; |
104 | ToNaviCtrl.Param.Byte[7] = FCParam.UserParam8; |
- | 105 | ToNaviCtrl.Param.Byte[8] = MKFlags; |
|
- | 106 | MKFlags &= ~(MKFLAG_CALIBRATE | MKFLAG_START); // calibrate and start are temporal states that are cleared immediately after transmitting |
|
- | 107 | ToNaviCtrl.Param.Byte[9] = (uint8_t)UBat; |
|
- | 108 | ToNaviCtrl.Param.Byte[10] = ParamSet.LowVoltageWarning; |
|
- | 109 | ToNaviCtrl.Param.Byte[11] = GetActiveParamSet(); |
|
- | 110 | break; |
|
- | 111 | ||
- | 112 | case SPI_CMD_PARAMETER1: |
|
- | 113 | ToNaviCtrl.Param.Byte[0] = FCParam.NaviGpsModeControl; // Parameters for the Naviboard |
|
- | 114 | ToNaviCtrl.Param.Byte[1] = FCParam.NaviGpsGain; |
|
- | 115 | ToNaviCtrl.Param.Byte[2] = FCParam.NaviGpsP; |
|
- | 116 | ToNaviCtrl.Param.Byte[3] = FCParam.NaviGpsI; |
|
- | 117 | ToNaviCtrl.Param.Byte[4] = FCParam.NaviGpsD; |
|
- | 118 | ToNaviCtrl.Param.Byte[5] = FCParam.NaviGpsACC; |
|
- | 119 | ToNaviCtrl.Param.Byte[6] = ParamSet.NaviGpsMinSat; |
|
- | 120 | ToNaviCtrl.Param.Byte[7] = ParamSet.NaviStickThreshold; |
|
- | 121 | ToNaviCtrl.Param.Byte[8] = 15; // MaxRadius |
|
106 | break; |
122 | break; |
- | 123 | ||
107 | 124 | ||
108 | case SPI_CMD_STICK: |
125 | case SPI_CMD_STICK: |
109 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_GAS]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
126 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_GAS]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
110 | ToNaviCtrl.Param.Byte[0] = (int8_t) tmp; |
127 | ToNaviCtrl.Param.Byte[0] = (int8_t) tmp; |
111 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_YAW]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
128 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_YAW]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
112 | ToNaviCtrl.Param.Byte[1] = (int8_t) tmp; |
129 | ToNaviCtrl.Param.Byte[1] = (int8_t) tmp; |
113 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
130 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
114 | ToNaviCtrl.Param.Byte[2] = (int8_t) tmp; |
131 | ToNaviCtrl.Param.Byte[2] = (int8_t) tmp; |
115 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
132 | tmp = PPM_in[ParamSet.ChannelAssignment[CH_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -128) tmp = -128; |
116 | ToNaviCtrl.Param.Byte[3] = (int8_t) tmp; |
133 | ToNaviCtrl.Param.Byte[3] = (int8_t) tmp; |
117 | ToNaviCtrl.Param.Byte[4] = (uint8_t) Poti1; |
134 | ToNaviCtrl.Param.Byte[4] = (uint8_t) Poti1; |
118 | ToNaviCtrl.Param.Byte[5] = (uint8_t) Poti2; |
135 | ToNaviCtrl.Param.Byte[5] = (uint8_t) Poti2; |
119 | ToNaviCtrl.Param.Byte[6] = (uint8_t) Poti3; |
136 | ToNaviCtrl.Param.Byte[6] = (uint8_t) Poti3; |
120 | ToNaviCtrl.Param.Byte[7] = (uint8_t) Poti4; |
137 | ToNaviCtrl.Param.Byte[7] = (uint8_t) Poti4; |
121 | ToNaviCtrl.Param.Byte[8] = (uint8_t) RC_Quality; |
138 | ToNaviCtrl.Param.Byte[8] = (uint8_t) RC_Quality; |
122 | ToNaviCtrl.Param.Byte[9] = (uint8_t) MotorsOn; |
- | |
123 | break; |
139 | break; |
124 | 140 | ||
125 | case SPI_CMD_CAL_COMPASS: |
141 | case SPI_CMD_CAL_COMPASS: |
126 | if(CompassCalState > 5) |
142 | if(CompassCalState > 5) |
127 | { |
143 | { |
128 | CompassCalState = 0; |
144 | CompassCalState = 0; |
129 | ToNaviCtrl.Param.Byte[0] = 5; |
145 | ToNaviCtrl.Param.Byte[0] = 5; |
130 | } |
146 | } |
131 | else |
147 | else |
132 | { |
148 | { |
133 | ToNaviCtrl.Param.Byte[0] = CompassCalState; |
149 | ToNaviCtrl.Param.Byte[0] = CompassCalState; |
134 | } |
150 | } |
135 | break; |
151 | break; |
136 | } |
152 | } |
137 | 153 | ||
138 | 154 | ||
139 | sei(); // enable all interrupts |
155 | sei(); // enable all interrupts |
140 | 156 | ||
141 | // analyze content of packet from NaviCtrl if valid |
157 | // analyze content of packet from NaviCtrl if valid |
142 | if (SPI_RxDataValid) |
158 | if (SPI_RxDataValid) |
143 | { |
159 | { |
144 | // update gps controls |
160 | // update gps controls |
145 | if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (ParamSet.GlobalConfig & CFG_GPS_ACTIVE)) |
161 | if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (ParamSet.GlobalConfig & CFG_GPS_ACTIVE)) |
146 | { |
162 | { |
147 | GPS_Nick = FromNaviCtrl.GPS_Nick; |
163 | GPS_Nick = FromNaviCtrl.GPS_Nick; |
148 | GPS_Roll = FromNaviCtrl.GPS_Roll; |
164 | GPS_Roll = FromNaviCtrl.GPS_Roll; |
149 | } |
165 | } |
150 | // update compass readings |
166 | // update compass readings |
151 | if(FromNaviCtrl.CompassHeading <= 360) |
167 | if(FromNaviCtrl.CompassHeading <= 360) |
152 | { |
168 | { |
153 | CompassHeading = FromNaviCtrl.CompassHeading; |
169 | CompassHeading = FromNaviCtrl.CompassHeading; |
154 | } |
170 | } |
155 | if(CompassHeading < 0) CompassOffCourse = 0; |
171 | if(CompassHeading < 0) CompassOffCourse = 0; |
156 | else CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180; |
172 | else CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180; |
157 | // NaviCtrl wants to beep? |
173 | // NaviCtrl wants to beep? |
158 | if (FromNaviCtrl.BeepTime > BeepTime && !CompassCalState) BeepTime = FromNaviCtrl.BeepTime; |
174 | if (FromNaviCtrl.BeepTime > BeepTime && !CompassCalState) BeepTime = FromNaviCtrl.BeepTime; |
159 | 175 | ||
160 | switch (FromNaviCtrl.Command) |
176 | switch (FromNaviCtrl.Command) |
161 | { |
177 | { |
162 | case SPI_CMD_OSD_DATA: |
178 | case SPI_CMD_OSD_DATA: |
163 | // ToFlightCtrl.Param.Byte[0] = OsdBar; |
179 | // ToFlightCtrl.Param.Byte[0] = OsdBar; |
164 | // ToFlightCtrl.Param.Int[1] = Distance; |
180 | // ToFlightCtrl.Param.Int[1] = Distance; |
165 | break; |
181 | break; |
166 | 182 | ||
167 | case SPI_CMD_GPS_POS: |
183 | case SPI_CMD_GPS_POS: |
168 | // ToFlightCtrl.Param.Long[0] = GPS_Data.Longitude; |
184 | // ToFlightCtrl.Param.Long[0] = GPS_Data.Longitude; |
169 | // ToFlightCtrl.Param.Long[1] = GPS_Data.Latitude; |
185 | // ToFlightCtrl.Param.Long[1] = GPS_Data.Latitude; |
170 | break; |
186 | break; |
171 | 187 | ||
172 | case SPI_CMD_GPS_TARGET: |
188 | case SPI_CMD_GPS_TARGET: |
173 | // ToFlightCtrl.Param.Long[0] = GPS_Data.TargetLongitude; |
189 | // ToFlightCtrl.Param.Long[0] = GPS_Data.TargetLongitude; |
174 | // ToFlightCtrl.Param.Long[1] = GPS_Data.TargetLatitude; |
190 | // ToFlightCtrl.Param.Long[1] = GPS_Data.TargetLatitude; |
175 | break; |
191 | break; |
176 | 192 | ||
177 | default: |
193 | default: |
178 | break; |
194 | break; |
179 | } |
195 | } |
180 | } |
196 | } |
181 | else // no valid data from NaviCtrl |
197 | else // no valid data from NaviCtrl |
182 | { |
198 | { |
183 | // disable GPS control |
199 | // disable GPS control |
184 | GPS_Nick = 0; |
200 | GPS_Nick = 0; |
185 | GPS_Roll = 0; |
201 | GPS_Roll = 0; |
186 | } |
202 | } |
187 | } |
203 | } |
188 | 204 | ||
189 | 205 | ||
190 | 206 | ||
191 | /*********************************************/ |
207 | /*********************************************/ |
192 | /* Start Transmission of packet to NaviCtrl */ |
208 | /* Start Transmission of packet to NaviCtrl */ |
193 | /*********************************************/ |
209 | /*********************************************/ |
194 | void SPI_StartTransmitPacket(void) |
210 | void SPI_StartTransmitPacket(void) |
195 | { |
211 | { |
196 | 212 | ||
197 | if (!SPITransferCompleted) return; // return immediately if transfer is in progress |
213 | if (!SPITransferCompleted) return; // return immediately if transfer is in progress |
198 | else // transmission was completed |
214 | else // transmission was completed |
199 | { |
215 | { |
200 | SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // Select slave |
216 | SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // Select slave |
201 | 217 | ||
202 | // cyclic commands |
218 | // cyclic commands |
203 | ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++]; |
219 | ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++]; |
204 | if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0; |
220 | if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0; |
205 | 221 | ||
206 | SPITransferCompleted = 0; // tranfer is in progress |
222 | SPITransferCompleted = 0; // transfer is in progress |
207 | UpdateSPI_Buffer(); // update data in ToNaviCtrl |
223 | UpdateSPI_Buffer(); // update data in ToNaviCtrl |
208 | 224 | ||
209 | SPI_TxBufferIndex = 1; //proceed with 2nd byte |
225 | SPI_TxBufferIndex = 1; //proceed with 2nd byte |
210 | 226 | ||
211 | // -- Debug-Output --- |
227 | // -- Debug-Output --- |
212 | //---- |
228 | //---- |
213 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
229 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
214 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
230 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
215 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
231 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
216 | ToNaviCtrl.Chksum = ToNaviCtrl.Sync1; // init checksum |
232 | ToNaviCtrl.Chksum = ToNaviCtrl.Sync1; // init checksum |
217 | SPDR = ToNaviCtrl.Sync1; // send first byte |
233 | SPDR = ToNaviCtrl.Sync1; // send first byte |
218 | } |
234 | } |
219 | } |
235 | } |
220 | 236 | ||
221 | //------------------------------------------------------ |
237 | //------------------------------------------------------ |
222 | // This is the spi data transfer between FlightCtrl and NaviCtrl |
238 | // This is the spi data transfer between FlightCtrl and NaviCtrl |
223 | // Every time this routine is called within the mainloop one byte of the packet to |
239 | // Every time this routine is called within the mainloop one byte of the packet to |
224 | // the NaviCtrl and one byte of the packet from the NaviCtrl is possible transfered |
240 | // the NaviCtrl and one byte of the packet from the NaviCtrl is possible transfered |
225 | 241 | ||
226 | void SPI_TransmitByte(void) |
242 | void SPI_TransmitByte(void) |
227 | { |
243 | { |
228 | static SPI_RXState_t SPI_RXState = SPI_SYNC1; |
244 | static SPI_RXState_t SPI_RXState = SPI_SYNC1; |
229 | uint8_t rxdata; |
245 | uint8_t rxdata; |
230 | static uint8_t rxchksum; |
246 | static uint8_t rxchksum; |
231 | 247 | ||
232 | if (SPITransferCompleted) return; // return immediatly if transfer was completed |
248 | if (SPITransferCompleted) return; // return immediatly if transfer was completed |
233 | if (!(SPSR & (1 << SPIF))) return; // return if no SPI-IRQ pending |
249 | if (!(SPSR & (1 << SPIF))) return; // return if no SPI-IRQ pending |
234 | SendSPI = 4; // mait 4 * 0.102 ms for the next call of SPI_TransmitByte() in the main loop |
250 | SendSPI = 4; // mait 4 * 0.102 ms for the next call of SPI_TransmitByte() in the main loop |
235 | 251 | ||
236 | SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave |
252 | SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave |
237 | 253 | ||
238 | rxdata = SPDR; // save spi data register |
254 | rxdata = SPDR; // save spi data register |
239 | 255 | ||
240 | switch (SPI_RXState) |
256 | switch (SPI_RXState) |
241 | { |
257 | { |
242 | case SPI_SYNC1: // first sync byte |
258 | case SPI_SYNC1: // first sync byte |
243 | SPI_RxBufferIndex = 0; // set pointer to start of rx buffer |
259 | SPI_RxBufferIndex = 0; // set pointer to start of rx buffer |
244 | rxchksum = rxdata; // initialize checksum |
260 | rxchksum = rxdata; // initialize checksum |
245 | if (rxdata == SPI_RXSYNCBYTE1 ) |
261 | if (rxdata == SPI_RXSYNCBYTE1 ) |
246 | { // 1st Syncbyte found |
262 | { // 1st Syncbyte found |
247 | SPI_RXState = SPI_SYNC2; // trigger to state for second sync byte |
263 | SPI_RXState = SPI_SYNC2; // trigger to state for second sync byte |
248 | } |
264 | } |
249 | break; |
265 | break; |
250 | 266 | ||
251 | case SPI_SYNC2: // second sync byte |
267 | case SPI_SYNC2: // second sync byte |
252 | if (rxdata == SPI_RXSYNCBYTE2) |
268 | if (rxdata == SPI_RXSYNCBYTE2) |
253 | { // 2nd Syncbyte found |
269 | { // 2nd Syncbyte found |
254 | rxchksum += rxdata; // update checksum |
270 | rxchksum += rxdata; // update checksum |
255 | SPI_RXState = SPI_DATA; // trigger to state for second sync byte |
271 | SPI_RXState = SPI_DATA; // trigger to state for second sync byte |
256 | } |
272 | } |
257 | else // 2nd Syncbyte not found |
273 | else // 2nd Syncbyte not found |
258 | { |
274 | { |
259 | SPI_RXState = SPI_SYNC1; // jump back to 1st sync byte |
275 | SPI_RXState = SPI_SYNC1; // jump back to 1st sync byte |
260 | } |
276 | } |
261 | break; |
277 | break; |
262 | 278 | ||
263 | case SPI_DATA: // data bytes |
279 | case SPI_DATA: // data bytes |
264 | SPI_RxBuffer[SPI_RxBufferIndex++] = rxdata; // copy data byte to spi buffer |
280 | SPI_RxBuffer[SPI_RxBufferIndex++] = rxdata; // copy data byte to spi buffer |
265 | // if all bytes are received of a packet from the NaviCtrl |
281 | // if all bytes are received of a packet from the NaviCtrl |
266 | if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) |
282 | if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) |
267 | { // last byte transfered is the checksum of the packet |
283 | { // last byte transfered is the checksum of the packet |
268 | if (rxdata == rxchksum) // checksum matching? |
284 | if (rxdata == rxchksum) // checksum matching? |
269 | { |
285 | { |
270 | // copy SPI_RxBuffer -> FromFlightCtrl |
286 | // copy SPI_RxBuffer -> FromFlightCtrl |
271 | uint8_t *ptr = (uint8_t *)&FromNaviCtrl; |
287 | uint8_t *ptr = (uint8_t *)&FromNaviCtrl; |
272 | cli(); |
288 | cli(); |
273 | memcpy(ptr, (uint8_t *) SPI_RxBuffer, sizeof(FromNaviCtrl)); |
289 | memcpy(ptr, (uint8_t *) SPI_RxBuffer, sizeof(FromNaviCtrl)); |
274 | sei(); |
290 | sei(); |
275 | SPI_RxDataValid = 1; |
291 | SPI_RxDataValid = 1; |
276 | DebugOut.Analog[18]++; |
292 | DebugOut.Analog[18]++; |
277 | } |
293 | } |
278 | else |
294 | else |
279 | { // checksum does not match |
295 | { // checksum does not match |
280 | DebugOut.Analog[17]++; |
296 | DebugOut.Analog[17]++; |
281 | SPI_RxDataValid = 0; // reset valid flag |
297 | SPI_RxDataValid = 0; // reset valid flag |
282 | } |
298 | } |
283 | SPI_RXState = SPI_SYNC1; // reset state sync |
299 | SPI_RXState = SPI_SYNC1; // reset state sync |
284 | } |
300 | } |
285 | else // not all bytes transfered |
301 | else // not all bytes transfered |
286 | { |
302 | { |
287 | rxchksum += rxdata; // update checksum |
303 | rxchksum += rxdata; // update checksum |
288 | } |
304 | } |
289 | break; |
305 | break; |
290 | }// eof switch(SPI_RXState) |
306 | }// eof switch(SPI_RXState) |
291 | 307 | ||
292 | // if still some bytes left for transmission to NaviCtrl |
308 | // if still some bytes left for transmission to NaviCtrl |
293 | if (SPI_TxBufferIndex < SPI_TXBUFFER_LEN) |
309 | if (SPI_TxBufferIndex < SPI_TXBUFFER_LEN) |
294 | { |
310 | { |
295 | SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave |
311 | SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave |
296 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
312 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
297 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
313 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
298 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
314 | asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
299 | 315 | ||
300 | SPDR = SPI_TxBuffer[SPI_TxBufferIndex]; // transmit byte |
316 | SPDR = SPI_TxBuffer[SPI_TxBufferIndex]; // transmit byte |
301 | ToNaviCtrl.Chksum += SPI_TxBuffer[SPI_TxBufferIndex]; // update checksum for everey byte that was sent |
317 | ToNaviCtrl.Chksum += SPI_TxBuffer[SPI_TxBufferIndex]; // update checksum for everey byte that was sent |
302 | SPI_TxBufferIndex++; |
318 | SPI_TxBufferIndex++; |
303 | } |
319 | } |
304 | else |
320 | else |
305 | { |
321 | { |
306 | //Transfer of all bytes of the packet to NaviCtrl completed |
322 | //Transfer of all bytes of the packet to NaviCtrl completed |
307 | SPITransferCompleted = 1; |
323 | SPITransferCompleted = 1; |
308 | } |
324 | } |
309 | } |
325 | } |
310 | 326 | ||
311 | - | ||
312 | #endif //USE_SPI_COMMUNICATION |
- | |
313 | 327 | ||
314 | 328 | ||
315 | 329 |