TakeoffMissionItem.cc

Go to the documentation of this file.

#include "TakeoffMissionItem.h"
 
#include "FirmwarePlugin.h"
#include "MissionCommandTree.h"
#include "MissionSettingsItem.h"
#include "MultiVehicleManager.h"
#include "PlanMasterController.h"
#include "PlanViewSettings.h"
#include "QGroundControlQmlGlobal.h"
#include "SettingsManager.h"
#include "Vehicle.h"
 
TakeoffMissionItem::TakeoffMissionItem(PlanMasterController* masterController, bool flyView, MissionSettingsItem* settingsItem, bool forLoad)
    : SimpleMissionItem(masterController, flyView, forLoad)
    , _settingsItem(settingsItem)
{
    _init(forLoad);
}
 
TakeoffMissionItem::TakeoffMissionItem(MAV_CMD takeoffCmd, PlanMasterController* masterController, bool flyView, MissionSettingsItem* settingsItem, bool forLoad)
    : SimpleMissionItem(masterController, flyView, false /* forLoad */)
    , _settingsItem(settingsItem)
{
    setCommand(takeoffCmd);
    _init(forLoad);
}
 
TakeoffMissionItem::TakeoffMissionItem(const MissionItem& missionItem, PlanMasterController* masterController, bool flyView, MissionSettingsItem* settingsItem, bool forLoad)
    : SimpleMissionItem(masterController, flyView, missionItem)
    , _settingsItem(settingsItem)
{
    _init(forLoad);
}
 
TakeoffMissionItem::~TakeoffMissionItem()
{
 
}
 
void TakeoffMissionItem::_init(bool forLoad)
{
    _editorQml = QStringLiteral("qrc:/qml/QGroundControl/PlanView/SimpleItemEditor.qml");
 
    connect(_settingsItem, &MissionSettingsItem::coordinateChanged, this, &TakeoffMissionItem::launchCoordinateChanged);
 
    if (_flyView) {
        _initLaunchTakeoffAtSameLocation();
        return;
    }
 
    QGeoCoordinate homePosition = _settingsItem->coordinate();
    if (!homePosition.isValid()) {
        Vehicle* activeVehicle = MultiVehicleManager::instance()->activeVehicle();
        if (activeVehicle) {
            homePosition = activeVehicle->homePosition();
            if (homePosition.isValid()) {
                _settingsItem->setCoordinate(homePosition);
            }
        }
    }
 
    if (forLoad) {
        // Load routines will set the rest up after load
        return;
    }
 
    _initLaunchTakeoffAtSameLocation();
    if (_launchTakeoffAtSameLocation && homePosition.isValid()) {
        SimpleMissionItem::setCoordinate(homePosition);
    }
 
    // Wizard mode is set if:
    //  - Launch position is missing - requires prompt to user to click to set launch
    //  - Fixed wing - warn about climb out position adjustment
    if (!homePosition.isValid() || _controllerVehicle->fixedWing()) {
        _wizardMode = true;
    }
 
    setDirty(false);
}
 
void TakeoffMissionItem::_setLaunchTakeoffAtSameLocation(bool launchTakeoffAtSameLocation)
{
    if (launchTakeoffAtSameLocation != _launchTakeoffAtSameLocation) {
        _launchTakeoffAtSameLocation = launchTakeoffAtSameLocation;
        if (_launchTakeoffAtSameLocation) {
            _setLaunchCoordinate(coordinate());
        }
        emit launchTakeoffAtSameLocationChanged(_launchTakeoffAtSameLocation);
        setDirty(true);
    }
}
 
QGeoCoordinate TakeoffMissionItem::launchCoordinate(void) const
{
    return _settingsItem->coordinate();
}
 
void TakeoffMissionItem::setCoordinate(const QGeoCoordinate& coordinate)
{
    if (coordinate != this->coordinate()) {
        SimpleMissionItem::setCoordinate(coordinate);
        if (_launchTakeoffAtSameLocation) {
            _settingsItem->setCoordinate(coordinate);
        }
    }
}
 
