zhaohuwei
/
QG4
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Airframe loader: Add commented-out code to load XML format from param class

QGC4.4
Lorenz Meier 10 years ago
parent
15bc15e878
commit
6368f2d3e6
2 changed files with 357 additions and 6 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 301
      src/AutoPilotPlugins/PX4/PX4AirframeLoader.cc
  2. 62
      src/AutoPilotPlugins/PX4/PX4AirframeLoader.h

301
src/AutoPilotPlugins/PX4/PX4AirframeLoader.cc
Unescape View File

@ -1,12 +1,307 @@ @@ -1,12 +1,307 @@
/*=====================================================================
QGroundControl Open Source Ground Control Station
(c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
This file is part of the QGROUNDCONTROL project
QGROUNDCONTROL 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.
QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
======================================================================*/
/// @file
/// @author Don Gagne <don@thegagnes.com>
#include "PX4AirframeLoader.h"
#include "QGCApplication.h"
#include "QGCLoggingCategory.h"
#include "AirframeComponentAirframes.h"
PX4AirframeLoader::PX4AirframeLoader()
{
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
QGC_LOGGING_CATEGORY(PX4AirframeLoaderLog, "PX4AirframeLoaderLog")
bool PX4AirframeLoader::_airframeMetaDataLoaded = false;
//QMap<QString, FactMetaData*> PX4AirframeLoader::_mapParameterName2FactMetaData;
PX4AirframeLoader::PX4AirframeLoader(AutoPilotPlugin* autopilot, UASInterface* uas, QObject* parent)
{
Q_ASSERT(uas);
}
PX4AirframeLoader::~PX4AirframeLoader()
/// Load Airframe Fact meta data
///
/// The meta data comes from firmware airframes.xml file.
void PX4AirframeLoader::loadAirframeFactMetaData(void)
{
if (_airframeMetaDataLoaded) {
return;
}
_airframeMetaDataLoaded = true;
qCDebug(PX4AirframeLoaderLog) << "Loading PX4 airframe fact meta data";
Q_ASSERT(AirframeComponentAirframes::rgAirframeTypes.count() == 0);
// QString parameterFilename;
// // We want unit test builds to always use the resource based meta data to provide repeatable results
// if (!qgcApp()->runningUnitTests()) {
// // First look for meta data that comes from a firmware download. Fall back to resource if not there.
// QSettings settings;
// QDir parameterDir = QFileInfo(settings.fileName()).dir();
// parameterFilename = parameterDir.filePath("PX4AirframeFactMetaData.xml");
// }
// if (parameterFilename.isEmpty() || !QFile(parameterFilename).exists()) {
// parameterFilename = ":/AutoPilotPlugins/PX4/AirframeFactMetaData.xml";
// }
// qCDebug(PX4AirframeLoaderLog) << "Loading meta data file:" << parameterFilename;
// QFile xmlFile(parameterFilename);
// Q_ASSERT(xmlFile.exists());
// bool success = xmlFile.open(QIODevice::ReadOnly);
// Q_UNUSED(success);
// Q_ASSERT(success);
// QXmlStreamReader xml(xmlFile.readAll());
// xmlFile.close();
// if (xml.hasError()) {
// qWarning() << "Badly formed XML" << xml.errorString();
// return;
// }
// QString factGroup;
// QString errorString;
// FactMetaData* metaData = NULL;
// int xmlState = XmlStateNone;
// bool badMetaData = true;
// 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;
// }
// if (intVersion <= 2) {
// // We can't read these old files
// qDebug() << "Parameter version stamp too old, skipping load. Found:" << intVersion << "Want: 3 File:" << parameterFilename;
// return;
// }
// } else if (elementName == "group") {
// if (xmlState != XmlStateFoundVersion) {
// // We didn't get a version stamp, assume older version we can't read
// qDebug() << "Parameter version stamp not found, skipping load" << parameterFilename;
// return;
// }
// xmlState = XmlStateFoundGroup;
// if (!xml.attributes().hasAttribute("name")) {
// qWarning() << "Badly formed XML";
// return;
// }
// factGroup = xml.attributes().value("name").toString();
// qCDebug(PX4AirframeLoaderLog) << "Found group: " << factGroup;
// } 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();
// QString strDefault = xml.attributes().value("default").toString();
// qCDebug(PX4AirframeLoaderLog) << "Found parameter name:" << name << " type:" << type << " default:" << strDefault;
// // Convert type from string to FactMetaData::ValueType_t
// struct String2Type {
// const char* strType;
// FactMetaData::ValueType_t type;
// };
// static const struct String2Type rgString2Type[] = {
// { "FLOAT", FactMetaData::valueTypeFloat },
// { "INT32", FactMetaData::valueTypeInt32 },
// };
// static const size_t crgString2Type = sizeof(rgString2Type) / sizeof(rgString2Type[0]);
// bool found = false;
// FactMetaData::ValueType_t foundType;
// for (size_t i=0; i<crgString2Type; i++) {
// const struct String2Type* info = &rgString2Type[i];
// if (type == info->strType) {
// found = true;
// foundType = info->type;
// break;
// }
// }
// if (!found) {
// 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
// metaData = new FactMetaData(foundType);
// Q_CHECK_PTR(metaData);
// if (_mapParameterName2FactMetaData.contains(name)) {
// // We can't trust the meta dafa since we have dups
// qCWarning(PX4AirframeLoaderLog) << "Duplicate parameter found:" << name;
// badMetaData = true;
// // Reset to default meta data
// _mapParameterName2FactMetaData[name] = metaData;
// } else {
// _mapParameterName2FactMetaData[name] = metaData;
// metaData->setName(name);
// metaData->setGroup(factGroup);
// if (xml.attributes().hasAttribute("default") && !strDefault.isEmpty()) {
// QVariant varDefault;
// if (metaData->convertAndValidate(strDefault, false, varDefault, errorString)) {
// metaData->setDefaultValue(varDefault);
// } else {
// qCWarning(PX4AirframeLoaderLog) << "Invalid default value, name:" << name << " type:" << type << " default:" << strDefault << " error:" << errorString;
// }
// }
// }
// } else {
// // We should be getting meta data now
// if (xmlState != XmlStateFoundParameter) {
// qWarning() << "Badly formed XML";
// return;
// }
// if (!badMetaData) {
// if (elementName == "short_desc") {
// Q_ASSERT(metaData);
// QString text = xml.readElementText();
// text = text.replace("\n", " ");
// qCDebug(PX4AirframeLoaderLog) << "Short description:" << text;
// metaData->setShortDescription(text);
// } else if (elementName == "long_desc") {
// Q_ASSERT(metaData);
// QString text = xml.readElementText();
// text = text.replace("\n", " ");
// qCDebug(PX4AirframeLoaderLog) << "Long description:" << text;
// metaData->setLongDescription(text);
// } else if (elementName == "min") {
// Q_ASSERT(metaData);
// QString text = xml.readElementText();
// qCDebug(PX4AirframeLoaderLog) << "Min:" << text;
// QVariant varMin;
// if (metaData->convertAndValidate(text, true /* convertOnly */, varMin, errorString)) {
// metaData->setMin(varMin);
// } else {
// qCWarning(PX4AirframeLoaderLog) << "Invalid min value, name:" << metaData->name() << " type:" << metaData->type() << " min:" << text << " error:" << errorString;
// }
// } else if (elementName == "max") {
// Q_ASSERT(metaData);
// QString text = xml.readElementText();
// qCDebug(PX4AirframeLoaderLog) << "Max:" << text;
// QVariant varMax;
// if (metaData->convertAndValidate(text, true /* convertOnly */, varMax, errorString)) {
// metaData->setMax(varMax);
// } else {
// qCWarning(PX4AirframeLoaderLog) << "Invalid max value, name:" << metaData->name() << " type:" << metaData->type() << " max:" << text << " error:" << errorString;
// }
// } else if (elementName == "unit") {
// Q_ASSERT(metaData);
// QString text = xml.readElementText();
// qCDebug(PX4AirframeLoaderLog) << "Unit:" << text;
// metaData->setUnits(text);
// } else {
// qDebug() << "Unknown element in XML: " << elementName;
// }
// }
// }
// } else if (xml.isEndElement()) {
// QString elementName = xml.name().toString();
// if (elementName == "parameter") {
// // Done loading this parameter, validate default value
// if (metaData->defaultValueAvailable()) {
// QVariant var;
// if (!metaData->convertAndValidate(metaData->defaultValue(), false /* convertOnly */, var, errorString)) {
// qCWarning(PX4AirframeLoaderLog) << "Invalid default value, name:" << metaData->name() << " type:" << metaData->type() << " default:" << metaData->defaultValue() << " error:" << errorString;
// }
// }
// // Reset for next parameter
// metaData = NULL;
// badMetaData = false;
// xmlState = XmlStateFoundGroup;
// } else if (elementName == "group") {
// xmlState = XmlStateFoundVersion;
// } else if (elementName == "parameters") {
// xmlState = XmlStateFoundParameters;
// }
// }
// xml.readNext();
// }
}
void PX4AirframeLoader::clearStaticData(void)
{
// foreach(QString airframeName, AirframeComponentAirframes::rgAirframeTypes.keys()) {
// delete AirframeComponentAirframes::rgAirframeTypes[airframeName];
// }
AirframeComponentAirframes::rgAirframeTypes.clear();
_airframeMetaDataLoaded = false;
}

62
src/AutoPilotPlugins/PX4/PX4AirframeLoader.h
Unescape View File

@ -1,13 +1,69 @@ @@ -1,13 +1,69 @@
/*=====================================================================
QGroundControl Open Source Ground Control Station
(c) 2009 - 2015 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
This file is part of the QGROUNDCONTROL project
QGROUNDCONTROL 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.
QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
======================================================================*/
#ifndef PX4AIRFRAMELOADER_H
#define PX4AIRFRAMELOADER_H
#include <QObject>
#include <QMap>
#include <QXmlStreamReader>
#include <QLoggingCategory>
class PX4AirframeLoader
#include "ParameterLoader.h"
#include "FactSystem.h"
#include "UASInterface.h"
#include "AutoPilotPlugin.h"
/// @file PX4AirframeLoader.h
/// @author Lorenz Meier <lm@qgroundcontrol.org>
Q_DECLARE_LOGGING_CATEGORY(PX4AirframeLoaderLog)
/// Collection of Parameter Facts for PX4 AutoPilot
class PX4AirframeLoader : QObject
{
Q_OBJECT
public:
PX4AirframeLoader();
~PX4AirframeLoader();
/// @param uas Uas which this set of facts is associated with
PX4AirframeLoader(AutoPilotPlugin* autpilot,UASInterface* uas, QObject* parent = NULL);
static void loadAirframeFactMetaData(void);
static void clearStaticData(void);
private:
enum {
XmlStateNone,
XmlStateFoundAirframes,
XmlStateFoundVersion,
XmlStateFoundGroup,
XmlStateFoundAirframe,
XmlStateDone
};
static bool _airframeMetaDataLoaded; ///< true: parameter meta data already loaded
static QMap<QString, FactMetaData*> _mapParameterName2FactMetaData; ///< Maps from a parameter name to FactMetaData
};
#endif // PX4AIRFRAMELOADER_H

Write Preview
Loading…
Cancel
Save