master/MockLink_8h_source.html

#pragma once


#include "PX4/px4_custom_mode.h"

#include "LinkInterface.h"

#include "MAVLinkEnums.h"

#include "MAVLinkMessageType.h"

#include "QGCMAVLinkTypes.h"

#include "MockConfiguration.h"

#include "MockLinkPX4Calibration.h"

#include "MockLinkMissionItemHandler.h"


#include <QtCore/QElapsedTimer>

#include <QtCore/QList>

#include <QtCore/QMap>

#include <QtCore/QMutex>

#include <QtCore/QPair>

#include <QtCore/QSet>

#include <QtPositioning/QGeoCoordinate>


#include <array>

#include <atomic>


class MockLinkCamera;

class MockLinkFTP;

class MockLinkGimbal;

class MockLinkWorker;

class MockVideoStreamServer;

class QThread;


class MockLink : public LinkInterface

{

    Q_OBJECT

    friend class MockLinkFTP;

    friend class StandardModesTest;


public:

    explicit MockLink(SharedLinkConfigurationPtr &config, QObject *parent = nullptr);

    virtual ~MockLink();


    void run1HzTasks();

    void run10HzTasks();

    void run500HzTasks();

    void sendStatusTextMessages();


    bool shouldSendStatusText() const { return _sendStatusText; }


    bool isConnected() const final { return _connected; }

    void disconnect() final;


    Q_INVOKABLE void setCommLost(bool commLost) { _commLost = commLost; }

    Q_INVOKABLE void simulateConnectionRemoved();


    int vehicleId() const { return _vehicleSystemId; }

    MAV_AUTOPILOT getFirmwareType() const { return _firmwareType; }


    double vehicleLatitude() const { return _vehicleLatitude; }

    double vehicleLongitude() const { return _vehicleLongitude; }

    double vehicleAltitudeAMSL() const { return _vehicleAltitudeAMSL; }


    QGeoCoordinate homeCoordinate() const { return _homeCoordinate; }


    bool signingEnabled() const { return _signingEnabled; }


    void respondWithMavlinkMessage(const mavlink_message_t &msg);


    void sendStatusTextMessage(uint8_t severity, const QString &text);


    void setCalibrationPose(MockLinkPX4Calibration::Pose pose) const { _mockLinkPX4Calibration->setPose(pose); }


    MockLinkFTP *mockLinkFTP() const;

    MockLinkGimbal *mockLinkGimbal() const { return _mockLinkGimbal; }


    void setVehicleAttitudeOverrideDeg(float rollDeg, float pitchDeg, float yawDeg);

    void clearVehicleAttitudeOverride();


    void setArmed(bool armed) { if (armed) _mavBaseMode |= MAV_MODE_FLAG_SAFETY_ARMED; else _mavBaseMode &= ~MAV_MODE_FLAG_SAFETY_ARMED; }

    bool armed() const { return (_mavBaseMode & MAV_MODE_FLAG_SAFETY_ARMED) != 0; }


    void setMissionItemFailureMode(MockLinkMissionItemHandler::FailureMode_t failureMode, MAV_MISSION_RESULT failureAckResult) const { _missionItemHandler->setFailureMode(failureMode, failureAckResult); }


    void sendUnexpectedMissionAck(MAV_MISSION_RESULT ackType) const { _missionItemHandler->sendUnexpectedMissionAck(ackType); }


    void sendUnexpectedMissionItem() const { _missionItemHandler->sendUnexpectedMissionItem(); }


    void sendUnexpectedMissionRequest() const { _missionItemHandler->sendUnexpectedMissionRequest(); }


    void sendUnexpectedCommandAck(MAV_CMD command, MAV_RESULT ackResult);


    void resetMissionItemHandler() const { _missionItemHandler->reset(); }


    void loadSimpleMultirotorMission() const { _missionItemHandler->loadSimpleMultirotorMission(); }


    QString logDownloadFile() const { return _logDownloadFilename; }


    uint8_t outgoingMavlinkChannel() const { return _outgoingMavlinkChannel; }


    void clearReceivedMavCommandCounts() { _receivedMavCommandCountMap.clear(); _receivedMavCommandByCompCountMap.clear(); _receivedRequestMessageByCompAndMsgCountMap.clear(); }

    int receivedMavCommandCount(MAV_CMD command) const { return _receivedMavCommandCountMap.value(command, 0); }

    int receivedMavCommandCount(MAV_CMD command, int compId) const { return _receivedMavCommandByCompCountMap.value(command).value(compId, 0); }

    int receivedRequestMessageCount(int compId, int messageId) const { return _receivedRequestMessageByCompAndMsgCountMap.value(compId).value(messageId, 0); }

    void clearReceivedRequestMessageCounts() { _receivedRequestMessageCountMap.clear(); _receivedRequestMessageByCompAndMsgCountMap.clear(); }

    int receivedRequestMessageCount(uint32_t messageId) const { return _receivedRequestMessageCountMap.value(messageId, 0); }

    void clearReceivedMavlinkMessageCounts() { _receivedMavlinkMessageCountMap.clear(); _lastReceivedMavlinkMessageMap.clear(); _hashCheckRequestCount = 0; _missionItemHandler->clearRequestListCounts(); }

    int receivedMavlinkMessageCount(uint32_t messageId) const { return _receivedMavlinkMessageCountMap.value(messageId, 0); }


    bool lastReceivedMavlinkMessage(uint32_t messageId, mavlink_message_t &message) const {

        if (!_lastReceivedMavlinkMessageMap.contains(messageId)) {

            return false;

        }

        message = _lastReceivedMavlinkMessageMap.value(messageId);

        return true;

    }


    int receivedMissionRequestListCount(MAV_MISSION_TYPE type) const { return _missionItemHandler->requestListCount(type); }


    void bumpAvailableModesMonitorSequence() { ++_availableModesMonitorSeqNumber; }


