Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1597 → Rev 1598

/trunk/analog.c
38,7 → 38,7
void SucheLuftruckOffset(void)
{
unsigned int off;
off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);
off = eeprom_read_byte((unsigned char*)(EEPROM_ADR_LAST_OFFSET));
if(off > 20) off -= 10;
OCR0A = off;
ExpandBaro = 0;
51,7 → 51,7
printf(".");
if(MessLuftdruck < DESIRED_H_ADC) break;
}
eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_LAST_OFFSET), off);
DruckOffsetSetting = off;
Delay_ms_Mess(300);
}
/trunk/fc.c
223,7 → 223,7
AdNeutralGierBias = AdNeutralGier;
StartNeutralRoll = AdNeutralRoll;
StartNeutralNick = AdNeutralNick;
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
if(eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_NICK)) > 4)
{
NeutralAccY = abs(Mittelwert_AccRoll) / (2*ACC_AMPLIFY);
NeutralAccX = abs(Mittelwert_AccNick) / (2*ACC_AMPLIFY);
231,9 → 231,9
}
else
{
NeutralAccX = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1]);
NeutralAccY = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL+1]);
NeutralAccZ = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1]);
NeutralAccX = (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_NICK)) * 256 + (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_NICK+1));
NeutralAccY = (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_ROLL)) * 256 + (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_ROLL+1));
NeutralAccZ = (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_Z)) * 256 + (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_Z+1));
}
 
MesswertNick = 0;
675,17 → 675,17
if(++delay_neutral > 200) // nicht sofort
{
GRN_OFF;
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],0xff); // Werte löschen
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_NICK),0xff); // Werte löschen
MotorenEin = 0;
delay_neutral = 0;
modell_fliegt = 0;
SetNeutral();
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],NeutralAccX / 256); // ACC-NeutralWerte speichern
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1],NeutralAccX % 256); // ACC-NeutralWerte speichern
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL],NeutralAccY / 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL+1],NeutralAccY % 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z],(int)NeutralAccZ / 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1],(int)NeutralAccZ % 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_NICK),NeutralAccX / 256); // ACC-NeutralWerte speichern
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_NICK+1),NeutralAccX % 256); // ACC-NeutralWerte speichern
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_ROLL),NeutralAccY / 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_ROLL+1),NeutralAccY % 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_Z),(int)NeutralAccZ / 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACC_Z+1),(int)NeutralAccZ % 256);
Piep(GetActiveParamSetNumber(),120);
}
}
/trunk/main.c
52,7 → 52,6
#include "main.h"
 
 
unsigned char EEPromArray[E2END+1] EEMEM;
unsigned char PlatinenVersion = 10;
unsigned char SendVersionToNavi = 1;
unsigned char BattLowVoltageWarning = 94;
65,7 → 64,7
void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
{
if((number > 5)||(number < 1)) number = 3;
eeprom_read_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
eeprom_read_block(buffer, (void*)(EEPROM_ADR_PARAM_BEGIN + length * (number - 1)), length);
LED_Init();
}
 
75,9 → 74,9
{
if(number > 5) number = 5;
if(number < 1) return;
eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * (number - 1)], length);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_PARAM_LENGTH], length); // Länge der Datensätze merken
eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_CHANNELS], 12); // 12 Kanäle merken
eeprom_write_block(buffer, (void*)(EEPROM_ADR_PARAM_BEGIN + length * (number - 1)), length);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_PARAM_LENGTH), length); // Länge der Datensätze merken
eeprom_write_block(buffer, (void*)(EEPROM_ADR_CHANNELS), 12); // 12 Kanäle merken
SetActiveParamSetNumber(number);
LED_Init();
}
85,7 → 84,7
unsigned char GetActiveParamSetNumber(void)
{
unsigned char set;
set = eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
set = eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACTIVE_SET));
if((set > 5) || (set < 1))
{
set = 3;
98,7 → 97,7
{
if(number > 5) number = 5;
if(number < 1) return;
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], number); // diesen Parametersatz als aktuell merken
eeprom_write_byte((unsigned char*)(EEPROM_ADR_ACTIVE_SET), number); // diesen Parametersatz als aktuell merken
}
 
 
209,11 → 208,11
ReadParameterSet(3, (unsigned char *) &EE_Parameter.Kanalbelegung[0], 13); // read only the first bytes
 
 
if((eeprom_read_byte(&EEPromArray[EEPROM_ADR_MIXER_TABLE]) == MIXER_REVISION) && // Check Revision in the first Byte
(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != 0xff)) // Settings reset via Koptertool
if((eeprom_read_byte((unsigned char*)(EEPROM_ADR_MIXER_TABLE)) == MIXER_REVISION) && // Check Revision in the first Byte
(eeprom_read_byte((unsigned char*)(EEPROM_ADR_VALID)) != 0xff)) // Settings reset via Koptertool
{
unsigned char i;
eeprom_read_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));
eeprom_read_block(&Mixer, (unsigned char*)(EEPROM_ADR_MIXER_TABLE), sizeof(Mixer));
for(i=0; i<16;i++) { if(Mixer.Motor[i][0] > 0) RequiredMotors++;}
}
else // default
228,7 → 227,7
Mixer.Motor[3][0] = 64; Mixer.Motor[3][1] = 0; Mixer.Motor[3][2] = +64; Mixer.Motor[3][3] = -64;
Mixer.Revision = MIXER_REVISION;
memcpy(Mixer.Name, "Quadro\0", 11);
eeprom_write_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));
eeprom_write_block(&Mixer, (void*)(EEPROM_ADR_MIXER_TABLE), sizeof(Mixer));
}
printf("\n\rMixer-Config: '%s' (%u Motors)",Mixer.Name,RequiredMotors);
 
