chore(cpn): remove binary file format models and settings support (#5653)

This commit is contained in:
Neil Horne
2024-11-22 10:27:19 +10:00
committed by GitHub
parent d94bc3321c
commit ebb5d39a14
37 changed files with 101 additions and 9548 deletions
@@ -20,8 +20,6 @@
*/
#include "opentxinterface.h"
#include "opentxeeprom.h"
#include "rlefile.h"
#include "appdata.h"
#include "constants.h"
@@ -42,463 +40,6 @@
using namespace Board;
QList<OpenTxEepromInterface *> opentxEEpromInterfaces;
OpenTxEepromInterface::OpenTxEepromInterface(OpenTxFirmware * firmware):
EEPROMInterface(firmware->getBoard()),
efile(new RleFile()),
firmware(firmware)
{
}
OpenTxEepromInterface::~OpenTxEepromInterface()
{
delete efile;
}
const char * OpenTxEepromInterface::getName()
{
switch (board) {
case BOARD_JUMPER_T12:
return "EdgeTX for Jumper T12";
case BOARD_JUMPER_TLITE:
return "EdgeTX for Jumper T-Lite";
case BOARD_JUMPER_TLITE_F4:
return "EdgeTX for Jumper T-Lite (F4 MCU)";
case BOARD_JUMPER_TPRO:
return "EdgeTX for Jumper T-Pro";
case BOARD_JUMPER_TPROV2:
return "EdgeTX for Jumper T-Pro V2";
case BOARD_JUMPER_TPROS:
return "EdgeTX for Jumper T-Pro S";
case BOARD_JUMPER_BUMBLEBEE:
return "EdgeTX for Jumper Bumblebee";
case BOARD_JUMPER_T12MAX:
return "EdgeTX for Jumper T12 MAX";
case BOARD_JUMPER_T14:
return "EdgeTX for Jumper T14";
case BOARD_JUMPER_T15:
return "EdgeTX for Jumper T15";
case BOARD_JUMPER_T16:
return "EdgeTX for Jumper T16";
case BOARD_JUMPER_T18:
return "EdgeTX for Jumper T18";
case BOARD_JUMPER_T20:
return "EdgeTX for Jumper T20";
case BOARD_JUMPER_T20V2:
return "EdgeTX for Jumper T20 V2";
case BOARD_RADIOMASTER_TX16S:
return "EdgeTX for Radiomaster TX16S";
case BOARD_RADIOMASTER_TX12:
return "EdgeTX for Radiomaster TX12";
case BOARD_RADIOMASTER_TX12_MK2:
return "EdgeTX for Radiomaster TX12 Mark II";
case BOARD_RADIOMASTER_ZORRO:
return "EdgeTX for Radiomaster Zorro";
case BOARD_RADIOMASTER_BOXER:
return "EdgeTX for Radiomaster Boxer";
case BOARD_RADIOMASTER_POCKET:
return "EdgeTX for Radiomaster Pocket";
case BOARD_RADIOMASTER_T8:
return "EdgeTX for Radiomaster T8";
case BOARD_TARANIS_X9D:
return "EdgeTX for FrSky Taranis X9D";
case BOARD_TARANIS_X9DP:
return "EdgeTX for FrSky Taranis X9D+";
case BOARD_TARANIS_X9DP_2019:
return "EdgeTX for FrSky Taranis X9D+ 2019";
case BOARD_TARANIS_X9E:
return "EdgeTX for FrSky Taranis X9E";
case BOARD_TARANIS_X7:
return "EdgeTX for FrSky Taranis X7";
case BOARD_TARANIS_X7_ACCESS:
return "EdgeTX for FrSky Taranis X7 Access";
case BOARD_TARANIS_X9LITES:
return "EdgeTX for FrSky Taranis X9-Lite S";
case BOARD_TARANIS_X9LITE:
return "EdgeTX for FrSky Taranis X9-Lite";
case BOARD_TARANIS_XLITE:
return "EdgeTX for FrSky Taranis X-Lite";
case BOARD_TARANIS_XLITES:
return "EdgeTX for FrSky Taranis X-Lite S/Pro";
case BOARD_SKY9X:
return "EdgeTX for Sky9x board / 9X";
case BOARD_9XRPRO:
return "EdgeTX for 9XR-PRO";
case BOARD_AR9X:
return "EdgeTX for ar9x board / 9X";
case BOARD_HORUS_X12S:
return "EdgeTX for FrSky Horus";
case BOARD_X10:
return "EdgeTX for FrSky X10";
case BOARD_X10_EXPRESS:
return "EdgeTX for FrSky X10 Express";
case BOARD_FLYSKY_NV14:
return "EdgeTX for FlySky NV14";
case BOARD_FLYSKY_EL18:
return "EdgeTX for FlySky EL18";
case BOARD_FLYSKY_PL18:
return "EdgeTX for FlySky PL18";
case BOARD_BETAFPV_LR3PRO:
return "EdgeTx for BETAFPV LR3PRO";
case BOARD_IFLIGHT_COMMANDO8:
return "EdgeTX for iFlight Commando 8";
case BOARD_FATFISH_F16:
return "EdgeTX for Fatfish F16";
case BOARD_HELLORADIOSKY_V16:
return "EdgeTX for HelloRadioSky V16";
default:
return "Board is unknown to EdgeTX";
}
}
bool OpenTxEepromInterface::loadRadioSettingsFromRLE(GeneralSettings & settings, RleFile * rleFile, uint8_t version)
{
// Companion loads the current profile firmware and associated board hardware definition ONLY!!!!
// For each OpenTxEepromInterface create a firmware variant to force the associated base firmware board hardware definition to be loaded.
// Note: The base firmware instance does not do load its hardware definition to save unnecessary processing.
// To create the variant take the base id and append the language from the current radio profile.
Firmware *fw = Firmware::getFirmwareForId(firmware->getId().append("-%1").arg(g.currentProfile().fwType().split('-').last()));
if (!fw) {
qWarning() << " error unable to create firmware variant";
return false;
}
QByteArray data(sizeof(settings), 0); // GeneralSettings should be always bigger than the EEPROM struct
OpenTxGeneralData open9xSettings(settings, board, version);
efile->openRd(FILE_GENERAL);
int size = rleFile->readRlc2((uint8_t *)data.data(), data.size());
if (size) {
open9xSettings.Import(data);
return checkVariant(settings.version, settings.variant);
}
else {
qWarning() << " error when loading general settings";
return false;
}
}
bool OpenTxEepromInterface::loadModelFromRLE(ModelData & model, RleFile * rleFile, unsigned int index, uint8_t version, uint32_t variant)
{
QByteArray data(sizeof(model), 0); // ModelData should be always bigger than the EEPROM struct
rleFile->openRd(FILE_MODEL(index));
int size = rleFile->readRlc2((uint8_t *)data.data(), data.size());
if (size) {
if (loadFromByteArray<ModelData, OpenTxModelData>(model, data, version, variant)) {
model.used = true;
}
}
else {
model.clear();
}
return true;
}
template <class T, class M>
bool OpenTxEepromInterface::saveToByteArray(const T & src, QByteArray & data, uint8_t version)
{
if (version == 0) {
version = getLastDataVersion(getBoard());
}
QByteArray raw;
T srcCopy(src); // work on a copy of radio data, because Export() will modify it!
M manager(srcCopy, board, version, 0);
// manager.dump();
manager.Export(raw);
data.resize(8);
*((uint32_t*)&data.data()[0]) = Boards::getFourCC(board);
data[4] = version;
data[5] = 'M';
*((uint16_t*)&data.data()[6]) = raw.size();
data.append(raw);
return true;
}
template <class T, class M>
bool OpenTxEepromInterface::loadFromByteArray(T & dest, const QByteArray & data, uint8_t version, uint32_t variant)
{
// Companion loads the current profile firmware and associated board hardware definition ONLY!!!!
// For each OpenTxEepromInterface create a firmware variant to force the associated base firmware board hardware definition to be loaded.
// Note: The base firmware instance does not do load its hardware definition to save unnecessary processing.
// To create the variant take the base id and append the language from the current radio profile.
Firmware *fw = Firmware::getFirmwareForId(firmware->getId().append("-%1").arg(g.currentProfile().fwType().split('-').last()));
if (!fw) {
qWarning() << " error unable to create firmware variant";
return false;
}
M manager(dest, board, version, variant);
if (manager.Import(data) != 0) {
return false;
}
// manager.dump(); // Dumps the structure so that it's easy to check with firmware datastructs.h
return true;
}
template <class T, class M>
bool OpenTxEepromInterface::loadFromByteArray(T & dest, const QByteArray & data)
{
uint32_t fourcc = *((uint32_t*)&data.data()[0]);
if (Boards::getFourCC(board) != fourcc) {
if (IS_FAMILY_HORUS_OR_T16(board) && fourcc == 0x3178396F) {
qDebug() << QString("%1: Deprecated fourcc used %2 vs %3").arg(getName()).arg(fourcc).arg(Boards::getFourCC(board));
}
else {
qDebug() << QString("%1: Wrong fourcc %2 vs %3").arg(getName()).arg(fourcc).arg(Boards::getFourCC(board));
return false;
}
}
if (Boards::getFourCC(board) == Boards::getFourCC(getCurrentBoard()) &&
board != getCurrentFirmware()->getBoard()) {
qDebug() << QString("%1: Fourcc not unique and does not match profile board: %2").arg(getName()).arg(Boards::getBoardName(getCurrentBoard()));
return false;
}
qDebug() << QString("%1: OK").arg(getName());
uint8_t version = data[4];
QByteArray raw = data.right(data.size() - 8);
return loadFromByteArray<T, M>(dest, raw, version);
}
unsigned long OpenTxEepromInterface::load(RadioData &radioData, const uint8_t * eeprom, int size)
{
QDebug dbg = qDebug();
dbg.setAutoInsertSpaces(false);
dbg << "trying " << getName() << " import...";
std::bitset<NUM_ERRORS> errors;
if (size != Boards::getEEpromSize(board)) {
if (size == 4096) {
int notnull = false;
for (int i = 2048; i < 4096; i++) {
if (eeprom[i] != 255) {
notnull = true;
}
}
if (notnull) {
dbg << " wrong size (" << size << ")";
errors.set(WRONG_SIZE);
return errors.to_ulong();
}
else {
errors.set(HAS_WARNINGS);
errors.set(WARNING_WRONG_FIRMWARE);
size = 2048;
}
}
else {
dbg << " wrong size (" << size << "/" << Boards::getEEpromSize(board) << ")";
errors.set(WRONG_SIZE);
return errors.to_ulong();
}
}
if (!efile->EeFsOpen((uint8_t *) eeprom, size, board)) {
dbg << " wrong file system";
errors.set(WRONG_FILE_SYSTEM);
return errors.to_ulong();
}
efile->openRd(FILE_GENERAL);
uint8_t version;
if (efile->readRlc2(&version, 1) != 1) {
dbg << " no";
errors.set(UNKNOWN_ERROR);
return errors.to_ulong();
}
dbg << " version " << (unsigned int) version;
EepromLoadErrors version_error = checkVersion(version);
if (version_error == OLD_VERSION) {
errors.set(version_error);
errors.set(HAS_WARNINGS);
}
else if (version_error == NOT_OPENTX) {
dbg << " not OpenTX";
errors.set(version_error);
return errors.to_ulong();
}
if (!loadRadioSettingsFromRLE(radioData.generalSettings, efile, version)) {
dbg << " ko";
errors.set(UNKNOWN_ERROR);
return errors.to_ulong();
}
dbg << " variant " << radioData.generalSettings.variant;
if (getCurrentFirmware()->getCapability(Models) == 0) {
radioData.models.resize(firmware->getCapability(Models));
}
for (int i = 0; i < firmware->getCapability(Models); i++) {
if (i < (int)radioData.models.size() && !loadModelFromRLE(radioData.models[i], efile, i, version, radioData.generalSettings.variant)) {
dbg << " ko";
errors.set(UNKNOWN_ERROR);
if (getCurrentFirmware()->getCapability(Models) == 0) {
radioData.models.resize(i);
}
return errors.to_ulong();
}
}
dbg << " ok";
errors.set(ALL_OK);
return errors.to_ulong();
}
uint8_t OpenTxEepromInterface::getLastDataVersion(Board::Type board)
{
return 220; // Note: this is the last bin format before the switch to YAML introduced in Companion version 2.6
}
void OpenTxEepromInterface::showErrors(const QString & title, const QStringList & errors)
{
QString msg;
if (errors.empty()) {
msg = tr("Unknown error");
}
else {
int noErrorsToDisplay = std::min((int)errors.size(), 10);
for (int n = 0; n < noErrorsToDisplay; n++) {
msg += " -" + errors.at(n) + "\n";
}
if (noErrorsToDisplay < errors.size()) {
msg += tr(" ... plus %1 errors").arg(errors.size() - noErrorsToDisplay) + "\n" + msg;
}
}
QMessageBox::warning(NULL,
CPN_STR_TTL_ERROR,
title + "\n" + msg);
}
int OpenTxEepromInterface::save(uint8_t * eeprom, const RadioData & radioData, uint8_t version, uint32_t variant)
{
// TODO QMessageBox::warning should not be called here
if (version == 0) {
version = getLastDataVersion(board);
}
int size = Boards::getEEpromSize(board);
efile->EeFsCreate(eeprom, size, board, version);
if (IS_TARANIS_X9E(board)) {
variant |= TARANIS_X9E_VARIANT;
}
else if (IS_TARANIS_X9LITES(board)) {
variant |= TARANIS_X9LITES_VARIANT;
}
else if (IS_TARANIS_X9LITE(board)) {
variant |= TARANIS_X9LITE_VARIANT;
}
else if (IS_TARANIS_X7_ACCESS(board)) {
variant |= TARANIS_X7_VARIANT;
}
else if (IS_TARANIS_X7(board)) {
variant |= TARANIS_X7_VARIANT;
}
else if (IS_TARANIS_XLITES(board)) {
variant |= TARANIS_XLITES_VARIANT;
}
else if (IS_TARANIS_XLITE(board)) {
variant |= TARANIS_XLITE_VARIANT;
}
else if (IS_JUMPER_T12(board)) {
variant |= JUMPER_T12_VARIANT;
}
else if (IS_JUMPER_TLITE(board)) {
variant |= JUMPER_TLITE_VARIANT;
}
else if (IS_JUMPER_TPRO(board)) {
variant |= JUMPER_TPRO_VARIANT;
}
else if (IS_RADIOMASTER_TX12(board)) {
variant |= RADIOMASTER_TX12_VARIANT;
}
else if (IS_RADIOMASTER_TX12_MK2(board)) {
variant |= RADIOMASTER_TX12_MK2_VARIANT;
}
else if (IS_RADIOMASTER_ZORRO(board)) {
variant |= RADIOMASTER_ZORRO_VARIANT;
}
else if (IS_RADIOMASTER_T8(board)) {
variant |= RADIOMASTER_T8_VARIANT;
}
OpenTxGeneralData generator((GeneralSettings &)radioData.generalSettings, board, version, variant);
// generator.dump();
QByteArray data;
generator.Export(data);
int sz = efile->writeRlc2(FILE_GENERAL, FILE_TYP_GENERAL, (const uint8_t *)data.constData(), data.size());
if (sz == 0 || generator.errors().count() > 0) {
showErrors(tr("Cannot write radio settings"), generator.errors());
return 0;
}
for (int i = 0; i < getCurrentFirmware()->getCapability(Models); i++) {
if (i < (int)radioData.models.size() && !radioData.models[i].isEmpty()) {
OpenTxModelData generator((ModelData &)radioData.models[i], board, version, variant);
// generator.dump();
QByteArray data;
generator.Export(data);
int sz = efile->writeRlc2(FILE_MODEL(i), FILE_TYP_MODEL, (const uint8_t *)data.constData(), data.size());
if (sz == 0 || generator.errors().count() > 0) {
showErrors(tr("Cannot write model %1").arg(radioData.models[i].name), generator.errors());
return 0;
}
}
}
return size;
}
int OpenTxEepromInterface::getSize(const ModelData &model)
{
if (IS_SKY9X(board))
return 0;
if (model.isEmpty())
return 0;
QByteArray tmp(Boards::getEEpromSize(Board::BOARD_UNKNOWN), 0);
efile->EeFsCreate((uint8_t *) tmp.data(), Boards::getEEpromSize(Board::BOARD_UNKNOWN), board, 255/*version max*/);
ModelData srcCopy(model); // work on a copy of model data, because Export() may modify it!
OpenTxModelData open9xModel(srcCopy, board, 255/*version max*/, getCurrentFirmware()->getVariantNumber());
QByteArray eeprom;
open9xModel.Export(eeprom);
int sz = efile->writeRlc2(0, FILE_TYP_MODEL, (const uint8_t *) eeprom.constData(), eeprom.size());
if (sz != eeprom.size()) {
return -1;
}
return efile->size(0);
}
int OpenTxEepromInterface::getSize(const GeneralSettings &settings)
{
if (IS_SKY9X(board))
return 0;
QByteArray tmp(Boards::getEEpromSize(Board::BOARD_UNKNOWN), 0);
efile->EeFsCreate((uint8_t *) tmp.data(), Boards::getEEpromSize(Board::BOARD_UNKNOWN), board, 255);
GeneralSettings srcCopy(settings); // work on a copy of settings data, because Export() may modify it!
OpenTxGeneralData open9xGeneral(srcCopy, board, 255, getCurrentFirmware()->getVariantNumber());
// open9xGeneral.dump();
QByteArray eeprom;
open9xGeneral.Export(eeprom);
int sz = efile->writeRlc2(0, FILE_TYP_GENERAL, (const uint8_t *) eeprom.constData(), eeprom.size());
if (sz != eeprom.size()) {
return -1;
}
return efile->size(0);
}
Firmware * OpenTxFirmware::getFirmwareVariant(const QString &id)
{
if (id == getId()) {
@@ -736,33 +277,6 @@ int OpenTxFirmware::getCapability(::Capability capability)
return true;
case HasMahPersistent:
return true;
case SimulatorVariant:
if (IS_TARANIS_X9E(board))
return TARANIS_X9E_VARIANT;
else if (IS_TARANIS_X9LITES(board))
return TARANIS_X9LITES_VARIANT;
else if (IS_TARANIS_X9LITE(board))
return TARANIS_X9LITE_VARIANT;
else if (IS_TARANIS_X7(board))
return TARANIS_X7_VARIANT;
else if (IS_TARANIS_XLITES(board))
return TARANIS_XLITES_VARIANT;
else if (IS_TARANIS_XLITE(board))
return TARANIS_XLITE_VARIANT;
else if (IS_BETAFPV_LR3PRO(board))
return BETAFPV_LR3PRO_VARIANT;
else if (IS_IFLIGHT_COMMANDO8(board))
return IFLIGHT_COMMANDO8_VARIANT;
else if (IS_JUMPER_T12(board))
return JUMPER_T12_VARIANT;
else if (IS_JUMPER_TLITE(board))
return JUMPER_TLITE_VARIANT;
else if (IS_RADIOMASTER_TX12(board))
return RADIOMASTER_TX12_VARIANT;
else if (IS_RADIOMASTER_T8(board))
return RADIOMASTER_T8_VARIANT;
else
return 0;
case MavlinkTelemetry:
return id.contains("mavlink") ? 1 : 0;
case SportTelemetry:
@@ -873,273 +387,6 @@ size_t getSizeA(T (&)[SIZE])
return SIZE;
}
EepromLoadErrors OpenTxEepromInterface::checkVersion(unsigned int version)
{
switch (version) {
case 201:
// first version
case 202:
// channel order is now always RUD - ELE - THR - AIL
// changes in timers
// ppmFrameLength added
// thrTraceSrc added
case 203:
// mixers changed (for the trims use for change the offset of a mix)
// telemetry offset raised to -127 +127
// function switches now have a param on 4 bits
case 204:
// telemetry changes (bars)
case 205:
// mixer changes (differential, negative curves)...
// case 206:
case 207:
// V4: Rotary Encoders position in FlightModes
case 208:
// Trim value in 16bits
// FrSky A1/A2 offset on 12bits
// ARM: More Mixers / Expos / CSW / FSW / CHNOUT
case 209:
// Add TrmR, TrmE, TrmT, TrmA as Mix sources
// Trims are now OFF / ON / Rud / Ele / Thr / Ail
case 210:
// Add names in Mixes / Expos
// Add a new telemetry screen
// Add support for Play Track <filename>
case 211:
// Curves big change
case 212:
// Big changes in mixers / limitse
case 213:
// GVARS / Variants introduction
case 214:
// Massive EEPROM change!
case 215:
// M128 revert because too much RAM used!
case 216:
// A lot of things (first github release)
case 217:
// 3 logical switches removed on M128 / gruvin9x boards
return OLD_VERSION;
case 218:
// ACCESS
// switches add for X7/X10/X12S
// 60 sensors for X12
return OLD_VERSION;
case 219:
// 60 (Horus / X9) / 40 (others) telemetry sensors instead of 32
// ALL: ReceiverData array added
// ALL: registrationId added
// ALL: failsafeChannels moved from ModuleData to ModelData
// ALL: ModuleData / TrainerModuleData modified
// PCBX9 : 6 chars for expos / mixes names instead of 8
// on X7: 2 additional switches
// on X9D / X9D+: 1 additional switch
// on xlite : 2 more storage switches
// on X10: 2 additional pots => 12 multipos switches
return OLD_VERSION;
case 220:
// Refer radio/src/storage/conversions/conversions_219_220.cpp
// ALL: TimerData split mode into separate mode and switch and change modes
// ALL: TimerData countdownStart invert value
// ALL: convert more fields from zchar to normal string
// COLORLCD: change CustomScreenData and TopBarPersistentData
return OLD_VERSION;
case 221:
// ALL: YAML storage
// X10PCB: add pots EXT3 and EXT4 (conversion required as shifts slider settings in multiple fields)
// RM TX16S: add Flysky gimbals firmware build option and repurpose EXT3 and EXT4 if selected
// ??: add source TX GPS
break;
default:
return NOT_OPENTX;
}
return ALL_OK;
}
bool OpenTxEepromInterface::checkVariant(unsigned int version, unsigned int variant)
{
bool variantError = false;
if (IS_TARANIS_X9E(board)) {
if (variant != TARANIS_X9E_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS_X7(board)) {
if (variant != TARANIS_X7_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS_XLITES(board)) {
if (variant != TARANIS_XLITES_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS_XLITE(board)) {
if (variant != TARANIS_XLITE_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS_X9LITES(board)) {
if (variant != TARANIS_X9LITES_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS_X9LITE(board)) {
if (variant != TARANIS_X9LITE_VARIANT) {
variantError = true;
}
}
else if (IS_JUMPER_T12(board)) {
if (variant != JUMPER_T12_VARIANT) {
variantError = true;
}
}
else if (IS_JUMPER_TLITE(board)) {
if (variant != JUMPER_TLITE_VARIANT) {
variantError = true;
}
}
else if (IS_JUMPER_TPRO(board)) {
if (variant != JUMPER_TPRO_VARIANT) {
variantError = true;
}
}
else if (IS_RADIOMASTER_TX12(board)) {
if (variant != RADIOMASTER_TX12_VARIANT) {
variantError = true;
}
}
else if (IS_RADIOMASTER_TX12_MK2(board)) {
if (variant != RADIOMASTER_TX12_MK2_VARIANT) {
variantError = true;
}
}
else if (IS_RADIOMASTER_ZORRO(board)) {
if (variant != RADIOMASTER_ZORRO_VARIANT) {
variantError = true;
}
}
else if (IS_RADIOMASTER_T8(board)) {
if (variant != RADIOMASTER_T8_VARIANT) {
variantError = true;
}
}
else if (IS_TARANIS(board)) {
if (variant != 0) {
variantError = true;
}
}
if (variantError) {
qWarning() << " wrong variant (" << variant << ")";
return false;
}
return true;
}
bool
OpenTxEepromInterface::loadModelFromBackup(ModelData & model, const uint8_t * data, unsigned int size, uint8_t version, uint32_t variant)
{
QByteArray backupData((char *) data, size);
QByteArray modelData;
if (IS_SKY9X(board)) {
modelData = QByteArray((char *) data, size);
}
else {
importRlc(modelData, backupData);
}
if (modelData.size()) {
if (loadFromByteArray<ModelData, OpenTxModelData>(model, modelData, version, variant)) {
model.used = true;
return true;
}
}
model.clear();
return false;
}
unsigned long OpenTxEepromInterface::loadBackup(RadioData &radioData, const uint8_t * eeprom, int esize, int index)
{
std::bitset<NUM_ERRORS> errors;
QDebug dbg = qDebug();
dbg.setAutoInsertSpaces(false);
dbg << "trying " << getName() << " backup import...";
if (esize < 8 || memcmp(eeprom, "o9x", 3) != 0) {
dbg << " no\n";
errors.set(WRONG_SIZE);
return errors.to_ulong();
}
Type backupBoard = (Type) -1;
switch (eeprom[3]) {
case 0x33:
backupBoard = BOARD_TARANIS_X9D;
break;
case 0x32:
backupBoard = BOARD_SKY9X;
break;
default:
dbg << " unknown board";
errors.set(UNKNOWN_BOARD);
return errors.to_ulong();
}
if (backupBoard != board) {
dbg << " not right board";
errors.set(WRONG_BOARD);
return errors.to_ulong();
}
uint8_t version = eeprom[4];
uint8_t bcktype = eeprom[5];
uint16_t size = ((uint16_t) eeprom[7] << 8) + eeprom[6];
uint16_t variant = ((uint16_t) eeprom[9] << 8) + eeprom[8];
dbg << " version " << (unsigned int) version << " ";
EepromLoadErrors version_error = checkVersion(version);
if (version_error == OLD_VERSION) {
errors.set(version_error);
errors.set(HAS_WARNINGS);
}
else if (version_error == NOT_OPENTX) {
dbg << " not open9x";
errors.set(version_error);
return errors.to_ulong();
}
if (size > esize - 8) {
dbg << " wrong size";
errors.set(WRONG_SIZE);
return errors.to_ulong();
}
if (bcktype == 'M') {
if (!loadModelFromBackup(radioData.models[index], &eeprom[8], size, version, variant)) {
dbg << " ko";
errors.set(UNKNOWN_ERROR);
return errors.to_ulong();
}
}
else {
dbg << " backup type not supported";
errors.set(BACKUP_NOT_SUPPORTED);
return errors.to_ulong();
}
dbg << " ok";
errors.set(ALL_OK);
return errors.to_ulong();
}
QString OpenTxFirmware::getReleaseNotesUrl()
{
return QString("%1/downloads").arg(EDGETX_HOME_PAGE_URL);
@@ -1150,10 +397,6 @@ QString OpenTxFirmware::getReleaseNotesUrl()
void registerOpenTxFirmware(OpenTxFirmware * firmware, bool deprecated = false)
{
OpenTxEepromInterface * eepromInterface = new OpenTxEepromInterface(firmware);
firmware->setEEpromInterface(eepromInterface);
opentxEEpromInterfaces.push_back(eepromInterface);
eepromInterfaces.push_back(eepromInterface);
if (!deprecated)
Firmware::addRegisteredFirmware(firmware);
}
@@ -1215,24 +458,6 @@ void addOpenTxTaranisOptions(OpenTxFirmware * firmware)
addOpenTxFontOptions(firmware);
}
void addOpenTxArm9xOptions(OpenTxFirmware * firmware, bool dblkeys = true)
{
addOpenTxCommonOptions(firmware);
firmware->addOption("heli", Firmware::tr("Enable HELI menu and cyclic mix support"));
firmware->addOption("gvars", Firmware::tr("Global variables"), GVARS_VARIANT);
firmware->addOption("potscroll", Firmware::tr("Pots use in menus navigation"));
firmware->addOption("autosource", Firmware::tr("In model setup menus automatically set source by moving the control"));
firmware->addOption("autoswitch", Firmware::tr("In model setup menus automatically set switch by moving the control"));
firmware->addOption("nographics", Firmware::tr("No graphical check boxes and sliders"));
firmware->addOption("battgraph", Firmware::tr("Battery graph"));
firmware->addOption("nobold", Firmware::tr("Don't use bold font for highlighting active items"));
//firmware->addOption("bluetooth", Firmware::tr("Bluetooth interface"));
if (dblkeys)
firmware->addOption("dblkeys", Firmware::tr("Enable resetting values by pressing up and down at the same time"));
addOpenTxFontOptions(firmware);
addOpenTxRfOptions(firmware, FLEX);
}
// TODO: refactoring OpenTxFirmware constructor - need to check if used elsewhere and how
#define FIRMWAREID(flavour) std::string(FIRMWARE_ID_PREFIX).append(flavour).c_str()
@@ -1585,48 +810,4 @@ void unregisterOpenTxFirmwares()
foreach (Firmware * f, Firmware::getRegisteredFirmwares()) {
delete f;
}
unregisterEEpromInterfaces();
}
template <class T, class M>
OpenTxEepromInterface * loadFromByteArray(T & dest, const QByteArray & data)
{
foreach(OpenTxEepromInterface * eepromInterface, opentxEEpromInterfaces) {
if (eepromInterface->loadFromByteArray<T, M>(dest, data)) {
return eepromInterface;
}
}
return NULL;
}
template <class T, class M>
bool saveToByteArray(const T & dest, QByteArray & data)
{
Board::Type board = getCurrentBoard();
foreach(OpenTxEepromInterface * eepromInterface, opentxEEpromInterfaces) {
if (eepromInterface->getBoard() == board) {
return eepromInterface->saveToByteArray<T, M>(dest, data);
}
}
return false;
}
OpenTxEepromInterface * loadModelFromByteArray(ModelData & model, const QByteArray & data)
{
return loadFromByteArray<ModelData, OpenTxModelData>(model, data);
}
OpenTxEepromInterface * loadRadioSettingsFromByteArray(GeneralSettings & settings, const QByteArray & data)
{
return loadFromByteArray<GeneralSettings, OpenTxGeneralData>(settings, data);
}
bool writeModelToByteArray(const ModelData & model, QByteArray & data)
{
return saveToByteArray<ModelData, OpenTxModelData>(model, data);
}
bool writeRadioSettingsToByteArray(const GeneralSettings & settings, QByteArray & data)
{
return saveToByteArray<GeneralSettings, OpenTxGeneralData>(settings, data);
}