'phase' renamed to 'flight mode' everywhere in the code
This commit is contained in:
@@ -250,7 +250,7 @@ int applyCurve(int x, CurveRef & curve)
|
||||
switch (curve.type) {
|
||||
case CURVE_REF_DIFF:
|
||||
{
|
||||
int curveParam = calc100to256(GET_GVAR(curve.value, -100, 100, s_current_mixer_flight_mode));
|
||||
int curveParam = calc100to256(GET_GVAR(curve.value, -100, 100, mixerCurrentFlightMode));
|
||||
if (curveParam > 0 && x < 0)
|
||||
x = (x * (256 - curveParam)) >> 8;
|
||||
else if (curveParam < 0 && x > 0)
|
||||
@@ -259,7 +259,7 @@ int applyCurve(int x, CurveRef & curve)
|
||||
}
|
||||
|
||||
case CURVE_REF_EXPO:
|
||||
return expo(x, GET_GVAR(curve.value, -100, 100, s_current_mixer_flight_mode));
|
||||
return expo(x, GET_GVAR(curve.value, -100, 100, mixerCurrentFlightMode));
|
||||
|
||||
case CURVE_REF_FUNC:
|
||||
switch (curve.value) {
|
||||
|
||||
@@ -41,7 +41,7 @@ PACK(typedef struct {
|
||||
uint8_t mode; // 0=end, 1=pos, 2=neg, 3=both
|
||||
uint8_t chn;
|
||||
int8_t swtch;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
int8_t weight;
|
||||
uint8_t curveMode;
|
||||
char name[LEN_EXPOMIX_NAME];
|
||||
@@ -53,7 +53,7 @@ PACK(typedef struct {
|
||||
uint8_t mode; // 0=end, 1=pos, 2=neg, 3=both
|
||||
uint8_t chn;
|
||||
int8_t swtch;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
int8_t weight;
|
||||
uint8_t curveMode;
|
||||
char name[LEN_EXPOMIX_NAME];
|
||||
@@ -80,7 +80,7 @@ PACK(typedef struct {
|
||||
#if defined(PCBTARANIS)
|
||||
PACK(typedef struct {
|
||||
uint8_t destCh;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
uint8_t curveMode:1; // O=curve, 1=differential
|
||||
uint8_t noExpo:1;
|
||||
int8_t carryTrim:3;
|
||||
@@ -103,7 +103,7 @@ PACK(typedef struct {
|
||||
#else
|
||||
PACK(typedef struct {
|
||||
uint8_t destCh;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
uint8_t curveMode:1; // O=curve, 1=differential
|
||||
uint8_t noExpo:1;
|
||||
int8_t carryTrim:3;
|
||||
@@ -142,7 +142,7 @@ PACK(typedef struct {
|
||||
uint8_t fadeOut;
|
||||
ROTARY_ENCODER_ARRAY;
|
||||
gvar_t gvars[5];
|
||||
}) PhaseData_v215;
|
||||
}) FlightModeData_v215;
|
||||
|
||||
PACK(typedef struct {
|
||||
int16_t v1;
|
||||
@@ -225,7 +225,7 @@ PACK(typedef struct {
|
||||
LogicalSwitchData_v215 logicalSw[NUM_LOGICAL_SWITCH];
|
||||
CustomFnData_v215 funcSw[32];
|
||||
SwashRingData swashR;
|
||||
PhaseData_v215 phaseData[MAX_FLIGHT_MODES];
|
||||
FlightModeData_v215 flightModeData[MAX_FLIGHT_MODES];
|
||||
|
||||
int8_t ppmFrameLength; // 0=22.5ms (10ms-30ms) 0.5ms increments
|
||||
uint8_t thrTraceSrc;
|
||||
@@ -500,7 +500,7 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
MixData_v215 * oldMix = &oldModel.mixData[i];
|
||||
#if defined(PCBTARANIS)
|
||||
mix->destCh = oldMix->destCh;
|
||||
mix->phases = oldMix->phases;
|
||||
mix->flightModes = oldMix->flightModes;
|
||||
mix->mltpx = oldMix->mltpx;
|
||||
if (oldMix->carryTrim == TRIM_OFF) mix->carryTrim = TRIM_OFF;
|
||||
mix->weight = ConvertGVAR_215_to_216(oldMix->weight);
|
||||
@@ -533,7 +533,7 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
#else
|
||||
mix->destCh = oldMix->destCh;
|
||||
mix->mixWarn = oldMix->mixWarn;
|
||||
mix->phases = oldMix->phases;
|
||||
mix->flightModes = oldMix->flightModes;
|
||||
mix->curveMode = oldMix->curveMode;
|
||||
mix->noExpo = oldMix->noExpo;
|
||||
mix->carryTrim = oldMix->carryTrim;
|
||||
@@ -575,7 +575,7 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
if (oldExpo->mode) {
|
||||
#if defined(PCBTARANIS)
|
||||
uint8_t chn = oldExpo->chn;
|
||||
if (!oldExpo->swtch && !oldExpo->phases) {
|
||||
if (!oldExpo->swtch && !oldExpo->flightModes) {
|
||||
indexes[chn] = -1;
|
||||
}
|
||||
else if (indexes[chn] != -1) {
|
||||
@@ -588,7 +588,7 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
expo->chn = chn;
|
||||
expo->mode = oldExpo->mode;
|
||||
expo->swtch = ConvertSwitch_215_to_216(oldExpo->swtch);
|
||||
expo->phases = oldExpo->phases;
|
||||
expo->flightModes = oldExpo->flightModes;
|
||||
expo->weight = oldExpo->weight;
|
||||
memcpy(expo->name, oldExpo->name, LEN_EXPOMIX_NAME);
|
||||
if (oldExpo->curveMode==0/*expo*/) {
|
||||
@@ -610,7 +610,7 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
expo->chn = oldExpo->chn;
|
||||
expo->curveMode = oldExpo->curveMode;
|
||||
expo->swtch = oldExpo->swtch;
|
||||
expo->phases = oldExpo->phases;
|
||||
expo->flightModes = oldExpo->flightModes;
|
||||
expo->weight = oldExpo->weight;
|
||||
memcpy(expo->name, oldExpo->name, LEN_EXPOMIX_NAME);
|
||||
expo->curveParam = oldExpo->curveParam;
|
||||
@@ -802,22 +802,22 @@ void ConvertModel_215_to_216(ModelData &model)
|
||||
g_model.swashR.collectiveSource = ConvertSource_215_to_216(g_model.swashR.collectiveSource);
|
||||
|
||||
for (uint8_t i=0; i<9; i++) {
|
||||
if (i==0 || oldModel.phaseData[i].swtch) {
|
||||
memcpy(&g_model.phaseData[i], &oldModel.phaseData[i], sizeof(oldModel.phaseData[i])); // the last 4 gvars will remain blank
|
||||
g_model.phaseData[i].swtch = ConvertSwitch_215_to_216(oldModel.phaseData[i].swtch);
|
||||
if (i==0 || oldModel.flightModeData[i].swtch) {
|
||||
memcpy(&g_model.flightModeData[i], &oldModel.flightModeData[i], sizeof(oldModel.flightModeData[i])); // the last 4 gvars will remain blank
|
||||
g_model.flightModeData[i].swtch = ConvertSwitch_215_to_216(oldModel.flightModeData[i].swtch);
|
||||
#if defined(PCBTARANIS)
|
||||
for (uint8_t t=0; t<4; t++) {
|
||||
int trim = oldModel.phaseData[i].trim[t];
|
||||
int trim = oldModel.flightModeData[i].trim[t];
|
||||
if (trim > 500) {
|
||||
trim -= 501;
|
||||
if (trim >= i)
|
||||
trim += 1;
|
||||
g_model.phaseData[i].trim[t].mode = 2*trim;
|
||||
g_model.phaseData[i].trim[t].value = 0;
|
||||
g_model.flightModeData[i].trim[t].mode = 2*trim;
|
||||
g_model.flightModeData[i].trim[t].value = 0;
|
||||
}
|
||||
else {
|
||||
g_model.phaseData[i].trim[t].mode = 2*i;
|
||||
g_model.phaseData[i].trim[t].value = trim;
|
||||
g_model.flightModeData[i].trim[t].mode = 2*i;
|
||||
g_model.flightModeData[i].trim[t].value = trim;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
+10
-10
@@ -59,7 +59,7 @@ void MIXER_RESET()
|
||||
s_last_switch_used = 0;
|
||||
s_last_switch_value = 0;
|
||||
#endif
|
||||
s_current_mixer_flight_mode = s_last_phase = 0;
|
||||
mixerCurrentFlightMode = s_last_phase = 0;
|
||||
lastAct = 0;
|
||||
logicalSwitchesReset();
|
||||
}
|
||||
@@ -365,8 +365,8 @@ TEST(getSwitch, recursiveSW)
|
||||
TEST(FlightModes, nullFadeOut_posFadeIn)
|
||||
{
|
||||
MODEL_RESET();
|
||||
g_model.phaseData[1].swtch = SWSRC_ID1;
|
||||
g_model.phaseData[1].fadeIn = 15;
|
||||
g_model.flightModeData[1].swtch = SWSRC_ID1;
|
||||
g_model.flightModeData[1].fadeIn = 15;
|
||||
perMain();
|
||||
simuSetSwitch(3, 0);
|
||||
perMain();
|
||||
@@ -527,7 +527,7 @@ TEST(Mixer, RecursiveAddChannelAfterInactivePhase)
|
||||
{
|
||||
MODEL_RESET();
|
||||
MIXER_RESET();
|
||||
g_model.phaseData[1].swtch = SWSRC_ID1;
|
||||
g_model.flightModeData[1].swtch = SWSRC_ID1;
|
||||
g_model.mixData[0].destCh = 0;
|
||||
g_model.mixData[0].mltpx = MLTPX_ADD;
|
||||
g_model.mixData[0].srcRaw = MIXSRC_CH2;
|
||||
@@ -634,7 +634,7 @@ TEST(Mixer, SlowOnPhase)
|
||||
{
|
||||
MODEL_RESET();
|
||||
MIXER_RESET();
|
||||
g_model.phaseData[1].swtch = TR(SWSRC_THR, SWSRC_SA0);
|
||||
g_model.flightModeData[1].swtch = TR(SWSRC_THR, SWSRC_SA0);
|
||||
g_model.mixData[0].destCh = 0;
|
||||
g_model.mixData[0].mltpx = MLTPX_ADD;
|
||||
g_model.mixData[0].srcRaw = MIXSRC_MAX;
|
||||
@@ -644,13 +644,13 @@ TEST(Mixer, SlowOnPhase)
|
||||
g_model.mixData[0].speedDown = SLOW_STEP*5;
|
||||
|
||||
s_mixer_first_run_done = true;
|
||||
s_current_mixer_flight_mode = 0;
|
||||
mixerCurrentFlightMode = 0;
|
||||
evalFlightModeMixes(e_perout_mode_normal, 0);
|
||||
EXPECT_EQ(chans[0], 0);
|
||||
|
||||
CHECK_SLOW_MOVEMENT(0, +1, 250);
|
||||
|
||||
s_current_mixer_flight_mode = 1;
|
||||
mixerCurrentFlightMode = 1;
|
||||
CHECK_SLOW_MOVEMENT(0, -1, 250);
|
||||
}
|
||||
|
||||
@@ -659,7 +659,7 @@ TEST(Mixer, SlowOnSwitchAndPhase)
|
||||
{
|
||||
MODEL_RESET();
|
||||
MIXER_RESET();
|
||||
g_model.phaseData[1].swtch = TR(SWSRC_THR, SWSRC_SA0);
|
||||
g_model.flightModeData[1].swtch = TR(SWSRC_THR, SWSRC_SA0);
|
||||
g_model.mixData[0].destCh = 0;
|
||||
g_model.mixData[0].mltpx = MLTPX_ADD;
|
||||
g_model.mixData[0].srcRaw = MIXSRC_MAX;
|
||||
@@ -678,11 +678,11 @@ TEST(Mixer, SlowOnSwitchAndPhase)
|
||||
EXPECT_EQ(chans[0], 0);
|
||||
|
||||
simuSetSwitch(0, 1);
|
||||
s_current_mixer_flight_mode = 0;
|
||||
mixerCurrentFlightMode = 0;
|
||||
CHECK_SLOW_MOVEMENT(0, +1, 250);
|
||||
|
||||
simuSetSwitch(0, -1);
|
||||
s_current_mixer_flight_mode = 1;
|
||||
mixerCurrentFlightMode = 1;
|
||||
CHECK_SLOW_MOVEMENT(0, -1, 250);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1160,7 +1160,7 @@ void menuModelSetup(uint8_t event)
|
||||
if (event==EVT_KEY_LONG(KEY_ENTER)) {
|
||||
s_noHi = NO_HI_LEN;
|
||||
for (uint8_t i=0; i<MAX_FLIGHT_MODES; i++) {
|
||||
memclear(&g_model.phaseData[i], TRIMS_ARRAY_SIZE);
|
||||
memclear(&g_model.flightModeData[i], TRIMS_ARRAY_SIZE);
|
||||
}
|
||||
eeDirty(EE_MODEL);
|
||||
AUDIO_WARNING1();
|
||||
@@ -1839,16 +1839,16 @@ FlightModesType editFlightModes(uint8_t x, uint8_t y, uint8_t event, FlightModes
|
||||
#if defined(PCBTARANIS)
|
||||
|
||||
enum FlightModesItems {
|
||||
ITEM_PHASES_NAME,
|
||||
ITEM_PHASES_SWITCH,
|
||||
ITEM_PHASES_TRIM_RUD,
|
||||
ITEM_PHASES_TRIM_ELE,
|
||||
ITEM_PHASES_TRIM_THR,
|
||||
ITEM_PHASES_TRIM_AIL,
|
||||
ITEM_PHASES_FADE_IN,
|
||||
ITEM_PHASES_FADE_OUT,
|
||||
ITEM_PHASES_COUNT,
|
||||
ITEM_PHASES_LAST = ITEM_PHASES_COUNT-1
|
||||
ITEM_FLIGHT_MODES_NAME,
|
||||
ITEM_FLIGHT_MODES_SWITCH,
|
||||
ITEM_FLIGHT_MODES_TRIM_RUD,
|
||||
ITEM_FLIGHT_MODES_TRIM_ELE,
|
||||
ITEM_FLIGHT_MODES_TRIM_THR,
|
||||
ITEM_FLIGHT_MODES_TRIM_AIL,
|
||||
ITEM_FLIGHT_MODES_FADE_IN,
|
||||
ITEM_FLIGHT_MODES_FADE_OUT,
|
||||
ITEM_FLIGHT_MODES_COUNT,
|
||||
ITEM_FLIGHT_MODES_LAST = ITEM_FLIGHT_MODES_COUNT-1
|
||||
};
|
||||
|
||||
bool isTrimModeAvailable(int mode)
|
||||
@@ -1858,7 +1858,7 @@ bool isTrimModeAvailable(int mode)
|
||||
|
||||
void menuModelFlightModesAll(uint8_t event)
|
||||
{
|
||||
MENU(STR_MENUFLIGHTPHASES, menuTabModel, e_FlightModesAll, 1+MAX_FLIGHT_MODES+1, {0, NAVIGATION_LINE_BY_LINE|(ITEM_PHASES_LAST-5), NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_PHASES_LAST, 0});
|
||||
MENU(STR_MENUFLIGHTPHASES, menuTabModel, e_FlightModesAll, 1+MAX_FLIGHT_MODES+1, {0, NAVIGATION_LINE_BY_LINE|(ITEM_FLIGHT_MODES_LAST-5), NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, NAVIGATION_LINE_BY_LINE|ITEM_FLIGHT_MODES_LAST, 0});
|
||||
|
||||
int8_t sub = m_posVert - 1;
|
||||
|
||||
@@ -1876,26 +1876,26 @@ void menuModelFlightModesAll(uint8_t event)
|
||||
if (k==MAX_FLIGHT_MODES) {
|
||||
// last line available - add the "check trims" line
|
||||
lcd_putsLeft((LCD_LINES-1)*FH+1, STR_CHECKTRIMS);
|
||||
putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, s_current_mixer_flight_mode+1);
|
||||
putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, mixerCurrentFlightMode+1);
|
||||
if (sub==MAX_FLIGHT_MODES && !trimsCheckTimer) {
|
||||
lcd_status_line();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
PhaseData *p = phaseAddress(k);
|
||||
FlightModeData *p = flightModeAddress(k);
|
||||
|
||||
putsFlightMode(0, y, k+1, (getFlightPhase()==k ? BOLD : 0) | ((sub==k && m_posHorz<0) ? INVERS : 0));
|
||||
putsFlightMode(0, y, k+1, (getFlightMode()==k ? BOLD : 0) | ((sub==k && m_posHorz<0) ? INVERS : 0));
|
||||
|
||||
for (uint8_t j=0; j<ITEM_PHASES_COUNT; j++) {
|
||||
for (uint8_t j=0; j<ITEM_FLIGHT_MODES_COUNT; j++) {
|
||||
uint8_t attr = ((sub==k && posHorz==j) ? ((s_editMode>0) ? BLINK|INVERS : INVERS) : 0);
|
||||
uint8_t active = (attr && (s_editMode>0 || p1valdiff)) ;
|
||||
switch (j) {
|
||||
case ITEM_PHASES_NAME:
|
||||
case ITEM_FLIGHT_MODES_NAME:
|
||||
editName(4*FW-1, y, p->name, sizeof(p->name), event, attr);
|
||||
break;
|
||||
|
||||
case ITEM_PHASES_SWITCH:
|
||||
case ITEM_FLIGHT_MODES_SWITCH:
|
||||
if (k == 0) {
|
||||
lcd_puts((5+LEN_FP_NAME)*FW, y, STR_DEFAULT);
|
||||
}
|
||||
@@ -1905,12 +1905,12 @@ void menuModelFlightModesAll(uint8_t event)
|
||||
}
|
||||
break;
|
||||
|
||||
case ITEM_PHASES_TRIM_RUD:
|
||||
case ITEM_PHASES_TRIM_ELE:
|
||||
case ITEM_PHASES_TRIM_THR:
|
||||
case ITEM_PHASES_TRIM_AIL:
|
||||
case ITEM_FLIGHT_MODES_TRIM_RUD:
|
||||
case ITEM_FLIGHT_MODES_TRIM_ELE:
|
||||
case ITEM_FLIGHT_MODES_TRIM_THR:
|
||||
case ITEM_FLIGHT_MODES_TRIM_AIL:
|
||||
if (k != 0) {
|
||||
uint8_t t = j-ITEM_PHASES_TRIM_RUD;
|
||||
uint8_t t = j-ITEM_FLIGHT_MODES_TRIM_RUD;
|
||||
putsTrimMode((4+LEN_FP_NAME)*FW+j*(5*FW/2), y, k, t, attr);
|
||||
if (active) {
|
||||
trim_t & v = p->trim[t];
|
||||
@@ -1918,12 +1918,12 @@ void menuModelFlightModesAll(uint8_t event)
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ITEM_PHASES_FADE_IN:
|
||||
case ITEM_FLIGHT_MODES_FADE_IN:
|
||||
lcd_outdezAtt(32*FW-2, y, (10/DELAY_STEP)*p->fadeIn, attr|PREC1);
|
||||
if (active) p->fadeIn = checkIncDec(event, p->fadeIn, 0, DELAY_MAX, EE_MODEL|NO_INCDEC_MARKS);
|
||||
break;
|
||||
|
||||
case ITEM_PHASES_FADE_OUT:
|
||||
case ITEM_FLIGHT_MODES_FADE_OUT:
|
||||
lcd_outdezAtt(35*FW, y, (10/DELAY_STEP)*p->fadeOut, attr|PREC1);
|
||||
if (active) p->fadeOut = checkIncDec(event, p->fadeOut, 0, DELAY_MAX, EE_MODEL|NO_INCDEC_MARKS);
|
||||
break;
|
||||
@@ -1961,14 +1961,14 @@ enum menuModelPhaseItems {
|
||||
|
||||
void menuModelPhaseOne(uint8_t event)
|
||||
{
|
||||
PhaseData *phase = phaseAddress(s_currIdx);
|
||||
putsFlightMode(13*FW, 0, s_currIdx+1, (getFlightPhase()==s_currIdx ? BOLD : 0));
|
||||
FlightModeData *fm = flightModeAddress(s_currIdx);
|
||||
putsFlightMode(13*FW, 0, s_currIdx+1, (getFlightMode()==s_currIdx ? BOLD : 0));
|
||||
|
||||
#if defined(GVARS) && !defined(PCBSTD)
|
||||
static const pm_uint8_t mstate_tab_phase1[] PROGMEM = {0, 0, 0, (uint8_t)-1, 1, 1, 1, 1, 1};
|
||||
static const pm_uint8_t mstate_tab_fm1[] PROGMEM = {0, 0, 0, (uint8_t)-1, 1, 1, 1, 1, 1};
|
||||
static const pm_uint8_t mstate_tab_others[] PROGMEM = {0, 0, 3, IF_ROTARY_ENCODERS(NUM_ROTARY_ENCODERS-1) 0, 0, (uint8_t)-1, 2, 2, 2, 2, 2};
|
||||
|
||||
if (!check(event, 0, NULL, 0, (s_currIdx == 0) ? mstate_tab_phase1 : mstate_tab_others, DIM(mstate_tab_others)-1, ITEM_MODEL_PHASE_MAX - 1 - (s_currIdx==0 ? (ITEM_MODEL_PHASE_FADE_IN-ITEM_MODEL_PHASE_SWITCH) : 0))) return;
|
||||
if (!check(event, 0, NULL, 0, (s_currIdx == 0) ? mstate_tab_fm1 : mstate_tab_others, DIM(mstate_tab_others)-1, ITEM_MODEL_PHASE_MAX - 1 - (s_currIdx==0 ? (ITEM_MODEL_PHASE_FADE_IN-ITEM_MODEL_PHASE_SWITCH) : 0))) return;
|
||||
|
||||
TITLE(STR_MENUFLIGHTPHASE);
|
||||
|
||||
@@ -1996,10 +1996,10 @@ void menuModelPhaseOne(uint8_t event)
|
||||
#endif
|
||||
switch(i) {
|
||||
case ITEM_MODEL_PHASE_NAME:
|
||||
editSingleName(MIXES_2ND_COLUMN, y, STR_PHASENAME, phase->name, sizeof(phase->name), event, attr);
|
||||
editSingleName(MIXES_2ND_COLUMN, y, STR_PHASENAME, fm->name, sizeof(fm->name), event, attr);
|
||||
break;
|
||||
case ITEM_MODEL_PHASE_SWITCH:
|
||||
phase->swtch = switchMenuItem(MIXES_2ND_COLUMN, y, phase->swtch, attr, event);
|
||||
fm->swtch = switchMenuItem(MIXES_2ND_COLUMN, y, fm->swtch, attr, event);
|
||||
break;
|
||||
case ITEM_MODEL_PHASE_TRIMS:
|
||||
lcd_putsLeft(y, STR_TRIMS);
|
||||
@@ -2023,12 +2023,12 @@ void menuModelPhaseOne(uint8_t event)
|
||||
for (uint8_t t=0; t<NUM_ROTARY_ENCODERS; t++) {
|
||||
putsRotaryEncoderMode(MIXES_2ND_COLUMN+(t*FW), y, s_currIdx, t, m_posHorz==t ? attr : 0);
|
||||
if (attr && m_posHorz==t && ((editMode>0) || p1valdiff)) {
|
||||
int16_t v = phaseAddress(s_currIdx)->rotaryEncoders[t];
|
||||
int16_t v = flightModeAddress(s_currIdx)->rotaryEncoders[t];
|
||||
if (v < ROTARY_ENCODER_MAX) v = ROTARY_ENCODER_MAX;
|
||||
v = checkIncDec(event, v, ROTARY_ENCODER_MAX, ROTARY_ENCODER_MAX+MAX_FLIGHT_MODES-1, EE_MODEL);
|
||||
if (checkIncDec_Ret) {
|
||||
if (v == ROTARY_ENCODER_MAX) v = 0;
|
||||
phaseAddress(s_currIdx)->rotaryEncoders[t] = v;
|
||||
flightModeAddress(s_currIdx)->rotaryEncoders[t] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2036,11 +2036,11 @@ void menuModelPhaseOne(uint8_t event)
|
||||
#endif
|
||||
|
||||
case ITEM_MODEL_PHASE_FADE_IN:
|
||||
phase->fadeIn = EDIT_DELAY(0, y, event, attr, STR_FADEIN, phase->fadeIn);
|
||||
fm->fadeIn = EDIT_DELAY(0, y, event, attr, STR_FADEIN, fm->fadeIn);
|
||||
break;
|
||||
|
||||
case ITEM_MODEL_PHASE_FADE_OUT:
|
||||
phase->fadeOut = EDIT_DELAY(0, y, event, attr, STR_FADEOUT, phase->fadeOut);
|
||||
fm->fadeOut = EDIT_DELAY(0, y, event, attr, STR_FADEOUT, fm->fadeOut);
|
||||
break;
|
||||
|
||||
#if defined(GVARS) && !defined(PCBSTD)
|
||||
@@ -2058,7 +2058,7 @@ void menuModelPhaseOne(uint8_t event)
|
||||
|
||||
editName(4*FW, y, g_model.gvars[idx].name, LEN_GVAR_NAME, event, posHorz==0 ? attr : 0);
|
||||
|
||||
int16_t v = phase->gvars[idx];
|
||||
int16_t v = fm->gvars[idx];
|
||||
if (v > GVAR_MAX) {
|
||||
uint8_t p = v - GVAR_MAX - 1;
|
||||
if (p >= s_currIdx) p++;
|
||||
@@ -2072,7 +2072,7 @@ void menuModelPhaseOne(uint8_t event)
|
||||
v = checkIncDec(event, v, GVAR_MAX, GVAR_MAX+MAX_FLIGHT_MODES-1, EE_MODEL);
|
||||
if (checkIncDec_Ret) {
|
||||
if (v == GVAR_MAX) v = 0;
|
||||
phase->gvars[idx] = v;
|
||||
fm->gvars[idx] = v;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2138,11 +2138,11 @@ void menuModelFlightModesAll(uint8_t event)
|
||||
uint8_t y = 1 + (i+1)*FH;
|
||||
#endif
|
||||
att = (i==sub ? INVERS : 0);
|
||||
PhaseData *p = phaseAddress(i);
|
||||
FlightModeData *p = flightModeAddress(i);
|
||||
#if ROTARY_ENCODERS > 2
|
||||
putsFlightMode(0, y, i+1, att|CONDENSED|(getFlightPhase()==i ? BOLD : 0));
|
||||
putsFlightMode(0, y, i+1, att|CONDENSED|(getFlightMode()==i ? BOLD : 0));
|
||||
#else
|
||||
putsFlightMode(0, y, i+1, att|(getFlightPhase()==i ? BOLD : 0));
|
||||
putsFlightMode(0, y, i+1, att|(getFlightMode()==i ? BOLD : 0));
|
||||
#endif
|
||||
|
||||
lcd_putsnAtt(4*FW+NAME_OFS, y, p->name, sizeof(p->name), ZCHAR);
|
||||
@@ -2171,7 +2171,7 @@ void menuModelFlightModesAll(uint8_t event)
|
||||
#endif
|
||||
|
||||
lcd_putsLeft((LCD_LINES-1)*FH+1, STR_CHECKTRIMS);
|
||||
putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, s_current_mixer_flight_mode+1);
|
||||
putsFlightMode(OFS_CHECKTRIMS, (LCD_LINES-1)*FH+1, mixerCurrentFlightMode+1);
|
||||
if (sub==MAX_FLIGHT_MODES && !trimsCheckTimer) {
|
||||
lcd_status_line();
|
||||
}
|
||||
@@ -2255,10 +2255,10 @@ int16_t expoFn(int16_t x)
|
||||
ExpoData *ed = expoAddress(s_currIdx);
|
||||
int16_t anas[NUM_INPUTS] = {0};
|
||||
#if defined(PCBTARANIS)
|
||||
applyExpos(anas, e_perout_mode_inactive_phase, ed->srcRaw, x);
|
||||
applyExpos(anas, e_perout_mode_inactive_flight_mode, ed->srcRaw, x);
|
||||
#else
|
||||
anas[ed->chn] = x;
|
||||
applyExpos(anas, e_perout_mode_inactive_phase);
|
||||
applyExpos(anas, e_perout_mode_inactive_flight_mode);
|
||||
#endif
|
||||
return anas[ed->chn];
|
||||
}
|
||||
@@ -3022,7 +3022,7 @@ void menuModelExpoOne(uint8_t event)
|
||||
|
||||
#if defined(FLIGHT_MODES)
|
||||
case EXPO_FIELD_FLIGHT_PHASE:
|
||||
ed->phases = editFlightModes(EXPO_ONE_2ND_COLUMN-IF_9X(EXPO_ONE_FP_WIDTH), y, event, ed->phases, attr);
|
||||
ed->flightModes = editFlightModes(EXPO_ONE_2ND_COLUMN-IF_9X(EXPO_ONE_FP_WIDTH), y, event, ed->flightModes, attr);
|
||||
break;
|
||||
#endif
|
||||
|
||||
@@ -3255,7 +3255,7 @@ void menuModelMixOne(uint8_t event)
|
||||
#endif
|
||||
#if defined(FLIGHT_MODES)
|
||||
case MIX_FIELD_FLIGHT_PHASE:
|
||||
md2->phases = editFlightModes(COLUMN_X+MIXES_2ND_COLUMN, y, event, md2->phases, attr);
|
||||
md2->flightModes = editFlightModes(COLUMN_X+MIXES_2ND_COLUMN, y, event, md2->flightModes, attr);
|
||||
break;
|
||||
#endif
|
||||
case MIX_FIELD_SWITCH:
|
||||
@@ -3603,12 +3603,12 @@ void menuModelExpoMix(uint8_t expo, uint8_t event)
|
||||
if (ed->mode!=3) lcd_putc(EXPO_LINE_SIDE_POS, y, ed->mode == 2 ? 126 : 127);
|
||||
|
||||
#if defined(CPUARM) && LCD_W >= 212
|
||||
if (ed->phases) lcd_puts(EXPO_LINE_FM_POS, y, STR_FP);
|
||||
if (ed->flightModes) lcd_puts(EXPO_LINE_FM_POS, y, STR_FP);
|
||||
if (ed->name[0]) lcd_putsnAtt(EXPO_LINE_NAME_POS, y, ed->name, sizeof(ed->name), ZCHAR | (isExpoActive(i) ? BOLD : 0));
|
||||
#elif defined(CPUARM)
|
||||
if (ed->name[0]) lcd_putsnAtt(EXPO_LINE_NAME_POS, y, ed->name, sizeof(ed->name), ZCHAR | (isExpoActive(i) ? BOLD : 0));
|
||||
#else
|
||||
displayFlightModes(EXPO_LINE_FM_POS, y, ed->phases);
|
||||
displayFlightModes(EXPO_LINE_FM_POS, y, ed->flightModes);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
@@ -3635,7 +3635,7 @@ void menuModelExpoMix(uint8_t expo, uint8_t event)
|
||||
{
|
||||
#if defined(PCBTARANIS)
|
||||
putsCurveRef(MIX_LINE_CURVE_POS, y, md->curve, 0);
|
||||
if (md->phases) lcd_puts(MIX_LINE_FM_POS, y, STR_FP);
|
||||
if (md->flightModes) lcd_puts(MIX_LINE_FM_POS, y, STR_FP);
|
||||
#else
|
||||
if (md->curveParam) {
|
||||
if (md->curveMode == MODE_CURVE)
|
||||
@@ -4117,7 +4117,7 @@ void onGVARSMenu(const char *result)
|
||||
}
|
||||
else if (result == STR_CLEAR) {
|
||||
for (int i=0; i<MAX_FLIGHT_MODES; i++) {
|
||||
g_model.phaseData[i].gvars[sub] = 0;
|
||||
g_model.flightModeData[i].gvars[sub] = 0;
|
||||
}
|
||||
eeDirty(EE_MODEL);
|
||||
}
|
||||
@@ -4134,7 +4134,7 @@ void menuModelGVars(uint8_t event)
|
||||
if (first2seconds) {
|
||||
menuTitle = STR_GLOBAL_V;
|
||||
for (int i=0; i<MAX_GVARS; i++) {
|
||||
putsStrIdx(GVARS_FM_COLUMN(i)-16, 1, STR_FP, i, SMLSIZE|(getFlightPhase()==i ? INVERS : 0));
|
||||
putsStrIdx(GVARS_FM_COLUMN(i)-16, 1, STR_FP, i, SMLSIZE|(getFlightMode()==i ? INVERS : 0));
|
||||
}
|
||||
}
|
||||
else {
|
||||
@@ -4178,8 +4178,8 @@ void menuModelGVars(uint8_t event)
|
||||
|
||||
default:
|
||||
{
|
||||
PhaseData *phase = &g_model.phaseData[j-1];
|
||||
int16_t & v = phase->gvars[i];
|
||||
FlightModeData *fm = &g_model.flightModeData[j-1];
|
||||
int16_t & v = fm->gvars[i];
|
||||
int16_t vmin, vmax;
|
||||
if (v > GVAR_MAX) {
|
||||
uint8_t p = v - GVAR_MAX - 1;
|
||||
|
||||
@@ -1163,11 +1163,11 @@ int16_t gvarMenuItem(uint8_t x, uint8_t y, int16_t value, int16_t min, int16_t m
|
||||
s_editMode = !s_editMode;
|
||||
#if defined(CPUARM)
|
||||
if (attr & PREC1)
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, s_current_mixer_flight_mode)*10 : delta);
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, mixerCurrentFlightMode)*10 : delta);
|
||||
else
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, s_current_mixer_flight_mode) : delta);
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, mixerCurrentFlightMode) : delta);
|
||||
#else
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, s_current_mixer_flight_mode) : delta);
|
||||
value = (GV_IS_GV_VALUE(value, min, max) ? GET_GVAR(value, min, max, mixerCurrentFlightMode) : delta);
|
||||
#endif
|
||||
eeDirty(EE_MODEL);
|
||||
}
|
||||
|
||||
@@ -654,8 +654,8 @@ void menuMainView(uint8_t event)
|
||||
|
||||
{
|
||||
// Flight Phase Name
|
||||
uint8_t phase = s_current_mixer_flight_mode;
|
||||
lcd_putsnAtt(PHASE_X, PHASE_Y, g_model.phaseData[phase].name, sizeof(g_model.phaseData[phase].name), ZCHAR|PHASE_FLAGS);
|
||||
uint8_t phase = mixerCurrentFlightMode;
|
||||
lcd_putsnAtt(PHASE_X, PHASE_Y, g_model.flightModeData[phase].name, sizeof(g_model.flightModeData[phase].name), ZCHAR|PHASE_FLAGS);
|
||||
|
||||
// Model Name
|
||||
putsModelName(MODELNAME_X, MODELNAME_Y, g_model.header.name, g_eeGeneral.currModel, BIGSIZE);
|
||||
@@ -868,13 +868,13 @@ void menuMainView(uint8_t event)
|
||||
putsStrIdx(BITMAP_X+FW, BITMAP_Y+FH-1, STR_GV, s_gvar_last+1);
|
||||
lcd_putsnAtt(BITMAP_X+4*FW+FW/2, BITMAP_Y+FH-1, g_model.gvars[s_gvar_last].name, LEN_GVAR_NAME, ZCHAR);
|
||||
lcd_putsAtt(BITMAP_X+FW, BITMAP_Y+2*FH+3, PSTR("[\010]"), BOLD);
|
||||
lcd_outdezAtt(BITMAP_X+5*FW+FW/2, BITMAP_Y+2*FH+3, GVAR_VALUE(s_gvar_last, getGVarFlightPhase(s_current_mixer_flight_mode, s_gvar_last)), BOLD);
|
||||
lcd_outdezAtt(BITMAP_X+5*FW+FW/2, BITMAP_Y+2*FH+3, GVAR_VALUE(s_gvar_last, getGVarFlightPhase(mixerCurrentFlightMode, s_gvar_last)), BOLD);
|
||||
#else
|
||||
s_warning = STR_GLOBAL_VAR;
|
||||
displayBox();
|
||||
lcd_putsnAtt(16, 5*FH, g_model.gvars[s_gvar_last].name, LEN_GVAR_NAME, ZCHAR);
|
||||
lcd_putsAtt(16+7*FW, 5*FH, PSTR("[\010]"), BOLD);
|
||||
lcd_outdezAtt(16+7*FW+4*FW+FW/2, 5*FH, GVAR_VALUE(s_gvar_last, getGVarFlightPhase(s_current_mixer_flight_mode, s_gvar_last)), BOLD);
|
||||
lcd_outdezAtt(16+7*FW+4*FW+FW/2, 5*FH, GVAR_VALUE(s_gvar_last, getGVarFlightPhase(mixerCurrentFlightMode, s_gvar_last)), BOLD);
|
||||
s_warning = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
+1
-1
@@ -1167,7 +1167,7 @@ void putsTrimMode(xcoord_t x, uint8_t y, uint8_t phase, uint8_t idx, LcdFlags at
|
||||
#if ROTARY_ENCODERS > 0
|
||||
void putsRotaryEncoderMode(xcoord_t x, uint8_t y, uint8_t phase, uint8_t idx, LcdFlags att)
|
||||
{
|
||||
int16_t v = phaseAddress(phase)->rotaryEncoders[idx];
|
||||
int16_t v = flightModeAddress(phase)->rotaryEncoders[idx];
|
||||
|
||||
if (v > ROTARY_ENCODER_MAX) {
|
||||
uint8_t p = v - ROTARY_ENCODER_MAX - 1;
|
||||
|
||||
+2
-2
@@ -856,7 +856,7 @@ static int luaModelGetGlobalVariable(lua_State *L)
|
||||
int idx = luaL_checkunsigned(L, 1);
|
||||
int phase = luaL_checkunsigned(L, 2);
|
||||
if (phase < MAX_FLIGHT_MODES && idx < MAX_GVARS)
|
||||
lua_pushinteger(L, g_model.phaseData[phase].gvars[idx]);
|
||||
lua_pushinteger(L, g_model.flightModeData[phase].gvars[idx]);
|
||||
else
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
@@ -868,7 +868,7 @@ static int luaModelSetGlobalVariable(lua_State *L)
|
||||
int phase = luaL_checkunsigned(L, 2);
|
||||
int value = luaL_checkinteger(L, 3);
|
||||
if (phase < MAX_FLIGHT_MODES && idx < MAX_GVARS && value >= -GVAR_LIMIT && value <= GVAR_LIMIT) {
|
||||
g_model.phaseData[phase].gvars[idx] = value;
|
||||
g_model.flightModeData[phase].gvars[idx] = value;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
+46
-46
@@ -89,7 +89,7 @@ void applyExpos(int16_t *anas, uint8_t mode APPLY_EXPOS_EXTRA_PARAMS)
|
||||
if (!EXPO_VALID(ed)) break; // end of list
|
||||
if (ed->chn == cur_chn)
|
||||
continue;
|
||||
if (ed->phases & (1<<s_current_mixer_flight_mode))
|
||||
if (ed->flightModes & (1<<mixerCurrentFlightMode))
|
||||
continue;
|
||||
if (getSwitch(ed->swtch)) {
|
||||
#if defined(PCBTARANIS)
|
||||
@@ -128,18 +128,18 @@ void applyExpos(int16_t *anas, uint8_t mode APPLY_EXPOS_EXTRA_PARAMS)
|
||||
if (ed->curveMode == MODE_CURVE)
|
||||
v = applyCurve(v, curveParam);
|
||||
else
|
||||
v = expo(v, GET_GVAR(curveParam, -100, 100, s_current_mixer_flight_mode));
|
||||
v = expo(v, GET_GVAR(curveParam, -100, 100, mixerCurrentFlightMode));
|
||||
}
|
||||
#endif
|
||||
|
||||
//========== WEIGHT ===============
|
||||
int16_t weight = GET_GVAR(ed->weight, MIN_EXPO_WEIGHT, 100, s_current_mixer_flight_mode);
|
||||
int16_t weight = GET_GVAR(ed->weight, MIN_EXPO_WEIGHT, 100, mixerCurrentFlightMode);
|
||||
weight = calc100to256(weight);
|
||||
v = ((int32_t)v * weight) >> 8;
|
||||
|
||||
#if defined(PCBTARANIS)
|
||||
//========== OFFSET ===============
|
||||
int16_t offset = GET_GVAR(ed->offset, -100, 100, s_current_mixer_flight_mode);
|
||||
int16_t offset = GET_GVAR(ed->offset, -100, 100, mixerCurrentFlightMode);
|
||||
if (offset) v += calc100toRESX(offset);
|
||||
|
||||
//========== TRIMS ================
|
||||
@@ -289,7 +289,7 @@ getvalue_t getValue(uint8_t i)
|
||||
return 0;
|
||||
#endif
|
||||
|
||||
else if (i<=MIXSRC_TrimAil) return calc1000toRESX((int16_t)8 * getTrimValue(s_current_mixer_flight_mode, i-MIXSRC_TrimRud));
|
||||
else if (i<=MIXSRC_TrimAil) return calc1000toRESX((int16_t)8 * getTrimValue(mixerCurrentFlightMode, i-MIXSRC_TrimRud));
|
||||
|
||||
#if defined(PCBTARANIS)
|
||||
else if (i==MIXSRC_SA) return (switchState(SW_SA0) ? -1024 : (switchState(SW_SA1) ? 0 : 1024));
|
||||
@@ -314,7 +314,7 @@ getvalue_t getValue(uint8_t i)
|
||||
else if (i<=MIXSRC_LAST_CH) return ex_chans[i-MIXSRC_CH1];
|
||||
|
||||
#if defined(GVARS)
|
||||
else if (i<=MIXSRC_LAST_GVAR) return GVAR_VALUE(i-MIXSRC_GVAR1, getGVarFlightPhase(s_current_mixer_flight_mode, i-MIXSRC_GVAR1));
|
||||
else if (i<=MIXSRC_LAST_GVAR) return GVAR_VALUE(i-MIXSRC_GVAR1, getGVarFlightPhase(mixerCurrentFlightMode, i-MIXSRC_GVAR1));
|
||||
#endif
|
||||
|
||||
else if (i==MIXSRC_FIRST_TELEM-1+TELEM_TX_VOLTAGE) return g_vbat100mV;
|
||||
@@ -473,7 +473,7 @@ void evalInputs(uint8_t mode)
|
||||
}
|
||||
#endif
|
||||
|
||||
if (mode <= e_perout_mode_inactive_phase && isFunctionActive(FUNCTION_TRAINER+ch) && ppmInValid) {
|
||||
if (mode <= e_perout_mode_inactive_flight_mode && isFunctionActive(FUNCTION_TRAINER+ch) && ppmInValid) {
|
||||
// trainer mode
|
||||
TrainerMix* td = &g_eeGeneral.trainer.mix[ch];
|
||||
if (td->mode) {
|
||||
@@ -528,7 +528,7 @@ void evalInputs(uint8_t mode)
|
||||
#define HELI_ANAS_ARRAY anas
|
||||
#endif
|
||||
|
||||
uint8_t s_current_mixer_flight_mode;
|
||||
uint8_t mixerCurrentFlightMode;
|
||||
void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
{
|
||||
evalInputs(mode);
|
||||
@@ -634,8 +634,8 @@ void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
}
|
||||
|
||||
//========== PHASE && SWITCH =====
|
||||
bool mixCondition = (md->phases != 0 || md->swtch);
|
||||
delayval_t mixEnabled = !(md->phases & (1 << s_current_mixer_flight_mode)) && getSwitch(md->swtch);
|
||||
bool mixCondition = (md->flightModes != 0 || md->swtch);
|
||||
delayval_t mixEnabled = !(md->flightModes & (1 << mixerCurrentFlightMode)) && getSwitch(md->swtch);
|
||||
|
||||
if (mixEnabled && md->srcRaw >= MIXSRC_FIRST_TRAINER && md->srcRaw <= MIXSRC_LAST_TRAINER && !ppmInValid) {
|
||||
mixEnabled = 0;
|
||||
@@ -643,7 +643,7 @@ void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
|
||||
//========== VALUE ===============
|
||||
getvalue_t v = 0;
|
||||
if (mode > e_perout_mode_inactive_phase) {
|
||||
if (mode > e_perout_mode_inactive_flight_mode) {
|
||||
#if defined(PCBTARANIS)
|
||||
if (!mixEnabled) {
|
||||
continue;
|
||||
@@ -767,14 +767,14 @@ void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
}
|
||||
|
||||
// saves 12 bytes code if done here and not together with weight; unknown reason
|
||||
int16_t weight = GET_GVAR(MD_WEIGHT(md), GV_RANGELARGE_NEG, GV_RANGELARGE, s_current_mixer_flight_mode);
|
||||
int16_t weight = GET_GVAR(MD_WEIGHT(md), GV_RANGELARGE_NEG, GV_RANGELARGE, mixerCurrentFlightMode);
|
||||
weight = calc100to256_16Bits(weight);
|
||||
|
||||
//========== SPEED ===============
|
||||
// now its on input side, but without weight compensation. More like other remote controls
|
||||
// lower weight causes slower movement
|
||||
|
||||
if (mode <= e_perout_mode_inactive_phase && (md->speedUp || md->speedDown)) { // there are delay values
|
||||
if (mode <= e_perout_mode_inactive_flight_mode && (md->speedUp || md->speedDown)) { // there are delay values
|
||||
#define DEL_MULT_SHIFT 8
|
||||
// we recale to a mult 256 higher value for calculation
|
||||
int32_t tact = act[i];
|
||||
@@ -827,7 +827,7 @@ void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
|
||||
//========== OFFSET / AFTER ===============
|
||||
if (apply_offset_and_curve) {
|
||||
int16_t offset = GET_GVAR(MD_OFFSET(md), GV_RANGELARGE_NEG, GV_RANGELARGE, s_current_mixer_flight_mode);
|
||||
int16_t offset = GET_GVAR(MD_OFFSET(md), GV_RANGELARGE_NEG, GV_RANGELARGE, mixerCurrentFlightMode);
|
||||
if (offset) dv += int32_t(calc100toRESX_16Bits(offset)) << 8;
|
||||
}
|
||||
|
||||
@@ -839,7 +839,7 @@ void evalFlightModeMixes(uint8_t mode, uint8_t tick10ms)
|
||||
#else
|
||||
if (md->curveMode == MODE_DIFFERENTIAL) {
|
||||
// @@@2 also recalculate curveParam to a 256 basis which ease the calculation later a lot
|
||||
int16_t curveParam = calc100to256(GET_GVAR(md->curveParam, -100, 100, s_current_mixer_flight_mode));
|
||||
int16_t curveParam = calc100to256(GET_GVAR(md->curveParam, -100, 100, mixerCurrentFlightMode));
|
||||
if (curveParam > 0 && dv < 0)
|
||||
dv = (dv * (256 - curveParam)) >> 8;
|
||||
else if (curveParam < 0 && dv > 0)
|
||||
@@ -925,7 +925,7 @@ int32_t sum_chans512[NUM_CHNOUT] = {0};
|
||||
|
||||
|
||||
#define MAX_ACT 0xffff
|
||||
uint8_t s_last_phase = 255; // TODO reinit everything here when the model changes, no???
|
||||
uint8_t lastFlightMode = 255; // TODO reinit everything here when the model changes, no???
|
||||
|
||||
#if defined(CPUARM)
|
||||
tmr10ms_t flightModeTransitionTime;
|
||||
@@ -940,58 +940,58 @@ void evalMixes(uint8_t tick10ms)
|
||||
|
||||
static uint16_t fp_act[MAX_FLIGHT_MODES] = {0};
|
||||
static uint16_t delta = 0;
|
||||
static ACTIVE_PHASES_TYPE s_fade_flight_phases = 0;
|
||||
static ACTIVE_PHASES_TYPE flightModesFade = 0;
|
||||
|
||||
LS_RECURSIVE_EVALUATION_RESET();
|
||||
|
||||
uint8_t phase = getFlightPhase();
|
||||
uint8_t fm = getFlightMode();
|
||||
|
||||
if (s_last_phase != phase) {
|
||||
if (lastFlightMode != fm) {
|
||||
#if defined(CPUARM)
|
||||
flightModeTransitionTime = get_tmr10ms();
|
||||
#endif
|
||||
|
||||
if (s_last_phase == 255) {
|
||||
fp_act[phase] = MAX_ACT;
|
||||
if (lastFlightMode == 255) {
|
||||
fp_act[fm] = MAX_ACT;
|
||||
}
|
||||
else {
|
||||
uint8_t fadeTime = max(g_model.phaseData[s_last_phase].fadeOut, g_model.phaseData[phase].fadeIn);
|
||||
ACTIVE_PHASES_TYPE transitionMask = ((ACTIVE_PHASES_TYPE)1 << s_last_phase) + ((ACTIVE_PHASES_TYPE)1 << phase);
|
||||
uint8_t fadeTime = max(g_model.flightModeData[lastFlightMode].fadeOut, g_model.flightModeData[fm].fadeIn);
|
||||
ACTIVE_PHASES_TYPE transitionMask = ((ACTIVE_PHASES_TYPE)1 << lastFlightMode) + ((ACTIVE_PHASES_TYPE)1 << fm);
|
||||
if (fadeTime) {
|
||||
s_fade_flight_phases |= transitionMask;
|
||||
flightModesFade |= transitionMask;
|
||||
delta = (MAX_ACT / (100/SLOW_STEP)) / fadeTime;
|
||||
}
|
||||
else {
|
||||
s_fade_flight_phases &= ~transitionMask;
|
||||
fp_act[s_last_phase] = 0;
|
||||
fp_act[phase] = MAX_ACT;
|
||||
flightModesFade &= ~transitionMask;
|
||||
fp_act[lastFlightMode] = 0;
|
||||
fp_act[fm] = MAX_ACT;
|
||||
}
|
||||
#if defined(CPUARM)
|
||||
logicalSwitchesCopyState(s_last_phase, phase); // push last logical switches state from old to new phase
|
||||
logicalSwitchesCopyState(lastFlightMode, fm); // push last logical switches state from old to new flight mode
|
||||
#endif
|
||||
}
|
||||
s_last_phase = phase;
|
||||
lastFlightMode = fm;
|
||||
}
|
||||
|
||||
#if defined(CPUARM)
|
||||
if (flightModeTransitionTime && get_tmr10ms() > flightModeTransitionTime+g_eeGeneral.switchesDelay) {
|
||||
flightModeTransitionTime = 0;
|
||||
if (phase != flightModeTransitionLast) {
|
||||
if (fm != flightModeTransitionLast) {
|
||||
if (flightModeTransitionLast != 255) PLAY_PHASE_OFF(flightModeTransitionLast);
|
||||
PLAY_PHASE_ON(phase);
|
||||
flightModeTransitionLast = phase;
|
||||
PLAY_PHASE_ON(fm);
|
||||
flightModeTransitionLast = fm;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
int32_t weight = 0;
|
||||
if (s_fade_flight_phases) {
|
||||
if (flightModesFade) {
|
||||
memclear(sum_chans512, sizeof(sum_chans512));
|
||||
for (uint8_t p=0; p<MAX_FLIGHT_MODES; p++) {
|
||||
LS_RECURSIVE_EVALUATION_RESET();
|
||||
if (s_fade_flight_phases & ((ACTIVE_PHASES_TYPE)1 << p)) {
|
||||
s_current_mixer_flight_mode = p;
|
||||
evalFlightModeMixes(p==phase ? e_perout_mode_normal : e_perout_mode_inactive_phase, p==phase ? tick10ms : 0);
|
||||
if (flightModesFade & ((ACTIVE_PHASES_TYPE)1 << p)) {
|
||||
mixerCurrentFlightMode = p;
|
||||
evalFlightModeMixes(p==fm ? e_perout_mode_normal : e_perout_mode_inactive_flight_mode, p==fm ? tick10ms : 0);
|
||||
for (uint8_t i=0; i<NUM_CHNOUT; i++)
|
||||
sum_chans512[i] += (chans[i] >> 4) * fp_act[p];
|
||||
weight += fp_act[p];
|
||||
@@ -999,10 +999,10 @@ void evalMixes(uint8_t tick10ms)
|
||||
LS_RECURSIVE_EVALUATION_RESET();
|
||||
}
|
||||
assert(weight);
|
||||
s_current_mixer_flight_mode = phase;
|
||||
mixerCurrentFlightMode = fm;
|
||||
}
|
||||
else {
|
||||
s_current_mixer_flight_mode = phase;
|
||||
mixerCurrentFlightMode = fm;
|
||||
evalFlightModeMixes(e_perout_mode_normal, tick10ms);
|
||||
}
|
||||
|
||||
@@ -1023,7 +1023,7 @@ void evalMixes(uint8_t tick10ms)
|
||||
// at the end chans[i] = chans[i]/256 => -1024..1024
|
||||
// interpolate value with min/max so we get smooth motion from center to stop
|
||||
// this limits based on v original values and min=-1024, max=1024 RESX=1024
|
||||
int32_t q = (s_fade_flight_phases ? (sum_chans512[i] / weight) << 4 : chans[i]);
|
||||
int32_t q = (flightModesFade ? (sum_chans512[i] / weight) << 4 : chans[i]);
|
||||
|
||||
#if defined(PCBSTD)
|
||||
ex_chans[i] = q >> 8;
|
||||
@@ -1038,17 +1038,17 @@ void evalMixes(uint8_t tick10ms)
|
||||
sei();
|
||||
}
|
||||
|
||||
if (tick10ms && s_fade_flight_phases) {
|
||||
if (tick10ms && flightModesFade) {
|
||||
uint16_t tick_delta = delta * tick10ms;
|
||||
for (uint8_t p=0; p<MAX_FLIGHT_MODES; p++) {
|
||||
ACTIVE_PHASES_TYPE phaseMask = ((ACTIVE_PHASES_TYPE)1 << p);
|
||||
if (s_fade_flight_phases & phaseMask) {
|
||||
if (p == phase) {
|
||||
ACTIVE_PHASES_TYPE flightModeMask = ((ACTIVE_PHASES_TYPE)1 << p);
|
||||
if (flightModesFade & flightModeMask) {
|
||||
if (p == fm) {
|
||||
if (MAX_ACT - fp_act[p] > tick_delta)
|
||||
fp_act[p] += tick_delta;
|
||||
else {
|
||||
fp_act[p] = MAX_ACT;
|
||||
s_fade_flight_phases -= phaseMask;
|
||||
flightModesFade -= flightModeMask;
|
||||
}
|
||||
}
|
||||
else {
|
||||
@@ -1056,12 +1056,12 @@ void evalMixes(uint8_t tick10ms)
|
||||
fp_act[p] -= tick_delta;
|
||||
else {
|
||||
fp_act[p] = 0;
|
||||
s_fade_flight_phases -= phaseMask;
|
||||
flightModesFade -= flightModeMask;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} //endif s_fade_fligh_phases
|
||||
}
|
||||
|
||||
#if defined(PCBGRUVIN9X) && defined(DEBUG) && !defined(VOICE)
|
||||
PORTH &= ~0x40; // PORTH:6 HIGH->LOW signals end of mixer interrupt
|
||||
|
||||
+17
-17
@@ -205,7 +205,7 @@ typedef int16_t gvar_t;
|
||||
#endif
|
||||
#define MODEL_GVARS_DATA global_gvar_t gvars[MAX_GVARS];
|
||||
#define PHASE_GVARS_DATA gvar_t gvars[MAX_GVARS]
|
||||
#define GVAR_VALUE(x, p) g_model.phaseData[p].gvars[x]
|
||||
#define GVAR_VALUE(x, p) g_model.flightModeData[p].gvars[x]
|
||||
#endif
|
||||
|
||||
PACK(typedef struct t_TrainerMix {
|
||||
@@ -481,7 +481,7 @@ PACK(typedef struct {
|
||||
uint16_t scale;
|
||||
uint8_t chn;
|
||||
int8_t swtch;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
int8_t weight;
|
||||
int8_t carryTrim:6;
|
||||
uint8_t mode:2;
|
||||
@@ -499,7 +499,7 @@ PACK(typedef struct {
|
||||
uint8_t chn:4;
|
||||
uint8_t curveMode:2;
|
||||
int8_t swtch;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
int8_t weight;
|
||||
char name[LEN_EXPOMIX_NAME];
|
||||
int8_t curveParam;
|
||||
@@ -513,7 +513,7 @@ PACK(typedef struct t_ExpoData {
|
||||
uint8_t chn:2;
|
||||
uint8_t curveMode:1;
|
||||
uint8_t spare:3;
|
||||
uint8_t phases;
|
||||
uint8_t flightModes;
|
||||
int8_t swtch;
|
||||
uint8_t weight;
|
||||
int8_t curveParam;
|
||||
@@ -526,7 +526,7 @@ PACK(typedef struct t_ExpoData {
|
||||
uint8_t mode:2; // 0=end, 1=pos, 2=neg, 3=both
|
||||
int8_t swtch:6;
|
||||
uint8_t chn:2;
|
||||
uint8_t phases:5;
|
||||
uint8_t flightModes:5;
|
||||
uint8_t curveMode:1;
|
||||
uint8_t weight; // One spare bit here (used for GVARS)
|
||||
int8_t curveParam;
|
||||
@@ -540,9 +540,9 @@ PACK(typedef struct t_ExpoData {
|
||||
#define limit_min_max_t int16_t
|
||||
#define LIMIT_EXT_PERCENT 150
|
||||
#define LIMIT_EXT_MAX (LIMIT_EXT_PERCENT*10)
|
||||
#define LIMIT_MAX(lim) (GV_IS_GV_VALUE(lim->max, -LIMIT_EXT_MAX, LIMIT_EXT_MAX) ? GET_GVAR(lim->max, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, s_current_mixer_flight_mode)*10 : lim->max+1000)
|
||||
#define LIMIT_MIN(lim) (GV_IS_GV_VALUE(lim->min, -LIMIT_EXT_MAX, LIMIT_EXT_MAX) ? GET_GVAR(lim->min, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, s_current_mixer_flight_mode)*10 : lim->min-1000)
|
||||
#define LIMIT_OFS(lim) (GV_IS_GV_VALUE(lim->offset, -1000, 1000) ? GET_GVAR(lim->offset, -1000, 1000, s_current_mixer_flight_mode)*10 : lim->offset)
|
||||
#define LIMIT_MAX(lim) (GV_IS_GV_VALUE(lim->max, -LIMIT_EXT_MAX, LIMIT_EXT_MAX) ? GET_GVAR(lim->max, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, mixerCurrentFlightMode)*10 : lim->max+1000)
|
||||
#define LIMIT_MIN(lim) (GV_IS_GV_VALUE(lim->min, -LIMIT_EXT_MAX, LIMIT_EXT_MAX) ? GET_GVAR(lim->min, -LIMIT_EXT_MAX, LIMIT_EXT_MAX, mixerCurrentFlightMode)*10 : lim->min-1000)
|
||||
#define LIMIT_OFS(lim) (GV_IS_GV_VALUE(lim->offset, -1000, 1000) ? GET_GVAR(lim->offset, -1000, 1000, mixerCurrentFlightMode)*10 : lim->offset)
|
||||
#define LIMIT_MAX_RESX(lim) calc1000toRESX(LIMIT_MAX(lim))
|
||||
#define LIMIT_MIN_RESX(lim) calc1000toRESX(LIMIT_MIN(lim))
|
||||
#define LIMIT_OFS_RESX(lim) calc1000toRESX(LIMIT_OFS(lim))
|
||||
@@ -593,7 +593,7 @@ PACK(typedef struct t_LimitData {
|
||||
#if defined(PCBTARANIS)
|
||||
PACK(typedef struct {
|
||||
uint8_t destCh;
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
uint8_t mltpx:2; // multiplex method: 0 means +=, 1 means *=, 2 means :=
|
||||
uint8_t carryTrim:1;
|
||||
uint8_t spare1:5;
|
||||
@@ -615,7 +615,7 @@ PACK(typedef struct {
|
||||
PACK(typedef struct {
|
||||
uint8_t destCh:4;
|
||||
uint8_t mixWarn:4; // mixer warning
|
||||
uint16_t phases;
|
||||
uint16_t flightModes;
|
||||
uint8_t curveMode:1;
|
||||
uint8_t noExpo:1;
|
||||
int8_t carryTrim:3;
|
||||
@@ -673,7 +673,7 @@ PACK(typedef struct t_MixData {
|
||||
uint8_t srcRaw;
|
||||
int8_t weight;
|
||||
int8_t swtch;
|
||||
uint8_t phases;
|
||||
uint8_t flightModes;
|
||||
uint8_t mltpx:2; // multiplex method: 0 means +=, 1 means *=, 2 means :=
|
||||
int8_t carryTrim:3;
|
||||
uint8_t mixWarn:2; // mixer warning
|
||||
@@ -695,7 +695,7 @@ PACK(typedef struct t_MixData {
|
||||
int8_t weight;
|
||||
int8_t swtch:6;
|
||||
uint8_t mltpx:2; // multiplex method: 0 means +=, 1 means *=, 2 means :=
|
||||
uint8_t phases:5;
|
||||
uint8_t flightModes:5;
|
||||
int8_t carryTrim:3;
|
||||
uint8_t srcRaw:6;
|
||||
uint8_t mixWarn:2; // mixer warning
|
||||
@@ -1315,7 +1315,7 @@ PACK(typedef struct t_SwashRingData { // Swash Ring data
|
||||
#endif
|
||||
|
||||
#if defined(CPUARM)
|
||||
PACK(typedef struct t_PhaseData {
|
||||
PACK(typedef struct t_FlightModeData {
|
||||
TRIMS_ARRAY;
|
||||
int8_t swtch; // swtch of phase[0] is not used
|
||||
char name[LEN_FP_NAME];
|
||||
@@ -1323,9 +1323,9 @@ PACK(typedef struct t_PhaseData {
|
||||
uint8_t fadeOut;
|
||||
ROTARY_ENCODER_ARRAY;
|
||||
PHASE_GVARS_DATA;
|
||||
}) PhaseData;
|
||||
}) FlightModeData;
|
||||
#else
|
||||
PACK(typedef struct t_PhaseData {
|
||||
PACK(typedef struct t_FlightModeData {
|
||||
TRIMS_ARRAY;
|
||||
int8_t swtch; // swtch of phase[0] is not used
|
||||
char name[LEN_FP_NAME];
|
||||
@@ -1333,7 +1333,7 @@ PACK(typedef struct t_PhaseData {
|
||||
uint8_t fadeOut:4;
|
||||
ROTARY_ENCODER_ARRAY;
|
||||
PHASE_GVARS_DATA;
|
||||
}) PhaseData;
|
||||
}) FlightModeData;
|
||||
#endif
|
||||
|
||||
enum SwitchSources {
|
||||
@@ -1730,7 +1730,7 @@ PACK(typedef struct t_ModelData {
|
||||
LogicalSwitchData logicalSw[NUM_LOGICAL_SWITCH];
|
||||
CustomFnData funcSw[NUM_CFN];
|
||||
SwashRingData swashR;
|
||||
PhaseData phaseData[MAX_FLIGHT_MODES];
|
||||
FlightModeData flightModeData[MAX_FLIGHT_MODES];
|
||||
|
||||
AVR_FIELD(int8_t ppmFrameLength) // 0=22.5ms (10ms-30ms) 0.5ms increments
|
||||
uint8_t thrTraceSrc;
|
||||
|
||||
+24
-24
@@ -261,9 +261,9 @@ void per10ms()
|
||||
heartbeat |= HEART_TIMER_10MS;
|
||||
}
|
||||
|
||||
PhaseData *phaseAddress(uint8_t idx)
|
||||
FlightModeData *flightModeAddress(uint8_t idx)
|
||||
{
|
||||
return &g_model.phaseData[idx];
|
||||
return &g_model.flightModeData[idx];
|
||||
}
|
||||
|
||||
ExpoData *expoAddress(uint8_t idx )
|
||||
@@ -492,10 +492,10 @@ int8_t getMovedSource(GET_MOVED_SOURCE_PARAMS)
|
||||
#endif
|
||||
|
||||
#if defined(FLIGHT_MODES)
|
||||
uint8_t getFlightPhase()
|
||||
uint8_t getFlightMode()
|
||||
{
|
||||
for (uint8_t i=1; i<MAX_FLIGHT_MODES; i++) {
|
||||
PhaseData *phase = &g_model.phaseData[i];
|
||||
FlightModeData *phase = &g_model.flightModeData[i];
|
||||
if (phase->swtch && getSwitch(phase->swtch)) {
|
||||
return i;
|
||||
}
|
||||
@@ -506,7 +506,7 @@ uint8_t getFlightPhase()
|
||||
|
||||
trim_t getRawTrimValue(uint8_t phase, uint8_t idx)
|
||||
{
|
||||
PhaseData *p = phaseAddress(phase);
|
||||
FlightModeData *p = flightModeAddress(phase);
|
||||
#if defined(PCBSTD)
|
||||
return (((trim_t)p->trim[idx]) << 2) + ((p->trim_ext >> (2*idx)) & 0x03);
|
||||
#else
|
||||
@@ -546,7 +546,7 @@ void setTrimValue(uint8_t phase, uint8_t idx, int trim)
|
||||
{
|
||||
#if defined(PCBTARANIS)
|
||||
for (uint8_t i=0; i<MAX_FLIGHT_MODES; i++) {
|
||||
trim_t & v = phaseAddress(phase)->trim[idx];
|
||||
trim_t & v = flightModeAddress(phase)->trim[idx];
|
||||
if (v.mode == TRIM_MODE_NONE)
|
||||
return;
|
||||
unsigned int p = v.mode >> 1;
|
||||
@@ -563,12 +563,12 @@ void setTrimValue(uint8_t phase, uint8_t idx, int trim)
|
||||
}
|
||||
}
|
||||
#elif defined(PCBSTD)
|
||||
PhaseData *p = phaseAddress(phase);
|
||||
FlightModeData *p = flightModeAddress(phase);
|
||||
p->trim[idx] = (int8_t)(trim >> 2);
|
||||
idx <<= 1;
|
||||
p->trim_ext = (p->trim_ext & ~(0x03 << idx)) + (((trim & 0x03) << idx));
|
||||
#else
|
||||
PhaseData *p = phaseAddress(phase);
|
||||
FlightModeData *p = flightModeAddress(phase);
|
||||
p->trim[idx] = trim;
|
||||
#endif
|
||||
eeDirty(EE_MODEL);
|
||||
@@ -592,10 +592,10 @@ uint8_t getTrimFlightPhase(uint8_t phase, uint8_t idx)
|
||||
#if defined(ROTARY_ENCODERS)
|
||||
uint8_t getRotaryEncoderFlightPhase(uint8_t idx)
|
||||
{
|
||||
uint8_t phase = s_current_mixer_flight_mode;
|
||||
uint8_t phase = mixerCurrentFlightMode;
|
||||
for (uint8_t i=0; i<MAX_FLIGHT_MODES; i++) {
|
||||
if (phase == 0) return 0;
|
||||
int16_t value = phaseAddress(phase)->rotaryEncoders[idx];
|
||||
int16_t value = flightModeAddress(phase)->rotaryEncoders[idx];
|
||||
if (value <= ROTARY_ENCODER_MAX) return phase;
|
||||
uint8_t result = value-ROTARY_ENCODER_MAX-1;
|
||||
if (result >= phase) result++;
|
||||
@@ -606,13 +606,13 @@ uint8_t getRotaryEncoderFlightPhase(uint8_t idx)
|
||||
|
||||
int16_t getRotaryEncoder(uint8_t idx)
|
||||
{
|
||||
return phaseAddress(getRotaryEncoderFlightPhase(idx))->rotaryEncoders[idx];
|
||||
return flightModeAddress(getRotaryEncoderFlightPhase(idx))->rotaryEncoders[idx];
|
||||
}
|
||||
|
||||
void incRotaryEncoder(uint8_t idx, int8_t inc)
|
||||
{
|
||||
g_rotenc[idx] += inc;
|
||||
int16_t *value = &(phaseAddress(getRotaryEncoderFlightPhase(idx))->rotaryEncoders[idx]);
|
||||
int16_t *value = &(flightModeAddress(getRotaryEncoderFlightPhase(idx))->rotaryEncoders[idx]);
|
||||
*value = limit((int16_t)-1024, (int16_t)(*value + (inc * 8)), (int16_t)+1024);
|
||||
eeDirty(EE_MODEL);
|
||||
}
|
||||
@@ -1222,13 +1222,13 @@ uint8_t checkTrim(uint8_t event)
|
||||
#if defined(PCBSTD)
|
||||
phase = 0;
|
||||
#else
|
||||
phase = getGVarFlightPhase(s_current_mixer_flight_mode, trimGvar[idx]);
|
||||
phase = getGVarFlightPhase(mixerCurrentFlightMode, trimGvar[idx]);
|
||||
#endif
|
||||
before = GVAR_VALUE(trimGvar[idx], phase);
|
||||
thro = false;
|
||||
}
|
||||
else {
|
||||
phase = getTrimFlightPhase(s_current_mixer_flight_mode, idx);
|
||||
phase = getTrimFlightPhase(mixerCurrentFlightMode, idx);
|
||||
#if defined(PCBTARANIS)
|
||||
before = getTrimValue(phase, idx);
|
||||
#else
|
||||
@@ -1237,7 +1237,7 @@ uint8_t checkTrim(uint8_t event)
|
||||
thro = (idx==THR_STICK && g_model.thrTrim);
|
||||
}
|
||||
#else
|
||||
phase = getTrimFlightPhase(s_current_mixer_flight_mode, idx);
|
||||
phase = getTrimFlightPhase(mixerCurrentFlightMode, idx);
|
||||
#if defined(PCBTARANIS)
|
||||
before = getTrimValue(phase, idx);
|
||||
#else
|
||||
@@ -1597,7 +1597,7 @@ uint16_t s_sum_samples_thr_10s;
|
||||
|
||||
FORCEINLINE void evalTrims()
|
||||
{
|
||||
uint8_t phase = s_current_mixer_flight_mode;
|
||||
uint8_t phase = mixerCurrentFlightMode;
|
||||
for (uint8_t i=0; i<NUM_STICKS; i++) {
|
||||
// do trim -> throttle trim if applicable
|
||||
int16_t trim = getTrimValue(phase, i);
|
||||
@@ -1918,14 +1918,14 @@ void evalFunctions()
|
||||
#if defined(GVARS)
|
||||
case FUNC_ADJUST_GVAR:
|
||||
if (CFN_GVAR_MODE(sd) == 0) {
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), CFN_PARAM(sd), s_current_mixer_flight_mode);
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), CFN_PARAM(sd), mixerCurrentFlightMode);
|
||||
}
|
||||
else if (CFN_GVAR_MODE(sd) == 2) {
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_PARAM(sd), s_current_mixer_flight_mode), s_current_mixer_flight_mode);
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_PARAM(sd), mixerCurrentFlightMode), mixerCurrentFlightMode);
|
||||
}
|
||||
else if (CFN_GVAR_MODE(sd) == 3) {
|
||||
if (!(activeFnSwitches & switch_mask)) {
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_GVAR_INDEX(sd), getGVarFlightPhase(s_current_mixer_flight_mode, CFN_GVAR_INDEX(sd))) + (CFN_PARAM(sd) ? +1 : -1), s_current_mixer_flight_mode);
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_GVAR_INDEX(sd), getGVarFlightPhase(mixerCurrentFlightMode, CFN_GVAR_INDEX(sd))) + (CFN_PARAM(sd) ? +1 : -1), mixerCurrentFlightMode);
|
||||
}
|
||||
}
|
||||
else if (CFN_PARAM(sd) >= MIXSRC_TrimRud && CFN_PARAM(sd) <= MIXSRC_TrimAil) {
|
||||
@@ -1935,12 +1935,12 @@ void evalFunctions()
|
||||
else if (CFN_PARAM(sd) >= MIXSRC_REa && CFN_PARAM(sd) < MIXSRC_TrimRud) {
|
||||
int8_t scroll = rePreviousValues[CFN_PARAM(sd)-MIXSRC_REa] - (g_rotenc[CFN_PARAM(sd)-MIXSRC_REa] / ROTARY_ENCODER_GRANULARITY);
|
||||
if (scroll) {
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_GVAR_INDEX(sd), getGVarFlightPhase(s_current_mixer_flight_mode, CFN_GVAR_INDEX(sd))) + scroll, s_current_mixer_flight_mode);
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), GVAR_VALUE(CFN_GVAR_INDEX(sd), getGVarFlightPhase(mixerCurrentFlightMode, CFN_GVAR_INDEX(sd))) + scroll, mixerCurrentFlightMode);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), calcRESXto100(getValue(CFN_PARAM(sd))), s_current_mixer_flight_mode);
|
||||
SET_GVAR(CFN_GVAR_INDEX(sd), calcRESXto100(getValue(CFN_PARAM(sd))), mixerCurrentFlightMode);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
@@ -2023,7 +2023,7 @@ void evalFunctions()
|
||||
else {
|
||||
#if defined(GVARS)
|
||||
if (CFN_FUNC(sd) == FUNC_PLAY_TRACK && param > 250)
|
||||
param = GVAR_VALUE(param-251, getGVarFlightPhase(s_current_mixer_flight_mode, param-251));
|
||||
param = GVAR_VALUE(param-251, getGVarFlightPhase(mixerCurrentFlightMode, param-251));
|
||||
#endif
|
||||
PUSH_CUSTOM_PROMPT(active ? param : param+1, i+1);
|
||||
}
|
||||
@@ -3024,7 +3024,7 @@ void instantTrim()
|
||||
for (uint8_t i=0; i<NUM_STICKS; i++) {
|
||||
if (i!=THR_STICK) {
|
||||
// don't instant trim the throttle stick
|
||||
uint8_t trim_phase = getTrimFlightPhase(s_current_mixer_flight_mode, i);
|
||||
uint8_t trim_phase = getTrimFlightPhase(mixerCurrentFlightMode, i);
|
||||
#if defined(PCBTARANIS)
|
||||
int16_t delta = calibratedStick[i];
|
||||
#else
|
||||
@@ -3091,7 +3091,7 @@ void moveTrimsToOffsets() // copy state of 3 primary to subtrim
|
||||
// reset all trims, except throttle (if throttle trim)
|
||||
for (uint8_t i=0; i<NUM_STICKS; i++) {
|
||||
if (i!=THR_STICK || !g_model.thrTrim) {
|
||||
int16_t original_trim = getTrimValue(s_current_mixer_flight_mode, i);
|
||||
int16_t original_trim = getTrimValue(mixerCurrentFlightMode, i);
|
||||
for (uint8_t phase=0; phase<MAX_FLIGHT_MODES; phase++) {
|
||||
#if defined(PCBTARANIS)
|
||||
trim_t trim = getRawTrimValue(phase, i);
|
||||
|
||||
+6
-6
@@ -647,7 +647,7 @@ extern void alert(const pm_char * t, const pm_char * s MESSAGE_SOUND_ARG);
|
||||
|
||||
enum PerOutMode {
|
||||
e_perout_mode_normal = 0,
|
||||
e_perout_mode_inactive_phase = 1,
|
||||
e_perout_mode_inactive_flight_mode = 1,
|
||||
e_perout_mode_notrainer = 2,
|
||||
e_perout_mode_notrims = 4,
|
||||
e_perout_mode_nosticks = 8,
|
||||
@@ -673,7 +673,7 @@ enum StartupWarningStates {
|
||||
#define FORCE_INDIRECT(ptr) __asm__ __volatile__ ("" : "=e" (ptr) : "0" (ptr))
|
||||
#endif
|
||||
|
||||
extern uint8_t s_current_mixer_flight_mode;
|
||||
extern uint8_t mixerCurrentFlightMode;
|
||||
extern uint8_t s_last_phase;
|
||||
extern uint8_t flightModeTransitionLast;
|
||||
|
||||
@@ -740,9 +740,9 @@ int8_t getMovedSwitch();
|
||||
#endif
|
||||
|
||||
#if defined(FLIGHT_MODES)
|
||||
extern uint8_t getFlightPhase();
|
||||
extern uint8_t getFlightMode();
|
||||
#else
|
||||
#define getFlightPhase() 0
|
||||
#define getFlightMode() 0
|
||||
#endif
|
||||
|
||||
#if !defined(PCBTARANIS)
|
||||
@@ -1137,7 +1137,7 @@ extern uint16_t lightOffCounter;
|
||||
extern uint8_t flashCounter;
|
||||
extern uint8_t mixWarning;
|
||||
|
||||
PhaseData *phaseAddress(uint8_t idx);
|
||||
FlightModeData *flightModeAddress(uint8_t idx);
|
||||
ExpoData *expoAddress(uint8_t idx);
|
||||
MixData *mixAddress(uint8_t idx);
|
||||
LimitData *limitAddress(uint8_t idx);
|
||||
@@ -1563,7 +1563,7 @@ uint8_t zlen(const char *str, uint8_t size);
|
||||
bool zexist(const char *str, uint8_t size);
|
||||
char * strcat_zchar(char * dest, char * name, uint8_t size, const char *defaultName, uint8_t defaultNameSize, uint8_t defaultIdx);
|
||||
#define strcat_modelname(dest, idx) strcat_zchar(dest, modelHeaders[idx].name, LEN_MODEL_NAME, STR_MODEL, PSIZE(TR_MODEL), idx+1)
|
||||
#define strcat_phasename(dest, idx) strcat_zchar(dest, g_model.phaseData[idx].name, LEN_FP_NAME, STR_FP, PSIZE(TR_FP), idx+1)
|
||||
#define strcat_phasename(dest, idx) strcat_zchar(dest, g_model.flightModeData[idx].name, LEN_FP_NAME, STR_FP, PSIZE(TR_FP), idx+1)
|
||||
#define ZLEN(s) zlen(s, sizeof(s))
|
||||
#define ZEXIST(s) zexist(s, sizeof(s))
|
||||
#endif
|
||||
|
||||
+13
-13
@@ -188,7 +188,7 @@ bool getLogicalSwitch(uint8_t idx)
|
||||
#endif
|
||||
|
||||
if (ls->func == LS_FUNC_NONE || (s && !getSwitch(s))) {
|
||||
LS_LAST_VALUE(s_current_mixer_flight_mode, idx) = CS_LAST_VALUE_INIT;
|
||||
LS_LAST_VALUE(mixerCurrentFlightMode, idx) = CS_LAST_VALUE_INIT;
|
||||
result = false;
|
||||
}
|
||||
else if ((s=lswFamily(ls->func)) == LS_FAMILY_BOOL) {
|
||||
@@ -208,14 +208,14 @@ bool getLogicalSwitch(uint8_t idx)
|
||||
}
|
||||
}
|
||||
else if (s == LS_FAMILY_TIMER) {
|
||||
result = (LS_LAST_VALUE(s_current_mixer_flight_mode, idx) <= 0);
|
||||
result = (LS_LAST_VALUE(mixerCurrentFlightMode, idx) <= 0);
|
||||
}
|
||||
else if (s == LS_FAMILY_STICKY) {
|
||||
result = (LS_LAST_VALUE(s_current_mixer_flight_mode, idx) & (1<<0));
|
||||
result = (LS_LAST_VALUE(mixerCurrentFlightMode, idx) & (1<<0));
|
||||
}
|
||||
#if defined(CPUARM)
|
||||
else if (s == LS_FAMILY_STAY) {
|
||||
result = (LS_LAST_VALUE(s_current_mixer_flight_mode, idx) & (1<<0));
|
||||
result = (LS_LAST_VALUE(mixerCurrentFlightMode, idx) & (1<<0));
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
@@ -303,10 +303,10 @@ bool getLogicalSwitch(uint8_t idx)
|
||||
break;
|
||||
default:
|
||||
{
|
||||
if (LS_LAST_VALUE(s_current_mixer_flight_mode, idx) == CS_LAST_VALUE_INIT) {
|
||||
LS_LAST_VALUE(s_current_mixer_flight_mode, idx) = x;
|
||||
if (LS_LAST_VALUE(mixerCurrentFlightMode, idx) == CS_LAST_VALUE_INIT) {
|
||||
LS_LAST_VALUE(mixerCurrentFlightMode, idx) = x;
|
||||
}
|
||||
int16_t diff = x - LS_LAST_VALUE(s_current_mixer_flight_mode, idx);
|
||||
int16_t diff = x - LS_LAST_VALUE(mixerCurrentFlightMode, idx);
|
||||
bool update = false;
|
||||
if (ls->func == LS_FUNC_DIFFEGREATER) {
|
||||
if (y >= 0) {
|
||||
@@ -324,7 +324,7 @@ bool getLogicalSwitch(uint8_t idx)
|
||||
result = (abs(diff) >= y);
|
||||
}
|
||||
if (result || update) {
|
||||
LS_LAST_VALUE(s_current_mixer_flight_mode, idx) = x;
|
||||
LS_LAST_VALUE(mixerCurrentFlightMode, idx) = x;
|
||||
}
|
||||
break;
|
||||
}
|
||||
@@ -334,7 +334,7 @@ bool getLogicalSwitch(uint8_t idx)
|
||||
|
||||
#if defined(CPUARM)
|
||||
if (ls->delay || ls->duration) {
|
||||
LogicalSwitchContext &context = lswFm[s_current_mixer_flight_mode].lsw[idx];
|
||||
LogicalSwitchContext &context = lswFm[mixerCurrentFlightMode].lsw[idx];
|
||||
if (result) {
|
||||
if (context.timerState == SWITCH_START) {
|
||||
// set delay timer
|
||||
@@ -438,13 +438,13 @@ bool getSwitch(int8_t swtch)
|
||||
if (flags & GETSWITCH_MIDPOS_DELAY)
|
||||
result = (idx == flightModeTransitionLast);
|
||||
else
|
||||
result = (idx == s_current_mixer_flight_mode);
|
||||
result = (idx == mixerCurrentFlightMode);
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
cs_idx -= SWSRC_FIRST_LOGICAL_SWITCH;
|
||||
#if defined(CPUARM)
|
||||
result = lswFm[s_current_mixer_flight_mode].lsw[cs_idx].state;
|
||||
result = lswFm[mixerCurrentFlightMode].lsw[cs_idx].state;
|
||||
#else
|
||||
GETSWITCH_RECURSIVE_TYPE mask = ((GETSWITCH_RECURSIVE_TYPE)1 << cs_idx);
|
||||
if (s_last_switch_used & mask) {
|
||||
@@ -468,12 +468,12 @@ bool getSwitch(int8_t swtch)
|
||||
|
||||
#if defined(CPUARM)
|
||||
/**
|
||||
@brief Calculates new state of logical switches for s_current_mixer_flight_mode
|
||||
@brief Calculates new state of logical switches for mixerCurrentFlightMode
|
||||
*/
|
||||
void evalLogicalSwitches(bool isCurrentPhase)
|
||||
{
|
||||
for (unsigned int idx=0; idx<NUM_LOGICAL_SWITCH; idx++) {
|
||||
LogicalSwitchContext &context = lswFm[s_current_mixer_flight_mode].lsw[idx];
|
||||
LogicalSwitchContext &context = lswFm[mixerCurrentFlightMode].lsw[idx];
|
||||
bool result = getLogicalSwitch(idx);
|
||||
if (isCurrentPhase) {
|
||||
if (result) {
|
||||
|
||||
Reference in New Issue
Block a user