telemetry.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 *
 * Additional note on redistribution: The copyright and license notices above
 * must be maintained in each individual source file that is a derivative work
 * of this source file; otherwise redistribution is prohibited.
 */

#include "telemetry.h"
#include "hwtaulink.h"
#include "objectpersistence.h"
#include <QTime>
#include <QtGlobal>
#include <stdlib.h>
#include <QDebug>

#ifdef TELEMETRY_DEBUG
#define TELEMETRY_QXTLOG_DEBUG(...) qDebug() << (__VA_ARGS__)
#else // TELEMETRY_DEBUG
#define TELEMETRY_QXTLOG_DEBUG(...)
#endif // TELEMETRY_DEBUG

class TransactionKey
{
public:
    TransactionKey(quint32 objId, quint32 instId, bool req)
    {
        this->objId = objId;
        this->instId = instId;
        this->req = req;
    }

    TransactionKey(UAVObject *obj, bool req)
    {
        this->objId = obj->getObjID();
        this->instId = obj->getInstID();
        this->req = req;
    }

    // See if this is an equivalent transaction key
    bool operator==(const TransactionKey &rhs) const
    {
        return (rhs.objId == objId && rhs.instId == instId && rhs.req == req);
    }

    bool operator<(const TransactionKey &rhs) const
    {
        return objId < rhs.objId || (objId == rhs.objId && instId < rhs.instId)
            || (objId == rhs.objId && instId == rhs.instId && req != rhs.req);
    }

    quint32 objId;
    quint32 instId;
    bool req;
};

Telemetry::Telemetry(UAVTalk *utalk, UAVObjectManager *objMngr)
{
    this->utalk = utalk;
    this->objMngr = objMngr;
    // Process all objects in the list
    QVector<QVector<UAVObject *>> objs = objMngr->getObjectsVector();
    const int objSize = objs.size();
    for (int objidx = 0; objidx < objSize; ++objidx) {
        registerObject(objs[objidx][0]); // we only need to register one instance per object type
    }
    // Listen to new object creations
    connect(objMngr, &UAVObjectManager::newObject, this, &Telemetry::newObject);
    connect(objMngr, &UAVObjectManager::newInstance, this, &Telemetry::newInstance);
    // Listen to transaction completions
    connect(utalk, &UAVTalk::ackReceived, this, &Telemetry::transactionSuccess);
    connect(utalk, &UAVTalk::nackReceived, this, &Telemetry::transactionFailure);
    // Get GCS stats object
    gcsStatsObj = GCSTelemetryStats::GetInstance(objMngr);
    // Setup and start the periodic timer
    timeToNextUpdateMs = 0;
    updateTimer = new QTimer(this);
    connect(updateTimer, &QTimer::timeout, this, &Telemetry::processPeriodicUpdates);
    updateTimer->start(1000);
    // Setup and start the stats timer
    txErrors = 0;
    txRetries = 0;
}

Telemetry::~Telemetry()
{
    for (QMap<TransactionKey, ObjectTransactionInfo *>::iterator itr = transMap.begin();
         itr != transMap.end(); ++itr) {
        delete itr.value();
    }
}

void Telemetry::registerObject(UAVObject *obj)
{
    // Setup object for periodic updates
    addObject(obj);

    // Setup object for telemetry updates
    updateObject(obj, EV_NONE);
}

void Telemetry::addObject(UAVObject *obj)
{
    // Check if object type is already in the list
    const QVector<ObjectTimeInfo>::iterator iterEnd = objList.end();
    for (QVector<ObjectTimeInfo>::const_iterator iter = objList.constBegin(); iter != iterEnd;
         ++iter) {
        if (iter->obj->getObjID() == obj->getObjID()) {
            // Object type (not instance!) is already in the list, do nothing
            return;
        }
    }

    // If this point is reached, then the object type is new, let's add it
    ObjectTimeInfo timeInfo;
    timeInfo.obj = obj;
    timeInfo.timeToNextUpdateMs = 0;
    timeInfo.updatePeriodMs = 0;
    objList.append(timeInfo);
}

