configoutputwidget.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 *
 * Additional note on redistribution: The copyright and license notices above
 * must be maintained in each individual source file that is a derivative work
 * of this source file; otherwise redistribution is prohibited.
 */

#include "configoutputwidget.h"
#include "outputchannelform.h"
#include "configvehicletypewidget.h"

#include "uavtalk/telemetrymanager.h"

#include <QDebug>
#include <QStringList>
#include <QWidget>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QPushButton>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include "mixersettings.h"
#include "actuatorcommand.h"
#include "actuatorsettings.h"
#include "systemalarms.h"
#include "systemsettings.h"
#include "uavsettingsimportexport/uavsettingsimportexportmanager.h"
#include <extensionsystem/pluginmanager.h>
#include <coreplugin/modemanager.h>
#include <coreplugin/imode.h>

ConfigOutputWidget::ConfigOutputWidget(QWidget *parent)
    : ConfigTaskWidget(parent)
{
    m_config = new Ui_OutputWidget();
    m_config->setupUi(this);

    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();

    /* There's lots of situations where it's unsafe to run tests.
     * Import/export:
     */
    UAVSettingsImportExportManager *importexportplugin =
        pm->getObject<UAVSettingsImportExportManager>();
    connect(importexportplugin, &UAVSettingsImportExportManager::importAboutToBegin, this,
            &ConfigOutputWidget::stopTests);

    /* Board connection/disconnection: */
    TelemetryManager *telMngr = pm->getObject<TelemetryManager>();
    connect(telMngr, &TelemetryManager::connected, this, &ConfigOutputWidget::stopTests);
    connect(telMngr, &TelemetryManager::disconnected, this, &ConfigOutputWidget::stopTests);

    /* When we go into wizards, etc.. time to stop this too. */
    Core::ModeManager *modeMngr = Core::ModeManager::instance();
    connect(modeMngr, &Core::ModeManager::currentModeAboutToChange, this,
            &ConfigOutputWidget::stopTests);
    connect(modeMngr, &Core::ModeManager::currentModeChanged, this, &ConfigOutputWidget::stopTests);

    // NOTE: we have channel indices from 0 to 9, but the convention for OP is Channel 1 to Channel
    // 10.
    // Register for ActuatorSettings changes:
    for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++) {
        OutputChannelForm *outputForm = new OutputChannelForm(i, this, i == 0);
        m_config->channelLayout->addWidget(outputForm);

        connect(m_config->channelOutTest, &QAbstractButton::toggled, outputForm,
                &OutputChannelForm::enableChannelTest);
        connect(outputForm, &OutputChannelForm::channelChanged, this,
                &ConfigOutputWidget::sendChannelTest);

        connect(outputForm, &OutputChannelForm::formChanged, this,
                &ConfigOutputWidget::do_SetDirty);
    }

    connect(m_config->channelOutTest, &QAbstractButton::toggled, this,
            &ConfigOutputWidget::runChannelTests);
    connect(m_config->calibrateESC, &QAbstractButton::clicked, this,
            &ConfigOutputWidget::startESCCalibration);

    // Cache all the combo boxes and labels
    lblList.clear();
    lblList << m_config->chBank1 << m_config->chBank2 << m_config->chBank3 << m_config->chBank4
            << m_config->chBank5 << m_config->chBank6;
    rateList.clear();
    rateList << m_config->cb_outputRate1 << m_config->cb_outputRate2 << m_config->cb_outputRate3
             << m_config->cb_outputRate4 << m_config->cb_outputRate5 << m_config->cb_outputRate6;

    QList<QComboBox *>::iterator rateIter;
    for (rateIter = rateList.begin(); rateIter != rateList.end(); rateIter++) {
        QComboBox *rate = *rateIter;

        connect(rate, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
                &ConfigOutputWidget::refreshWidgetRanges);
    }

    UAVObjectManager *objManager = pm->getObject<UAVObjectManager>();
    UAVObject *obj = objManager->getObject(QString("ActuatorCommand"));
    if (UAVObject::GetGcsTelemetryUpdateMode(obj->getMetadata()) == UAVObject::UPDATEMODE_ONCHANGE)
        this->setEnabled(false);
    connect(SystemSettings::GetInstance(objManager), &UAVObject::objectUpdated, this,
            &ConfigOutputWidget::assignOutputChannels);

    autoLoadWidgets();
    refreshWidgetsValues();

    // track dirty state of these since they're managed manually
    // note: must come after autoLoadWidgets because it will choke with no object
    // TODO: make a cleaner mechanism for just tracking dirtiness
    addWidget(m_config->cb_outputRate6);
    addWidget(m_config->cb_outputRate5);
    addWidget(m_config->cb_outputRate4);
    addWidget(m_config->cb_outputRate3);
    addWidget(m_config->cb_outputRate2);
    addWidget(m_config->cb_outputRate1);
    addWidget(m_config->spinningArmed);
    addUAVObject("ActuatorSettings");
}

