FirmwareUpgradeController.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtCore/QTimer>
#include <QtGui/QPixmap>
#include <QtQmlIntegration/QtQmlIntegration>
#include <QtQuick/QQuickItem>
 
#include "QGCSerialPortInfo.h"
 
class QGCFileDownload;
 
class PX4FirmwareUpgradeThread;
class PX4FirmwareUpgradeThreadController;
class FirmwareImage;
class Fact;
 
 
// Firmware Upgrade MVC Controller for FirmwareUpgrade.qml.
class FirmwareUpgradeController : public QObject
{
    Q_OBJECT
    QML_ELEMENT
#ifdef QGC_UNITTEST_BUILD
    friend class FirmwareUpgradeControllerTest; // Unit test
#endif
public:
        typedef enum {
            AutoPilotStackPX4 = 0,
            AutoPilotStackAPM,
            SiKRadio,
            SingleFirmwareMode
        } AutoPilotStackType_t;
 
        typedef enum {
            StableFirmware = 0,
            BetaFirmware,
            DeveloperFirmware,
            CustomFirmware
        } FirmwareBuildType_t;
 
        typedef enum {
            CopterFirmware = 0,
            HeliFirmware,
            PlaneFirmware,
            RoverFirmware,
            SubFirmware,
            DefaultVehicleFirmware
        } FirmwareVehicleType_t;
 
        Q_ENUM(AutoPilotStackType_t)
        Q_ENUM(FirmwareBuildType_t)
        Q_ENUM(FirmwareVehicleType_t)
 
    class FirmwareIdentifier
    {
    public:
        FirmwareIdentifier(AutoPilotStackType_t stack = AutoPilotStackPX4,
                           FirmwareBuildType_t firmware = StableFirmware,
                           FirmwareVehicleType_t vehicle = DefaultVehicleFirmware)
            : autopilotStackType(stack), firmwareType(firmware), firmwareVehicleType(vehicle) {}
 
        bool operator==(const FirmwareIdentifier& firmwareId) const
        {
            return (firmwareId.autopilotStackType == autopilotStackType &&
                    firmwareId.firmwareType == firmwareType &&
                    firmwareId.firmwareVehicleType == firmwareVehicleType);
        }
 
        // members
        AutoPilotStackType_t    autopilotStackType;
        FirmwareBuildType_t     firmwareType;
        FirmwareVehicleType_t   firmwareVehicleType;
    };
 
    FirmwareUpgradeController(void);
    ~FirmwareUpgradeController();
 
    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 _boardTypeName                                               NOTIFY boardFound)
    Q_PROPERTY(bool                 pixhawkBoard                READ pixhawkBoard                                                   NOTIFY boardFound)
    Q_PROPERTY(FirmwareBuildType_t  selectedFirmwareBuildType   READ selectedFirmwareBuildType  WRITE setSelectedFirmwareBuildType  NOTIFY selectedFirmwareBuildTypeChanged)
    Q_PROPERTY(QStringList          apmFirmwareNames            MEMBER _apmFirmwareNames                                            NOTIFY apmFirmwareNamesChanged)
    Q_PROPERTY(int                  apmFirmwareNamesBestIndex   MEMBER _apmFirmwareNamesBestIndex                                   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)
    Q_PROPERTY(QVariantList         availablePorts              MEMBER _availablePorts                                              NOTIFY availablePortsChanged)
 
    
    Q_PROPERTY(QQuickItem* statusLog READ statusLog WRITE setStatusLog)
 
    
    Q_PROPERTY(QQuickItem* progressBar READ progressBar WRITE setProgressBar)
 
    
    Q_INVOKABLE void startBoardSearch(void);
 
    Q_INVOKABLE void flashPort(const QString& systemLocation);
 
    Q_INVOKABLE void cancel(void);
 
    Q_INVOKABLE void flash(AutoPilotStackType_t stackType,
                           FirmwareBuildType_t firmwareType = StableFirmware,
                           FirmwareVehicleType_t vehicleType = DefaultVehicleFirmware );
 
    Q_INVOKABLE void flashFirmwareUrl(QString firmwareUrl);
 
    Q_INVOKABLE void flashSingleFirmwareMode(FirmwareBuildType_t firmwareType);
 
    Q_INVOKABLE FirmwareVehicleType_t vehicleTypeFromFirmwareSelectionIndex(int index);
 
    // overload, not exposed to qml side
    void flash(const FirmwareIdentifier& firmwareId);
 
    // Property accessors
 
    QQuickItem* progressBar(void) { return _progressBar; }
    void setProgressBar(QQuickItem* progressBar) { _progressBar = progressBar; }
 
    QQuickItem* statusLog(void) { return _statusLog; }
    void setStatusLog(QQuickItem* statusLog) { _statusLog = statusLog; }
 
    QString boardPort(void) { return _boardInfo.portName(); }
    QString boardDescription(void) { return _boardInfo.description(); }
 
    FirmwareBuildType_t selectedFirmwareBuildType(void) { return _selectedFirmwareBuildType; }
    void setSelectedFirmwareBuildType(FirmwareBuildType_t firmwareType);
    QString firmwareTypeAsString(FirmwareBuildType_t type) const;
 
    QString     px4StableVersion    (void) { return _px4StableVersion; }
    QString     px4BetaVersion  (void) { return _px4BetaVersion; }
 
    bool pixhawkBoard(void) const { return _boardType == QGCSerialPortInfo::BoardTypePixhawk; }
 
    Q_INVOKABLE QStringList availableBoardsName(void);
 