void Telemetry::setUpdatePeriod(UAVObject *obj, qint32 periodMs)
{
    // Find object type (not instance!) and update its period
    const quint32 objID = obj->getObjID();

    const QVector<ObjectTimeInfo>::iterator iterEnd = objList.end();
    for (QVector<ObjectTimeInfo>::iterator iter = objList.begin(); iter != iterEnd; ++iter) {
        if (iter->obj->getObjID() == objID) {
            iter->updatePeriodMs = periodMs;
            iter->timeToNextUpdateMs = quint32((float)periodMs * (float)qrand()
                                               / (float)RAND_MAX); // avoid bunching of updates
        }
    }
}

void Telemetry::connectToObjectInstances(UAVObject *obj, quint32 eventMask)
{
    QVector<UAVObject *> objs = objMngr->getObjectInstancesVector(obj->getObjID());
    int objsSize = objs.size();
    for (int n = 0; n < objsSize; ++n) {
        // Disconnect all
        objs[n]->disconnect(this);
        // Connect only the selected events
        if ((eventMask & EV_UNPACKED) != 0) {
            connect(objs[n], &UAVObject::objectUnpacked, this, &Telemetry::objectUnpacked);
        }
        if ((eventMask & EV_UPDATED) != 0) {
            connect(objs[n], &UAVObject::objectUpdatedAuto, this, &Telemetry::objectUpdatedAuto);
        }
        if ((eventMask & EV_UPDATED_MANUAL) != 0) {
            connect(objs[n], &UAVObject::objectUpdatedManual, this,
                    &Telemetry::objectUpdatedManual);
        }
        if ((eventMask & EV_UPDATED_PERIODIC) != 0) {
            connect(objs[n], &UAVObject::objectUpdatedPeriodic, this,
                    &Telemetry::objectUpdatedPeriodic);
        }
        if ((eventMask & EV_UPDATE_REQ) != 0) {
            connect(objs[n], &UAVObject::updateRequested, this, &Telemetry::updateRequested);
            connect(objs[n], &UAVObject::updateAllInstancesRequested, this,
                    &Telemetry::updateAllInstancesRequested);
        }
    }
}

void Telemetry::updateObject(UAVObject *obj, quint32 eventType)
{
    // Get metadata
    UAVObject::Metadata metadata = obj->getMetadata();
    UAVObject::UpdateMode updateMode = UAVObject::GetGcsTelemetryUpdateMode(metadata);

    // Setup object depending on update mode
    qint32 eventMask;
    if (updateMode == UAVObject::UPDATEMODE_PERIODIC) {
        // Set update period
        setUpdatePeriod(obj, metadata.gcsTelemetryUpdatePeriod);
        // Connect signals for all instances
        eventMask = EV_UPDATED_MANUAL | EV_UPDATE_REQ | EV_UPDATED_PERIODIC;
        eventMask |= EV_UNPACKED; // we also need to act on remote updates (unpack events)
        connectToObjectInstances(obj, eventMask);
    } else if (updateMode == UAVObject::UPDATEMODE_ONCHANGE) {
        // Set update period
        setUpdatePeriod(obj, 0);
        // Connect signals for all instances
        eventMask = EV_UPDATED | EV_UPDATED_MANUAL | EV_UPDATE_REQ;
        eventMask |= EV_UNPACKED; // we also need to act on remote updates (unpack events)
        connectToObjectInstances(obj, eventMask);
    } else if (updateMode == UAVObject::UPDATEMODE_THROTTLED) {
        // If we received a periodic update, we can change back to update on change
        if ((eventType == EV_UPDATED_PERIODIC) || (eventType == EV_NONE)) {
            // Set update period
            if (eventType == EV_NONE)
                setUpdatePeriod(obj, metadata.gcsTelemetryUpdatePeriod);
            // Connect signals for all instances
            eventMask = EV_UPDATED | EV_UPDATED_MANUAL | EV_UPDATE_REQ | EV_UPDATED_PERIODIC;
        } else {
            // Otherwise, we just received an object update, so switch to periodic for the timeout
            // period to prevent more updates
            // Connect signals for all instances
            eventMask = EV_UPDATED | EV_UPDATED_MANUAL | EV_UPDATE_REQ;
        }
        eventMask |= EV_UNPACKED; // we also need to act on remote updates (unpack events)
        connectToObjectInstances(obj, eventMask);
    } else if (updateMode == UAVObject::UPDATEMODE_MANUAL) {
        // Set update period
        setUpdatePeriod(obj, 0);
        // Connect signals for all instances
        eventMask = EV_UPDATED_MANUAL | EV_UPDATE_REQ;
        eventMask |= EV_UNPACKED; // we also need to act on remote updates (unpack events)
        connectToObjectInstances(obj, eventMask);
    }
}