void ConfigOutputWidget::enableControls(bool enable)
{
    ConfigTaskWidget::enableControls(enable);
    if (!enable)
        m_config->channelOutTest->setChecked(false);
    m_config->channelOutTest->setEnabled(enable);
    m_config->calibrateESC->setEnabled(enable);
    m_config->motorCurveFit->setEnabled(enable);
    m_config->motorPowerGain->setEnabled(enable);
}

ConfigOutputWidget::~ConfigOutputWidget()
{
    // Do nothing
}

// ************************************

void ConfigOutputWidget::runChannelTests(bool state)
{
    SystemAlarms *systemAlarmsObj = SystemAlarms::GetInstance(getObjectManager());
    SystemAlarms::DataFields systemAlarms = systemAlarmsObj->getData();

    if (state && ((systemAlarms.Alarm[SystemAlarms::ALARM_ACTUATOR] == SystemAlarms::ALARM_ERROR)
                  || (systemAlarms.Alarm[SystemAlarms::ALARM_ACTUATOR]
                      == SystemAlarms::ALARM_CRITICAL))) {
        (void) QMessageBox::critical(this, tr("Actuator error"),
            tr("The actuator module is in an error state. "
                "Please fix these before testing outputs."));

        // Unfortunately must cache this since callback will reoccur
        accInitialData = ActuatorCommand::GetInstance(getObjectManager())->getMetadata();

        m_config->channelOutTest->setChecked(false);
        return;
    }

    // Confirm this is definitely what they want
    if (state) {
        int retval = QMessageBox::warning(this, tr("Actuator test"),
                tr("This option will start your motors by the amount selected on the "
                    "sliders regardless of transmitter.  It is recommended to remove "
                    "any blades from motors.  Are you sure you want to do this?"),
                QMessageBox::Yes | QMessageBox::No);

        if (retval != QMessageBox::Yes) {
            state = false;
            m_config->channelOutTest->setChecked(false);
            return;
        }
    }

    ActuatorCommand *obj = ActuatorCommand::GetInstance(getObjectManager());
    UAVObject::Metadata mdata = obj->getMetadata();
    if (state) {
        accInitialData = mdata;
        UAVObject::SetFlightAccess(mdata, UAVObject::ACCESS_READONLY);
        UAVObject::SetFlightTelemetryUpdateMode(mdata, UAVObject::UPDATEMODE_ONCHANGE);
        UAVObject::SetGcsTelemetryAcked(mdata, false);
        UAVObject::SetGcsTelemetryUpdateMode(mdata, UAVObject::UPDATEMODE_ONCHANGE);
        mdata.gcsTelemetryUpdatePeriod = 100;
    } else {
        mdata = accInitialData; // Restore metadata
    }
    obj->setMetadata(mdata);
    obj->updated();
}

OutputChannelForm *ConfigOutputWidget::getOutputChannelForm(const int index) const
{
    QList<OutputChannelForm *> outputChannelForms = findChildren<OutputChannelForm *>();
    foreach (OutputChannelForm *outputChannelForm, outputChannelForms) {
        if (outputChannelForm->index() == index)
            return outputChannelForm;
    }

    // no OutputChannelForm found with given index
    return NULL;
}

