Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 372 → Rev 373

/branches/v0.60_MicroMag3_Nick666/trunc/compass.c
15,10 → 15,10
 
#include "main.h"
 
MM3_working_struct MM3;
struct MM3_calib_struct ee_calib EEMEM;
 
MM3_calib_struct ee_calib EEMEM; // Reservierung im EEPROM
MM3_calib_struct MM3_calib;
struct MM3_working_struct MM3;
struct MM3_calib_struct MM3_calib;
 
 
//############################################################################
37,7 → 37,7
MM3.STATE = MM3_RESET;
// Kalibrierung aus dem EEprom lesen
eeprom_read_block(&MM3_calib,&ee_calib,sizeof(MM3_calib_struct));
eeprom_read_block(&MM3_calib,&ee_calib,sizeof(struct MM3_calib_struct));
}
 
 
168,15 → 168,16
{
ROT_FLASH;
GRN_FLASH;
//beeptime = 50;
beeper = 50;
}
beeper--;
// Schleife mit 100 Hz voll ausreichend
// Schleife mit 100 Hz
timer = SetDelay(10);
while(!CheckDelay(timer));
// Wenn Gas zurück genommen wird, Kalibrierung mit Verzögerung beenden
// Wenn Gas zurück genommen wird, Kalibrierung mit 1/2 Sekunde Verzögerung beenden
if (PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < 100) measurement--;
}
186,7 → 187,7
MM3_calib.Z_off = (z_max + z_min) / 2;
// und im EEProm abspeichern
eeprom_write_block(&MM3_calib,&ee_calib,sizeof(MM3_calib_struct));
eeprom_write_block(&MM3_calib,&ee_calib,sizeof(struct MM3_calib_struct));
}
 
/branches/v0.60_MicroMag3_Nick666/trunc/compass.h
1,6 → 1,6
 
 
typedef struct
struct MM3_working_struct
{
uint8_t STATE;
unsigned int DRDY;
13,18 → 13,18
signed int z_axis_old;
signed int NickGrad;
signed int RollGrad;
}MM3_working_struct;
};
 
 
typedef struct
struct MM3_calib_struct
{
int8_t X_off;
int8_t Y_off;
int8_t Z_off;
}MM3_calib_struct;
};
 
extern MM3_working_struct MM3;
extern MM3_calib_struct MM3_calib;
extern struct MM3_working_struct MM3;
extern struct MM3_calib_struct MM3_calib;
 
void init_MM3(void);
void timer0_MM3(void);
/branches/v0.60_MicroMag3_Nick666/trunc/fc.c
107,8 → 107,8
unsigned char Parameter_ServoNickControl = 100;
struct mk_param_struct EE_Parameter;
 
acc_neutral_struct ee_acc_neutral EEMEM; // Reservierung im EEPROM
acc_neutral_struct acc_neutral;
struct acc_neutral_struct ee_acc_neutral EEMEM;
struct acc_neutral_struct acc_neutral;
 
void Piep(unsigned char Anzahl)
{
139,7 → 139,7
acc_neutral.Y = abs(Mittelwert_AccRoll) / ACC_AMPLIFY;
acc_neutral.Z = Aktuell_az;
eeprom_write_block(&acc_neutral,&ee_acc_neutral,sizeof(acc_neutral_struct));
eeprom_write_block(&acc_neutral,&ee_acc_neutral,sizeof(struct acc_neutral_struct));
}
 