void Telemetry::transactionSuccess(UAVObject *obj)
{
    if (updateTransactionMap(obj, false)) {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Transaction succeeded:%0 Instance:%1")
                .arg(obj->getName()
                     + QString(QString(" 0x") + QString::number(obj->getObjID(), 16).toUpper()))
                .arg(obj->getInstID()));
        obj->emitTransactionCompleted(true);
        obj->emitTransactionCompleted(true, false);
    } else {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Received an ACK we were not expecting object:%0")
                .arg(obj->getName()));
    }
    // Process new object updates from queue
    processObjectQueue();
}

void Telemetry::transactionFailure(UAVObject *obj)
{
    bool nacked = false;
    if (sender() == this->utalk)
        nacked = true;
    // Here we need to check for true or false as a NAK can occur for OBJ_REQ or an
    // object set
    if (updateTransactionMap(obj, true) || updateTransactionMap(obj, false)) {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Transaction failed:%0 Instance:%1")
                .arg(obj->getName()
                     + QString(QString(" 0x") + QString::number(obj->getObjID(), 16).toUpper()))
                .arg(obj->getInstID()));
        obj->emitTransactionCompleted(false);
        obj->emitTransactionCompleted(false, nacked);
    } else {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Received a NACK we were not expecting for object %0")
                .arg(obj->getName()));
    }
    // Process new object updates from queue
    processObjectQueue();
}

void Telemetry::transactionRequestCompleted(UAVObject *obj)
{
    if (updateTransactionMap(obj, true)) {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Transaction succeeded:%0 Instance:%1")
                .arg(obj->getName()
                     + QString(QString(" 0x") + QString::number(obj->getObjID(), 16).toUpper()))
                .arg(obj->getInstID()));
        obj->emitTransactionCompleted(true);
        obj->emitTransactionCompleted(true, false);
    } else {
        TELEMETRY_QXTLOG_DEBUG(
            QString("[telemetry.cpp] Received a ACK we were not expecting for object %0")
                .arg(obj->getName()));
    }
    // Process new object updates from queue
    processObjectQueue();
}

bool Telemetry::updateTransactionMap(UAVObject *obj, bool request)
{
    TransactionKey key(obj, request);
    QMap<TransactionKey, ObjectTransactionInfo *>::iterator itr = transMap.find(key);
    if (itr != transMap.end()) {
        ObjectTransactionInfo *transInfo = itr.value();
        // Remove this transaction as it is complete.
        transInfo->timer->stop();
        transMap.remove(key);
        delete transInfo;
        return true;
    }
    return false;
}

void Telemetry::transactionTimeout(ObjectTransactionInfo *transInfo)
{
    transInfo->timer->stop();
    // Check if more retries are pending
    if (transInfo->retriesRemaining > 0) {
        --transInfo->retriesRemaining;
        qInfo() << QString("[telemetry.cpp] Transaction timeout:%0 Instance:%1 Retrying remaining=%3")
                .arg(transInfo->obj->getName()
                     + QString(QString(" 0x")
                               + QString::number(transInfo->obj->getObjID(), 16).toUpper()))
                .arg(transInfo->obj->getInstID())
                .arg(transInfo->retriesRemaining);
        processObjectTransaction(transInfo);
        ++txRetries;
    } else {
        qInfo() << QString("[telemetry.cpp] Transaction timeout:%0 Instance:%1 no more retries. FAILED "
                    "TRANSACT")
                .arg(transInfo->obj->getName()
                     + QString(QString(" 0x")
                               + QString::number(transInfo->obj->getObjID(), 16).toUpper()))
                .arg(transInfo->obj->getInstID());
        transInfo->timer->stop();
        transactionFailure(transInfo->obj);
        ++txErrors;
    }
}