    void setDuplicateResponses(bool duplicate) { _duplicateResponses = duplicate; }


    enum RequestMessageFailureMode_t {

        FailRequestMessageNone,

        FailRequestMessageCommandAcceptedMsgNotSent,

        FailRequestMessageCommandUnsupported,

        FailRequestMessageCommandNoResponse,

    };


    void setRequestMessageFailureMode(RequestMessageFailureMode_t failureMode) { _requestMessageFailureMode = failureMode; }


    void setRequestMessageNoResponse(uint32_t messageId, bool noResponse = true) {

        QMutexLocker locker(&_requestMessageNoResponseMutex);

        if (noResponse) {

            _requestMessageNoResponseIds.insert(messageId);

        } else {

            _requestMessageNoResponseIds.remove(messageId);

        }

    }


    enum ParamSetFailureMode_t {

        FailParamSetNone,

        FailParamSetNoAck,

        FailParamSetFirstAttemptNoAck,

        FailParamSetParamError,

    };


    void setParamSetFailureMode(ParamSetFailureMode_t mode) {

        _paramSetFailureMode = mode;

        _paramSetFailureFirstAttemptPending = (mode == FailParamSetFirstAttemptNoAck);

    }


    enum ParamRequestReadFailureMode_t {

        FailParamRequestReadNone,

        FailParamRequestReadNoResponse,

        FailParamRequestReadFirstAttemptNoResponse,

        FailParamRequestReadParamError,

    };


    void setParamRequestReadFailureMode(ParamRequestReadFailureMode_t mode) {

        _paramRequestReadFailureMode = mode;

        _paramRequestReadFailureFirstAttemptPending = (mode == FailParamRequestReadFirstAttemptNoResponse);

    }


    void setHashCheckNoResponse(bool noResponse) { _hashCheckNoResponse = noResponse; }


    void setResetSysAutostartOnParamReset(bool reset) { _resetSysAutostartOnParamReset = reset; }


    int hashCheckRequestCount() const { return _hashCheckRequestCount; }

    QList<QPair<int, int>> paramRequestReadIndexLog() const { return _paramRequestReadIndexLog; }


    void setMockParamValue(int componentId, const QString &paramName, float value);


    void startAPMStaleFailedMagCalReportStreaming();


    bool apmStaleFailedMagCalReportStreamingActive() const;


    void setAPMMagCalStartFailureMode(bool fail) { _apmMagCalStartFailureMode = fail; }


    void setInt32ParamValue(int componentId, const QString &paramName, int32_t value) { _mapParamName2Value[componentId][paramName] = QVariant::fromValue(value); }


    QVariant paramValue(int componentId, const QString &paramName) const { return _mapParamName2Value.value(componentId).value(paramName); }


    void setRemoteIDArmStatus(uint8_t status, const QString& error);


    static MockLink *startPX4MockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *startMockLink(MockConfiguration *mockConfig) { return _startMockLink(mockConfig); }

    static MockLink *startPX4MockLinkWithMission(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone);

    static MockLink *startGenericMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *startNoInitialConnectMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone);

    static MockLink *startAPMArduCopterMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *startAPMArduPlaneMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *startAPMArduSubMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *startAPMArduRoverMockLink(MockConfiguration::Options options = MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode = MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);


    void servedVideoStream(MockConfiguration::VideoStreamType &type, QString &uri) const;


    MockConfiguration::VideoStreamType requestedVideoStreamType() const { return _requestedVideoStreamType; }


    // Special commands for testing Vehicle::sendMavCommandWithHandler

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_ALWAYS_RESULT_ACCEPTED = MAV_CMD_USER_1;

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_ALWAYS_RESULT_FAILED = MAV_CMD_USER_2;

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_ACCEPTED = MAV_CMD_USER_3;

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_FAILED = MAV_CMD_USER_4;

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_NO_RESPONSE = MAV_CMD_USER_5;

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_NO_RESPONSE_NO_RETRY = static_cast<MAV_CMD>(MAV_CMD_USER_5 + 1);

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_ACCEPTED = static_cast<MAV_CMD>(MAV_CMD_USER_5 + 2);

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_FAILED = static_cast<MAV_CMD>(MAV_CMD_USER_5 + 3);

    static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_NO_ACK = static_cast<MAV_CMD>(MAV_CMD_USER_5 + 4);


signals:

    void writeBytesQueuedSignal(const QByteArray &bytes);

    void highLatencyTransmissionEnabledChanged(bool highLatencyTransmissionEnabled);


private slots:

    void _writeBytes(const QByteArray &bytes) final;

    void _writeBytesQueued(const QByteArray &bytes);


