Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1619 → Rev 1620

/beta/Code Redesign killagreg/eeprom.c
76,6 → 76,30
MixerTable_t Mixer;
 
 
uint8_t RAM_Checksum(uint8_t* pBuffer, uint16_t len)
{
uint8_t crc = 0xAA;
uint16_t i;
 
for(i=0; i<len; i++)
{
crc += pBuffer[i];
}
return crc;
}
 
uint8_t EEProm_Checksum(uint16_t EEAddr, uint16_t len)
{
uint8_t crc = 0xAA;
uint16_t off;
 
for(off=0; off<len; off++)
{
crc += eeprom_read_byte((uint8_t*)(EEAddr + off));;
}
return crc;
}
 
void ParamSet_DefaultStickMapping(void)
{
ParamSet.ChannelAssignment[CH_GAS] = 1;
98,6 → 122,7
/***************************************************/
void ParamSet_DefaultSet1(void) // sport
{
ParamSet.Revision = EEPARAM_REVISION;
if(BoardRelease >= 20)
{
ParamSet.GyroD = 5;
193,6 → 218,7
ParamSet.NaviAngleLimitation = 100;
ParamSet.NaviPHLoginTime = 4;
memcpy(ParamSet.Name, "Sport\0",6);
ParamSet.crc = RAM_Checksum((uint8_t*)(&ParamSet), sizeof(ParamSet)-1);
}
 
 
201,6 → 227,7
/***************************************************/
void ParamSet_DefaultSet2(void) // normal
{
ParamSet.Revision = EEPARAM_REVISION;
if(BoardRelease >= 20)
{
ParamSet.GyroD = 5;
296,6 → 323,7
ParamSet.NaviAngleLimitation = 100;
ParamSet.NaviPHLoginTime = 4;
memcpy(ParamSet.Name, "Normal\0", 7);
ParamSet.crc = RAM_Checksum((uint8_t*)(&ParamSet), sizeof(ParamSet)-1);
}
 
 
304,6 → 332,7
/***************************************************/
void ParamSet_DefaultSet3(void) // beginner
{
ParamSet.Revision = EEPARAM_REVISION;
if(BoardRelease >= 20)
{
ParamSet.GyroD = 5;
399,6 → 428,7
ParamSet.NaviAngleLimitation = 100;
ParamSet.NaviPHLoginTime = 4;
memcpy(ParamSet.Name, "Beginner\0", 9);
ParamSet.crc = RAM_Checksum((uint8_t*)(&ParamSet), sizeof(ParamSet)-1);
}
 
/***************************************************/
437,11 → 467,30
/* Read Parameter Set from EEPROM */
/***************************************************/
// number [1..5]
void ParamSet_ReadFromEEProm(uint8_t setnumber)
uint8_t ParamSet_ReadFromEEProm(uint8_t setnumber)
{
uint8_t crc;
uint16_t eeaddr;
 
// range the setnumber
if((1 > setnumber) || (setnumber > 5)) setnumber = 3;
eeprom_read_block((void *) &ParamSet.ChannelAssignment[0], (void*)(EEPROM_ADR_PARAMSET_BEGIN + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN);
 
// calculate eeprom addr
eeaddr = EEPROM_ADR_PARAMSET + PARAMSET_STRUCT_LEN * (setnumber - 1);
 
// calculate checksum from eeprom
crc = EEProm_Checksum(eeaddr, PARAMSET_STRUCT_LEN - 1);
 
// check crc
if(crc != eeprom_read_byte((uint8_t*)(eeaddr + PARAMSET_STRUCT_LEN - 1))) return 0;
 
// check revision
if(eeprom_read_byte((uint8_t*)(eeaddr)) != EEPARAM_REVISION) return 0;
 
// read paramset from eeprom
eeprom_read_block((void *) &ParamSet, (void*)(EEPROM_ADR_PARAMSET + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN);
LED_Init();
return 1;
}
 
/***************************************************/
448,16 → 497,35
/* Write Parameter Set to EEPROM */
/***************************************************/
// number [1..5]
void ParamSet_WriteToEEProm(uint8_t setnumber)
uint8_t ParamSet_WriteToEEProm(uint8_t setnumber)
{
if(setnumber > 5) setnumber = 5;
if(setnumber < 1) return;
eeprom_write_block((void *) &ParamSet.ChannelAssignment[0], (void*)(EEPROM_ADR_PARAMSET_BEGIN + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN);
eeprom_write_word((uint16_t *)(EEPROM_ADR_PARAMSET_LENGTH), PARAMSET_STRUCT_LEN);
eeprom_write_block( (void*)(&ParamSet.ChannelAssignment[0]), (void*)(EEPROM_ADR_CHANNELS), 12); // backup the first 12 bytes that is the rc channel mapping
// set this parameter set to active set
SetActiveParamSet(setnumber);
LED_Init();
uint8_t crc;
 
if(ParamSet.Revision == EEPARAM_REVISION) // write only the right revision to eeprom
{
if(setnumber > 5) setnumber = 5;
if(setnumber < 1) return 0;
 
// update checksum
ParamSet.crc = RAM_Checksum((uint8_t*)(&ParamSet), sizeof(ParamSet)-1);
 
// write paramset to eeprom
eeprom_write_block((void *) &ParamSet, (void*)(EEPROM_ADR_PARAMSET + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN);
 
// backup channel settings to separate block in eeprom
eeprom_write_block( (void*)(ParamSet.ChannelAssignment), (void*)(EEPROM_ADR_CHANNELS), sizeof(ParamSet.ChannelAssignment));
 
// write crc of channel block to eeprom
crc = RAM_Checksum((uint8_t*)(ParamSet.ChannelAssignment), sizeof(ParamSet.ChannelAssignment));
eeprom_write_byte((uint8_t*)(EEPROM_ADR_CHANNELS + sizeof(ParamSet.ChannelAssignment)), crc);
 
// update active settings number
SetActiveParamSet(setnumber);
LED_Init();
return 1;
}
// wrong revision
return 0;
}
 
/***************************************************/
465,12 → 533,20
/***************************************************/
uint8_t MixerTable_ReadFromEEProm(void)
{
if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXER_TABLE)) == EEMIXER_REVISION)
{
eeprom_read_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXER_TABLE), sizeof(Mixer));
return 1;
}
else return 0;
uint8_t crc;
 
// calculate checksum in eeprom
crc = EEProm_Checksum(EEPROM_ADR_MIXERTABLE, sizeof(Mixer) - 1);
 
// check crc
if( crc != eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE + sizeof(Mixer) - 1)) ) return 0;
 
// check revision
if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE)) != EEMIXER_REVISION) return 0;
 
