configinputwidget.h

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/>
 */
#ifndef CONFIGINPUTWIDGET_H
#define CONFIGINPUTWIDGET_H

#include <QGraphicsView>
#include <QList>
#include <QPointer>
#include <QRadioButton>
#include <QWidget>
#include <QSvgRenderer>
#include <QGraphicsSvgItem>

#include "ui_input.h"
#include "ui_inputchannelform.h"

#include "uavobjectwidgetutils/configtaskwidget.h"
#include "extensionsystem/pluginmanager.h"
#include "uavobjects/uavobjectmanager.h"
#include "uavobjects/uavobject.h"
#include <QWidget>
#include <QList>
#include "inputchannelform.h"

#include "flightstatus.h"
#include "manualcontrolcommand.h"
#include "manualcontrolsettings.h"
#include "receiveractivity.h"

class TelemetryManager;
class Ui_InputWidget;

class ConfigInputWidget : public ConfigTaskWidget
{
    Q_OBJECT
public:
    ConfigInputWidget(QWidget *parent = nullptr);
    ~ConfigInputWidget();
    enum wizardSteps {
        wizardWelcome,
        wizardChooseMode,
        wizardChooseType,
        wizardIdentifySticks,
        wizardIdentifyCenter,
        wizardIdentifyLimits,
        wizardIdentifyInverted,
        wizardVerifyFailsafe,
        wizardFinish,
        wizardNone
    };
    enum txMode { mode1, mode2 };
    enum txMovements {
        moveLeftVerticalStick,
        moveRightVerticalStick,
        moveLeftHorizontalStick,
        moveRightHorizontalStick,
        moveAccess0,
        moveAccess1,
        moveAccess2,
        moveFlightMode,
        centerAll,
        moveAll,
        armingSwitch,
        nothing
    };
    enum txMovementType { vertical, horizontal, jump, mix };
    enum txType { acro, heli };
    enum failsafeDetection { FS_AWAITING_CONNECTION, FS_AWAITING_FAILSAFE, FS_AWAITING_RECONNECT };
    void startInputWizard() { goToWizard(); }

protected:
    // Note: must match armingNames
    enum ArmingMethodType {
        ARM_INVALID,
        ARM_ALWAYS_DISARMED,
        ARM_SWITCH,
        ARM_ROLL_LEFT,
        ARM_ROLL_RIGHT,
        ARM_YAW_LEFT,
        ARM_YAW_RIGHT,
        ARM_CORNERS,
    };

    struct ArmingMethod
    {
        enum ArmingMethodType method;
        QString name;
        QString armName;
        QString disarmName;
        QString uavoOption;
        bool isSwitch;
        bool isStick;
        bool isFixed;
    };

    static const QVector<ArmingMethod> armingMethods;

private:
    // This was set through trial and error. Extensive testing
    // will have to be done before changing it. At a minimum,
    // this should include Turnigy9x, FrSky, S.BUS, and Spektrum
    // transmitters.
    static const int DEBOUNCE_THRESHOLD_COUNT = 1;
    // This was set through trial and error. Extensive testing
    // will have to be done before changing it. At a minimum,
    // this should include Turnigy9x, FrSky, S.BUS, and Spektrum
    // transmitters.
    static const int CHANNEL_IDENTIFICATION_WAIT_TIME_MS = 2500;

    bool growing;
    bool reverse[ManualControlSettings::CHANNELNEUTRAL_NUMELEM];

    int minSeen[ManualControlSettings::CHANNELNEUTRAL_NUMELEM];
    int maxSeen[ManualControlSettings::CHANNELNEUTRAL_NUMELEM];

    txMovements currentMovement;
    int movePos;
    void setTxMovement(txMovements movement);
    Ui_InputWidget *m_config;
    wizardSteps wizardStep;
    QList<QPointer<QWidget>> extraWidgets;
    txMode transmitterMode;
    txType transmitterType;