private:

    typedef struct {

        const char *name;

        uint8_t standard_mode;

        uint32_t custom_mode;

        bool canBeSet;

        bool advanced;

    } FlightMode_t;


    bool _connect() final;

    bool _allocateMavlinkChannel() final;

    void _freeMavlinkChannel() final;


    bool _incomingMavlinkChannelIsSet() const;

    bool _outgoingMavlinkChannelIsSet() const;


    void _loadParams();

    void _resetParamsToDefaults();

    void _applyAPMFreshFlashState();


    float _floatUnionForParam(int componentId, const QString &paramName);

    uint32_t _computeParamHash(int componentId) const;

    void _setParamFloatUnionIntoMap(int componentId, const QString &paramName, float paramFloat);


    void _handleIncomingNSHBytes(const char *bytes, int cBytes);

    void _handleIncomingMavlinkBytes(const uint8_t *bytes, int cBytes);

    void _updateIncomingMessageCounts(const mavlink_message_t &msg);

    void _handleIncomingMavlinkMsg(const mavlink_message_t &msg);

    void _handleHeartBeat(const mavlink_message_t &msg);

    void _handleSetMode(const mavlink_message_t &msg);

    void _handleParamRequestList(const mavlink_message_t &msg);

    void _handleParamSet(const mavlink_message_t &msg);

    void _handleParamRequestRead(const mavlink_message_t &msg);

    bool _shouldSkipParamSend(int componentId, const QString &paramName, int paramIndex) const;

    bool _shouldSkipParamRead(int componentId, const QString &paramName, int paramIndex);

    bool _hasNonDefaultParamComponent() const;

    void _handleFTP(const mavlink_message_t &msg);

    void _handleCommandLong(const mavlink_message_t &msg);

    void _handleCommandInt(const mavlink_message_t &msg);

    void _handleInProgressCommandLong(const mavlink_command_long_t &request);

    void _handleCommandLongSetMessageInterval(const mavlink_command_long_t &request, bool &acccepted);

    void _handleManualControl(const mavlink_message_t &msg);

    void _handleRCChannelsOverride(const mavlink_message_t &msg);

    void _handlePreFlightCalibration(const mavlink_command_long_t &request);

    void _handleTakeoff(const mavlink_command_long_t &request);

    void _handleLogRequestList(const mavlink_message_t &msg);

    void _handleLogErase(const mavlink_message_t &msg);

    void _handleLogRequestData(const mavlink_message_t &msg);

    void _handleParamMapRC(const mavlink_message_t &msg);

    void _handleSetupSigning(const mavlink_message_t &msg);

    void _sendParamError(int componentId, const char *paramId, int16_t paramIndex, uint8_t errorCode);

    void _handleRequestMessage(const mavlink_command_long_t &request, bool &accepted, bool &noAck);

    void _handleRequestMessageAutopilotVersion(const mavlink_command_long_t &request, bool &accepted);

    void _handleRequestMessageDebug(const mavlink_command_long_t &request, bool &accepted, bool &noAck);

    void _handleRequestMessageAvailableModes(const mavlink_command_long_t &request, bool &accepted);


    void _sendHeartBeat();

    void _sendHighLatency2();

    void _sendHomePosition();

    void _sendGpsRawInt();

    void _sendGlobalPositionInt();

    void _sendExtendedSysState();

    void _sendVibration();

    void _sendSysStatus();

    void _sendBatteryStatus();

    void _sendNamedValueFloats();

    void _sendDistanceSensors();

    void _sendChunkedStatusText(uint16_t chunkId, bool missingChunks);

    void _sendStatusTextMessages();

    void _respondWithAutopilotVersion();

    void _sendRCChannels();

    void _sendADSBVehicles();

    void _sendGeneralMetaData();

    void _sendRemoteIDArmStatus();

    void _sendEscInfo();

    void _sendEscStatus();

    void _sendRadioStatus();

    void _sendAvailableModesMonitor();

    void _sendAttitudeQuaternion();

    void _sendAttitudeTarget();

    void _sendLocalPositionNed();

    void _sendPositionTargetLocalNed();


    void _paramRequestListWorker();

    void _logDownloadWorker();

    void _availableModesWorker();

    void _apmCompassCalWorker();

    void _apmAccelCalWorker();

    void _sendAvailableMode(uint8_t modeIndexOneBased);

    int  _availableModesCount() const;

    void _moveADSBVehicle(int vehicleIndex);


    static MockLink *_startMockLinkWorker(const QString &configName, MAV_AUTOPILOT firmwareType, MAV_TYPE vehicleType, MockConfiguration::Options options, MockConfiguration::FailureMode_t failureMode, MockConfiguration::VideoStreamType videoStreamType = MockConfiguration::VideoStreamNone);

    static MockLink *_startMockLink(MockConfiguration *mockConfig);


    void _startVideoStreamServer();

    void _stopVideoStreamServer();


    static QString _createRandomFile(uint32_t byteCount);

    QString _createLogContentsFile(const QString &logName);


    QThread *_workerThread = nullptr;

    MockLinkWorker *_worker = nullptr;


    const MockConfiguration *_mockConfig = nullptr;

    const MAV_AUTOPILOT _firmwareType = MAV_AUTOPILOT_PX4;

    const MAV_TYPE _vehicleType = MAV_TYPE_QUADROTOR;

    const bool _sendStatusText = false;

    const bool _apmStartFreshParams = false;

    const bool _enableCamera = false;

    const bool _enableGimbal = false;

    const bool _enableProximity = false;

    const bool _enableADSB = _mockConfig->enableADSB();

    const MockConfiguration::FailureMode_t _failureMode = MockConfiguration::FailNone;

    const bool _stayMavlinkV1 = false;

    const bool _ftpCapability = false;

    const bool _sendRadioStatusEnabled = true;

    const uint8_t _vehicleSystemId = 0;

    const QGeoCoordinate _homeCoordinate = MockConfiguration::homeCoordinate(_mockConfig->homeLocationEnum());

    const double _defaultVehicleLatitude = _homeCoordinate.latitude();

    const double _defaultVehicleLongitude = _homeCoordinate.longitude();

    const double _defaultVehicleHomeAltitude = _homeCoordinate.altitude();

    const double _vehicleLatitude = 0.0;

    const double _vehicleLongitude = 0.0;

    // These are just set for reporting the fields in _respondWithAutopilotVersion()

    // and ensuring that the Vehicle reports the fields in Vehicle::firmwareBoardVendorId etc.

    // They do not control any mock simulation (and it is up to the Custom build to do that).

    const uint16_t _boardVendorId = 0;

    const uint16_t _boardProductId = 0;

    MockLinkMissionItemHandler *const _missionItemHandler = nullptr;

    MockLinkCamera *const _mockLinkCamera = nullptr;

    MockLinkGimbal *const _mockLinkGimbal = nullptr;

    MockLinkPX4Calibration *const _mockLinkPX4Calibration = nullptr;

    MockLinkFTP *const _mockLinkFTP = nullptr;


    // Written by test thread, read by worker thread in _sendAttitudeQuaternion; one lock so a frame never mixes old and new angles

    struct AttitudeOverride {

        bool enabled = false;

        float rollRad = 0.0f;

        float pitchRad = 0.0f;

        float yawRad = 0.0f;

    };

    mutable QMutex _attitudeOverrideMutex;

    AttitudeOverride _attitudeOverride;


    const MockConfiguration::VideoStreamType _requestedVideoStreamType = MockConfiguration::VideoStreamNone;

    MockVideoStreamServer *_videoStreamServer = nullptr;

    // Served state is written on the connect/disconnect thread and read from the worker

    // thread (MockLinkCamera), so it is guarded by _videoStreamMutex.

    mutable QMutex _videoStreamMutex;

    MockConfiguration::VideoStreamType _servedVideoStreamType = MockConfiguration::VideoStreamNone;

    QString _videoStreamUri;


    uint8_t _incomingMavlinkChannel = std::numeric_limits<uint8_t>::max();

    QMutex _incomingMavlinkMutex;

    uint8_t _outgoingMavlinkChannel = std::numeric_limits<uint8_t>::max();


    mavlink_signing_t _mockSigning{};

    mavlink_signing_streams_t _mockSigningStreams{};


    bool _connected = false;

    bool _inNSH = false;


    uint8_t _mavBaseMode = MAV_MODE_FLAG_MANUAL_INPUT_ENABLED | MAV_MODE_FLAG_CUSTOM_MODE_ENABLED;

    uint32_t _mavCustomMode = PX4CustomMode::MANUAL;


    QElapsedTimer _runningTime;

    static constexpr int kTestParamRequestListBatch = 25;

    static constexpr int32_t _batteryMaxTimeRemaining = 15 * 60;

    int8_t _battery1PctRemaining = 100;

    int32_t _battery1TimeRemaining = _batteryMaxTimeRemaining;

    MAV_BATTERY_CHARGE_STATE _battery1ChargeState = MAV_BATTERY_CHARGE_STATE_OK;

    int8_t _battery2PctRemaining = 100;

    int32_t _battery2TimeRemaining = _batteryMaxTimeRemaining;

    MAV_BATTERY_CHARGE_STATE _battery2ChargeState = MAV_BATTERY_CHARGE_STATE_OK;


    double _vehicleAltitudeAMSL = _defaultVehicleHomeAltitude;

    std::atomic<bool> _commLost = false;

    std::atomic<bool> _duplicateResponses = false;

    bool _mavlinkV2Upgraded = false;

    bool _signingEnabled = false;

    bool _highLatencyTransmissionEnabled = true;


    int _sendHomePositionDelayCount = 10;

    int _sendGPSPositionDelayCount = 100;


    int _currentParamRequestListComponentIndex = -1;

    int _currentParamRequestListParamIndex = -1;

    QList<int> _paramRequestListComponentIds;

    QStringList _paramRequestListParamNames;

    QMutex _paramRequestListMutex;


    // Mavlink standard modes worker information

    int _availableModesWorkerNextModeIndex = 0;

    QMutex _availableModesWorkerMutex;

    std::atomic<uint8_t> _availableModesMonitorSeqNumber = 0;


    QString _logDownloadFilename;

    bool _logsErased = false;

    uint16_t _logDownloadId = 0;

    uint32_t _logDownloadSize = 0;

    uint32_t _logDownloadCurrentOffset = 0;

    uint32_t _logDownloadBytesRemaining = 0;

    QMutex _logDownloadMutex;


    RequestMessageFailureMode_t _requestMessageFailureMode = FailRequestMessageNone;

    mutable QMutex _requestMessageNoResponseMutex;

    QSet<uint32_t> _requestMessageNoResponseIds;

    ParamSetFailureMode_t _paramSetFailureMode = FailParamSetNone;

    bool _paramSetFailureFirstAttemptPending = false;

    ParamRequestReadFailureMode_t _paramRequestReadFailureMode = FailParamRequestReadNone;

    bool _paramRequestReadFailureFirstAttemptPending = false;

    bool _hashCheckNoResponse = false;

    int _hashCheckRequestCount = 0;

    QList<QPair<int, int>> _paramRequestReadIndexLog;

    bool _paramRequestListHashCheckSent = false;

    bool _resetSysAutostartOnParamReset = false;


    // Periodic OPEN_DRONE_ID_ARM_STATUS content (overridable via setRemoteIDArmStatus).

    // Written by the test (main) thread, read by the 1Hz worker: guarded by _remoteIDArmStatusMutex.

    QMutex _remoteIDArmStatusMutex;

    uint8_t _remoteIDArmStatus = MAV_ODID_ARM_STATUS_GOOD_TO_ARM;

    QString _remoteIDArmStatusError = QStringLiteral("No Error");


    // APM compass calibration worker state

    // Protects _apmCompassCalProgress: main thread writes 0 to start/stop,

    // worker thread reads/increments each 100ms tick.

    mutable QMutex _apmCompassCalMutex;

    int    _apmCompassCalProgress  = -1;

    int    _apmCompassCalTickCount = 0;

    bool   _apmStaleFailedMagCalReportStreaming = false;

    bool   _apmMagCalStartFailureMode = false;


    // APM accel calibration worker state

    // Protects _apmAccelCalPos: main thread writes the starting pos,

    // worker thread reads and advances through the sequence.

    QMutex _apmAccelCalMutex;

    static constexpr ACCELCAL_VEHICLE_POS kAPMAccelCalPosSequence[] = {

        ACCELCAL_VEHICLE_POS_LEVEL,

        ACCELCAL_VEHICLE_POS_LEFT,

        ACCELCAL_VEHICLE_POS_RIGHT,

        ACCELCAL_VEHICLE_POS_NOSEDOWN,

        ACCELCAL_VEHICLE_POS_NOSEUP,

        ACCELCAL_VEHICLE_POS_BACK,

    };

    int  _apmAccelCalPosIndex   = -1;

    bool _apmAccelCalGotAck     = false;

    int  _apmAccelCalTickCount  = 0;


    struct RCChannelOverride {

        enum class State { Ignore, Overridden, Released } state = State::Ignore;

        uint16_t value = 0;

    };

    static constexpr int kRcChannelOverrideChannelCount = 18;

    std::array<RCChannelOverride, kRcChannelOverrideChannelCount> _rcChannelOverrides;


    QMap<MAV_CMD, int> _receivedMavCommandCountMap;

    QMap<MAV_CMD, QMap<int, int>> _receivedMavCommandByCompCountMap;

    QMap<uint32_t, int> _receivedRequestMessageCountMap;

    QMap<int, QMap<int, int>> _receivedRequestMessageByCompAndMsgCountMap;

    QMap<uint32_t, int> _receivedMavlinkMessageCountMap;

    QMap<uint32_t, mavlink_message_t> _lastReceivedMavlinkMessageMap;

    QMap<int, QMap<QString, QVariant>> _mapParamName2Value;

    QMap<int, QMap<QString, MAV_PARAM_TYPE>> _mapParamName2MavParamType;


    struct ADSBVehicle {

        QGeoCoordinate coordinate;

        double angle = 0.0;

        double altitude = 0.0;

    };

    QList<ADSBVehicle> _adsbVehicles;

    QList<QGeoCoordinate> _adsbVehicleCoordinates;

    static constexpr int _numberOfVehicles = 5;

    double _adsbAngles[_numberOfVehicles]{};


    static std::atomic<int> _nextVehicleSystemId;


    static constexpr const char *_failParam = "COM_FLTMODE6";


    static constexpr uint8_t _vehicleComponentId = MAV_COMP_ID_AUTOPILOT1;


    // Simulated DroneCAN node exposed as its own param component (FailMissingParamOnAllRequestsNonDefaultComponent and friends)

    static constexpr uint8_t _nonDefaultParamComponentId = 125;

    static constexpr const char *_nonDefaultFailParam = "BATT_MONITOR";

    static constexpr int _sharedFailParamIndex = 1;

    static constexpr int _nonDefaultStreamedParamCount = 2;

    QSet<QPair<int, int>> _nonDefaultReadAttempted;


    static constexpr uint16_t _logDownloadLogId = 0;

    static constexpr uint32_t _logDownloadFileSize = 1000;


    static constexpr bool _mavlinkStarted = true;


    inline static const QSet<QString> kAPMCalOffsetParams = {

        QStringLiteral("COMPASS_OFS_X"),  QStringLiteral("COMPASS_OFS_Y"),  QStringLiteral("COMPASS_OFS_Z"),

        QStringLiteral("COMPASS_OFS2_X"), QStringLiteral("COMPASS_OFS2_Y"), QStringLiteral("COMPASS_OFS2_Z"),

        QStringLiteral("COMPASS_OFS3_X"), QStringLiteral("COMPASS_OFS3_Y"), QStringLiteral("COMPASS_OFS3_Z"),

        QStringLiteral("INS_ACCOFFS_X"),  QStringLiteral("INS_ACCOFFS_Y"),  QStringLiteral("INS_ACCOFFS_Z"),

    };


    static QList<FlightMode_t> _availableFlightModes;

    static QList<FlightMode_t> _apmCopterAvailableFlightModes;

    static QList<FlightMode_t> _apmPlaneAvailableFlightModes;

    static QList<FlightMode_t> _apmRoverAvailableFlightModes;

    static QList<FlightMode_t> _apmSubAvailableFlightModes;


    const QList<FlightMode_t> &_flightModeList() const;


    std::atomic<bool> _disconnectedEmitted{false};

};


