QGCVehicleConfig.h 7.53 KB
Newer Older
1 2 3 4
#ifndef QGCVEHICLECONFIG_H
#define QGCVEHICLECONFIG_H

#include <QWidget>
5
#include <QTimer>
6
#include <QList>
7
#include <QGroupBox>
8
#include <QPushButton>
9

10
#include "QGCToolWidget.h"
11 12
#include "UASInterface.h"

13 14 15 16 17 18 19 20 21 22 23
namespace Ui {
class QGCVehicleConfig;
}

class QGCVehicleConfig : public QWidget
{
    Q_OBJECT
    
public:
    explicit QGCVehicleConfig(QWidget *parent = 0);
    ~QGCVehicleConfig();
24

25 26 27 28
    enum RC_MODE {
        RC_MODE_1 = 1,
        RC_MODE_2 = 2,
        RC_MODE_3 = 3,
29 30
        RC_MODE_4 = 4,
        RC_MODE_NONE = 5
31 32
    };

33
public slots:
34 35 36 37 38
    void rcMenuButtonClicked();
    void sensorMenuButtonClicked();
    void generalMenuButtonClicked();
    void advancedMenuButtonClicked();

39 40
    /** Set the MAV currently being calibrated */
    void setActiveUAS(UASInterface* active);
41
    /** Fallback function, automatically called by loadConfig() upon failure to find and xml file*/
42
    void loadQgcConfig(bool primary);
43
    /** Load configuration from xml file */
44
    void loadConfig();
45 46 47 48 49 50
    /** Start the RC calibration routine */
    void startCalibrationRC();
    /** Stop the RC calibration routine */
    void stopCalibrationRC();
    /** Start/stop the RC calibration routine */
    void toggleCalibrationRC(bool enabled);
51 52 53 54
    /** Set trim positions */
    void setTrimPositions();
    /** Detect which channels need to be inverted */
    void detectChannelInversion();
55 56
    /** Change the mode setting of the control inputs */
    void setRCModeIndex(int newRcMode);
57 58 59
    /** Render the data updated */
    void updateView();

60 61
    void updateMinMax();

62 63 64
    /** Set the RC channel */
    void setRollChan(int channel) {
        rcMapping[0] = channel - 1;
65
        updateInvertedCheckboxes(channel - 1);
66 67 68 69
    }
    /** Set the RC channel */
    void setPitchChan(int channel) {
        rcMapping[1] = channel - 1;
70
        updateInvertedCheckboxes(channel - 1);
71 72 73 74
    }
    /** Set the RC channel */
    void setYawChan(int channel) {
        rcMapping[2] = channel - 1;
75
        updateInvertedCheckboxes(channel - 1);
76 77 78 79
    }
    /** Set the RC channel */
    void setThrottleChan(int channel) {
        rcMapping[3] = channel - 1;
80
        updateInvertedCheckboxes(channel - 1);
81 82 83 84
    }
    /** Set the RC channel */
    void setModeChan(int channel) {
        rcMapping[4] = channel - 1;
85
        updateInvertedCheckboxes(channel - 1);
86 87 88 89
    }
    /** Set the RC channel */
    void setAux1Chan(int channel) {
        rcMapping[5] = channel - 1;
90
        updateInvertedCheckboxes(channel - 1);
91 92 93 94
    }
    /** Set the RC channel */
    void setAux2Chan(int channel) {
        rcMapping[6] = channel - 1;
95
        updateInvertedCheckboxes(channel - 1);
96 97 98 99
    }
    /** Set the RC channel */
    void setAux3Chan(int channel) {
        rcMapping[7] = channel - 1;
100
        updateInvertedCheckboxes(channel - 1);
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
    }

