FirmwareUpgradeController.h 14.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
/****************************************************************************
 *
 *   (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

10
#pragma once
11

12
#include "PX4FirmwareUpgradeThread.h"
13 14
#include "LinkManager.h"
#include "FirmwareImage.h"
15
#include "Fact.h"
16 17

#include <QObject>
18 19 20 21
#include <QUrl>
#include <QTimer>
#include <QNetworkAccessManager>
#include <QNetworkReply>
22 23
#include <QPixmap>
#include <QQuickItem>
24
#include <QSerialPort>
25

26 27
#include <stdint.h>

28 29
/// Supported firmware types. If you modify these you will need to update the qml file as well.

30 31
// Firmware Upgrade MVC Controller for FirmwareUpgrade.qml.
class FirmwareUpgradeController : public QObject
32 33
{
    Q_OBJECT
34
    
35
public:
36
        typedef enum {
37
            AutoPilotStackPX4 = 0,
38
            AutoPilotStackAPM,
39 40
            PX4FlowPX4,
            PX4FlowAPM,
41 42
            ThreeDRRadio,
            SingleFirmwareMode
43 44 45
        } AutoPilotStackType_t;

        typedef enum {
46
            StableFirmware = 0,
47 48 49
            BetaFirmware,
            DeveloperFirmware,
            CustomFirmware
50
        } FirmwareBuildType_t;
51 52

        typedef enum {
53
            CopterFirmware = 0,
Don Gagne's avatar
Don Gagne committed
54
            HeliFirmware,
55 56
            PlaneFirmware,
            RoverFirmware,
57
            SubFirmware,
58
            DefaultVehicleFirmware
59 60
        } FirmwareVehicleType_t;

61
        Q_ENUM(AutoPilotStackType_t)
62
        Q_ENUM(FirmwareBuildType_t)
63
        Q_ENUM(FirmwareVehicleType_t)
64 65 66 67 68

    class FirmwareIdentifier
    {
    public:
        FirmwareIdentifier(AutoPilotStackType_t stack = AutoPilotStackPX4,
69
                           FirmwareBuildType_t firmware = StableFirmware,
70 71 72
                           FirmwareVehicleType_t vehicle = DefaultVehicleFirmware)
            : autopilotStackType(stack), firmwareType(firmware), firmwareVehicleType(vehicle) {}

73
        bool operator==(const FirmwareIdentifier& firmwareId) const
74
        {
75 76 77
            return (firmwareId.autopilotStackType == autopilotStackType &&
                    firmwareId.firmwareType == firmwareType &&
                    firmwareId.firmwareVehicleType == firmwareVehicleType);
78 79 80 81
        }

        // members
        AutoPilotStackType_t    autopilotStackType;
82
        FirmwareBuildType_t          firmwareType;
83 84 85
        FirmwareVehicleType_t   firmwareVehicleType;
    };

86
    FirmwareUpgradeController(void);
Don Gagne's avatar
Don Gagne committed
87 88
    ~FirmwareUpgradeController();

89 90 91 92 93 94 95 96 97 98 99
    Q_PROPERTY(bool                 downloadingFirmwareList     MEMBER _downloadingFirmwareList                                     NOTIFY downloadingFirmwareListChanged)
    Q_PROPERTY(QString              boardPort                   READ boardPort                                                      NOTIFY boardFound)
    Q_PROPERTY(QString              boardDescription            READ boardDescription                                               NOTIFY boardFound)
    Q_PROPERTY(QString              boardType                   MEMBER _foundBoardTypeName                                          NOTIFY boardFound)
    Q_PROPERTY(bool                 pixhawkBoard                READ pixhawkBoard                                                   NOTIFY boardFound)
    Q_PROPERTY(bool                 px4FlowBoard                READ px4FlowBoard                                                   NOTIFY boardFound)
    Q_PROPERTY(FirmwareBuildType_t  selectedFirmwareBuildType   READ selectedFirmwareBuildType  WRITE setSelectedFirmwareBuildType  NOTIFY selectedFirmwareBuildTypeChanged)
    Q_PROPERTY(QStringList          apmFirmwareNames            MEMBER _apmFirmwareNames                                            NOTIFY apmFirmwareNamesChanged)
    Q_PROPERTY(QStringList          apmFirmwareUrls             MEMBER _apmFirmwareUrls                                             NOTIFY apmFirmwareNamesChanged)
    Q_PROPERTY(QString              px4StableVersion            READ px4StableVersion                                               NOTIFY px4StableVersionChanged)
    Q_PROPERTY(QString              px4BetaVersion              READ px4BetaVersion                                                 NOTIFY px4BetaVersionChanged)
100

101 102 103
    /// TextArea for log output
    Q_PROPERTY(QQuickItem* statusLog READ statusLog WRITE setStatusLog)
    
104 105
    /// Progress bar for you know what
    Q_PROPERTY(QQuickItem* progressBar READ progressBar WRITE setProgressBar)
106 107 108

    /// Starts searching for boards on the background thread
    Q_INVOKABLE void startBoardSearch(void);
109
    
110 111
    /// Cancels whatever state the upgrade worker thread is in
    Q_INVOKABLE void cancel(void);
112
    
113
    /// Called when the firmware type has been selected by the user to continue the flash process.
114
    Q_INVOKABLE void flash(AutoPilotStackType_t stackType,
115
                           FirmwareBuildType_t firmwareType = StableFirmware,
116
                           FirmwareVehicleType_t vehicleType = DefaultVehicleFirmware );
117

118 119
    Q_INVOKABLE void flashFirmwareUrl(QString firmwareUrl);

120
    /// Called to flash when upgrade is running in singleFirmwareMode
121
    Q_INVOKABLE void flashSingleFirmwareMode(FirmwareBuildType_t firmwareType);
122

123
    Q_INVOKABLE FirmwareVehicleType_t vehicleTypeFromFirmwareSelectionIndex(int index);
124
    
125 126 127
    // overload, not exposed to qml side
    void flash(const FirmwareIdentifier& firmwareId);

128
    // Property accessors
129
    
130 131 132
    QQuickItem* progressBar(void) { return _progressBar; }
    void setProgressBar(QQuickItem* progressBar) { _progressBar = progressBar; }
    
133 134 135
    QQuickItem* statusLog(void) { return _statusLog; }
    void setStatusLog(QQuickItem* statusLog) { _statusLog = statusLog; }
    
136 137
    QString boardPort(void) { return _foundBoardInfo.portName(); }
    QString boardDescription(void) { return _foundBoardInfo.description(); }
138

139 140 141
    FirmwareBuildType_t selectedFirmwareBuildType(void) { return _selectedFirmwareBuildType; }
    void setSelectedFirmwareBuildType(FirmwareBuildType_t firmwareType);
    QString firmwareTypeAsString(FirmwareBuildType_t type) const;
142

143 144
    QString     px4StableVersion    (void) { return _px4StableVersion; }
    QString     px4BetaVersion  (void) { return _px4BetaVersion; }
145

146 147 148
    bool pixhawkBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePixhawk; }
    bool px4FlowBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePX4Flow; }

149 150 151 152 153 154 155
    /**
     * @brief Return a human friendly string of available boards
     *
     * @return availableBoardNames
     */
    Q_INVOKABLE QStringList availableBoardsName(void);

