PX4ParameterMetaData.cc 21.5 KB
Newer Older
1 2
/****************************************************************************
 *
Gus Grubba's avatar
Gus Grubba committed
3
 * (c) 2009-2020 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
4 5 6 7 8 9
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

10 11 12 13

/// @file
///     @author Don Gagne <don@thegagnes.com>

14
#include "PX4ParameterMetaData.h"
15 16 17 18 19 20 21 22
#include "QGCApplication.h"
#include "QGCLoggingCategory.h"

#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QDebug>

23 24
static const char* kInvalidConverstion = "Internal Error: No support for string parameters";

25
QGC_LOGGING_CATEGORY(PX4ParameterMetaDataLog, "PX4ParameterMetaDataLog")
26

27 28
PX4ParameterMetaData::PX4ParameterMetaData(void)
    : _parameterMetaDataLoaded(false)
29
{
30

31 32 33 34 35 36 37
}

/// Converts a string to a typed QVariant
///     @param string String to convert
///     @param type Type for Fact which dictates the QVariant type as well
///     @param convertOk Returned: true: conversion success, false: conversion failure
/// @return Returns the correctly type QVariant
38
QVariant PX4ParameterMetaData::_stringToTypedVariant(const QString& string, FactMetaData::ValueType_t type, bool* convertOk)
39 40 41
{
    QVariant var(string);

Don Gagne's avatar
Don Gagne committed
42
    int convertTo = QVariant::Int; // keep compiler warning happy
43
    switch (type) {
Don Gagne's avatar
Don Gagne committed
44 45 46
    case FactMetaData::valueTypeUint8:
    case FactMetaData::valueTypeUint16:
    case FactMetaData::valueTypeUint32:
47
    case FactMetaData::valueTypeUint64:
Don Gagne's avatar
Don Gagne committed
48 49 50 51 52
        convertTo = QVariant::UInt;
        break;
    case FactMetaData::valueTypeInt8:
    case FactMetaData::valueTypeInt16:
    case FactMetaData::valueTypeInt32:
53
    case FactMetaData::valueTypeInt64:
Don Gagne's avatar
Don Gagne committed
54 55 56 57 58
        convertTo = QVariant::Int;
        break;
    case FactMetaData::valueTypeFloat:
        convertTo = QMetaType::Float;
        break;
59
    case FactMetaData::valueTypeElapsedTimeInSeconds:
Don Gagne's avatar
Don Gagne committed
60 61 62 63
    case FactMetaData::valueTypeDouble:
        convertTo = QVariant::Double;
        break;
    case FactMetaData::valueTypeString:
64
        qWarning() << kInvalidConverstion;
Don Gagne's avatar
Don Gagne committed
65 66
        convertTo = QVariant::String;
        break;
67
    case FactMetaData::valueTypeBool:
68
        qWarning() << kInvalidConverstion;
69 70
        convertTo = QVariant::Bool;
        break;
71 72 73 74
    case FactMetaData::valueTypeCustom:
        qWarning() << kInvalidConverstion;
        convertTo = QVariant::ByteArray;
        break;
75 76 77 78 79 80 81
    }
    
    *convertOk = var.convert(convertTo);
    
    return var;
}

82
void PX4ParameterMetaData::loadParameterFactMetaDataFile(const QString& metaDataFile)
83
{
84
    qCDebug(ParameterManagerLog) << "PX4ParameterMetaData::loadParameterFactMetaDataFile" << metaDataFile;
85

86
    if (_parameterMetaDataLoaded) {
87
        qWarning() << "Internal error: parameter meta data loaded more than once";
88 89 90
        return;
    }
    _parameterMetaDataLoaded = true;
DonLakeFlyer's avatar
DonLakeFlyer committed
91

92
    qCDebug(PX4ParameterMetaDataLog) << "Loading parameter meta data:" << metaDataFile;
93

94
    QFile xmlFile(metaDataFile);
95

96 97 98
    if (!xmlFile.exists()) {
        qWarning() << "Internal error: metaDataFile mission" << metaDataFile;
        return;
99
    }
100
    
101 102 103 104
    if (!xmlFile.open(QIODevice::ReadOnly)) {
        qWarning() << "Internal error: Unable to open parameter file:" << metaDataFile << xmlFile.errorString();
        return;
    }
105 106 107 108 109 110 111 112
    
    QXmlStreamReader xml(xmlFile.readAll());
    xmlFile.close();
    if (xml.hasError()) {
        qWarning() << "Badly formed XML" << xml.errorString();
        return;
    }
    
113 114
    QString         factGroup;
    QString         errorString;
115
    FactMetaData*   metaData = nullptr;
116 117
    int             xmlState = XmlStateNone;
    bool            badMetaData = true;
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
    
    while (!xml.atEnd()) {
        if (xml.isStartElement()) {
            QString elementName = xml.name().toString();
            
            if (elementName == "parameters") {
                if (xmlState != XmlStateNone) {
                    qWarning() << "Badly formed XML";
                    return;
                }
                xmlState = XmlStateFoundParameters;
                
            } else if (elementName == "version") {
                if (xmlState != XmlStateFoundParameters) {
                    qWarning() << "Badly formed XML";
                    return;
                }
                xmlState = XmlStateFoundVersion;
                
                bool convertOk;
                QString strVersion = xml.readElementText();
                int intVersion = strVersion.toInt(&convertOk);
                if (!convertOk) {
                    qWarning() << "Badly formed XML";
                    return;
                }
144
                if (intVersion <= 2) {
145
                    // We can't read these old files
146
                    qDebug() << "Parameter version stamp too old, skipping load. Found:" << intVersion << "Want: 3 File:" << metaDataFile;
147 148 149
                    return;
                }
                
150 151 152 153 154
            } else if (elementName == "parameter_version_major") {
                // Just skip over for now
            } else if (elementName == "parameter_version_minor") {
                // Just skip over for now

155 156 157
            } else if (elementName == "group") {
                if (xmlState != XmlStateFoundVersion) {
                    // We didn't get a version stamp, assume older version we can't read
158
                    qDebug() << "Parameter version stamp not found, skipping load" << metaDataFile;
159 160 161 162 163 164 165 166 167
                    return;
                }
                xmlState = XmlStateFoundGroup;
                
                if (!xml.attributes().hasAttribute("name")) {
                    qWarning() << "Badly formed XML";
                    return;
                }
                factGroup = xml.attributes().value("name").toString();
168
                qCDebug(PX4ParameterMetaDataLog) << "Found group: " << factGroup;
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
                
            } else if (elementName == "parameter") {
                if (xmlState != XmlStateFoundGroup) {
                    qWarning() << "Badly formed XML";
                    return;
                }
                xmlState = XmlStateFoundParameter;
                
                if (!xml.attributes().hasAttribute("name") || !xml.attributes().hasAttribute("type")) {
                    qWarning() << "Badly formed XML";
                    return;
                }
                
                QString name = xml.attributes().value("name").toString();
                QString type = xml.attributes().value("type").toString();
184
                QString strDefault =    xml.attributes().value("default").toString();
185
                
186 187 188 189 190
                QString category = xml.attributes().value("category").toString();
                if (category.isEmpty()) {
                    category = QStringLiteral("Standard");
                }

191 192 193 194 195 196 197 198 199 200 201 202 203 204
                bool volatileValue = false;
                bool readOnly = false;
                QString volatileStr = xml.attributes().value("volatile").toString();
                if (volatileStr.compare(QStringLiteral("true")) == 0) {
                    volatileValue = true;
                    readOnly = true;
                }
                if (!volatileValue) {
                    QString readOnlyStr = xml.attributes().value("readonly").toString();
                    if (readOnlyStr.compare(QStringLiteral("true")) == 0) {
                        readOnly = true;
                    }
                }

205
                qCDebug(PX4ParameterMetaDataLog) << "Found parameter name:" << name << " type:" << type << " default:" << strDefault;
206 207

                // Convert type from string to FactMetaData::ValueType_t
Don Gagne's avatar
Don Gagne committed
208 209 210
                bool unknownType;
                FactMetaData::ValueType_t foundType = FactMetaData::stringToType(type, unknownType);
                if (unknownType) {
211 212 213 214 215
                    qWarning() << "Parameter meta data with bad type:" << type << " name:" << name;
                    return;
                }
                
                // Now that we know type we can create meta data object and add it to the system
216
                metaData = new FactMetaData(foundType, this);
217
                if (_mapParameterName2FactMetaData.contains(name)) {
218
                    // We can't trust the meta data since we have dups
219
                    qCWarning(PX4ParameterMetaDataLog) << "Duplicate parameter found:" << name;
220 221 222
                    badMetaData = true;
                    // Reset to default meta data
                    _mapParameterName2FactMetaData[name] = metaData;
223
                } else {
224
                    _mapParameterName2FactMetaData[name] = metaData;
225
                    metaData->setName(name);
226
                    metaData->setCategory(category);
227
                    metaData->setGroup(factGroup);
228 229
                    metaData->setReadOnly(readOnly);
                    metaData->setVolatileValue(volatileValue);
230
                    
231 232 233
                    if (xml.attributes().hasAttribute("default") && !strDefault.isEmpty()) {
                        QVariant varDefault;
                        
234 235
                        if (metaData->convertAndValidateRaw(strDefault, false, varDefault, errorString)) {
                            metaData->setRawDefaultValue(varDefault);
236
                        } else {
237
                            qCWarning(PX4ParameterMetaDataLog) << "Invalid default value, name:" << name << " type:" << type << " default:" << strDefault << " error:" << errorString;
238
                        }
239 240 241 242 243 244 245 246 247 248
                    }
                }
                
            } else {
                // We should be getting meta data now
                if (xmlState != XmlStateFoundParameter) {
                    qWarning() << "Badly formed XML";
                    return;
                }

249
                if (!badMetaData) {
DonLakeFlyer's avatar
DonLakeFlyer committed
250 251 252 253 254 255
                    if (metaData) {
                        if (elementName == "short_desc") {
                            QString text = xml.readElementText();
                            text = text.replace("\n", " ");
                            qCDebug(PX4ParameterMetaDataLog) << "Short description:" << text;
                            metaData->setShortDescription(text);
256

DonLakeFlyer's avatar
DonLakeFlyer committed
257 258 259 260 261
                        } else if (elementName == "long_desc") {
                            QString text = xml.readElementText();
                            text = text.replace("\n", " ");
                            qCDebug(PX4ParameterMetaDataLog) << "Long description:" << text;
                            metaData->setLongDescription(text);
262

DonLakeFlyer's avatar
DonLakeFlyer committed
263 264 265
                        } else if (elementName == "min") {
                            QString text = xml.readElementText();
                            qCDebug(PX4ParameterMetaDataLog) << "Min:" << text;
266

DonLakeFlyer's avatar
DonLakeFlyer committed
267
                            QVariant varMin;
268
                            if (metaData->convertAndValidateRaw(text, false /* convertOnly */, varMin, errorString)) {
DonLakeFlyer's avatar
DonLakeFlyer committed
269 270 271 272
                                metaData->setRawMin(varMin);
                            } else {
                                qCWarning(PX4ParameterMetaDataLog) << "Invalid min value, name:" << metaData->name() << " type:" << metaData->type() << " min:" << text << " error:" << errorString;
                            }
