Mirror/opentx
1
0
Fork 0
mirror of https://github.com/opentx/opentx.git synced 2025-07-24 00:35:18 +03:00
Code Issues Wiki Activity
opentx/companion/src/firmwares/boards.cpp
Bertrand Songis 4a618f1317
X9LiteS (#6820)
2019-09-24 13:13:45 +02:00

529 lines
13 KiB
C++
Raw Blame History

/*
* Copyright (C) OpenTX
*
* Based on code named
* 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"
// 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_STOCK 2048
#define EESIZE_M128 4096
#define EESIZE_GRUVIN9X 4096
#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_STOCK (64*1024)
#define FSIZE_M128 (128*1024)
#define FSIZE_GRUVIN9X (256*1024)
#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
using namespace Board;
void Boards::setBoardType(const Type & board)
{
if (board >= BOARD_UNKNOWN && board <= BOARD_TYPE_MAX)
m_boardType = board;
else
m_boardType = BOARD_UNKNOWN;
}
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:
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_MEGA2560:
case BOARD_GRUVIN9X:
return 0x3178746F;
case BOARD_9X_M64:
case BOARD_9X_M128:
return 0;
case BOARD_JUMPER_T12:
return 0x3D78746F;
case BOARD_UNKNOWN:
break;
}
return 0;
}
int Boards::getEEpromSize(Board::Type board)
{
switch (board) {
case BOARD_9X_M64:
return EESIZE_STOCK;
case BOARD_9X_M128:
return EESIZE_M128;
case BOARD_MEGA2560:
case BOARD_GRUVIN9X:
return EESIZE_GRUVIN9X;
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_X9LITE:
case BOARD_TARANIS_X9LITES:
case BOARD_TARANIS_X9D:
case BOARD_TARANIS_X9DP:
case BOARD_TARANIS_X9DP_2019:
case BOARD_TARANIS_X9E:
case BOARD_JUMPER_T12:
return EESIZE_TARANIS;
case BOARD_UNKNOWN:
return EESIZE_MAX;
case BOARD_HORUS_X12S:
case BOARD_X10:
case BOARD_X10_EXPRESS:
return 0;
}
return 0;
}
int Boards::getFlashSize(Type board)
{
switch (board) {
case BOARD_9X_M64:
return FSIZE_STOCK;
case BOARD_9X_M128:
return FSIZE_M128;
case BOARD_MEGA2560:
case BOARD_GRUVIN9X:
return FSIZE_GRUVIN9X;
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_X9LITE:
case BOARD_TARANIS_X9LITES:
case BOARD_TARANIS_X9D:
case BOARD_TARANIS_X9DP:
case BOARD_TARANIS_X9DP_2019:
case BOARD_TARANIS_X9E:
case BOARD_JUMPER_T12:
return FSIZE_TARANIS;
case BOARD_HORUS_X12S:
case BOARD_X10:
case BOARD_X10_EXPRESS:
return FSIZE_HORUS;
case BOARD_UNKNOWN:
return FSIZE_MAX;
default:
return 0;
}
}
SwitchInfo Boards::getSwitchInfo(Board::Type board, int index)
{
if (index < 0)
return {SWITCH_NOT_AVAILABLE, CPN_STR_UNKNOWN_ITEM};
if (IS_TARANIS_XLITES(board)) {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "SA"},
{SWITCH_3POS, "SB"},
{SWITCH_2POS, "SC"},
{SWITCH_2POS, "SD"},
{SWITCH_TOGGLE, "SE"},
{SWITCH_TOGGLE, "SF"}
};
if (index < DIM(switches))
return switches[index];
}
else if (IS_TARANIS_XLITE(board)) {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "SA"},
{SWITCH_3POS, "SB"},
{SWITCH_2POS, "SC"},
{SWITCH_2POS, "SD"}
};
if (index < DIM(switches))
return switches[index];
}
else if (IS_TARANIS_X7(board)) {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "SA"},
{SWITCH_3POS, "SB"},
{SWITCH_3POS, "SC"},
{SWITCH_3POS, "SD"},
{SWITCH_2POS, "SF"},
{SWITCH_TOGGLE, "SH"},
{SWITCH_2POS, "SI"},
{SWITCH_2POS, "SJ"}
};
if (index < DIM(switches))
return switches[index];
}
else if (IS_JUMPER_T12(board)) {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "SA"},
{SWITCH_3POS, "SB"},
{SWITCH_3POS, "SC"},
{SWITCH_3POS, "SD"},
{SWITCH_2POS, "SG"},
{SWITCH_2POS, "SH"}
};
if (index < DIM(switches))
return switches[index];
}
else if (IS_HORUS_OR_TARANIS(board)) {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "SA"},
{SWITCH_3POS, "SB"},
{SWITCH_3POS, "SC"},
{SWITCH_3POS, "SD"},
{SWITCH_3POS, "SE"},
{SWITCH_2POS, "SF"},
{SWITCH_3POS, "SG"},
{SWITCH_TOGGLE, "SH"},
{board == Board::BOARD_TARANIS_X9DP_2019 ? SWITCH_TOGGLE : SWITCH_3POS, "SI"},
{SWITCH_3POS, "SJ"},
{SWITCH_3POS, "SK"},
{SWITCH_3POS, "SL"},
{SWITCH_3POS, "SM"},
{SWITCH_3POS, "SN"},
{SWITCH_3POS, "SO"},
{SWITCH_3POS, "SP"},
{SWITCH_3POS, "SQ"},
{SWITCH_3POS, "SR"}
};
if (index < DIM(switches))
return switches[index];
}
else {
const Board::SwitchInfo switches[] = {
{SWITCH_3POS, "3POS"},
{SWITCH_2POS, "THR"},
{SWITCH_2POS, "RUD"},
{SWITCH_2POS, "ELE"},
{SWITCH_2POS, "AIL"},
{SWITCH_2POS, "GEA"},
{SWITCH_TOGGLE, "TRN"}
};
if (index < DIM(switches))
return switches[index];
}
return {SWITCH_NOT_AVAILABLE, CPN_STR_UNKNOWN_ITEM};
}
int Boards::getCapability(Board::Type board, Board::Capability capability)
{
switch (capability) {
case Sticks:
return 4;
case Pots:
if (IS_TARANIS_X9LITE(board))
return 1;
else if (IS_TARANIS_SMALL(board) || IS_JUMPER_T12(board))
return 2;
else if (IS_TARANIS_X9E(board))
return 4;
else if (IS_HORUS_X10(board))
return 5;
else if (IS_HORUS_X12S(board))
return 3;
else
return 3;
case FactoryInstalledPots:
if (IS_TARANIS_X9(board))
return 2;
else
return getCapability(board, Pots);
case Sliders:
if (IS_HORUS_X12S(board) || IS_TARANIS_X9E(board))
return 4;
else if (IS_TARANIS_X9D(board) || IS_HORUS_X10(board))
return 2;
else
return 0;
case MouseAnalogs:
if (IS_HORUS(board))
return 2;
else
return 0;
case GyroAnalogs:
if (IS_TARANIS_XLITES(board))
return 2;
else
return 0;
case MaxAnalogs:
return getCapability(board, Board::Sticks) + getCapability(board, Board::Pots) + getCapability(board, Board::Sliders) + getCapability(board, Board::MouseAnalogs) + getCapability(board, Board::GyroAnalogs);
case MultiposPots:
return IS_HORUS_OR_TARANIS(board) ? getCapability(board, Board::Pots) : 0;
case MultiposPotsPositions:
return IS_HORUS_OR_TARANIS(board) ? 6 : 0;
case Switches:
if (IS_TARANIS_X9E(board))
return 18;
else if (IS_TARANIS_X9LITE(board))
return 5;
else if (IS_TARANIS_X7(board))
return 8;
else if (IS_JUMPER_T12(board))
return 6;
else if (IS_TARANIS_XLITE(board))
return 6;
else if (board == Board::BOARD_TARANIS_X9DP_2019)
return 9;
else if (IS_TARANIS(board))
return 8;
else if (IS_HORUS(board))
return 10;
else
return 7;
case FactoryInstalledSwitches:
if (IS_TARANIS_X9E(board))
return 8;
if (IS_HORUS_X12S(board))
return 8;
else
return getCapability(board, Switches);
case SwitchPositions:
if (IS_HORUS_OR_TARANIS(board))
return getCapability(board, Switches) * 3;
else
return 9;
case NumTrims:
if (IS_HORUS(board))
return 6;
else
return 4;
case NumTrimSwitches:
return getCapability(board, NumTrims) * 2;
}
return 0;
}
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 tr("Unknown");
}
QString Boards::getAnalogInputName(Board::Type board, int index)
{
if (index < 0)
return CPN_STR_UNKNOWN_ITEM;
if (index < getBoardCapability(board, Board::Sticks)) {
const QString sticks[] = {
tr("Rud"),
tr("Ele"),
tr("Thr"),
tr("Ail")
};
return sticks[index];
}
index -= getCapability(board, Board::Sticks);
if (IS_9X(board) || IS_2560(board) || IS_SKY9X(board)) {
const QString pots[] = {
"P1",
"P2",
"P3"
};
if (index < DIM(pots))
return pots[index];
}
else if (IS_TARANIS_X9E(board)) {
const QString pots[] = {
"F1",
"F2",
"F3",
"F4",
"S1",
"S2",
"LS",
"RS"
};
if (index < DIM(pots))
return pots[index];
}
else if (IS_TARANIS_XLITE(board)) {
const QString pots[] = {
"S1",
"S2",
"GyrX",
"GyrY"
};
if (index < DIM(pots))
return pots[index];
}
else if (IS_TARANIS(board)) {
const QString pots[] = {
"S1",
"S2",
"S3",
"LS",
"RS"
};
if (index < DIM(pots))
return pots[index];
}
else if (IS_HORUS_X12S(board)) {
const QString pots[] = {
"S1",
"6P",
"S2",
"S3",
"S4",
"LS",
"RS",
"JSx",
"JSy"
};
if (index < DIM(pots))
return pots[index];
}
else if (IS_HORUS_X10(board)) {
const QString pots[] = {
"S1",
"6P",
"S2",
"EX1",
"EX2",
"LS",
"RS"
};
if (index < DIM(pots))
return pots[index];
}
return CPN_STR_UNKNOWN_ITEM;
}
bool Boards::isBoardCompatible(Type board1, Type board2)
{
return (getFourCC(board1) == getFourCC(board2));
}
QString Boards::getBoardName(Board::Type board)
{
switch (board) {
case BOARD_9X_M64:
return "9X";
case BOARD_9X_M128:
return "9X128";
case BOARD_GRUVIN9X:
return "Gruvin9x";
case BOARD_MEGA2560:
return "MEGA2560";
case BOARD_TARANIS_X7:
return "Taranis X7/X7S";
case BOARD_JUMPER_T12:
return "Jumper T12";
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 Express";
default:
return tr("Unknown");
}
}
Reference in a new issue View git blame Copy permalink