WebSVN - Projects - Blame - Rev 2231 - /RaspberryPi/ExPlat/FlightCtrl/088n/spi.c

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

Subversion Repositories Projects

(root)/RaspberryPi/ExPlat/FlightCtrl/088n/spi.c - Rev 2231