273

DonLakeFlyer's avatar
DonLakeFlyer committed
274 275 276 277 278
                        } else if (elementName == "max") {
                            QString text = xml.readElementText();
                            qCDebug(PX4ParameterMetaDataLog) << "Max:" << text;

                            QVariant varMax;
279
                            if (metaData->convertAndValidateRaw(text, false /* convertOnly */, varMax, errorString)) {
DonLakeFlyer's avatar
DonLakeFlyer committed
280 281 282 283
                                metaData->setRawMax(varMax);
                            } else {
                                qCWarning(PX4ParameterMetaDataLog) << "Invalid max value, name:" << metaData->name() << " type:" << metaData->type() << " max:" << text << " error:" << errorString;
                            }
Don Gagne's avatar
Don Gagne committed
284

DonLakeFlyer's avatar
DonLakeFlyer committed
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
                        } else if (elementName == "unit") {
                            QString text = xml.readElementText();
                            qCDebug(PX4ParameterMetaDataLog) << "Unit:" << text;
                            metaData->setRawUnits(text);

                        } else if (elementName == "decimal") {
                            QString text = xml.readElementText();
                            qCDebug(PX4ParameterMetaDataLog) << "Decimal:" << text;

                            bool convertOk;
                            QVariant varDecimals = QVariant(text).toUInt(&convertOk);
                            if (convertOk) {
                                metaData->setDecimalPlaces(varDecimals.toInt());
                            } else {
                                qCWarning(PX4ParameterMetaDataLog) << "Invalid decimals value, name:" << metaData->name() << " type:" << metaData->type() << " decimals:" << text << " error: invalid number";
                            }

                        } else if (elementName == "reboot_required") {
                            QString text = xml.readElementText();
                            qCDebug(PX4ParameterMetaDataLog) << "RebootRequired:" << text;
                            if (text.compare("true", Qt::CaseInsensitive) == 0) {
306
                                metaData->setVehicleRebootRequired(true);
DonLakeFlyer's avatar
DonLakeFlyer committed
307 308 309 310 311 312 313 314
                            }

                        } else if (elementName == "values") {
                            // doing nothing individual value will follow anyway. May be used for sanity checking.

                        } else if (elementName == "value") {
                            QString enumValueStr = xml.attributes().value("code").toString();
                            QString enumString = xml.readElementText();
315
                            qCDebug(PX4ParameterMetaDataLog) << "parameter value:"
DonLakeFlyer's avatar
DonLakeFlyer committed
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
                                                             << "value desc:" << enumString << "code:" << enumValueStr;

                            QVariant    enumValue;
                            QString     errorString;
                            if (metaData->convertAndValidateRaw(enumValueStr, false /* validate */, enumValue, errorString)) {
                                metaData->addEnumInfo(enumString, enumValue);
                            } else {
                                qCDebug(PX4ParameterMetaDataLog) << "Invalid enum value, name:" << metaData->name()
                                                                 << " type:" << metaData->type() << " value:" << enumValueStr
                                                                 << " error:" << errorString;
                            }
                        } else if (elementName == "increment") {
                            double  increment;
                            bool    ok;
                            QString text = xml.readElementText();
                            increment = text.toDouble(&ok);
                            if (ok) {
333
                                metaData->setRawIncrement(increment);
DonLakeFlyer's avatar
DonLakeFlyer committed
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
                            } else {
                                qCWarning(PX4ParameterMetaDataLog) << "Invalid value for increment, name:" << metaData->name() << " increment:" << text;
                            }

                        } else if (elementName == "boolean") {
                            QVariant    enumValue;
                            metaData->convertAndValidateRaw(1, false /* validate */, enumValue, errorString);
                            metaData->addEnumInfo(tr("Enabled"), enumValue);
                            metaData->convertAndValidateRaw(0, false /* validate */, enumValue, errorString);
                            metaData->addEnumInfo(tr("Disabled"), enumValue);

                        } else if (elementName == "bitmask") {
                            // doing nothing individual bits will follow anyway. May be used for sanity checking.

                        } else if (elementName == "bit") {
                            bool ok = false;
                            unsigned char bit = xml.attributes().value("index").toString().toUInt(&ok);
                            if (ok) {
                                QString bitDescription = xml.readElementText();
                                qCDebug(PX4ParameterMetaDataLog) << "parameter value:"
                                                                 << "index:" << bit << "description:" << bitDescription;

                                if (bit < 31) {
                                    QVariant bitmaskRawValue = 1 << bit;
                                    QVariant bitmaskValue;
                                    QString errorString;
                                    if (metaData->convertAndValidateRaw(bitmaskRawValue, true, bitmaskValue, errorString)) {
                                        metaData->addBitmaskInfo(bitDescription, bitmaskValue);
                                    } else {
                                        qCDebug(PX4ParameterMetaDataLog) << "Invalid bitmask value, name:" << metaData->name()
                                                                         << " type:" << metaData->type() << " value:" << bitmaskValue
                                                                         << " error:" << errorString;
                                    }
367
                                } else {
DonLakeFlyer's avatar
DonLakeFlyer committed
368
                                    qCWarning(PX4ParameterMetaDataLog) << "Invalid value for bitmask, bit:" << bit;
369 370
                                }
                            }
DonLakeFlyer's avatar
DonLakeFlyer committed
371 372
                        } else {
                            qCDebug(PX4ParameterMetaDataLog) << "Unknown element in XML: " << elementName;
373
                        }
