piotr/edgetx-gx12
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
efcfdf171d360e7604dbac0fe6e574390e369d8c
edgetx-gx12/companion/src/simulation/simulatordialog.cpp
T

1124 lines
36 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 "simulatordialog.h"
#include "ui_simulatordialog.h"
#include "appdata.h"
#include "debugoutput.h"
#include "radiofaderwidget.h"
#include "radioknobwidget.h"
#include "radioswitchwidget.h"
#include "radiouiaction.h"
#include "sdcard.h"
#include "simulateduiwidget.h"
#include "simulatorinterface.h"
#include "storage.h"
#include "telemetrysimu.h"
#include "trainersimu.h"
#include "virtualjoystickwidget.h"
#ifdef JOYSTICKS
#include "joystick.h"
#include "joystickdialog.h"
#endif
#include <QDebug>
#include <QFile>
#include <iostream>
SimulatorDialog * traceCallbackInstance = 0;
void traceCb(const char * text)
{
// divert C callback into simulator instance
if (traceCallbackInstance) {
traceCallbackInstance->traceCallback(text);
}
}
SimulatorDialog::SimulatorDialog(QWidget * parent, SimulatorInterface *simulator, quint8 flags):
QDialog(parent),
ui(new Ui::SimulatorDialog),
simulator(simulator),
firmware(getCurrentFirmware()),
radioSettings(GeneralSettings()),
timer(NULL),
radioUiWidget(NULL),
vJoyLeft(NULL),
vJoyRight(NULL),
TelemetrySimu(NULL),
TrainerSimu(NULL),
DebugOut(NULL),
m_board(getCurrentBoard()),
flags(flags),
radioProfileId(g.id()),
lastPhase(-1),
buttonPressed(0),
trimPressed(TRIM_NONE),
startupFromFile(false),
deleteTempRadioData(false),
saveTempRadioData(false),
middleButtonPressed(false)
{
setWindowFlags(Qt::Window);
// install simulator TRACE hook
traceCallbackInstance = this;
simulator->installTraceHook(traceCb);
// defaults
setRadioProfileId(radioProfileId);
setSdPath(g.profile[radioProfileId].sdPath());
setupUi();
}
SimulatorDialog::~SimulatorDialog()
{
traceCallbackInstance = 0;
delete timer;
delete simulator;
}
/*
* Public slots/setters
*/
void SimulatorDialog::setRadioProfileId(int value)
{
radioProfileId = value;
if (simulator)
simulator->setVolumeGain(g.profile[radioProfileId].volumeGain());
}
void SimulatorDialog::setSdPath(const QString & sdPath)
{
setPaths(sdPath, radioDataPath);
}
void SimulatorDialog::setDataPath(const QString & dataPath)
{
setPaths(sdCardPath, dataPath);
}
void SimulatorDialog::setPaths(const QString & sdPath, const QString & dataPath)
{
sdCardPath = sdPath;
radioDataPath = dataPath;
if (simulator)
simulator->setSdPath(sdPath, dataPath);
}
void SimulatorDialog::setRadioSettings(const GeneralSettings settings)
{
radioSettings = settings;
}
/*
* This function can accept no parameters, a file name (QString is a QBA), or a data array. It will attempt to load radio settings data from one of
* several sources into a RadioData object, parse the data, and then pass it on as appropriate to the SimulatorInterface in start().
* If given no/blank <eeprom>, and setDataPath() was already called, then it will check that directory for "Horus-style" data files.
* If given a file name, set the <fromFile> parameter to 'true'. This will attempt to load radio settings from said file
* and later start the simulator interface in start() using the same data.
* If <eeprom> is a byte array of data, attempts to load radio settings from there and will also start the simulator interface
* with the same data when start() is called.
* If you already have a valid RadioData structure, call setRadioData() instead.
*/
void SimulatorDialog::setStartupData(const QByteArray & dataSource, bool fromFile)
{
RadioData simuData;
quint16 ret = 1;
QString error;
// If <eeprom> is blank but we have a data path, use that for individual radio/model files.
if (dataSource.isEmpty() && !radioDataPath.isEmpty()) {
// If directory structure already exists, try to load data from there.
// FIXME : need Storage class to return formal error code, not just a boolean, because it would be better
// to avoid hard-coding paths like "RADIO" here. E.g. did it fail due to no data at all, or corrupt data, or...?
if (QDir(QString(radioDataPath).append("/RADIO")).exists()) {
SdcardFormat sdcard(radioDataPath);
if (!(ret = sdcard.load(simuData)))
error = sdcard.error();
}
}
// Supposedly we're being given a file name to use, try that out.
else if (fromFile) {
Storage store = Storage(QString(dataSource));
if ((ret = store.load(simuData))) {
if (IS_HORUS(m_board)) {
// save the data to a temp folder
if (!(ret = useTempDataPath(true, true))) // save data back to file on simulator close
error = tr("Error: Could not save data to temporary directory in '%1'").arg(QDir::tempPath());
else
ret = saveRadioData(&simuData, radioDataPath, &error);
}
else if (QString(dataSource).endsWith(".otx", Qt::CaseInsensitive)) {
// FIXME : Right now there's no way to read data back into the .otx file after simulation finishes.
setRadioData(&simuData);
return;
}
else {
startupData = dataSource; // save the file name for start()
}
}
else {
error = store.error();
}
}
// Assume a byte array of radio data was passed, load it.
else if (!dataSource.isEmpty()) {
ret = firmware->getEEpromInterface()->load(simuData, (uint8_t *)dataSource.constData(), getEEpromSize(m_board));
startupData = dataSource; // save the data for start()
}
// we're :-(
else {
ret = 0;
error = tr("Could not determine startup data source.");
}
if (!ret) {
if (error.isEmpty())
error = tr("Could not load data, possibly wrong format.");
QMessageBox::critical(this, tr("Data Load Error"), error);
return;
}
radioSettings = simuData.generalSettings;
startupFromFile = fromFile;
}
void SimulatorDialog::setRadioData(RadioData * radioData)
{
if (radioDataPath.isEmpty()) {
QByteArray eeprom(getEEpromSize(m_board), 0);
if (firmware->getEEpromInterface()->save((uint8_t *)eeprom.data(), *radioData, 0, firmware->getCapability(SimulatorVariant)) > 0)
setStartupData(eeprom, false);
}
else {
saveRadioData(radioData, radioDataPath);
radioSettings = radioData->generalSettings;
}
}
void SimulatorDialog::setOptions(SimulatorOptions & options, bool withSave)
{
setSdPath(options.sdPath);
if (options.startupDataType == SimulatorOptions::START_WITH_FOLDER && !options.dataFolder.isEmpty()) {
setDataPath(options.dataFolder);
setStartupData();
}
else if (options.startupDataType == SimulatorOptions::START_WITH_SDPATH && !options.sdPath.isEmpty()) {
setDataPath(options.sdPath);
setStartupData();
}
else if (options.startupDataType == SimulatorOptions::START_WITH_FILE && !options.dataFile.isEmpty()) {
setStartupData(options.dataFile.toLocal8Bit(), true);
}
if (withSave)
g.profile[radioProfileId].simulatorOptions(options);
}
bool SimulatorDialog::saveRadioData(RadioData * radioData, const QString & path, QString * error)
{
QString dir = path;
if (dir.isEmpty())
dir = radioDataPath;
if (radioData && !dir.isEmpty()) {
SdcardFormat sdcard(dir);
bool ret = sdcard.write(*radioData);
if (!ret && error)
*error = sdcard.error();
return ret;
}
return false;
}
bool SimulatorDialog::useTempDataPath(bool deleteOnClose, bool saveOnClose)
{
if (deleteTempRadioData)
deleteTempData();
QTemporaryDir tmpDir(QDir::tempPath() + "/otx-XXXXXX");
if (tmpDir.isValid()) {
setDataPath(tmpDir.path());
tmpDir.setAutoRemove(false);
deleteTempRadioData = deleteOnClose;
saveTempRadioData = saveOnClose;
qDebug() << __FILE__ << __LINE__ << "Created temporary settings directory" << radioDataPath
<< "with delteOnClose:" << deleteOnClose << "with saveOnClose:" << saveOnClose;
return true;
}
else {
qDebug() << __FILE__ << __LINE__ << "ERROR : Failed to create temporary settings directory" << radioDataPath;
return false;
}
}
// This will save radio data from temporary folder structure back into an .otx file, eg. for Horus.
bool SimulatorDialog::saveTempData()
{
bool ret = false;
QString error;
QString file = g.profile[radioProfileId].simulatorOptions().dataFile;
if (!saveTempRadioData || radioDataPath.isEmpty() || file.isEmpty())
return ret;
RadioData radioData;
SdcardFormat sdcard(radioDataPath);
if (!(ret = sdcard.load(radioData))) {
error = sdcard.error();
}
else {
Storage store(file);
if (!(ret = store.write(radioData)))
error = store.error();
else
qDebug() << __FILE__ << __LINE__ << "Saved radio data to file" << file;
}
if (!ret)
QMessageBox::critical(this, tr("Data Save Error"), error);
return ret;
}
void SimulatorDialog::deleteTempData()
{
if (!radioDataPath.isEmpty()) {
QDir tpath(radioDataPath);
qDebug() << __FILE__ << __LINE__ << "Deleting temporary settings directory" << tpath.absolutePath();
tpath.removeRecursively();
tpath.rmdir(radioDataPath); // for some reason this is necessary to remove the base folder
}
}
void SimulatorDialog::setUiAreaStyle(const QString & style)
{
ui->radioUiTab->setStyleSheet(style);
}
void SimulatorDialog::traceCallback(const char * text)
{
// this function is called from other threads
traceMutex.lock();
// limit the size of list
if (traceList.size() < 1000) {
traceList.append(QString(text));
}
traceMutex.unlock();
}
/*
* Startup
*/
void SimulatorDialog::start()
{
setupRadioWidgets();
setupJoysticks();
setupOutputsDisplay();
setupGVarsDisplay();
restoreRadioWidgetsState();
setTrims();
if (startupData.isEmpty())
simulator->start((const char *)0);
else if (startupFromFile)
simulator->start(startupData.constData());
else
simulator->start(startupData, (flags & SIMULATOR_FLAGS_NOTX) ? false : true);
getValues();
setupTimer();
startupData.clear(); // this is safe because simulator->start() makes copy of data/discards the file name
}
/*
* Setup
*/
void SimulatorDialog::setupUi()
{
ui->setupUi(this);
windowName = tr("Simulating Radio (%1)").arg(firmware->getName());
setWindowTitle(windowName);
switch(m_board) {
case Board::BOARD_TARANIS_X7 :
radioUiWidget = new SimulatedUIWidgetX7(simulator, this);
break;
case Board::BOARD_TARANIS_X9D :
case Board::BOARD_TARANIS_X9DP :
case Board::BOARD_TARANIS_X9E :
radioUiWidget = new SimulatedUIWidgetX9(simulator, this);
break;
case Board::BOARD_HORUS :
radioUiWidget = new SimulatedUIWidgetX12(simulator, this);
break;
default:
radioUiWidget = new SimulatedUIWidget9X(simulator, this);
break;
}
foreach (keymapHelp_t item, *radioUiWidget->getKeymapHelp()) {
keymapHelp.append(item);
}
ui->radioUiTab->layout()->addWidget(radioUiWidget);
ui->tabWidget->setTabText(0, firmware->getName());
ui->tabWidget->setFixedHeight(radioUiWidget->height() + ui->tabWidget->tabBar()->height() - 8);
vJoyLeft = new VirtualJoystickWidget(this, 'L');
ui->leftStickLayout->addWidget(vJoyLeft);
vJoyRight = new VirtualJoystickWidget(this, 'R');
ui->rightStickLayout->addWidget(vJoyRight);
ui->tabWidget->setCurrentIndex(flags & SIMULATOR_FLAGS_NOTX);
connect(vJoyLeft, SIGNAL(trimButtonPressed(int)), this, SLOT(onTrimPressed(int)));
connect(vJoyLeft, SIGNAL(trimButtonReleased()), this, SLOT(onTrimReleased()));
connect(vJoyLeft, SIGNAL(trimSliderMoved(int,int)), this, SLOT(onTrimSliderMoved(int,int)));
connect(vJoyRight, SIGNAL(trimButtonPressed(int)), this, SLOT(onTrimPressed(int)));
connect(vJoyRight, SIGNAL(trimButtonReleased()), this, SLOT(onTrimReleased()));
connect(vJoyRight, SIGNAL(trimSliderMoved(int,int)), this, SLOT(onTrimSliderMoved(int,int)));
connect(ui->btn_help, SIGNAL(released()), this, SLOT(showHelp()));
connect(ui->btn_joystickDialog, SIGNAL(released()), this, SLOT(openJoystickDialog()));
connect(ui->btn_telemSim, SIGNAL(released()), this, SLOT(openTelemetrySimulator()));
connect(ui->btn_trainerSim, SIGNAL(released()), this, SLOT(openTrainerSimulator()));
connect(ui->btn_debugConsole, SIGNAL(released()), this, SLOT(openDebugOutput()));
connect(ui->btn_luaReload, SIGNAL(released()), this, SLOT(luaReload()));
connect(ui->btn_screenshot, SIGNAL(released()), radioUiWidget, SLOT(captureScreenshot()));
// Hide some main UI buttons based on board capabilities, and add keymap help texts.
keymapHelp.append(keymapHelp_t(ui->btn_help->shortcut().toString(QKeySequence::NativeText), ui->btn_help->statusTip()));
#ifdef JOYSTICKS
keymapHelp.append(keymapHelp_t(ui->btn_joystickDialog->shortcut().toString(QKeySequence::NativeText), ui->btn_joystickDialog->statusTip()));
#else
ui->btn_joystickDialog->hide();
#endif
if (firmware->getCapability(Capability(SportTelemetry)))
keymapHelp.append(keymapHelp_t(ui->btn_telemSim->shortcut().toString(QKeySequence::NativeText), ui->btn_telemSim->statusTip()));
else
ui->btn_telemSim->hide();
keymapHelp.append(keymapHelp_t(ui->btn_trainerSim->shortcut().toString(QKeySequence::NativeText), ui->btn_trainerSim->statusTip()));
keymapHelp.append(keymapHelp_t(ui->btn_debugConsole->shortcut().toString(QKeySequence::NativeText), ui->btn_debugConsole->statusTip()));
if (!firmware->getCapability(Capability(LuaInputsPerScript))) // hackish! but using "LuaScripts" checks for id "lua" in fw.
keymapHelp.append(keymapHelp_t(ui->btn_luaReload->shortcut().toString(QKeySequence::NativeText), ui->btn_luaReload->statusTip()));
else
ui->btn_luaReload->hide();
keymapHelp.append(keymapHelp_t(ui->btn_screenshot->shortcut().toString(QKeySequence::NativeText), ui->btn_screenshot->statusTip()));
}
void SimulatorDialog::setupRadioWidgets()
{
int i, midpos, aIdx, wval;
QString wname;
Board::Type board = firmware->getBoard();
// First clear out any existing widgets.
if (switches.size()) {
foreach (RadioWidget * w, switches) {
ui->radioWidgetsHTLayout->removeWidget(w);
w->deleteLater();
}
}
if (analogs.size()) {
foreach (RadioWidget * w, analogs) {
if (w->getType() == RadioWidget::RADIO_WIDGET_KNOB)
ui->radioWidgetsHTLayout->removeWidget(w);
else
ui->VCGridLayout->removeWidget(w);
w->deleteLater();
}
}
// Now set up new widgets.
// switches
Board::SwitchInfo switchInfo;
Board::SwitchType swcfg;
// FIXME : CPN_MAX_SWITCHES == 32 but GeneralSettings::switchConfig[18] !!
for (i = 0; i < firmware->getCapability(Capability(Switches)) && i < 18 /*CPN_MAX_SWITCHES*/; ++i) {
if (radioSettings.switchConfig[i] == Board::SWITCH_NOT_AVAILABLE)
continue;
swcfg = Board::SwitchType(radioSettings.switchConfig[i]);
wval = (swcfg == Board::SWITCH_3POS ? -1 : 0);
if ((wname = QString(radioSettings.switchName[i])).isEmpty()) {
switchInfo = getSwitchInfo(board, i);
wname = QString(switchInfo.name);
}
RadioSwitchWidget * sw = new RadioSwitchWidget(swcfg, wname, wval, ui->radioWidgetsHT);
sw->setIndex(i);
ui->radioWidgetsHTLayout->addWidget(sw);
switches.append(sw);
}
midpos = (int)floorf(switches.size() / 2.0f);
aIdx = 0;
// pots in middle of switches
for (i = 0; i < firmware->getCapability(Pots) && i < CPN_MAX_POTS; ++i) {
if (!radioSettings.isPotAvailable(i))
continue;
if ((wname = QString(radioSettings.potName[i])).isEmpty())
wname = firmware->getAnalogInputName(4 + aIdx + i);
RadioKnobWidget * pot = new RadioKnobWidget(Board::PotType(radioSettings.potConfig[i]), wname, 0, ui->radioWidgetsHT);
pot->setIndex(aIdx + i);
// FIXME : total hack here -- this needs to follow the exception in radio/src/mixer.cpp:evalInputs()
if (i == 0 && IS_TARANIS(board) && !IS_TARANIS_X7(board))
pot->setInvertValue(true);
ui->radioWidgetsHTLayout->insertWidget(midpos++, pot);
analogs.append(pot);
}
aIdx += i;
// faders between sticks
int r = 0, c = 0;
for (i = 0; i < firmware->getCapability(Sliders) && i + aIdx < CPN_MAX_POTS; ++i) {
if (!radioSettings.isSliderAvailable(i))
continue;
if ((wname = QString(radioSettings.sliderName[i])).isEmpty())
wname = firmware->getAnalogInputName(4 + aIdx + i);
RadioFaderWidget * sl = new RadioFaderWidget(wname, 0, ui->radioWidgetsVC);
sl->setIndex(aIdx + i);
// FIXME : total hack here -- this needs to follow the exception in radio/src/mixer.cpp:evalInputs()
if (i == 0 && IS_TARANIS(board) && !IS_TARANIS_X7(board))
sl->setInvertValue(true);
/* 2-row option
if (!(i % 2)) {
++r;
c = 0;
} */
ui->VCGridLayout->addWidget(sl, r, c++, 1, 1);
analogs.append(sl);
}
}
void SimulatorDialog::setupOutputsDisplay()
{
// setup Outputs tab
QWidget * outputsWidget = new QWidget();
QGridLayout * gridLayout = new QGridLayout(outputsWidget);
gridLayout->setHorizontalSpacing(0);
gridLayout->setVerticalSpacing(3);
gridLayout->setContentsMargins(5, 3, 5, 3);
// logical switches area
QWidget * logicalSwitches = new QWidget(outputsWidget);
logicalSwitches->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
QGridLayout * logicalSwitchesLayout = new QGridLayout(logicalSwitches);
logicalSwitchesLayout->setHorizontalSpacing(3);
logicalSwitchesLayout->setVerticalSpacing(2);
logicalSwitchesLayout->setContentsMargins(0, 0, 0, 0);
gridLayout->addWidget(logicalSwitches, 0, 0, 1, 1);
// channels area
QScrollArea * scrollArea = new QScrollArea(outputsWidget);
QSizePolicy sp(QSizePolicy::Expanding, QSizePolicy::Preferred);
sp.setHorizontalStretch(0);
sp.setVerticalStretch(0);
scrollArea->setSizePolicy(sp);
scrollArea->setWidgetResizable(true);
QWidget * channelsWidget = new QWidget();
QGridLayout * channelsLayout = new QGridLayout(channelsWidget);
channelsLayout->setHorizontalSpacing(4);
channelsLayout->setVerticalSpacing(3);
channelsLayout->setContentsMargins(0, 0, 0, 3);
scrollArea->setWidget(channelsWidget);
gridLayout->addWidget(scrollArea, 1, 0, 1, 1);
ui->tabWidget->insertTab(1, outputsWidget, QString(tr("Outputs")));
// populate outputs
int outputs = std::min(32, firmware->getCapability(Outputs));
int column = 0;
for (int i=0; i<outputs; i++) {
QLabel * label = new QLabel(outputsWidget);
label->setText(" " + RawSource(SOURCE_TYPE_CH, i).toString() + " ");
label->setAlignment(Qt::AlignCenter);
label->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
channelsLayout->addWidget(label, 0, column, 1, 1);
QSlider * slider = new QSlider(outputsWidget);
slider->setEnabled(false);
slider->setMinimum(-1024);
slider->setMaximum(1024);
slider->setPageStep(128);
slider->setTracking(false);
slider->setOrientation(Qt::Vertical);
slider->setInvertedAppearance(false);
slider->setTickPosition(QSlider::TicksRight);
slider->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
QLabel * value = new QLabel(outputsWidget);
value->setMinimumSize(QSize(value->fontMetrics().size(Qt::TextSingleLine, "-100.0").width(), 0));
value->setAlignment(Qt::AlignCenter);
value->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
channelValues << value;
channelsLayout->addWidget(value, 1, column, 1, 1);
channelSliders << slider;
channelsLayout->addWidget(slider, 2, column++, 1, 1);
channelsLayout->setAlignment(slider, Qt::AlignHCenter);
}
// populate logical switches
int switches = firmware->getCapability(LogicalSwitches);
int rows = switches / (switches > 16 ? 4 : 2);
for (int i=0; i<switches; i++) {
QFrame * swtch = createLogicalSwitch(outputsWidget, i, logicalSwitchLabels);
logicalSwitchesLayout->addWidget(swtch, i / rows, i % rows, 1, 1);
}
}
void SimulatorDialog::setupGVarsDisplay()
{
int fmodes = firmware->getCapability(FlightModes);
int gvars = firmware->getCapability(Gvars);
if (gvars>0) {
// setup GVars tab
QWidget * gvarsWidget = new QWidget();
QGridLayout * gvarsLayout = new QGridLayout(gvarsWidget);
ui->tabWidget->addTab(gvarsWidget, QString(tr("GVars")));
for (int fm=0; fm<fmodes; fm++) {
QLabel * label = new QLabel(gvarsWidget);
label->setText(QString("FM%1").arg(fm));
label->setAlignment(Qt::AlignCenter);
gvarsLayout->addWidget(label, 0, fm+1);
}
for (int i=0; i<gvars; i++) {
QLabel * label = new QLabel(gvarsWidget);
label->setText(QString("GV%1").arg(i+1));
label->setAutoFillBackground(true);
if ((i % 2) ==0 ) {
label->setStyleSheet("QLabel { background-color: rgb(220, 220, 220) }");
}
gvarsLayout->addWidget(label, i+1, 0);
for (int fm=0; fm<fmodes; fm++) {
QLabel * value = new QLabel(gvarsWidget);
value->setAutoFillBackground(true);
value->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
if ((i % 2) ==0 ) {
value->setStyleSheet("QLabel { background-color: rgb(220, 220, 220) }");
}
value->setText("0");
gvarValues << value;
gvarsLayout->addWidget(value, i+1, fm+1);
}
}
}
}
QFrame * SimulatorDialog::createLogicalSwitch(QWidget * parent, int switchNo, QVector<QLabel *> & labels)
{
QFrame * swtch = new QFrame(parent);
swtch->setAutoFillBackground(true);
swtch->setFrameShape(QFrame::Panel);
swtch->setFrameShadow(QFrame::Raised);
swtch->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
swtch->setMaximumHeight(18);
QVBoxLayout * layout = new QVBoxLayout(swtch);
layout->setContentsMargins(2, 0, 2, 0);
QFont font;
font.setPointSize(8);
QLabel * label = new QLabel(swtch);
label->setFont(font);
label->setText(RawSwitch(SWITCH_TYPE_VIRTUAL, switchNo+1).toString());
label->setAlignment(Qt::AlignCenter);
label->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
labels << label;
layout->addWidget(label);
return swtch;
}
void SimulatorDialog::setupJoysticks()
{
#ifdef JOYSTICKS
static bool joysticksEnabled = false;
if (g.jsSupport() && g.jsCtrl() > -1) {
int count=0, axe;
for (int j=0; j < MAX_JOYSTICKS; j++){
axe = g.joystick[j].stick_axe();
if (axe >= 0 && axe < MAX_JOYSTICKS) {
jsmap[axe] = j + 1;
jscal[axe][0] = g.joystick[j].stick_min();
jscal[axe][1] = g.joystick[j].stick_med();
jscal[axe][2] = g.joystick[j].stick_max();
jscal[axe][3] = g.joystick[j].stick_inv();
count++;
}
}
if (count<3) {
QMessageBox::critical(this, tr("Warning"), tr("Joystick enabled but not configured correctly"));
return;
}
joystick = new Joystick(this);
if (joystick && joystick->open(g.jsCtrl())) {
int numAxes = std::min(joystick->numAxes, MAX_JOYSTICKS);
for (int j=0; j<numAxes; j++) {
joystick->sensitivities[j] = 0;
joystick->deadzones[j] = 0;
}
//mode 1,3 -> THR on right
vJoyRight->setStickConstraint(VirtualJoystickWidget::HOLD_Y, true);
vJoyRight->setStickConstraint(VirtualJoystickWidget::HOLD_X, true);
vJoyLeft->setStickConstraint(VirtualJoystickWidget::HOLD_Y, true);
vJoyLeft->setStickConstraint(VirtualJoystickWidget::HOLD_X, true);
connect(joystick, SIGNAL(axisValueChanged(int, int)), this, SLOT(onjoystickAxisValueChanged(int, int)));
joysticksEnabled = true;
}
else {
QMessageBox::critical(this, tr("Warning"), tr("Cannot open joystick, joystick disabled"));
}
}
else if (joysticksEnabled && joystick) {
disconnect(joystick, 0, this, 0);
vJoyRight->setStickConstraint(VirtualJoystickWidget::HOLD_Y, false);
vJoyRight->setStickConstraint(VirtualJoystickWidget::HOLD_X, false);
vJoyLeft->setStickConstraint(VirtualJoystickWidget::HOLD_Y, false);
vJoyLeft->setStickConstraint(VirtualJoystickWidget::HOLD_X, false);
}
#endif
}
void SimulatorDialog::setupTimer()
{
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(onTimerEvent()));
timer->start(10);
}
void SimulatorDialog::restoreRadioWidgetsState()
{
RadioWidget::RadioWidgetState state;
QMap<int, QByteArray> switchesMap;
QMap<int, QByteArray> analogsMap;
QList<QByteArray> states = g.profile[radioProfileId].simulatorOptions().controlsState;
foreach (QByteArray ba, states) {
QDataStream stream(ba);
stream >> state;
if (state.type == RadioWidget::RADIO_WIDGET_SWITCH)
switchesMap.insert(state.index, ba);
else
analogsMap.insert(state.index, ba);
}
for (int i = 0; i < analogs.size(); ++i) {
if (analogsMap.contains(analogs[i]->getIndex()))
analogs[i]->setStateData(analogsMap.value(analogs[i]->getIndex()));
}
for (int i = 0; i < switches.size(); ++i) {
if (switchesMap.contains(switches[i]->getIndex()))
switches[i]->setStateData(switchesMap.value(switches[i]->getIndex()));
}
}
QList<QByteArray> SimulatorDialog::saveRadioWidgetsState()
{
QList<QByteArray> states;
for (int i = 0; i < analogs.size(); ++i)
states.append(analogs[i]->getStateData());
for (int i = 0; i < switches.size(); ++i)
states.append(switches[i]->getStateData());
return states;
}
/*
* Input/Output handlers for SimulatorInterface
*/
// Read various values from firmware simulator and populate values in this UI
void SimulatorDialog::setValues()
{
static const int numGvars = firmware->getCapability(Gvars);
static const int numFlightModes = firmware->getCapability(FlightModes);
static QString phase_name;
static TxOutputs prevOutputs;
static int prevPhase = -1;
int currentPhase;
TxOutputs outputs;
simulator->getValues(outputs);
for (int i = 0; i < channelSliders.size() && i < CPN_MAX_CHNOUT; i++) {
channelSliders[i]->setValue(qMin(1024, qMax(-1024, outputs.chans[i])));
channelValues[i]->setText(QString("%1").arg((qreal)outputs.chans[i]*100/1024, 0, 'f', 1));
}
for (int i = 0; i < logicalSwitchLabels.size() && i < CPN_MAX_CSW; i++) {
if (prevOutputs.vsw[i] != outputs.vsw[i]) {
// setStyleSheet() is very CPU time consuming, doing it only on the actual
// switch state change brings down CPU usage time (for Taranis simulation) from 40% to 7% (Linux, one core usage)
logicalSwitchLabels[i]->setStyleSheet(outputs.vsw[i] ? CSWITCH_ON : CSWITCH_OFF);
}
}
for (int gv = 0; gv < numGvars; gv++) {
for (int fm = 0; fm < numFlightModes; fm++) {
if (prevPhase != lastPhase || prevOutputs.gvars[fm][gv] != outputs.gvars[fm][gv]) {
// same trick for GVARS, but this has far less effect on CPU usage as setStyleSheet()
gvarValues[gv*numFlightModes+fm]->setText(QString((fm == lastPhase) ? "<b>%1</b>" : "%1").arg(outputs.gvars[fm][gv]));
}
}
}
// display current flight mode in window title
currentPhase = simulator->getPhase();
if (currentPhase != lastPhase) {
lastPhase = currentPhase;
phase_name = QString(simulator->getPhaseName(currentPhase));
if (phase_name.isEmpty())
phase_name = QString::number(currentPhase);
setWindowTitle(windowName + QString(" - Flight Mode %1").arg(phase_name));
}
prevOutputs = outputs;
prevPhase = lastPhase;
}
// "get" values from this UI and send them to the firmware simulator.
void SimulatorDialog::getValues()
{
static const int numTrims = firmware->getCapability(NumTrimSwitches);
int i;
TxInputs inp;
memset(&inp, 0, sizeof(TxInputs));
inp.sticks[0] = int(1024 * vJoyLeft->getStickX()); // LEFT HORZ
inp.sticks[1] = int(-1024 * vJoyLeft->getStickY()); // LEFT VERT
inp.sticks[2] = int(-1024 * vJoyRight->getStickY()); // RGHT VERT
inp.sticks[3] = int(1024 * vJoyRight->getStickX()); // RGHT HORZ
for (i = 0; i < analogs.size() && i < CPN_MAX_POTS; ++i)
inp.pots[analogs[i]->getIndex()] = analogs[i]->getValue();
for (i = 0; i < switches.size() && i < CPN_MAX_SWITCHES; ++i)
inp.switches[switches[i]->getIndex()] = switches[i]->getValue();
for (i = 0; i < numTrims; ++i)
inp.trims[i] = (trimPressed == i);
foreach (RadioUiAction * act, radioUiWidget->getActions()) {
if (act->getIndex() > -1 && act->getIndex() < CPN_MAX_KEYS)
inp.keys[act->getIndex()] = act->isActive();
}
if (radioUiWidget->getRotEncAction())
inp.rotenc = radioUiWidget->getRotEncAction()->isActive();
simulator->setValues(inp);
}
// Read stick trim values from firmware simulator and set joystick widgets as needed.
void SimulatorDialog::setTrims()
{
typedef VirtualJoystickWidget VJW;
static Trims lastTrims;
Trims trims;
simulator->getTrims(trims);
if (trims.values[VJW::TRIM_AXIS_L_X] != lastTrims.values[VJW::TRIM_AXIS_L_X])
vJoyLeft->setTrimValue(VJW::TRIM_AXIS_L_X, trims.values[VJW::TRIM_AXIS_L_X]);
if (trims.values[VJW::TRIM_AXIS_L_Y] != lastTrims.values[VJW::TRIM_AXIS_L_Y])
vJoyLeft->setTrimValue(VJW::TRIM_AXIS_L_Y, trims.values[VJW::TRIM_AXIS_L_Y]);
if (trims.values[VJW::TRIM_AXIS_R_Y] != lastTrims.values[VJW::TRIM_AXIS_R_Y])
vJoyRight->setTrimValue(VJW::TRIM_AXIS_R_Y, trims.values[VJW::TRIM_AXIS_R_Y]);
if (trims.values[VJW::TRIM_AXIS_R_X] != lastTrims.values[VJW::TRIM_AXIS_R_X])
vJoyRight->setTrimValue(VJW::TRIM_AXIS_R_X, trims.values[VJW::TRIM_AXIS_R_X]);
if (trims.extended != lastTrims.extended) {
int trimMin = -125, trimMax = +125;
if (trims.extended) {
trimMin = -500;
trimMax = +500;
}
vJoyLeft->setTrimRange(VJW::TRIM_AXIS_L_X, trimMin, trimMax);
vJoyLeft->setTrimRange(VJW::TRIM_AXIS_L_Y, trimMin, trimMax);
vJoyRight->setTrimRange(VJW::TRIM_AXIS_R_Y, trimMin, trimMax);
vJoyRight->setTrimRange(VJW::TRIM_AXIS_R_X, trimMin, trimMax);
}
lastTrims = trims;
}
/*
* Event handlers/private slots
*/
void SimulatorDialog::closeEvent(QCloseEvent *)
{
simulator->stop();
timer->stop();
SimulatorOptions opts = g.profile[radioProfileId].simulatorOptions();
opts.windowGeometry = saveGeometry();
opts.controlsState = saveRadioWidgetsState();
g.profile[radioProfileId].simulatorOptions(opts);
if (saveTempRadioData)
saveTempData();
if (deleteTempRadioData)
deleteTempData();
}
void SimulatorDialog::showEvent(QShowEvent *)
{
static bool firstShow = true;
if (firstShow) {
restoreGeometry(g.profile[radioProfileId].simulatorOptions().windowGeometry);
// The stick position needs to be set after the final show event, otherwise resizes during dialog creation will screw it up.
if (radioSettings.stickMode & 1) {
vJoyLeft->setStickConstraint(VirtualJoystickWidget::HOLD_Y, true);
vJoyLeft->setStickY(1);
}
else {
vJoyRight->setStickConstraint(VirtualJoystickWidget::HOLD_Y, true);
vJoyRight->setStickY(1);
}
firstShow = false;
}
}
void SimulatorDialog::mousePressEvent(QMouseEvent *event)
{
if (radioUiWidget)
radioUiWidget->mousePressEvent(event);
}
void SimulatorDialog::mouseReleaseEvent(QMouseEvent *event)
{
if (radioUiWidget)
radioUiWidget->mouseReleaseEvent(event);
}
void SimulatorDialog::wheelEvent(QWheelEvent *event)
{
if (radioUiWidget)
radioUiWidget->wheelEvent(event);
}
void SimulatorDialog::onTimerEvent()
{
static unsigned int lcd_counter = 0;
if (!simulator->timer10ms()) {
QMessageBox::critical(this, "Companion", tr("Firmware %1 error: %2").arg(firmware->getName()).arg(simulator->getError()));
timer->stop();
return;
}
getValues();
if (!(lcd_counter++ % 5)) {
setValues();
setTrims();
centerSticks();
}
radioUiWidget->timedUpdate(lcd_counter);
updateDebugOutput();
}
void SimulatorDialog::onTrimPressed(int which)
{
trimPressed = which;
}
void SimulatorDialog::onTrimReleased()
{
trimPressed = TRIM_NONE;
}
void SimulatorDialog::onTrimSliderMoved(int which, int value)
{
simulator->setTrim(which, value);
}
void SimulatorDialog::centerSticks()
{
if (vJoyLeft)
vJoyLeft->centerStick();
if (vJoyRight)
vJoyRight->centerStick();
}
void SimulatorDialog::openTelemetrySimulator()
{
// allow only one instance
if (TelemetrySimu == 0) {
TelemetrySimu = new TelemetrySimulator(this, simulator);
TelemetrySimu->show();
connect(TelemetrySimu, &TelemetrySimulator::destroyed, [this](QObject *) {
this->TelemetrySimu = NULL;
});
}
else if (!TelemetrySimu->isVisible()) {
TelemetrySimu->show();
}
}
void SimulatorDialog::openTrainerSimulator()
{
// allow only one instance
if (TrainerSimu == 0) {
TrainerSimu = new TrainerSimulator(this, simulator);
TrainerSimu->show();
connect(TrainerSimu, &TrainerSimulator::destroyed, [this](QObject *) {
this->TrainerSimu = NULL;
});
}
else if (!TrainerSimu->isVisible()) {
TrainerSimu->show();
}
}
void SimulatorDialog::openJoystickDialog()
{
#ifdef JOYSTICKS
joystickDialog * jd = new joystickDialog(this);
if (jd->exec() == QDialog::Accepted)
setupJoysticks();
jd->deleteLater();
#endif
}
void SimulatorDialog::openDebugOutput()
{
// allow only one instance, but install signal handler to catch dialog destruction just in case
if (!DebugOut) {
DebugOut = new DebugOutput(this);
DebugOut->traceCallback(traceBuffer);
DebugOut->show();
connect(DebugOut, &DebugOutput::destroyed, [this](QObject *) {
this->DebugOut = NULL;
});
}
else if (!DebugOut->isVisible()) {
DebugOut->show();
}
}
void SimulatorDialog::updateDebugOutput()
{
traceMutex.lock();
while (!traceList.isEmpty()) {
QString text = traceList.takeFirst();
traceBuffer.append(text);
// limit the size of traceBuffer
if (traceBuffer.size() > 10*1024) {
traceBuffer.remove(0, 1*1024);
}
if (DebugOut) {
DebugOut->traceCallback(QString(text));
}
}
traceMutex.unlock();
}
void SimulatorDialog::luaReload()
{
// force a reload of the lua environment
simulator->setLuaStateReloadPermanentScripts();
}
void SimulatorDialog::showHelp()
{
QString helpText = tr("Simulator Controls:");
helpText += "<table cellspacing=4 cellpadding=0>";
helpText += tr("<tr><th>Key/Mouse</td><th>Action</td></tr>");
QString keyTemplate = "<tr><td align='center'><pre>%1</pre></td><td align='center'>%2</td></tr>";
foreach (keymapHelp_t pair, keymapHelp)
helpText += keyTemplate.arg(pair.first, pair.second);
helpText += "</table>";
QMessageBox * msgBox = new QMessageBox(this);
msgBox->setAttribute(Qt::WA_DeleteOnClose);
msgBox->setWindowFlags(msgBox->windowFlags() | Qt::WindowStaysOnTopHint);
msgBox->setStandardButtons( QMessageBox::Ok );
msgBox->setWindowTitle(tr("Simulator Help"));
msgBox->setText(helpText);
msgBox->setModal(false);
msgBox->show();
}
#ifdef JOYSTICKS
void SimulatorDialog::onjoystickAxisValueChanged(int axis, int value)
{
int stick;
if (axis>=0 && axis<=8) {
stick=jsmap[axis];
int stickval;
if (value>jscal[axis][1]) {
if ((jscal[axis][2]-jscal[axis][1])==0)
return;
stickval=(1024*(value-jscal[axis][1]))/(jscal[axis][2]-jscal[axis][1]);
}
else {
if ((jscal[axis][1]-jscal[axis][0])==0)
return;
stickval=(1024*(value-jscal[axis][1]))/(jscal[axis][1]-jscal[axis][0]);
}
if (jscal[axis][3]==1) {
stickval*=-1;
}
if (stick==1 ) {
vJoyRight->setStickY(-stickval/1024.0);
}
else if (stick==2) {
vJoyRight->setStickX(stickval/1024.0);
}
else if (stick==3) {
vJoyLeft->setStickY(-stickval/1024.0);
}
else if (stick==4) {
vJoyLeft->setStickX(stickval/1024.0);
}
else if (stick >= 5 && stick < 5 + analogs.count()) {
analogs[stick-5]->setValue(stickval);
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink