FirmwarePlugin.cc 21.2 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.
 *
 ****************************************************************************/
9

10
#include "FirmwarePlugin.h"
Don Gagne's avatar
Don Gagne committed
11
#include "QGCApplication.h"
12
#include "Generic/GenericAutoPilotPlugin.h"
13
#include "CameraMetaData.h"
14 15
#include "SettingsManager.h"
#include "AppSettings.h"
Don Gagne's avatar
Don Gagne committed
16 17 18

#include <QDebug>

19 20
static FirmwarePluginFactoryRegister* _instance = NULL;

21
const QString guided_mode_not_supported_by_vehicle = QObject::tr("Guided mode not supported by Vehicle.");
22

23 24
QVariantList FirmwarePlugin::_cameraList;

25
const QString FirmwarePlugin::px4FollowMeFlightMode(QObject::tr("Follow Me"));
26 27 28 29 30 31

FirmwarePluginFactory::FirmwarePluginFactory(void)
{
    FirmwarePluginFactoryRegister::instance()->registerPluginFactory(this);
}

32 33 34 35 36 37 38
QList<MAV_TYPE> FirmwarePluginFactory::supportedVehicleTypes(void) const
{
    QList<MAV_TYPE> vehicleTypes;
    vehicleTypes << MAV_TYPE_FIXED_WING << MAV_TYPE_QUADROTOR << MAV_TYPE_VTOL_QUADROTOR << MAV_TYPE_GROUND_ROVER << MAV_TYPE_SUBMARINE;
    return vehicleTypes;
}

39 40 41 42 43 44 45 46 47 48 49 50 51 52
FirmwarePluginFactoryRegister* FirmwarePluginFactoryRegister::instance(void)
{
    if (!_instance) {
        _instance = new FirmwarePluginFactoryRegister;
    }

    return _instance;
}

AutoPilotPlugin* FirmwarePlugin::autopilotPlugin(Vehicle* vehicle)
{
    return new GenericAutoPilotPlugin(vehicle, vehicle);
}

53
bool FirmwarePlugin::isCapable(const Vehicle *vehicle, FirmwareCapabilities capabilities)
Don Gagne's avatar
Don Gagne committed
54
{
55
    Q_UNUSED(vehicle);
Don Gagne's avatar
Don Gagne committed
56 57 58 59
    Q_UNUSED(capabilities);
    return false;
}

60
QList<VehicleComponent*> FirmwarePlugin::componentsForVehicle(AutoPilotPlugin* vehicle)
Don Gagne's avatar
Don Gagne committed
61 62
{
    Q_UNUSED(vehicle);
63

Don Gagne's avatar
Don Gagne committed
64 65 66
    return QList<VehicleComponent*>();
}

Don Gagne's avatar
Don Gagne committed
67
QString FirmwarePlugin::flightMode(uint8_t base_mode, uint32_t custom_mode) const
Don Gagne's avatar
Don Gagne committed
68 69
{
    QString flightMode;
70

Don Gagne's avatar
Don Gagne committed
71 72 73 74 75
    struct Bit2Name {
        uint8_t     baseModeBit;
        const char* name;
    };
    static const struct Bit2Name rgBit2Name[] = {
76 77 78 79 80 81
    { MAV_MODE_FLAG_MANUAL_INPUT_ENABLED,   "Manual" },
    { MAV_MODE_FLAG_STABILIZE_ENABLED,      "Stabilize" },
    { MAV_MODE_FLAG_GUIDED_ENABLED,         "Guided" },
    { MAV_MODE_FLAG_AUTO_ENABLED,           "Auto" },
    { MAV_MODE_FLAG_TEST_ENABLED,           "Test" },
};
82

Don Gagne's avatar
Don Gagne committed
83
    Q_UNUSED(custom_mode);
84

Don Gagne's avatar
Don Gagne committed
85 86 87 88 89 90 91 92 93 94 95 96 97 98
    if (base_mode == 0) {
        flightMode = "PreFlight";
    } else if (base_mode & MAV_MODE_FLAG_CUSTOM_MODE_ENABLED) {
        flightMode = QString("Custom:0x%1").arg(custom_mode, 0, 16);
    } else {
        for (size_t i=0; i<sizeof(rgBit2Name)/sizeof(rgBit2Name[0]); i++) {
            if (base_mode & rgBit2Name[i].baseModeBit) {
                if (i != 0) {
                    flightMode += " ";
                }
                flightMode += rgBit2Name[i].name;
            }
        }
    }
99

Don Gagne's avatar
Don Gagne committed
100 101 102
    return flightMode;
}