void ConfigOutputWidget::assignOutputChannels(UAVObject *obj)
{
    Q_UNUSED(obj);

    // Get UAVO
    ActuatorSettings *actuatorSettings = ActuatorSettings::GetInstance(getObjectManager());
    ActuatorSettings::DataFields actuatorSettingsData = actuatorSettings->getData();

    // Get channel descriptions
    QStringList ChannelDesc = ConfigVehicleTypeWidget::getChannelDescriptions();

    // Find all output forms in the tab, and set the text and min/max values
    QList<OutputChannelForm *> outputChannelForms = findChildren<OutputChannelForm *>();
    foreach (OutputChannelForm *outputChannelForm, outputChannelForms) {
        outputChannelForm->setAssignment(ChannelDesc[outputChannelForm->index()]);

        // init min,max,neutral
        quint32 minValue = actuatorSettingsData.ChannelMin[outputChannelForm->index()];
        quint32 maxValue = actuatorSettingsData.ChannelMax[outputChannelForm->index()];
        outputChannelForm->setMinmax(minValue, maxValue);

        quint32 neutral = actuatorSettingsData.ChannelNeutral[outputChannelForm->index()];
        outputChannelForm->setNeutral(neutral);
    }

    refreshWidgetRanges();
}

void ConfigOutputWidget::sendChannelTest(int index, int value)
{
    if (!m_config->channelOutTest->isChecked())
        return;

    if (index < 0 || (unsigned)index >= ActuatorCommand::CHANNEL_NUMELEM)
        return;

    ActuatorCommand *actuatorCommand = ActuatorCommand::GetInstance(getObjectManager());
    Q_ASSERT(actuatorCommand);
    ActuatorCommand::DataFields actuatorCommandFields = actuatorCommand->getData();
    actuatorCommandFields.Channel[index] = value;
    actuatorCommand->setData(actuatorCommandFields);
}

bool showOutputChannelSelectWindow(bool (&selectedChannels)[ActuatorCommand::CHANNEL_NUMELEM])
{
    // Get channel descriptions
    QStringList ChannelDesc = ConfigVehicleTypeWidget::getChannelDescriptions();

    // Build up dialog
    QDialog dialog;
    QVBoxLayout layout;
    QCheckBox *checkBoxes[ActuatorCommand::CHANNEL_NUMELEM];
    QLabel infoLabel("Select output channels to calibrate: ");
    layout.addWidget(&infoLabel);
    for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++) {
        checkBoxes[i] = new QCheckBox();
        checkBoxes[i]->setText(QString("Channel ") + QString::number(i + 1) + QString("  (")
                               + ChannelDesc[i] + QString(")"));
        checkBoxes[i]->setChecked(false);
        layout.addWidget(checkBoxes[i]);
    }

    QHBoxLayout horizontalLayout;
    QPushButton buttonOk("Ok");
    QPushButton buttonCancel("Cancel");
    horizontalLayout.addWidget(&buttonOk);
    horizontalLayout.addWidget(&buttonCancel);
    layout.addLayout(&horizontalLayout);

    // Connect buttons with dialog slots
    dialog.connect(&buttonOk, &QAbstractButton::clicked, &dialog, &QDialog::accept);
    dialog.connect(&buttonCancel, &QAbstractButton::clicked, &dialog, &QDialog::reject);

    // Show dialog
    dialog.setLayout(&layout);
    int retCode = dialog.exec();
    if (retCode == dialog.Accepted) {
        for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++)
            selectedChannels[i] = checkBoxes[i]->isChecked();
        return true;
    } else
        return false;
}

