FirmwarePlugin.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QVariantList>
#include <QtPositioning/QGeoCoordinate>
 
#include "MAVLinkEnums.h"
#include "QGCMAVLinkTypes.h"
#include "FollowMe.h"
#include "VehicleTypes.h"
 
class Vehicle;
 
class VehicleComponent;
class AutoPilotPlugin;
class FactMetaData;
class MavlinkCameraControlInterface;
class QGCCameraManager;
class Autotune;
class LinkInterface;
class FactGroup;
class ParameterMetaData;
 
struct FirmwareFlightMode
{
    FirmwareFlightMode(const QString &mName, uint32_t cMode, bool cbs = false, bool adv = false)
        : mode_name(mName)
        , custom_mode(cMode)
        , canBeSet(cbs)
        , advanced(adv)
    {
 
    }
 
    FirmwareFlightMode(const QString &mName, uint8_t sMode, uint32_t cMode,
                       bool cbs = false, bool adv = false,
                       bool fWing = false, bool mRotor = true
    )
        : mode_name(mName)
        , standard_mode(sMode)
        , custom_mode(cMode)
        , canBeSet(cbs)
        , advanced(adv)
        , fixedWing(fWing)
        , multiRotor(mRotor)
    {
 
    }
 
    QString mode_name = "Unknown";
    uint8_t standard_mode = 0;
    uint32_t custom_mode = UINT32_MAX;
    bool canBeSet = false;
    bool advanced = false;
    bool fixedWing = false;
    bool multiRotor = true;
};
 
/*===========================================================================*/
 
typedef QList<FirmwareFlightMode> FlightModeList;
typedef QMap<uint32_t,QString> FlightModeCustomModeMap;
 
class FirmwarePlugin : public QObject
{
    Q_OBJECT
 
public:
    explicit FirmwarePlugin(QObject *parent = nullptr);
    virtual ~FirmwarePlugin();
 
    enum FirmwareCapabilities {
        SetFlightModeCapability =   1 << 0, 
        PauseVehicleCapability =    1 << 1, 
        GuidedModeCapability =      1 << 2, 
        OrbitModeCapability =       1 << 3, 
        TakeoffVehicleCapability =  1 << 4, 
        ROIModeCapability =         1 << 5, 
        ChangeHeadingCapability =   1 << 6, 
        GuidedTakeoffCapability =   1 << 7, 
        VTOLMulticopterTakeoffCapability = 1 << 8, 
    };
 
 
    typedef QMap<QString, QString> remapParamNameMap_t;
 
    typedef QMap<int, remapParamNameMap_t> remapParamNameMinorVersionRemapMap_t;
 
    typedef QMap<int, remapParamNameMinorVersionRemapMap_t> remapParamNameMajorVersionMap_t;
 
    virtual AutoPilotPlugin *autopilotPlugin(Vehicle *vehicle) const;
 
    virtual void initializeVehicle(Vehicle* /*vehicle*/) {}
 
    virtual bool isCapable(const Vehicle* /*vehicle*/, FirmwareCapabilities /*capabilities*/) const { return false; }
 
    virtual QStringList flightModes(Vehicle* /*vehicle*/) const { return QStringList(); }
 
    virtual QString flightMode(uint8_t base_mode, uint32_t custom_mode) const;
 
    virtual bool setFlightMode(const QString &flightMode, uint8_t *base_mode, uint32_t *custom_mode) const;
 
    virtual bool MAV_CMD_DO_SET_MODE_is_supported() const { return false; }
 
    virtual QString pauseFlightMode() const { return QString(); }
 
    virtual QString missionFlightMode() const { return QString(); }
 
    virtual QString rtlFlightMode() const { return QString(); }
 
    virtual QString smartRTLFlightMode() const { return QString(); }
 
    virtual bool supportsSmartRTL() const { return false; }
 
    virtual QString landFlightMode() const { return QString(); }
 
    virtual QString takeOffFlightMode() const { return QString(); }
 
    virtual QString motorDetectionFlightMode() const { return QString(); }
 
    virtual QString stabilizedFlightMode() const { return QString(); }
 
    virtual QString takeControlFlightMode() const { return QString(); }
 
    virtual bool isGuidedMode(const Vehicle * /*vehicle*/) const { return false; }
 
    virtual QString gotoFlightMode() const { return QString(); }
 
    virtual QString followFlightMode() const { return QString(); }
 
    virtual void setGuidedMode(Vehicle *vehicle, bool guidedMode) const;
 
    virtual void pauseVehicle(Vehicle *vehicle) const;
 
    virtual void guidedModeRTL(Vehicle *vehicle, bool smartRTL) const;
 
    virtual void guidedModeLand(Vehicle *vehicle) const;
 
