Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 822 → Rev 823

/trunk/fc.c
1035,8 → 1035,8
DebugOut.Analog[10] = SenderOkay;
DebugOut.Analog[16] = Mittelwert_AccHoch;
 
DebugOut.Analog[17] = FromNaviCtrl_Value.Distance;
DebugOut.Analog[18] = (int)FromNaviCtrl_Value.OsdBar;
//DebugOut.Analog[17] = FromNaviCtrl_Value.Distance;
//DebugOut.Analog[18] = (int)FromNaviCtrl_Value.OsdBar;
DebugOut.Analog[19] = WinkelOut.CalcState;
 
DebugOut.Analog[30] = GPS_Nick;
/trunk/main.c
265,7 → 265,7
}
else SPI_StartTransmitPacket(SPI_CMD_VALUE);//#
*/
SPI_StartTransmitPacket(SPI_CMD_VALUE);//#
SPI_StartTransmitPacket();//#
 
SendSPI = 4;
timer = SetDelay(20);
/trunk/spi.c
2,20 → 2,23
#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;
//struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
//struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
struct str_ToNaviCtrl ToNaviCtrl;
struct str_FromNaviCtrl FromNaviCtrl;
 
unsigned char SPI_BufferIndex;
unsigned char SPI_RxBufferIndex;
 
volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl_Value) + 8];
unsigned char *SPI_TX_Buffer, *ToNaviCtrl_Chksum;
volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl) + 8];
unsigned char *SPI_TX_Buffer;
 
unsigned char SPITransferCompleted, SPI_ChkSum;
unsigned char SPI_RxDataValid;
 
unsigned char SPI_CommandSequence[] = { SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_CAL_COMPASS };
unsigned char SPI_CommandCounter = 0;
 
#ifdef USE_SPI_COMMUNICATION
 
//------------------------------------------------------
32,21 → 35,17
//SPDR = 0x00; // dummy write
ToNaviCtrl_Value.Sync1 = 0xAA;
ToNaviCtrl_Value.Sync2 = 0x83;
ToNaviCtrl.Sync1 = 0xAA;
ToNaviCtrl.Sync2 = 0x83;
ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
ToNaviCtrl_Value.IntegralNick = 0;
ToNaviCtrl_Value.IntegralRoll = 0;
ToNaviCtrl_Value.StickNick = 0;
ToNaviCtrl_Value.StickRoll = 0;//(char) StickRoll;
ToNaviCtrl_Value.StickGier = 0;//(char) StickGier;
ToNaviCtrl_Value.CalState = 0;
ToNaviCtrl.Command = SPI_CMD_USER;
ToNaviCtrl.IntegralNick = 0;
ToNaviCtrl.IntegralRoll = 0;
SPI_RxDataValid = 0;
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(unsigned char command)
void SPI_StartTransmitPacket(void)
{
//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
if (!SPITransferCompleted) return;
53,22 → 52,14
// _delay_us(30);
SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
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;
 
}
ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
SPITransferCompleted = 0;
UpdateSPI_Buffer(); // update buffer
 
SPI_BufferIndex = 1;
//ebugOut.Analog[16]++;
// -- Debug-Output ---
76,8 → 67,8
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;
ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
SPDR = ToNaviCtrl.Sync1; // Start transmission
// SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
 
}
118,12 → 109,12
case 2:
SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data
//DebugOut.Analog[19]++;
if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl_Value))
if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
{
if (rxdata == rxchksum)
{
unsigned char *ptr = (unsigned char *)&FromNaviCtrl_Value;
unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
138,7 → 129,7
}
if (SPI_BufferIndex < sizeof(ToNaviCtrl_Value))
if (SPI_BufferIndex < sizeof(ToNaviCtrl))
{
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");
146,7 → 137,7
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];
ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
// SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
 
}
161,35 → 152,78
{
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 = (char) PPM_in[EE_Parameter.Kanalbelegung[K_NICK]];
ToNaviCtrl_Value.StickRoll = (char) PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]];
ToNaviCtrl_Value.StickGier = (char) PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
ToNaviCtrl_Value.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
ToNaviCtrl_Value.AccNick = (int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc);
ToNaviCtrl_Value.AccRoll = (int) ACC_AMPLIFY * (Mittelwert_AccRoll / NaviCntAcc);
ToNaviCtrl.IntegralNick = (int) (IntegralNick / 1024);
ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / 1024);
ToNaviCtrl.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
ToNaviCtrl.AccNick = (int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc);
ToNaviCtrl.AccRoll = (int) ACC_AMPLIFY * (Mittelwert_AccRoll / NaviCntAcc);
NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
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;
ToNaviCtrl_Value.CalState = WinkelOut.CalcState;
// ToNaviCtrl.User8 = Parameter_UserParam8;
// ToNaviCtrl.CalState = WinkelOut.CalcState;
 
switch(ToNaviCtrl.Command) //
{
case SPI_CMD_USER:
ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
ToNaviCtrl.Param.Byte[3] = Parameter_UserParam4;
ToNaviCtrl.Param.Byte[4] = Parameter_UserParam5;
ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6;
ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7;
break;
 
case SPI_CMD_STICK:
ToNaviCtrl.Param.Byte[0] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];
ToNaviCtrl.Param.Byte[1] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
ToNaviCtrl.Param.Byte[2] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]];
ToNaviCtrl.Param.Byte[3] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_NICK]];
ToNaviCtrl.Param.Byte[4] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]];
ToNaviCtrl.Param.Byte[5] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]];
ToNaviCtrl.Param.Byte[6] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]];
ToNaviCtrl.Param.Byte[7] = (char) PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]];
 