156
signals:
157 158 159 160 161 162 163 164 165 166 167
    void boardFound                     (void);
    void noBoardFound                   (void);
    void boardGone                      (void);
    void flashComplete                  (void);
    void flashCancelled                 (void);
    void error                          (void);
    void selectedFirmwareBuildTypeChanged(FirmwareBuildType_t firmwareType);
    void apmFirmwareNamesChanged        (void);
    void px4StableVersionChanged        (const QString& px4StableVersion);
    void px4BetaVersionChanged          (const QString& px4BetaVersion);
    void downloadingFirmwareListChanged (bool downloadingFirmwareList);
168

169
private slots:
170 171 172
    void _firmwareDownloadProgress(qint64 curr, qint64 total);
    void _firmwareDownloadFinished(QString remoteFile, QString localFile);
    void _firmwareDownloadError(QString errorMsg);
173
    void _foundBoard(bool firstAttempt, const QSerialPortInfo& portInfo, int boardType, QString boardName);
174 175
    void _noBoardFound(void);
    void _boardGone();
176
    void _foundBootloader(int bootloaderVersion, int boardID, int flashSize);
177 178
    void _error(const QString& errorString);
    void _status(const QString& statusString);
179
    void _bootloaderSyncFailed(void);
180
    void _flashComplete(void);
