1016 lines
30 KiB
C++
1016 lines
30 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 "boards.h"
|
|
#include "macros.h"
|
|
#include "compounditemmodels.h"
|
|
#include "moduledata.h"
|
|
#include "helpers.h"
|
|
#include "boardfactories.h"
|
|
#include "generalsettings.h"
|
|
|
|
// TODO remove all those constants
|
|
// Update: These are now all only used within this class.
|
|
// External access is only via getEEpromSize() and getFlashSize()
|
|
|
|
#define EESIZE_TARANIS (32*1024)
|
|
#define EESIZE_SKY9X (128*4096)
|
|
#define EESIZE_9XRPRO (128*4096)
|
|
#define EESIZE_MAX EESIZE_9XRPRO
|
|
|
|
// getFlashSize() (and these macros) is only used by radiointerface::getDfuArgs (perhaps can find a better way?)
|
|
|
|
#define FSIZE_TARANIS (512*1024)
|
|
#define FSIZE_SKY9X (256*1024)
|
|
#define FSIZE_9XRPRO (512*1024)
|
|
#define FSIZE_HORUS (2048*1024)
|
|
#define FSIZE_MAX FSIZE_HORUS
|
|
|
|
// pre v2.10
|
|
static const StringTagMappingTable legacyTrimSourcesLut = {
|
|
{std::to_string(TRIM_AXIS_LH), "TrimRud"},
|
|
{std::to_string(TRIM_AXIS_LV), "TrimEle"},
|
|
{std::to_string(TRIM_AXIS_RV), "TrimThr"},
|
|
{std::to_string(TRIM_AXIS_RH), "TrimAil"},
|
|
{std::to_string(TRIM_AXIS_T5), "TrimT5"},
|
|
{std::to_string(TRIM_AXIS_T6), "TrimT6"},
|
|
{std::to_string(TRIM_AXIS_T7), "TrimT7"},
|
|
{std::to_string(TRIM_AXIS_T8), "TrimT8"},
|
|
};
|
|
|
|
static const StringTagMappingTable trimSwitchesLut = {
|
|
{std::to_string(TRIM_SW_LH_DEC), "TrimRudLeft"},
|
|
{std::to_string(TRIM_SW_LH_INC), "TrimRudRight"},
|
|
{std::to_string(TRIM_SW_LV_DEC), "TrimEleDown"},
|
|
{std::to_string(TRIM_SW_LV_INC), "TrimEleUp"},
|
|
{std::to_string(TRIM_SW_RV_DEC), "TrimThrDown"},
|
|
{std::to_string(TRIM_SW_RV_INC), "TrimThrUp"},
|
|
{std::to_string(TRIM_SW_RH_DEC), "TrimAilLeft"},
|
|
{std::to_string(TRIM_SW_RH_INC), "TrimAilRight"},
|
|
{std::to_string(TRIM_SW_T5_DEC), "TrimT5Down"},
|
|
{std::to_string(TRIM_SW_T5_INC), "TrimT5Up"},
|
|
{std::to_string(TRIM_SW_T6_DEC), "TrimT6Down"},
|
|
{std::to_string(TRIM_SW_T6_INC), "TrimT6Up"},
|
|
{std::to_string(TRIM_SW_T7_INC), "TrimT7Up"},
|
|
{std::to_string(TRIM_SW_T7_DEC), "TrimT7Down"},
|
|
{std::to_string(TRIM_SW_T8_INC), "TrimT8Up"},
|
|
{std::to_string(TRIM_SW_T8_DEC), "TrimT8Down"},
|
|
};
|
|
|
|
using namespace Board;
|
|
|
|
Boards::Boards(Board::Type board) :
|
|
legacyTrimSourcesLookupTable(legacyTrimSourcesLut),
|
|
trimSwitchesLookupTable(trimSwitchesLut),
|
|
rawSwitchTypesLookupTable(RawSwitch::getRawSwitchTypesLookupTable()),
|
|
rawSourceSpecialTypesLookupTable(RawSource::getSpecialTypesLookupTable())
|
|
{
|
|
setBoardType(board);
|
|
}
|
|
|
|
void Boards::setBoardType(const Type & board)
|
|
{
|
|
if (board < BOARD_TYPE_MAX)
|
|
m_boardType = board;
|
|
else
|
|
m_boardType = BOARD_UNKNOWN;
|
|
|
|
m_boardJson = getBoardJson(m_boardType);
|
|
}
|
|
|
|
uint32_t Boards::getFourCC(Type board)
|
|
{
|
|
switch (board) {
|
|
case BOARD_HORUS_X12S:
|
|
return 0x3478746F;
|
|
case BOARD_X10:
|
|
case BOARD_X10_EXPRESS:
|
|
return 0x3778746F;
|
|
case BOARD_TARANIS_XLITE:
|
|
return 0x3978746F;
|
|
case BOARD_TARANIS_XLITES:
|
|
return 0x3B78746F;
|
|
case BOARD_TARANIS_X7:
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
return 0x3678746F;
|
|
case BOARD_TARANIS_X9E:
|
|
return 0x3578746F;
|
|
case BOARD_TARANIS_X9D:
|
|
case BOARD_TARANIS_X9DP:
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
return 0x3378746F;
|
|
case BOARD_TARANIS_X9LITE:
|
|
return 0x3C78746F;
|
|
case BOARD_TARANIS_X9LITES:
|
|
return 0x3E78746F;
|
|
case BOARD_SKY9X:
|
|
case BOARD_AR9X:
|
|
case BOARD_9XRPRO:
|
|
return 0x3278746F;
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
return 0x4578746F;
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
return 0x4B78746F; // TODO : Check this value
|
|
case BOARD_JUMPER_T12:
|
|
return 0x3D78746F;
|
|
case BOARD_JUMPER_TLITE:
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
return 0x4278746F;
|
|
case BOARD_JUMPER_TPRO:
|
|
return 0x4678746F;
|
|
case BOARD_JUMPER_T16:
|
|
return 0x3F78746F;
|
|
case BOARD_JUMPER_T18:
|
|
return 0x4078746F;
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
return 0x3878746F;
|
|
case BOARD_RADIOMASTER_TX12:
|
|
return 0x4178746F;
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
return 0x4878746F;
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
return 0x4778746F;
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
return 0x4778746F;
|
|
case BOARD_RADIOMASTER_T8:
|
|
return 0x4378746F;
|
|
case BOARD_FLYSKY_NV14:
|
|
return 0x3A78746F;
|
|
case BOARD_FLYSKY_EL18:
|
|
return 0x3A78746F;
|
|
case BOARD_FLYSKY_PL18:
|
|
return 0x4878746F;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int Boards::getEEpromSize(Board::Type board)
|
|
{
|
|
switch (board) {
|
|
case BOARD_SKY9X:
|
|
return EESIZE_SKY9X;
|
|
case BOARD_9XRPRO:
|
|
case BOARD_AR9X:
|
|
return EESIZE_9XRPRO;
|
|
case BOARD_TARANIS_XLITES:
|
|
case BOARD_TARANIS_XLITE:
|
|
case BOARD_TARANIS_X7:
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
case BOARD_TARANIS_X9LITE:
|
|
case BOARD_TARANIS_X9LITES:
|
|
case BOARD_TARANIS_X9D:
|
|
case BOARD_TARANIS_X9DP:
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
case BOARD_TARANIS_X9E:
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
case BOARD_JUMPER_T12:
|
|
case BOARD_JUMPER_T12MAX:
|
|
case BOARD_JUMPER_T14:
|
|
case BOARD_JUMPER_T20:
|
|
case BOARD_JUMPER_T20V2:
|
|
case BOARD_JUMPER_TLITE:
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
case BOARD_JUMPER_TPRO:
|
|
case BOARD_JUMPER_TPROV2:
|
|
case BOARD_JUMPER_TPROS:
|
|
case BOARD_RADIOMASTER_TX12:
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
case BOARD_RADIOMASTER_T8:
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
case BOARD_RADIOMASTER_POCKET:
|
|
return EESIZE_TARANIS;
|
|
case BOARD_UNKNOWN:
|
|
return EESIZE_MAX;
|
|
case BOARD_HORUS_X12S:
|
|
case BOARD_X10:
|
|
case BOARD_X10_EXPRESS:
|
|
case BOARD_JUMPER_T15:
|
|
case BOARD_JUMPER_T16:
|
|
case BOARD_JUMPER_T18:
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
case BOARD_FLYSKY_NV14:
|
|
case BOARD_FLYSKY_EL18:
|
|
case BOARD_FLYSKY_PL18:
|
|
case BOARD_FATFISH_F16:
|
|
return 0;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int Boards::getFlashSize(Type board)
|
|
{
|
|
switch (board) {
|
|
case BOARD_SKY9X:
|
|
return FSIZE_SKY9X;
|
|
case BOARD_9XRPRO:
|
|
case BOARD_AR9X:
|
|
return FSIZE_9XRPRO;
|
|
case BOARD_TARANIS_XLITES:
|
|
case BOARD_TARANIS_XLITE:
|
|
case BOARD_TARANIS_X7:
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
case BOARD_TARANIS_X9LITE:
|
|
case BOARD_TARANIS_X9LITES:
|
|
case BOARD_TARANIS_X9D:
|
|
case BOARD_TARANIS_X9DP:
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
case BOARD_TARANIS_X9E:
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
case BOARD_JUMPER_T12:
|
|
case BOARD_JUMPER_T12MAX:
|
|
case BOARD_JUMPER_T14:
|
|
case BOARD_JUMPER_T20:
|
|
case BOARD_JUMPER_T20V2:
|
|
case BOARD_JUMPER_TLITE:
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
case BOARD_JUMPER_TPRO:
|
|
case BOARD_JUMPER_TPROV2:
|
|
case BOARD_JUMPER_TPROS:
|
|
case BOARD_RADIOMASTER_TX12:
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
case BOARD_RADIOMASTER_T8:
|
|
case BOARD_RADIOMASTER_POCKET:
|
|
return FSIZE_TARANIS;
|
|
case BOARD_HORUS_X12S:
|
|
case BOARD_X10:
|
|
case BOARD_X10_EXPRESS:
|
|
case BOARD_JUMPER_T15:
|
|
case BOARD_JUMPER_T16:
|
|
case BOARD_JUMPER_T18:
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
case BOARD_FLYSKY_NV14:
|
|
case BOARD_FLYSKY_EL18:
|
|
case BOARD_FLYSKY_PL18:
|
|
case BOARD_FATFISH_F16:
|
|
return FSIZE_HORUS;
|
|
case BOARD_UNKNOWN:
|
|
return FSIZE_MAX;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// static
|
|
int Boards::getCapability(Board::Type board, Board::Capability capability)
|
|
{
|
|
// TODO investigate usage of any that should be covered in BoardJson::getCapability or are no longer required
|
|
// some could be used when importing pre v2.10 configurations
|
|
switch (capability) {
|
|
case FactoryInstalledPots:
|
|
if (IS_TARANIS_X9(board))
|
|
return 2;
|
|
else
|
|
return getCapability(board, Pots);
|
|
|
|
case FactoryInstalledSwitches:
|
|
if (IS_TARANIS_X9E(board))
|
|
return 8;
|
|
else if (IS_JUMPER_TPROV2(board))
|
|
return 6;
|
|
else if (IS_JUMPER_TLITE(board) || IS_JUMPER_TPROV1(board) || IS_BETAFPV_LR3PRO(board) || IS_IFLIGHT_COMMANDO8(board))
|
|
return 4;
|
|
else if(IS_RADIOMASTER_ZORRO(board))
|
|
return 8;
|
|
else if (board == BOARD_RADIOMASTER_POCKET)
|
|
return 5;
|
|
else if (IS_FAMILY_T12(board))
|
|
return 6;
|
|
else if (IS_HORUS_X12S(board))
|
|
return 8;
|
|
else
|
|
return getCapability(board, Board::Switches);
|
|
|
|
case HasAudioMuteGPIO:
|
|
// All color lcd (including NV14 and EL18) except Horus X12S
|
|
// TX12, TX12MK2, ZORRO, BOXER, T8, TLITE, TPRO, LR3PRO, COMMANDO8
|
|
return (IS_FAMILY_HORUS_OR_T16(board) && !IS_HORUS_X12S(board)) || IS_FAMILY_T12(board);
|
|
|
|
case HasColorLcd:
|
|
return IS_FAMILY_HORUS_OR_T16(board);
|
|
|
|
case HasExternalModuleSupport:
|
|
return (IS_STM32(board) && !IS_RADIOMASTER_T8(board));
|
|
|
|
case HasIMU:
|
|
return (IS_FAMILY_HORUS_OR_T16(board) || IS_TARANIS(board));
|
|
|
|
case HasInternalModuleSupport:
|
|
return (IS_STM32(board) && !IS_TARANIS_X9(board));
|
|
|
|
case HasLedStripGPIO:
|
|
// No current radio do support that feature
|
|
return false;
|
|
|
|
case HasSDCard:
|
|
return IS_STM32(board);
|
|
|
|
case HasTrainerModuleCPPM:
|
|
return (getCapability(board, HasTrainerModuleSBUS) || IS_FAMILY_HORUS_OR_T16(board));
|
|
|
|
case HasTrainerModuleSBUS:
|
|
return ((IS_TARANIS_X9LITE(board) || (IS_TARANIS_XLITE(board) && !IS_TARANIS_X9LITES(board)) ||
|
|
IS_TARANIS_X9DP_2019(board) || IS_TARANIS_X7_ACCESS(board) || IS_RADIOMASTER_ZORRO(board) ||
|
|
IS_RADIOMASTER_TX12_MK2(board) || IS_RADIOMASTER_BOXER(board) || IS_RADIOMASTER_POCKET(board)) ||
|
|
(getCapability(board, HasExternalModuleSupport) && (IS_TARANIS(board) && !IS_FAMILY_T12(board))));
|
|
|
|
case MaxAnalogs:
|
|
return getCapability(board, Board::Sticks) + getCapability(board, Board::Pots) + getCapability(board, Board::Sliders) +
|
|
getCapability(board, Board::JoystickAxes) + getCapability(board, Board::GyroAxes);
|
|
|
|
case SportMaxBaudRate:
|
|
if (IS_FAMILY_T16(board) || IS_FLYSKY_NV14(board) || IS_FLYSKY_EL18(board) || IS_TARANIS_X7_ACCESS(board) ||
|
|
(IS_TARANIS(board) && !IS_TARANIS_XLITE(board) && !IS_TARANIS_X7(board) && !IS_TARANIS_X9LITE(board)))
|
|
return 400000; // 400K and higher
|
|
else
|
|
return 250000; // less than 400K
|
|
|
|
default:
|
|
return getBoardJson(board)->getCapability(capability);
|
|
}
|
|
}
|
|
|
|
QString Boards::getAxisName(int index)
|
|
{
|
|
const QString axes[] = {
|
|
tr("Left Horizontal"),
|
|
tr("Left Vertical"),
|
|
tr("Right Vertical"),
|
|
tr("Right Horizontal"),
|
|
tr("Aux. 1"),
|
|
tr("Aux. 2"),
|
|
};
|
|
if (index < (int)DIM(axes))
|
|
return axes[index];
|
|
else
|
|
return CPN_STR_UNKNOWN_ITEM;
|
|
}
|
|
|
|
// mapping json tag (1st entry) to legacy tag (2nd entry)
|
|
// json tag then used to find inputs index
|
|
// only used to decode pre v2.10 yaml configs
|
|
StringTagMappingTable Boards::getLegacyAnalogsLookupTable(Board::Type board)
|
|
{
|
|
StringTagMappingTable tbl;
|
|
|
|
tbl.insert(tbl.end(), {
|
|
{tr("LH").toStdString(), "Rud"},
|
|
{tr("LV").toStdString(), "Ele"},
|
|
{tr("RV").toStdString(), "Thr"},
|
|
{tr("RH").toStdString(), "Ail"},
|
|
});
|
|
|
|
tbl.insert(tbl.end(), {
|
|
|
|
{tr("JSx").toStdString(), "MOUSE1"},
|
|
{tr("JSy").toStdString(), "MOUSE2"},
|
|
{tr("JSx").toStdString(), "JSx"},
|
|
{tr("JSy").toStdString(), "JSy"},
|
|
{tr("TILT_X").toStdString(), "TILT_X"},
|
|
{tr("TILT_Y").toStdString(), "TILT_Y"},
|
|
{tr("TILT_X").toStdString(), "GYRO1"},
|
|
{tr("TILT_Y").toStdString(), "GYRO2"},
|
|
});
|
|
|
|
if (IS_TARANIS_X9LITE(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("SL1").toStdString(), "S1"},
|
|
{tr("P1").toStdString(), "POT1"},
|
|
});
|
|
} else if (IS_TARANIS_X9E(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
{tr("P3").toStdString(), "POT3"},
|
|
{tr("P4").toStdString(), "POT4"},
|
|
{tr("SL1").toStdString(), "SLIDER1"},
|
|
{tr("SL2").toStdString(), "SLIDER2"},
|
|
{tr("SL3").toStdString(), "SLIDER3"},
|
|
{tr("SL4").toStdString(), "SLIDER4"},
|
|
});
|
|
} else if (IS_TARANIS_XLITES(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
});
|
|
} else if (IS_RADIOMASTER_BOXER(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
{tr("P3").toStdString(), "POT3"},
|
|
});
|
|
} else if (IS_RADIOMASTER_POCKET(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "P1"},
|
|
});
|
|
} else if ((IS_TARANIS_SMALL(board) && !IS_JUMPER_TLITE(board) && !IS_JUMPER_T20(board)) || IS_FLYSKY_NV14(board) || IS_FLYSKY_EL18(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
});
|
|
} else if (IS_TARANIS_X9(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
{tr("P3").toStdString(), "POT3"},
|
|
{tr("SL1").toStdString(), "SLIDER1"},
|
|
{tr("SL2").toStdString(), "SLIDER2"},
|
|
});
|
|
} else if (IS_HORUS_X12S(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "S1"},
|
|
{tr("P2").toStdString(), "6POS"},
|
|
{tr("P3").toStdString(), "S2"},
|
|
{tr("P4").toStdString(), "S3"},
|
|
{tr("P5").toStdString(), "S4"},
|
|
{tr("SL1").toStdString(), "LS"},
|
|
{tr("SL2").toStdString(), "RS"},
|
|
});
|
|
} else if (IS_FLYSKY_PL18(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "POT1"},
|
|
{tr("P2").toStdString(), "POT2"},
|
|
{tr("P3").toStdString(), "POT3"},
|
|
{tr("SL1").toStdString(), "LS"},
|
|
{tr("SL2").toStdString(), "RS"},
|
|
});
|
|
} else if (IS_HORUS_X10(board) || IS_FAMILY_T16(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "S1"},
|
|
{tr("P2").toStdString(), "6POS"},
|
|
{tr("P3").toStdString(), "S2"},
|
|
{tr("EXT1").toStdString(), "EXT1"},
|
|
{tr("EXT2").toStdString(), "EXT2"},
|
|
{tr("EXT3").toStdString(), "EXT3"},
|
|
{tr("EXT4").toStdString(), "EXT4"},
|
|
{tr("SL1").toStdString(), "LS"},
|
|
{tr("SL2").toStdString(), "RS"},
|
|
});
|
|
} else if (IS_JUMPER_T20(board)) {
|
|
tbl.insert(tbl.end(), {
|
|
{tr("P1").toStdString(), "P1"},
|
|
{tr("P2").toStdString(), "P2"},
|
|
{tr("SL1").toStdString(), "SL1"},
|
|
{tr("SL2").toStdString(), "SL2"},
|
|
{tr("SL3").toStdString(), "SL3"},
|
|
{tr("SL4").toStdString(), "SL4"},
|
|
});
|
|
}
|
|
|
|
return tbl;
|
|
}
|
|
|
|
std::string Boards::getLegacyAnalogMappedInputTag(const char * legacytag, Board::Type board)
|
|
{
|
|
return DataHelpers::getStringTagMappingName(getLegacyAnalogsLookupTable(board == Board::BOARD_UNKNOWN ? getCurrentBoard() : board), legacytag);
|
|
}
|
|
|
|
bool Boards::isBoardCompatible(Type board1, Type board2)
|
|
{
|
|
return (getFourCC(board1) == getFourCC(board2));
|
|
}
|
|
|
|
QString Boards::getBoardName(Board::Type board)
|
|
{
|
|
switch (board) {
|
|
case BOARD_TARANIS_X7:
|
|
return "Taranis X7/X7S";
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
return "Taranis X7/X7S Access";
|
|
case BOARD_TARANIS_XLITE:
|
|
return "Taranis X-Lite";
|
|
case BOARD_TARANIS_XLITES:
|
|
return "Taranis X-Lite S/PRO";
|
|
case BOARD_TARANIS_X9D:
|
|
return "Taranis X9D";
|
|
case BOARD_TARANIS_X9DP:
|
|
return "Taranis X9D+";
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
return "Taranis X9D+ 2019";
|
|
case BOARD_TARANIS_X9E:
|
|
return "Taranis X9E";
|
|
case BOARD_TARANIS_X9LITE:
|
|
return "Taranis X9-Lite";
|
|
case BOARD_TARANIS_X9LITES:
|
|
return "Taranis X9-Lite S";
|
|
case BOARD_SKY9X:
|
|
return "Sky9x";
|
|
case BOARD_9XRPRO:
|
|
return "9XR-PRO";
|
|
case BOARD_AR9X:
|
|
return "AR9X";
|
|
case BOARD_HORUS_X12S:
|
|
return "Horus X12S";
|
|
case BOARD_X10:
|
|
return "Horus X10/X10S";
|
|
case BOARD_X10_EXPRESS:
|
|
return "Horus X10/X10S Express";
|
|
case BOARD_JUMPER_T12:
|
|
return "Jumper T12";
|
|
case BOARD_JUMPER_TLITE:
|
|
return "Jumper T-Lite";
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
return "Jumper T-Lite (F4 MCU)";
|
|
case BOARD_JUMPER_TPRO:
|
|
return "Jumper T-Pro";
|
|
case BOARD_JUMPER_TPROV2:
|
|
return "Jumper T-Pro V2";
|
|
case BOARD_JUMPER_TPROS:
|
|
return "Jumper T-Pro S";
|
|
case BOARD_JUMPER_T12MAX:
|
|
return "Jumper T12 MAX";
|
|
case BOARD_JUMPER_T14:
|
|
return "Jumper T14";
|
|
case BOARD_JUMPER_T15:
|
|
return "Jumper T15";
|
|
case BOARD_JUMPER_T16:
|
|
return "Jumper T16";
|
|
case BOARD_JUMPER_T18:
|
|
return "Jumper T18";
|
|
case BOARD_JUMPER_T20:
|
|
return "Jumper T20";
|
|
case BOARD_JUMPER_T20V2:
|
|
return "Jumper T20 V2";
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
return "Radiomaster TX16S";
|
|
case BOARD_RADIOMASTER_TX12:
|
|
return "Radiomaster TX12";
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
return "Radiomaster TX12 Mark II";
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
return "Radiomaster Zorro";
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
return "Radiomaster Boxer";
|
|
case BOARD_RADIOMASTER_POCKET:
|
|
return "Radiomaster Pocket";
|
|
case BOARD_RADIOMASTER_T8:
|
|
return "Radiomaster T8";
|
|
case BOARD_FLYSKY_NV14:
|
|
return "FlySky NV14";
|
|
case BOARD_FLYSKY_EL18:
|
|
return "FlySky EL18";
|
|
case BOARD_FLYSKY_PL18:
|
|
return "FlySky PL18";
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
return "BETAFPV LR3PRO";
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
return "iFlight Commando 8";
|
|
case BOARD_FATFISH_F16:
|
|
return "Fatfish F16";
|
|
default:
|
|
return CPN_STR_UNKNOWN_ITEM;
|
|
}
|
|
}
|
|
|
|
// static
|
|
QString Boards::switchTypeToString(int value)
|
|
{
|
|
switch(value) {
|
|
case SWITCH_NOT_AVAILABLE:
|
|
return tr("None");
|
|
case SWITCH_TOGGLE:
|
|
return tr("2 Positions Toggle");
|
|
case SWITCH_2POS:
|
|
return tr("2 Positions");
|
|
case SWITCH_3POS:
|
|
return tr("3 Positions");
|
|
case SWITCH_FUNC:
|
|
return tr("Function");
|
|
default:
|
|
return CPN_STR_UNKNOWN_ITEM;
|
|
}
|
|
}
|
|
|
|
// static
|
|
AbstractStaticItemModel * Boards::switchTypeItemModel()
|
|
{
|
|
AbstractStaticItemModel * mdl = new AbstractStaticItemModel();
|
|
mdl->setName(AIM_BOARDS_SWITCH_TYPE);
|
|
|
|
for (int i = 0; i < SWITCH_FUNC; i++) { // Function not required in lists
|
|
mdl->appendToItemList(switchTypeToString(i), i, true, 0,
|
|
(i == SWITCH_NOT_AVAILABLE ? SwitchTypeFlagNone : (i < SWITCH_3POS ? SwitchTypeFlag2Pos : SwitchTypeFlag3Pos)));
|
|
}
|
|
|
|
mdl->loadItemList();
|
|
return mdl;
|
|
}
|
|
|
|
QList<int> Boards::getSupportedInternalModules(Board::Type board)
|
|
{
|
|
QList<int> modules;
|
|
modules = {(int)MODULE_TYPE_NONE};
|
|
if (IS_TARANIS_X9DP_2019(board) || IS_TARANIS_X7_ACCESS(board)) {
|
|
modules.append({(int)MODULE_TYPE_ISRM_PXX2});
|
|
} else if (IS_FLYSKY_NV14(board)) {
|
|
modules.append({(int)MODULE_TYPE_FLYSKY_AFHDS2A});
|
|
} else if (IS_FLYSKY_EL18(board)) {
|
|
modules.append({
|
|
(int)MODULE_TYPE_FLYSKY_AFHDS3,
|
|
(int)MODULE_TYPE_CROSSFIRE,
|
|
});
|
|
} else if (IS_FAMILY_HORUS_OR_T16(board) || IS_FAMILY_T12(board) ||
|
|
(IS_TARANIS_SMALL(board) && IS_ACCESS_RADIO(board))) {
|
|
modules.append({
|
|
(int)MODULE_TYPE_XJT_PXX1,
|
|
(int)MODULE_TYPE_ISRM_PXX2,
|
|
(int)MODULE_TYPE_CROSSFIRE,
|
|
(int)MODULE_TYPE_MULTIMODULE,
|
|
});
|
|
} else if (IS_TARANIS(board)) {
|
|
modules.append({(int)MODULE_TYPE_XJT_PXX1});
|
|
}
|
|
|
|
return modules;
|
|
}
|
|
|
|
int Boards::getDefaultInternalModules(Board::Type board)
|
|
{
|
|
switch(board) {
|
|
case BOARD_TARANIS_X7:
|
|
case BOARD_TARANIS_X9D:
|
|
case BOARD_TARANIS_X9DP:
|
|
case BOARD_TARANIS_X9E:
|
|
case BOARD_HORUS_X12S:
|
|
case BOARD_X10:
|
|
case BOARD_TARANIS_XLITE:
|
|
return (int)MODULE_TYPE_XJT_PXX1;
|
|
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
case BOARD_X10_EXPRESS:
|
|
case BOARD_TARANIS_XLITES:
|
|
case BOARD_TARANIS_X9LITE:
|
|
case BOARD_TARANIS_X9LITES:
|
|
return (int)MODULE_TYPE_ISRM_PXX2;
|
|
|
|
case BOARD_JUMPER_T12:
|
|
case BOARD_JUMPER_T16:
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
case BOARD_JUMPER_T18:
|
|
case BOARD_RADIOMASTER_TX12:
|
|
case BOARD_RADIOMASTER_T8:
|
|
case BOARD_JUMPER_TLITE:
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
case BOARD_JUMPER_TPRO:
|
|
case BOARD_JUMPER_TPROV2:
|
|
case BOARD_FLYSKY_PL18:
|
|
return (int)MODULE_TYPE_MULTIMODULE;
|
|
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
case BOARD_RADIOMASTER_POCKET:
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
case BOARD_JUMPER_T12MAX:
|
|
case BOARD_JUMPER_T14:
|
|
case BOARD_JUMPER_T15:
|
|
case BOARD_JUMPER_T20:
|
|
case BOARD_JUMPER_T20V2:
|
|
case BOARD_JUMPER_TPROS:
|
|
case BOARD_FATFISH_F16:
|
|
return (int)MODULE_TYPE_CROSSFIRE;
|
|
|
|
case BOARD_FLYSKY_NV14:
|
|
return (int)MODULE_TYPE_FLYSKY_AFHDS2A;
|
|
|
|
case BOARD_FLYSKY_EL18:
|
|
return (int)MODULE_TYPE_FLYSKY_AFHDS3;
|
|
|
|
default:
|
|
return (int)MODULE_TYPE_NONE;
|
|
}
|
|
}
|
|
|
|
#define BR(min, max, warn) vmin = min - 90; vmax = max - 120; vwarn = warn;
|
|
|
|
void Boards::getBattRange(Board::Type board, int& vmin, int& vmax, unsigned int& vwarn)
|
|
{
|
|
switch (board) {
|
|
case BOARD_TARANIS_X7:
|
|
case BOARD_TARANIS_X7_ACCESS:
|
|
case BOARD_TARANIS_X9D:
|
|
case BOARD_TARANIS_X9DP:
|
|
case BOARD_TARANIS_X9DP_2019:
|
|
case BOARD_TARANIS_X9LITE:
|
|
case BOARD_TARANIS_X9LITES:
|
|
case BOARD_RADIOMASTER_TX12:
|
|
case BOARD_RADIOMASTER_TX12_MK2:
|
|
case BOARD_RADIOMASTER_BOXER:
|
|
case BOARD_RADIOMASTER_POCKET:
|
|
case BOARD_RADIOMASTER_ZORRO:
|
|
// case BOARD_RADIOMASTER_MT12: // TODO
|
|
case BOARD_JUMPER_T12:
|
|
case BOARD_JUMPER_T14:
|
|
case BOARD_JUMPER_TPRO:
|
|
case BOARD_JUMPER_TPROV2:
|
|
default:
|
|
BR(60, 80, 65)
|
|
break;
|
|
case BOARD_TARANIS_X9E:
|
|
case BOARD_HORUS_X12S:
|
|
BR(85, 115, 87)
|
|
break;
|
|
case BOARD_TARANIS_XLITE:
|
|
case BOARD_TARANIS_XLITES:
|
|
case BOARD_X10:
|
|
case BOARD_X10_EXPRESS:
|
|
case BOARD_RADIOMASTER_TX16S:
|
|
case BOARD_JUMPER_T16:
|
|
case BOARD_JUMPER_T18:
|
|
case BOARD_JUMPER_T20:
|
|
case BOARD_JUMPER_T20V2:
|
|
BR(67, 83, 66)
|
|
break;
|
|
case BOARD_JUMPER_TLITE:
|
|
case BOARD_JUMPER_TLITE_F4:
|
|
case BOARD_RADIOMASTER_T8:
|
|
case BOARD_BETAFPV_LR3PRO:
|
|
BR(34, 42, 36)
|
|
break;
|
|
case BOARD_FLYSKY_NV14:
|
|
case BOARD_FLYSKY_EL18:
|
|
BR(35, 42, 37)
|
|
break;
|
|
case BOARD_FLYSKY_PL18:
|
|
BR(35, 43, 37)
|
|
break;
|
|
case BOARD_IFLIGHT_COMMANDO8:
|
|
BR(30, 42, 32)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// static
|
|
int Boards::getDefaultExternalModuleSize(Board::Type board)
|
|
{
|
|
if (!getCapability(board, HasExternalModuleSupport))
|
|
return EXTMODSIZE_NONE;
|
|
|
|
if (getCapability(board, HasColorLcd)) {
|
|
if (IS_FLYSKY_EL18(board))
|
|
return EXTMODSIZE_BOTH;
|
|
else
|
|
return EXTMODSIZE_STD;
|
|
}
|
|
|
|
if (IS_TARANIS_X9LITE(board) ||
|
|
IS_RADIOMASTER_ZORRO(board) ||
|
|
IS_RADIOMASTER_POCKET(board) ||
|
|
IS_JUMPER_TLITE(board) ||
|
|
IS_JUMPER_TPRO(board) ||
|
|
IS_JUMPER_T20(board) ||
|
|
IS_BETAFPV_LR3PRO(board))
|
|
return EXTMODSIZE_SMALL;
|
|
|
|
return EXTMODSIZE_STD;
|
|
}
|
|
|
|
// static
|
|
QString Boards::externalModuleSizeToString(int value)
|
|
{
|
|
switch(value) {
|
|
case EXTMODSIZE_NONE:
|
|
return tr("None");
|
|
case EXTMODSIZE_STD:
|
|
return tr("Standard");
|
|
case EXTMODSIZE_SMALL:
|
|
return tr("Small");
|
|
case EXTMODSIZE_BOTH:
|
|
return tr("Both");
|
|
default:
|
|
return CPN_STR_UNKNOWN_ITEM;
|
|
}
|
|
}
|
|
|
|
// static
|
|
AbstractStaticItemModel * Boards::externalModuleSizeItemModel()
|
|
{
|
|
AbstractStaticItemModel * mdl = new AbstractStaticItemModel();
|
|
mdl->setName(AIM_BOARDS_MODULE_SIZE);
|
|
|
|
for (int i = 0; i < EXTMODSIZE_COUNT; i++) {
|
|
mdl->appendToItemList(externalModuleSizeToString(i), i);
|
|
}
|
|
|
|
mdl->loadItemList();
|
|
return mdl;
|
|
}
|
|
|
|
QString Boards::flexTypeToString(int value)
|
|
{
|
|
switch(value) {
|
|
case FLEX_NONE:
|
|
return tr("None");
|
|
case FLEX_POT:
|
|
return tr("Pot");
|
|
case FLEX_POT_CENTER:
|
|
return tr("Pot with detent");
|
|
case FLEX_SLIDER:
|
|
return tr("Slider");
|
|
case FLEX_MULTIPOS:
|
|
return tr("Multipos Switch");
|
|
case FLEX_AXIS_X:
|
|
return tr("Axis X");
|
|
case FLEX_AXIS_Y:
|
|
return tr("Axis Y");
|
|
case FLEX_SWITCH:
|
|
return tr("Switch");
|
|
default:
|
|
return CPN_STR_UNKNOWN_ITEM;
|
|
}
|
|
}
|
|
|
|
AbstractStaticItemModel * Boards::flexTypeItemModel()
|
|
{
|
|
AbstractStaticItemModel * mdl = new AbstractStaticItemModel();
|
|
mdl->setName(AIM_BOARDS_FLEX_TYPE);
|
|
|
|
for (int i = 0; i < FLEX_TYPE_COUNT; i++) {
|
|
mdl->appendToItemList(flexTypeToString(i), i, true, 0, (i == (int)FLEX_SWITCH ? FlexTypeFlagSwitch : FlexTypeFlagNotSwitch));
|
|
}
|
|
|
|
mdl->loadItemList();
|
|
return mdl;
|
|
}
|
|
|
|
BoardJson* Boards::getBoardJson(Board::Type board)
|
|
{
|
|
return gBoardFactories->instance(board == Board::BOARD_UNKNOWN ? getCurrentBoard() : board);
|
|
}
|
|
|
|
Board::InputInfo Boards::getInputInfo(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputInfo(index);
|
|
}
|
|
|
|
int Boards::getInputIndex(QString val, Board::LookupValueType lvt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputIndex(val, lvt);
|
|
}
|
|
|
|
QString Boards::getInputName(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputName(index);
|
|
}
|
|
|
|
int Boards::getInputExtIndex(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputExtIndex(index);
|
|
}
|
|
|
|
int Boards::getInputPotIndex(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputPotIndex(index);
|
|
}
|
|
|
|
int Boards::getInputSliderIndex(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputSliderIndex(index);
|
|
}
|
|
|
|
QString Boards::getInputTag(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputTag(index);
|
|
}
|
|
|
|
int Boards::getInputTagOffset(QString tag, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputTagOffset(tag);
|
|
}
|
|
|
|
int Boards::getInputTypeOffset(Board::AnalogInputType type, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputTypeOffset(type);
|
|
}
|
|
|
|
int Boards::getInputYamlIndex(QString val, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputYamlIndex(val, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
QString Boards::getInputYamlName(int index, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputYamlName(index, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
int Boards::getInputsCalibrated(Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getInputsCalibrated();
|
|
}
|
|
|
|
Board::SwitchInfo Boards::getSwitchInfo(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchInfo(index);
|
|
}
|
|
|
|
int Boards::getSwitchIndex(QString val, Board::LookupValueType lvt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchIndex(val, lvt);
|
|
}
|
|
|
|
QString Boards::getSwitchName(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchName(index);
|
|
}
|
|
|
|
QString Boards::getSwitchTag(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchTag(index);
|
|
}
|
|
|
|
int Boards::getSwitchTagNum(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchTagNum(index);
|
|
}
|
|
|
|
int Boards::getSwitchYamlIndex(QString val, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchYamlIndex(val, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
QString Boards::getSwitchYamlName(int index, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getSwitchYamlName(index, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
int Boards::getTrimYamlIndex(QString val, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getTrimYamlIndex(val, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
QString Boards::getTrimYamlName(int index, int ylt, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->getTrimYamlName(index, (BoardJson::YamlLookupType)ylt);
|
|
}
|
|
|
|
bool Boards::isInputAvailable(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputAvailable(index);
|
|
}
|
|
|
|
bool Boards::isInputCalibrated(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputCalibrated(index);
|
|
}
|
|
|
|
bool Boards::isInputConfigurable(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputConfigurable(index);
|
|
}
|
|
|
|
bool Boards::isInputIgnored(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputIgnored(index);
|
|
}
|
|
|
|
bool Boards::isInputPot(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputFlexPot(index);
|
|
}
|
|
|
|
bool Boards::isInputStick(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isInputStick(index);
|
|
}
|
|
|
|
bool Boards::isSwitchConfigurable(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isSwitchConfigurable(index);
|
|
}
|
|
|
|
bool Boards::isSwitchFlex(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isSwitchFlex(index);
|
|
}
|
|
|
|
bool Boards::isSwitchFunc(int index, Board::Type board)
|
|
{
|
|
return getBoardJson(board)->isSwitchFunc(index);
|
|
}
|