uavobject.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 "uavobject.h"
#include <QtEndian>
#include <QDebug>
#include <QJsonArray>
#include <QJsonValue>

// Constants
#define UAVOBJ_ACCESS_SHIFT 0
#define UAVOBJ_GCS_ACCESS_SHIFT 1
#define UAVOBJ_TELEMETRY_ACKED_SHIFT 2
#define UAVOBJ_GCS_TELEMETRY_ACKED_SHIFT 3
#define UAVOBJ_TELEMETRY_UPDATE_MODE_SHIFT 4
#define UAVOBJ_GCS_TELEMETRY_UPDATE_MODE_SHIFT 6
#define UAVOBJ_UPDATE_MODE_MASK 0x3

// Macros
#define SET_BITS(var, shift, value, mask) var = (var & ~(mask << shift)) | (value << shift);

UAVObject::UAVObject(quint32 objID, bool isSingleInst, const QString &name)
{
    this->objID = objID;
    this->instID = 0;
    this->isSingleInst = isSingleInst;
    this->name = name;
}

void UAVObject::initialize(quint32 instID)
{
    this->instID = instID;
}

void UAVObject::initializeFields(QList<UAVObjectField *> &fields, quint8 *data, quint32 numBytes)
{
    this->numBytes = numBytes;
    this->data = data;
    this->fields = fields;
    // Initialize fields
    quint32 offset = 0;
    for (int n = 0; n < fields.length(); ++n) {
        fields[n]->initialize(data, offset, this);
        offset += fields[n]->getNumBytes();
        connect(fields[n], &UAVObjectField::fieldUpdated, this, &UAVObject::fieldUpdated);
    }
}

void UAVObject::fieldUpdated(UAVObjectField *field)
{
    Q_UNUSED(field);
}

quint32 UAVObject::getObjID()
{
    return objID;
}

quint32 UAVObject::getInstID()
{
    return instID;
}

bool UAVObject::isSingleInstance()
{
    return isSingleInst;
}

QString UAVObject::getName()
{
    return name;
}

QString UAVObject::getDescription()
{
    return description;
}

void UAVObject::setDescription(const QString &description)
{
    this->description = description;
}

quint32 UAVObject::getNumBytes()
{
    return numBytes;
}

void UAVObject::requestUpdate()
{
    emit updateRequested(this);
}

void UAVObject::requestUpdateAllInstances()
{
    emit updateAllInstancesRequested(this);
}

void UAVObject::updated()
{
    emit objectUpdatedManual(this);
    emit objectUpdated(this);
}

qint32 UAVObject::getNumFields()
{
    return fields.count();
}

QList<UAVObjectField *> UAVObject::getFields()
{
    return fields;
}

QJsonObject UAVObject::getJsonRepresentation()
{

    QJsonObject obj, fieldMap;

    obj["id"] = static_cast<qint64>(getObjID());
    obj["name"] = getName();

    foreach (UAVObjectField *field, fields) {
        quint32 nelem = field->getNumElements();

        if (nelem > 1) {
            QVariantList vals;
            for (unsigned int n = 0; n < nelem; ++n) {
                vals.append(field->getValue(n));
            }

            fieldMap[field->getName()] = QJsonArray::fromVariantList(vals);
        } else {
            fieldMap[field->getName()] = QJsonValue::fromVariant(field->getValue(0));
        }
    }

    obj["fields"] = fieldMap;

    return obj;
}

UAVObjectField *UAVObject::getField(const QString &name)
{
    // Look for field
    for (int n = 0; n < fields.length(); ++n) {
        if (name.compare(fields[n]->getName()) == 0) {
            return fields[n];
        }
    }
    // If this point is reached then the field was not found
    qWarning() << "UAVObject::getField Non existant field " << name
               << " requested.  This indicates a bug.  Make sure you also have null checking for "
                  "non-debug code.";
    return NULL;
}

qint32 UAVObject::pack(quint8 *dataOut)
{
    qint32 offset = 0;
    for (QList<UAVObjectField *>::iterator iter = fields.begin(); iter != fields.end(); ++iter) {
        UAVObjectField *field = *iter;
        field->pack(&dataOut[offset]);
        offset += field->getNumBytes();
    }
    return numBytes;
}

qint32 UAVObject::unpack(const quint8 *dataIn)
{
    qint32 offset = 0;
    for (QList<UAVObjectField *>::iterator iter = fields.begin(); iter != fields.end(); ++iter) {
        UAVObjectField *field = *iter;
        field->unpack(&dataIn[offset]);
        offset += field->getNumBytes();
    }
    emit objectUnpacked(this); // trigger object updated event
    emit objectUpdated(this);

    return numBytes;
}

QString UAVObject::toString()
{
    QString sout;
    sout.append(toStringBrief());
    sout.append(toStringData());
    return sout;
}

QString UAVObject::toStringBrief()
{
    QString sout;
    sout.append(QString("%1 (ID: %2, InstID: %3, NumBytes: %4, SInst: %5)\n")
                    .arg(getName())
                    .arg(getObjID())
                    .arg(getInstID())
                    .arg(getNumBytes())
                    .arg(isSingleInstance()));
    return sout;
}