103
bool FirmwarePlugin::setFlightMode(const QString& flightMode, uint8_t* base_mode, uint32_t* custom_mode)
Don Gagne's avatar
Don Gagne committed
104 105 106 107
{
    Q_UNUSED(flightMode);
    Q_UNUSED(base_mode);
    Q_UNUSED(custom_mode);
108

109
    qWarning() << "FirmwarePlugin::setFlightMode called on base class, not supported";
110

Don Gagne's avatar
Don Gagne committed
111 112
    return false;
}
113

114
int FirmwarePlugin::manualControlReservedButtonCount(void)
115 116 117 118 119
{
    // We don't know whether the firmware is going to used any of these buttons.
    // So reserve them all.
    return -1;
}
Don Gagne's avatar
Don Gagne committed
120

121 122 123 124 125
int FirmwarePlugin::defaultJoystickTXMode(void)
{
    return 2;
}

126 127 128 129 130 131
bool FirmwarePlugin::supportsThrottleModeCenterZero(void)
{
    // By default, this is supported
    return true;
}

132 133 134 135 136 137
bool FirmwarePlugin::supportsNegativeThrust(void)
{
    // By default, this is not supported
    return false;
}

138 139 140 141 142
bool FirmwarePlugin::supportsRadio(void)
{
    return true;
}

143 144 145 146 147
bool FirmwarePlugin::supportsMotorInterference(void)
{
    return true;
}

148 149 150 151 152
bool FirmwarePlugin::supportsJSButton(void)
{
    return false;
}

153 154 155 156 157 158
bool FirmwarePlugin::supportsTerrainFrame(void) const
{
    // Generic firmware supports this since we don't know
    return true;
}

159
bool FirmwarePlugin::adjustIncomingMavlinkMessage(Vehicle* vehicle, mavlink_message_t* message)
Don Gagne's avatar
Don Gagne committed
160 161
{
    Q_UNUSED(vehicle);
162
    Q_UNUSED(message);
Don Gagne's avatar
Don Gagne committed
163
    // Generic plugin does no message adjustment
164
    return true;
Don Gagne's avatar
Don Gagne committed
165 166
}

167
void FirmwarePlugin::adjustOutgoingMavlinkMessage(Vehicle* vehicle, LinkInterface* outgoingLink, mavlink_message_t* message)
Don Gagne's avatar
Don Gagne committed
168
{
169
    Q_UNUSED(vehicle);
170
    Q_UNUSED(outgoingLink);
Don Gagne's avatar
Don Gagne committed
171 172 173
    Q_UNUSED(message);
    // Generic plugin does no message adjustment
}
174

175
void FirmwarePlugin::initializeVehicle(Vehicle* vehicle)
176 177
{
    Q_UNUSED(vehicle);
178

179 180
    // Generic Flight Stack is by definition "generic", so no extra work
}
181

182
bool FirmwarePlugin::sendHomePositionToVehicle(void)
183 184 185 186 187 188
{
    // Generic stack does not want home position sent in the first position.
    // Subsequent sequence numbers must be adjusted.
    // This is the mavlink spec default.
    return false;
}
189

190
QList<MAV_CMD> FirmwarePlugin::supportedMissionCommands(void)
Don Gagne's avatar
Don Gagne committed
191 192 193 194
{
    // Generic supports all commands
    return QList<MAV_CMD>();
}
195

196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
QString FirmwarePlugin::missionCommandOverrides(MAV_TYPE vehicleType) const
{
    switch (vehicleType) {
    case MAV_TYPE_GENERIC:
        return QStringLiteral(":/json/MavCmdInfoCommon.json");
        break;
    case MAV_TYPE_FIXED_WING:
        return QStringLiteral(":/json/MavCmdInfoFixedWing.json");
        break;
    case MAV_TYPE_QUADROTOR:
        return QStringLiteral(":/json/MavCmdInfoMultiRotor.json");
        break;
    case MAV_TYPE_VTOL_QUADROTOR:
        return QStringLiteral(":/json/MavCmdInfoVTOL.json");
        break;
    case MAV_TYPE_SUBMARINE:
        return QStringLiteral(":/json/MavCmdInfoSub.json");
        break;
    case MAV_TYPE_GROUND_ROVER:
        return QStringLiteral(":/json/MavCmdInfoRover.json");
        break;
    default:
        qWarning() << "FirmwarePlugin::missionCommandOverrides called with bad MAV_TYPE:" << vehicleType;
        return QString();
    }
221
}
222 223 224 225 226 227 228

