PlanManager.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QObject>
#include <QtCore/QTimer>
#include <QtCore/QLoggingCategory>
 
#include "MissionItem.h"
#include "QGCMAVLink.h"
 
class Vehicle;
 
Q_DECLARE_LOGGING_CATEGORY(PlanManagerLog)
 
 
class PlanManager : public QObject
{
    Q_OBJECT
 
public:
    PlanManager(Vehicle* vehicle, MAV_MISSION_TYPE planType);
    ~PlanManager();
 
    bool inProgress(void) const;
    const QList<MissionItem*>& missionItems(void) { return _missionItems; }
 
    int currentIndex(void) const { return _currentMissionIndex; }
 
    int lastCurrentIndex(void) const { return _lastCurrentIndex; }
 
    void loadFromVehicle(void);
 
    void writeMissionItems(const QList<MissionItem*>& missionItems);
 
    void removeAll(void);
 
    typedef enum {
        InternalError,
        AckTimeoutError,        
        ProtocolError,          
        RequestRangeError,      
        ItemMismatchError,      
        VehicleAckError,        
        MissingRequestsError,   
        MaxRetryExceeded,       
        MissionTypeMismatch,    
    } ErrorCode_t;
 
    // These values are public so the unit test can set appropriate signal wait times
    // When passively waiting for a mission process, use a longer timeout.
    static constexpr int _ackTimeoutMilliseconds = 1500;
    // When actively retrying to request mission items, use a shorter timeout instead.
    static constexpr int _retryTimeoutMilliseconds = 250;
    static constexpr int _maxRetryCount = 5;
 
    static constexpr int kTestAckTimeoutMs = 50;
 
signals:
    void newMissionItemsAvailable   (bool removeAllRequested);
    void inProgressChanged          (bool inProgress);
    void error                      (int errorCode, const QString& errorMsg);
    void currentIndexChanged        (int currentIndex);
    void lastCurrentIndexChanged    (int lastCurrentIndex);
    void progressPctChanged         (double progressPercentPct);
    void removeAllComplete          (bool error);
    void sendComplete               (bool error);
    void resumeMissionReady         (void);
    void resumeMissionUploadFail    (void);
 
private slots:
    void _mavlinkMessageReceived(const mavlink_message_t& message);
    void _ackTimeout(void);
 
protected:
    typedef enum {
        AckNone,            
        AckMissionCount,    
        AckMissionItem,     
        AckMissionRequest,  
        AckMissionClearAll, 
        AckGuidedItem,      
    } AckType_t;
 
    typedef enum {
        TransactionNone,
        TransactionRead,
        TransactionWrite,
        TransactionRemoveAll
    } TransactionType_t;
 
    void _startAckTimeout(AckType_t ack);
    bool _checkForExpectedAck(AckType_t receivedAck);
    void _readTransactionComplete(void);
    void _handleMissionCount(const mavlink_message_t& message);
    void _handleMissionItem(const mavlink_message_t& message);
    void _handleMissionRequest(const mavlink_message_t& message);
    void _handleMissionAck(const mavlink_message_t& message);
    void _requestNextMissionItem(void);
    void _clearMissionItems(void);
    void _sendError(ErrorCode_t errorCode, const QString& errorMsg);
    QString _ackTypeToString(AckType_t ackType);
    QString _missionResultToString(MAV_MISSION_RESULT result);
    void _finishTransaction(bool success, bool apmGuidedItemWrite = false);
    void _requestList(void);
    void _writeMissionCount(void);
    void _writeMissionItemsWorker(void);
    void _clearAndDeleteMissionItems(void);
    void _clearAndDeleteWriteMissionItems(void);
    QString _lastMissionReqestString(MAV_MISSION_RESULT result);
    void _removeAllWorker(void);
    void _connectToMavlink(void);
    void _disconnectFromMavlink(void);
    QString _planTypeString(void);
 
protected:
    Vehicle*            _vehicle =              nullptr;
    MAV_MISSION_TYPE    _planType;
 
    QTimer*             _ackTimeoutTimer =      nullptr;
    AckType_t           _expectedAck;
    int                 _retryCount;
 
    TransactionType_t   _transactionInProgress;
    bool                _resumeMission;
    QList<int>          _itemIndicesToWrite;    
    QList<int>          _itemIndicesToRead;     
    int                 _lastMissionRequest;    
    int                 _missionItemCountToRead;
 
    QList<MissionItem*> _missionItems;          
    QList<MissionItem*> _writeMissionItems;     
    int                 _currentMissionIndex;
    int                 _lastCurrentIndex;
 
private:
    void _setTransactionInProgress(TransactionType_t type);
};