signals:
    void boardFound                     (void);
    void showFirmwareSelectDlg          (void);
    void noBoardFound                   (void);
    void boardGone                      (void);
    void flashComplete                  (void);
    void flashCancelled                 (void);
    void error                          (void);
    void eraseStarted                   (void);
    void selectedFirmwareBuildTypeChanged(FirmwareBuildType_t firmwareType);
    void apmFirmwareNamesChanged        (void);
    void px4StableVersionChanged        (const QString& px4StableVersion);
    void px4BetaVersionChanged          (const QString& px4BetaVersion);
    void downloadingFirmwareListChanged (bool downloadingFirmwareList);
    void availablePortsChanged          (void);
 
private slots:
    void _firmwareDownloadProgress          (qint64 curr, qint64 total);
    void _firmwareDownloadComplete          (bool success, const QString &localFile, const QString &errorMsg);
    void _foundBoard                        (bool firstAttempt, const QSerialPortInfo& portInfo, int boardType, QString boardName);
    void _noBoardFound                      (void);
    void _boardGone                         (void);
    void _foundBoardInfo                    (int bootloaderVersion, int boardID, int flashSize);
    void _error                             (const QString& errorString);
    void _status                            (const QString& statusString);
    void _bootloaderSyncFailed              (void);
    void _flashComplete                     (void);
    void _updateProgress                    (int curr, int total);
    void _eraseStarted                      (void);
    void _eraseComplete                     (void);
    void _eraseProgressTick                 (void);
    void _px4ReleasesGithubDownloadComplete (bool success, const QString &localFile, const QString &errorMsg);
    void _ardupilotManifestDownloadComplete (bool success, const QString &localFile, const QString &errorMsg);
    void _buildAPMFirmwareNames             (void);
    void _portsAvailable                    (const QVariantList& ports);
 