/* This is synchronous, so we use a primitive callback mechanism
 * instead of signal/slot.  Can have a future async variant if
 * necessary
 */
QByteArray *Telemetry::downloadFile(quint32 fileId, quint32 maxSize,
        std::function<void(quint32)>progressCb)
{
    quint32 curOffset = 0;

    QByteArray *result = new QByteArray();

    quint32 sizeGuess = 32 * 1024;

    if (maxSize < sizeGuess) {
        sizeGuess = maxSize;
    }

    result->reserve(maxSize);

    bool newReqNeeded = false;
    bool completed = false;
    int inactivityCount = 0;
    int failCount = 0;

    QEventLoop loop;
    QTimer timeStep;

    timeStep.setSingleShot(false);
    timeStep.start(150);

    connect(&timeStep, &QTimer::timeout, &loop, &QEventLoop::quit);

    connect(utalk, &UAVTalk::fileDataReceived, &loop,
            [&](quint32 recvFileId, quint32 offset, quint8 *data, quint32 dataLen,
                bool eof, bool lastInSeq) {
                    if (recvFileId != fileId) {
                        return;
                    }

                    if (offset != curOffset) {
                        if (lastInSeq) {
                            newReqNeeded = true;
                            loop.exit();
                        }

                        return;
                    }

                    result->append((const char *) data, dataLen);

                    curOffset += dataLen;

                    if (eof) {
                        completed = true;
                        loop.exit();
                    } else if (lastInSeq) {
                        newReqNeeded = true;
                        loop.exit();
                    }

                    inactivityCount = 0;
                    failCount = 0;

                    if (progressCb) {
                        progressCb(curOffset);
                    }
                }
            );

    while (curOffset < maxSize && (!completed)) {
        utalk->requestFile(fileId, curOffset);

        newReqNeeded = false;
        inactivityCount = 0;

        do {
            if ((inactivityCount++) > 10) {
                qDebug() << "Retrying file transfer because of inactivity";
                failCount++;
                break;
            }

            loop.exec();

        } while (curOffset < maxSize && (!completed) && (!newReqNeeded));

        if (failCount > 5) {
            qDebug() << "Aborting file transfer";
            delete result;
            return NULL;
        }
    }

    return result;
}

void Telemetry::processObjectTransaction(ObjectTransactionInfo *transInfo)
{

    // Initiate transaction
    if (transInfo->objRequest) { // We are requesting an object from the remote end
        utalk->sendObjectRequest(transInfo->obj, transInfo->allInstances);
    } else { // We are sending an object to the remote end
        utalk->sendObject(transInfo->obj, transInfo->acked, transInfo->allInstances);
    }
    // Start timer if a response is expected
    if (transInfo->objRequest || transInfo->acked) {
        transInfo->timer->start(REQ_TIMEOUT_MS);
    } else {
        // Stop tracking this transaction, since we're not expecting a response:
        transMap.remove(TransactionKey(transInfo->obj, transInfo->objRequest));
        delete transInfo;
    }
}

void Telemetry::processObjectUpdates(UAVObject *obj, EventMask event, bool allInstances,
                                     bool priority)
{
    // Push event into queue
    ObjectQueueInfo objInfo;
    objInfo.obj = obj;
    objInfo.event = event;
    objInfo.allInstances = allInstances;
    if (priority) {
        if (objPriorityQueue.length() < MAX_QUEUE_SIZE) {
            objPriorityQueue.enqueue(objInfo);
        } else {
            ++txErrors;
            obj->emitTransactionCompleted(false);
            obj->emitTransactionCompleted(false, false);
            qWarning() << QString(tr("Telemetry: priority event queue is full, event lost (%1)")
                            .arg(obj->getName()));
        }
    } else {
        if (objQueue.length() < MAX_QUEUE_SIZE) {
            objQueue.enqueue(objInfo);
        } else {
            ++txErrors;
            obj->emitTransactionCompleted(false, false);
            obj->emitTransactionCompleted(false);
            qWarning() << QString(tr("Telemetry: event queue is full, event lost (%1)")
                            .arg(obj->getName()));
        }
    }
    // Process the transaction queue
    processObjectQueue();
}