bool TakeoffMissionItem::isTakeoffCommand(MAV_CMD command)
{
    return MissionCommandTree::instance()->isTakeoffCommand(command);
}
 
bool TakeoffMissionItem::isVTOLMulticopterTakeoff(Vehicle* vehicle, MAV_CMD command)
{
    return vehicle
        && command == MAV_CMD_NAV_TAKEOFF
        && vehicle->firmwarePlugin()->isCapable(vehicle, FirmwarePlugin::VTOLMulticopterTakeoffCapability);
}
 
QString TakeoffMissionItem::commandDescription(void) const
{
    return isVTOLMulticopterTakeoff(_controllerVehicle, mavCommand())
        ? tr("Take off vertically and continue the mission in multicopter mode.")
        : SimpleMissionItem::commandDescription();
}
 
QString TakeoffMissionItem::commandName(void) const
{
    return isVTOLMulticopterTakeoff(_controllerVehicle, mavCommand())
        ? tr("Multicopter takeoff")
        : SimpleMissionItem::commandName();
}
 
void TakeoffMissionItem::_initLaunchTakeoffAtSameLocation(void)
{
    if (specifiesCoordinate()) {
        if (_controllerVehicle->fixedWing()
            || (_controllerVehicle->vtol() && !isVTOLMulticopterTakeoff(_controllerVehicle, mavCommand()))) {
            _setLaunchTakeoffAtSameLocation(false);
        } else {
            // PX4 specifies a coordinate for takeoff even for multi-rotor. But it makes more sense to not have a coordinate
            // from and end user standpoint. So even for PX4 we try to keep launch and takeoff at the same position. Unless the
            // user has moved/loaded launch at a different location than takeoff.
            if (coordinate().isValid() && _settingsItem->coordinate().isValid()) {
                _setLaunchTakeoffAtSameLocation(coordinate().latitude() == _settingsItem->coordinate().latitude() && coordinate().longitude() == _settingsItem->coordinate().longitude());
            } else {
                _setLaunchTakeoffAtSameLocation(true);
            }
 
        }
    } else {
        _setLaunchTakeoffAtSameLocation(true);
    }
}
 
bool TakeoffMissionItem::load(QTextStream &loadStream)
{
    bool success = SimpleMissionItem::load(loadStream);
    if (success) {
        _initLaunchTakeoffAtSameLocation();
    }
    _wizardMode = false; // Always be off for loaded items
    return success;
}
 
bool TakeoffMissionItem::load(const QJsonObject& json, int sequenceNumber, QString& errorString)
{
    bool success = SimpleMissionItem::load(json, sequenceNumber, errorString);
    if (success) {
        _initLaunchTakeoffAtSameLocation();
    }
    _wizardMode = false; // Always be off for loaded items
    return success;
}
 
void TakeoffMissionItem::_setLaunchCoordinate(const QGeoCoordinate& launchCoordinate)
{
    if (!launchCoordinate.isValid()) {
        return;
    }
 
    _settingsItem->setCoordinate(launchCoordinate);
 
    if (!coordinate().isValid()) {
        QGeoCoordinate takeoffCoordinate;
        if (_launchTakeoffAtSameLocation) {
            takeoffCoordinate = launchCoordinate;
        } else {
            double distance = SettingsManager::instance()->planViewSettings()->vtolTransitionDistance()->rawValue().toDouble(); // Default distance is VTOL transition to takeoff point distance
            if (_controllerVehicle->fixedWing()) {
                double altitude = this->altitude()->rawValue().toDouble();
 
                if (altitudeFrame() == QGroundControlQmlGlobal::AltitudeFrameRelative) {
                    // Offset for fixed wing climb out of 30 degrees to specified altitude
                    if (altitude != 0.0) {
                        distance = altitude / tan(qDegreesToRadians(30.0));
                    }
                } else {
                    distance = altitude * 1.5;
                }
            }
            takeoffCoordinate = launchCoordinate.atDistanceAndAzimuth(distance, 0);
        }
        SimpleMissionItem::setCoordinate(takeoffCoordinate);
    }
}