break;
case SPI_CMD_CAL_COMPASS:
ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
break;
}
 
sei();
if (SPI_RxDataValid)
{
GPS_Nick = FromNaviCtrl_Value.GPS_Nick;
GPS_Roll = FromNaviCtrl_Value.GPS_Roll;
KompassValue = FromNaviCtrl_Value.CompassValue;
GPS_Nick = FromNaviCtrl.GPS_Nick;
GPS_Roll = FromNaviCtrl.GPS_Roll;
KompassValue = FromNaviCtrl.CompassValue;
KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
if (FromNaviCtrl_Value.BeepTime > beeptime) beeptime = FromNaviCtrl_Value.BeepTime;
if (FromNaviCtrl.BeepTime > beeptime) beeptime = FromNaviCtrl.BeepTime;
switch (FromNaviCtrl.Command)
{
case SPI_CMD_OSD_DATA:
// ToFlightCtrl.Param.Byte[0] = OsdBar;
// ToFlightCtrl.Param.Int[1] = Distance;
break;
 
case SPI_CMD_GPS_POS:
// ToFlightCtrl.Param.Long[0] = GPS_Data.Longitude;
// ToFlightCtrl.Param.Long[1] = GPS_Data.Latitude;
break;
 
case SPI_CMD_GPS_TARGET:
// ToFlightCtrl.Param.Long[0] = GPS_Data.TargetLongitude;
// ToFlightCtrl.Param.Long[1] = GPS_Data.TargetLatitude;
break;
 
default:
break;
}
}
else
{
/trunk/spi.h
49,7 → 49,11
#define SLAVE_SELECT_PORT PORTC
#define SPI_SLAVE_SELECT PC5
 
struct str_ToNaviCtrl_Value
 
#define SPI_CMD_USER 10
#define SPI_CMD_STICK 11
#define SPI_CMD_CAL_COMPASS 12
struct str_ToNaviCtrl
{
unsigned char Sync1, Sync2;
unsigned char Command;
57,79 → 61,50
signed int IntegralRoll;
signed int AccNick;
signed int AccRoll;
char StickNick,StickRoll, StickGier, StickGas;
signed int GyroCompass;
unsigned char User1, User2, User3, User4, User5, User6, User7;//, User8;
unsigned char CalState;
signed int GyroNick;
signed int GyroRoll;
signed int GyroGier;
union
{ char Byte[12];
int Int[6];
long Long[3];
float Float[3];
} Param;
unsigned char Chksum;
};
 
struct str_ToNaviCtrl_Version
{
unsigned char Sync1, Sync2;
unsigned char Command;
unsigned char HVersion;
unsigned char NVersion;
unsigned char Comp;
unsigned char ActualSettingNo;
unsigned char MinimumSatNo;
unsigned char d1;
signed int d2;
signed int d3;
signed int d4;
signed int d5;
signed int d6;
signed int d7;
unsigned char Chksum;
};
struct str_FromNaviCtrl_Value
#define SPI_CMD_OSD_DATA 100
#define SPI_CMD_GPS_POS 101
#define SPI_CMD_GPS_TARGET 102
struct str_FromNaviCtrl
{
unsigned char Command;
signed int GPS_Nick;
signed int GPS_Roll;
signed int GPS_Gier;
signed int GPS_Height;
signed int CompassValue;
signed int Status;
unsigned char BeepTime;
unsigned char OsdBar;
signed int Distance;
signed int d2;
signed int d3;
signed int d4;
union
{ char Byte[12];
int Int[6];
long Long[3];
float Float[3];
} Param;
unsigned char Chksum;
};
 
struct str_FromNaviCtrl_Version
{
unsigned char Command;
unsigned char HVersion;
unsigned char NVersion;
unsigned char Comp;
unsigned char d0;
signed int d1;
signed int d2;
signed int d3;
signed int d4;
signed int d5;
signed int d6;
signed int d7;
unsigned char Chksum;
};
 
#ifdef USE_SPI_COMMUNICATION
extern struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
extern struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
 
extern struct str_ToNaviCtrl_Value ToNaviCtrl_Value;
extern struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
extern struct str_ToNaviCtrl ToNaviCtrl;
extern struct str_FromNaviCtrl FromNaviCtrl;
 
#define SPI_CMD_VERSION 0x02
#define SPI_CMD_VALUE 0x03
//#define SPI_CMD_VALUE 0x03
 
extern void SPI_MasterInit(void);
extern void SPI_StartTransmitPacket(unsigned char command);
extern void SPI_StartTransmitPacket(void);
extern void UpdateSPI_Buffer(void);
extern void SPI_TransmitByte(void);
#else
/trunk/timer0.h
14,4 → 14,4
extern volatile unsigned int cntKompass;
extern int ServoValue;
extern unsigned int BeepMuster;
extern volatile unsigned char SendSPI;
extern volatile unsigned char SendSPI;