QString UAVObject::toStringData()
{
    QString sout;
    sout.append("Data:\n");
    for (QList<UAVObjectField *>::iterator iter = fields.begin(); iter != fields.end(); ++iter) {
        UAVObjectField *field = *iter;
        sout.append(QString("\t%1").arg(field->toString()));
    }
    return sout;
}

void UAVObject::emitTransactionCompleted(bool success)
{
    emit transactionCompleted(this, success);
}

void UAVObject::emitTransactionCompleted(bool success, bool nacked)
{
    emit transactionCompleted(this, success, nacked);
}

void UAVObject::emitNewInstance(UAVObject *obj)
{
    emit newInstance(obj);
}

void UAVObject::emitInstanceRemoved(UAVObject *obj)
{
    emit instanceRemoved(obj);
}

void UAVObject::MetadataInitialize(UAVObject::Metadata &metadata)
{
    metadata.flags = ACCESS_READWRITE << UAVOBJ_ACCESS_SHIFT
        | ACCESS_READWRITE << UAVOBJ_GCS_ACCESS_SHIFT | 1 << UAVOBJ_TELEMETRY_ACKED_SHIFT
        | 1 << UAVOBJ_GCS_TELEMETRY_ACKED_SHIFT
        | UPDATEMODE_ONCHANGE << UAVOBJ_TELEMETRY_UPDATE_MODE_SHIFT
        | UPDATEMODE_ONCHANGE << UAVOBJ_GCS_TELEMETRY_UPDATE_MODE_SHIFT;
    metadata.flightTelemetryUpdatePeriod = 0;
    metadata.gcsTelemetryUpdatePeriod = 0;
    metadata.loggingUpdatePeriod = 0;
}

UAVObject::AccessMode UAVObject::GetFlightAccess(const UAVObject::Metadata &metadata)
{
    return UAVObject::AccessMode((metadata.flags >> UAVOBJ_ACCESS_SHIFT) & 1);
}

void UAVObject::SetFlightAccess(UAVObject::Metadata &metadata, UAVObject::AccessMode mode)
{
    SET_BITS(metadata.flags, UAVOBJ_ACCESS_SHIFT, mode, 1);
}

UAVObject::AccessMode UAVObject::GetGcsAccess(const UAVObject::Metadata &metadata)
{
    return UAVObject::AccessMode((metadata.flags >> UAVOBJ_GCS_ACCESS_SHIFT) & 1);
}

void UAVObject::SetGcsAccess(UAVObject::Metadata &metadata, UAVObject::AccessMode mode)
{
    SET_BITS(metadata.flags, UAVOBJ_GCS_ACCESS_SHIFT, mode, 1);
}

quint8 UAVObject::GetFlightTelemetryAcked(const UAVObject::Metadata &metadata)
{
    return (metadata.flags >> UAVOBJ_TELEMETRY_ACKED_SHIFT) & 1;
}

void UAVObject::SetFlightTelemetryAcked(UAVObject::Metadata &metadata, quint8 val)
{
    SET_BITS(metadata.flags, UAVOBJ_TELEMETRY_ACKED_SHIFT, val, 1);
}

quint8 UAVObject::GetGcsTelemetryAcked(const UAVObject::Metadata &metadata)
{
    return (metadata.flags >> UAVOBJ_GCS_TELEMETRY_ACKED_SHIFT) & 1;
}

void UAVObject::SetGcsTelemetryAcked(UAVObject::Metadata &metadata, quint8 val)
{
    SET_BITS(metadata.flags, UAVOBJ_GCS_TELEMETRY_ACKED_SHIFT, val, 1);
}

UAVObject::UpdateMode UAVObject::GetFlightTelemetryUpdateMode(const UAVObject::Metadata &metadata)
{
    return UAVObject::UpdateMode((metadata.flags >> UAVOBJ_TELEMETRY_UPDATE_MODE_SHIFT)
                                 & UAVOBJ_UPDATE_MODE_MASK);
}

void UAVObject::SetFlightTelemetryUpdateMode(UAVObject::Metadata &metadata,
                                             UAVObject::UpdateMode val)
{
    SET_BITS(metadata.flags, UAVOBJ_TELEMETRY_UPDATE_MODE_SHIFT, val, UAVOBJ_UPDATE_MODE_MASK);
}

UAVObject::UpdateMode UAVObject::GetGcsTelemetryUpdateMode(const UAVObject::Metadata &metadata)
{
    return UAVObject::UpdateMode((metadata.flags >> UAVOBJ_GCS_TELEMETRY_UPDATE_MODE_SHIFT)
                                 & UAVOBJ_UPDATE_MODE_MASK);
}

void UAVObject::SetGcsTelemetryUpdateMode(UAVObject::Metadata &metadata, UAVObject::UpdateMode val)
{
    SET_BITS(metadata.flags, UAVOBJ_GCS_TELEMETRY_UPDATE_MODE_SHIFT, val, UAVOBJ_UPDATE_MODE_MASK);
}