181
    void _updateProgress(int curr, int total);
182 183
    void _eraseStarted(void);
    void _eraseComplete(void);
184
    void _eraseProgressTick(void);
185 186
    void _px4ReleasesGithubDownloadFinished(QString remoteFile, QString localFile);
    void _px4ReleasesGithubDownloadError(QString errorMsg);
187 188 189
    void _ardupilotManifestDownloadFinished(QString remoteFile, QString localFile);
    void _ardupilotManifestDownloadError(QString errorMsg);
    void _buildAPMFirmwareNames(void);
190 191

private:
192
    QHash<FirmwareIdentifier, QString>* _firmwareHashForBoardId(int boardId);
193 194 195 196 197 198 199
    void _getFirmwareFile(FirmwareIdentifier firmwareId);
    void _initFirmwareHash          (void);
    void _downloadFirmware          (void);
    void _appendStatusLog           (const QString& text, bool critical = false);
    void _errorCancel               (const QString& msg);
    void _determinePX4StableVersion (void);
    void _downloadArduPilotManifest (void);
200

201 202
    QString _singleFirmwareURL;
    bool    _singleFirmwareMode;
203
    bool    _downloadingFirmwareList;
204 205 206
    QString _portName;
    QString _portDescription;

207 208 209 210 211
    // Firmware hashes
    QHash<FirmwareIdentifier, QString> _rgFMUV5Firmware;
    QHash<FirmwareIdentifier, QString> _rgFMUV4PROFirmware;
    QHash<FirmwareIdentifier, QString> _rgFMUV4Firmware;
    QHash<FirmwareIdentifier, QString> _rgFMUV3Firmware;
Pritam Ghanghas's avatar
Pritam Ghanghas committed
212 213
    QHash<FirmwareIdentifier, QString> _rgPX4FMUV2Firmware;
    QHash<FirmwareIdentifier, QString> _rgAeroCoreFirmware;
214
    QHash<FirmwareIdentifier, QString> _rgAUAVX2_1Firmware;
Henry Zhang's avatar
Henry Zhang committed
215
    QHash<FirmwareIdentifier, QString> _rgMindPXFMUV2Firmware;
216 217
    QHash<FirmwareIdentifier, QString> _rgTAPV1Firmware;
    QHash<FirmwareIdentifier, QString> _rgASCV1Firmware;
218
    QHash<FirmwareIdentifier, QString> _rgCrazyflie2Firmware;
219
    QHash<FirmwareIdentifier, QString> _rgOmnibusF4SDFirmware;
220
    QHash<FirmwareIdentifier, QString> _rgFMUK66V3Firmware;
Pritam Ghanghas's avatar
Pritam Ghanghas committed
221 222 223
    QHash<FirmwareIdentifier, QString> _rgPX4FLowFirmware;
    QHash<FirmwareIdentifier, QString> _rg3DRRadioFirmware;

224 225 226 227
    // Hash map for ArduPilot ChibiOS lookup by board name
    QHash<FirmwareIdentifier, QString> _rgAPMChibiosReplaceNamedBoardFirmware;
    QHash<FirmwareIdentifier, QString> _rgFirmwareDynamic;

228
    QMap<FirmwareBuildType_t, QMap<FirmwareVehicleType_t, QString> > _apmVersionMap;
229 230
    QList<FirmwareVehicleType_t>                                _apmVehicleTypeFromCurrentVersionList;

231 232 233 234 235 236
    /// Information which comes back from the bootloader
    bool        _bootloaderFound;           ///< true: we have received the foundBootloader signals
    uint32_t    _bootloaderVersion;         ///< Bootloader version
    uint32_t    _bootloaderBoardID;         ///< Board ID
    uint32_t    _bootloaderBoardFlashSize;  ///< Flash size in bytes of board
    
237 238
    bool                 _startFlashWhenBootloaderFound;
    FirmwareIdentifier   _startFlashWhenBootloaderFoundFirmwareIdentity;