// read mixer table
eeprom_read_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXERTABLE), sizeof(Mixer));
return 1;
}
 
/***************************************************/
480,7 → 556,11
{
if(Mixer.Revision == EEMIXER_REVISION)
{
eeprom_write_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXER_TABLE), sizeof(Mixer));
// update crc
Mixer.crc = RAM_Checksum((uint8_t*)(&Mixer), sizeof(Mixer) - 1);
 
// write to eeprom
eeprom_write_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXERTABLE), sizeof(Mixer));
return 1;
}
else return 0;
508,6 → 588,7
Mixer.Motor[2][MIX_GAS] = 64; Mixer.Motor[2][MIX_NICK] = 0; Mixer.Motor[2][MIX_ROLL] = -64; Mixer.Motor[2][MIX_YAW] = -64;
Mixer.Motor[3][MIX_GAS] = 64; Mixer.Motor[3][MIX_NICK] = 0; Mixer.Motor[3][MIX_ROLL] = +64; Mixer.Motor[3][MIX_YAW] = -64;
memcpy(Mixer.Name, "Quadro\0", 7);
Mixer.crc = Mixer.crc = RAM_Checksum((uint8_t*)(&Mixer), sizeof(Mixer) - 1);
}
 
 
541,26 → 622,30
/***************************************************/
void ParamSet_Init(void)
{
uint8_t Channel_Backup = 0, i;
uint8_t channel_backup = 0, bad_params = 0, ee_default = 0,i;
 
// parameter version check
if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_PARAM_BEGIN + PID_PARAM_REVISION)) != EEPARAM_REVISION)
 