    /** Set channel inversion status */
    void setRollInverted(bool inverted) {
        rcRev[rcMapping[0]] = inverted;
    }
    /** Set channel inversion status */
    void setPitchInverted(bool inverted) {
        rcRev[rcMapping[1]] = inverted;
    }
    /** Set channel inversion status */
    void setYawInverted(bool inverted) {
        rcRev[rcMapping[2]] = inverted;
    }
    /** Set channel inversion status */
    void setThrottleInverted(bool inverted) {
        rcRev[rcMapping[3]] = inverted;
    }
    /** Set channel inversion status */
    void setModeInverted(bool inverted) {
        rcRev[rcMapping[4]] = inverted;
    }
    /** Set channel inversion status */
    void setAux1Inverted(bool inverted) {
        rcRev[rcMapping[5]] = inverted;
    }
    /** Set channel inversion status */
    void setAux2Inverted(bool inverted) {
        rcRev[rcMapping[6]] = inverted;
    }
    /** Set channel inversion status */
    void setAux3Inverted(bool inverted) {
        rcRev[rcMapping[7]] = inverted;
    }

136
protected slots:
137
    void menuButtonClicked();
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
    /** Reset the RC calibration */
    void resetCalibrationRC();
    /** Write the RC calibration */
    void writeCalibrationRC();
    /** Request the RC calibration */
    void requestCalibrationRC();
    /** Store all parameters in onboard EEPROM */
    void writeParameters();
    /** Receive remote control updates from MAV */
    void remoteControlChannelRawChanged(int chan, float val);
    /** Parameter changed onboard */
    void parameterChanged(int uas, int component, QString parameterName, QVariant value);
    void updateStatus(const QString& str);
    void updateError(const QString& str);
    void setRCType(int type);
    /** Check timeouts */
    void checktimeOuts();
155 156
    /** Update checkbox status */
    void updateInvertedCheckboxes(int index);
157 158

protected:
159
    bool doneLoadingConfig;
160 161
    UASInterface* mav;                  ///< The current MAV
    static const unsigned int chanMax = 8;    ///< Maximum number of channels
162
    unsigned int chanCount;               ///< Actual channels
163 164 165
    int rcType;                         ///< Type of the remote control
    quint64 rcTypeUpdateRequested;      ///< Zero if not requested, non-zero if requested
    static const unsigned int rcTypeTimeout = 5000; ///< 5 seconds timeout, in milliseconds
166 167 168
    float rcMin[chanMax];                 ///< Minimum values
    float rcMax[chanMax];                 ///< Maximum values
    float rcTrim[chanMax];                ///< Zero-position (center for roll/pitch/yaw, 0 throttle for throttle)
169
    int rcMapping[chanMax];             ///< PWM to function mappings
170
    float rcScaling[chanMax];           ///< Scaling of channel input to control commands
171
    bool rcRev[chanMax];                ///< Channel reverse
172
    int rcValue[chanMax];               ///< Last values
173 174 175 176 177 178 179 180 181 182
    float rcRoll;                       ///< PPM input channel used as roll control input
    float rcPitch;                      ///< PPM input channel used as pitch control input
    float rcYaw;                        ///< PPM input channel used as yaw control input
    float rcThrottle;                   ///< PPM input channel used as throttle control input
    float rcMode;                       ///< PPM input channel used as mode switch control input
    float rcAux1;                       ///< PPM input channel used as aux 1 input
    float rcAux2;                       ///< PPM input channel used as aux 1 input
    float rcAux3;                       ///< PPM input channel used as aux 1 input
    bool rcCalChanged;                  ///< Set if the calibration changes (and needs to be written)
    bool changed;                       ///< Set if any of the input data changed
183
    QTimer updateTimer;                 ///< Controls update intervals
184 185
    enum RC_MODE rc_mode;               ///< Mode of the remote control, according to usual convention
    QList<QGCToolWidget*> toolWidgets;  ///< Configurable widgets
186
    bool calibrationEnabled;            ///< calibration mode on / off
187

188 189 190 191 192
    QMap<QString,QGCToolWidget*> *paramToWidgetMap;                     ///< Holds the current active MAV's parameter widgets.
    QMap<QString,QGCToolWidget*> *libParamToWidgetMap;                  ///< Holds the library parameter widgets
    QMap<QString,QMap<QString,QGCToolWidget*>*> systemTypeToParamMap;   ///< Holds all loaded MAV specific parameter widgets, for every MAV.
    QMap<QGCToolWidget*,QGroupBox*> toolToBoxMap;                       ///< Easy method of figuring out which QGroupBox is tied to which ToolWidget.
    QMap<QString,QString> paramTooltips;                                ///< Tooltips for the ? button next to a parameter.
193 194 195
    
private:
    Ui::QGCVehicleConfig *ui;
196
    QMap<QPushButton*,QWidget*> buttonToWidgetMap;
197 198
signals:
    void visibilityChanged(bool visible);
199 200 201
};

#endif // QGCVEHICLECONFIG_H