    enum failsafeDetection failsafeDetection;
    struct channelsStruct
    {
        bool operator==(const channelsStruct &rhs) const
        {
            return ((group == rhs.group) && (number == rhs.number));
        }
        int group;
        int number;
    } lastChannel;
    channelsStruct currentChannel;
    QList<channelsStruct> usedChannels;
    bool channelDetected;
    QEventLoop *loop;
    bool skipflag;

    int currentChannelNum;
    QList<int> heliChannelOrder;
    QList<int> acroChannelOrder;

    ManualControlCommand *manualCommandObj;
    ManualControlCommand::DataFields manualCommandData;
    FlightStatus *flightStatusObj;
    UAVObject::Metadata manualControlMdata;
    ManualControlSettings *manualSettingsObj;
    ManualControlSettings::DataFields manualSettingsData;
    ManualControlSettings::DataFields previousManualSettingsData;
    ReceiverActivity *receiverActivityObj;
    ReceiverActivity::DataFields receiverActivityData;
    QMap<QString, UAVObject::Metadata> originalMetaData;

    QSvgRenderer *m_renderer;

    // Background: background
    QGraphicsSvgItem *m_txMainBody;
    QGraphicsSvgItem *m_txLeftStick;
    QGraphicsSvgItem *m_txRightStick;
    QGraphicsSvgItem *m_txAccess0;
    QGraphicsSvgItem *m_txAccess1;
    QGraphicsSvgItem *m_txAccess2;
    QGraphicsSvgItem *m_txFlightMode;
    QGraphicsSvgItem *m_txArming;
    QGraphicsSvgItem *m_txBackground;
    QGraphicsSvgItem *m_txArrows;
    QTransform m_txLeftStickOrig;
    QTransform m_txRightStickOrig;
    QTransform m_txAccess0Orig;
    QTransform m_txAccess1Orig;
    QTransform m_txAccess2Orig;
    QTransform m_txFlightModeCOrig;
    QTransform m_txFlightModeLOrig;
    QTransform m_txFlightModeROrig;
    QTransform m_txArmingSwitchOrigL;
    QTransform m_txArmingSwitchOrigR;
    QTransform m_txMainBodyOrig;
    QTransform m_txArrowsOrig;
    QTimer *animate;

    QComboBox *cbArmingOption;
    ArmingMethodType lastArmingMethod;
    bool armingConfigUpdating;

    void resetTxControls();
    void setMoveFromCommand(int command);

    void fastMdata();
    void restoreMdata();

    void setChannel(int);
    void nextChannel();
    void prevChannel();

    void wizardSetUpStep(enum wizardSteps);
    void wizardTearDownStep(enum wizardSteps);

    TelemetryManager *telMngr;
    quint8 scaleSwitchChannel(quint8 channelNumber, quint8 switchPositions);

    const ArmingMethod armingMethodFromArmName(const QString &name);
    const ArmingMethod armingMethodFromUavoOption(const QString &option);
    void fillArmingComboBox();

private slots:
    void wzNext();
    void wzBack();
    void wzCancel();
    void goToWizard();
    void identifyControls();
    void identifyLimits();
    void moveTxControls();
    void moveSticks();
    void detectFailsafe();
    void dimOtherControls(bool value);
    void moveFMSlider();
    void updatePositionSlider();
    void invertControls();
    void simpleCalibration(bool state);
    void updateCalibration();
    void checkArmingConfig();
    void checkReprojection();
    void updateArmingConfig(UAVObject *manualControlSettings);
    void timeoutCheckboxChanged();
    void checkCollective();

protected:
    void resizeEvent(QResizeEvent *event);
    virtual void enableControls(bool enable);
    void addMessage(QWidget *target, const QString type, const QString msg);
    void addWarning(QWidget *target, QWidget *cause, const QString msg);
    void clearMessages(QWidget *widget, const QString type);
    void clearWarnings(QWidget *target, QWidget *causesParent);
};

#endif