if(EEPARAM_REVISION != GetParamByte(PID_EE_REVISION) )
{
// if version check faild
printf("\n\rInit Parameter in EEPROM");
eeprom_write_byte((uint8_t*)(EEPROM_ADR_MIXER_TABLE), 0xFF); // reset also mixer table
// check if channel mapping backup is valid
if( (eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+0)) < 12)
&& (eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+1)) < 12)
&& (eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+2)) < 12)
&& (eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+3)) < 12)
)
ee_default = 1; // software update or forced by mktool
SetParamByte(PID_EE_REVISION, EEPARAM_REVISION);
}
 
 
// 1st check for a valid channel backup in eeprom
i = EEProm_Checksum(EEPROM_ADR_CHANNELS, sizeof(ParamSet.ChannelAssignment));
if(i == eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS + sizeof(ParamSet.ChannelAssignment))) ) channel_backup = 1;
 
 
// parameter check
 
// check all 5 parameter settings
for (i = 1;i < 6; i++)
{
if(ee_default || !ParamSet_ReadFromEEProm(i)) // could not read paramset from eeprom
{
Channel_Backup = 1;
}
// fill all 5 parameter settings
for (i = 1;i < 6; i++)
{
bad_params = 1;
printf("\n\rGenerating default Parameter Set %d",i);
switch(i)
{
case 1:
576,49 → 661,30
ParamSet_DefaultSet2(); // Kamera
break;
}
if(Channel_Backup) // if we have a rc channel mapping backup in eeprom
{
// restore it
ParamSet.ChannelAssignment[0] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+0));
ParamSet.ChannelAssignment[1] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+1));
ParamSet.ChannelAssignment[2] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+2));
ParamSet.ChannelAssignment[3] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+3));
ParamSet.ChannelAssignment[4] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+4));
ParamSet.ChannelAssignment[5] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+5));
ParamSet.ChannelAssignment[6] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+6));
ParamSet.ChannelAssignment[7] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+7));
if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+8)) < 255)
{
ParamSet.ChannelAssignment[8] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+8));
ParamSet.ChannelAssignment[9] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+9));
ParamSet.ChannelAssignment[10] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+10));
ParamSet.ChannelAssignment[11] = eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS+11));
}
else
{
ParamSet.ChannelAssignment[8] = 9;
ParamSet.ChannelAssignment[9] = 10;
ParamSet.ChannelAssignment[10] = 11;
ParamSet.ChannelAssignment[11] = 12;
}
if(channel_backup) // if we have an channel mapping backup in eeprom
{ // restore it from eeprom
eeprom_read_block((void *)ParamSet.ChannelAssignment, (void*)(EEPROM_ADR_CHANNELS), sizeof(ParamSet.ChannelAssignment));
}
else
{
{ // use default mapping
ParamSet_DefaultStickMapping();
}
ParamSet_WriteToEEProm(i);
}
}
if(bad_params) // at least one of the parameter settings were invalid
{
// default-Setting is parameter set 3
SetActiveParamSet(3);
// update version info
SetParamByte(PID_PARAM_REVISION, EEPARAM_REVISION);
}
 
 
// read active parameter set to ParamSet stucture
ParamSet_ReadFromEEProm(GetActiveParamSet());
printf("\n\rUsing Parameter Set %d", GetActiveParamSet());
 