374
                    } else {
DonLakeFlyer's avatar
DonLakeFlyer committed
375
                        qWarning() << "Internal error";
376 377 378 379 380 381 382
                    }
                }
            }
        } else if (xml.isEndElement()) {
            QString elementName = xml.name().toString();

            if (elementName == "parameter") {
383 384 385
                // Done loading this parameter, validate default value
                if (metaData->defaultValueAvailable()) {
                    QVariant var;
DonLakeFlyer's avatar
DonLakeFlyer committed
386

387 388
                    if (!metaData->convertAndValidateRaw(metaData->rawDefaultValue(), false /* convertOnly */, var, errorString)) {
                        qCWarning(PX4ParameterMetaDataLog) << "Invalid default value, name:" << metaData->name() << " type:" << metaData->type() << " default:" << metaData->rawDefaultValue() << " error:" << errorString;
389 390
                    }
                }
DonLakeFlyer's avatar
DonLakeFlyer committed
391

392
                // Reset for next parameter
393
                metaData = nullptr;
394
                badMetaData = false;
395 396 397 398 399 400 401 402 403
                xmlState = XmlStateFoundGroup;
            } else if (elementName == "group") {
                xmlState = XmlStateFoundVersion;
            } else if (elementName == "parameters") {
                xmlState = XmlStateFoundParameters;
            }
        }
        xml.readNext();
    }
