SerialLink.h 6.46 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

pixhawk's avatar
pixhawk committed
11 12 13 14 15 16 17 18 19 20 21
/**
 * @file
 *   @brief Brief Description
 *
 *   @author Lorenz Meier <mavteam@student.ethz.ch>
 *
 */

#ifndef SERIALLINK_H
#define SERIALLINK_H

22 23 24 25
class LinkInterface;
class SerialConfiguration;
class SerialLink;

pixhawk's avatar
pixhawk committed
26 27 28 29
#include <QObject>
#include <QThread>
#include <QMutex>
#include <QString>
dogmaphobic's avatar
dogmaphobic committed
30

dogmaphobic's avatar
dogmaphobic committed
31 32 33
#ifdef __android__
#include "qserialport.h"
#else
34
#include <QSerialPort>
dogmaphobic's avatar
dogmaphobic committed
35
#endif
36
#include <QMetaType>
37
#include <QLoggingCategory>
38 39

// We use QSerialPort::SerialPortError in a signal so we must declare it as a meta type
40 41
Q_DECLARE_METATYPE(QSerialPort::SerialPortError)

42 43 44
#include "QGCConfig.h"
#include "LinkManager.h"

45 46
Q_DECLARE_LOGGING_CATEGORY(SerialLinkLog)

47 48
class SerialConfiguration : public LinkConfiguration
{
Don Gagne's avatar
Don Gagne committed
49 50
    Q_OBJECT

51 52 53 54 55
public:

    SerialConfiguration(const QString& name);
    SerialConfiguration(SerialConfiguration* copy);

56 57 58 59 60 61 62
    Q_PROPERTY(int      baud            READ baud               WRITE setBaud               NOTIFY baudChanged)
    Q_PROPERTY(int      dataBits        READ dataBits           WRITE setDataBits           NOTIFY dataBitsChanged)
    Q_PROPERTY(int      flowControl     READ flowControl        WRITE setFlowControl        NOTIFY flowControlChanged)
    Q_PROPERTY(int      stopBits        READ stopBits           WRITE setStopBits           NOTIFY stopBitsChanged)
    Q_PROPERTY(int      parity          READ parity             WRITE setParity             NOTIFY parityChanged)
    Q_PROPERTY(QString  portName        READ portName           WRITE setPortName           NOTIFY portNameChanged)
    Q_PROPERTY(QString  portDisplayName READ portDisplayName                                NOTIFY portDisplayNameChanged)
63
    Q_PROPERTY(bool     usbDirect       READ usbDirect          WRITE setUsbDirect          NOTIFY usbDirectChanged)        ///< true: direct usb connection to board
64

65 66 67 68 69
    int  baud()         { return _baud; }
    int  dataBits()     { return _dataBits; }
    int  flowControl()  { return _flowControl; }    ///< QSerialPort Enums
    int  stopBits()     { return _stopBits; }
    int  parity()       { return _parity; }         ///< QSerialPort Enums
70
    bool usbDirect()    { return _usbDirect; }
71

72 73
    const QString portName          () { return _portName; }
    const QString portDisplayName   () { return _portDisplayName; }
74

75 76 77 78 79 80
    void setBaud            (int baud);
    void setDataBits        (int databits);
    void setFlowControl     (int flowControl);          ///< QSerialPort Enums
    void setStopBits        (int stopBits);
    void setParity          (int parity);               ///< QSerialPort Enums
    void setPortName        (const QString& portName);
81
    void setUsbDirect       (bool usbDirect);
82

83
    static QStringList supportedBaudRates();
84
    static QString cleanPortDisplayname(const QString name);
85

86
    /// From LinkConfiguration
87 88
    LinkType    type            () { return LinkConfiguration::TypeSerial; }
    void        copyFrom        (LinkConfiguration* source);
89
    bool        isHighLatencyAllowed () { return true; }
90 91 92 93
    void        loadSettings    (QSettings& settings, const QString& root);
    void        saveSettings    (QSettings& settings, const QString& root);
    void        updateSettings  ();
    QString     settingsURL     () { return "SerialSettings.qml"; }
94

95 96 97 98 99 100 101 102
signals:
    void baudChanged            ();
    void dataBitsChanged        ();
    void flowControlChanged     ();
    void stopBitsChanged        ();
    void parityChanged          ();
    void portNameChanged        ();
    void portDisplayNameChanged ();
103
    void usbDirectChanged       (bool usbDirect);
104

105 106 107
private:
    static void _initBaudRates();

108 109 110 111 112 113 114
private:
    int _baud;
    int _dataBits;
    int _flowControl;
    int _stopBits;
    int _parity;
    QString _portName;
115
    QString _portDisplayName;
116
    bool _usbDirect;
117 118
};