//############################################################################
166,7 → 166,7
AdNeutralRoll= abs(MesswertRoll);
AdNeutralGier= abs(MesswertGier);
eeprom_read_block(&acc_neutral,&ee_acc_neutral,sizeof(acc_neutral_struct));
eeprom_read_block(&acc_neutral,&ee_acc_neutral,sizeof(struct acc_neutral_struct));
Mess_IntegralNick = 0;
Mess_IntegralNick2 = 0;
514,7 → 514,7
if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) setting = 5;
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], setting); // aktiven Datensatz merken
}
ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], sizeof(struct mk_param_struct));
Piep(GetActiveParamSetNumber());
if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)) // Höhenregelung aktiviert?
{
/branches/v0.60_MicroMag3_Nick666/trunc/fc.h
51,7 → 51,7
char MotorenEin;
extern void DefaultKonstanten(void);
 
#define STRUCT_PARAM_LAENGE 58
 
struct mk_param_struct
{
unsigned char Kanalbelegung[8]; // GAS[0], GIER[1],NICK[2], ROLL[3], POTI1, POTI2, POTI3
90,14 → 90,14
char Name[12];
};
 
typedef struct
struct acc_neutral_struct
{
int X;
int Y;
float Z;
}acc_neutral_struct;
};
 
extern acc_neutral_struct acc_neutral;
extern struct acc_neutral_struct acc_neutral;
extern void calib_acc(void);
 
 
/branches/v0.60_MicroMag3_Nick666/trunc/main.c
51,16 → 51,17
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "main.h"
 
// unsigned char EEPromArray[E2END+1] EEMEM;
unsigned char EEPromArray[501] EEMEM;
unsigned char EEPromArray[10] EEMEM;
struct mk_param_struct EEParameterArray[5] EEMEM;
 
 
// -- Parametersatz aus EEPROM lesen ---
// number [0..5]
void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
{
if (number > 5) number = 5;
eeprom_read_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * number], length);
 
number--; // Auf Index 0 bis 4 anpassen
eeprom_read_block(buffer, &EEParameterArray[number], length);
}
 
 
68,8 → 69,9
// number [0..5]
void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
{
if (number > 5) number = 5;
eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * number], length);
if (number > 5) number = 5;
number--; // Auf Index 0 bis 4 anpassen
eeprom_write_block(buffer, &EEParameterArray[number], length);
 
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], number); // diesen Parametersatz als aktuell merken
}
126,7 → 128,7
printf("\n\r==============================");
GRN_ON;
 
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != 59) // seit V 0.60
if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != 60) // seit V 0.60
{
printf("\n\rInit. EEPROM: Generiere Default-Parameter...");
DefaultKonstanten1();
133,13 → 135,13
for (unsigned char i=0;i<6;i++)
{
if(i==2) DefaultKonstanten2();
WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], sizeof(struct mk_param_struct));
}
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], 1);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], 59);
eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], 60);
}
ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], sizeof(struct mk_param_struct));
printf("\n\rBenutze Parametersatz %d", GetActiveParamSetNumber());
//kurze Wartezeit (sonst reagiert die "Kompass kalibrieren?"-Abfrage nicht
/branches/v0.60_MicroMag3_Nick666/trunc/main.h
31,8 → 31,6
#define EEPROM_ADR_VALID 1
#define EEPROM_ADR_ACTIVE_SET 2
 
#define EEPROM_ADR_PARAM_BEGIN 100
 
#define CFG_HOEHENREGELUNG 0x01
#define CFG_HOEHEN_SCHALTER 0x02
#define CFG_HEADING_HOLD 0x04
/branches/v0.60_MicroMag3_Nick666/trunc/timer0.c
46,7 → 46,7
{
timer0_MM3(); // Kompass auslesen
 
if (!cntKompass--) // Aufruf mit 10 Hz
if (!cntKompass--) // Aufruf mit ~10 Hz
{
KompassValue = heading_MM3();
KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
/branches/v0.60_MicroMag3_Nick666/trunc/uart.c
220,11 → 220,11
if(tmp_char_arr2[0] != 0xff)
{
if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], sizeof(struct mk_param_struct));
SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],sizeof(struct mk_param_struct));
}
else
SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],sizeof(struct mk_param_struct));
break;
233,8 → 233,8
case 'n':
case 'o':
case 'p': // Parametersatz speichern
Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],sizeof(struct mk_param_struct),3,AnzahlEmpfangsBytes);
WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], sizeof(struct mk_param_struct));
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken
Piep(GetActiveParamSetNumber());
break;