void FirmwarePlugin::getParameterMetaDataVersionInfo(const QString& metaDataFile, int& majorVersion, int& minorVersion)
{
    Q_UNUSED(metaDataFile);
    majorVersion = -1;
    minorVersion = -1;
}
Don Gagne's avatar
Don Gagne committed
229 230 231 232 233 234 235 236 237 238 239 240

bool FirmwarePlugin::isGuidedMode(const Vehicle* vehicle) const
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
    return false;
}

void FirmwarePlugin::setGuidedMode(Vehicle* vehicle, bool guidedMode)
{
    Q_UNUSED(vehicle);
    Q_UNUSED(guidedMode);
241
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
242 243 244 245 246 247
}

void FirmwarePlugin::pauseVehicle(Vehicle* vehicle)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
248
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
249 250 251 252 253 254
}

void FirmwarePlugin::guidedModeRTL(Vehicle* vehicle)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
255
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
256 257 258 259 260 261
}

void FirmwarePlugin::guidedModeLand(Vehicle* vehicle)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
262
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
263 264
}

265
void FirmwarePlugin::guidedModeTakeoff(Vehicle* vehicle, double takeoffAltRel)
Don Gagne's avatar
Don Gagne committed
266 267 268
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
269
    Q_UNUSED(takeoffAltRel);
270
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
271 272 273 274 275 276 277
}

void FirmwarePlugin::guidedModeGotoLocation(Vehicle* vehicle, const QGeoCoordinate& gotoCoord)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
    Q_UNUSED(gotoCoord);
278
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
279 280 281 282 283 284 285
}

void FirmwarePlugin::guidedModeChangeAltitude(Vehicle* vehicle, double altitudeRel)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
    Q_UNUSED(altitudeRel);
286
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
Don Gagne's avatar
Don Gagne committed
287
}
288

289 290 291 292 293 294 295
void FirmwarePlugin::startMission(Vehicle* vehicle)
{
    // Not supported by generic vehicle
    Q_UNUSED(vehicle);
    qgcApp()->showMessage(guided_mode_not_supported_by_vehicle);
}

296 297
const FirmwarePlugin::remapParamNameMajorVersionMap_t& FirmwarePlugin::paramNameRemapMajorVersionMap(void) const
{
Don Gagne's avatar
Don Gagne committed
298 299 300
    static const remapParamNameMajorVersionMap_t remap;

    return remap;
301 302 303 304 305 306 307
}

int FirmwarePlugin::remapParamNameHigestMinorVersionNumber(int majorVersionNumber) const
{
    Q_UNUSED(majorVersionNumber);
    return 0;
}
308

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
QString FirmwarePlugin::vehicleImageOpaque(const Vehicle* vehicle) const
{
    Q_UNUSED(vehicle);
    return QStringLiteral("/qmlimages/vehicleArrowOpaque.svg");
}

QString FirmwarePlugin::vehicleImageOutline(const Vehicle* vehicle) const
{
    Q_UNUSED(vehicle);
    return QStringLiteral("/qmlimages/vehicleArrowOutline.svg");
}

QString FirmwarePlugin::vehicleImageCompass(const Vehicle* vehicle) const
{
    Q_UNUSED(vehicle);
    return QStringLiteral("/qmlimages/compassInstrumentArrow.svg");
}
326

327
const QVariantList &FirmwarePlugin::toolBarIndicators(const Vehicle* vehicle)
328 329 330 331 332 333 334 335 336 337
{
    Q_UNUSED(vehicle);
    //-- Default list of indicators for all vehicles.
    if(_toolBarIndicatorList.size() == 0) {
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/MessageIndicator.qml")));
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/GPSIndicator.qml")));
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/TelemetryRSSIIndicator.qml")));
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/RCRSSIIndicator.qml")));
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/BatteryIndicator.qml")));
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/ModeIndicator.qml")));
338
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/VTOLModeIndicator.qml")));
339
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/ArmedIndicator.qml")));
340
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/GPSRTKIndicator.qml")));
341
        _toolBarIndicatorList.append(QVariant::fromValue(QUrl::fromUserInput("qrc:/toolbar/LinkIndicator.qml")));
342 343 344
    }
    return _toolBarIndicatorList;
}
345 346 347 348 349 350 351 352