266,7 → 265,7
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Check Settings
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION)
if(eeprom_read_byte((unsigned char*)(EEPROM_ADR_VALID)) != EE_DATENREVISION)
{
DefaultKonstanten1();
printf("\n\rInit. EEPROM");
284,23 → 283,23
EE_Parameter.WinkelUmschlagRoll = 78;
}
// valid Stick-Settings?
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS]) < 12 && eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+1]) < 12 && eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+2]) < 12 && eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+3]) < 12)
if(eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS)) < 12 && eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+1)) < 12 && eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+2)) < 12 && eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+3)) < 12)
{
EE_Parameter.Kanalbelegung[0] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+0]);
EE_Parameter.Kanalbelegung[1] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+1]);
EE_Parameter.Kanalbelegung[2] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+2]);
EE_Parameter.Kanalbelegung[3] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+3]);
EE_Parameter.Kanalbelegung[4] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+4]);
EE_Parameter.Kanalbelegung[5] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+5]);
EE_Parameter.Kanalbelegung[6] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+6]);
EE_Parameter.Kanalbelegung[7] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+7]);
EE_Parameter.Kanalbelegung[0] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+0));
EE_Parameter.Kanalbelegung[1] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+1));
EE_Parameter.Kanalbelegung[2] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+2));
EE_Parameter.Kanalbelegung[3] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+3));
EE_Parameter.Kanalbelegung[4] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+4));
EE_Parameter.Kanalbelegung[5] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+5));
EE_Parameter.Kanalbelegung[6] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+6));
EE_Parameter.Kanalbelegung[7] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+7));
 
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+8]) < 255)
if(eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+8)) < 0xFF)
{
EE_Parameter.Kanalbelegung[K_POTI5] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+8]);
EE_Parameter.Kanalbelegung[K_POTI6] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+9]);
EE_Parameter.Kanalbelegung[K_POTI7] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+10]);
EE_Parameter.Kanalbelegung[K_POTI8] = eeprom_read_byte(&EEPromArray[EEPROM_ADR_CHANNELS+11]);
EE_Parameter.Kanalbelegung[K_POTI5] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+8));
EE_Parameter.Kanalbelegung[K_POTI6] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+9));
EE_Parameter.Kanalbelegung[K_POTI7] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+10));
EE_Parameter.Kanalbelegung[K_POTI8] = eeprom_read_byte((unsigned char*)(EEPROM_ADR_CHANNELS+11));
}
else
{
314,11 → 313,11
WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
}
SetActiveParamSetNumber(3); // default-Setting
eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], EE_DATENREVISION);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_VALID), EE_DATENREVISION);
}
 
FlugMinuten = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_MINUTES2]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_MINUTES2+1]);
FlugMinutenGesamt = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_MINUTES]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_MINUTES+1]);
FlugMinuten = (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_MINUTES2)) * 256 + (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_MINUTES2+1));
FlugMinutenGesamt = (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_MINUTES)) * 256 + (int)eeprom_read_byte((unsigned char*)(EEPROM_ADR_MINUTES+1));
if(FlugMinutenGesamt == 0xffff || FlugMinuten == 0xffff)
{
FlugMinuten = 0;
326,7 → 325,7
}
printf("\n\rFlight-time %u min Total:%u min" ,FlugMinuten,FlugMinutenGesamt);
 
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
if(eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACC_NICK)) > 4)
{
printf("\n\rACC not calibrated !");
}
471,10 → 470,10
timer2 = 0;
FlugMinuten++;
FlugMinutenGesamt++;
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES2],FlugMinuten / 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES2+1],FlugMinuten % 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES],FlugMinutenGesamt / 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES+1],FlugMinutenGesamt % 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES2),FlugMinuten / 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES2+1),FlugMinuten % 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES),FlugMinutenGesamt / 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES+1),FlugMinutenGesamt % 256);
timer = SetDelay(20); // falls "timer += 20;" mal nicht geht
}
}
/trunk/main.h
83,7 → 83,6
extern unsigned char GetActiveParamSetNumber(void);
void SetActiveParamSetNumber(unsigned char number);
void LipoDetection(unsigned char print);
extern unsigned char EEPromArray[];
extern unsigned int FlugMinuten,FlugMinutenGesamt,FlugSekunden;
 
#include <stdlib.h>
/trunk/menu.c
179,8 → 179,8
if(RemoteKeys & KEY4)
{
FlugMinuten = 0;
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES2],FlugMinuten / 256);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_MINUTES2+1],FlugMinuten % 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES2),FlugMinuten / 256);
eeprom_write_byte((unsigned char*)(EEPROM_ADR_MINUTES2+1),FlugMinuten % 256);
}
break;
default:
/trunk/spi.c
177,7 → 177,7
ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8;
ToNaviCtrl.Param.Byte[8] = (unsigned char) FCFlags;
FCFlags &= ~(FCFLAG_CALIBRATE | FCFLAG_START);
ToNaviCtrl.Param.Byte[9] =(unsigned char) eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
ToNaviCtrl.Param.Byte[9] =(unsigned char) eeprom_read_byte((unsigned char*)(EEPROM_ADR_ACTIVE_SET));
break;
 
case SPI_FCCMD_ACCU:
/trunk/uart.c
327,7 → 327,7
if(pRxData[0] == MIXER_REVISION)
{
memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer));
eeprom_write_block(&Mixer, &EEPromArray[EEPROM_ADR_MIXER_TABLE], sizeof(Mixer));
eeprom_write_block(&Mixer, (void*)(EEPROM_ADR_MIXER_TABLE), sizeof(Mixer));
tempchar1 = 1;
}
else tempchar1 = 0;