Microhard: Added settings panel similar to Taisync

QGCCommon.pri

@@ -22,6 +22,7 @@ linux {
         CONFIG  += LinuxBuild
         DEFINES += __STDC_LIMIT_MACROS
         DEFINES += QGC_GST_TAISYNC_ENABLED
+        DEFINES += QGC_GST_MICROHARD_ENABLED 
         linux-clang {
             message("Linux clang")
             QMAKE_CXXFLAGS += -Qunused-arguments -fcolor-diagnostics
@@ -31,12 +32,14 @@ linux {
         CONFIG += LinuxBuild
         DEFINES += __STDC_LIMIT_MACROS __rasp_pi2__
         DEFINES += QGC_GST_TAISYNC_ENABLED
+        DEFINES += QGC_GST_MICROHARD_ENABLED 
     } else : android-g++ | android-clang {
         CONFIG += AndroidBuild MobileBuild
         DEFINES += __android__
         DEFINES += __STDC_LIMIT_MACROS
         DEFINES += QGC_ENABLE_BLUETOOTH
         DEFINES += QGC_GST_TAISYNC_ENABLED
+        DEFINES += QGC_GST_MICROHARD_ENABLED 
         target.path = $$DESTDIR
         equals(ANDROID_TARGET_ARCH, x86)  {
             CONFIG += Androidx86Build
@@ -54,6 +57,7 @@ linux {
         CONFIG += WindowsBuild
         DEFINES += __STDC_LIMIT_MACROS
         DEFINES += QGC_GST_TAISYNC_ENABLED
+        DEFINES += QGC_GST_MICROHARD_ENABLED 
     } else {
         error("Unsupported Windows toolchain, only Visual Studio 2015 is supported")
     }
@@ -64,6 +68,7 @@ linux {
         CONFIG  += x86_64
         CONFIG  -= x86
         DEFINES += QGC_GST_TAISYNC_ENABLED
+        DEFINES += QGC_GST_MICROHARD_ENABLED 
         equals(QT_MAJOR_VERSION, 5) | greaterThan(QT_MINOR_VERSION, 5) {
                 QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.7
         } else {

qgroundcontrol.pro

@@ -1148,6 +1148,23 @@ contains (DEFINES, QGC_GST_TAISYNC_ENABLED) {
     }
 }
 
+#-------------------------------------------------------------------------------------
+# Microhard
+contains (DEFINES, QGC_GST_MICROHARD_ENABLED) {
+    INCLUDEPATH += \
+        src/Microhard
+
+    HEADERS += \
+        src/Microhard/MicrohardManager.h \
+        src/Microhard/MicrohardHandler.h \
+        src/Microhard/MicrohardSettings.h \
+
+    SOURCES += \
+        src/Microhard/MicrohardManager.cc \
+        src/Microhard/MicrohardHandler.cc \
+        src/Microhard/MicrohardSettings.cc \
+}
+
 #-------------------------------------------------------------------------------------
 # AirMap
 

qgroundcontrol.qrc

@@ -201,6 +201,7 @@
         <file alias="SyslinkComponent.qml">src/AutoPilotPlugins/Common/SyslinkComponent.qml</file>
         <file alias="TcpSettings.qml">src/ui/preferences/TcpSettings.qml</file>
         <file alias="TaisyncSettings.qml">src/Taisync/TaisyncSettings.qml</file>
+        <file alias="MicrohardSettings.qml">src/Microhard/MicrohardSettings.qml</file>
         <file alias="test.qml">src/test.qml</file>
         <file alias="UdpSettings.qml">src/ui/preferences/UdpSettings.qml</file>
         <file alias="ValuePageWidget.qml">src/FlightMap/Widgets/ValuePageWidget.qml</file>

src/Microhard/MicrohardHandler.cc

+/****************************************************************************
+ *
+ *   (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.
+ *
+ ****************************************************************************/
+
+#include "MicrohardHandler.h"
+#include "SettingsManager.h"
+#include "QGCApplication.h"
+#include "VideoManager.h"
+
+
+QGC_LOGGING_CATEGORY(MicrohardLog,     "MicrohardLog")
+QGC_LOGGING_CATEGORY(MicrohardVerbose, "MicrohardVerbose")
+
+//-----------------------------------------------------------------------------
+MicrohardHandler::MicrohardHandler(QObject* parent)
+    : QObject (parent)
+{
+}
+
+//-----------------------------------------------------------------------------
+MicrohardHandler::~MicrohardHandler()
+{
+    close();
+}
+
+//-----------------------------------------------------------------------------
+bool MicrohardHandler::close()
+{
+    bool res = (_tcpSocket || _tcpServer);
+    if(_tcpSocket) {
+        qCDebug(MicrohardLog) << "Close Microhard TCP socket on port" << _tcpSocket->localPort();
+        _tcpSocket->close();
+        _tcpSocket->deleteLater();
+        _tcpSocket = nullptr;
+    }
+    if(_tcpServer) {
+        qCDebug(MicrohardLog) << "Close Microhard TCP server on port" << _tcpServer->serverPort();;
+        _tcpServer->close();
+        _tcpServer->deleteLater();
+        _tcpServer = nullptr;
+    }
+    return res;
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardHandler::_start(uint16_t port, QHostAddress addr)
+{
+    close();
+    _serverMode = addr == QHostAddress::AnyIPv4;
+    if(_serverMode) {
+        if(!_tcpServer) {
+            qCDebug(MicrohardLog) << "Listen for Microhard TCP on port" << port;
+            _tcpServer = new QTcpServer(this);
+            QObject::connect(_tcpServer, &QTcpServer::newConnection, this, &MicrohardHandler::_newConnection);
+            _tcpServer->listen(QHostAddress::AnyIPv4, port);
+        }
+    } else {
+        _tcpSocket = new QTcpSocket();
+        QObject::connect(_tcpSocket, &QIODevice::readyRead, this, &MicrohardHandler::_readBytes);
+        qCDebug(MicrohardLog) << "Connecting to" << addr;
+        _tcpSocket->connectToHost(addr, port);
+        if (!_tcpSocket->waitForConnected(1000)) {
+            close();
+            return false;
+        }
+        emit connected();
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+void
+MicrohardHandler::_newConnection()
+{
+    qCDebug(MicrohardLog) << "New Microhard TCP Connection on port" << _tcpServer->serverPort();
+    if(_tcpSocket) {
+        _tcpSocket->close();
+        _tcpSocket->deleteLater();
+    }
+    _tcpSocket = _tcpServer->nextPendingConnection();
+    if(_tcpSocket) {
+        QObject::connect(_tcpSocket, &QIODevice::readyRead, this, &MicrohardHandler::_readBytes);
+        QObject::connect(_tcpSocket, &QAbstractSocket::disconnected, this, &MicrohardHandler::_socketDisconnected);
+        emit connected();
+    } else {
+        qCWarning(MicrohardLog) << "New Microhard TCP Connection provided no socket";
+    }
+}
+
+//-----------------------------------------------------------------------------
+void
+MicrohardHandler::_socketDisconnected()
+{
+    qCDebug(MicrohardLog) << "Microhard TCP Connection Closed on port" << _tcpSocket->localPort();
+    if(_tcpSocket) {
+        _tcpSocket->close();
+        _tcpSocket->deleteLater();
+        _tcpSocket = nullptr;
+    }
+    emit disconnected();
+}

src/Microhard/MicrohardHandler.h

+/****************************************************************************
+ *
+ *   (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.
+ *
+ ****************************************************************************/
+
+#pragma once
+
+#include "QGCLoggingCategory.h"
+
+#include <QTcpServer>
+#include <QTcpSocket>
+
+#define MICROHARD_SETTINGS_PORT   23
+
+Q_DECLARE_LOGGING_CATEGORY(MicrohardLog)
+Q_DECLARE_LOGGING_CATEGORY(MicrohardVerbose)
+
+class MicrohardHandler : public QObject
+{
+    Q_OBJECT
+public:
+
+    explicit MicrohardHandler           (QObject* parent = nullptr);
+    ~MicrohardHandler                   ();
+    virtual bool start                  () = 0;
+    virtual bool close                  ();
+    virtual bool isServerRunning        () { return (_serverMode && _tcpServer); }
+
+protected:
+    virtual bool    _start              (uint16_t port, QHostAddress addr = QHostAddress::AnyIPv4);
+
+protected slots:
+    virtual void    _newConnection      ();
+    virtual void    _socketDisconnected ();
+    virtual void    _readBytes          () = 0;
+
+signals:
+    void connected                      ();
+    void disconnected                   ();
+
+protected:
+    bool            _serverMode = true;
+    QTcpServer*     _tcpServer  = nullptr;
+    QTcpSocket*     _tcpSocket  = nullptr;
+};

src/Microhard/MicrohardManager.h

+/****************************************************************************
+ *
+ *   (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.
+ *
+ ****************************************************************************/
+
+#pragma once
+
+#include "QGCToolbox.h"
+#include "QGCLoggingCategory.h"
+#include "MicrohardSettings.h"
+#include "Fact.h"
+
+#include <QTimer>
+#include <QTime>
+
+class AppSettings;
+class QGCApplication;
+
+//-----------------------------------------------------------------------------
+class MicrohardManager : public QGCTool
+{
+    Q_OBJECT
+public:
+
+    Q_PROPERTY(bool         connected           READ connected                                  NOTIFY connectedChanged)
+    Q_PROPERTY(bool         linkConnected       READ linkConnected                              NOTIFY linkConnectedChanged)
+    Q_PROPERTY(bool         needReboot          READ needReboot                                 NOTIFY needRebootChanged)
+    Q_PROPERTY(QString      linkVidFormat       READ linkVidFormat                              NOTIFY linkChanged)
+    Q_PROPERTY(int          uplinkRSSI          READ uplinkRSSI                                 NOTIFY linkChanged)
+    Q_PROPERTY(int          downlinkRSSI        READ downlinkRSSI                               NOTIFY linkChanged)
+    Q_PROPERTY(QString      serialNumber        READ serialNumber                               NOTIFY infoChanged)
+    Q_PROPERTY(QString      fwVersion           READ fwVersion                                  NOTIFY infoChanged)
+    Q_PROPERTY(Fact*        radioMode           READ radioMode                                  CONSTANT)
+    Q_PROPERTY(Fact*        radioChannel        READ radioChannel                               CONSTANT)
+    Q_PROPERTY(Fact*        videoOutput         READ videoOutput                                CONSTANT)
+    Q_PROPERTY(Fact*        videoMode           READ videoMode                                  CONSTANT)
+    Q_PROPERTY(Fact*        videoRate           READ videoRate                                  CONSTANT)
+    Q_PROPERTY(QString      rtspURI             READ rtspURI                                    NOTIFY rtspURIChanged)
+    Q_PROPERTY(QString      rtspAccount         READ rtspAccount                                NOTIFY rtspAccountChanged)
+    Q_PROPERTY(QString      rtspPassword        READ rtspPassword                               NOTIFY rtspPasswordChanged)
+    Q_PROPERTY(QString      localIPAddr         READ localIPAddr                                NOTIFY localIPAddrChanged)
+    Q_PROPERTY(QString      remoteIPAddr        READ remoteIPAddr                               NOTIFY remoteIPAddrChanged)
+    Q_PROPERTY(QString      netMask             READ netMask                                    NOTIFY netMaskChanged)
+
+    Q_INVOKABLE bool setRTSPSettings            (QString uri, QString account, QString password);
+    Q_INVOKABLE bool setIPSettings              (QString localIP, QString remoteIP, QString netMask);
+
+    explicit MicrohardManager                   (QGCApplication* app, QGCToolbox* toolbox);
+    ~MicrohardManager                           () override;
+
+    void        setToolbox                      (QGCToolbox* toolbox) override;
+
+    bool        connected                       () { return _isConnected; }
+    bool        linkConnected                   () { return _linkConnected; }
+    bool        needReboot                      () { return _needReboot; }
+    QString     linkVidFormat                   () { return _linkVidFormat; }
+    int         uplinkRSSI                      () { return _downlinkRSSI; }
+    int         downlinkRSSI                    () { return _uplinkRSSI; }
+    QString     serialNumber                    () { return _serialNumber; }
+    QString     fwVersion                       () { return _fwVersion; }
+    Fact*       radioMode                       () { return _radioMode; }
+    Fact*       radioChannel                    () { return _radioChannel; }
+    Fact*       videoOutput                     () { return _videoOutput; }
+    Fact*       videoMode                       () { return _videoMode; }
+    Fact*       videoRate                       () { return _videoRate; }
+    QString     rtspURI                         () { return _rtspURI; }
+    QString     rtspAccount                     () { return _rtspAccount; }
+    QString     rtspPassword                    () { return _rtspPassword; }
+    QString     localIPAddr                     () { return _localIPAddr; }
+    QString     remoteIPAddr                    () { return _remoteIPAddr; }
+    QString     netMask                         () { return _netMask; }
+
+signals:
+    void    linkChanged                     ();
+    void    linkConnectedChanged            ();
+    void    infoChanged                     ();
+    void    connectedChanged                ();
+    void    decodeIndexChanged              ();
+    void    rateIndexChanged                ();
+    void    rtspURIChanged                  ();
+    void    rtspAccountChanged              ();
+    void    rtspPasswordChanged             ();
+    void    localIPAddrChanged              ();
+    void    remoteIPAddrChanged             ();
+    void    netMaskChanged                  ();
+    void    needRebootChanged               ();
+
+private slots:
+    void    _connected                      ();
+    void    _disconnected                   ();
+    void    _checkMicrohard                 ();
+    void    _updateSettings                 (QByteArray jSonData);
+    void    _setEnabled                     ();
+    void    _setVideoEnabled                ();
+    void    _radioSettingsChanged           (QVariant);
+    void    _videoSettingsChanged           (QVariant);
+
+private:
+    void    _close                          ();
+    void    _reset                          ();
+    void    _restoreVideoSettings           (Fact* setting);
+    FactMetaData *_createMetadata           (const char *name, QStringList enums);
+
+private:
+
+    enum {
+        REQ_LINK_STATUS         = 1,
+        REQ_DEV_INFO            = 2,
+        REQ_FREQ_SCAN           = 4,
+        REQ_VIDEO_SETTINGS      = 8,
+        REQ_RADIO_SETTINGS      = 16,
+        REQ_RTSP_SETTINGS       = 32,
+        REQ_IP_SETTINGS         = 64,
+        REQ_ALL                 = 0xFFFFFFF,
+    };
+
+    uint32_t                _reqMask        = static_cast<uint32_t>(REQ_ALL);
+    bool                    _running        = false;
+    bool                    _isConnected    = false;
+    AppSettings*            _appSettings    = nullptr;
+    MicrohardSettings*      _mhSettings    = nullptr;
+    bool            _enableVideo            = true;
+    bool            _enabled                = true;
+    bool            _linkConnected          = false;
+    bool            _needReboot             = false;
+    QTimer          _workTimer;
+    QString         _linkVidFormat;
+    int             _downlinkRSSI           = 0;
+    int             _uplinkRSSI             = 0;
+    QStringList     _decodeList;
+    int             _decodeIndex            = 0;
+    QStringList     _rateList;
+    int             _rateIndex              = 0;
+    QString         _serialNumber;
+    QString         _fwVersion;
+    Fact*           _radioMode              = nullptr;
+    Fact*           _radioChannel           = nullptr;
+    Fact*           _videoOutput            = nullptr;
+    Fact*           _videoMode              = nullptr;
+    Fact*           _videoRate              = nullptr;
+    QStringList     _radioModeList;
+    QStringList     _videoOutputList;
+    QStringList     _videoRateList;
+    QString         _rtspURI;
+    QString         _rtspAccount;
+    QString         _rtspPassword;
+    QString         _localIPAddr;
+    QString         _remoteIPAddr;
+    QString         _netMask;
+    QTime           _timeoutTimer;
+};

src/Microhard/MicrohardSettings.cc

+/****************************************************************************
+ *
+ *   (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.
+ *
+ ****************************************************************************/
+
+#include "MicrohardSettings.h"
+#include "SettingsManager.h"
+#include "QGCApplication.h"
+#include "VideoManager.h"
+
+//-----------------------------------------------------------------------------
+MicrohardSettings::MicrohardSettings(QObject* parent)
+    : MicrohardHandler(parent)
+{
+}
+
+//-----------------------------------------------------------------------------
+bool MicrohardSettings::start()
+{
+    qCDebug(MicrohardLog) << "Start Microhard Settings";
+    return false;
+//    return _start(MICROHARD_SETTINGS_PORT, QHostAddress(qgcApp()->toolbox()->microhardManager()->remoteIPAddr()));
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestLinkStatus()
+{
+    return _request("/v1/baseband.json");
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestDevInfo()
+{
+    return _request("/v1/device.json");
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestFreqScan()
+{
+    return _request("/v1/freqscan.json");
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestVideoSettings()
+{
+    return false;
+//    return _request(kVideoURI);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestRadioSettings()
+{
+    return false;
+//    return _request(kRadioURI);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestIPSettings()
+{
+    return false;
+//    return _request(kIPAddrURI);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::requestRTSPURISettings()
+{
+    return false;
+//    return _request(kRTSPURI);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::_request(const QString& request)
+{
+    /*
+    if(_tcpSocket) {
+        QString req = QString(kGetReq).arg(request);
+        //qCDebug(MicrohardVerbose) << "Request" << req;
+        _tcpSocket->write(req.toUtf8());
+        return true;
+    }
+    */
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::_post(const QString& post, const QString &postPayload)
+{
+    /*
+    if(_tcpSocket) {
+        QString req = QString(kPostReq).arg(post).arg(postPayload.size()).arg(postPayload);
+        qCDebug(MicrohardVerbose) << "Post" << req;
+        _tcpSocket->write(req.toUtf8());
+        return true;
+    }
+    */
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::setRadioSettings(const QString& mode, const QString& channel)
+{
+//    static const char* kRadioPost = "{\"mode\":\"%1\",\"freq\":\"%2\"}";
+//    QString post = QString(kRadioPost).arg(mode).arg(channel);
+    return false;
+//    return _post(kRadioURI, post);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::setVideoSettings(const QString& output, const QString& mode, const QString& rate)
+{
+    return false;
+/*
+    static const char* kVideoPost = "{\"decode\":\"%1\",\"mode\":\"%2\",\"maxbitrate\":\"%3\"}";
+    QString post = QString(kVideoPost).arg(output).arg(mode).arg(rate);
+    return _post(kVideoURI, post);
+    */
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::setRTSPSettings(const QString& uri, const QString& account, const QString& password)
+{
+    return false;
+//    static const char* kRTSPPost = "{\"rtspURI\":\"%1\",\"account\":\"%2\",\"passwd\":\"%3\"}";
+//    QString post = QString(kRTSPPost).arg(uri).arg(account).arg(password);
+//    return _post(kRTSPURI, post);
+}
+
+//-----------------------------------------------------------------------------
+bool
+MicrohardSettings::setIPSettings(const QString& localIP, const QString& remoteIP, const QString& netMask)
+{
+    return false;
+//    static const char* kRTSPPost = "{\"ipaddr\":\"%1\",\"netmask\":\"%2\",\"usbEthIp\":\"%3\"}";
+//    QString post = QString(kRTSPPost).arg(localIP).arg(netMask).arg(remoteIP);
+//    return _post(kIPAddrURI, post);
+}
+
+//-----------------------------------------------------------------------------
+void
+MicrohardSettings::_readBytes()
+{
+    QByteArray bytesIn = _tcpSocket->read(_tcpSocket->bytesAvailable());
+    //-- Go straight to Json payload
+    int idx = bytesIn.indexOf('{');
+    //-- We may receive more than one response within one TCP packet.
+    while(idx >= 0) {
+        bytesIn = bytesIn.mid(idx);
+        idx = bytesIn.indexOf('}');
+        if(idx > 0) {
+            QByteArray data = bytesIn.left(idx + 1);
+            emit updateSettings(data);
+            bytesIn = bytesIn.mid(idx+1);
+            idx = bytesIn.indexOf('{');
+        }
+    }
+}
+

src/Microhard/MicrohardSettings.h

+/****************************************************************************
+ *
+ *   (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.
+ *
+ ****************************************************************************/
+
+#pragma once
+
+#include "MicrohardHandler.h"
+
+class MicrohardSettings : public MicrohardHandler
+{
+    Q_OBJECT
+public:
+    explicit MicrohardSettings            (QObject* parent = nullptr);
+    bool    start                       () override;
+    bool    requestLinkStatus           ();
+    bool    requestDevInfo              ();
+    bool    requestFreqScan             ();
+    bool    requestVideoSettings        ();
+    bool    requestRadioSettings        ();
+    bool    requestIPSettings           ();
+    bool    requestRTSPURISettings      ();
+    bool    setRadioSettings            (const QString& mode, const QString& channel);
+    bool    setVideoSettings            (const QString& output, const QString& mode, const QString& rate);
+    bool    setRTSPSettings             (const QString& uri, const QString& account, const QString& password);
+    bool    setIPSettings               (const QString& localIP, const QString& remoteIP, const QString& netMask);
+
+signals:
+    void    updateSettings              (QByteArray jSonData);
+
+protected slots:
+    void    _readBytes                  () override;
+
+private:
+    bool    _request                    (const QString& request);
+    bool    _post                       (const QString& post, const QString& postPayload);
+};

src/QGCToolbox.h

@@ -36,6 +36,9 @@ class AirspaceManager;
 #if defined(QGC_GST_TAISYNC_ENABLED)
 class TaisyncManager;
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+class MicrohardManager;
+#endif
 
 /// This is used to manage all of our top level services/tools
 class QGCToolbox : public QObject {
@@ -67,6 +70,9 @@ public:
 #if defined(QGC_GST_TAISYNC_ENABLED)
     TaisyncManager*             taisyncManager          () { return _taisyncManager; }
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+    MicrohardManager*           microhardManager        () { return _microhardManager; }
+#endif
 
 private:
     void setChildToolboxes(void);
@@ -96,6 +102,9 @@ private:
     AirspaceManager*            _airspaceManager        = nullptr;
 #if defined(QGC_GST_TAISYNC_ENABLED)
     TaisyncManager*             _taisyncManager         = nullptr;
+#endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+    MicrohardManager*             _microhardManager         = nullptr;
 #endif
     friend class QGCApplication;
 };

src/QmlControls/QGroundControlQmlGlobal.cc

@@ -69,6 +69,9 @@ void QGroundControlQmlGlobal::setToolbox(QGCToolbox* toolbox)
 #if defined(QGC_GST_TAISYNC_ENABLED)
     _taisyncManager         = toolbox->taisyncManager();
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+    _microhardManager       = toolbox->microhardManager();
+#endif
 }
 
 void QGroundControlQmlGlobal::saveGlobalSetting (const QString& key, const QString& value)

src/QmlControls/QGroundControlQmlGlobal.h

@@ -28,6 +28,11 @@
 #else
 class TaisyncManager;
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+#include "MicrohardManager.h"
+#else
+class MicrohardManager;
+#endif
 
 #ifdef QT_DEBUG
 #include "MockLink.h"
@@ -68,6 +73,8 @@ public:
     Q_PROPERTY(bool                 airmapSupported     READ airmapSupported        CONSTANT)
     Q_PROPERTY(TaisyncManager*      taisyncManager      READ taisyncManager         CONSTANT)
     Q_PROPERTY(bool                 taisyncSupported    READ taisyncSupported       CONSTANT)
+    Q_PROPERTY(MicrohardManager*    microhardManager    READ microhardManager       CONSTANT)
+    Q_PROPERTY(bool                 microhardSupported  READ microhardSupported     CONSTANT)
 
     Q_PROPERTY(int      supportedFirmwareCount          READ supportedFirmwareCount CONSTANT)
     Q_PROPERTY(bool     px4ProFirmwareSupported         READ px4ProFirmwareSupported CONSTANT)
@@ -170,6 +177,13 @@ public:
     bool                    taisyncSupported    () { return false; }
 #endif
 
+    MicrohardManager*       microhardManager    ()  { return _microhardManager; }
+#if defined(QGC_GST_TAISYNC_ENABLED)
+    bool                    microhardSupported  () { return true; }
+#else
+    bool                    microhardSupported  () { return false; }
+#endif
+
     qreal zOrderTopMost             () { return 1000; }
     qreal zOrderWidgets             () { return 100; }
     qreal zOrderMapItems            () { return 50; }
@@ -230,6 +244,7 @@ private:
     FactGroup*              _gpsRtkFactGroup        = nullptr;
     AirspaceManager*        _airspaceManager        = nullptr;
     TaisyncManager*         _taisyncManager         = nullptr;
+    MicrohardManager*       _microhardManager       = nullptr;
 
     bool                    _skipSetupPage          = false;
 

src/Settings/App.SettingsGroup.json

@@ -221,4 +221,18 @@
     "type":             "bool",
     "defaultValue":     true
 }
-]
+,
+{
+    "name":             "enableMicrohard",
+    "shortDescription": "Enable Microhard Module Support",
+    "longDescription":  "Enable Microhard Module Support",
+    "type":             "bool",
+    "defaultValue":     false
+},
+{
+    "name":             "enableMicrohardVideo",
+    "shortDescription": "Enable Microhard Video Support",
+    "longDescription":  "Enable Microhard Video Support",
+    "type":             "bool",
+    "defaultValue":     true
+}]

src/Settings/AppSettings.cc

@@ -87,6 +87,8 @@ DECLARE_SETTINGSFACT(AppSettings, followTarget)
 DECLARE_SETTINGSFACT(AppSettings, apmStartMavlinkStreams)
 DECLARE_SETTINGSFACT(AppSettings, enableTaisync)
 DECLARE_SETTINGSFACT(AppSettings, enableTaisyncVideo)
+DECLARE_SETTINGSFACT(AppSettings, enableMicrohard)
+DECLARE_SETTINGSFACT(AppSettings, enableMicrohardVideo)
 
 DECLARE_SETTINGSFACT_NO_FUNC(AppSettings, indoorPalette)
 {

src/Settings/AppSettings.h

@@ -45,6 +45,8 @@ public:
     DEFINE_SETTINGFACT(followTarget)
     DEFINE_SETTINGFACT(enableTaisync)
     DEFINE_SETTINGFACT(enableTaisyncVideo)
+    DEFINE_SETTINGFACT(enableMicrohard)
+    DEFINE_SETTINGFACT(enableMicrohardVideo)
 
     // Although this is a global setting it only affects ArduPilot vehicle since PX4 automatically starts the stream from the vehicle side
     DEFINE_SETTINGFACT(apmStartMavlinkStreams)

src/api/QGCCorePlugin.cc

@@ -48,6 +48,10 @@ public:
         if(pTaisync)
             delete pTaisync;
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+        if(pMicrohard)
+            delete pMicrohard;
+#endif
 #if defined(QGC_AIRMAP_ENABLED)
         if(pAirmap)
             delete pAirmap;
@@ -72,6 +76,9 @@ public:
 #if defined(QGC_GST_TAISYNC_ENABLED)
     QmlComponentInfo* pTaisync                  = nullptr;
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+    QmlComponentInfo* pMicrohard                = nullptr;
+#endif
 #if defined(QGC_AIRMAP_ENABLED)
     QmlComponentInfo* pAirmap                   = nullptr;
 #endif
@@ -140,6 +147,12 @@ QVariantList &QGCCorePlugin::settingsPages()
             QUrl::fromUserInput(""));
         _p->settingsList.append(QVariant::fromValue(reinterpret_cast<QmlComponentInfo*>(_p->pTaisync)));
 #endif
+#if defined(QGC_GST_MICROHARD_ENABLED)
+        _p->pMicrohard = new QmlComponentInfo(tr("Microhard"),
+            QUrl::fromUserInput("qrc:/qml/MicrohardSettings.qml"),
+            QUrl::fromUserInput(""));
+        _p->settingsList.append(QVariant::fromValue(reinterpret_cast<QmlComponentInfo*>(_p->pMicrohard)));
+#endif
 #if defined(QGC_AIRMAP_ENABLED)
         _p->pAirmap = new QmlComponentInfo(tr("AirMap"),
             QUrl::fromUserInput("qrc:/qml/AirmapSettings.qml"),