const QVariantList& FirmwarePlugin::cameraList(const Vehicle* vehicle)
{
    Q_UNUSED(vehicle);

    if (_cameraList.size() == 0) {
        CameraMetaData* metaData;

353 354 355 356 357 358 359 360 361 362 363 364
        metaData = new CameraMetaData(tr("Sony NEX-5R 20mm"),  //http://www.sony.co.uk/electronics/interchangeable-lens-cameras/ilce-qx1-body-kit/specifications
                                      23.2,                 //http://www.sony.com/electronics/camera-lenses/sel16f28/specifications
                                      15.4,
                                      4912,
                                      3264,
                                      20,
                                      true,
                                      false,
                                      1,
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

365 366
        metaData = new CameraMetaData(tr("Sony ILCE-QX1"),  //http://www.sony.co.uk/electronics/interchangeable-lens-cameras/ilce-qx1-body-kit/specifications
                                      23.2,                 //http://www.sony.com/electronics/camera-lenses/sel16f28/specifications
367 368 369 370
                                      15.4,
                                      5456,
                                      3632,
                                      16,
371 372
                                      true,
                                      false,
373
                                      0,
374 375 376 377 378 379 380 381 382
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

        metaData = new CameraMetaData(tr("Canon S100 PowerShot"),
                                      7.6,
                                      5.7,
                                      4000,
                                      3000,
                                      5.2,
383 384
                                      true,
                                      false,
385
                                      0,
386 387 388
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

389 390 391 392 393 394 395 396
        metaData = new CameraMetaData(tr("Canon G9 X PowerShot"),
                                      13.2,
                                      8.8,
                                      5488,
                                      3680,
                                      10.2,
                                      true,
                                      false,
397
                                      0,
398 399 400
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

401 402 403 404 405 406
        metaData = new CameraMetaData(tr("Canon SX260 HS PowerShot"),
                                      6.17,
                                      4.55,
                                      4000,
                                      3000,
                                      4.5,
407 408
                                      true,
                                      false,
409
                                      0,
410
                                      this);
411
        _cameraList.append(QVariant::fromValue(metaData));
412 413 414 415 416 417 418

        metaData = new CameraMetaData(tr("Canon EOS-M 22mm"),
                                      22.3,
                                      14.9,
                                      5184,
                                      3456,
                                      22,
419 420
                                      true,
                                      false,
421
                                      0,
422 423 424 425 426 427 428 429 430
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

        metaData = new CameraMetaData(tr("Sony a6000 16mm"),    //http://www.sony.co.uk/electronics/interchangeable-lens-cameras/ilce-6000-body-kit#product_details_default
                                      23.5,
                                      15.6,
                                      6000,
                                      4000,
                                      16,
431 432
                                      true,
                                      false,
433
                                      0,
434 435
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));
André's avatar
André committed
436 437 438 439 440 441 442 443 444

        metaData = new CameraMetaData(tr("Sony RX100 II 28mm"),
                                      13.2,
                                      8.8,
                                      5472,
                                      3648,
                                      10.4,
                                      true,
                                      false,
445
                                      0,
André's avatar
André committed
446 447
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));
DonLakeFlyer's avatar
DonLakeFlyer committed
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

        metaData = new CameraMetaData(tr("Ricoh GR II"),
                                      23.7,     // sensorWidth
                                      15.7,     // sendsorHeight
                                      4928,     // imageWidth
                                      3264,     // imageHeight
                                      18.3,     // focalLength
                                      true,     // landscape
                                      false,    // fixedOrientation
                                      0,        // minTriggerInterval
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

        metaData = new CameraMetaData(tr("RedEdge"),
                                      4.8,      // sensorWidth
                                      3.6,      // sendsorHeight
                                      1280,     // imageWidth
                                      960,      // imageHeight
                                      5.5,      // focalLength
                                      true,     // landscape
                                      false,    // fixedOrientation
                                      0,        // minTriggerInterval
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

        metaData = new CameraMetaData(tr("Parrot Sequioa RGB"),
                                      6.17,     // sensorWidth
                                      4.63,     // sendsorHeight
                                      4608,     // imageWidth
                                      3456,     // imageHeight
                                      4.9,      // focalLength
                                      true,     // landscape
                                      false,    // fixedOrientation
                                      1,        // minTriggerInterval
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));

        metaData = new CameraMetaData(tr("Parrot Sequioa Monochrome"),
                                      4.8,      // sensorWidth
                                      3.6,      // sendsorHeight
                                      1280,     // imageWidth
                                      960,      // imageHeight
                                      4.0,      // focalLength
                                      true,     // landscape
                                      false,    // fixedOrientation
                                      0.8,      // minTriggerInterval
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));
Jared Szechy's avatar
Jared Szechy committed
496 497 498 499 500 501 502 503 504 505 506 507

        metaData = new CameraMetaData(tr("GoPro Hero 4"),
                                      6.17,     // sensorWidth
                                      4.55,     // sendsorHeight
                                      4000,     // imageWidth
                                      3000,     // imageHeight
                                      2.98,     // focalLength
                                      true,     // landscape
                                      false,    // fixedOrientation
                                      0,        // minTriggerInterval
                                      this);
        _cameraList.append(QVariant::fromValue(metaData));
508 509 510 511
    }

    return _cameraList;
}
512

513 514 515
QMap<QString, FactGroup*>* FirmwarePlugin::factGroups(void) {
    // Generic plugin has no FactGroups
    return NULL;
516 517
}

518 519 520 521
bool FirmwarePlugin::vehicleYawsToNextWaypointInMission(const Vehicle* vehicle) const
{
    return vehicle->multiRotor() ? false : true;
}
522

523
bool FirmwarePlugin::_armVehicleAndValidate(Vehicle* vehicle)
524
{
525 526 527 528 529 530 531 532
    if (vehicle->armed()) {
        return true;
    }

    bool armedChanged = false;

    // We try arming 3 times
    for (int retries=0; retries<3; retries++) {
533
        vehicle->setArmed(true);
534 535 536 537 538 539 540 541 542 543 544 545 546

        // Wait for vehicle to return armed state for 3 seconds
        for (int i=0; i<30; i++) {
            if (vehicle->armed()) {
                armedChanged = true;
                break;
            }
            QGC::SLEEP::msleep(100);
            qgcApp()->processEvents(QEventLoop::ExcludeUserInputEvents);
        }
        if (armedChanged) {
            break;
        }
547 548
    }

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
    return armedChanged;
}

bool FirmwarePlugin::_setFlightModeAndValidate(Vehicle* vehicle, const QString& flightMode)
{
    if (vehicle->flightMode() == flightMode) {
        return true;
    }

    bool flightModeChanged = false;

    // We try 3 times
    for (int retries=0; retries<3; retries++) {
        vehicle->setFlightMode(flightMode);

        // Wait for vehicle to return flight mode
565
        for (int i=0; i<13; i++) {
566 567 568 569 570 571 572 573
            if (vehicle->flightMode() == flightMode) {
                flightModeChanged = true;
                break;
            }
            QGC::SLEEP::msleep(100);
            qgcApp()->processEvents(QEventLoop::ExcludeUserInputEvents);
        }
        if (flightModeChanged) {
574 575 576
            break;
        }
    }
577 578

    return flightModeChanged;
579
}
580

581

Don Gagne's avatar
Don Gagne committed
582
void FirmwarePlugin::batteryConsumptionData(Vehicle* vehicle, int& mAhBattery, double& hoverAmps, double& cruiseAmps) const
583 584 585 586 587 588
{
    Q_UNUSED(vehicle);
    mAhBattery = 0;
    hoverAmps = 0;
    cruiseAmps = 0;
}
589 590 591 592 593 594

QString FirmwarePlugin::autoDisarmParameter(Vehicle* vehicle)
{
    Q_UNUSED(vehicle);
    return QString();
}
595

596 597 598 599 600 601 602 603
bool FirmwarePlugin::hasGimbal(Vehicle* vehicle, bool& rollSupported, bool& pitchSupported, bool& yawSupported)
{
    Q_UNUSED(vehicle);
    rollSupported = false;
    pitchSupported = false;
    yawSupported = false;
    return false;
}
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619

bool FirmwarePlugin::isVtol(const Vehicle* vehicle) const
{
    switch (vehicle->vehicleType()) {
    case MAV_TYPE_VTOL_DUOROTOR:
    case MAV_TYPE_VTOL_QUADROTOR:
    case MAV_TYPE_VTOL_TILTROTOR:
    case MAV_TYPE_VTOL_RESERVED2:
    case MAV_TYPE_VTOL_RESERVED3:
    case MAV_TYPE_VTOL_RESERVED4:
    case MAV_TYPE_VTOL_RESERVED5:
        return true;
    default:
        return false;
    }
}
620

621
QGCCameraManager* FirmwarePlugin::createCameraManager(Vehicle* vehicle)
622 623 624 625 626 627 628 629 630 631 632 633 634 635
{
    Q_UNUSED(vehicle);
    return NULL;
}

QGCCameraControl* FirmwarePlugin::createCameraControl(const mavlink_camera_information_t *info, Vehicle *vehicle, int compID, QObject* parent)
{
    Q_UNUSED(info);
    Q_UNUSED(vehicle);
    Q_UNUSED(compID);
    Q_UNUSED(parent);
    return NULL;
}

636 637 638 639 640
uint32_t FirmwarePlugin::highLatencyCustomModeTo32Bits(uint16_t hlCustomMode)
{
    // Standard implementation assumes no special handling. Upper part of 32 bit value is not used.
    return hlCustomMode;
}
641