UASParameterCommsMgr.h 4.85 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
#ifndef UASPARAMETERCOMMSMGR_H
#define UASPARAMETERCOMMSMGR_H

#include <QObject>
#include <QMap>
#include <QTimer>
#include <QVariant>
#include <QVector>

class UASInterface;
class UASParameterDataModel;

tstellanova's avatar
tstellanova committed
13 14


15 16 17
class UASParameterCommsMgr : public QObject
{
    Q_OBJECT
tstellanova's avatar
tstellanova committed
18 19


20
public:
21 22 23
    explicit UASParameterCommsMgr(QObject *parent = 0);
    UASParameterCommsMgr* initWithUAS(UASInterface* model);///< Two-stage constructor

24 25
    ~UASParameterCommsMgr();

tstellanova's avatar
tstellanova committed
26 27 28 29 30 31 32
    typedef enum ParamCommsStatusLevel {
        ParamCommsStatusLevel_OK = 0,
        ParamCommsStatusLevel_Warning = 2,
        ParamCommsStatusLevel_Error = 4,
        ParamCommsStatusLevel_Count
    } ParamCommsStatusLevel_t;

33 34

protected:
35 36 37

    /** @brief activate the silence timer if there are unack'd reads or writes */
    virtual void updateSilenceTimer();
38

tstellanova's avatar
tstellanova committed
39 40 41 42
    virtual void setParameterStatusMsg(const QString& msg, ParamCommsStatusLevel_t level=ParamCommsStatusLevel_OK);

    /** @brief Load settings that control eg retransmission timeouts */
    void loadParamCommsSettings();
43

44
    /** @brief clear transmissionMissingPackets and transmissionMissingWriteAckPackets */
tstellanova's avatar
tstellanova committed
45
    void clearRetransmissionLists(int& missingReadCount, int& missingWriteCount );
46

47 48 49 50 51 52
    /** @brief we are waiting for a response to this read param request */
    virtual void markReadParamWaiting(int compId, int paramId);

    /** @brief we are waiting for a response to this write param request */
    void markWriteParamWaiting(int compId, QString paramName, QVariant value);

53
    void resendReadWriteRequests();
54
    void resetAfterListReceive();
55

56
    void emitPendingParameterCommit(int compId, const QString& key, QVariant& value);
57

58
signals:
59
    void commitPendingParameter(int component, QString parameter, QVariant value);
60
    void parameterChanged(int component, int parameterIndex, QVariant value);
tstellanova's avatar
tstellanova committed
61
    void parameterValueConfirmed(int uas, int component,int paramCount, int paramId, QString parameter, QVariant value);
62

tstellanova's avatar
tstellanova committed
63 64 65
    /** @brief We have received a complete list of all parameters onboard the MAV */
    void parameterListUpToDate();

66 67 68
    void parameterUpdateRequested(int component, const QString& parameter);
    void parameterUpdateRequestedById(int componentId, int paramId);

tstellanova's avatar
tstellanova committed
69
    /** @brief We updated the parameter status message */
70
    void parameterStatusMsgUpdated(QString msg, int level);
71 72 73 74 75
    
    
    /// @brief We signal this to ourselves in order to get timer started/stopped on our own thread.
    void _startSilenceTimer(void);
    void _stopSilenceTimer(void);
76 77

public slots:
tstellanova's avatar
tstellanova committed
78
    /** @brief  Iterate through all components, through all pending parameters and send them to UAS */
79
    virtual void sendPendingParameters(bool copyToPersistent = false, bool forceSend = false);
tstellanova's avatar
tstellanova committed
80 81 82 83

    /** @brief  Write the current onboard parameters from transient RAM into persistent storage, e.g. EEPROM or harddisk */
    virtual void writeParamsToPersistentStorage();

84
    /** @brief Write one parameter to the MAV */
85
    virtual void setParameter(int component, QString parameterName, QVariant value, bool forceSend = false);
tstellanova's avatar
tstellanova committed
86

87 88
    /** @brief Request list of parameters from MAV */
    virtual void requestParameterList();
89

90 91
    /** @brief The max silence time expired */
    virtual void silenceTimerExpired();
92 93 94 95

    /** @brief Request a single parameter update by name */
    virtual void requestParameterUpdate(int component, const QString& parameter);

96 97 98
    /** @brief Request an update of RC parameters */
    virtual void requestRcCalibrationParamsUpdate();

tstellanova's avatar
tstellanova committed
99 100
    virtual void receivedParameterUpdate(int uas, int compId, int paramCount, int paramId, QString paramName, QVariant value);

101 102
protected:

103 104 105 106

    QMap<int, int> knownParamListSize;///< The known param list size for each component, by component ID
    quint64 lastReceiveTime; ///< The last time we received anything from our partner
    quint64 lastSilenceTimerReset;
107 108
    UASInterface* mav;   ///< The MAV we're talking to

109 110
    int maxSilenceTimeout; ///< If nothing received within this period of time, abandon resends

111 112
    UASParameterDataModel* paramDataModel;

113
    bool persistParamsAfterSend; ///< Copy all parameters to persistent storage after sending
114 115 116 117 118 119 120
    QMap<int, QSet<int>*> readsWaiting; ///< All reads that have not yet been received, by component ID
    int retransmitBurstLimit; ///< Number of packets requested for retransmission per burst
    int silenceTimeout; ///< If nothing received within this period of time, start resends
    QTimer silenceTimer;      ///< Timer handling parameter retransmission
    bool transmissionListMode;       ///< Currently requesting list
    QMap<int, QMap<QString, QVariant>* > writesWaiting; ///< All writes that have not yet been ack'd, by component ID

121 122 123 124
private slots:
    /// @brief We signal this to ourselves in order to get timer started/stopped on our own thread.
    void _startSilenceTimerOnThisThread(void);
    void _stopSilenceTimerOnThisThread(void);
125 126 127 128
};
    

#endif // UASPARAMETERCOMMSMGR_H