config
Config config
Definition GstSourceFactory.cc:183

SharedLinkConfigurationPtr
std::shared_ptr< LinkConfiguration > SharedLinkConfigurationPtr
Definition LinkConfiguration.h:181

LinkInterface.h

MAVLinkMessageType.h

MockConfiguration.h

MockLinkMissionItemHandler.h

MockLinkPX4Calibration.h

error
Error error
Definition QGCCompression.cc:114

mavlink_message_t
struct __mavlink_message mavlink_message_t
Definition QGCCorePlugin.h:26

QGCMAVLinkTypes.h

mavlink_command_long_t
struct __mavlink_command_long_t mavlink_command_long_t
Definition QGCMAVLinkTypes.h:25

latitude
int32_t latitude
Definition UBXPlan.cc:40

longitude
int32_t longitude
Definition UBXPlan.cc:42

ADSBVehicle
Definition ADSBVehicle.h:12

LinkInterface
The link interface defines the interface for all links used to communicate with the ground station ap...
Definition LinkInterface.h:19

MockConfiguration
Definition MockConfiguration.h:9

MockConfiguration::VideoStreamType
VideoStreamType
Definition MockConfiguration.h:63

MockConfiguration::VideoStreamNone
@ VideoStreamNone
No stream served.
Definition MockConfiguration.h:64

