692 lines
21 KiB
C++
692 lines
21 KiB
C++
/*
|
|
* Copyright (C) EdgeTX
|
|
*
|
|
* Based on code named
|
|
* opentx - https://github.com/opentx/opentx
|
|
* th9x - http://code.google.com/p/th9x
|
|
* er9x - http://code.google.com/p/er9x
|
|
* gruvin9x - http://code.google.com/p/gruvin9x
|
|
*
|
|
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "edgetx.h"
|
|
#include "switches.h"
|
|
#include "tasks/mixer_task.h"
|
|
|
|
#include "hal/audio_driver.h"
|
|
#include "os/time.h"
|
|
|
|
#if defined(VIDEO_SWITCH)
|
|
#include "videoswitch_driver.h"
|
|
#if defined(SIMU)
|
|
void switchToRadio() {};
|
|
void switchToVideo() {};
|
|
#endif
|
|
#endif
|
|
|
|
CustomFunctionsContext modelFunctionsContext = { 0 };
|
|
CustomFunctionsContext globalFunctionsContext = { 0 };
|
|
|
|
#if defined(DEBUG)
|
|
/*
|
|
* This is a test function for debugging purpose, you may insert there your code and compile with the option DEBUG=YES
|
|
*/
|
|
void testFunc()
|
|
{
|
|
#ifdef SIMU
|
|
printf("testFunc\n"); fflush(stdout);
|
|
#endif
|
|
|
|
// for testing the WD reset uncomment the following line
|
|
// while (1);
|
|
}
|
|
#endif
|
|
|
|
PLAY_FUNCTION(playValue, mixsrc_t idx)
|
|
{
|
|
if (IS_FAI_FORBIDDEN(idx))
|
|
return;
|
|
|
|
if (idx == MIXSRC_NONE)
|
|
return;
|
|
|
|
getvalue_t val = getValue(idx);
|
|
idx = abs(idx); // Don't need negative form any longer
|
|
|
|
if (idx >= MIXSRC_FIRST_TELEM) {
|
|
TelemetrySensor & telemetrySensor = g_model.telemetrySensors[(idx-MIXSRC_FIRST_TELEM) / 3];
|
|
uint8_t attr = 0;
|
|
|
|
// Preserve the sign
|
|
int sign = (val >= 0) ? 1 : -1;
|
|
val = abs(val);
|
|
|
|
if (telemetrySensor.prec > 0) {
|
|
if (telemetrySensor.prec == 2) {
|
|
if (val >= 5000) {
|
|
val = divRoundClosest(val, 100);
|
|
}
|
|
else {
|
|
val = divRoundClosest(val, 10);
|
|
attr = PREC1;
|
|
}
|
|
}
|
|
else {
|
|
if (val >= 500) {
|
|
val = divRoundClosest(val, 10);
|
|
}
|
|
else {
|
|
attr = PREC1;
|
|
}
|
|
}
|
|
}
|
|
|
|
val *= sign; // Reapply sign if needed
|
|
|
|
PLAY_NUMBER(val, telemetrySensor.unit == UNIT_CELLS ? UNIT_VOLTS : telemetrySensor.unit, attr);
|
|
}
|
|
else if (idx >= MIXSRC_FIRST_TIMER && idx <= MIXSRC_LAST_TIMER) {
|
|
int flag = 0;
|
|
if (abs(val) > LONG_TIMER_DURATION) {
|
|
flag = PLAY_LONG_TIMER;
|
|
}
|
|
PLAY_DURATION(val, flag);
|
|
} else if (idx == MIXSRC_TX_TIME) {
|
|
PLAY_DURATION(val * 60, PLAY_TIME);
|
|
} else if (idx == MIXSRC_TX_VOLTAGE) {
|
|
PLAY_NUMBER(val, UNIT_VOLTS, PREC1);
|
|
#if defined(LUMINOSITY_SENSOR)
|
|
} else if (idx == MIXSRC_LIGHT) {
|
|
PLAY_NUMBER(val, UNIT_RAW, 0);
|
|
#endif
|
|
} else {
|
|
if (idx <= MIXSRC_LAST_CH) {
|
|
val = calcRESXto100(val);
|
|
}
|
|
PLAY_NUMBER(val, 0, 0);
|
|
}
|
|
}
|
|
|
|
void playCustomFunctionFile(const CustomFunctionData * sd, uint8_t id)
|
|
{
|
|
if (sd->play.name[0] != '\0') {
|
|
char filename[sizeof(SOUNDS_PATH) + LEN_FUNCTION_NAME + sizeof(SOUNDS_EXT)] = SOUNDS_PATH "/";
|
|
strncpy(filename + SOUNDS_PATH_LNG_OFS, currentLanguagePack->id, 2);
|
|
strncpy(filename + sizeof(SOUNDS_PATH), sd->play.name, LEN_FUNCTION_NAME);
|
|
filename[sizeof(SOUNDS_PATH) + LEN_FUNCTION_NAME] = '\0';
|
|
strcat(filename + sizeof(SOUNDS_PATH), SOUNDS_EXT);
|
|
PLAY_FILE(filename, sd->func == FUNC_BACKGND_MUSIC ? PLAY_BACKGROUND : 0, id);
|
|
}
|
|
}
|
|
|
|
bool isRepeatDelayElapsed(const CustomFunctionData * functions, CustomFunctionsContext & functionsContext, uint8_t index)
|
|
{
|
|
const CustomFunctionData * cfn = &functions[index];
|
|
tmr10ms_t tmr10ms = get_tmr10ms();
|
|
int8_t repeatParam = CFN_PLAY_REPEAT(cfn);
|
|
|
|
// hold prompts during startup: silence window is the floor, extended while permanent Lua scripts load
|
|
bool startupBusy = !IS_SILENCE_PERIOD_ELAPSED();
|
|
#if defined(LUA)
|
|
if (luaState >= INTERPRETER_RELOAD_PERMANENT_SCRIPTS && luaState < INTERPRETER_RUNNING)
|
|
startupBusy = true;
|
|
#endif
|
|
|
|
if (startupBusy) {
|
|
if (repeatParam == CFN_PLAY_REPEAT_NOSTART) {
|
|
functionsContext.lastFunctionTime[index] = tmr10ms; // '!1x': suppress at startup
|
|
} else {
|
|
return false; // defer until startup settles, don't stamp
|
|
}
|
|
}
|
|
if (!functionsContext.lastFunctionTime[index] || (repeatParam && repeatParam!=CFN_PLAY_REPEAT_NOSTART && (signed)(tmr10ms-functionsContext.lastFunctionTime[index])>=100*repeatParam)) {
|
|
functionsContext.lastFunctionTime[index] = tmr10ms;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool isUIFunction(uint16_t f, int16_t p)
|
|
{
|
|
return f == FUNC_LOGS || f == FUNC_SET_SCREEN || f == FUNC_SCREENSHOT || f == FUNC_BACKLIGHT
|
|
#if defined(AUDIO)
|
|
|| f == FUNC_VOLUME
|
|
#endif
|
|
#if defined(HARDWARE_TOUCH)
|
|
|| f == FUNC_DISABLE_TOUCH
|
|
#endif
|
|
#if defined(KEYS_LOCK_KEY1) && defined(KEYS_LOCK_KEY2)
|
|
|| f == FUNC_DISABLE_KEYS
|
|
#endif
|
|
|| (f == FUNC_RESET && p == FUNC_RESET_FLIGHT);
|
|
}
|
|
|
|
void evalFunctions(CustomFunctionData * functions, CustomFunctionsContext & functionsContext)
|
|
{
|
|
MASK_FUNC_TYPE newActiveFunctions = 0;
|
|
MASK_CFN_TYPE newActiveSwitches = 0;
|
|
|
|
#if defined(FUNCTION_SWITCHES)
|
|
g_model.cfsResetSFState();
|
|
#endif
|
|
|
|
uint8_t playFirstIndex = (functions == g_model.customFn ? 1 : 1+MAX_SPECIAL_FUNCTIONS);
|
|
#define PLAY_INDEX (i+playFirstIndex)
|
|
|
|
#if defined(OVERRIDE_CHANNEL_FUNCTION)
|
|
for (uint8_t i=0; i<MAX_OUTPUT_CHANNELS; i++) {
|
|
safetyCh[i] = OVERRIDE_CHANNEL_UNDEFINED;
|
|
}
|
|
#endif
|
|
|
|
#if defined(GVARS)
|
|
for (uint8_t i=0; i<MAX_TRIMS; i++) {
|
|
trimGvar[i] = -1;
|
|
}
|
|
#endif
|
|
|
|
#if defined(VIDEO_SWITCH)
|
|
bool videoEnabled = false;
|
|
#endif
|
|
|
|
for (uint8_t i=0; i<MAX_SPECIAL_FUNCTIONS; i++) {
|
|
CustomFunctionData * cfn = &functions[i];
|
|
// Skip functions evaluated in UI task
|
|
if (isUIFunction(CFN_FUNC(cfn), CFN_PARAM(cfn))) {
|
|
continue;
|
|
}
|
|
swsrc_t swtch = CFN_SWITCH(cfn);
|
|
if (swtch) {
|
|
bool active = getSwitch(swtch, IS_PLAY_FUNC(CFN_FUNC(cfn)) ? GETSWITCH_MIDPOS_DELAY : 0);
|
|
// Handle case where function is disabled while active
|
|
if (CFN_ACTIVE(cfn) == 0)
|
|
active = false;
|
|
|
|
if (active) {
|
|
switch (CFN_FUNC(cfn)) {
|
|
#if defined(OVERRIDE_CHANNEL_FUNCTION)
|
|
case FUNC_OVERRIDE_CHANNEL:
|
|
safetyCh[CFN_CH_INDEX(cfn)] = CFN_PARAM(cfn);
|
|
break;
|
|
#endif
|
|
|
|
case FUNC_TRAINER: {
|
|
uint8_t param = CFN_CH_INDEX(cfn);
|
|
if (param == 0)
|
|
for (int i = 0; i < MAX_STICKS; i += 1)
|
|
newActiveFunctions |= (1u << i);
|
|
else if (param <= MAX_STICKS)
|
|
newActiveFunctions |= (1 << (param - 1));
|
|
else if (param == MAX_STICKS + 1)
|
|
newActiveFunctions |= (1u << FUNCTION_TRAINER_CHANNELS);
|
|
break;
|
|
}
|
|
|
|
case FUNC_INSTANT_TRIM:
|
|
if (IS_INSTANT_TRIM_ALLOWED()) {
|
|
// Use 'repeat' property to ensure single activation (repeat defaults to 1x)
|
|
if (isRepeatDelayElapsed(functions, functionsContext, i)) {
|
|
instantTrim();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FUNC_RESET:
|
|
switch (CFN_PARAM(cfn)) {
|
|
case FUNC_RESET_TIMER1:
|
|
case FUNC_RESET_TIMER2:
|
|
case FUNC_RESET_TIMER3:
|
|
timerReset(CFN_PARAM(cfn));
|
|
break;
|
|
case FUNC_RESET_FLIGHT:
|
|
// Handled in evalUIFunctions()
|
|
break;
|
|
case FUNC_RESET_TELEMETRY:
|
|
telemetryReset();
|
|
break;
|
|
case FUNC_RESET_TRIMS: {
|
|
for (uint8_t i = 0; i < keysGetMaxTrims(); i++) {
|
|
setTrimValue(mixerCurrentFlightMode, i, 0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (CFN_PARAM(cfn) >= FUNC_RESET_PARAM_FIRST_TELEM) {
|
|
uint8_t item = CFN_PARAM(cfn) - FUNC_RESET_PARAM_FIRST_TELEM;
|
|
if (item < MAX_TELEMETRY_SENSORS) {
|
|
telemetryItems[item].clear();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FUNC_SET_TIMER:
|
|
timerSet(CFN_TIMER_INDEX(cfn), CFN_PARAM(cfn));
|
|
break;
|
|
|
|
case FUNC_SET_FAILSAFE:
|
|
setCustomFailsafe(CFN_PARAM(cfn));
|
|
break;
|
|
|
|
#if defined(DANGEROUS_MODULE_FUNCTIONS)
|
|
case FUNC_RANGECHECK:
|
|
case FUNC_BIND: {
|
|
unsigned int moduleIndex = CFN_PARAM(cfn);
|
|
if (moduleIndex < NUM_MODULES) {
|
|
moduleState[moduleIndex].mode =
|
|
1 + CFN_FUNC(cfn) - FUNC_RANGECHECK;
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
#if defined(GVARS)
|
|
case FUNC_ADJUST_GVAR:
|
|
if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_CONSTANT) {
|
|
SET_GVAR(CFN_GVAR_INDEX(cfn), CFN_PARAM(cfn),
|
|
mixerCurrentFlightMode);
|
|
} else if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_GVAR) {
|
|
SET_GVAR(CFN_GVAR_INDEX(cfn),
|
|
GVAR_VALUE(CFN_PARAM(cfn),
|
|
getGVarFlightMode(mixerCurrentFlightMode,
|
|
CFN_PARAM(cfn))),
|
|
mixerCurrentFlightMode);
|
|
} else if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_INCDEC) {
|
|
if (!functionsContext.isFunctionSwitchActive(i)) {
|
|
SET_GVAR(CFN_GVAR_INDEX(cfn),
|
|
limit<int16_t>(MODEL_GVAR_MIN(CFN_GVAR_INDEX(cfn)),
|
|
GVAR_VALUE(CFN_GVAR_INDEX(cfn),
|
|
getGVarFlightMode(
|
|
mixerCurrentFlightMode,
|
|
CFN_GVAR_INDEX(cfn))) +
|
|
CFN_PARAM(cfn),
|
|
MODEL_GVAR_MAX(CFN_GVAR_INDEX(cfn))),
|
|
mixerCurrentFlightMode);
|
|
}
|
|
} else if (CFN_PARAM(cfn) >= MIXSRC_FIRST_TRIM &&
|
|
CFN_PARAM(cfn) <= MIXSRC_LAST_TRIM) {
|
|
trimGvar[CFN_PARAM(cfn) - MIXSRC_FIRST_TRIM] =
|
|
CFN_GVAR_INDEX(cfn);
|
|
} else {
|
|
if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_SOURCE)
|
|
SET_GVAR(CFN_GVAR_INDEX(cfn),
|
|
limit<int16_t>(MODEL_GVAR_MIN(CFN_GVAR_INDEX(cfn)),
|
|
calcRESXto100(getValue(CFN_PARAM(cfn))),
|
|
MODEL_GVAR_MAX(CFN_GVAR_INDEX(cfn))),
|
|
mixerCurrentFlightMode);
|
|
else
|
|
SET_GVAR(CFN_GVAR_INDEX(cfn),
|
|
limit<int16_t>(MODEL_GVAR_MIN(CFN_GVAR_INDEX(cfn)),
|
|
getValue(CFN_PARAM(cfn)),
|
|
MODEL_GVAR_MAX(CFN_GVAR_INDEX(cfn))),
|
|
mixerCurrentFlightMode);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case FUNC_PLAY_SOUND:
|
|
case FUNC_PLAY_TRACK:
|
|
case FUNC_PLAY_VALUE:
|
|
#if defined(HAPTIC)
|
|
case FUNC_HAPTIC:
|
|
#endif
|
|
{
|
|
if (isRepeatDelayElapsed(functions, functionsContext, i)) {
|
|
if (!IS_PLAYING(PLAY_INDEX)) {
|
|
if (CFN_FUNC(cfn) == FUNC_PLAY_SOUND) {
|
|
AUDIO_PLAY(AU_SPECIAL_SOUND_FIRST + CFN_PARAM(cfn));
|
|
} else if (CFN_FUNC(cfn) == FUNC_PLAY_VALUE) {
|
|
PLAY_VALUE(CFN_PARAM(cfn), PLAY_INDEX);
|
|
}
|
|
#if defined(HAPTIC)
|
|
else if (CFN_FUNC(cfn) == FUNC_HAPTIC) {
|
|
haptic.event(AU_SPECIAL_SOUND_LAST + CFN_PARAM(cfn));
|
|
}
|
|
#endif
|
|
else {
|
|
playCustomFunctionFile(cfn, PLAY_INDEX);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FUNC_BACKGND_MUSIC:
|
|
if (!(newActiveFunctions & (1 << FUNCTION_BACKGND_MUSIC))) {
|
|
newActiveFunctions |= (1 << FUNCTION_BACKGND_MUSIC);
|
|
if (!IS_PLAYING(PLAY_INDEX)) {
|
|
playCustomFunctionFile(cfn, PLAY_INDEX);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FUNC_BACKGND_MUSIC_PAUSE:
|
|
newActiveFunctions |= (1 << FUNCTION_BACKGND_MUSIC_PAUSE);
|
|
break;
|
|
|
|
#if defined(VARIO)
|
|
case FUNC_VARIO:
|
|
newActiveFunctions |= (1u << FUNCTION_VARIO);
|
|
break;
|
|
#endif
|
|
|
|
#if defined(FUNCTION_SWITCHES)
|
|
case FUNC_PUSH_CUST_SWITCH:
|
|
if (CFN_PARAM(cfn)) { // Duration is set
|
|
if (! CFN_VAL2(cfn) ) { // Duration not started yet
|
|
CFN_VAL2(cfn) = time_get_ms() + CFN_PARAM(cfn) * 100;
|
|
g_model.cfsSetSFState(CFN_CS_INDEX(cfn), 1);
|
|
}
|
|
else if (time_get_ms() < (uint32_t)CFN_VAL2(cfn) ) { // Still within push duration
|
|
g_model.cfsSetSFState(CFN_CS_INDEX(cfn), 1);
|
|
}
|
|
} else { // No duration set
|
|
g_model.cfsSetSFState(CFN_CS_INDEX(cfn), 1);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#if defined(PXX2)
|
|
case FUNC_RACING_MODE:
|
|
if (isRacingModeEnabled()) {
|
|
newActiveFunctions |= (1u << FUNCTION_RACING_MODE);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#if defined(AUDIO_MUTE_GPIO)
|
|
case FUNC_DISABLE_AUDIO_AMP:
|
|
newActiveFunctions |= (1u << FUNCTION_DISABLE_AUDIO_AMP);
|
|
break;
|
|
#endif
|
|
|
|
#if defined(VIDEO_SWITCH)
|
|
case FUNC_LCD_TO_VIDEO:
|
|
switchToVideo();
|
|
videoEnabled = true;
|
|
break;
|
|
#endif
|
|
|
|
#if defined(DEBUG)
|
|
case FUNC_TEST:
|
|
testFunc();
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
newActiveSwitches |= ((MASK_CFN_TYPE)1 << i);
|
|
} else {
|
|
#if defined(FUNCTION_SWITCHES)
|
|
if (CFN_FUNC(cfn) == FUNC_PUSH_CUST_SWITCH) {
|
|
// Handling duration after function is active
|
|
if (time_get_ms() < (uint32_t)CFN_VAL2(cfn)) {
|
|
g_model.cfsSetSFState(CFN_CS_INDEX(cfn), 1);
|
|
}
|
|
else {
|
|
CFN_VAL2(cfn) = 0;
|
|
}
|
|
}
|
|
#endif
|
|
functionsContext.lastFunctionTime[i] = 0;
|
|
#if defined(DANGEROUS_MODULE_FUNCTIONS)
|
|
if (functionsContext.isFunctionSwitchActive(i)) {
|
|
switch (CFN_FUNC(cfn)) {
|
|
case FUNC_RANGECHECK:
|
|
case FUNC_BIND:
|
|
{
|
|
unsigned int moduleIndex = CFN_PARAM(cfn);
|
|
if (moduleIndex < NUM_MODULES) {
|
|
moduleState[moduleIndex].mode = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(VIDEO_SWITCH)
|
|
if (!videoEnabled)
|
|
switchToRadio();
|
|
#endif
|
|
|
|
functionsContext.activeSwitches = newActiveSwitches;
|
|
functionsContext.activeFunctions = newActiveFunctions;
|
|
}
|
|
|
|
void evalUIFunctions(CustomFunctionData * functions, CustomFunctionsContext & functionsContext)
|
|
{
|
|
MASK_FUNC_TYPE newActiveFunctions = 0;
|
|
MASK_CFN_TYPE newActiveSwitches = 0;
|
|
|
|
for (uint8_t i=0; i<MAX_SPECIAL_FUNCTIONS; i++) {
|
|
CustomFunctionData * cfn = &functions[i];
|
|
// Skip functions evaluated in mixer task
|
|
if (!isUIFunction(CFN_FUNC(cfn), CFN_PARAM(cfn))) {
|
|
continue;
|
|
}
|
|
swsrc_t swtch = CFN_SWITCH(cfn);
|
|
if (swtch) {
|
|
|
|
bool active = getSwitch(swtch, 0);
|
|
// Handle case where function is disabled while active
|
|
if (CFN_ACTIVE(cfn) == 0)
|
|
active = false;
|
|
|
|
#if defined(KEYS_LOCK_KEY1) && defined(KEYS_LOCK_KEY2)
|
|
// 'No Keys' function checks both switch states
|
|
if (CFN_FUNC(cfn) == FUNC_DISABLE_KEYS) {
|
|
if (active != isFunctionActive(FUNCTION_DISABLE_KEYS))
|
|
setKeyLockedState(active);
|
|
if (active)
|
|
newActiveFunctions |= (1u << FUNCTION_DISABLE_KEYS);
|
|
}
|
|
#endif
|
|
|
|
#if defined(HARDWARE_TOUCH)
|
|
if (CFN_FUNC(cfn) == FUNC_DISABLE_TOUCH) {
|
|
if (active != isFunctionActive(FUNCTION_DISABLE_TOUCH))
|
|
POPUP_BUBBLE(active ? STR_TOUCH_DISABLED : STR_TOUCH_ENABLED, 1500, DEFAULT_BUBBLE_WIDTH, DEFAULT_BUBBLE_Y-BUBBLE_HEIGHT);
|
|
if (active)
|
|
newActiveFunctions |= (1u << FUNCTION_DISABLE_TOUCH);
|
|
}
|
|
#endif
|
|
|
|
if (active) {
|
|
switch (CFN_FUNC(cfn)) {
|
|
case FUNC_LOGS:
|
|
if (CFN_PARAM(cfn)) {
|
|
newActiveFunctions |= (1u << FUNCTION_LOGS);
|
|
logDelay100ms = CFN_PARAM(cfn); // logging period is 0..25.5s in 100ms increments
|
|
}
|
|
break;
|
|
|
|
case FUNC_SET_SCREEN:
|
|
if (isRepeatDelayElapsed(functions, functionsContext, i)) {
|
|
#if defined(COLORLCD)
|
|
extern void setRequestedMainView(uint8_t view);
|
|
setRequestedMainView(max(0, CFN_PARAM(cfn) - 1));
|
|
#else
|
|
extern void showTelemScreen(uint8_t index);
|
|
showTelemScreen(CFN_PARAM(cfn));
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case FUNC_SCREENSHOT:
|
|
// Use 'repeat' property to ensure single activation (repeat defaults to 1x)
|
|
if (isRepeatDelayElapsed(functions, functionsContext, i)) {
|
|
writeScreenshot();
|
|
}
|
|
break;
|
|
|
|
case FUNC_RESET:
|
|
if (CFN_PARAM(cfn) == FUNC_RESET_FLIGHT) {
|
|
// Use 'repeat' property to ensure single activation (repeat defaults to 1x)
|
|
if (isRepeatDelayElapsed(functions, functionsContext, i)) {
|
|
flightReset();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FUNC_BACKLIGHT: {
|
|
newActiveFunctions |= (1u << FUNCTION_BACKLIGHT);
|
|
if (!CFN_PARAM(cfn)) { // When no source is set, backlight works
|
|
// like original backlight and turn on
|
|
// regardless of backlight settings
|
|
requiredBacklightBright = BACKLIGHT_FORCED_ON;
|
|
} else {
|
|
calcBacklightValue(CFN_PARAM(cfn));
|
|
}
|
|
break;
|
|
}
|
|
|
|
#if defined(AUDIO)
|
|
case FUNC_VOLUME: {
|
|
newActiveFunctions |= (1u << FUNCTION_VOLUME);
|
|
calcVolumeValue(CFN_PARAM(cfn));
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
newActiveSwitches |= ((MASK_CFN_TYPE)1 << i);
|
|
} else {
|
|
functionsContext.lastFunctionTime[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
functionsContext.activeUIFunctions = newActiveFunctions;
|
|
functionsContext.activeUISwitches = newActiveSwitches;
|
|
|
|
if (!isFunctionActive(FUNCTION_BACKLIGHT)) {
|
|
if (g_eeGeneral.backlightSrc && mixerTaskRunning()) {
|
|
calcBacklightValue(g_eeGeneral.backlightSrc);
|
|
} else {
|
|
requiredBacklightBright = g_eeGeneral.getBrightness();
|
|
}
|
|
}
|
|
|
|
#if defined(AUDIO)
|
|
if (!isFunctionActive(FUNCTION_VOLUME)) {
|
|
if (g_eeGeneral.volumeSrc && mixerTaskRunning()) {
|
|
calcVolumeValue(g_eeGeneral.volumeSrc);
|
|
} else {
|
|
requiredSpeakerVolume =
|
|
limit<int>(0, g_eeGeneral.speakerVolume + VOLUME_LEVEL_DEF, VOLUME_LEVEL_MAX);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
const char* funcGetLabel(uint8_t func)
|
|
{
|
|
switch(func) {
|
|
case FUNC_OVERRIDE_CHANNEL:
|
|
return STR_SF_SAFETY;
|
|
case FUNC_TRAINER:
|
|
return STR_SF_TRAINER;
|
|
case FUNC_INSTANT_TRIM:
|
|
return STR_SF_INST_TRIM;
|
|
case FUNC_RESET:
|
|
return STR_SF_RESET;
|
|
case FUNC_SET_TIMER:
|
|
return STR_SF_SET_TIMER;
|
|
#if defined(GVARS)
|
|
case FUNC_ADJUST_GVAR:
|
|
return STR_ADJUST_GVAR;
|
|
#endif
|
|
case FUNC_VOLUME:
|
|
return STR_SF_VOLUME;
|
|
case FUNC_SET_FAILSAFE:
|
|
return STR_SF_FAILSAFE;
|
|
case FUNC_RANGECHECK:
|
|
return STR_SF_RANGE_CHECK;
|
|
case FUNC_BIND:
|
|
return STR_SF_MOD_BIND;
|
|
#if defined(AUDIO)
|
|
case FUNC_PLAY_SOUND:
|
|
return STR_SOUND;
|
|
#endif
|
|
case FUNC_PLAY_TRACK:
|
|
return STR_PLAY_TRACK;
|
|
case FUNC_PLAY_VALUE:
|
|
return STR_PLAY_VALUE;
|
|
#if defined(LUA)
|
|
case FUNC_PLAY_SCRIPT:
|
|
return STR_SF_PLAY_SCRIPT;
|
|
#endif
|
|
case FUNC_BACKGND_MUSIC:
|
|
return STR_SF_BG_MUSIC;
|
|
case FUNC_BACKGND_MUSIC_PAUSE:
|
|
return STR_SF_BG_MUSIC_PAUSE;
|
|
#if defined(VARIO)
|
|
case FUNC_VARIO:
|
|
return STR_SF_VARIO;
|
|
#endif
|
|
#if defined(HAPTIC)
|
|
case FUNC_HAPTIC:
|
|
return STR_SF_HAPTIC;
|
|
#endif
|
|
case FUNC_LOGS:
|
|
return STR_SF_LOGS;
|
|
case FUNC_BACKLIGHT:
|
|
#if OLED_SCREEN
|
|
return STR_BRIGHTNESS;
|
|
#else
|
|
return STR_SF_BACKLIGHT;
|
|
#endif
|
|
case FUNC_SCREENSHOT:
|
|
return STR_SF_SCREENSHOT;
|
|
case FUNC_RACING_MODE:
|
|
return STR_SF_RACING_MODE;
|
|
#if defined(COLORLCD)
|
|
case FUNC_DISABLE_TOUCH:
|
|
return STR_SF_DISABLE_TOUCH;
|
|
#endif
|
|
#if defined(KEYS_LOCK_KEY1) && defined(KEYS_LOCK_KEY2)
|
|
case FUNC_DISABLE_KEYS:
|
|
return STR_SF_DISABLE_KEYS;
|
|
#endif
|
|
case FUNC_SET_SCREEN:
|
|
return STR_SF_SET_SCREEN;
|
|
#if defined(AUDIO_MUTE_GPIO)
|
|
case FUNC_DISABLE_AUDIO_AMP:
|
|
return STR_SF_DISABLE_AUDIO_AMP;
|
|
#endif
|
|
case FUNC_RGB_LED:
|
|
return STR_SF_RGBLEDS;
|
|
#if defined(VIDEO_SWITCH)
|
|
case FUNC_LCD_TO_VIDEO:
|
|
return STR_SF_LCD_TO_VIDEO;
|
|
#endif
|
|
#if defined(FUNCTION_SWITCHES)
|
|
case FUNC_PUSH_CUST_SWITCH:
|
|
return STR_SF_PUSH_CUST_SWITCH;
|
|
#endif
|
|
#if defined(DEBUG)
|
|
case FUNC_TEST:
|
|
return STR_SF_TEST;
|
|
#endif
|
|
default:
|
|
return STR_EMPTY;
|
|
}
|
|
}
|