void ConfigOutputWidget::startESCCalibration()
{
    bool channelsToCalibrate[ActuatorCommand::CHANNEL_NUMELEM];
    if (!showOutputChannelSelectWindow(channelsToCalibrate))
        return;

    QMessageBox mbox(this);
    mbox.setText(QString(tr("Starting ESC calibration.<br/><b>Please remove all propellers and "
                            "disconnect battery from ESCs.</b>")));
    mbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
    mbox.setDefaultButton(QMessageBox::Cancel);

    if (mbox.exec() != QMessageBox::Ok)
        return;

    // Get access to actuator command (for setting actual value)
    ActuatorCommand *actuatorCommand = ActuatorCommand::GetInstance(getObjectManager());
    Q_ASSERT(actuatorCommand);
    ActuatorCommand::DataFields actuatorCommandFields = actuatorCommand->getData();
    UAVObject::Metadata mdata = actuatorCommand->getMetadata();
    // Get access to actuator settings (for min / max values)
    ActuatorSettings *actuatorSettings = ActuatorSettings::GetInstance(getObjectManager());
    Q_ASSERT(actuatorSettings);
    ActuatorSettings::DataFields actuatorSettingsData = actuatorSettings->getData();

    // Save previous metadata
    accInitialData = mdata;

    // Change settings for period of calibration
    UAVObject::SetFlightAccess(mdata, UAVObject::ACCESS_READONLY);
    UAVObject::SetFlightTelemetryUpdateMode(mdata, UAVObject::UPDATEMODE_ONCHANGE);
    UAVObject::SetGcsTelemetryAcked(mdata, false);
    UAVObject::SetGcsTelemetryUpdateMode(mdata, UAVObject::UPDATEMODE_ONCHANGE);
    mdata.gcsTelemetryUpdatePeriod = 100;
    actuatorCommand->setMetadata(mdata);
    actuatorCommand->updated();

    mbox.setText(QString(tr("Please wait...")));

    // Set output for motors to nil to disarm
    // Should not be necessary; battery is supposed to be disconnected, etc.
    // But this makes it moderately safer if the user does not obey.
    for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++) {
        // Check if the output channel was selected
        if (!channelsToCalibrate[i])
            continue;

        actuatorCommandFields.Channel[i] = 0;
    }

    actuatorCommand->setData(actuatorCommandFields);

    QEventLoop loop;

    QTimer timeout;
    timeout.setSingleShot(true);
    connect(&timeout, &QTimer::timeout, &loop, &QEventLoop::quit);
    timeout.start(1250); // 1.25 seconds
    loop.exec();

    // Increase output for all motors
    for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++) {
        // Check if the output channel was selected
        if (!channelsToCalibrate[i])
            continue;

        actuatorCommandFields.Channel[i] = actuatorSettingsData.ChannelMax[i];
    }

    actuatorCommand->setData(actuatorCommandFields);

    mbox.setText(QString(tr("Motors outputs were increased to maximum. "
                            "Reconnect the battery and wait for notification from ESCs that they "
                            "recognized high throttle position.<br/>"
                            "<b>Immediately after that proceed to next step.</b>")));
    if (mbox.exec() == QMessageBox::Ok) {
        // Decrease output for all motors
        for (unsigned int i = 0; i < ActuatorCommand::CHANNEL_NUMELEM; i++) {
            // Check if the output channel was selected
            if (!channelsToCalibrate[i])
                continue;

            // calibrate the minimum of the range
            // to be a little off what we send at idle.  Blheli takes the value
            // we give verbatim as the minimum, and small amounts of jitter
            // can cause the motor to tick over.
            double range = actuatorSettingsData.ChannelMax[i] - actuatorSettingsData.ChannelMin[i];
            actuatorCommandFields.Channel[i] = actuatorSettingsData.ChannelMin[i]
                + std::copysign(std::min(5.0, std::abs(range) / 40.0 + 0.5), range);
        }
        actuatorCommand->setData(actuatorCommandFields);

        mbox.setStandardButtons(QMessageBox::Ok);
        mbox.setDefaultButton(QMessageBox::Ok);
        mbox.setText(QString(tr("Motors outputs were decreased to minimum.<br/>Wait for "
                                "notification from ESCs that calibration is finished.")));
        mbox.exec();
    }

    // Restore metadata
    actuatorCommand->setMetadata(accInitialData);
    actuatorCommand->updated();
}

/********************************
  *  Output settings
  *******************************/