MockConfiguration::FailureMode_t
FailureMode_t
Definition MockConfiguration.h:191

MockConfiguration::FailNone
@ FailNone
No failures.
Definition MockConfiguration.h:192

MockConfiguration::OptionNone
@ OptionNone
Definition MockConfiguration.h:47

MockLinkCamera
Simulates MAVLink Camera Protocol v2 components for MockLink.
Definition MockLinkCamera.h:40

MockLinkFTP
Mock implementation of Mavlink FTP server.
Definition MockLinkFTP.h:18

MockLinkGimbal
Simulates MAVLink Gimbal Manager Protocol for MockLink.
Definition MockLinkGimbal.h:28

MockLinkMissionItemHandler
Definition MockLinkMissionItemHandler.h:12

MockLinkMissionItemHandler::requestListCount
int requestListCount(MAV_MISSION_TYPE type) const
Definition MockLinkMissionItemHandler.h:73

MockLinkMissionItemHandler::sendUnexpectedMissionAck
void sendUnexpectedMissionAck(MAV_MISSION_RESULT ackType)
Called to send a MISSION_ACK message while the MissionManager is in idle state.
Definition MockLinkMissionItemHandler.cc:438

MockLinkMissionItemHandler::reset
void reset()
Reset the state of the MissionItemHandler to no items, no transactions in progress.
Definition MockLinkMissionItemHandler.h:65

