PX4FirmwareUpgradeThread.h 6.13 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 11

/// @file
Ricardo de Almeida Gonzaga's avatar
Ricardo de Almeida Gonzaga committed
12
///     @brief PX4 Firmware Upgrade operations which occur on a separate thread.
13 14 15 16 17
///     @author Don Gagne <don@thegagnes.com>

#ifndef PX4FirmwareUpgradeThread_H
#define PX4FirmwareUpgradeThread_H

18 19
#include "Bootloader.h"
#include "FirmwareImage.h"
Don Gagne's avatar
Don Gagne committed
20
#include "QGCSerialPortInfo.h"
21

22 23 24 25
#include <QObject>
#include <QThread>
#include <QTimer>
#include <QTime>
26
#include <QSerialPort>
27

28 29
#include <stdint.h>

30
class PX4FirmwareUpgradeThreadController;
31

Ricardo de Almeida Gonzaga's avatar
Ricardo de Almeida Gonzaga committed
32
/// @brief Used to run bootloader commands on a separate thread. These routines are mainly meant to to be called
33 34 35 36 37 38 39
///         internally by the PX4FirmwareUpgradeThreadController. Clients should call the various public methods
///         exposed by PX4FirmwareUpgradeThreadController.
class PX4FirmwareUpgradeThreadWorker : public QObject
{
    Q_OBJECT
    
public:
40
    PX4FirmwareUpgradeThreadWorker(PX4FirmwareUpgradeThreadController* controller);
41 42 43
    ~PX4FirmwareUpgradeThreadWorker();
    
signals:
44
    void updateProgress(int curr, int total);
45
    void foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString boardName);
46 47
    void noBoardFound(void);
    void boardGone(void);
48 49
    void foundBootloader(int bootloaderVersion, int boardID, int flashSize);
    void bootloaderSyncFailed(void);
50 51 52 53 54
    void error(const QString& errorString);
    void status(const QString& statusText);
    void eraseStarted(void);
    void eraseComplete(void);
    void flashComplete(void);
55 56
    
private slots:
57 58 59 60
    void _init(void);
    void _startFindBoardLoop(void);
    void _reboot(void);
    void _flash(void);
61
    void _findBoardOnce(void);
62 63
    void _updateProgress(int curr, int total) { emit updateProgress(curr, total); }
    void _cancel(void);
64 65
    
private:
66
    bool _findBoardFromPorts(QGCSerialPortInfo& portInfo, QGCSerialPortInfo::BoardType_t& boardType, QString& boardName);
Don Gagne's avatar
Don Gagne committed
67 68
    bool _findBootloader(const QGCSerialPortInfo& portInfo, bool radioMode, bool errorOnNotFound);
    void _3drRadioForceBootloader(const QGCSerialPortInfo& portInfo);
69 70 71 72 73
    bool _erase(void);
    
    PX4FirmwareUpgradeThreadController* _controller;
    
    Bootloader*      _bootloader;
74
    QSerialPort*     _bootloaderPort;
75 76
    QTimer*             _timerRetry;
    QTime               _elapsed;
77
    static const int    _retryTimeout = 100;
78 79 80
    
    bool                _foundBoard;            ///< true: board is currently connected
    bool                _findBoardFirstAttempt; ///< true: this is our first try looking for a board
Don Gagne's avatar
Don Gagne committed
81
    QGCSerialPortInfo   _foundBoardPortInfo;    ///< port info for found board
82 83 84
};

/// @brief Provides methods to interact with the bootloader. The commands themselves are signalled
Ricardo de Almeida Gonzaga's avatar
Ricardo de Almeida Gonzaga committed
85
///         across to PX4FirmwareUpgradeThreadWorker so that they run on the separate thread.
86 87 88 89 90
class PX4FirmwareUpgradeThreadController : public QObject
{
    Q_OBJECT
    
public:
91
    PX4FirmwareUpgradeThreadController(QObject* parent = nullptr);
92 93
    ~PX4FirmwareUpgradeThreadController(void);
    
94 95 96
    /// @brief Begins the process of searching for a supported board connected to any serial port. This will
    /// continue until cancelFind is called. Signals foundBoard and boardGone as boards come and go.
    void startFindBoardLoop(void);
97
    
98
    void cancel(void);
99 100
    
    /// @brief Sends a reboot command to the bootloader
101
    void reboot(void) { emit _rebootOnThread(); }
102
    
103
    void flash(const FirmwareImage* image);
104
    
105
    const FirmwareImage* image(void) { return _image; }
106 107
    
signals:
108
    /// @brief Emitted by the find board process when it finds a board.
109
    void foundBoard(bool firstAttempt, const QGCSerialPortInfo &portInfo, int boardType, QString boardName);
110 111 112 113 114
    
    void noBoardFound(void);
    
    /// @brief Emitted by the find board process when a board it previously reported as found disappears.
    void boardGone(void);
115 116 117 118 119
    
    /// @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.
120 121 122
    void error(const QString& errorString);
    
    void status(const QString& status);
123 124 125 126 127
    
    /// @brief Signalled when the findBootloader process connects to the port, but cannot sync to the
    ///         bootloader.
    void bootloaderSyncFailed(void);
    
128 129
    void eraseStarted(void);
    void eraseComplete(void);
130
    
131
    void flashComplete(void);
132 133 134 135
    
    /// @brief Signalled to update progress for long running bootloader commands
    void updateProgress(int curr, int total);
    
136
    // Internal signals to communicate with thread worker
137
    void _initThreadWorker(void);
138 139 140 141
    void _startFindBoardLoopOnThread(void);
    void _rebootOnThread(void);
    void _flashOnThread(void);
    void _cancel(void);
142 143
    
private slots:
144
    void _foundBoard(bool firstAttempt, const QGCSerialPortInfo& portInfo, int type, QString name) { emit foundBoard(firstAttempt, portInfo, type, name); }
145 146 147 148 149 150 151 152 153
    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(); }
154 155
    
private:
156 157
    void _updateProgress(int curr, int total) { emit updateProgress(curr, total); }
    
158 159
    PX4FirmwareUpgradeThreadWorker* _worker;
    QThread*                        _workerThread;  ///< Thread which PX4FirmwareUpgradeThreadWorker runs on
160 161
    
    const FirmwareImage* _image;
162 163 164
};

#endif