void Telemetry::processObjectQueue()
{
    if (objQueue.length() > 1) {
        TELEMETRY_QXTLOG_DEBUG(
            "[telemetry.cpp] **************** Object Queue above 1 in backlog ****************");
    }
    // Get object information from queue (first the priority and then the regular queue)
    ObjectQueueInfo objInfo;
    if (!objPriorityQueue.isEmpty()) {
        objInfo = objPriorityQueue.dequeue();
    } else if (!objQueue.isEmpty()) {
        objInfo = objQueue.dequeue();
    } else {
        return;
    }

    // Check if a connection has been established, only process
    // GCSTelemetryStats updates (used to establish the connection)
    GCSTelemetryStats::DataFields gcsStats = gcsStatsObj->getData();
    if (gcsStats.Status != GCSTelemetryStats::STATUS_CONNECTED) {
        objQueue.clear();
        if (objInfo.obj->getObjID() != GCSTelemetryStats::OBJID) {
            objInfo.obj->emitTransactionCompleted(false);
            objInfo.obj->emitTransactionCompleted(false, false);
            return;
        }
    }

    // Setup transaction (skip if unpack event)
    UAVObject::Metadata metadata = objInfo.obj->getMetadata();
    UAVObject::UpdateMode updateMode = UAVObject::GetGcsTelemetryUpdateMode(metadata);
    if ((objInfo.event != EV_UNPACKED) && ((objInfo.event != EV_UPDATED_PERIODIC)
                                           || (updateMode != UAVObject::UPDATEMODE_THROTTLED))) {
        // We are either going to send an object, or are requesting one:
        if (transMap.contains(TransactionKey(objInfo.obj, objInfo.event == EV_UPDATE_REQ))) {
            TELEMETRY_QXTLOG_DEBUG(QString("[telemetry.cpp] Warning: Got request for %0 for which "
                                           "a request is already in progress. Not doing it")
                                       .arg(objInfo.obj->getName()));
            // We will not re-request it, then, we should wait for a timeout or success...
        } else {
            UAVObject::Metadata metadata = objInfo.obj->getMetadata();
            ObjectTransactionInfo *transInfo = new ObjectTransactionInfo(this);
            transInfo->obj = objInfo.obj;
            transInfo->allInstances = objInfo.allInstances;
            transInfo->retriesRemaining = MAX_RETRIES;
            transInfo->acked = UAVObject::GetGcsTelemetryAcked(metadata);
            if (objInfo.event == EV_UPDATED || objInfo.event == EV_UPDATED_MANUAL
                || objInfo.event == EV_UPDATED_PERIODIC) {
                transInfo->objRequest = false;
            } else if (objInfo.event == EV_UPDATE_REQ) {
                transInfo->objRequest = true;
            }
            transInfo->telem = this;
            // Insert the transaction into the transaction map.
            TransactionKey key(objInfo.obj, transInfo->objRequest);
            transMap.insert(key, transInfo);
            processObjectTransaction(transInfo);
        }
    }

    // If this is a metaobject then make necessary telemetry updates
    // to the connections of this object to Telemetry (this) :
    UAVMetaObject *metaobj = dynamic_cast<UAVMetaObject *>(objInfo.obj);
    if (metaobj != NULL) {
        updateObject(metaobj->getParentObject(), EV_NONE);
    } else if (updateMode != UAVObject::UPDATEMODE_THROTTLED) {
        updateObject(objInfo.obj, objInfo.event);
    }

    // We received an "unpacked" event, check whether
    // this is for an object we were expecting
    if (objInfo.event == EV_UNPACKED) {
        // TODO: Check here this is for a OBJ_REQ
        if (transMap.contains(TransactionKey(objInfo.obj, true))) {
            TELEMETRY_QXTLOG_DEBUG(
                QString("[telemetry.cpp] EV_UNPACKED %0 Instance:%1")
                    .arg(objInfo.obj->getName()
                         + QString(QString("0x")
                                   + QString::number(objInfo.obj->getObjID(), 16).toUpper()))
                    .arg(objInfo.obj->getInstID()));
            transactionRequestCompleted(objInfo.obj);
        } else {
            processObjectQueue();
        }
    }
}