    virtual void guidedModeTakeoff(Vehicle *vehicle, double takeoffAltRel) const;
 
    virtual void guidedModeChangeHeading(Vehicle *vehicle, const QGeoCoordinate &headingCoord) const;
 
    virtual bool guidedModeROI(Vehicle *vehicle, const QGeoCoordinate &roiCenterCoord, double relativeAltitudeMeters) const;
 
    virtual double minimumTakeoffAltitudeMeters(Vehicle* /*vehicle*/) const { return 3.048; }
 
    virtual double maximumHorizontalSpeedMultirotorMetersSecond(Vehicle* /*vehicle*/) const { return NAN; }
 
    virtual double maximumEquivalentAirspeed(Vehicle* /*vehicle*/) const { return NAN; }
 
    virtual double minimumEquivalentAirspeed(Vehicle* /*vehicle*/) const { return NAN; }
 
    virtual bool hasGripper(const Vehicle* /*vehicle*/) const { return false; }
 
    virtual bool mulirotorSpeedLimitsAvailable(Vehicle* /*vehicle*/) const { return false; }
 
    virtual bool fixedWingAirSpeedLimitsAvailable(Vehicle* /*vehicle*/) const { return false; }
 
    virtual void startTakeoff(Vehicle *vehicle) const;
 
    virtual void startMission(Vehicle *vehicle) const;
 
    virtual bool guidedModeGotoLocation(Vehicle *vehicle, const QGeoCoordinate &gotoCoord, double forwardFlightLoiterRadius = 0.0) const;
 
    virtual void guidedModeChangeAltitude(Vehicle *vehicle, double altitudeChange, bool pauseVehicle);
 
    virtual void guidedModeChangeGroundSpeedMetersSecond(Vehicle *vehicle, double groundspeed) const;
 
    virtual void guidedModeChangeEquivalentAirspeedMetersSecond(Vehicle *vehicle, double airspeed_equiv) const;
 
    virtual int defaultJoystickTXMode() const { return 2; }
 
    virtual bool supportsThrottleModeCenterZero() const { return true; }
 
    virtual bool supportsNegativeThrust(Vehicle* /*vehicle*/) const { return false; }
 
    virtual bool supportsRadio() const { return true; }
 
    virtual bool supportsJSButton() const { return false; }
 
    virtual bool supportsMotorInterference() const { return true; }
 
    virtual bool adjustIncomingMavlinkMessage(Vehicle* /*vehicle*/, mavlink_message_t* /*message*/) { return true; }
 
    virtual void adjustOutgoingMavlinkMessageThreadSafe(Vehicle* /*vehicle*/, LinkInterface* /*outgoingLink*/, mavlink_message_t* /*message*/) {}
 
    virtual bool sendHomePositionToVehicle() const { return false; }
 
    virtual QList<MAV_CMD> supportedMissionCommands(QGCMAVLinkTypes::VehicleClass_t /*vehicleClass*/) const { return QList<MAV_CMD>(); }
 
    virtual QString missionCommandOverrides(QGCMAVLinkTypes::VehicleClass_t vehicleClass) const;
 
    virtual const remapParamNameMajorVersionMap_t &paramNameRemapMajorVersionMap() const;
 
    virtual int remapParamNameHigestMinorVersionNumber(int /*majorVersionNumber*/) const { return VehicleTypes::versionNotSetValue; }
 
    virtual bool multiRotorCoaxialMotors(Vehicle* /*vehicle*/) const { return false; }
 
    virtual bool multiRotorXConfig(Vehicle* /*vehicle*/) const { return false; }
 
    virtual QString offlineEditingParamFile(Vehicle* /*vehicle*/) const { return QString(); }
 
    virtual QString vehicleImageOpaque(const Vehicle* /*vehicle*/) const { return QStringLiteral("/qmlimages/vehicleArrowOpaque.svg"); }
 
    virtual QString vehicleImageOutline(const Vehicle* /*vehicle*/) const { return QStringLiteral("/qmlimages/vehicleArrowOutline.svg"); }
 
    virtual QVariant expandedToolbarIndicatorSource(const Vehicle* /*vehicle*/, const QString& /*indicatorName*/) const { return QVariant(); }
 
    virtual const QVariantList &toolIndicators(const Vehicle *vehicle);
 
    virtual QGCCameraManager *createCameraManager(Vehicle *vehicle) const;
 
    virtual MavlinkCameraControlInterface *createCameraControl(const mavlink_camera_information_t *info, Vehicle *vehicle, int compID, QObject *parent = nullptr) const;
 
    virtual QMap<QString, FactGroup*> *factGroups() { return nullptr; }
 
    virtual void batteryConsumptionData(Vehicle *vehicle, int &mAhBattery, double &hoverAmps, double &cruiseAmps) const;
 
