MAVLinkProtocol.h 9.47 KB
Newer Older
1 2 3 4 5 6 7 8
/****************************************************************************
 *
 *   (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.
 *
 ****************************************************************************/
pixhawk's avatar
pixhawk committed
9 10 11 12


/**
 * @file
pixhawk's avatar
pixhawk committed
13 14
 *   @brief Definition of class MAVLinkProtocol
 *   @author Lorenz Meier <mail@qgroundcontrol.org>
pixhawk's avatar
pixhawk committed
15 16 17 18 19 20 21 22 23
 */

#ifndef MAVLINKPROTOCOL_H_
#define MAVLINKPROTOCOL_H_

#include <QObject>
#include <QMutex>
#include <QString>
#include <QTimer>
lm's avatar
lm committed
24
#include <QFile>
lm's avatar
lm committed
25
#include <QMap>
pixhawk's avatar
pixhawk committed
26
#include <QByteArray>
27
#include <QLoggingCategory>
Don Gagne's avatar
Don Gagne committed
28

pixhawk's avatar
pixhawk committed
29
#include "LinkInterface.h"
pixhawk's avatar
pixhawk committed
30
#include "QGCMAVLink.h"
31
#include "QGC.h"
32
#include "QGCTemporaryFile.h"
33
#include "QGCToolbox.h"
pixhawk's avatar
pixhawk committed
34

35
class LinkManager;
36 37
class MultiVehicleManager;
class QGCApplication;
38

39 40
Q_DECLARE_LOGGING_CATEGORY(MAVLinkProtocolLog)

pixhawk's avatar
pixhawk committed
41
/**
pixhawk's avatar
pixhawk committed
42
 * @brief MAVLink micro air vehicle protocol reference implementation.
pixhawk's avatar
pixhawk committed
43
 *
pixhawk's avatar
pixhawk committed
44 45 46
 * MAVLink is a generic communication protocol for micro air vehicles.
 * for more information, please see the official website.
 * @ref http://pixhawk.ethz.ch/software/mavlink/
pixhawk's avatar
pixhawk committed
47
 **/