MockLinkMissionItemHandler::setFailureMode
void setFailureMode(FailureMode_t failureMode, MAV_MISSION_RESULT failureAckResult)
Definition MockLinkMissionItemHandler.cc:455

MockLinkMissionItemHandler::clearRequestListCounts
void clearRequestListCounts()
Definition MockLinkMissionItemHandler.h:74

MockLinkMissionItemHandler::loadSimpleMultirotorMission
void loadSimpleMultirotorMission()
Definition MockLinkMissionItemHandler.cc:32

MockLinkMissionItemHandler::sendUnexpectedMissionRequest
void sendUnexpectedMissionRequest()
Called to send a MISSION_REQUEST message while the MissionManager is in idle state.
Definition MockLinkMissionItemHandler.cc:449

MockLinkMissionItemHandler::FailureMode_t
FailureMode_t
Definition MockLinkMissionItemHandler.h:27

MockLinkMissionItemHandler::sendUnexpectedMissionItem
void sendUnexpectedMissionItem()
Called to send a MISSION_ITEM message while the MissionManager is in idle state.
Definition MockLinkMissionItemHandler.cc:443

MockLinkPX4Calibration
Simulates the PX4 commander magnetometer and accelerometer calibration protocols for MockLink.
Definition MockLinkPX4Calibration.h:41

MockLinkPX4Calibration::Pose
Pose
Vehicle poses. Order matches the PX4 detect_orientation_return enum.
Definition MockLinkPX4Calibration.h:44

MockLinkPX4Calibration::setPose
void setPose(Pose pose)
Definition MockLinkPX4Calibration.cc:85

MockLinkWorker
Worker class that runs periodic tasks for MockLink simulation.
Definition MockLinkWorker.h:13

MockLink
Definition MockLink.h:31

MockLink::hashCheckRequestCount
int hashCheckRequestCount() const
Returns the number of standalone PARAM_REQUEST_READ requests for _HASH_CHECK received.
Definition MockLink.h:189

MockLink::setCommLost
Q_INVOKABLE void setCommLost(bool commLost)
Definition MockLink.h:50

MockLink::servedVideoStream
void servedVideoStream(MockConfiguration::VideoStreamType &type, QString &uri) const
Definition MockLink.cc:396

MockLink::resetMissionItemHandler
void resetMissionItemHandler() const
Reset the state of the MissionItemHandler to no items, no transactions in progress.
Definition MockLink.h:104

MockLink::setVehicleAttitudeOverrideDeg
void setVehicleAttitudeOverrideDeg(float rollDeg, float pitchDeg, float yawDeg)
Definition MockLink.cc:3407

MockLink::setCalibrationPose
void setCalibrationPose(MockLinkPX4Calibration::Pose pose) const
Test API: places the simulated vehicle into the given pose during calibration.
Definition MockLink.h:73

MockLink::vehicleAltitudeAMSL
double vehicleAltitudeAMSL() const
Definition MockLink.h:58

MockLink::signingEnabled
bool signingEnabled() const
Definition MockLink.h:63

MockLink::loadSimpleMultirotorMission
void loadSimpleMultirotorMission() const
Test-only: seeds a simple multirotor mission (takeoff, waypoint, RTL) onto the simulated vehicle.
Definition MockLink.h:107

MockLink::paramRequestReadIndexLog
QList< QPair< int, int > > paramRequestReadIndexLog() const
Index-based PARAM_REQUEST_READs received, in arrival order: (componentId, paramIndex)
Definition MockLink.h:191

MockLink::setRequestMessageFailureMode
void setRequestMessageFailureMode(RequestMessageFailureMode_t failureMode)
Definition MockLink.h:146

MockLink::homeCoordinate
QGeoCoordinate homeCoordinate() const
Configured home position, before the per-vehicle offset applied to the vehicle position.
Definition MockLink.h:61

MockLink::lastReceivedMavlinkMessage
bool lastReceivedMavlinkMessage(uint32_t messageId, mavlink_message_t &message) const
Returns the last received message with the given id. Returns false if none received.
Definition MockLink.h:124

MockLink::RequestMessageFailureMode_t
RequestMessageFailureMode_t
Definition MockLink.h:140

MockLink::FailRequestMessageCommandAcceptedMsgNotSent
@ FailRequestMessageCommandAcceptedMsgNotSent
Definition MockLink.h:142

MockLink::FailRequestMessageCommandNoResponse
@ FailRequestMessageCommandNoResponse
Definition MockLink.h:144

MockLink::FailRequestMessageCommandUnsupported
@ FailRequestMessageCommandUnsupported
Definition MockLink.h:143

MockLink::FailRequestMessageNone
@ FailRequestMessageNone
Definition MockLink.h:141

MockLink::receivedMavCommandCount
int receivedMavCommandCount(MAV_CMD command) const
Definition MockLink.h:116

MockLink::setParamRequestReadFailureMode
void setParamRequestReadFailureMode(ParamRequestReadFailureMode_t mode)
Definition MockLink.h:176

MockLink::sendUnexpectedMissionAck
void sendUnexpectedMissionAck(MAV_MISSION_RESULT ackType) const
Called to send a MISSION_ACK message while the MissionManager is in idle state.
Definition MockLink.h:93

MockLink::sendUnexpectedMissionRequest
void sendUnexpectedMissionRequest() const
Called to send a MISSION_REQUEST message while the MissionManager is in idle state.
Definition MockLink.h:99