    // Returns the parameter which control auto-disarm. Assume == 0 means no auto disarm
    virtual QString autoDisarmParameter(Vehicle* /*vehicle*/) const { return QString(); }
 
    virtual bool hasGimbal(Vehicle *vehicle, bool &rollSupported, bool &pitchSupported, bool &yawSupported) const;
 
    virtual uint32_t highLatencyCustomModeTo32Bits(uint16_t hlCustomMode) const { return hlCustomMode; }
 
    virtual void checkIfIsLatestStable(Vehicle *vehicle) const;
 
    static QString stableFirmwareSettingsKey(const Vehicle* vehicle);
 
    static bool isStableFirmwareVersionUnseen(const QString& latestVersion, const QString& seenVersion);
 
    int versionCompare(const Vehicle *vehicle, const QString &compare) const;
    int versionCompare(const Vehicle *vehicle, int major, int minor, int patch) const;
 
    virtual void adjustMetaData(MAV_TYPE /*vehicleType*/, FactMetaData* /*metaData*/) {}
 
    virtual void sendGCSMotionReport(Vehicle *vehicle, const FollowMe::GCSMotionReport &motionReport, uint8_t estimationCapabilities) const;
 
    virtual QString getHobbsMeter(Vehicle *vehicle) const { Q_UNUSED(vehicle); return QStringLiteral("Not Supported"); }
 
    virtual Autotune *createAutotune(Vehicle *vehicle) const;
 
    virtual void updateAvailableFlightModes(FlightModeList &flightModeList) { _updateFlightModeList(flightModeList); }
 
    ParameterMetaData *loadParameterMetaData(const Vehicle *vehicle);
    void cacheParameterMetaDataFile(const QString &metaDataFile);
 
signals:
    void toolIndicatorsChanged();
 
protected:
    bool _armVehicleAndValidate(Vehicle *vehicle) const;
 
    void _sendROICommand(Vehicle *vehicle, const QGeoCoordinate &coord, MAV_FRAME frame, float altitude) const;
 
    bool _setFlightModeAndValidate(Vehicle *vehicle, const QString &flightMode) const;
 
    virtual QString _internalParameterMetaDataFile(const Vehicle* /*vehicle*/) const { return QString(); }
    virtual MAV_AUTOPILOT _autopilotType() const { return MAV_AUTOPILOT_GENERIC; }
    virtual ParameterMetaData *_createParameterMetaData() { return nullptr; }
    QString _cachedParameterMetaDataFile(const Vehicle *vehicle) const;
 
    virtual QString _getLatestVersionFileUrl(Vehicle* /*vehicle*/) const { return QString(); }
 
    virtual void _versionFileDownloadFinished(const QString& remoteFile, const QString& localFile,
                                              Vehicle* vehicle) const;
 
    virtual QString _versionRegex() const { return QString(); }
 
    // Set Custom Mode mapping to Flight Mode String
    void _setModeEnumToModeStringMapping(FlightModeCustomModeMap enumToString) { _modeEnumToString = enumToString; }
 
    // Convert Base enum to Derived class Enums
    virtual uint32_t _convertToCustomFlightModeEnum(uint32_t val) const { return val; }
 
    // Update internal mappings for a list of flight modes
    void _updateFlightModeList(FlightModeList &flightModeList);
    void _addNewFlightMode(FirmwareFlightMode &flightMode);
 
    FlightModeList _flightModeList;
    FlightModeCustomModeMap _modeEnumToString;
 
    QVariantList _toolIndicatorList;
    QVariantList _modeIndicatorList;
};
 
/*===========================================================================*/
 
class FirmwarePluginInstanceData : public QObject
{
    Q_OBJECT
 
public:
    using QObject::QObject;
 
    // support for detecting whether the firmware a vehicle is running
    // supports a given MAV_CMD:
    enum class CommandSupportedResult : uint8_t {
        SUPPORTED = 23,
        UNSUPPORTED = 24,
        UNKNOWN = 25,
    };
    // anyVersionSupportsCommand returns true if any version of the
    // firmware has supported cmd.  Used so that extra round-trips to
    // the autopilot to probe for command support are not required.
    virtual CommandSupportedResult anyVersionSupportsCommand(MAV_CMD /*cmd*/) const { return CommandSupportedResult::UNKNOWN; }
 
    // support for detecting whether the firmware a vehicle is running
    // supports a given MAV_CMD:
    void setCommandSupported(MAV_CMD cmd, CommandSupportedResult status) { MAV_CMD_supported[cmd] = status; }
 
    CommandSupportedResult getCommandSupported(MAV_CMD cmd) const;
 
private:
    QMap<MAV_CMD, CommandSupportedResult> MAV_CMD_supported;
};