void Telemetry::processPeriodicUpdates()
{
    // Stop timer
    updateTimer->stop();

    // Iterate through each object and update its timer, if zero then transmit object.
    // Also calculate smallest delay to next update (will be used for setting timeToNextUpdateMs)
    qint32 minDelay = MAX_UPDATE_PERIOD_MS;
    qint32 elapsedMs = 0;
    QTime time;
    qint32 offset;

    const QVector<ObjectTimeInfo>::iterator objInfoEnd = objList.end();
    for (QVector<ObjectTimeInfo>::iterator objinfo = objList.begin(); objinfo != objInfoEnd;
         ++objinfo) {
        // If object is configured for periodic updates
        // FixMe: This is an inefficient process as it depends on polling. It would be better to
        // have
        // this functionality be driven through timers.
        if (objinfo->updatePeriodMs > 0) {
            objinfo->timeToNextUpdateMs -= timeToNextUpdateMs;
            // Check if time for the next update
            if (objinfo->timeToNextUpdateMs <= 0) {
                // Reset timer
                offset = (-objinfo->timeToNextUpdateMs) % objinfo->updatePeriodMs;
                objinfo->timeToNextUpdateMs = objinfo->updatePeriodMs - offset;
                // Send object
                time.start();
                processObjectUpdates(objinfo->obj, EV_UPDATED_PERIODIC, true, false);
                elapsedMs = time.elapsed();
                // Update timeToNextUpdateMs with the elapsed delay of sending the object;
                timeToNextUpdateMs += elapsedMs;
            }
            // Update minimum delay
            if (objinfo->timeToNextUpdateMs < minDelay) {
                minDelay = objinfo->timeToNextUpdateMs;
            }
        }
    }

    // Check if delay for the next update is too short
    if (minDelay < MIN_UPDATE_PERIOD_MS) {
        minDelay = MIN_UPDATE_PERIOD_MS;
    }

    // Done
    timeToNextUpdateMs = minDelay;

    // Restart timer
    updateTimer->start(timeToNextUpdateMs);
}

Telemetry::TelemetryStats Telemetry::getStats()
{
    // Get UAVTalk stats
    UAVTalk::ComStats utalkStats = utalk->getStats();

    // Update stats
    TelemetryStats stats;
    stats.txBytes = utalkStats.txBytes;
    stats.rxBytes = utalkStats.rxBytes;
    stats.txObjectBytes = utalkStats.txObjectBytes;
    stats.rxObjectBytes = utalkStats.rxObjectBytes;
    stats.rxObjects = utalkStats.rxObjects;
    stats.txObjects = utalkStats.txObjects;
    stats.txErrors = utalkStats.txErrors + txErrors;
    stats.rxErrors = utalkStats.rxErrors;
    stats.txRetries = txRetries;

    txErrors = 0;
    txRetries = 0;

    // Done
    return stats;
}

void Telemetry::objectUpdatedAuto(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UPDATED, false, true);
}

void Telemetry::objectUpdatedManual(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UPDATED_MANUAL, false, true);
}

void Telemetry::objectUpdatedPeriodic(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UPDATED_PERIODIC, false, true);
}

void Telemetry::objectUnpacked(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UNPACKED, false, true);
}

void Telemetry::updateRequested(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UPDATE_REQ, false, true);
}

void Telemetry::updateAllInstancesRequested(UAVObject *obj)
{
    processObjectUpdates(obj, EV_UPDATE_REQ, true, true);
}

void Telemetry::newObject(UAVObject *obj)
{
    registerObject(obj);
}

void Telemetry::newInstance(UAVObject *obj)
{
    registerObject(obj);
}

ObjectTransactionInfo::ObjectTransactionInfo(QObject *parent)
    : QObject(parent)
{
    obj = nullptr;
    allInstances = false;
    objRequest = false;
    retriesRemaining = 0;
    acked = false;
    telem = nullptr;
    // Setup transaction timer
    timer = new QTimer(this);
    timer->stop();
    connect(timer, &QTimer::timeout, this, &ObjectTransactionInfo::timeout);
}

ObjectTransactionInfo::~ObjectTransactionInfo()
{
    telem = nullptr;
    timer->stop();
    timer->deleteLater();
}

void ObjectTransactionInfo::timeout()
{
    if (!telem.isNull())
        telem->transactionTimeout(this);
}