companion/src/radiodata.h

   1 #ifndef _RADIODATA_H_
   2 #define _RADIODATA_H_
   3
   4 #include "boards.h"
   5 #include "constants.h"
   6 #include <QString>
   7 #include <QComboBox>
   8
   9 class Firmware;
  10
  11 enum Switches {
  12   SWITCH_NONE,
  13
  14   SWITCH_THR = SWITCH_NONE+1,
  15   SWITCH_RUD,
  16   SWITCH_ELE,
  17   SWITCH_ID0,
  18   SWITCH_ID1,
  19   SWITCH_ID2,
  20   SWITCH_AIL,
  21   SWITCH_GEA,
  22   SWITCH_TRN,
  23
  24   SWITCH_SA0 = SWITCH_NONE+1,
  25   SWITCH_SA1,
  26   SWITCH_SA2,
  27   SWITCH_SB0,
  28   SWITCH_SB1,
  29   SWITCH_SB2,
  30   SWITCH_SC0,
  31   SWITCH_SC1,
  32   SWITCH_SC2,
  33   SWITCH_SD0,
  34   SWITCH_SD1,
  35   SWITCH_SD2,
  36   SWITCH_SE0,
  37   SWITCH_SE1,
  38   SWITCH_SE2,
  39   SWITCH_SF0,
  40   SWITCH_SF1,
  41   SWITCH_SG0,
  42   SWITCH_SG1,
  43   SWITCH_SG2,
  44   SWITCH_SH0,
  45   SWITCH_SH2,
  46   SWITCH_SI0,
  47   SWITCH_SI2,
  48   SWITCH_SJ0,
  49   SWITCH_SJ2,
  50   SWITCH_SK0,
  51   SWITCH_SK2,
  52 };
  53
  54 enum TimerModes {
  55   TMRMODE_NONE,
  56   TMRMODE_ABS,
  57   TMRMODE_THR,
  58   TMRMODE_THR_REL,
  59   TMRMODE_THR_TRG,
  60   TMRMODE_FIRST_SWITCH
  61 };
  62
  63 enum FailsafeModes {
  64   FAILSAFE_NOT_SET,
  65   FAILSAFE_HOLD,
  66   FAILSAFE_CUSTOM,
  67   FAILSAFE_NOPULSES,
  68   FAILSAFE_RECEIVER,
  69   FAILSAFE_LAST = FAILSAFE_RECEIVER
  70 };
  71
  72 #define CHAR_FOR_NAMES " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-."
  73 #define CHAR_FOR_NAMES_REGEX "[ A-Za-z0-9_.-,]*"
  74
  75 enum HeliSwashTypes {
  76   HELI_SWASH_TYPE_NONE=0,
  77   HELI_SWASH_TYPE_120,
  78   HELI_SWASH_TYPE_120X,
  79   HELI_SWASH_TYPE_140,
  80   HELI_SWASH_TYPE_90
  81 };
  82
  83 class ModelData;
  84 class GeneralSettings;
  85
  86 enum TelemetrySource {
  87   TELEMETRY_SOURCE_TX_BATT,
  88   TELEMETRY_SOURCE_TX_TIME,
  89   TELEMETRY_SOURCE_TIMER1,
  90   TELEMETRY_SOURCE_TIMER2,
  91   TELEMETRY_SOURCE_TIMER3,
  92   TELEMETRY_SOURCE_SWR,
  93   TELEMETRY_SOURCE_RSSI_TX,
  94   TELEMETRY_SOURCE_RSSI_RX,
  95   TELEMETRY_SOURCE_A1,
  96   TELEMETRY_SOURCE_A2,
  97   TELEMETRY_SOURCE_A3,
  98   TELEMETRY_SOURCE_A4,
  99   TELEMETRY_SOURCE_ALT,
 100   TELEMETRY_SOURCE_RPM,
 101   TELEMETRY_SOURCE_FUEL,
 102   TELEMETRY_SOURCE_T1,
 103   TELEMETRY_SOURCE_T2,
 104   TELEMETRY_SOURCE_SPEED,
 105   TELEMETRY_SOURCE_DIST,
 106   TELEMETRY_SOURCE_GPS_ALT,
 107   TELEMETRY_SOURCE_CELL,
 108   TELEMETRY_SOURCE_CELLS_SUM,
 109   TELEMETRY_SOURCE_VFAS,
 110   TELEMETRY_SOURCE_CURRENT,
 111   TELEMETRY_SOURCE_CONSUMPTION,
 112   TELEMETRY_SOURCE_POWER,
 113   TELEMETRY_SOURCE_ACCX,
 114   TELEMETRY_SOURCE_ACCY,
 115   TELEMETRY_SOURCE_ACCZ,
 116   TELEMETRY_SOURCE_HDG,
 117   TELEMETRY_SOURCE_VERTICAL_SPEED,
 118   TELEMETRY_SOURCE_ASPEED,
 119   TELEMETRY_SOURCE_DTE,
 120   TELEMETRY_SOURCE_A1_MIN,
 121   TELEMETRY_SOURCE_A2_MIN,
 122   TELEMETRY_SOURCE_A3_MIN,
 123   TELEMETRY_SOURCE_A4_MIN,
 124   TELEMETRY_SOURCE_ALT_MIN,
 125   TELEMETRY_SOURCE_ALT_MAX,
 126   TELEMETRY_SOURCE_RPM_MAX,
 127   TELEMETRY_SOURCE_T1_MAX,
 128   TELEMETRY_SOURCE_T2_MAX,
 129   TELEMETRY_SOURCE_SPEED_MAX,
 130   TELEMETRY_SOURCE_DIST_MAX,
 131   TELEMETRY_SOURCE_ASPEED_MAX,
 132   TELEMETRY_SOURCE_CELL_MIN,
 133   TELEMETRY_SOURCE_CELLS_MIN,
 134   TELEMETRY_SOURCE_VFAS_MIN,
 135   TELEMETRY_SOURCE_CURRENT_MAX,
 136   TELEMETRY_SOURCE_POWER_MAX,
 137   TELEMETRY_SOURCE_ACC,
 138   TELEMETRY_SOURCE_GPS_TIME,
 139   TELEMETRY_SOURCES_STATUS_COUNT = TELEMETRY_SOURCE_GPS_TIME+1,
 140   TELEMETRY_SOURCES_DISPLAY_COUNT = TELEMETRY_SOURCE_POWER_MAX+1,
 141   TELEMETRY_SOURCES_COUNT = TELEMETRY_SOURCE_POWER_MAX+1,
 142   TELEMETRY_SOURCE_RESERVE = -1
 143 };
 144
 145 #define TM_HASTELEMETRY     0x01
 146 #define TM_HASOFFSET        0x02
 147 #define TM_HASWSHH          0x04
 148
 149 enum RawSourceType {
 150   SOURCE_TYPE_NONE,
 151   SOURCE_TYPE_VIRTUAL_INPUT,
 152   SOURCE_TYPE_LUA_OUTPUT,
 153   SOURCE_TYPE_STICK, // and POTS
 154   SOURCE_TYPE_ROTARY_ENCODER,
 155   SOURCE_TYPE_TRIM,
 156   SOURCE_TYPE_MAX,
 157   SOURCE_TYPE_SWITCH,
 158   SOURCE_TYPE_CUSTOM_SWITCH,
 159   SOURCE_TYPE_CYC,
 160   SOURCE_TYPE_PPM,
 161   SOURCE_TYPE_CH,
 162   SOURCE_TYPE_GVAR,
 163   SOURCE_TYPE_SPECIAL,
 164   SOURCE_TYPE_TELEMETRY,
 165   MAX_SOURCE_TYPE
 166 };
 167
 168 class RawSourceRange
 169 {
 170   public:
 171     RawSourceRange():
 172       decimals(0),
 173       min(0.0),
 174       max(0.0),
 175       step(1.0),
 176       offset(0.0)
 177     {
 178     }
 179
 180     float getValue(int value);
 181
 182     int decimals;
 183     double min;
 184     double max;
 185     double step;
 186     double offset;
 187     QString unit;
 188 };
 189
 190 #define RANGE_SINGLE_PRECISION    1
 191 #define RANGE_DELTA_FUNCTION      2
 192 #define RANGE_DELTA_ABS_FUNCTION  4
 193
 194 class RawSource {
 195   public:
 196     RawSource():
 197       type(SOURCE_TYPE_NONE),
 198       index(0)
 199     {
 200     }
 201
 202     explicit RawSource(int value):
 203       type(RawSourceType(abs(value)/65536)),
 204       index(value >= 0 ? abs(value)%65536 : -(abs(value)%65536))
 205     {
 206     }
 207
 208     RawSource(RawSourceType type, int index=0):
 209       type(type),
 210       index(index)
 211     {
 212     }
 213
 214     RawSource convert(Board::Type before, Board::Type after);
 215
 216     inline const int toValue() const
 217     {
 218       return index >= 0 ? (type * 65536 + index) : -(type * 65536 - index);
 219     }
 220
 221     QString toString(const ModelData * model = NULL, const GeneralSettings * const generalSettings = NULL) const;
 222
 223     RawSourceRange getRange(const ModelData * model, const GeneralSettings & settings, unsigned int flags=0) const;
 224
 225     bool operator == ( const RawSource & other) {
 226       return (this->type == other.type) && (this->index == other.index);
 227     }
 228
 229     bool operator != ( const RawSource & other) {
 230       return (this->type != other.type) || (this->index != other.index);
 231     }
 232
 233     bool isTimeBased() const;
 234     bool isStick(int * potsIndex = NULL) const;
 235     bool isPot(int * potsIndex = NULL) const;
 236     bool isSlider(int * sliderIndex = NULL) const;
 237
 238     RawSourceType type;
 239     int index;
 240 };
 241
 242 enum RawSwitchType {
 243   SWITCH_TYPE_NONE,
 244   SWITCH_TYPE_SWITCH,
 245   SWITCH_TYPE_VIRTUAL,
 246   SWITCH_TYPE_MULTIPOS_POT,
 247   SWITCH_TYPE_TRIM,
 248   SWITCH_TYPE_ROTARY_ENCODER,
 249   SWITCH_TYPE_ON,
 250   SWITCH_TYPE_OFF,
 251   SWITCH_TYPE_ONE,
 252   SWITCH_TYPE_FLIGHT_MODE,
 253   SWITCH_TYPE_TIMER_MODE,
 254   SWITCH_TYPE_TELEMETRY,
 255   SWITCH_TYPE_SENSOR,
 256 };
 257
 258 class RawSwitch {
 259   public:
 260     RawSwitch():
 261       type(SWITCH_TYPE_NONE),
 262       index(0)
 263     {
 264     }
 265
 266     explicit RawSwitch(int value):
 267       type(RawSwitchType(abs(value)/256)),
 268       index(value >= 0 ? abs(value)%256 : -(abs(value)%256))
 269     {
 270     }
 271
 272     RawSwitch(RawSwitchType type, int index=0):
 273       type(type),
 274       index(index)
 275     {
 276     }
 277
 278     inline const int toValue() const
 279     {
 280       return index >= 0 ? (type * 256 + index) : -(type * 256 - index);
 281     }
 282
 283     QString toString(Board::Type board = Board::BOARD_UNKNOWN, const GeneralSettings * const generalSettings = NULL, const ModelData * const modelData = NULL) const;
 284
 285     bool operator== ( const RawSwitch& other) {
 286       return (this->type == other.type) && (this->index == other.index);
 287     }
 288
 289     bool operator!= ( const RawSwitch& other) {
 290       return (this->type != other.type) || (this->index != other.index);
 291     }
 292
 293     RawSwitch convert(Board::Type before, Board::Type after);
 294
 295     RawSwitchType type;
 296     int index;
 297 };
 298
 299 class CurveReference {
 300   public:
 301     enum CurveRefType {
 302       CURVE_REF_DIFF,
 303       CURVE_REF_EXPO,
 304       CURVE_REF_FUNC,
 305       CURVE_REF_CUSTOM
 306     };
 307
 308     CurveReference() { clear(); }
 309
 310     CurveReference(CurveRefType type, int value):
 311       type(type),
 312       value(value)
 313     {
 314     }
 315
 316     void clear() { memset(this, 0, sizeof(CurveReference)); }
 317
 318     CurveRefType type;
 319     int value;
 320
 321     QString toString(const ModelData * model = NULL, bool verbose = true) const;
 322 };
 323
 324 enum InputMode {
 325   INPUT_MODE_NONE,
 326   INPUT_MODE_POS,
 327   INPUT_MODE_NEG,
 328   INPUT_MODE_BOTH
 329 };
 330
 331 class ExpoData {
 332   public:
 333     ExpoData() { clear(); }
 334     RawSource srcRaw;
 335     unsigned int scale;
 336     unsigned int mode;
 337     unsigned int chn;
 338     RawSwitch swtch;
 339     unsigned int flightModes;        // -5=!FP4, 0=normal, 5=FP4
 340     int  weight;
 341     int offset;
 342     CurveReference curve;
 343     int carryTrim;
 344     char name[10+1];
 345     void clear() { memset(this, 0, sizeof(ExpoData)); }
 346     void convert(Board::Type before, Board::Type after);
 347 };
 348
 349 class CurvePoint {
 350   public:
 351     int8_t x;
 352     int8_t y;
 353 };
 354
 355 class CurveData {
 356   public:
 357     enum CurveType {
 358       CURVE_TYPE_STANDARD,
 359       CURVE_TYPE_CUSTOM,
 360       CURVE_TYPE_LAST = CURVE_TYPE_CUSTOM
 361     };
 362
 363     CurveData();
 364     void clear(int count);
 365     bool isEmpty() const;
 366     QString nameToString(const int idx) const;
 367
 368     CurveType type;
 369     bool smooth;
 370     int  count;
 371     CurvePoint points[CPN_MAX_POINTS];
 372     char name[6+1];
 373 };
 374
 375 class LimitData {
 376   public:
 377     LimitData() { clear(); }
 378     int   min;
 379     int   max;
 380     bool  revert;
 381     int   offset;
 382     int   ppmCenter;
 383     bool  symetrical;
 384     char  name[6+1];
 385     CurveReference curve;
 386     QString minToString() const;
 387     QString maxToString() const;
 388     QString offsetToString() const;
 389     QString revertToString() const;
 390     void clear();
 391 };
 392
 393 enum MltpxValue {
 394   MLTPX_ADD=0,
 395   MLTPX_MUL=1,
 396   MLTPX_REP=2
 397 };
 398
 399 #define MIXDATA_NAME_LEN  10
 400
 401 class MixData {
 402   public:
 403     MixData() { clear(); }
 404     void convert(Board::Type before, Board::Type after);
 405
 406     unsigned int destCh;            //        1..CPN_MAX_CHNOUT
 407     RawSource srcRaw;
 408     int     weight;
 409     RawSwitch swtch;
 410     CurveReference     curve;             //0=symmetrisch
 411     unsigned int delayUp;
 412     unsigned int delayDown;
 413     unsigned int speedUp;           // Servogeschwindigkeit aus Tabelle (10ms Cycle)
 414     unsigned int speedDown;         // 0 nichts
 415     int  carryTrim;
 416     bool noExpo;
 417     MltpxValue mltpx;          // multiplex method 0=+ 1=* 2=replace
 418     unsigned int mixWarn;           // mixer warning
 419     unsigned int flightModes;             // -5=!FP4, 0=normal, 5=FP4
 420     int    sOffset;
 421     char   name[MIXDATA_NAME_LEN+1];
 422
 423     void clear() { memset(this, 0, sizeof(MixData)); }
 424 };
 425
 426 enum CSFunction {
 427   LS_FN_OFF,
 428   LS_FN_VPOS,
 429   LS_FN_VNEG,
 430   LS_FN_APOS,
 431   LS_FN_ANEG,
 432   LS_FN_AND,
 433   LS_FN_OR,
 434   LS_FN_XOR,
 435   LS_FN_EQUAL,
 436   LS_FN_NEQUAL,
 437   LS_FN_GREATER,
 438   LS_FN_LESS,
 439   LS_FN_EGREATER,
 440   LS_FN_ELESS,
 441   LS_FN_DPOS,
 442   LS_FN_DAPOS,
 443   LS_FN_VEQUAL, // added at the end to avoid everything renumbered
 444   LS_FN_VALMOSTEQUAL,
 445   LS_FN_TIMER,
 446   LS_FN_STICKY,
 447   LS_FN_EDGE,
 448   // later ... LS_FN_RANGE,
 449     LS_FN_MAX
 450 };
 451
 452 enum CSFunctionFamily {
 453   LS_FAMILY_VOFS,
 454   LS_FAMILY_VBOOL,
 455   LS_FAMILY_VCOMP,
 456   LS_FAMILY_TIMER,
 457   LS_FAMILY_STICKY,
 458   LS_FAMILY_EDGE,
 459 };
 460
 461 class LogicalSwitchData { // Logical Switches data
 462   public:
 463     LogicalSwitchData(unsigned int func=0)
 464     {
 465       clear();
 466       this->func = func;
 467     }
 468     unsigned int func;
 469     int val1;
 470     int val2;
 471     int val3;
 472     unsigned int delay;
 473     unsigned int duration;
 474     int andsw;
 475
 476     void clear() { memset(this, 0, sizeof(LogicalSwitchData)); }
 477     bool isEmpty() const;
 478     CSFunctionFamily getFunctionFamily() const;
 479     unsigned int getRangeFlags() const;
 480     QString funcToString() const;
 481     void convert(Board::Type before, Board::Type after);
 482 };
 483
 484 enum AssignFunc {
 485   FuncOverrideCH1 = 0,
 486   FuncOverrideCH32 = FuncOverrideCH1+CPN_MAX_CHNOUT-1,
 487   FuncTrainer,
 488   FuncTrainerRUD,
 489   FuncTrainerELE,
 490   FuncTrainerTHR,
 491   FuncTrainerAIL,
 492   FuncInstantTrim,
 493   FuncPlaySound,
 494   FuncPlayHaptic,
 495   FuncReset,
 496   FuncSetTimer1,
 497   FuncSetTimer2,
 498   FuncSetTimer3,
 499   FuncVario,
 500   FuncPlayPrompt,
 501   FuncPlayBoth,
 502   FuncPlayValue,
 503   FuncPlayScript,
 504   FuncLogs,
 505   FuncVolume,
 506   FuncBacklight,
 507   FuncScreenshot,
 508   FuncBackgroundMusic,
 509   FuncBackgroundMusicPause,
 510   FuncAdjustGV1,
 511   FuncAdjustGVLast = FuncAdjustGV1+CPN_MAX_GVARS-1,
 512   FuncSetFailsafeInternalModule,
 513   FuncSetFailsafeExternalModule,
 514   FuncRangeCheckInternalModule,
 515   FuncRangeCheckExternalModule,
 516   FuncBindInternalModule,
 517   FuncBindExternalModule,
 518   FuncCount,
 519   FuncReserve = -1
 520 };
 521
 522 enum GVarAdjustModes
 523 {
 524   FUNC_ADJUST_GVAR_CONSTANT,
 525   FUNC_ADJUST_GVAR_SOURCE,
 526   FUNC_ADJUST_GVAR_GVAR,
 527   FUNC_ADJUST_GVAR_INCDEC
 528 };
 529
 530 class CustomFunctionData { // Function Switches data
 531   public:
 532     CustomFunctionData(AssignFunc func=FuncOverrideCH1) { clear(); this->func = func; }
 533     RawSwitch    swtch;
 534     AssignFunc   func;
 535     int param;
 536     char paramarm[10];
 537     unsigned int enabled; // TODO perhaps not any more the right name
 538     unsigned int adjustMode;
 539     int repeatParam;
 540
 541     void clear();
 542     bool isEmpty() const;
 543     QString funcToString(const ModelData * model = NULL) const;
 544     QString paramToString(const ModelData * model) const;
 545     QString repeatToString() const;
 546     QString enabledToString() const;
 547
 548     static void populateResetParams(const ModelData * model, QComboBox * b, unsigned int value);
 549     static void populatePlaySoundParams(QStringList & qs);
 550     static void populateHapticParams(QStringList & qs);
 551
 552     void convert(Board::Type before, Board::Type after);
 553
 554 };
 555
 556 class FlightModeData {
 557   public:
 558     FlightModeData() { clear(0); }
 559     int trimMode[CPN_MAX_TRIMS];
 560     int trimRef[CPN_MAX_TRIMS];
 561     int trim[CPN_MAX_TRIMS];
 562     RawSwitch swtch;
 563     char name[10+1];
 564     unsigned int fadeIn;
 565     unsigned int fadeOut;
 566     int rotaryEncoders[CPN_MAX_ENCODERS];
 567     int gvars[CPN_MAX_GVARS];
 568     void clear(const int phase);
 569     void convert(Board::Type before, Board::Type after);
 570 };
 571
 572 class SwashRingData { // Swash Ring data
 573   public:
 574     SwashRingData() { clear(); }
 575     int elevatorWeight;
 576     int aileronWeight;
 577     int collectiveWeight;
 578     unsigned int  type;
 579     RawSource collectiveSource;
 580     RawSource aileronSource;
 581     RawSource elevatorSource;
 582     unsigned int  value;
 583     void clear() { memset(this, 0, sizeof(SwashRingData)); }
 584 };
 585
 586 class FrSkyAlarmData {
 587   public:
 588     FrSkyAlarmData() { clear(); }
 589     unsigned int   level;               // 0=none, 1=Yellow, 2=Orange, 3=Red
 590     unsigned int   greater;             // 0=LT(<), 1=GT(>)
 591     unsigned int value;               // 0.1V steps EG. 6.6 Volts = 66. 25.1V = 251, etc.
 592
 593     void clear() { memset(this, 0, sizeof(FrSkyAlarmData)); }
 594 };
 595
 596 class RSSIAlarmData {
 597   public:
 598     RSSIAlarmData() { clear(); }
 599     unsigned int level[2];  // AVR Only
 600     int warning;
 601     int critical;
 602     bool disabled;
 603     void clear() {
 604       this->level[0] = 2;
 605       this->level[1] = 3;
 606       this->warning = 45;
 607       this->critical = 42;
 608       this->disabled = false;
 609     }
 610 };
 611
 612 class FrSkyChannelData {
 613   public:
 614     FrSkyChannelData() { clear(); }
 615     unsigned int ratio;                // 0.0 means not used, 0.1V steps EG. 6.6 Volts = 66. 25.1V = 251, etc.
 616     unsigned int type;                 // future use: 0=volts, 1=ml...
 617     int   offset;
 618     unsigned int multiplier;
 619     FrSkyAlarmData alarms[2];
 620
 621     float getRatio() const;
 622     RawSourceRange getRange() const;
 623     void clear() { memset(this, 0, sizeof(FrSkyChannelData)); }
 624 };
 625
 626 struct FrSkyBarData {
 627   RawSource source;
 628   int barMin;           // minimum for bar display
 629   int barMax;           // ditto for max display (would usually = ratio)
 630 };
 631
 632 struct FrSkyLineData {
 633   RawSource source[3];
 634 };
 635
 636 struct TelemetryScriptData {
 637   char filename[8+1];
 638 };
 639
 640 enum TelemetryScreenEnum {
 641   TELEMETRY_SCREEN_NONE,
 642   TELEMETRY_SCREEN_NUMBERS,
 643   TELEMETRY_SCREEN_BARS,
 644   TELEMETRY_SCREEN_SCRIPT
 645 };
 646
 647 class FrSkyScreenData {
 648   public:
 649     FrSkyScreenData() { clear(); }
 650
 651     typedef struct {
 652       FrSkyBarData bars[4];
 653       FrSkyLineData lines[4];
 654       TelemetryScriptData script;
 655     } FrSkyScreenBody;
 656
 657     unsigned int type;
 658     FrSkyScreenBody body;
 659
 660     void clear();
 661 };
 662
 663 enum TelemetryVarioSources {
 664   TELEMETRY_VARIO_SOURCE_ALTI,
 665   TELEMETRY_VARIO_SOURCE_ALTI_PLUS,
 666   TELEMETRY_VARIO_SOURCE_VSPEED,
 667   TELEMETRY_VARIO_SOURCE_A1,
 668   TELEMETRY_VARIO_SOURCE_A2,
 669   TELEMETRY_VARIO_SOURCE_DTE,
 670 };
 671
 672 enum TelemetryVoltsSources {
 673   TELEMETRY_VOLTS_SOURCE_A1,
 674   TELEMETRY_VOLTS_SOURCE_A2,
 675   TELEMETRY_VOLTS_SOURCE_A3,
 676   TELEMETRY_VOLTS_SOURCE_A4,
 677   TELEMETRY_VOLTS_SOURCE_FAS,
 678   TELEMETRY_VOLTS_SOURCE_CELLS
 679 };
 680
 681 enum TelemetryCurrentSources {
 682   TELEMETRY_CURRENT_SOURCE_NONE,
 683   TELEMETRY_CURRENT_SOURCE_A1,
 684   TELEMETRY_CURRENT_SOURCE_A2,
 685   TELEMETRY_CURRENT_SOURCE_A3,
 686   TELEMETRY_CURRENT_SOURCE_A4,
 687   TELEMETRY_CURRENT_SOURCE_FAS
 688 };
 689
 690 enum UartModes {
 691   UART_MODE_NONE,
 692   UART_MODE_TELEMETRY_MIRROR,
 693   UART_MODE_TELEMETRY,
 694   UART_MODE_SBUS_TRAINER,
 695   UART_MODE_DEBUG
 696 };
 697
 698 enum TrainerMode {
 699   TRAINER_MODE_MASTER_TRAINER_JACK,
 700   TRAINER_MODE_SLAVE,
 701   TRAINER_MODE_MASTER_SBUS_EXTERNAL_MODULE,
 702   TRAINER_MODE_MASTER_CPPM_EXTERNAL_MODULE,
 703   TRAINER_MODE_MASTER_BATTERY_COMPARTMENT,
 704 };
 705
 706 class FrSkyData {
 707   public:
 708     FrSkyData() { clear(); }
 709     FrSkyChannelData channels[4];
 710     unsigned int usrProto;
 711     int blades;
 712     unsigned int voltsSource;
 713     unsigned int altitudeSource;
 714     unsigned int currentSource;
 715     FrSkyScreenData screens[4];
 716     unsigned int varioSource;
 717     bool varioCenterSilent;
 718     int varioMin;
 719     int varioCenterMin;    // if increment in 0.2m/s = 3.0m/s max
 720     int varioCenterMax;
 721     int varioMax;
 722     bool mAhPersistent;
 723     unsigned int storedMah;
 724     int fasOffset;
 725     bool ignoreSensorIds;
 726
 727     void clear();
 728 };
 729
 730 class MavlinkData {
 731   public:
 732     MavlinkData() { clear();}
 733     unsigned int rc_rssi_scale;
 734     unsigned int pc_rssi_en;
 735     void clear() { memset(this, 0, sizeof(MavlinkData)); }
 736 };
 737
 738 #define TIMER_NAME_LEN 8
 739
 740 class TimerData {
 741   public:
 742     enum CountDownMode {
 743       COUNTDOWN_SILENT,
 744       COUNTDOWN_BEEPS,
 745       COUNTDOWN_VOICE,
 746       COUNTDOWN_HAPTIC
 747     };
 748     TimerData() { clear(); }
 749     RawSwitch    mode;
 750     char         name[TIMER_NAME_LEN+1];
 751     bool         minuteBeep;
 752     unsigned int countdownBeep;
 753     unsigned int val;
 754     unsigned int persistent;
 755     int          pvalue;
 756     void clear() { memset(this, 0, sizeof(TimerData)); mode = RawSwitch(SWITCH_TYPE_TIMER_MODE, 0); }
 757 };
 758
 759 enum PulsesProtocol {
 760   PULSES_OFF,
 761   PULSES_PPM,
 762   PULSES_SILV_A,
 763   PULSES_SILV_B,
 764   PULSES_SILV_C,
 765   PULSES_CTP1009,
 766   PULSES_LP45,
 767   PULSES_DSM2,
 768   PULSES_DSMX,
 769   PULSES_PPM16,
 770   PULSES_PPMSIM,
 771   PULSES_PXX_XJT_X16,
 772   PULSES_PXX_XJT_D8,
 773   PULSES_PXX_XJT_LR12,
 774   PULSES_PXX_DJT,
 775   PULSES_CROSSFIRE,
 776   PULSES_MULTIMODULE,
 777   PULSES_PXX_R9M,
 778   PULSES_SBUS,
 779   PULSES_PROTOCOL_LAST
 780 };
 781
 782 enum MultiModuleRFProtocols {
 783   MM_RF_PROTO_FLYSKY=0,
 784   MM_RF_PROTO_FIRST=MM_RF_PROTO_FLYSKY,
 785   MM_RF_PROTO_HUBSAN,
 786   MM_RF_PROTO_FRSKY,
 787   MM_RF_PROTO_HISKY,
 788   MM_RF_PROTO_V2X2,
 789   MM_RF_PROTO_DSM2,
 790   MM_RF_PROTO_DEVO,
 791   MM_RF_PROTO_YD717,
 792   MM_RF_PROTO_KN,
 793   MM_RF_PROTO_SYMAX,
 794   MM_RF_PROTO_SLT,
 795   MM_RF_PROTO_CX10,
 796   MM_RF_PROTO_CG023,
 797   MM_RF_PROTO_BAYANG,
 798   MM_RF_PROTO_ESky,
 799   MM_RF_PROTO_MT99XX,
 800   MM_RF_PROTO_MJXQ,
 801   MM_RF_PROTO_SHENQI,
 802   MM_RF_PROTO_FY326,
 803   MM_RF_PROTO_SFHSS,
 804   MM_RF_PROTO_J6PRO,
 805   MM_RF_PROTO_FQ777,
 806   MM_RF_PROTO_ASSAN,
 807   MM_RF_PROTO_HONTAI,
 808   MM_RF_PROTO_OLRS,
 809   MM_RF_PROTO_FS_AFHDS2A,
 810   MM_RF_PROTO_Q2X2,
 811   MM_RF_PROTO_WK_2X01,
 812   MM_RF_PROTO_Q303,
 813   MM_RF_PROTO_GW008,
 814   MM_RF_PROTO_DM002,
 815   MM_RF_PROTO_CABELL,
 816   MM_RF_PROTO_ESKY150,
 817   MM_RF_PROTO_H83D,
 818   MM_RF_PROTO_LAST=MM_RF_PROTO_H83D
 819 };
 820
 821 enum TrainerProtocol {
 822   TRAINER_MASTER_JACK,
 823   TRAINER_SLAVE_JACK,
 824   TRAINER_MASTER_SBUS_MODULE,
 825   TRAINER_MASTER_CPPM_MODULE,
 826   TRAINER_MASTER_SBUS_BATT_COMPARTMENT
 827 };
 828
 829 class ModuleData {
 830   public:
 831     ModuleData() { clear(); }
 832     unsigned int modelId;
 833     int          protocol;
 834     unsigned int subType;
 835     bool         invertedSerial;
 836     unsigned int channelsStart;
 837     int          channelsCount; // 0=8 channels
 838     unsigned int failsafeMode;
 839     int          failsafeChannels[CPN_MAX_CHNOUT];
 840
 841
 842     struct {
 843       int delay;
 844       bool pulsePol;           // false = positive
 845       bool outputType;         // false = open drain, true = push pull
 846       int frameLength;
 847     } ppm;
 848
 849     struct {
 850       unsigned int rfProtocol;
 851       bool autoBindMode;
 852       bool lowPowerMode;
 853       bool customProto;
 854       int optionValue;
 855     } multi;
 856
 857     struct {
 858       int power;                   // 0 10 mW, 1 100 mW, 2 500 mW, 3 1W
 859       bool receiver_telem_off;     // false = receiver telem enabled
 860       bool receiver_channel_9_16;  // false = pwm out 1-8, true 9-16
 861       bool external_antenna;       // false = internal antenna, true = external antenna
 862       bool sport_out;
 863     } pxx;
 864
 865
 866     void clear() { memset(this, 0, sizeof(ModuleData)); }
 867     QString polarityToString() const { return ppm.pulsePol ? QObject::tr("Positive") : QObject::tr("Negative"); } // TODO ModelPrinter
 868 };
 869
 870 #define CPN_MAX_SCRIPTS       9
 871 #define CPN_MAX_SCRIPT_INPUTS 10
 872 class ScriptData {
 873   public:
 874     ScriptData() { clear(); }
 875     char    filename[10+1];
 876     char    name[10+1];
 877     int     inputs[CPN_MAX_SCRIPT_INPUTS];
 878     void clear() { memset(this, 0, sizeof(ScriptData)); }
 879 };
 880
 881 #define CPN_MAX_SENSORS       32
 882 class SensorData {
 883
 884   public:
 885
 886     enum
 887     {
 888       TELEM_TYPE_CUSTOM,
 889       TELEM_TYPE_CALCULATED
 890     };
 891
 892     enum
 893     {
 894       TELEM_FORMULA_ADD,
 895       TELEM_FORMULA_AVERAGE,
 896       TELEM_FORMULA_MIN,
 897       TELEM_FORMULA_MAX,
 898       TELEM_FORMULA_MULTIPLY,
 899       TELEM_FORMULA_TOTALIZE,
 900       TELEM_FORMULA_CELL,
 901       TELEM_FORMULA_CONSUMPTION,
 902       TELEM_FORMULA_DIST,
 903       TELEM_FORMULA_LAST = TELEM_FORMULA_DIST
 904     };
 905
 906     enum {
 907       TELEM_CELL_INDEX_LOWEST,
 908       TELEM_CELL_INDEX_1,
 909       TELEM_CELL_INDEX_2,
 910       TELEM_CELL_INDEX_3,
 911       TELEM_CELL_INDEX_4,
 912       TELEM_CELL_INDEX_5,
 913       TELEM_CELL_INDEX_6,
 914       TELEM_CELL_INDEX_HIGHEST,
 915       TELEM_CELL_INDEX_DELTA,
 916     };
 917
 918     enum
 919     {
 920       UNIT_RAW,
 921       UNIT_VOLTS,
 922       UNIT_AMPS,
 923       UNIT_MILLIAMPS,
 924       UNIT_KTS,
 925       UNIT_METERS_PER_SECOND,
 926       UNIT_FEET_PER_SECOND,
 927       UNIT_KMH,
 928       UNIT_MPH,
 929       UNIT_METERS,
 930       UNIT_FEET,
 931       UNIT_CELSIUS,
 932       UNIT_FAHRENHEIT,
 933       UNIT_PERCENT,
 934       UNIT_MAH,
 935       UNIT_WATTS,
 936       UNIT_MILLIWATTS,
 937       UNIT_DB,
 938       UNIT_RPMS,
 939       UNIT_G,
 940       UNIT_DEGREE,
 941       UNIT_RADIANS,
 942       UNIT_MILLILITERS,
 943       UNIT_FLOZ,
 944       UNIT_HOURS,
 945       UNIT_MINUTES,
 946       UNIT_SECONDS,
 947       // FrSky format used for these fields, could be another format in the future
 948         UNIT_FIRST_VIRTUAL,
 949       UNIT_CELLS = UNIT_FIRST_VIRTUAL,
 950       UNIT_DATETIME,
 951       UNIT_GPS,
 952       UNIT_GPS_LONGITUDE,
 953       UNIT_GPS_LATITUDE,
 954       UNIT_GPS_LONGITUDE_EW,
 955       UNIT_GPS_LATITUDE_NS,
 956       UNIT_DATETIME_YEAR,
 957       UNIT_DATETIME_DAY_MONTH,
 958       UNIT_DATETIME_HOUR_MIN,
 959       UNIT_DATETIME_SEC
 960     };
 961
 962     SensorData() { clear(); }
 963     unsigned int type; // custom / formula
 964     unsigned int id;
 965     unsigned int subid;
 966     unsigned int instance;
 967     unsigned int persistentValue;
 968     unsigned int formula;
 969     char label[4+1];
 970     unsigned int unit;
 971     unsigned int prec;
 972     bool autoOffset;
 973     bool filter;
 974     bool logs;
 975     bool persistent;
 976     bool onlyPositive;
 977
 978     // for custom sensors
 979     unsigned int ratio;
 980     int offset;
 981
 982     // for consumption
 983     unsigned int amps;
 984
 985     // for cell
 986     unsigned int source;
 987     unsigned int index;
 988
 989     // for calculations
 990     int sources[4];
 991
 992     // for GPS dist
 993     unsigned int gps;
 994     unsigned int alt;
 995
 996     bool isAvailable() const { return strlen(label) > 0; }
 997     void updateUnit();
 998     QString unitString() const;
 999     void clear() { memset(this, 0, sizeof(SensorData)); }
1000 };
1001
1002 /*
1003  * TODO ...
1004  */
1005 #if 0
1006 class CustomScreenOptionData {
1007   public:
1008
1009 };
1010
1011 class CustomScreenZoneData {
1012   public:
1013     char widgetName[10+1];
1014     WidgetOptionData widgetOptions[5];
1015 };
1016
1017 class CustomScreenData {
1018   public:
1019     CustomScreenData();
1020
1021     char layoutName[10+1];
1022     CustomScreenZoneData zones[];
1023     CustomScreenOptionData options[];
1024 };
1025 #else
1026 typedef char CustomScreenData[610+1];
1027 typedef char TopbarData[216+1];
1028 #endif
1029
1030 #define GVAR_NAME_LEN       3
1031 #define GVAR_MAX_VALUE      1024
1032 #define GVAR_MIN_VALUE      -GVAR_MAX_VALUE
1033
1034 class GVarData {
1035   public:
1036     GVarData() { clear(); }
1037
1038     enum {
1039       GVAR_UNIT_NUMBER,
1040       GVAR_UNIT_PERCENT
1041     };
1042
1043     enum {
1044       GVAR_PREC_MUL10,
1045       GVAR_PREC_MUL1
1046     };
1047
1048     char name[GVAR_NAME_LEN+1];
1049     int min;
1050     int max;
1051     bool popup;
1052     unsigned int prec;     // 0 0._  1 0.0
1053     unsigned int unit;     // 0 _    1 %
1054
1055     void clear() {memset(this, 0, sizeof(GVarData)); }
1056     QString unitToString() const;
1057     QString precToString() const;
1058     int multiplierSet();
1059     float multiplierGet() const;
1060     void setMin(float val);
1061     void setMax(float val);
1062     int getMin() const;
1063     int getMax() const;
1064     float getMinPrec() const;
1065     float getMaxPrec() const;
1066 };
1067
1068 class ModelData {
1069   public:
1070     ModelData();
1071     ModelData(const ModelData & src);
1072     ModelData & operator = (const ModelData & src);
1073
1074     void convert(Board::Type before, Board::Type after);
1075
1076     ExpoData * insertInput(const int idx);
1077     void removeInput(const int idx);
1078
1079     bool isInputValid(const unsigned int idx) const;
1080     bool hasExpos(uint8_t inputIdx) const;
1081     bool hasMixes(uint8_t output) const;
1082
1083     QVector<const ExpoData *> expos(int input) const;
1084     QVector<const MixData *> mixes(int channel) const;
1085
1086     bool      used;
1087     int       category;
1088     char      name[15+1];
1089     char      filename[16+1];
1090     int       modelIndex;      // Companion only, temporary index position managed by data model.
1091
1092     TimerData timers[CPN_MAX_TIMERS];
1093     bool      noGlobalFunctions;
1094     bool      thrTrim;            // Enable Throttle Trim
1095     int       trimInc;            // Trim Increments
1096     unsigned int trimsDisplay;
1097     bool      disableThrottleWarning;
1098
1099     unsigned int beepANACenter;      // 1<<0->A1.. 1<<6->A7
1100
1101     bool      extendedLimits; // TODO xml
1102     bool      extendedTrims;
1103     bool      throttleReversed;
1104     FlightModeData flightModeData[CPN_MAX_FLIGHT_MODES];
1105     MixData   mixData[CPN_MAX_MIXERS];
1106     LimitData limitData[CPN_MAX_CHNOUT];
1107
1108     char      inputNames[CPN_MAX_INPUTS][4+1];
1109     ExpoData  expoData[CPN_MAX_EXPOS];
1110
1111     CurveData curves[CPN_MAX_CURVES];
1112     LogicalSwitchData  logicalSw[CPN_MAX_LOGICAL_SWITCHES];
1113     CustomFunctionData customFn[CPN_MAX_SPECIAL_FUNCTIONS];
1114     SwashRingData swashRingData;
1115     unsigned int thrTraceSrc;
1116     uint64_t switchWarningStates;
1117     unsigned int switchWarningEnable;
1118     unsigned int potsWarningMode;
1119     bool potsWarningEnabled[CPN_MAX_POTS];
1120     int          potPosition[CPN_MAX_POTS];
1121     bool         displayChecklist;
1122     GVarData gvarData[CPN_MAX_GVARS];
1123     MavlinkData mavlink;
1124     unsigned int telemetryProtocol;
1125     FrSkyData frsky;
1126     RSSIAlarmData rssiAlarms;
1127
1128     char bitmap[10+1];
1129
1130     unsigned int trainerMode;
1131
1132     ModuleData moduleData[CPN_MAX_MODULES+1/*trainer*/];
1133
1134     ScriptData scriptData[CPN_MAX_SCRIPTS];
1135
1136     SensorData sensorData[CPN_MAX_SENSORS];
1137
1138     unsigned int toplcdTimer;
1139
1140     CustomScreenData customScreenData[5];
1141
1142     TopbarData topbarData;
1143
1144     void clear();
1145     bool isEmpty() const;
1146     void setDefaultInputs(const GeneralSettings & settings);
1147     void setDefaultMixes(const GeneralSettings & settings);
1148     void setDefaultValues(unsigned int id, const GeneralSettings & settings);
1149
1150     int getTrimValue(int phaseIdx, int trimIdx);
1151     void setTrimValue(int phaseIdx, int trimIdx, int value);
1152
1153     bool isGVarLinked(int phaseIdx, int gvarIdx);
1154     int getGVarFieldValue(int phaseIdx, int gvarIdx);
1155     float getGVarFieldValuePrec(int phaseIdx, int gvarIdx);
1156
1157     ModelData removeGlobalVars();
1158
1159     void clearMixes();
1160     void clearInputs();
1161
1162     int getChannelsMax(bool forceExtendedLimits=false) const;
1163
1164     bool isAvailable(const RawSwitch & swtch) const;
1165
1166   protected:
1167     void removeGlobalVar(int & var);
1168 };
1169
1170
1171 class TrainerMix {
1172   public:
1173     TrainerMix() { clear(); }
1174     unsigned int src; // 0-7 = ch1-8
1175     RawSwitch swtch;
1176     int weight;
1177     unsigned int mode;   // off, add-mode, subst-mode
1178     void clear() { memset(this, 0, sizeof(TrainerMix)); }
1179 };
1180
1181 class TrainerData {
1182   public:
1183     TrainerData() { clear(); }
1184     int         calib[4];
1185     TrainerMix  mix[4];
1186     void clear() { memset(this, 0, sizeof(TrainerData)); }
1187 };
1188
1189 class GeneralSettings {
1190   public:
1191
1192     enum BeeperMode {
1193       BEEPER_QUIET = -2,
1194       BEEPER_ALARMS_ONLY = -1,
1195       BEEPER_NOKEYS = 0,
1196       BEEPER_ALL = 1
1197     };
1198
1199     GeneralSettings();
1200     void convert(Board::Type before, Board::Type after);
1201
1202     int getDefaultStick(unsigned int channel) const;
1203     RawSource getDefaultSource(unsigned int channel) const;
1204     int getDefaultChannel(unsigned int stick) const;
1205
1206     unsigned int version;
1207     unsigned int variant;
1208     int   calibMid[CPN_MAX_ANALOGS];
1209     int   calibSpanNeg[CPN_MAX_ANALOGS];
1210     int   calibSpanPos[CPN_MAX_ANALOGS];
1211     unsigned int  currModelIndex;
1212     char currModelFilename[16+1];
1213     unsigned int   contrast;
1214     unsigned int   vBatWarn;
1215     int    txVoltageCalibration;
1216     int    txCurrentCalibration;
1217     int    vBatMin;
1218     int    vBatMax;
1219     int   backlightMode;
1220     TrainerData trainer;
1221     unsigned int   view;    // main screen view // TODO enum
1222     bool      disableThrottleWarning;
1223     bool      fai;
1224     bool      disableMemoryWarning;
1225     BeeperMode beeperMode;
1226     bool      disableAlarmWarning;
1227     bool      disableRssiPoweroffAlarm;
1228     unsigned int       usbMode;
1229     BeeperMode hapticMode;
1230     unsigned int   stickMode; // TODO enum
1231     int       timezone;
1232     bool      adjustRTC;
1233     bool      optrexDisplay;
1234     unsigned int    inactivityTimer;
1235     bool      minuteBeep;
1236     bool      preBeep;
1237     bool      flashBeep;
1238     unsigned int  splashMode;
1239     int splashDuration;
1240     unsigned int  backlightDelay;
1241     unsigned int   templateSetup;  //RETA order according to chout_ar array
1242     int    PPM_Multiplier;
1243     int    hapticLength;
1244     unsigned int   reNavigation;
1245     unsigned int stickReverse;
1246     unsigned int   speakerPitch;
1247     int   hapticStrength;
1248     unsigned int   speakerMode;
1249     char      ownerName[10+1];
1250     int    beeperLength;
1251     unsigned int    gpsFormat;
1252     int     speakerVolume;
1253     unsigned int   backlightBright;
1254     unsigned int   backlightOffBright;
1255     int switchesDelay;
1256     int    temperatureCalib;
1257     int    temperatureWarn;
1258     unsigned int mAhWarn;
1259     unsigned int mAhUsed;
1260     unsigned int globalTimer;
1261     bool bluetoothEnable;
1262     char bluetoothName[10+1];
1263     unsigned int bluetoothBaudrate;
1264     unsigned int bluetoothMode;
1265     unsigned int sticksGain;
1266     unsigned int rotarySteps;
1267     unsigned int countryCode;
1268     bool jitterFilter;
1269     unsigned int imperial;
1270     char ttsLanguage[2+1];
1271     int beepVolume;
1272     int wavVolume;
1273     int varioVolume;
1274     int varioPitch;
1275     int varioRange;
1276     int varioRepeat;
1277     int backgroundVolume;
1278     unsigned int mavbaud;
1279     unsigned int switchUnlockStates;
1280     unsigned int hw_uartMode;
1281     unsigned int backlightColor;
1282     CustomFunctionData customFn[CPN_MAX_SPECIAL_FUNCTIONS];
1283     char switchName[CPN_MAX_SWITCHES][3+1];
1284     unsigned int switchConfig[CPN_MAX_SWITCHES];
1285     char stickName[CPN_MAX_STICKS][3+1];
1286     char potName[CPN_MAX_KNOBS][3+1];
1287     unsigned int potConfig[CPN_MAX_KNOBS];
1288     char sliderName[CPN_MAX_SLIDERS][3+1];
1289     unsigned int sliderConfig[CPN_MAX_SLIDERS];
1290
1291     char themeName[8+1];
1292     typedef uint8_t ThemeOptionData[8+1];
1293     ThemeOptionData themeOptionValue[5];
1294
1295     bool switchPositionAllowedTaranis(int index) const;
1296     bool switchSourceAllowedTaranis(int index) const;
1297     bool isPotAvailable(int index) const;
1298     bool isSliderAvailable(int index) const;
1299 };
1300
1301 class CategoryData {
1302   public:
1303     CategoryData(const char * name) {
1304       strncpy(this->name, name, sizeof(CategoryData::name));
1305     }
1306     char name[15+1];
1307 };
1308
1309 class RadioData {
1310   public:
1311     RadioData();
1312
1313     GeneralSettings generalSettings;
1314     std::vector<CategoryData> categories;
1315     std::vector<ModelData> models;
1316
1317     void convert(Board::Type before, Board::Type after);
1318
1319     void setCurrentModel(unsigned int index);
1320     void fixModelFilenames();
1321     QString getNextModelFilename();
1322
1323   protected:
1324     void fixModelFilename(unsigned int index);
1325 };
1326
1327 #endif // _RADIODATA_H_