pixhawk's avatar
pixhawk committed
119 120 121 122 123 124 125 126
/**
 * @brief The SerialLink class provides cross-platform access to serial links.
 * It takes care of the link management and provides a common API to higher
 * level communication layers. It is implemented as a wrapper class for a thread
 * that handles the serial communication. All methods have therefore to be thread-
 * safe.
 *
 */
127
class SerialLink : public LinkInterface
128
{
pixhawk's avatar
pixhawk committed
129
    Q_OBJECT
130

131
    friend class SerialConfiguration;
132
    friend class LinkManager;
133

pixhawk's avatar
pixhawk committed
134
public:
135
    // LinkInterface
pixhawk's avatar
pixhawk committed
136

137
    QString getName() const;
138 139 140
    void    requestReset();
    bool    isConnected() const;
    qint64  getConnectionSpeed() const;
141
    SerialConfiguration* getSerialConfig() const { return _serialConfig; }
142

143 144 145 146
    // 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.
    bool    connect(void);
    bool    disconnect(void);
147

148
private slots:
pixhawk's avatar
pixhawk committed
149 150 151 152 153 154
    /**
     * @brief Write a number of bytes to the interface.
     *
     * @param data Pointer to the data byte array
     * @param size The size of the bytes array
     **/
155
    void _writeBytes(const QByteArray data);
pixhawk's avatar
pixhawk committed
156

157
public slots:
158
    void linkError(QSerialPort::SerialPortError error);
159

pixhawk's avatar
pixhawk committed
160
protected:
161 162 163 164 165 166
    QSerialPort* _port;
    quint64 _bytesRead;
    int     _timeout;
    QMutex  _dataMutex;       // Mutex for reading data from _port
    QMutex  _writeMutex;      // Mutex for accessing the _transmitBuffer.

167
private slots:
168
    void _readBytes(void);
pixhawk's avatar
pixhawk committed
169

oberion's avatar
oberion committed
170
private:
171
    // Links are only created/destroyed by LinkManager so constructor/destructor is not public
172
    SerialLink(SharedLinkConfigurationPointer& config);
173
    ~SerialLink();
174

175
    // From LinkInterface
176
    virtual bool _connect(void);
Don Gagne's avatar
Don Gagne committed
177
    virtual void _disconnect(void);
178

179 180
    // Internal methods
    void _emitLinkError(const QString& errorMsg);
181
    bool _hardwareConnect(QSerialPort::SerialPortError& error, QString& errorString);
182 183 184 185 186 187 188 189
    bool _isBootloader();
    void _resetConfiguration();

    // Local data
    volatile bool        _stopp;
    volatile bool        _reqReset;
    QMutex               _stoppMutex;      // Mutex for accessing _stopp
    QByteArray           _transmitBuffer;  // An internal buffer for receiving data from member functions and actually transmitting them via the serial port.
190
    SerialConfiguration* _serialConfig;
pixhawk's avatar
pixhawk committed
191 192

signals:
193
    void aboutToCloseFlag();
pixhawk's avatar
pixhawk committed
194 195 196 197

};

#endif // SERIALLINK_H