void ConfigOutputWidget::refreshWidgetsValues(UAVObject *obj)
{
    Q_UNUSED(obj);

    // Get Actuator Settings
    ActuatorSettings *actuatorSettings = ActuatorSettings::GetInstance(getObjectManager());
    Q_ASSERT(actuatorSettings);
    ActuatorSettings::DataFields actuatorSettingsData = actuatorSettings->getData();

    // Fill output forms
    assignOutputChannels(actuatorSettings);

    // Get the SpinWhileArmed setting
    m_config->spinningArmed->setChecked(actuatorSettingsData.MotorsSpinWhileArmed
                                        == ActuatorSettings::MOTORSSPINWHILEARMED_TRUE);

    // Get Output rates for all channel banks
    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
    Q_ASSERT(pm);
    UAVObjectUtilManager *utilMngr = pm->getObject<UAVObjectUtilManager>();
    if (utilMngr) {
        Core::IBoardType *board = utilMngr->getBoardType();
        if (board != NULL) {
            QStringList banks = board->queryChannelBanks();

            // First reset & disable all channel fields/outputs, then repopulate (because
            // we might be for instance connecting various board types one after another)
            for (int i = 0; i < 6; i++) {
                lblList.at(i)->setText("-");
                rateList.at(i)->setEnabled(false);
            }

            // Now repopulate based on board capabilities:
            for (int i = 0; i < banks.length(); i++) {
                lblList.at(i)->setText(banks.at(i));
                QComboBox *ccmb = rateList.at(i);
                ccmb->setEnabled(true);

                QString setting = timerFreqToString(actuatorSettingsData.TimerUpdateFreq[i]);
                if (ccmb->findText(setting) == -1) {
                    ccmb->addItem(setting);
                }
                ccmb->setCurrentIndex(ccmb->findText(setting));
            }
        }
    }

    m_config->motorCurveFit->setValue(actuatorSettingsData.MotorInputOutputCurveFit);
    m_config->motorPowerGain->setValue(actuatorSettingsData.MotorInputOutputGain * 100);

    // Get Channel ranges:
    QList<OutputChannelForm *> outputChannelForms = findChildren<OutputChannelForm *>();
    foreach (OutputChannelForm *outputChannelForm, outputChannelForms) {
        quint32 minValue = actuatorSettingsData.ChannelMin[outputChannelForm->index()];
        quint32 maxValue = actuatorSettingsData.ChannelMax[outputChannelForm->index()];

        outputChannelForm->setMinmax(minValue, maxValue);

        quint32 neutral = actuatorSettingsData.ChannelNeutral[outputChannelForm->index()];
        outputChannelForm->setNeutral(neutral);
    }

    refreshWidgetRanges();
}

void ConfigOutputWidget::refreshWidgetRanges()
{
    QList<OutputChannelForm *> outputChannelForms = findChildren<OutputChannelForm *>();

    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
    Q_ASSERT(pm);
    UAVObjectUtilManager *utilMngr = pm->getObject<UAVObjectUtilManager>();

    if (utilMngr) {
        Core::IBoardType *board = utilMngr->getBoardType();
        if (board != NULL) {
            QVector<QVector<qint32>> banks = board->getChannelBanks();

            for (int i = 0; i < banks.size(); i++) {
                QVector<int> bank = banks[i];

                // Pull out the parameters relating to this bank, and
                // calculate the maximum value.
                //
                QComboBox *ccmb = rateList.at(i);
                quint32 timerFreq = timerStringToFreq(ccmb->currentText());

                // First saturate at the timer period and UAVO maximum value.
                double maxPulseWidth, timerPeriodUs = UINT16_MAX;
                int minPulseWidth = 0;
                bool digital = false;

                switch (timerFreq) {
                case RATE_SYNCPWM:
                    // only the timer period provides bounding
                    maxPulseWidth = timerPeriodUs;
                    break;
                case RATE_DSHOT300:
                case RATE_DSHOT600:
                case RATE_DSHOT1200:
                    // 1-47 reserved for commands
                    minPulseWidth = 48;
                    // 11-bit value
                    maxPulseWidth = 2047;
                    // don't allow min/max to be changed
                    digital = true;
                    break;
                default:
                    maxPulseWidth = 1000000 / timerFreq;

                    // Should never happen, but here in case we ever have a
                    // < 16Hz PWM mode.
                    if (maxPulseWidth > timerPeriodUs)
                        maxPulseWidth = timerPeriodUs;
                    break;
                }

                // For each of the channels...
                for (auto channel : bank) {
                    // Find its form line and set the limit.
                    for (auto outputChannelForm : outputChannelForms) {
                        // Don't like the bogus index adjustments
                        if (outputChannelForm->index() != (channel - 1))
                            continue;
                        outputChannelForm->updateChannelLimits(
                            minPulseWidth, static_cast<int>(maxPulseWidth), digital);
                    }
                }
            }
        }
    }
}