private:
    QHash<FirmwareIdentifier, QString>* _firmwareHashForBoardId(int boardId);
    void _getFirmwareFile           (FirmwareIdentifier firmwareId);
    void _downloadFirmware          (void);
    void _appendStatusLog           (const QString& text, bool critical = false);
    void _errorCancel               (const QString& msg);
    void _determinePX4StableVersion (void);
    void _downloadArduPilotManifest (void);
 
    QString _singleFirmwareURL;
    bool    _singleFirmwareMode;
    bool    _downloadingFirmwareList;
    QString _portName;
    QString _portDescription;
 
    // Firmware hashes
    QHash<FirmwareIdentifier, QString> _rgSiKRadioFirmware;
 
    // Hash map for ArduPilot ChibiOS lookup by board name
    QHash<FirmwareIdentifier, QString> _rgAPMChibiosReplaceNamedBoardFirmware;
    QHash<FirmwareIdentifier, QString> _rgFirmwareDynamic;
 
    QMap<FirmwareBuildType_t, QMap<FirmwareVehicleType_t, QString> > _apmVersionMap;
    QList<FirmwareVehicleType_t>                                _apmVehicleTypeFromCurrentVersionList;
 
    bool        _bootloaderFound;           
    uint32_t    _bootloaderVersion;         
    uint32_t    _bootloaderBoardID;         
    uint32_t    _bootloaderBoardFlashSize;  
 
    bool                 _startFlashWhenBootloaderFound;
    FirmwareIdentifier   _startFlashWhenBootloaderFoundFirmwareIdentity;
 
    QPixmap _boardIcon;             
 
    QString _firmwareFilename;      
 
    PX4FirmwareUpgradeThreadController* _threadController;
 
    static const int    _eraseTickMsec = 500;       
    static const int    _eraseTotalMsec = 15000;    
    int                 _eraseTickCount;            
    QTimer              _eraseTimer;                
 
    static const int    _findBoardTimeoutMsec = 30000;      
    static const int    _findBootloaderTimeoutMsec = 5000;  
 
    QQuickItem*     _statusLog;         
    QQuickItem*     _progressBar;
 
    bool _searchingForBoard;    
 
    QSerialPortInfo                 _boardInfo;
    QGCSerialPortInfo::BoardType_t  _boardType;
    QString                         _boardTypeName;
 
    FirmwareBuildType_t             _selectedFirmwareBuildType;
 
    FirmwareImage*                  _image;
 
    QString _px4StableVersion;  // Version strange for latest PX4 stable
    QString _px4BetaVersion;    // Version strange for latest PX4 beta
 
    const QString _apmBoardDescriptionReplaceText;
 
    static constexpr const char* _manifestFirmwareJsonKey =               "firmware";
    static constexpr const char* _manifestBoardIdJsonKey =                "board_id";
    static constexpr const char* _manifestMavTypeJsonKey =                "mav-type";
    static constexpr const char* _manifestFormatJsonKey =                 "format";
    static constexpr const char* _manifestUrlJsonKey =                    "url";
    static constexpr const char* _manifestMavFirmwareVersionTypeJsonKey = "mav-firmware-version-type";
    static constexpr const char* _manifestUSBIDJsonKey =                  "USBID";
    static constexpr const char* _manifestMavFirmwareVersionJsonKey =     "mav-firmware-version";
    static constexpr const char* _manifestBootloaderStrJsonKey =          "bootloader_str";
    static constexpr const char* _manifestLatestKey =                     "latest";
    static constexpr const char* _manifestPlatformKey =                   "platform";
    static constexpr const char* _manifestBrandNameKey =                  "brand_name";
 
    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;
        bool                    fmuv2;
    } ManifestFirmwareInfo_t;
 
 
    QList<ManifestFirmwareInfo_t>           _rgManifestFirmwareInfo;
    QMap<QString, FirmwareBuildType_t>      _manifestMavFirmwareVersionTypeToFirmwareBuildTypeMap;
    QMap<QString, FirmwareVehicleType_t>    _manifestMavTypeToFirmwareVehicleTypeMap;
    QStringList                             _apmFirmwareNames;
    int                                     _apmFirmwareNamesBestIndex = 0;
    QStringList                             _apmFirmwareUrls;
    Fact*                                   _apmChibiOSSetting;
    Fact*                                   _apmVehicleTypeSetting;
    QVariantList                            _availablePorts;
    QPointer<QGCFileDownload>               _activeDownloader;          
    bool                                    _flashCancelled = false;    
 
    FirmwareBuildType_t     _manifestMavFirmwareVersionTypeToFirmwareBuildType  (const QString& manifestMavFirmwareVersionType);
    FirmwareVehicleType_t   _manifestMavTypeToFirmwareVehicleType               (const QString& manifestMavType);
};
 
// global hashing function
uint qHash(const FirmwareUpgradeController::FirmwareIdentifier& firmwareId);