| /branches/thjac/V1_11/main.h |
|---|
| 34,6 → 34,7 |
| #define EEPROM_ADR_ACC_ROLL 6 |
| #define EEPROM_ADR_ACC_Z 8 |
| #define EEPROM_ADR_PITCH_MD_HOVER 10 |
| #define EEPROM_ADR_PITCH_NEUTRAL_DIFF 12 |
| #define EEPROM_ADR_PARAM_BEGIN 100 |
| /branches/thjac/V1_11/makefile |
|---|
| 5,7 → 5,7 |
| #------------------------------------------------------------------- |
| VERSION_MAJOR = 1 |
| VERSION_MINOR = 11 |
| VERSION_PATCH = 1 |
| VERSION_PATCH = 2 |
| VERSION_SERIAL_MAJOR = 10 # Serial Protocol |
| VERSION_SERIAL_MINOR = 0 # Serial Protocol |
| /branches/thjac/V1_11/menu.c |
|---|
| 7,6 → 7,7 |
| #include "main.h" |
| #include "altcon.h" |
| #include "pitch.h" |
| #include "pitch_neutral.h" |
| #include "pitch_md.h" |
| #include "parameter.h" |
| 147,12 → 148,18 |
| break; |
| case 12: |
| LCD_printfxy( 0, 0, "PitchSteuerung " ); |
| LCD_printfxy( 0, 1, "Modus: %s ", pitchModeStrings[ pitch_current_mode() ] ); |
| LCD_printfxy( 0, 1, "Modus: %8s", pitchModeStrings[ pitch_currentMode() ] ); |
| LCD_printfxy( 0, 2, "GsInit: %3i", pitch_initialStickValue() ); |
| // MD-Modus |
| switch( pitch_current_mode() ) { |
| switch( pitch_currentMode() ) { |
| case PARAM_PITCH_MODE_NEUTRAL: |
| LCD_printfxy( 0, 3, "StickDiff: %2i", pitch_neutralDiff() ) |
| break; |
| case PARAM_PITCH_MODE_MD: |
| LCD_printfxy( 0, 2, "Standgas: %3i ", pitch_hover_value() ); |
| LCD_printfxy( 0, 3, "Standgas: %3i", pitch_hoverValue() ); |
| break; |
| } |
| /branches/thjac/V1_11/parameter.h |
|---|
| 20,8 → 20,7 |
| /****************************************************************************************** |
| * Parameter für Neutral-Pitch-Steuerung |
| */ |
| #define PARAM_PITCH_NEUTRAL_DIFF EE_Parameter.UserParam1 // Stick-Loslass-Erkennung |
| #define PARAM_PITCH_MIN2 EE_Parameter.UserParam2 // Minimalgas |
| #define PARAM_PITCH_MIN2 EE_Parameter.UserParam1 // Minimalgas |
| /****************************************************************************************** |
| * Allgemeine Pitch-Steuerungsparameter |
| 33,7 → 32,8 |
| * Parameter für MD-Pitch-Steuerung |
| */ |
| #define PARAM_PITCH_MD_DELAY0 5 // Begrenzung der Pitch-Beschleunigung am Boden |
| #define PARAM_PITCH_MD_DELAY1 0 // Begrenzung der Pitch-Beschleunigung im Flug |
| #define PARAM_PITCH_MD_DELAY1 2 // Begrenzung der Pitch-Beschleunigung beim Start |
| #define PARAM_PITCH_MD_DELAY2 0 // Begrenzung der Pitch-Beschleunigung im Flug |
| /****************************************************************************************** |
| 103,6 → 103,7 |
| #define PARAM_PITCH_MODE_NORMAL 0x00 |
| #define PARAM_PITCH_MODE_NEUTRAL 0x01 |
| #define PARAM_PITCH_MODE_MD 0x02 |
| #define PARAM_PITCH_MODE_INVALID 0x03 |
| /* Wenn gesetzt, wird nach ca. 2s andauernder Stick-Stellung auf Minimum |
| * ein Reset der Pitch-Regelung durchgeführt, so daß der MK ohne Aus- und |
| /branches/thjac/V1_11/pitch.c |
|---|
| 11,13 → 11,18 |
| #include "pitch_md.h" |
| #include "pitch.h" |
| #define UNDEFINED 255 |
| #define INVALID 255 |
| int pitchInitialStickValue = UNDEFINED; |
| unsigned char pitchMode; |
| char *pitchModeStrings[] = { |
| "Normal ", |
| "Neutral ", |
| "MD " |
| "MD ", |
| "Inaktiv " |
| }; |
| 34,8 → 39,40 |
| */ |
| void pitch_init( void ) { |
| // Nur beim Einschalten ermitteln, da beim Setting-Wechsel ungültig |
| if( pitchInitialStickValue == UNDEFINED ) { |
| // Warten, bis ein gültiger Wert von der Fernsteuerung anliegt |
| unsigned int timer = SetDelay( 500 ); |
| while( !CheckDelay( timer ) ); |
| pitchInitialStickValue = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ]; |
| } |
| pitchMode = PARAM_PITCH_MODE; |
| /* Die Stick-Position beim Einschalten muß mit dem im Setting eingestellten |
| * Pitch-Modus übereinstimmen. Sonst wird die Pitch-Steuerung aus Sicherheits- |
| * gründen deaktiviert. Selbiges gilt, wenn die Höhenregelung deaktiviert wurde. |
| */ |
| switch( pitchMode ) { |
| // Pitch-Modi mit neutralisiertem Gas |
| case PARAM_PITCH_MODE_NEUTRAL: |
| case PARAM_PITCH_MODE_MD: |
| if( !( EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG ) ) |
| pitchMode = PARAM_PITCH_MODE_INVALID; |
| if( abs( pitchInitialStickValue ) > PARAM_PITCH_STICK_THRESHOLD ) |
| pitchMode = PARAM_PITCH_MODE_INVALID; |
| break; |
| // Pitch-Modi mit 0-Gas |
| case PARAM_PITCH_MODE_NORMAL: |
| if( pitchInitialStickValue > 35 - 120 ) |
| pitchMode = PARAM_PITCH_MODE_INVALID; |
| break; |
| } |
| pitch_neutral_init(); |
| pitch_md_init(); |
| // FIXME Funktioniert noch nicht |
| 64,8 → 101,11 |
| case PARAM_PITCH_MODE_MD: |
| return pitch_md_value(); |
| case PARAM_PITCH_MODE_NORMAL: |
| return pitch_mk_value(); |
| default: |
| return pitch_mk_value(); |
| return 0; |
| } |
| } |
| 75,7 → 115,7 |
| */ |
| int pitch_mk_value( void ) { |
| register int stickValue = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ]; |
| register int pitchCount = stickValue + 120; // Warum 120? Gas= 0 ist -125 |
| register int pitchCount = stickValue + 120; |
| DebugOut.Analog[26] = stickValue; |
| DebugOut.Analog[28] = pitchCount; |
| /branches/thjac/V1_11/pitch.h |
|---|
| 8,15 → 8,15 |
| extern int (* pitch_value_ptr)( void ); |
| // TODO Soll den Stick-Wert der Mittelstellung liefern |
| #define pitch_stickoffset() 0 |
| #define pitch_initialStickValue() pitchInitialStickValue |
| #define pitch_current_mode() ( pitchMode ) |
| #define pitch_current_mode_string() ( pitchModeStrings[ pitchMode ] ); |
| #define pitch_currentMode() ( pitchMode ) |
| #define pitch_currentModeString() ( pitchModeStrings[ pitchMode ] ) |
| extern void pitch_init( void ); |
| extern int pitch_value( void ); |
| extern int pitchInitialStickValue; |
| extern unsigned char pitchMode; |
| extern char *pitchModeStrings[]; |
| /branches/thjac/V1_11/pitch_md.c |
|---|
| 23,18 → 23,18 |
| #define STATE_ACTIVE 0x08 // Höhenregelung ist aktiv |
| static int stickValue = 0; // Aktueller Stick-Wert |
| static int lastStickValue = 0; // Vorheriger Stick-Wert |
| static int actualPitchCount = 0; // Soll-Pitch-Wert |
| static int targetPitchCount = 0; // Ist-Pitch-Wert |
| static int pitchOffset; // Aktueller Grundgaswert in Neutralstellung |
| static char state; // Zustand |
| static int stickValue = 0; // Aktueller Stick-Wert |
| static int lastStickValue = 0; // Vorheriger Stick-Wert |
| static int actualPitchCount = 0; // Soll-Pitch-Wert |
| static int targetPitchCount = 0; // Ist-Pitch-Wert |
| static int pitchOffset; // Aktueller Grundgaswert in Neutralstellung |
| static char state; // Zustand |
| static int timer; |
| static int delay = 0; |
| static int delayCounter = 0; |
| static int temp; // Temporäre Werte; wird mehrfach verwendet |
| static int temp; // Temporäre Werte; wird mehrfach verwendet |
| unsigned char pitchHover = 0; // Standgaswert |
| unsigned char pitchHover = 0; // Standgaswert |
| void pitch_md_init( void ) { |
| 45,30 → 45,31 |
| /* |
| * Berechnet den aktuellen Pitch-Wert für die Regelung |
| * |
| * Nachdem die Motoren eingeschaltet sind, wird der Pitch-Stick losgelassen und damit in Mittelstellung |
| * gebracht. Die Motoren laufen zu dieser Zeit im Leerlaufgas. Vor dem Abheben müssen die Motoren in |
| * das Standgas gebracht werden. Dies geschieht durch minimales Gasgeben. Durch weiteres Gasgeben und |
| * nehmen kann abgehoben und geflogen werden. |
| * Funktionsweise: |
| * |
| * Erreicht der Stick während des Fluges die Neutralstellung und verbleibt dort für ca. 1 Sekunde ohne |
| * bewegt zu werden, aktiviert sich die Höhenregelung und hält den MK auf der aktuellen Höhe. |
| * 1. Einmalig muß man das Standgas kalibrieren. Standgas ist ein neuer Parameter. |
| * Dies tut man durch Beätigen des Roll-Sticks in eine beliebige Richtung (Vollausschlag) und |
| * Starten der Motoren. Nun gibt man soviel Gas (in der oberen Hälfte des Stick-Bereichs) wie |
| * der MK gerade noch stabil auf dem Boden steht. Man hält diese Stick-Position solange, bis ein |
| * Piepen ertönt. Damit wurde der Gaswert als Standgasparameter übernommen und im EEProm dauerhaft gespeichert. |
| * Diese Kalibrierung muß mit vollem Akku und nach jeder Gewichtsänderung des MK einmal durchgeführt werden. |
| * |
| * Sobald der Stick die Neutralstellung verläßt, wird die automatische Höhenregelung deaktiviert |
| * und der vorige Pitch-Wert als Wert der Neutralstellung übernommen. Der Pitch läßt sich nun |
| * über den gesamten Stick-Bereich regeln. |
| * 2. Für den Flug startet man die Motoren und läßt den Stick los. Die Motoren laufen im Leerlaufgas. |
| * |
| * Erreicht der Stick ein weiteres Mal die Neutralstellung, wird die automatische Höhenregelung |
| * wieder aktiviert, jetzt jedoch immer mit einer zeitlichen Verzögerung. Nur so ist ein |
| * ungestörtes manuelles Steuern möglich. |
| * 3. Nun schaltet man auf Standgas durch kurzes Antippen des Sticks nach oben. Die Motoren beschleunigen langsam |
| * bis zum Erreichen des zuvor kalibriertes Standgaswertes. |
| * |
| * Der Pitch-Wert ist innerhalb der Regelung durch ein konfigurierbares Minimalgas nach unten begrenzt. |
| * Dieses Minimalgas kann auf einen sehr niedrigen Wert eingestellt sein. Um im Flug nicht unterhalb |
| * eines Wertes zu gelangen, der die Lageregelung außer Funktion setzt, wird ein zweiter Wert für |
| * Minimalgas konfiguriert, der greift, sobald erstmalig die automatische Höhenregelung aktiviert wurde. |
| * 4. Nun hebt man wie gewohnt ab. Hierzu hat man den oberen Stick-Bereich zur Verfügung. Da der Grundgaswert |
| * bei Mittelstellung jetzt knapp unterhalb des Schwebegaswertes liegt, kann man im Flug einfach die Höhe halten, |
| * indem man den Stick in Mittelstellung bewegt. Nach kurzer Zeit (quittiert mit einem Piep) wird die automatische |
| * Höhenregelung aktiviert und solange gehalten, bis man den Stick wieder bewegt. |
| * |
| * 5. Nach der Landung drückt man den Stick ganz nach unten, bis ein Piepen ertönt. Jetzt laufen die Motoren |
| * wieder im Leerlaufgas. Man kann nun neu Starten (ab Punkt 3) oder die Motoren ausschalten. |
| */ |
| int pitch_md_value( void ) { |
| int register rawStickValue = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ] - pitch_stickoffset(); |
| int register rawStickValue = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ] - pitch_initialStickValue(); |
| // Sind die Motoren eingeschaltet? |
| if( MotorenEin ) { |
| 136,12 → 137,7 |
| // Konfiguration dauerhaft speichern |
| eeprom_write_byte( &EEPromArray[ EEPROM_ADR_PITCH_MD_HOVER ], pitchHover ); |
| /* |
| WriteParameterSet( |
| GetActiveParamSetNumber(), |
| (unsigned char *) &EE_Parameter.Kanalbelegung[0], |
| STRUCT_PARAM_LAENGE ); |
| */ |
| // Signalisieren |
| beeptime = 500; |
| } |
| 213,6 → 209,9 |
| // Stick ist innerhalb der Neutralstellung |
| if( abs( stickValue ) < PARAM_PITCH_STICK_THRESHOLD ) { |
| // Ab jetzt gilt eine höhere Pitch-Beschleunigung |
| delay = PARAM_PITCH_MD_DELAY2; |
| // Aktuelle Höhe festhalten (aktiviert noch nicht den Regler) |
| altcon_lock(); |
| 282,20 → 281,18 |
| state = STATE_INITIALIZE; |
| } |
| if( !delayCounter ) { |
| /* Durch die Sollwertvorgabe kann hier eine einstellbare Trägheit auf dem Pitch-Wert |
| * abgebildet werden. */ |
| int pitchDelta = targetPitchCount - actualPitchCount; |
| /* Durch die Sollwertvorgabe kann hier eine einstellbare Trägheit auf dem Pitch-Wert |
| * abgebildet werden. */ |
| int pitchDelta = targetPitchCount - actualPitchCount; |
| if( pitchDelta > 3 ) |
| pitchDelta = 3; |
| if( pitchDelta < -3 ) |
| pitchDelta = -3; |
| if( pitchDelta > 3 ) |
| pitchDelta = 3; |
| if( pitchDelta < -3 ) |
| pitchDelta = -3; |
| if( !delayCounter ) { |
| actualPitchCount += pitchDelta; |
| delayCounter = delay + 1; |
| delayCounter = delay + 1; |
| } |
| delayCounter--; |
| /branches/thjac/V1_11/pitch_md.h |
|---|
| 6,7 → 6,7 |
| #ifndef PITCH_MD_H |
| #define PITCH_MD_H |
| #define pitch_hover_value() pitchHover |
| #define pitch_hoverValue() pitchHover |
| extern void pitch_md_init( void ); |
| extern int pitch_md_value( void ); |
| /branches/thjac/V1_11/pitch_neutral.c |
|---|
| 10,11 → 10,11 |
| #include "pitch.h" |
| #include "pitch_neutral.h" |
| #define STATE_STARTUP_WAIT 0x00 // Init-Timeout beim Einschalten abwarten |
| #define STATE_STARTUP_INIT 0x01 // Initialisierung beim Einschalten |
| #define STATE_BEGIN 0x02 // Anfangszustand nach Einschalten der Motoren |
| #define STATE_INITIALIZING 0x03 // Initialisierungsphase |
| #define STATE_MANUAL 0x04 // Manuelle Kontrolle, Höhenregelung in Konfiguration deaktiviert |
| #define STATE_INITIALIZE 0x00 // Initialisierung nach Einschalten der Motoren |
| #define STATE_SETUP 0x01 // Kalibrierung des Gas-Sticks |
| #define STATE_SETUP1 0x02 // |
| #define STATE_BEGIN 0x03 // Startphase |
| #define STATE_BEGIN1 0x04 // |
| #define STATE_INACTIVE 0x05 // Manuelle Kontrolle |
| #define STATE_WAIT 0x06 // Warten auf Einschalten der Höhenregelung |
| #define STATE_ACTIVATING 0x07 // Aktivierung der Höhenregelung |
| 24,9 → 24,12 |
| static int stickValue = 0; // Aktueller Stick-Wert |
| static int lastStickValue = 0; // Vorheriger Stick-Wert |
| static int pitchOffset = 0; // Aktueller Grundgaswert in Neutralstellung |
| static char state = STATE_STARTUP_WAIT; // Zustand |
| static char state; // Zustand |
| static int temp; |
| char pitchNeutralDiff = 0; |
| /* Wird verwendet, um das Umschalten auf automatische Höhenregelung |
| * nach Erreichen der Neutralstellung zu verzögern. |
| */ |
| 33,39 → 36,58 |
| static int pitchNeutralTimer = PITCH_NEUTRAL_TIMER; |
| void pitch_neutral_init( void ) { |
| pitchNeutralDiff = eeprom_read_byte( &EEPromArray[ EEPROM_ADR_PITCH_NEUTRAL_DIFF ] ); |
| } |
| /* |
| * Berechnet den aktuellen Pitch-Wert für die Regelung |
| * |
| * Nach dem Einschalten der FC wird der aktuelle Gas-Stick-Wert gelesen und als Kalibrierungswert |
| * für die Neutralstellung gespeichert. Somit spielt die korrekte Trimmung des Sticks auf Senderseite |
| * keine Rolle. |
| * Funktionsweise: |
| * |
| * Nach Einschalten der Motoren geht der Stick in Neutralstellung. Diese Stick-Bewegung wird ignoriert |
| * und die Motoren drehen mit dem eingestellten MinGas2. Ausgehend von der Neutralstellung wird nun |
| * durch Bewegen des Sticks im oberen Bereich das Gas geregelt. |
| * 1. Vor Verwendung der Pitch-Steuerung muß ein Parameter für den Gas-Stick eingestellt werden. Hierzu |
| * bewegt man den Roll-Stick ganz nach außen und startet die Motoren. Man befindet sich im Setup-Modus |
| * und die Motoren laufen unabhängig vom Gas-Stick im Leerlauf. Im Display auf Seite 12 muß nun der |
| * beste Wert für "StickDiff" gefunden werden. Den Wert ändern kann man mit dem Roll-Stick. Man betätigt |
| * nun den Gas-Stick nach oben und läßt ihn los, so daß er in die Mittelstellung zurückspringt. Der |
| * optimale Wert sorgt dafür, daß das gewollte Loslassen von einer normalen Bewegung unterschieden wird. |
| * Jedesmal, wenn die SW das Loslassen als solches erkannt hat, ertönt ein Signal. Dieses darf jedoch |
| * nicht ertönen, wenn man den Stick mit normaler Geschwindigkeit in die Mittelstellung zurückbewegt. |
| * Wurde ein guter Wert eingestellt, verläßt man den Setup-Modus durch Ausschalten der Motoren. Der |
| * ermittelte Wert wird permanent im EEProm gespeichert und muß nicht neu ermittelt werden. |
| * |
| * Das erstmalige Aktivieren der automatischen Höhenregelung erfolgt durch Loslassen des Sticks im |
| * Schwebeflug. Der zuvor aktuelle Stick-Wert wird als Wert in Neutralstellung übernommen und die |
| * automatische Höhenregelung sofort aktiviert. |
| * 2. Nach dem Einschalten der FC wird die aktuelle Gas-Stick-Position gemerkt und als Kalibrierungswert |
| * für die Neutralstellung gespeichert. Somit spielt die korrekte Trimmung des Sticks auf Senderseite |
| * keine Rolle. |
| * |
| * Sobald der Stick die Neutralstellung verläßt, wird die automatische Höhenregelung deaktiviert |
| * und der vorige Pitch-Wert als Wert der Neutralstellung übernommen. Der Pitch läßt sich nun |
| * über den gesamten Stick-Bereich regeln. |
| * 3. Nach Einschalten der Motoren geht der Stick in Neutralstellung. Diese Stick-Bewegung wird ignoriert |
| * und die Motoren drehen mit dem eingestellten MinGas2. Ausgehend von der Neutralstellung wird nun |
| * durch Bewegen des Sticks im oberen Bereich das Gas geregelt. |
| * |
| * Erreicht der Stick ein weiteres Mal die Neutralstellung, wird die automatische Höhenregelung |
| * wieder aktiviert, jetzt jedoch immer mit einer zeitlichen Verzögerung. Nur so ist ein |
| * ungestörtes manuelles Steuern möglich. |
| * 4. Das erstmalige Aktivieren der automatischen Höhenregelung erfolgt durch Loslassen des Sticks im |
| * Schwebeflug. Der zuvor aktuelle Stick-Wert wird als Wert in Neutralstellung übernommen und die |
| * automatische Höhenregelung sofort aktiviert. Wichtig hierfür ist die unter Punkt 1 vorgenommene |
| * Parameterfindung. Stimmt dieser Wert nicht, führt das zur Wegnahme des Gases und somit zum Sinken. |
| * |
| * Der Pitch-Wert ist innerhalb der Regelung durch ein konfigurierbares Minimalgas nach unten begrenzt. |
| * Dieses Minimalgas kann auf einen sehr niedrigen Wert eingestellt sein. Um im Flug nicht unterhalb |
| * eines Wertes zu gelangen, der die Lageregelung außer Funktion setzt, wird ein zweiter Wert für |
| * Minimalgas konfiguriert, der greift, sobald erstmalig die automatische Höhenregelung aktiviert wurde. |
| * 5. Sobald der Stick die Neutralstellung verläßt, wird die automatische Höhenregelung deaktiviert |
| * und der vorige Pitch-Wert als Wert der Neutralstellung übernommen. Der Pitch läßt sich nun |
| * über den gesamten Stick-Bereich regeln. |
| * |
| * 6. Erreicht der Stick ein weiteres Mal die Neutralstellung, wird die automatische Höhenregelung |
| * wieder aktiviert, jetzt jedoch immer mit einer zeitlichen Verzögerung. Nur so ist ein |
| * ungestörtes manuelles Steuern möglich. |
| * |
| * 7. Der Pitch-Wert ist innerhalb der Regelung durch ein konfigurierbares Minimalgas nach unten begrenzt. |
| * Dieses Minimalgas kann auf einen sehr niedrigen Wert eingestellt sein. Um im Flug nicht unterhalb |
| * eines Wertes zu gelangen, der die Lageregelung außer Funktion setzt, wird ein zweiter Wert für |
| * Minimalgas konfiguriert, der greift, sobald erstmalig die automatische Höhenregelung aktiviert wurde. |
| */ |
| int pitch_neutral_value( void ) { |
| int register pitchCount = 0; |
| // Sind die Motoren eingeschaltet? |
| // Sind die Motoren eingeschaltet? Ach ja, im Zustand STATE_SETUP sind die Motoren aus... |
| if( MotorenEin ) { |
| // Vorigen Stick-Wert merken |
| 74,7 → 96,7 |
| /* StickValue exponentiell angleichen, da ausgehend von der Neutralstellung |
| * nur jeweils die halbe Auflösung nach oben und unten zur Verfügung steht. Bei einer |
| * Multiplikation mit 2 ließe sich das Gas im Schwebebereich nicht fein genug einstellen. */ |
| temp = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ] - pitch_stickoffset(); |
| temp = PPM_in[ EE_Parameter.Kanalbelegung[ K_GAS ] ] - pitch_initialStickValue(); |
| if( temp > 0 ) { |
| temp = temp + ( ( temp * temp ) / 150 ); |
| } else { |
| 81,29 → 103,98 |
| temp = temp - ( ( temp * temp ) / 150 ); |
| } |
| // Original-Stick-Wert holen und glätten |
| stickValue = ( temp + 2 * lastStickValue ) / 3; |
| stickValue = temp; |
| /* Aktuellen Pitch-Wert berechnen. Der Wert ergibt sich aus dem Pitch-Offset |
| * zuzüglich dem Stick-Wert. */ |
| pitchCount = stickValue + pitchOffset; |
| switch( state ) { |
| /* Entscheidet über Flugbetrieb oder Setup-Betrieb. Für den Setup-Betrieb |
| * muß beim Einschalten der Motoren gleichzeitig der Roll-Stick ganz |
| * betätigt werden (Richtung ist egal). |
| */ |
| case STATE_INITIALIZE: |
| if( abs( PPM_in[ EE_Parameter.Kanalbelegung[ K_ROLL ] ] ) > 70 ) { |
| state = STATE_SETUP; |
| } else { |
| state = STATE_BEGIN; |
| } |
| break; |
| case STATE_SETUP: |
| if( stickValue < PARAM_PITCH_STICK_THRESHOLD && |
| abs( PPM_in[ EE_Parameter.Kanalbelegung[ K_ROLL ] ] ) < PARAM_PITCH_STICK_THRESHOLD ) { |
| state = STATE_SETUP1; |
| } |
| // Im Setup immer mit Leerlaufgas |
| pitchCount = 0; |
| break; |
| case STATE_SETUP1: |
| // Roll-Stick nach links |
| if( PPM_in[ EE_Parameter.Kanalbelegung[ K_ROLL ] ] < -20 ) { |
| if( pitchNeutralDiff < 20 ) { |
| pitchNeutralDiff++; |
| // Konfiguration dauerhaft speichern |
| eeprom_write_byte( &EEPromArray[ EEPROM_ADR_PITCH_NEUTRAL_DIFF ], pitchNeutralDiff ); |
| // Signalisieren |
| beeptime = 500; |
| state = STATE_SETUP; |
| } |
| } |
| // Roll-Stick nach rechts |
| if( PPM_in[ EE_Parameter.Kanalbelegung[ K_ROLL ] ] > 20 ) { |
| if( pitchNeutralDiff > 0 ) { |
| pitchNeutralDiff--; |
| // Konfiguration dauerhaft speichern |
| eeprom_write_byte( &EEPromArray[ EEPROM_ADR_PITCH_NEUTRAL_DIFF ], pitchNeutralDiff ); |
| // Signalisieren |
| beeptime = 500; |
| state = STATE_SETUP; |
| } |
| } |
| if( ( lastStickValue > PARAM_PITCH_STICK_THRESHOLD ) && |
| ( lastStickValue - stickValue >= pitchNeutralDiff ) ) { |
| state = STATE_SETUP; |
| // Signalisieren |
| beeptime = 500; |
| } |
| // Im Setup immer mit Leerlaufgas |
| pitchCount = 0; |
| break; |
| case STATE_BEGIN: |
| // Schnelles Bewegen aus dem oberen Bereich des Sticks in Neutralstellung |
| if( ( lastStickValue > PARAM_PITCH_STICK_THRESHOLD ) && |
| ( lastStickValue - stickValue >= PARAM_PITCH_NEUTRAL_DIFF ) ) { |
| ( lastStickValue - stickValue >= pitchNeutralDiff ) ) { |
| pitchOffset = lastStickValue; |
| state = STATE_INITIALIZING; |
| state = STATE_BEGIN1; |
| pitchNeutralTimer = PITCH_NEUTRAL_TIMER; |
| } |
| break; |
| case STATE_INITIALIZING: |
| case STATE_BEGIN1: |
| // Während der Initialisierung das Gas konstant halten |
| pitchCount = pitchOffset; |
| 120,26 → 211,10 |
| // Ist die Neutralstellung erreicht? |
| if( abs( stickValue ) <= PARAM_PITCH_STICK_THRESHOLD ) { |
| // Ist die Höhenregelung aktiviert? |
| if( EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG ) { |
| state = STATE_ACTIVATING; |
| } else { |
| state = STATE_MANUAL; |
| } |
| state = STATE_ACTIVATING; |
| } |
| break; |
| /* Wenn die Höhenregelung per Konfiguration deaktiviert ist, verbleibt |
| * die Funktion in diesem Zustand. */ |
| case STATE_MANUAL: |
| // Min2-Gas einstellen für Lageregelung bei Minimalgas |
| if( pitchCount < PARAM_PITCH_MIN2 ) { |
| pitchCount = PARAM_PITCH_MIN2; |
| } |
| break; |
| /* Die Höhenregelung ist per Konfiguration aktiviert, jedoch befindet |
| * sich der Stick außerhalb des als Neutralstellung anerkannten |
| * Wertebereiches. Es wird manuell geregelt. */ |
| 239,7 → 314,7 |
| pitchCount = 0; |
| pitchOffset = 0; |
| stickValue = 0; |
| state = STATE_BEGIN; |
| state = STATE_INITIALIZE; |
| } |
| if( pitchOffset < 0 ) |
| /branches/thjac/V1_11/pitch_neutral.h |
|---|
| 6,7 → 6,12 |
| #ifndef _PITCH_NEUTRAL_H |
| #define _PITCH_NEUTRAL_H |
| #define pitch_neutralDiff() pitchNeutralDiff |
| extern void pitch_neutral_init( void ); |
| extern int pitch_neutral_value( void ); |
| extern char pitchNeutralDiff; |
| #endif // PITCH_NEUTRAL_H |
| /branches/thjac/V1_11/version.txt |
|---|
| 235,3 → 235,10 |
| - Neue Display-Seite für Pitch-Steuerung |
| - Fehler in Höhenregelung korrigiert |
| - Integralanteil in Höhenregelung vorerst stillgelegt |
| V1_11c T. Jachmann |
| - Setup-Modus für Pitch-Steuerung "neutral" |
| - Parameter für "Loslasserkennung" der Pitch-Steuerung "neutral" liegt jetzt im EEProm (Setting-unabhängig) |
| - Erweiterung der Display-Seite für Pitch-Steuerung |
| - Sicherung des Pitch-Modus über die Einschalt-Gas-Stick-Position und die Höhenregelung im Setting |