// load mixer table
if(!MixerTable_ReadFromEEProm() )
if(ee_default || !MixerTable_ReadFromEEProm() )
{
printf("\n\rGenerating default Mixer Table");
MixerTable_Default(); // Quadro
/beta/Code Redesign killagreg/eeprom.h
4,7 → 4,7
#include <inttypes.h>
 
#define EEPROM_ADR_PARAM_BEGIN 0
#define PID_PARAM_REVISION 1 // byte
#define PID_EE_REVISION 1 // byte
#define PID_ACTIVE_SET 2 // byte
#define PID_PRESSURE_OFFSET 3 // byte
 
15,15 → 15,11
#define PID_FLIGHT_MINUTES_TOTAL 10 // word
#define PID_FLIGHT_MINUTES 14 // word
 
#define EEPROM_ADR_CHANNELS 80 // 12 bytes
#define EEPROM_ADR_CHANNELS 80 // 12 bytes + 1crc
#define EEPROM_ADR_PARAMSET 100
#define EEPROM_ADR_MIXERTABLE 1000 // 1000 - 1077
 
#define EEPROM_ADR_PARAMSET_LENGTH 98 // word
#define EEPROM_ADR_PARAMSET_BEGIN 100
 
 
#define EEPROM_ADR_MIXER_TABLE 1000 // 1000 - 1076
 
 
#define MIX_GAS 0
#define MIX_NICK 1
#define MIX_ROLL 2
34,6 → 30,7
uint8_t Revision;
int8_t Name[12];
int8_t Motor[16][4];
uint8_t crc;
} __attribute__((packed)) MixerTable_t;
 
extern MixerTable_t Mixer;
108,6 → 105,7
 
typedef struct
{
uint8_t Revision; // revision of the param struct
uint8_t ChannelAssignment[12]; // see upper defines for details
uint8_t Config0; // see upper defines for bitcoding
uint8_t HeightMinGas; // Value : 0-100
199,6 → 197,7
uint8_t ServoCompInvert; // Bitfield: 0x01 = Nick invert, 0x02 = Roll invert // WICHTIG!!! am Ende lassen
uint8_t Config2; // see upper defines for bitcoding
int8_t Name[12];
uint8_t crc; // must be the last byte!
} paramset_t;
 
#define PARAMSET_STRUCT_LEN sizeof(paramset_t)
206,8 → 205,9
extern paramset_t ParamSet;
 
extern void ParamSet_Init(void);
extern void ParamSet_ReadFromEEProm(uint8_t setnumber);
extern void ParamSet_WriteToEEProm(uint8_t setnumber);
extern uint8_t ParamSet_ReadFromEEProm(uint8_t setnumber);
extern uint8_t ParamSet_WriteToEEProm(uint8_t setnumber);
 
extern uint8_t GetActiveParamSet(void);
extern void SetActiveParamSet(uint8_t setnumber);
 
/beta/Code Redesign killagreg/fc.c
691,11 → 691,13
static uint16_t RcLostTimer;
static uint8_t delay_neutral = 0, delay_startmotors = 0, delay_stopmotors = 0;
static uint16_t UpdateCompassCourse = 0;
static uint8_t Calibration_Done = 0;
// high resolution motor values for smoothing of PID motor outputs
static int16_t MotorValue[MAX_MOTORS];
 