void ConfigOutputWidget::updateObjectsFromWidgets()
{
    emit updateObjectsFromWidgetsRequested();

    ActuatorSettings *actuatorSettings = ActuatorSettings::GetInstance(getObjectManager());
    Q_ASSERT(actuatorSettings);
    if (actuatorSettings) {
        ActuatorSettings::DataFields actuatorSettingsData = actuatorSettings->getData();
        QList<OutputChannelForm *> outputChannelForms = findChildren<OutputChannelForm *>();

        foreach (OutputChannelForm *outputChannelForm, outputChannelForms) {
            actuatorSettingsData.ChannelMax[outputChannelForm->index()] = outputChannelForm->max();
            actuatorSettingsData.ChannelMin[outputChannelForm->index()] = outputChannelForm->min();
            actuatorSettingsData.ChannelNeutral[outputChannelForm->index()] =
                outputChannelForm->neutral();
        }

        // Set update rates
        actuatorSettingsData.TimerUpdateFreq[0] =
            timerStringToFreq(m_config->cb_outputRate1->currentText());
        actuatorSettingsData.TimerUpdateFreq[1] =
            timerStringToFreq(m_config->cb_outputRate2->currentText());
        actuatorSettingsData.TimerUpdateFreq[2] =
            timerStringToFreq(m_config->cb_outputRate3->currentText());
        actuatorSettingsData.TimerUpdateFreq[3] =
            timerStringToFreq(m_config->cb_outputRate4->currentText());
        actuatorSettingsData.TimerUpdateFreq[4] =
            timerStringToFreq(m_config->cb_outputRate5->currentText());
        actuatorSettingsData.TimerUpdateFreq[5] =
            timerStringToFreq(m_config->cb_outputRate6->currentText());

        actuatorSettingsData.MotorInputOutputCurveFit = m_config->motorCurveFit->value();
        actuatorSettingsData.MotorInputOutputGain = m_config->motorPowerGain->value() * 0.01;

        if (m_config->spinningArmed->isChecked() == true)
            actuatorSettingsData.MotorsSpinWhileArmed = ActuatorSettings::MOTORSSPINWHILEARMED_TRUE;
        else
            actuatorSettingsData.MotorsSpinWhileArmed =
                ActuatorSettings::MOTORSSPINWHILEARMED_FALSE;

        // Apply settings
        actuatorSettings->setData(actuatorSettingsData);
    }

    refreshWidgetRanges();
}

QString ConfigOutputWidget::timerFreqToString(quint32 freq) const
{
    static const QMap<quint32, QString> mapping{
        { RATE_SYNCPWM, tr("SyncPWM") },
        { RATE_DSHOT300, tr("Dshot300") },
        { RATE_DSHOT600, tr("Dshot600") },
        { RATE_DSHOT1200, tr("Dshot1200") },
    };
    return mapping.value(freq, QString::number(freq));
}

quint32 ConfigOutputWidget::timerStringToFreq(QString str) const
{
    static const QMap<QString, quint32> mapping{
        { tr("SyncPWM"), RATE_SYNCPWM },
        { tr("Dshot300"), RATE_DSHOT300 },
        { tr("Dshot600"), RATE_DSHOT600 },
        { tr("Dshot1200"), RATE_DSHOT1200 },
    };
    return mapping.value(str, str.toUInt());
}

void ConfigOutputWidget::tabSwitchingAway()
{
    stopTests();
}

void ConfigOutputWidget::stopTests()
{
    if (m_config->channelOutTest->isChecked()) {
        qDebug() << "Output testing stopped by signal of incompatible mode";
    }

    m_config->channelOutTest->setChecked(false);
}

void ConfigOutputWidget::do_SetDirty()
{
    setDirty(true);
}