239 240 241 242 243 244 245 246

    QPixmap _boardIcon;             ///< Icon used to display image of board
    
    QString _firmwareFilename;      ///< Image which we are going to flash to the board
    
    QNetworkAccessManager*  _downloadManager;       ///< Used for firmware file downloading across the internet
    QNetworkReply*          _downloadNetworkReply;  ///< Used for firmware file downloading across the internet
    
Ricardo de Almeida Gonzaga's avatar
Ricardo de Almeida Gonzaga committed
247
    /// @brief Thread controller which is used to run bootloader commands on separate thread
248 249 250 251 252 253 254 255 256 257
    PX4FirmwareUpgradeThreadController* _threadController;
    
    static const int    _eraseTickMsec = 500;       ///< Progress bar update tick time for erase
    static const int    _eraseTotalMsec = 15000;    ///< Estimated amount of time erase takes
    int                 _eraseTickCount;            ///< Number of ticks for erase progress update
    QTimer              _eraseTimer;                ///< Timer used to update progress bar for erase

    static const int    _findBoardTimeoutMsec = 30000;      ///< Amount of time for user to plug in USB
    static const int    _findBootloaderTimeoutMsec = 5000;  ///< Amount time to look for bootloader
    
258
    QQuickItem*     _statusLog;         ///< Status log TextArea Qml control
259
    QQuickItem*     _progressBar;
260 261
    
    bool _searchingForBoard;    ///< true: searching for board, false: search for bootloader
262
    
263 264 265 266
    QSerialPortInfo                 _foundBoardInfo;
    QGCSerialPortInfo::BoardType_t  _foundBoardType;
    QString                         _foundBoardTypeName;

267
    FirmwareBuildType_t                  _selectedFirmwareBuildType;
268

269
    FirmwareImage*  _image;
Don Gagne's avatar
Don Gagne committed
270 271

    QString _px4StableVersion;  // Version strange for latest PX4 stable
272
    QString _px4BetaVersion;    // Version strange for latest PX4 beta
273 274

    const QString _apmBoardDescriptionReplaceText;
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299

    static const char* _manifestFirmwareJsonKey;
    static const char* _manifestBoardIdJsonKey;
    static const char* _manifestMavTypeJsonKey;
    static const char* _manifestFormatJsonKey;
    static const char* _manifestUrlJsonKey;
    static const char* _manifestMavFirmwareVersionTypeJsonKey;
    static const char* _manifestUSBIDJsonKey;
    static const char* _manifestMavFirmwareVersionJsonKey;
    static const char* _manifestBootloaderStrJsonKey;
    static const char* _manifestLatestKey;
    static const char* _manifestPlatformKey;
    static const char* _manifestBrandNameKey;

    typedef struct {
        uint32_t                boardId;
        FirmwareBuildType_t     firmwareBuildType;
        FirmwareVehicleType_t   vehicleType;
        QString                 url;
        QString                 version;
        QStringList             rgBootloaderPortString;
        QList<int>              rgVID;
        QList<int>              rgPID;
        QString                 friendlyName;
        bool                    chibios;
Don Gagne's avatar
Don Gagne committed
300
        bool                    fmuv2;
301 302 303 304 305 306 307 308 309 310 311 312 313
    } ManifestFirmwareInfo_t;


    QList<ManifestFirmwareInfo_t>           _rgManifestFirmwareInfo;
    QMap<QString, FirmwareBuildType_t>      _manifestMavFirmwareVersionTypeToFirmwareBuildTypeMap;
    QMap<QString, FirmwareVehicleType_t>    _manifestMavTypeToFirmwareVehicleTypeMap;
    QStringList                             _apmFirmwareNames;
    QStringList                             _apmFirmwareUrls;
    Fact*                                   _apmChibiOSSetting;
    Fact*                                   _apmVehicleTypeSetting;

    FirmwareBuildType_t     _manifestMavFirmwareVersionTypeToFirmwareBuildType  (const QString& manifestMavFirmwareVersionType);
    FirmwareVehicleType_t   _manifestMavTypeToFirmwareVehicleType               (const QString& manifestMavType);
314 315
};

316
// global hashing function
317
uint qHash(const FirmwareUpgradeController::FirmwareIdentifier& firmwareId);