48
class MAVLinkProtocol : public QGCTool
49
{
pixhawk's avatar
pixhawk committed
50 51
    Q_OBJECT

52
public:
53 54 55
    MAVLinkProtocol(QGCApplication* app);
    ~MAVLinkProtocol();

pixhawk's avatar
pixhawk committed
56 57
    /** @brief Get the human-friendly name of this protocol */
    QString getName();
58 59 60 61
    /** @brief Get the system id of this application */
    int getSystemId();
    /** @brief Get the component id of this application */
    int getComponentId();
Don Gagne's avatar
Don Gagne committed
62
    
lm's avatar
lm committed
63
    /** @brief Get protocol version check state */
64 65 66
    bool versionCheckEnabled() const {
        return m_enable_version_check;
    }
67
    /** @brief Get the multiplexing state */
68 69 70
    bool multiplexingEnabled() const {
        return m_multiplexingEnabled;
    }
71
    /** @brief Get the protocol version */
72 73 74
    int getVersion() {
        return MAVLINK_VERSION;
    }
75
    /** @brief Get state of parameter retransmission */
76 77 78
    bool paramGuardEnabled() {
        return m_paramGuardEnabled;
    }
79
    /** @brief Get parameter read timeout */
80 81 82
    int getParamRetransmissionTimeout() {
        return m_paramRetransmissionTimeout;
    }
83
    /** @brief Get parameter write timeout */
84 85 86
    int getParamRewriteTimeout() {
        return m_paramRewriteTimeout;
    }
87
    /** @brief Get state of action retransmission */
88 89 90
    bool actionGuardEnabled() {
        return m_actionGuardEnabled;
    }
91
    /** @brief Get parameter read timeout */
92 93 94
    int getActionRetransmissionTimeout() {
        return m_actionRetransmissionTimeout;
    }
95 96 97 98
    /**
     * Retrieve a total of all successfully parsed packets for the specified link.
     * @returns -1 if this is not available for this protocol, # of packets otherwise.
     */
99
    qint32 getReceivedPacketCount(const LinkInterface *link) const {
100
        return totalReceiveCounter[link->getMavlinkChannel()];
101 102 103 104 105
    }
    /**
     * Retrieve a total of all parsing errors for the specified link.
     * @returns -1 if this is not available for this protocol, # of errors otherwise.
     */
106
    qint32 getParsingErrorCount(const LinkInterface *link) const {
107
        return totalErrorCounter[link->getMavlinkChannel()];
108 109 110 111 112
    }
    /**
     * Retrieve a total of all dropped packets for the specified link.
     * @returns -1 if this is not available for this protocol, # of packets otherwise.
     */
113
    qint32 getDroppedPacketCount(const LinkInterface *link) const {
114
        return totalLossCounter[link->getMavlinkChannel()];
115
    }
116 117 118 119
    /**
     * Reset the counters for all metadata for this link.
     */
    virtual void resetMetadataForLink(const LinkInterface *link);
Don Gagne's avatar
Don Gagne committed
120
    
121 122
    /// Suspend/Restart logging during replay.
    void suspendLogForReplay(bool suspend);
Lorenz Meier's avatar
Lorenz Meier committed
123

124 125 126
    // Override from QGCTool
    virtual void setToolbox(QGCToolbox *toolbox);

pixhawk's avatar
pixhawk committed
127 128
public slots:
    /** @brief Receive bytes from a communication interface */
129
    void receiveBytes(LinkInterface* link, QByteArray b);
130
    
131 132
    /** @brief Set the system id of this application */
    void setSystemId(int id);
pixhawk's avatar
pixhawk committed
133

134 135 136
    /** @brief Enabled/disable packet multiplexing */
    void enableMultiplexing(bool enabled);

137 138 139
    /** @brief Enable / disable parameter retransmission */
    void enableParamGuard(bool enabled);

140 141 142
    /** @brief Enable / disable action retransmission */
    void enableActionGuard(bool enabled);

143 144 145 146 147 148
    /** @brief Set parameter read timeout */
    void setParamRetransmissionTimeout(int ms);

    /** @brief Set parameter write timeout */
    void setParamRewriteTimeout(int ms);

149 150 151
    /** @brief Set parameter read timeout */
    void setActionRetransmissionTimeout(int ms);

lm's avatar
lm committed
152 153 154
    /** @brief Enable / disable version check */
    void enableVersionCheck(bool enabled);

155 156 157 158
    /** @brief Load protocol settings */
    void loadSettings();
    /** @brief Store protocol settings */
    void storeSettings();
Don Gagne's avatar
Don Gagne committed
159
    
Don Gagne's avatar
Don Gagne committed
160
#ifndef __mobile__
161 162
    /// @brief Deletes any log files which are in the temp directory
    static void deleteTempLogFiles(void);
163 164 165
    
    /// Checks for lost log files
    void checkForLostLogFiles(void);
Don Gagne's avatar
Don Gagne committed
166
#endif
Don Gagne's avatar
Don Gagne committed
167

168
protected:
169
    bool m_multiplexingEnabled; ///< Enable/disable packet multiplexing
lm's avatar
lm committed
170
    bool m_enable_version_check; ///< Enable checking of version match of MAV and QGC
171 172
    int m_paramRetransmissionTimeout; ///< Timeout for parameter retransmission
    int m_paramRewriteTimeout;    ///< Timeout for sending re-write request
173 174 175
    bool m_paramGuardEnabled;       ///< Parameter retransmission/rewrite enabled
    bool m_actionGuardEnabled;       ///< Action request retransmission enabled
    int m_actionRetransmissionTimeout; ///< Timeout for parameter retransmission
176 177 178 179 180 181 182
    QMutex receiveMutex;        ///< Mutex to protect receiveBytes function
    int lastIndex[256][256];    ///< Store the last received sequence ID for each system/componenet pair
    int totalReceiveCounter[MAVLINK_COMM_NUM_BUFFERS];    ///< The total number of successfully received messages
    int totalLossCounter[MAVLINK_COMM_NUM_BUFFERS];       ///< Total messages lost during transmission.
    int totalErrorCounter[MAVLINK_COMM_NUM_BUFFERS];      ///< Total count of all parsing errors. Generally <= totalLossCounter.
    int currReceiveCounter[MAVLINK_COMM_NUM_BUFFERS];     ///< Received messages during this sample time window. Used for calculating loss %.
    int currLossCounter[MAVLINK_COMM_NUM_BUFFERS];        ///< Lost messages during this sample time window. Used for calculating loss %.
183
    bool versionMismatchIgnore;
184
    int systemId;
185

pixhawk's avatar
pixhawk committed
186
signals:
Don Gagne's avatar
Don Gagne committed
187 188 189
    /// Heartbeat received on link
    void vehicleHeartbeatInfo(LinkInterface* link, int vehicleId, int vehicleMavlinkVersion, int vehicleFirmwareType, int vehicleType);

pixhawk's avatar
pixhawk committed
190 191
    /** @brief Message received and directly copied via signal */
    void messageReceived(LinkInterface* link, mavlink_message_t message);
192 193
    /** @brief Emitted if multiplexing is started / stopped */
    void multiplexingChanged(bool enabled);
lm's avatar
lm committed
194 195
    /** @brief Emitted if version check is enabled / disabled */
    void versionCheckChanged(bool enabled);
196 197
    /** @brief Emitted if a message from the protocol should reach the user */
    void protocolStatusMessage(const QString& title, const QString& message);
198 199 200 201 202 203 204 205
    /** @brief Emitted if a new system ID was set */
    void systemIdChanged(int systemId);
    /** @brief Emitted if param guard status changed */
    void paramGuardChanged(bool enabled);
    /** @brief Emitted if param read timeout changed */
    void paramRetransmissionTimeoutChanged(int ms);
    /** @brief Emitted if param write timeout changed */
    void paramRewriteTimeoutChanged(int ms);
206 207
    /** @brief Emitted if action guard status changed */
    void actionGuardChanged(bool enabled);
208
    /** @brief Emitted if action request timeout changed */
209
    void actionRetransmissionTimeoutChanged(int ms);
210 211 212

    void receiveLossPercentChanged(int uasId, float lossPercent);
    void receiveLossTotalChanged(int uasId, int totalLoss);
213

214 215 216 217 218
    /**
     * @brief Emitted if a new radio status packet received
     *
     * @param rxerrors receive errors
     * @param fixed count of error corrected packets
219 220
     * @param rssi local signal strength in dBm
     * @param remrssi remote signal strength in dBm
221 222 223 224
     * @param txbuf how full the tx buffer is as a percentage
     * @param noise background noise level
     * @param remnoise remote background noise level
     */
225
    void radioStatusChanged(LinkInterface* link, unsigned rxerrors, unsigned fixed, int rssi, int remrssi,
226
    unsigned txbuf, unsigned noise, unsigned remnoise);
Don Gagne's avatar
Don Gagne committed
227 228 229
    
    /// @brief Emitted when a temporary log file is ready for saving
    void saveTempFlightDataLog(QString tempLogfile);
230 231 232

private slots:
    void _vehicleCountChanged(int count);
Don Gagne's avatar
Don Gagne committed
233 234
    
private:
Don Gagne's avatar
Don Gagne committed
235 236 237 238
    void _sendMessage(mavlink_message_t message);
    void _sendMessage(LinkInterface* link, mavlink_message_t message);
    void _sendMessage(LinkInterface* link, mavlink_message_t message, quint8 systemid, quint8 componentid);

Don Gagne's avatar
Don Gagne committed
239
#ifndef __mobile__
Don Gagne's avatar
Don Gagne committed
240 241 242
    bool _closeLogFile(void);
    void _startLogging(void);
    void _stopLogging(void);
Don Gagne's avatar
Don Gagne committed
243

Don Gagne's avatar
Don Gagne committed
244 245
    bool _logSuspendError;      ///< true: Logging suspended due to error
    bool _logSuspendReplay;     ///< true: Logging suspended due to replay
246
    bool _logPromptForSave;     ///< true: Prompt for log save when appropriate
Don Gagne's avatar
Don Gagne committed
247

248 249 250
    QGCTemporaryFile    _tempLogFile;            ///< File to log to
    static const char*  _tempLogFileTemplate;    ///< Template for temporary log file
    static const char*  _logFileExtension;       ///< Extension for log files
Don Gagne's avatar
Don Gagne committed
251
#endif
Don Gagne's avatar
Don Gagne committed
252

253 254
    LinkManager*            _linkMgr;
    MultiVehicleManager*    _multiVehicleManager;
pixhawk's avatar
pixhawk committed
255 256 257
};

#endif // MAVLINKPROTOCOL_H_