MockLink::writeBytesQueuedSignal
void writeBytesQueuedSignal(const QByteArray &bytes)

MockLink::setMockParamValue
void setMockParamValue(int componentId, const QString &paramName, float value)
Change a float parameter value directly on MockLink (for testing cache invalidation)
Definition MockLink.cc:1533

MockLink::run10HzTasks
void run10HzTasks()
Definition MockLink.cc:457

MockLink::setResetSysAutostartOnParamReset
void setResetSysAutostartOnParamReset(bool reset)
Definition MockLink.h:186

MockLink::armed
bool armed() const
Definition MockLink.h:85

MockLink::clearReceivedRequestMessageCounts
void clearReceivedRequestMessageCounts()
Definition MockLink.h:119

MockLink::sendStatusTextMessage
void sendStatusTextMessage(uint8_t severity, const QString &text)
Definition MockLink.cc:2898

MockLink::clearVehicleAttitudeOverride
void clearVehicleAttitudeOverride()
Definition MockLink.cc:3416

MockLink::MAV_CMD_MOCKLINK_ALWAYS_RESULT_ACCEPTED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_ALWAYS_RESULT_ACCEPTED
Definition MockLink.h:241

MockLink::startPX4MockLinkWithMission
static MockLink * startPX4MockLinkWithMission(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone)
Definition MockLink.cc:2792

MockLink::vehicleId
int vehicleId() const
Definition MockLink.h:53

MockLink::shouldSendStatusText
bool shouldSendStatusText() const
Definition MockLink.h:45

MockLink::ParamSetFailureMode_t
ParamSetFailureMode_t
Definition MockLink.h:159

MockLink::FailParamSetParamError
@ FailParamSetParamError
Respond with PARAM_ERROR (VALUE_OUT_OF_RANGE) instead of PARAM_VALUE.
Definition MockLink.h:163

MockLink::FailParamSetFirstAttemptNoAck
@ FailParamSetFirstAttemptNoAck
Skip ack on first attempt, respond to retry.
Definition MockLink.h:162

MockLink::FailParamSetNoAck
@ FailParamSetNoAck
Do not send PARAM_VALUE ack.
Definition MockLink.h:161

MockLink::FailParamSetNone
@ FailParamSetNone
Normal behavior.
Definition MockLink.h:160

MockLink::MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_ACCEPTED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_ACCEPTED
Definition MockLink.h:243

MockLink::startGenericMockLink
static MockLink * startGenericMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2797

MockLink::startAPMArduCopterMockLink
static MockLink * startAPMArduCopterMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2807

MockLink::outgoingMavlinkChannel
uint8_t outgoingMavlinkChannel() const
Vehicle-side channel used to encode outgoing (mock vehicle -> QGC) messages. Signing state lives here...
Definition MockLink.h:113

MockLink::mockLinkFTP
MockLinkFTP * mockLinkFTP() const
Definition MockLink.cc:3402

MockLink::startPX4MockLink
static MockLink * startPX4MockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2787

MockLink::clearReceivedMavCommandCounts
void clearReceivedMavCommandCounts()
Definition MockLink.h:115

MockLink::MAV_CMD_MOCKLINK_ALWAYS_RESULT_FAILED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_ALWAYS_RESULT_FAILED
Definition MockLink.h:242

MockLink::getFirmwareType
MAV_AUTOPILOT getFirmwareType() const
Definition MockLink.h:54

MockLink::startNoInitialConnectMockLink
static MockLink * startNoInitialConnectMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone)
Definition MockLink.cc:2802

MockLink::paramValue
QVariant paramValue(int componentId, const QString &paramName) const
Definition MockLink.h:214

MockLink::setDuplicateResponses
void setDuplicateResponses(bool duplicate)
Unit test support: sends every vehicle->QGC message twice, as when two links receive the same traffic...
Definition MockLink.h:138

MockLink::receivedRequestMessageCount
int receivedRequestMessageCount(uint32_t messageId) const
Definition MockLink.h:120

MockLink::receivedRequestMessageCount
int receivedRequestMessageCount(int compId, int messageId) const
Definition MockLink.h:118

MockLink::bumpAvailableModesMonitorSequence
void bumpAvailableModesMonitorSequence()
Definition MockLink.h:135