Mean();
GRN_ON;
DebugOut.Analog[16] = Calibration_Done;
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// RC-signal is bad
823,6 → 825,7
LIBFC_ReceiverInit();
Servo_Off(); // disable servo output
SetNeutral(NO_ACC_CALIB);
Calibration_Done = 1;
Servo_On(); // enable servo output
Beep(GetActiveParamSet(), 120);
}
850,6 → 853,7
ParamSet_ReadFromEEProm(GetActiveParamSet());
Servo_Off(); // disable servo output
SetNeutral(NO_ACC_CALIB);
Calibration_Done = 1;
Servo_On(); // enable servo output
Beep(GetActiveParamSet(), 120);
}
859,6 → 863,7
ParamSet_ReadFromEEProm(GetActiveParamSet());
Servo_Off(); // disable servo output
SetNeutral(NO_ACC_CALIB);
Calibration_Done = 1;
Servo_On(); // enable servo output
Beep(GetActiveParamSet(), 120);
}
884,6 → 889,7
ModelIsFlying = 0;
Servo_Off(); // disable servo output
SetNeutral(ACC_CALIB);
Calibration_Done = 1;
Servo_On(); // enable servo output
Beep(GetActiveParamSet(), 120);
}
911,16 → 917,23
if(++delay_startmotors > 200) // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)
{
delay_startmotors = 0;
ModelIsFlying = 1;
FCFlags |= (FCFLAG_MOTOR_RUN|FCFLAG_START); // set flag RUN and START
SetPointYaw = 0;
ReadingIntegralGyroYaw = 0;
ReadingIntegralGyroNick = ParamSet.GyroAccFactor * (int32_t)AccNick;
ReadingIntegralGyroRoll = ParamSet.GyroAccFactor * (int32_t)AccRoll;
ReadingIntegralGyroNick2 = IntegralGyroNick;
ReadingIntegralGyroRoll2 = IntegralGyroRoll;
IPartNick = 0;
IPartRoll = 0;
if(Calibration_Done)
{
ModelIsFlying = 1;
FCFlags |= (FCFLAG_MOTOR_RUN|FCFLAG_START); // set flag RUN and START
SetPointYaw = 0;
ReadingIntegralGyroYaw = 0;
ReadingIntegralGyroNick = ParamSet.GyroAccFactor * (int32_t)AccNick;
ReadingIntegralGyroRoll = ParamSet.GyroAccFactor * (int32_t)AccRoll;
ReadingIntegralGyroNick2 = IntegralGyroNick;
ReadingIntegralGyroRoll2 = IntegralGyroRoll;
IPartNick = 0;
IPartRoll = 0;
}
else
{
BeepTime = 1500; // indicate missing calibration
}
}
}
else delay_startmotors = 0; // reset delay timer if sticks are not in this position
/beta/Code Redesign killagreg/uart0.c
478,7 → 478,7
// if data in the rxd buffer are not locked immediately return
if(!rxd_buffer_locked) return;
 
uint8_t tempchar1, tempchar2;
uint8_t tempchar1;
 
Decode64(); // decode data block in rxd_buffer
 
511,13 → 511,13
 
case 'n':// "Get Mixer Table
while(!txd_complete); // wait for previous frame to be sent
SendOutData('N', FC_ADDRESS, 1, (uint8_t *) &Mixer, sizeof(Mixer));
SendOutData('N', FC_ADDRESS, 1, (uint8_t *) &Mixer, sizeof(Mixer) - 1);
break;
 
case 'm':// "Set Mixer Table
if(pRxData[0] == EEMIXER_REVISION)
{
memcpy(&Mixer, (uint8_t*)pRxData, sizeof(Mixer));
memcpy(&Mixer, (uint8_t*)pRxData, sizeof(Mixer) - 1);
MixerTable_WriteToEEProm();
while(!txd_complete); // wait for previous frame to be sent
tempchar1 = 1;
545,9 → 545,8
// load requested parameter set
ParamSet_ReadFromEEProm(pRxData[0]);
tempchar1 = pRxData[0];
tempchar2 = EEPARAM_REVISION;
while(!txd_complete); // wait for previous frame to be sent
SendOutData('Q', FC_ADDRESS,3, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), (uint8_t *) &ParamSet, sizeof(ParamSet));
SendOutData('Q', FC_ADDRESS,2, &tempchar1, sizeof(tempchar1), (uint8_t *) &ParamSet, sizeof(ParamSet) - 1);
break;
 
case 's': // save settings
555,7 → 554,7
{
if((1 <= pRxData[0]) && (pRxData[0] <= 5) && (pRxData[1] == EEPARAM_REVISION)) // check for setting to be in range and version of settings
{
memcpy(&ParamSet, (uint8_t*)&pRxData[2], sizeof(ParamSet));
memcpy(&ParamSet, (uint8_t*)&pRxData[1], sizeof(ParamSet) -1);
ParamSet_WriteToEEProm(pRxData[0]);
TurnOver180Nick = (int32_t) ParamSet.AngleTurnOverNick * 2500L;
TurnOver180Roll = (int32_t) ParamSet.AngleTurnOverRoll * 2500L;