404 405 406 407 408 409 410 411 412
}

FactMetaData* PX4ParameterMetaData::getMetaDataForFact(const QString& name, MAV_TYPE vehicleType)
{
    Q_UNUSED(vehicleType)

    if (_mapParameterName2FactMetaData.contains(name)) {
        return _mapParameterName2FactMetaData[name];
    } else {
413
        return nullptr;
414
    }
415 416
}

417
void PX4ParameterMetaData::addMetaDataToFact(Fact* fact, MAV_TYPE vehicleType)
418
{
419 420
    Q_UNUSED(vehicleType)

421 422
    if (_mapParameterName2FactMetaData.contains(fact->name())) {
        fact->setMetaData(_mapParameterName2FactMetaData[fact->name()]);
423 424 425 426 427 428
    }
}

void PX4ParameterMetaData::getParameterMetaDataVersionInfo(const QString& metaDataFile, int& majorVersion, int& minorVersion)
{
    QFile xmlFile(metaDataFile);
429 430 431 432
    QString errorString;

    majorVersion = -1;
    minorVersion = -1;
433 434

    if (!xmlFile.exists()) {
435
        _outputFileWarning(metaDataFile, QStringLiteral("Does not exist"), QString());
436 437 438 439
        return;
    }

    if (!xmlFile.open(QIODevice::ReadOnly)) {
440
        _outputFileWarning(metaDataFile, QStringLiteral("Unable to open file"), xmlFile.errorString());
441 442 443 444 445 446
        return;
    }

    QXmlStreamReader xml(xmlFile.readAll());
    xmlFile.close();
    if (xml.hasError()) {
447
        _outputFileWarning(metaDataFile, QStringLiteral("Badly formed XML"), xml.errorString());
448 449 450 451 452 453 454 455 456 457 458 459
        return;
    }

    while (!xml.atEnd() && (majorVersion == -1 || minorVersion == -1)) {
        if (xml.isStartElement()) {
            QString elementName = xml.name().toString();

            if (elementName == "parameter_version_major") {
                bool convertOk;
                QString strVersion = xml.readElementText();
                majorVersion = strVersion.toInt(&convertOk);
                if (!convertOk) {
460
                    _outputFileWarning(metaDataFile, QStringLiteral("Unable to convert parameter_version_major value to int"), QString());
461 462 463 464 465 466 467
                    return;
                }
            } else if (elementName == "parameter_version_minor") {
                bool convertOk;
                QString strVersion = xml.readElementText();
                minorVersion = strVersion.toInt(&convertOk);
                if (!convertOk) {
468
                    _outputFileWarning(metaDataFile, QStringLiteral("Unable to convert parameter_version_minor value to int"), QString());
469 470 471 472 473 474 475 476
                    return;
                }
            }
        }
        xml.readNext();
    }

    if (majorVersion == -1) {
477
        _outputFileWarning(metaDataFile, QStringLiteral("parameter_version_major is missing"), QString());
478 479
    }
    if (minorVersion == -1) {
480
        _outputFileWarning(metaDataFile, QStringLiteral("parameter_version_minor tag is missing"), QString());
481 482
    }
}
483 484 485 486 487

void PX4ParameterMetaData::_outputFileWarning(const QString& metaDataFile, const QString& error1, const QString& error2)
{
    qWarning() << QStringLiteral("Internal Error: Parameter meta data file '%1'. %2. error: %3").arg(metaDataFile).arg(error1).arg(error2);
}