Merge pull request #8886 from DonLakeFlyer/FlashRework

Major rework of flash to prevent SiK radio bricking in bootloader mode

src/VehicleSetup/FirmwareUpgrade.qml

@@ -245,11 +245,6 @@ SetupPage {
                         cancelFlash()
                     }
 
-                    Connections {
-                        target:         firmwarePage
-                        onCancelDialog: reject()
-                    }
-
                     ListModel {
                         id: firmwareBuildTypeList
 

src/VehicleSetup/FirmwareUpgradeController.cc

@@ -84,8 +84,7 @@ FirmwareUpgradeController::FirmwareUpgradeController(void)
     connect(_threadController, &PX4FirmwareUpgradeThreadController::foundBoard,             this, &FirmwareUpgradeController::_foundBoard);
     connect(_threadController, &PX4FirmwareUpgradeThreadController::noBoardFound,           this, &FirmwareUpgradeController::_noBoardFound);
     connect(_threadController, &PX4FirmwareUpgradeThreadController::boardGone,              this, &FirmwareUpgradeController::_boardGone);
-    connect(_threadController, &PX4FirmwareUpgradeThreadController::foundBootloader,        this, &FirmwareUpgradeController::_foundBootloader);
-    connect(_threadController, &PX4FirmwareUpgradeThreadController::bootloaderSyncFailed,   this, &FirmwareUpgradeController::_bootloaderSyncFailed);
+    connect(_threadController, &PX4FirmwareUpgradeThreadController::foundBoardInfo,         this, &FirmwareUpgradeController::_foundBoardInfo);
     connect(_threadController, &PX4FirmwareUpgradeThreadController::error,                  this, &FirmwareUpgradeController::_error);
     connect(_threadController, &PX4FirmwareUpgradeThreadController::updateProgress,         this, &FirmwareUpgradeController::_updateProgress);
     connect(_threadController, &PX4FirmwareUpgradeThreadController::status,                 this, &FirmwareUpgradeController::_status);
@@ -193,15 +192,15 @@ QStringList FirmwareUpgradeController::availableBoardsName(void)
 
 void FirmwareUpgradeController::_foundBoard(bool firstAttempt, const QSerialPortInfo& info, int boardType, QString boardName)
 {
-    _foundBoardInfo =       info;
-    _foundBoardType =       static_cast<QGCSerialPortInfo::BoardType_t>(boardType);
-    _foundBoardTypeName =   boardName;
+    _boardInfo      = info;
+    _boardType      = static_cast<QGCSerialPortInfo::BoardType_t>(boardType);
+    _boardTypeName  = boardName;
 
     qDebug() << info.manufacturer() << info.description();
 
     _startFlashWhenBootloaderFound = false;
 
-    if (_foundBoardType == QGCSerialPortInfo::BoardTypeSiKRadio) {
+    if (_boardType == QGCSerialPortInfo::BoardTypeSiKRadio) {
         if (!firstAttempt) {
             // Radio always flashes latest firmware, so we can start right away without
             // any further user input.
@@ -212,7 +211,7 @@ void FirmwareUpgradeController::_foundBoard(bool firstAttempt, const QSerialPort
         }
     }
     
-    qCDebug(FirmwareUpgradeLog) << _foundBoardType << _foundBoardTypeName;
+    qCDebug(FirmwareUpgradeLog) << _boardType << _boardTypeName;
     emit boardFound();
 }
 
@@ -229,12 +228,12 @@ void FirmwareUpgradeController::_boardGone(void)
 
 /// @brief Called when the bootloader is connected to by the findBootloader process. Moves the state machine
 ///         to the next step.
-void FirmwareUpgradeController::_foundBootloader(int bootloaderVersion, int boardID, int flashSize)
+void FirmwareUpgradeController::_foundBoardInfo(int bootloaderVersion, int boardID, int flashSize)
 {
-    _bootloaderFound = true;
-    _bootloaderVersion = static_cast<uint32_t>(bootloaderVersion);
-    _bootloaderBoardID = static_cast<uint32_t>(boardID);
-    _bootloaderBoardFlashSize = static_cast<uint32_t>(flashSize);
+    _bootloaderFound            = true;
+    _bootloaderVersion          = static_cast<uint32_t>(bootloaderVersion);
+    _bootloaderBoardID          = static_cast<uint32_t>(boardID);
+    _bootloaderBoardFlashSize   = static_cast<uint32_t>(flashSize);
     
     _appendStatusLog(tr("Connected to bootloader:"));
     _appendStatusLog(tr("  Version: %1").arg(_bootloaderVersion));
@@ -747,9 +746,9 @@ void FirmwareUpgradeController::_buildAPMFirmwareNames(void)
 
     bool                    chibios =           _apmChibiOSSetting->rawValue().toInt() == 0;
     FirmwareVehicleType_t   vehicleType =       static_cast<FirmwareVehicleType_t>(_apmVehicleTypeSetting->rawValue().toInt());
-    QString                 boardDescription =  _foundBoardInfo.description();
-    quint16                 boardVID =          _foundBoardInfo.vendorIdentifier();
-    quint16                 boardPID =          _foundBoardInfo.productIdentifier();
+    QString                 boardDescription =  _boardInfo.description();
+    quint16                 boardVID =          _boardInfo.vendorIdentifier();
+    quint16                 boardPID =          _boardInfo.productIdentifier();
     uint32_t                rawBoardId =        _bootloaderBoardID == Bootloader::boardIDPX4FMUV3 ? Bootloader::boardIDPX4FMUV2 : _bootloaderBoardID;
 
     qCDebug(FirmwareUpgradeLog) << QStringLiteral("_buildAPMFirmwareNames description(%1) vid(%2/0x%3) pid(%4/0x%5)").arg(boardDescription).arg(boardVID).arg(boardVID, 1, 16).arg(boardPID).arg(boardPID, 1, 16);

src/VehicleSetup/FirmwareUpgradeController.h

@@ -89,7 +89,7 @@ public:
     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(QString              boardType                   MEMBER _boardTypeName                                               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)
@@ -134,8 +134,8 @@ public:
     QQuickItem* statusLog(void) { return _statusLog; }
     void setStatusLog(QQuickItem* statusLog) { _statusLog = statusLog; }
     
-    QString boardPort(void) { return _foundBoardInfo.portName(); }
-    QString boardDescription(void) { return _foundBoardInfo.description(); }
+    QString boardPort(void) { return _boardInfo.portName(); }
+    QString boardDescription(void) { return _boardInfo.description(); }
 
     FirmwareBuildType_t selectedFirmwareBuildType(void) { return _selectedFirmwareBuildType; }
     void setSelectedFirmwareBuildType(FirmwareBuildType_t firmwareType);
@@ -144,8 +144,8 @@ public:
     QString     px4StableVersion    (void) { return _px4StableVersion; }
     QString     px4BetaVersion  (void) { return _px4BetaVersion; }
 
-    bool pixhawkBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePixhawk; }
-    bool px4FlowBoard(void) const { return _foundBoardType == QGCSerialPortInfo::BoardTypePX4Flow; }
+    bool pixhawkBoard(void) const { return _boardType == QGCSerialPortInfo::BoardTypePixhawk; }
+    bool px4FlowBoard(void) const { return _boardType == QGCSerialPortInfo::BoardTypePX4Flow; }
 
     /**
      * @brief Return a human friendly string of available boards
@@ -175,7 +175,7 @@ private slots:
     void _foundBoard(bool firstAttempt, const QSerialPortInfo& portInfo, int boardType, QString boardName);
     void _noBoardFound(void);
     void _boardGone();
-    void _foundBootloader(int bootloaderVersion, int boardID, int flashSize);
+    void _foundBoardInfo(int bootloaderVersion, int boardID, int flashSize);
     void _error(const QString& errorString);
     void _status(const QString& statusString);
     void _bootloaderSyncFailed(void);
@@ -266,13 +266,13 @@ private:
     
     bool _searchingForBoard;    ///< true: searching for board, false: search for bootloader
     
-    QSerialPortInfo                 _foundBoardInfo;
-    QGCSerialPortInfo::BoardType_t  _foundBoardType;
-    QString                         _foundBoardTypeName;
+    QSerialPortInfo                 _boardInfo;
+    QGCSerialPortInfo::BoardType_t  _boardType;
+    QString                         _boardTypeName;
 
-    FirmwareBuildType_t                  _selectedFirmwareBuildType;
+    FirmwareBuildType_t             _selectedFirmwareBuildType;
 
-    FirmwareImage*  _image;
+    FirmwareImage*                  _image;
 
     QString _px4StableVersion;  // Version strange for latest PX4 stable
     QString _px4BetaVersion;    // Version strange for latest PX4 beta

src/VehicleSetup/PX4FirmwareUpgradeThread.h

@@ -41,44 +41,39 @@ public:
     ~PX4FirmwareUpgradeThreadWorker();
     
 signals:
-    void updateProgress(int curr, int total);
-    void foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString boardName);
-    void noBoardFound(void);
-    void boardGone(void);
-    void foundBootloader(int bootloaderVersion, int boardID, int flashSize);
-    void bootloaderSyncFailed(void);
-    void error(const QString& errorString);
-    void status(const QString& statusText);
-    void eraseStarted(void);
-    void eraseComplete(void);
-    void flashComplete(void);
+    void updateProgress         (int curr, int total);
+    void foundBoard             (bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, 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& statusText);
+    void eraseStarted           (void);
+    void eraseComplete          (void);
+    void flashComplete          (void);
     
 private slots:
-    void _init(void);
+    void _init              (void);
     void _startFindBoardLoop(void);
-    void _reboot(void);
-    void _flash(void);
-    void _findBoardOnce(void);
-    void _updateProgress(int curr, int total) { emit updateProgress(curr, total); }
-    void _cancel(void);
+    void _reboot            (void);
+    void _flash             (void);
+    void _findBoardOnce     (void);
+    void _updateProgress    (int curr, int total) { emit updateProgress(curr, total); }
+    void _cancel            (void);
     
 private:
     bool _findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType, QString& boardName);
-    bool _findBootloader(const QGCSerialPortInfo& portInfo, bool radioMode, bool errorOnNotFound);
-    void _3drRadioForceBootloader(const QGCSerialPortInfo& portInfo);
-    bool _erase(void);
+    bool _erase             (void);
     
     PX4FirmwareUpgradeThreadController* _controller;
     
-    Bootloader*      _bootloader;
-    QSerialPort*     _bootloaderPort;
-    QTimer*             _timerRetry;
+    Bootloader*         _bootloader             = nullptr;
+    QTimer*             _findBoardTimer         = nullptr;
     QTime               _elapsed;
-    static const int    _retryTimeout = 100;
-    
-    bool                _foundBoard;            ///< true: board is currently connected
-    bool                _findBoardFirstAttempt; ///< true: this is our first try looking for a board
-    QGCSerialPortInfo   _foundBoardPortInfo;    ///< port info for found board
+    bool                _foundBoard             = false;
+    bool                _boardIsSiKRadio        = false;
+    bool                _findBoardFirstAttempt  = true;     ///< true: we found the board right away, it needs to be unplugged and plugged back in
+    QGCSerialPortInfo   _foundBoardPortInfo;                ///< port info for found board
 };
 
 /// @brief Provides methods to interact with the bootloader. The commands themselves are signalled
@@ -105,58 +100,40 @@ public:
     const FirmwareImage* image(void) { return _image; }
     
 signals:
-    /// @brief Emitted by the find board process when it finds a board.
-    void foundBoard(bool firstAttempt, const QGCSerialPortInfo &portInfo, int boardType, QString boardName);
-    
-    void noBoardFound(void);
-    
-    /// @brief Emitted by the find board process when a board it previously reported as found disappears.
-    void boardGone(void);
-    
-    /// @brief Emitted by the findBootloader process when has a connection to the bootloader
-    void foundBootloader(int bootloaderVersion, int boardID, int flashSize);
-    
-    /// @brief Emitted by the bootloader commands when an error occurs.
-    void error(const QString& errorString);
-    
-    void status(const QString& status);
-    
-    /// @brief Signalled when the findBootloader process connects to the port, but cannot sync to the
-    ///         bootloader.
-    void bootloaderSyncFailed(void);
-    
-    void eraseStarted(void);
-    void eraseComplete(void);
-    
-    void flashComplete(void);
-    
-    /// @brief Signalled to update progress for long running bootloader commands
-    void updateProgress(int curr, int total);
+    void foundBoard     (bool firstAttempt, const QGCSerialPortInfo &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& status);
+    void eraseStarted   (void);
+    void eraseComplete  (void);
+    void flashComplete  (void);
+    void updateProgress (int curr, int total);
     
     // Internal signals to communicate with thread worker
-    void _initThreadWorker(void);
+    void _initThreadWorker          (void);
     void _startFindBoardLoopOnThread(void);
-    void _rebootOnThread(void);
-    void _flashOnThread(void);
-    void _cancel(void);
+    void _rebootOnThread            (void);
+    void _flashOnThread             (void);
+    void _cancel                    (void);
     
 private slots:
-    void _foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString name) { emit foundBoard(firstAttempt, portInfo, type, name); }
-    void _noBoardFound(void) { emit noBoardFound(); }
-    void _boardGone(void) { emit boardGone(); }
-    void _foundBootloader(int bootloaderVersion, int boardID, int flashSize) { emit foundBootloader(bootloaderVersion, boardID, flashSize); }
-    void _bootloaderSyncFailed(void) { emit bootloaderSyncFailed(); }
-    void _error(const QString& errorString) { emit error(errorString); }
-    void _status(const QString& statusText) { emit status(statusText); }
-    void _eraseStarted(void) { emit eraseStarted(); }
-    void _eraseComplete(void) { emit eraseComplete(); }
-    void _flashComplete(void) { emit flashComplete(); }
+    void _foundBoard            (bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString name) { emit foundBoard(firstAttempt, portInfo, type, name); }
+    void _noBoardFound          (void) { emit noBoardFound(); }
+    void _boardGone             (void) { emit boardGone(); }
+    void _foundBoardInfo        (int bootloaderVersion, int boardID, int flashSize) { emit foundBoardInfo(bootloaderVersion, boardID, flashSize); }
+    void _error                 (const QString& errorString) { emit error(errorString); }
+    void _status                (const QString& statusText) { emit status(statusText); }
+    void _eraseStarted          (void) { emit eraseStarted(); }
+    void _eraseComplete         (void) { emit eraseComplete(); }
+    void _flashComplete         (void) { emit flashComplete(); }
     
 private:
     void _updateProgress(int curr, int total) { emit updateProgress(curr, total); }
     
-    PX4FirmwareUpgradeThreadWorker* _worker;
-    QThread*                        _workerThread;  ///< Thread which PX4FirmwareUpgradeThreadWorker runs on
+    PX4FirmwareUpgradeThreadWorker* _worker         = nullptr;
+    QThread*                        _workerThread   = nullptr;  ///< Thread which PX4FirmwareUpgradeThreadWorker runs on
     
     const FirmwareImage* _image;
 };