LogReplayLink.h 7.67 KB
Newer Older
1 2
/****************************************************************************
 *
3
 *   (c) 2009-2018 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
4 5 6 7 8
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
Don Gagne's avatar
Don Gagne committed
9

10
#pragma once
Don Gagne's avatar
Don Gagne committed
11

12
#include "LinkManager.h"
Don Gagne's avatar
Don Gagne committed
13 14 15 16 17 18 19
#include "MAVLinkProtocol.h"

#include <QTimer>
#include <QFile>

class LogReplayLinkConfiguration : public LinkConfiguration
{
Don Gagne's avatar
Don Gagne committed
20 21
    Q_OBJECT

Don Gagne's avatar
Don Gagne committed
22
public:
23 24
    Q_PROPERTY(QString  fileName    READ logFilename    WRITE setLogFilename    NOTIFY fileNameChanged)

Don Gagne's avatar
Don Gagne committed
25 26
    LogReplayLinkConfiguration(const QString& name);
    LogReplayLinkConfiguration(LogReplayLinkConfiguration* copy);
27

Don Gagne's avatar
Don Gagne committed
28
    QString logFilename(void) { return _logFilename; }
29
    void setLogFilename(const QString logFilename) { _logFilename = logFilename; emit fileNameChanged(); }
30

Don Gagne's avatar
Don Gagne committed
31 32 33
    QString logFilenameShort(void);

    // Virtuals from LinkConfiguration
34 35 36 37 38
    LinkType    type                    () { return LinkConfiguration::TypeLogReplay; }
    void        copyFrom                (LinkConfiguration* source);
    void        loadSettings            (QSettings& settings, const QString& root);
    void        saveSettings            (QSettings& settings, const QString& root);
    void        updateSettings          ();
39
    QString     settingsURL             () { return "LogReplaySettings.qml"; }
40
    QString     settingsTitle           () { return tr("Log Replay Link Settings"); }
41

42 43
signals:
    void fileNameChanged();
Don Gagne's avatar
Don Gagne committed
44 45 46 47 48 49 50 51 52 53 54

private:
    static const char*  _logFilenameKey;
    QString             _logFilename;
};

class LogReplayLink : public LinkInterface
{
    Q_OBJECT

    friend class LinkManager;
55

Don Gagne's avatar
Don Gagne committed
56 57 58
public:
    /// @return true: log is currently playing, false: log playback is paused
    bool isPlaying(void) { return _readTickTimer.isActive(); }
59

60 61 62
    void play           (void) { emit _playOnThread(); }
    void pause          (void) { emit _pauseOnThread(); }
    void movePlayhead   (qreal percentComplete);
63

Don Gagne's avatar
Don Gagne committed
64
    // Virtuals from LinkInterface
65 66 67 68 69 70
    virtual QString getName             (void) const { return _config->name(); }
    virtual void    requestReset        (void){ }
    virtual bool    isConnected         (void) const { return _connected; }
    virtual qint64  getConnectionSpeed  (void) const { return 100000000; }
    virtual qint64  bytesAvailable      (void) { return 0; }
    virtual bool    isLogReplay         (void) { return true; }
Don Gagne's avatar
Don Gagne committed
71 72 73

    // These are left unimplemented in order to cause linker errors which indicate incorrect usage of
    // connect/disconnect on link directly. All connect/disconnect calls should be made through LinkManager.
74 75 76 77 78 79
    bool connect    (void);
    bool disconnect (void);

public slots:
    /// Sets the acceleration factor: -100: 0.01X, 0: 1.0X, 100: 100.0X
    void setPlaybackSpeed(qreal playbackSpeed) { emit _setPlaybackSpeedOnThread(playbackSpeed); }
Don Gagne's avatar
Don Gagne committed
80

81
private slots:
82
    virtual void _writeBytes(const QByteArray bytes);
83

Don Gagne's avatar
Don Gagne committed
84
signals:
85 86 87 88 89 90
    void logFileStats                   (int logDurationSecs);
    void playbackStarted                (void);
    void playbackPaused                 (void);
    void playbackAtEnd                  (void);
    void playbackPercentCompleteChanged (qreal percentComplete);
    void currentLogTimeSecs             (int secs);
91

Don Gagne's avatar
Don Gagne committed
92
    // Internal signals
93 94 95
    void _playOnThread              (void);
    void _pauseOnThread             (void);
    void _setPlaybackSpeedOnThread  (qreal playbackSpeed);
Don Gagne's avatar
Don Gagne committed
96 97

private slots:
98 99 100 101
    void _readNextLogEntry  (void);
    void _play              (void);
    void _pause             (void);
    void _setPlaybackSpeed  (qreal playbackSpeed);
Don Gagne's avatar
Don Gagne committed
102 103 104

private:
    // Links are only created/destroyed by LinkManager so constructor/destructor is not public
105
    LogReplayLink(SharedLinkConfigurationPointer& config);
Don Gagne's avatar
Don Gagne committed
106
    ~LogReplayLink();
107

108 109 110 111 112 113 114 115 116
    void    _replayError                (const QString& errorMsg);
    quint64 _parseTimestamp             (const QByteArray& bytes);
    quint64 _seekToNextMavlinkMessage   (mavlink_message_t* nextMsg);
    quint64 _findLastTimestamp          (void);
    quint64 _readNextMavlinkMessage     (QByteArray& bytes);
    bool    _loadLogFile                (void);
    void    _finishPlayback             (void);
    void    _resetPlaybackToBeginning   (void);
    void    _signalCurrentLogTimeSecs   (void);
117

Don Gagne's avatar
Don Gagne committed
118
    // Virtuals from LinkInterface
119
    virtual bool _connect   (void);
Don Gagne's avatar
Don Gagne committed
120
    virtual void _disconnect(void);
121

Don Gagne's avatar
Don Gagne committed
122 123
    // Virtuals from QThread
    virtual void run(void);
124

125
    LogReplayLinkConfiguration* _logReplayConfig;
Don Gagne's avatar
Don Gagne committed
126 127

    bool    _connected;
128
    uint8_t _mavlinkChannel;
Don Gagne's avatar
Don Gagne committed
129
    QTimer  _readTickTimer;      ///< Timer which signals a read of next log record
130

131
    QString _errorTitle; ///< Title for communicatorError signals
132

Don Gagne's avatar
Don Gagne committed
133 134 135 136
    quint64 _logCurrentTimeUSecs;   ///< The timestamp of the next message in the log file.
    quint64 _logStartTimeUSecs;     ///< The first timestamp in the current log file.
    quint64 _logEndTimeUSecs;       ///< The last timestamp in the current log file.
    quint64 _logDurationUSecs;
137

138
    qreal   _playbackSpeed;
Don Gagne's avatar
Don Gagne committed
139
    quint64 _playbackStartTimeMSecs;    ///< The time when the logfile was first played back. This is used to pace out replaying the messages to fix long-term drift/skew. 0 indicates that the player hasn't initiated playback of this log file.
140
    quint64 _playbackStartLogTimeUSecs;
141

Don Gagne's avatar
Don Gagne committed
142 143 144
    MAVLinkProtocol*    _mavlink;
    QFile               _logFile;
    quint64             _logFileSize;
145

Don Gagne's avatar
Don Gagne committed
146 147 148
    static const int cbTimestamp = sizeof(quint64);
};

149 150 151 152 153 154 155 156 157 158
class LogReplayLinkController : public QObject
{
    Q_OBJECT

public:
    Q_PROPERTY(LogReplayLink*   link            READ link               WRITE setLink               NOTIFY linkChanged)
    Q_PROPERTY(bool             isPlaying       READ isPlaying          WRITE setIsPlaying          NOTIFY isPlayingChanged)
    Q_PROPERTY(qreal            percentComplete READ percentComplete    WRITE setPercentComplete    NOTIFY percentCompleteChanged)
    Q_PROPERTY(QString          totalTime       MEMBER _totalTime                                   NOTIFY totalTimeChanged)
    Q_PROPERTY(QString          playheadTime    MEMBER _playheadTime                                NOTIFY playheadTimeChanged)
159
    Q_PROPERTY(qreal            playbackSpeed   MEMBER _playbackSpeed                               NOTIFY playbackSpeedChanged)
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

    LogReplayLinkController(void);

    LogReplayLink*  link            (void) { return _link; }
    bool            isPlaying       (void) { return _isPlaying; }
    qreal           percentComplete (void) { return _percentComplete; }

    void setLink            (LogReplayLink* link);
    void setIsPlaying       (bool isPlaying);
    void setPercentComplete (qreal percentComplete);

signals:
    void linkChanged            (LogReplayLink* link);
    void isPlayingChanged       (bool isPlaying);
    void percentCompleteChanged (qreal percentComplete);
    void playheadTimeChanged    (QString playheadTime);
    void totalTimeChanged       (QString totalTime);
177
    void playbackSpeedChanged   (qreal playbackSpeed);
178 179

private slots:
180
    void _logFileStats                   (int logDurationSecs);
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
    void _playbackStarted                (void);
    void _playbackPaused                 (void);
    void _playbackAtEnd                  (void);
    void _playbackPercentCompleteChanged (qreal percentComplete);
    void _currentLogTimeSecs             (int secs);
    void _linkDisconnected               (void);

private:
    QString _secondsToHMS(int seconds);

    LogReplayLink*  _link;
    bool            _isPlaying;
    qreal           _percentComplete;
    int             _playheadSecs;
    QString         _playheadTime;
    QString         _totalTime;
197
    qreal           _playbackSpeed;
198 199
};