radio/src/functions.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "opentx.h"
  22
  23 CustomFunctionsContext modelFunctionsContext = { 0 };
  24
  25 CustomFunctionsContext globalFunctionsContext = { 0 };
  26
  27 #if defined(DEBUG)
  28 /*
  29  * This is a test function for debugging purpose, you may insert there your code and compile with the option DEBUG=YES
  30  */
  31 void testFunc()
  32 {
  33 #ifdef SIMU
  34   printf("testFunc\n"); fflush(stdout);
  35 #endif
  36
  37   // for testing the WD reset uncomment the following line
  38   // while (1);
  39 }
  40 #endif
  41
  42 PLAY_FUNCTION(playValue, source_t idx)
  43 {
  44   if (IS_FAI_FORBIDDEN(idx))
  45     return;
  46
  47   if (idx == MIXSRC_NONE)
  48     return;
  49
  50   getvalue_t val = getValue(idx);
  51
  52   if (idx >= MIXSRC_FIRST_TELEM) {
  53     TelemetrySensor & telemetrySensor = g_model.telemetrySensors[(idx-MIXSRC_FIRST_TELEM) / 3];
  54     uint8_t attr = 0;
  55     if (telemetrySensor.prec > 0) {
  56       if (telemetrySensor.prec == 2) {
  57         if (val >= 5000) {
  58           val = div_and_round(val, 100);
  59         }
  60         else {
  61           val = div_and_round(val, 10);
  62           attr = PREC1;
  63         }
  64       }
  65       else {
  66         if (val >= 500) {
  67           val = div_and_round(val, 10);
  68         }
  69         else {
  70           attr = PREC1;
  71         }
  72       }
  73     }
  74     PLAY_NUMBER(val, telemetrySensor.unit == UNIT_CELLS ? UNIT_VOLTS : telemetrySensor.unit, attr);
  75   }
  76   else if (idx >= MIXSRC_FIRST_TIMER && idx <= MIXSRC_LAST_TIMER) {
  77     PLAY_DURATION(val, 0);
  78   }
  79   else if (idx == MIXSRC_TX_TIME) {
  80     PLAY_DURATION(val*60, PLAY_TIME);
  81   }
  82   else if (idx == MIXSRC_TX_VOLTAGE) {
  83     PLAY_NUMBER(val, UNIT_VOLTS, PREC1);
  84   }
  85   else {
  86     if (idx <= MIXSRC_LAST_CH) {
  87       val = calcRESXto100(val);
  88     }
  89     PLAY_NUMBER(val, 0, 0);
  90   }
  91 }
  92
  93 void playCustomFunctionFile(const CustomFunctionData * sd, uint8_t id)
  94 {
  95   if (sd->play.name[0] != '\0') {
  96     char filename[sizeof(SOUNDS_PATH) + LEN_FUNCTION_NAME + sizeof(SOUNDS_EXT)] = SOUNDS_PATH "/";
  97     strncpy(filename + SOUNDS_PATH_LNG_OFS, currentLanguagePack->id, 2);
  98     strncpy(filename + sizeof(SOUNDS_PATH), sd->play.name, LEN_FUNCTION_NAME);
  99     filename[sizeof(SOUNDS_PATH) + LEN_FUNCTION_NAME] = '\0';
 100     strcat(filename + sizeof(SOUNDS_PATH), SOUNDS_EXT);
 101     PLAY_FILE(filename, sd->func == FUNC_BACKGND_MUSIC ? PLAY_BACKGROUND : 0, id);
 102   }
 103 }
 104
 105 bool isRepeatDelayElapsed(const CustomFunctionData * functions, CustomFunctionsContext & functionsContext, uint8_t index)
 106 {
 107   const CustomFunctionData * cfn = &functions[index];
 108   tmr10ms_t tmr10ms = get_tmr10ms();
 109   uint8_t repeatParam = CFN_PLAY_REPEAT(cfn);
 110   if (!IS_SILENCE_PERIOD_ELAPSED() && repeatParam == CFN_PLAY_REPEAT_NOSTART) {
 111     functionsContext.lastFunctionTime[index] = tmr10ms;
 112   }
 113   if (!functionsContext.lastFunctionTime[index] || (repeatParam && repeatParam!=CFN_PLAY_REPEAT_NOSTART && (signed)(tmr10ms-functionsContext.lastFunctionTime[index])>=100*repeatParam)) {
 114     functionsContext.lastFunctionTime[index] = tmr10ms;
 115     return true;
 116   }
 117   else {
 118     return false;
 119   }
 120 }
 121
 122 #define VOLUME_HYSTERESIS 10            // how much must a input value change to actually be considered for new volume setting
 123 getvalue_t requiredSpeakerVolumeRawLast = 1024 + 1; //initial value must be outside normal range
 124
 125 void evalFunctions(const CustomFunctionData * functions, CustomFunctionsContext & functionsContext)
 126 {
 127   MASK_FUNC_TYPE newActiveFunctions  = 0;
 128   MASK_CFN_TYPE  newActiveSwitches = 0;
 129
 130   uint8_t playFirstIndex = (functions == g_model.customFn ? 1 : 1+MAX_SPECIAL_FUNCTIONS);
 131   #define PLAY_INDEX   (i+playFirstIndex)
 132
 133 #if defined(OVERRIDE_CHANNEL_FUNCTION)
 134   for (uint8_t i=0; i<MAX_OUTPUT_CHANNELS; i++) {
 135     safetyCh[i] = OVERRIDE_CHANNEL_UNDEFINED;
 136   }
 137 #endif
 138
 139 #if defined(GVARS)
 140   for (uint8_t i=0; i<NUM_TRIMS; i++) {
 141     trimGvar[i] = -1;
 142   }
 143 #endif
 144
 145   for (uint8_t i=0; i<MAX_SPECIAL_FUNCTIONS; i++) {
 146     const CustomFunctionData * cfn = &functions[i];
 147     swsrc_t swtch = CFN_SWITCH(cfn);
 148     if (swtch) {
 149       MASK_CFN_TYPE switch_mask = ((MASK_CFN_TYPE)1 << i);
 150
 151       bool active = getSwitch(swtch, IS_PLAY_FUNC(CFN_FUNC(cfn)) ? GETSWITCH_MIDPOS_DELAY : 0);
 152
 153       if (HAS_ENABLE_PARAM(CFN_FUNC(cfn))) {
 154         active &= (bool)CFN_ACTIVE(cfn);
 155       }
 156
 157       if (active) {
 158         switch (CFN_FUNC(cfn)) {
 159
 160 #if defined(OVERRIDE_CHANNEL_FUNCTION)
 161           case FUNC_OVERRIDE_CHANNEL:
 162             safetyCh[CFN_CH_INDEX(cfn)] = CFN_PARAM(cfn);
 163             break;
 164 #endif
 165
 166           case FUNC_TRAINER:
 167           {
 168             uint8_t param = CFN_CH_INDEX(cfn);
 169             if (param == 0)
 170               newActiveFunctions |= 0x0F;
 171             else if (param <= NUM_STICKS)
 172               newActiveFunctions |= (1 << (param - 1));
 173             else if (param == NUM_STICKS + 1)
 174               newActiveFunctions |= (1u << FUNCTION_TRAINER_CHANNELS);
 175             break;
 176           }
 177
 178           case FUNC_INSTANT_TRIM:
 179             newActiveFunctions |= (1u << FUNCTION_INSTANT_TRIM);
 180             if (!isFunctionActive(FUNCTION_INSTANT_TRIM)) {
 181               if (IS_INSTANT_TRIM_ALLOWED()) {
 182                 instantTrim();
 183               }
 184             }
 185             break;
 186
 187           case FUNC_RESET:
 188             switch (CFN_PARAM(cfn)) {
 189               case FUNC_RESET_TIMER1:
 190               case FUNC_RESET_TIMER2:
 191               case FUNC_RESET_TIMER3:
 192                 timerReset(CFN_PARAM(cfn));
 193                 break;
 194               case FUNC_RESET_FLIGHT:
 195                 if (!(functionsContext.activeSwitches & switch_mask)) {
 196                   mainRequestFlags |= (1 << REQUEST_FLIGHT_RESET);     // on systems with threads flightReset() must not be called from the mixers thread!
 197                 }
 198                 break;
 199               case FUNC_RESET_TELEMETRY:
 200                 telemetryReset();
 201                 break;
 202             }
 203             if (CFN_PARAM(cfn)>=FUNC_RESET_PARAM_FIRST_TELEM) {
 204               uint8_t item = CFN_PARAM(cfn)-FUNC_RESET_PARAM_FIRST_TELEM;
 205               if (item < MAX_TELEMETRY_SENSORS) {
 206                 telemetryItems[item].clear();
 207               }
 208             }
 209             break;
 210
 211           case FUNC_SET_TIMER:
 212             timerSet(CFN_TIMER_INDEX(cfn), CFN_PARAM(cfn));
 213             break;
 214
 215           case FUNC_SET_FAILSAFE:
 216             setCustomFailsafe(CFN_PARAM(cfn));
 217             break;
 218
 219 #if defined(DANGEROUS_MODULE_FUNCTIONS)
 220           case FUNC_RANGECHECK:
 221           case FUNC_BIND:
 222           {
 223             unsigned int moduleIndex = CFN_PARAM(cfn);
 224             if (moduleIndex < NUM_MODULES) {
 225               moduleState[moduleIndex].mode = 1 + CFN_FUNC(cfn) - FUNC_RANGECHECK;
 226             }
 227             break;
 228           }
 229 #endif
 230
 231 #if defined(GVARS)
 232           case FUNC_ADJUST_GVAR:
 233             if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_CONSTANT) {
 234               SET_GVAR(CFN_GVAR_INDEX(cfn), CFN_PARAM(cfn), mixerCurrentFlightMode);
 235             }
 236             else if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_GVAR) {
 237               SET_GVAR(CFN_GVAR_INDEX(cfn), GVAR_VALUE(CFN_PARAM(cfn), getGVarFlightMode(mixerCurrentFlightMode, CFN_PARAM(cfn))), mixerCurrentFlightMode);
 238             }
 239             else if (CFN_GVAR_MODE(cfn) == FUNC_ADJUST_GVAR_INCDEC) {
 240               if (!(functionsContext.activeSwitches & switch_mask)) {
 241                 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);
 242               }
 243             }
 244             else if (CFN_PARAM(cfn) >= MIXSRC_FIRST_TRIM && CFN_PARAM(cfn) <= MIXSRC_LAST_TRIM) {
 245               trimGvar[CFN_PARAM(cfn)-MIXSRC_FIRST_TRIM] = CFN_GVAR_INDEX(cfn);
 246             }
 247             else {
 248               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);
 249             }
 250             break;
 251 #endif
 252
 253           case FUNC_VOLUME:
 254           {
 255             getvalue_t raw = getValue(CFN_PARAM(cfn));
 256             // only set volume if input changed more than hysteresis
 257             if (abs(requiredSpeakerVolumeRawLast - raw) > VOLUME_HYSTERESIS) {
 258               requiredSpeakerVolumeRawLast = raw;
 259             }
 260             requiredSpeakerVolume = ((1024 + requiredSpeakerVolumeRawLast) * VOLUME_LEVEL_MAX) / 2048;
 261             break;
 262           }
 263
 264 #if defined(SDCARD)
 265           case FUNC_PLAY_SOUND:
 266           case FUNC_PLAY_TRACK:
 267           case FUNC_PLAY_VALUE:
 268 #if defined(HAPTIC)
 269           case FUNC_HAPTIC:
 270 #endif
 271           {
 272             if (isRepeatDelayElapsed(functions, functionsContext, i)) {
 273               if (!IS_PLAYING(PLAY_INDEX)) {
 274                 if (CFN_FUNC(cfn) == FUNC_PLAY_SOUND) {
 275                   if (audioQueue.isEmpty()) {
 276                     AUDIO_PLAY(AU_SPECIAL_SOUND_FIRST + CFN_PARAM(cfn));
 277                   }
 278                 }
 279                 else if (CFN_FUNC(cfn) == FUNC_PLAY_VALUE) {
 280                   PLAY_VALUE(CFN_PARAM(cfn), PLAY_INDEX);
 281                 }
 282 #if defined(HAPTIC)
 283                 else if (CFN_FUNC(cfn) == FUNC_HAPTIC) {
 284                   haptic.event(AU_SPECIAL_SOUND_LAST+CFN_PARAM(cfn));
 285                 }
 286 #endif
 287                 else {
 288                   playCustomFunctionFile(cfn, PLAY_INDEX);
 289                 }
 290               }
 291             }
 292             break;
 293           }
 294
 295           case FUNC_BACKGND_MUSIC:
 296             if (!(newActiveFunctions & (1 << FUNCTION_BACKGND_MUSIC))) {
 297               newActiveFunctions |= (1 << FUNCTION_BACKGND_MUSIC);
 298               if (!IS_PLAYING(PLAY_INDEX)) {
 299                 playCustomFunctionFile(cfn, PLAY_INDEX);
 300               }
 301             }
 302             break;
 303
 304           case FUNC_BACKGND_MUSIC_PAUSE:
 305             newActiveFunctions |= (1 << FUNCTION_BACKGND_MUSIC_PAUSE);
 306             break;
 307
 308 #else
 309           case FUNC_PLAY_SOUND:
 310           case FUNC_PLAY_TRACK:
 311           case FUNC_PLAY_BOTH:
 312           case FUNC_PLAY_VALUE:
 313           {
 314             tmr10ms_t tmr10ms = get_tmr10ms();
 315             uint8_t repeatParam = CFN_PLAY_REPEAT(cfn);
 316             if (!functionsContext.lastFunctionTime[i] || (CFN_FUNC(cfn)==FUNC_PLAY_BOTH && active!=(bool)(functionsContext.activeSwitches&switch_mask)) || (repeatParam && (signed)(tmr10ms-functionsContext.lastFunctionTime[i])>=1000*repeatParam)) {
 317               functionsContext.lastFunctionTime[i] = tmr10ms;
 318               uint8_t param = CFN_PARAM(cfn);
 319               if (CFN_FUNC(cfn) == FUNC_PLAY_SOUND) {
 320                 AUDIO_PLAY(AU_SPECIAL_SOUND_FIRST+param);
 321               }
 322               else if (CFN_FUNC(cfn) == FUNC_PLAY_VALUE) {
 323                 PLAY_VALUE(param, PLAY_INDEX);
 324               }
 325               else {
 326 #if defined(GVARS)
 327                 if (CFN_FUNC(cfn) == FUNC_PLAY_TRACK && param > 250)
 328                   param = GVAR_VALUE(param-251, getGVarFlightMode(mixerCurrentFlightMode, param-251));
 329 #endif
 330                 PUSH_CUSTOM_PROMPT(active ? param : param+1, PLAY_INDEX);
 331               }
 332             }
 333             if (!active) {
 334               // PLAY_BOTH would change activeFnSwitches otherwise
 335               switch_mask = 0;
 336             }
 337             break;
 338           }
 339 #endif
 340
 341 #if defined(VARIO)
 342           case FUNC_VARIO:
 343             newActiveFunctions |= (1 << FUNCTION_VARIO);
 344             break;
 345 #endif
 346
 347
 348 #if defined(SDCARD)
 349           case FUNC_LOGS:
 350             if (CFN_PARAM(cfn)) {
 351               newActiveFunctions |= (1 << FUNCTION_LOGS);
 352               logDelay = CFN_PARAM(cfn);
 353             }
 354             break;
 355 #endif
 356
 357           case FUNC_BACKLIGHT:
 358             newActiveFunctions |= (1 << FUNCTION_BACKLIGHT);
 359             break;
 360
 361           case FUNC_SCREENSHOT:
 362             if (!(functionsContext.activeSwitches & switch_mask)) {
 363               mainRequestFlags |= (1 << REQUEST_SCREENSHOT);
 364             }
 365             break;
 366
 367 #if defined(DEBUG)
 368           case FUNC_TEST:
 369             testFunc();
 370             break;
 371 #endif
 372         }
 373
 374         newActiveSwitches |= switch_mask;
 375       }
 376       else {
 377         functionsContext.lastFunctionTime[i] = 0;
 378 #if defined(DANGEROUS_MODULE_FUNCTIONS)
 379         if (functionsContext.activeSwitches & switch_mask) {
 380           switch (CFN_FUNC(cfn)) {
 381             case FUNC_RANGECHECK:
 382             case FUNC_BIND:
 383             {
 384               unsigned int moduleIndex = CFN_PARAM(cfn);
 385               if (moduleIndex < NUM_MODULES) {
 386                 moduleState[moduleIndex].mode = 0;
 387               }
 388               break;
 389             }
 390           }
 391         }
 392 #endif
 393       }
 394     }
 395   }
 396
 397   functionsContext.activeSwitches   = newActiveSwitches;
 398   functionsContext.activeFunctions  = newActiveFunctions;
 399 }
 400