MockLink::startMockLink
static MockLink * startMockLink(MockConfiguration *mockConfig)
Starts a MockLink from a fully caller-configured MockConfiguration (ownership transfers to LinkManage...
Definition MockLink.h:222

MockLink::receivedMavCommandCount
int receivedMavCommandCount(MAV_CMD command, int compId) const
Definition MockLink.h:117

MockLink::disconnect
void disconnect() final
Definition MockLink.cc:293

MockLink::MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_FAILED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_SECOND_ATTEMPT_RESULT_FAILED
Definition MockLink.h:244

MockLink::startAPMArduSubMockLink
static MockLink * startAPMArduSubMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2817

MockLink::startAPMArduPlaneMockLink
static MockLink * startAPMArduPlaneMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2812

MockLink::logDownloadFile
QString logDownloadFile() const
Returns the filename for the simulated log file. Only available after a download is requested.
Definition MockLink.h:110

MockLink::run500HzTasks
void run500HzTasks()
Definition MockLink.cc:491

MockLink::respondWithMavlinkMessage
void respondWithMavlinkMessage(const mavlink_message_t &msg)
Sends the specified mavlink message to QGC.
Definition MockLink.cc:1102

MockLink::setMissionItemFailureMode
void setMissionItemFailureMode(MockLinkMissionItemHandler::FailureMode_t failureMode, MAV_MISSION_RESULT failureAckResult) const
Definition MockLink.h:90

MockLink::startAPMArduRoverMockLink
static MockLink * startAPMArduRoverMockLink(MockConfiguration::Options options=MockConfiguration::OptionNone, MockConfiguration::FailureMode_t failureMode=MockConfiguration::FailNone, MockConfiguration::VideoStreamType videoStreamType=MockConfiguration::VideoStreamNone)
Definition MockLink.cc:2822

MockLink::apmStaleFailedMagCalReportStreamingActive
bool apmStaleFailedMagCalReportStreamingActive() const
Returns true while the stale failed MAG_CAL_REPORT stream is active.
Definition MockLink.cc:3522

MockLink::MAV_CMD_MOCKLINK_NO_RESPONSE
static constexpr MAV_CMD MAV_CMD_MOCKLINK_NO_RESPONSE
Definition MockLink.h:245

MockLink::setRemoteIDArmStatus
void setRemoteIDArmStatus(uint8_t status, const QString &error)
Definition MockLink.cc:3295

MockLink::clearReceivedMavlinkMessageCounts
void clearReceivedMavlinkMessageCounts()
Definition MockLink.h:121

MockLink::StandardModesTest
friend class StandardModesTest
Definition MockLink.h:34

MockLink::setParamSetFailureMode
void setParamSetFailureMode(ParamSetFailureMode_t mode)
Definition MockLink.h:165

MockLink::~MockLink
virtual ~MockLink()
Definition MockLink.cc:246

MockLink::setInt32ParamValue
void setInt32ParamValue(int componentId, const QString &paramName, int32_t value)
Definition MockLink.h:210

MockLink::setArmed
void setArmed(bool armed)
Set the armed state of the simulated vehicle.
Definition MockLink.h:84

MockLink::vehicleLatitude
double vehicleLatitude() const
Definition MockLink.h:56

MockLink::requestedVideoStreamType
MockConfiguration::VideoStreamType requestedVideoStreamType() const
Video stream type the configuration requested (immutable after construction).
Definition MockLink.h:238

MockLink::vehicleLongitude
double vehicleLongitude() const
Definition MockLink.h:57

MockLink::receivedMavlinkMessageCount
int receivedMavlinkMessageCount(uint32_t messageId) const
Definition MockLink.h:122

MockLink::mockLinkGimbal
MockLinkGimbal * mockLinkGimbal() const
Definition MockLink.h:76

MockLink::MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_ACCEPTED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_ACCEPTED
Definition MockLink.h:247

MockLink::highLatencyTransmissionEnabledChanged
void highLatencyTransmissionEnabledChanged(bool highLatencyTransmissionEnabled)

MockLink::MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_FAILED
static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_FAILED
Definition MockLink.h:248

MockLink::sendUnexpectedCommandAck
void sendUnexpectedCommandAck(MAV_CMD command, MAV_RESULT ackResult)
Definition MockLink.cc:2366

MockLink::sendStatusTextMessages
void sendStatusTextMessages()
Definition MockLink.cc:513

MockLink::ParamRequestReadFailureMode_t
ParamRequestReadFailureMode_t
Definition MockLink.h:170

MockLink::FailParamRequestReadFirstAttemptNoResponse
@ FailParamRequestReadFirstAttemptNoResponse
Skip response on first attempt, respond to retry.
Definition MockLink.h:173

MockLink::FailParamRequestReadParamError
@ FailParamRequestReadParamError
Respond with PARAM_ERROR (DOES_NOT_EXIST) instead of PARAM_VALUE.
Definition MockLink.h:174

MockLink::FailParamRequestReadNone
@ FailParamRequestReadNone
Normal behavior.
Definition MockLink.h:171

MockLink::FailParamRequestReadNoResponse
@ FailParamRequestReadNoResponse
Do not respond to PARAM_REQUEST_READ.
Definition MockLink.h:172

MockLink::isConnected
bool isConnected() const final
Definition MockLink.h:47

MockLink::setHashCheckNoResponse
void setHashCheckNoResponse(bool noResponse)
Definition MockLink.h:181

MockLink::setAPMMagCalStartFailureMode
void setAPMMagCalStartFailureMode(bool fail)
Definition MockLink.h:206

MockLink::MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_NO_ACK
static constexpr MAV_CMD MAV_CMD_MOCKLINK_RESULT_IN_PROGRESS_NO_ACK
Definition MockLink.h:249

MockLink::sendUnexpectedMissionItem
void sendUnexpectedMissionItem() const
Called to send a MISSION_ITEM message while the MissionManager is in idle state.
Definition MockLink.h:96

MockLink::MAV_CMD_MOCKLINK_NO_RESPONSE_NO_RETRY
static constexpr MAV_CMD MAV_CMD_MOCKLINK_NO_RESPONSE_NO_RETRY
Definition MockLink.h:246

MockLink::setRequestMessageNoResponse
void setRequestMessageNoResponse(uint32_t messageId, bool noResponse=true)
Definition MockLink.h:150

MockLink::run1HzTasks
void run1HzTasks()
Definition MockLink.cc:403

MockLink::receivedMissionRequestListCount
int receivedMissionRequestListCount(MAV_MISSION_TYPE type) const
Definition MockLink.h:131

MockLink::startAPMStaleFailedMagCalReportStreaming
void startAPMStaleFailedMagCalReportStreaming()
Definition MockLink.cc:3515

MockLink::simulateConnectionRemoved
Q_INVOKABLE void simulateConnectionRemoved()
Definition MockLink.cc:3396

MockVideoStreamServer
Serves a synthetic (videotestsrc) live video stream for MockLink so the GStreamer receive pipeline ca...
Definition MockVideoStreamServer.h:25

NMEA::coordinate
std::optional< double > coordinate(std::string_view field, std::string_view hemisphere, bool latitude)
Definition NMEASentence.cc:147

TerrainQuery::State
State
Definition TerrainQueryInterface.h:19

px4_custom_mode.h

PX4CustomMode::MANUAL
@ MANUAL
Definition px4_custom_mode.h:67