ground/openpilotgcs/src/plugins/flightlog/flightlogmanager.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       flightlogmanager.cpp
   5  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
   6  * @addtogroup [Group]
   7  * @{
   8  * @addtogroup FlightLogManager
   9  * @{
  10  * @brief [Brief]
  11  *****************************************************************************/
  12 /*
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 3 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  20  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  21  * for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License along
  24  * with this program; if not, write to the Free Software Foundation, Inc.,
  25  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  */
  27
  28 #include "flightlogmanager.h"
  29 #include "extensionsystem/pluginmanager.h"
  30
  31 #include <QApplication>
  32 #include <QFileDialog>
  33 #include <QXmlStreamReader>
  34 #include <QMessageBox>
  35 #include <QDebug>
  36
  37 #include "debuglogcontrol.h"
  38 #include "uavobjecthelper.h"
  39 #include "uavtalk/uavtalk.h"
  40 #include "utils/logfile.h"
  41 #include "uavdataobject.h"
  42 #include <uavobjectutil/uavobjectutilmanager.h>
  43
  44 FlightLogManager::FlightLogManager(QObject *parent) :
  45     QObject(parent), m_disableControls(false),
  46     m_disableExport(true), m_cancelDownload(false),
  47     m_adjustExportedTimestamps(true)
  48 {
  49     ExtensionSystem::PluginManager *pluginManager = ExtensionSystem::PluginManager::instance();
  50
  51     Q_ASSERT(pluginManager);
  52
  53     m_objectManager     = pluginManager->getObject<UAVObjectManager>();
  54     Q_ASSERT(m_objectManager);
  55
  56     m_telemtryManager   = pluginManager->getObject<TelemetryManager>();
  57     Q_ASSERT(m_telemtryManager);
  58
  59     m_objectUtilManager = pluginManager->getObject<UAVObjectUtilManager>();
  60     Q_ASSERT(m_objectUtilManager);
  61
  62     m_flightLogControl  = DebugLogControl::GetInstance(m_objectManager);
  63     Q_ASSERT(m_flightLogControl);
  64
  65     m_flightLogStatus   = DebugLogStatus::GetInstance(m_objectManager);
  66     Q_ASSERT(m_flightLogStatus);
  67     connect(m_flightLogStatus, SIGNAL(FlightChanged(quint16)), this, SLOT(updateFlightEntries(quint16)));
  68
  69     m_flightLogEntry    = DebugLogEntry::GetInstance(m_objectManager);
  70     Q_ASSERT(m_flightLogEntry);
  71
  72     m_flightLogSettings = DebugLogSettings::GetInstance(m_objectManager);
  73     Q_ASSERT(m_flightLogSettings);
  74
  75     m_objectPersistence = ObjectPersistence::GetInstance(m_objectManager);
  76     Q_ASSERT(m_objectPersistence);
  77
  78     updateFlightEntries(m_flightLogStatus->getFlight());
  79
  80     setupLogSettings();
  81     setupLogStatuses();
  82     setupUAVOWrappers();
  83
  84     connect(m_telemtryManager, SIGNAL(connected()), this, SLOT(connectionStatusChanged()));
  85     connect(m_telemtryManager, SIGNAL(disconnected()), this, SLOT(connectionStatusChanged()));
  86     connectionStatusChanged();
  87 }
  88
  89 FlightLogManager::~FlightLogManager()
  90 {
  91     while (!m_logEntries.isEmpty()) {
  92         delete m_logEntries.takeFirst();
  93     }
  94     while (!m_uavoEntries.isEmpty()) {
  95         delete m_uavoEntries.takeFirst();
  96     }
  97 }
  98
  99 void addLogEntries(QQmlListProperty<ExtendedDebugLogEntry> *list, ExtendedDebugLogEntry *entry)
 100 {
 101     Q_UNUSED(list);
 102     Q_UNUSED(entry);
 103 }
 104
 105 int countLogEntries(QQmlListProperty<ExtendedDebugLogEntry> *list)
 106 {
 107     return static_cast< QList<ExtendedDebugLogEntry *> *>(list->data)->size();
 108 }
 109
 110 ExtendedDebugLogEntry *logEntryAt(QQmlListProperty<ExtendedDebugLogEntry> *list, int index)
 111 {
 112     return static_cast< QList<ExtendedDebugLogEntry *> *>(list->data)->at(index);
 113 }
 114
 115 void clearLogEntries(QQmlListProperty<ExtendedDebugLogEntry> *list)
 116 {
 117     return static_cast< QList<ExtendedDebugLogEntry *> *>(list->data)->clear();
 118 }
 119
 120 QQmlListProperty<ExtendedDebugLogEntry> FlightLogManager::logEntries()
 121 {
 122     return QQmlListProperty<ExtendedDebugLogEntry>(this, &m_logEntries, &addLogEntries, &countLogEntries, &logEntryAt, &clearLogEntries);
 123 }
 124
 125 void addUAVOEntries(QQmlListProperty<UAVOLogSettingsWrapper> *list, UAVOLogSettingsWrapper *entry)
 126 {
 127     Q_UNUSED(list);
 128     Q_UNUSED(entry);
 129 }
 130
 131 int countUAVOEntries(QQmlListProperty<UAVOLogSettingsWrapper> *list)
 132 {
 133     return static_cast< QList<UAVOLogSettingsWrapper *> *>(list->data)->size();
 134 }
 135
 136 UAVOLogSettingsWrapper *uavoEntryAt(QQmlListProperty<UAVOLogSettingsWrapper> *list, int index)
 137 {
 138     return static_cast< QList<UAVOLogSettingsWrapper *> *>(list->data)->at(index);
 139 }
 140
 141 void clearUAVOEntries(QQmlListProperty<UAVOLogSettingsWrapper> *list)
 142 {
 143     return static_cast< QList<UAVOLogSettingsWrapper *> *>(list->data)->clear();
 144 }
 145
 146 QQmlListProperty<UAVOLogSettingsWrapper> FlightLogManager::uavoEntries()
 147 {
 148     return QQmlListProperty<UAVOLogSettingsWrapper>(this, &m_uavoEntries, &addUAVOEntries, &countUAVOEntries, &uavoEntryAt, &clearUAVOEntries);
 149 }
 150
 151 QStringList FlightLogManager::flightEntries()
 152 {
 153     return m_flightEntries;
 154 }
 155
 156 void FlightLogManager::clearAllLogs()
 157 {
 158     setDisableControls(true);
 159     QApplication::setOverrideCursor(Qt::WaitCursor);
 160
 161     // Clear on flight side
 162     UAVObjectUpdaterHelper updateHelper;
 163
 164     m_flightLogControl->setFlight(0);
 165     m_flightLogControl->setEntry(0);
 166     m_flightLogControl->setOperation(DebugLogControl::OPERATION_FORMATFLASH);
 167     if (updateHelper.doObjectAndWait(m_flightLogControl, UAVTALK_TIMEOUT) == UAVObjectUpdaterHelper::SUCCESS) {
 168         // Then empty locally
 169         clearLogList();
 170     }
 171
 172     QApplication::restoreOverrideCursor();
 173     setDisableControls(false);
 174 }
 175
 176 void FlightLogManager::clearLogList()
 177 {
 178     QList<ExtendedDebugLogEntry *> tmpList(m_logEntries);
 179     m_logEntries.clear();
 180
 181     emit logEntriesChanged();
 182     setDisableExport(true);
 183
 184     while (!tmpList.isEmpty()) {
 185         delete tmpList.takeFirst();
 186     }
 187 }
 188
 189 void FlightLogManager::retrieveLogs(int flightToRetrieve)
 190 {
 191     setDisableControls(true);
 192     QApplication::setOverrideCursor(Qt::WaitCursor);
 193     m_cancelDownload = false;
 194     UAVObjectUpdaterHelper updateHelper;
 195     UAVObjectRequestHelper requestHelper;
 196
 197     clearLogList();
 198
 199     // Set up what to retrieve
 200     int startFlight = (flightToRetrieve == -1) ? 0 : flightToRetrieve;
 201     int endFlight   = (flightToRetrieve == -1) ? m_flightLogStatus->getFlight() : flightToRetrieve;
 202
 203     // Prepare to send request for event retrieval
 204     m_flightLogControl->setOperation(DebugLogControl::OPERATION_RETRIEVE);
 205     for (int flight = startFlight; flight <= endFlight; flight++) {
 206         m_flightLogControl->setFlight(flight);
 207         bool gotLast = false;
 208         int slot     = 0;
 209         while (!gotLast) {
 210             // Send request for loading flight entry on flight side and wait for ack/nack
 211             m_flightLogControl->setEntry(slot);
 212
 213             if (updateHelper.doObjectAndWait(m_flightLogControl, UAVTALK_TIMEOUT) == UAVObjectUpdaterHelper::SUCCESS &&
 214                 requestHelper.doObjectAndWait(m_flightLogEntry, UAVTALK_TIMEOUT) == UAVObjectUpdaterHelper::SUCCESS) {
 215                 if (m_flightLogEntry->getType() != DebugLogEntry::TYPE_EMPTY) {
 216                     // Ok, we retrieved the entry, and it was the correct one. clone it and add it to the list
 217                     ExtendedDebugLogEntry *logEntry = new ExtendedDebugLogEntry();
 218
 219                     logEntry->setData(m_flightLogEntry->getData(), m_objectManager);
 220                     m_logEntries << logEntry;
 221                     if (logEntry->getData().Type == DebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 222                         const quint32 total_len  = sizeof(DebugLogEntry::DataFields);
 223                         const quint32 data_len   = sizeof(((DebugLogEntry::DataFields *)0)->Data);
 224                         const quint32 header_len = total_len - data_len;
 225
 226                         DebugLogEntry::DataFields fields;
 227                         quint32 start = logEntry->getData().Size;
 228
 229                         // cycle until there is space for another object
 230                         while (start + header_len + 1 < data_len) {
 231                             memset(&fields, 0xFF, total_len);
 232                             memcpy(&fields, &logEntry->getData().Data[start], header_len);
 233                             // check wether a packed object is found
 234                             // note that empty data blocks are set as 0xFF in flight side to minimize flash wearing
 235                             // thus as soon as this read outside of used area, the test will fail as lenght would be 0xFFFF
 236                             quint32 toread = header_len + fields.Size;
 237                             if (!(toread + start > data_len)) {
 238                                 memcpy(&fields, &logEntry->getData().Data[start], toread);
 239                                 ExtendedDebugLogEntry *subEntry = new ExtendedDebugLogEntry();
 240                                 subEntry->setData(fields, m_objectManager);
 241                                 m_logEntries << subEntry;
 242                             }
 243                             start += toread;
 244                         }
 245                     }
 246
 247                     // Increment to get next entry from flight side
 248                     slot++;
 249                 } else {
 250                     // We are done, not more entries on this flight
 251                     gotLast = true;
 252                 }
 253             } else {
 254                 // We failed for some reason
 255                 break;
 256             }
 257             if (m_cancelDownload) {
 258                 break;
 259             }
 260         }
 261         if (m_cancelDownload) {
 262             break;
 263         }
 264     }
 265
 266     if (m_cancelDownload) {
 267         clearLogList();
 268         m_cancelDownload = false;
 269     }
 270
 271     emit logEntriesChanged();
 272     setDisableExport(m_logEntries.count() == 0);
 273
 274     QApplication::restoreOverrideCursor();
 275     setDisableControls(false);
 276 }
 277
 278 void FlightLogManager::exportToOPL(QString fileName)
 279 {
 280     // Fix the file name
 281     fileName.replace(QString(".opl"), QString("%1.opl"));
 282
 283     // Loop and create a new file for each flight.
 284     int currentEntry  = 0;
 285     int currentFlight = 0;
 286     quint32 adjustedBaseTime = 0;
 287     // Continue until all entries are exported
 288     while (currentEntry < m_logEntries.count()) {
 289         if (m_adjustExportedTimestamps) {
 290             adjustedBaseTime = m_logEntries[currentEntry]->getFlightTime();
 291         }
 292
 293         // Get current flight
 294         currentFlight = m_logEntries[currentEntry]->getFlight();
 295
 296         LogFile logFile;
 297         logFile.useProvidedTimeStamp(true);
 298
 299         // Set the file name to contain flight number
 300         logFile.setFileName(fileName.arg(tr("_flight-%1").arg(currentFlight + 1)));
 301         logFile.open(QIODevice::WriteOnly);
 302         UAVTalk uavTalk(&logFile, m_objectManager);
 303
 304         // Export entries until no more available or flight changes
 305         while (currentEntry < m_logEntries.count() && m_logEntries[currentEntry]->getFlight() == currentFlight) {
 306             ExtendedDebugLogEntry *entry = m_logEntries[currentEntry];
 307
 308             // Only log uavobjects
 309             if (entry->getType() == ExtendedDebugLogEntry::TYPE_UAVOBJECT || entry->getType() == ExtendedDebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 310                 // Set timestamp that should be logged for this entry
 311                 logFile.setNextTimeStamp(entry->getFlightTime() - adjustedBaseTime);
 312
 313                 // Use UAVTalk to log complete message to file
 314                 uavTalk.sendObject(entry->uavObject(), false, false);
 315                 qDebug() << entry->getFlightTime() - adjustedBaseTime << "=" << entry->toStringBrief();
 316             }
 317             currentEntry++;
 318         }
 319
 320         logFile.close();
 321     }
 322 }
 323
 324 void FlightLogManager::exportToCSV(QString fileName)
 325 {
 326     QFile csvFile(fileName);
 327
 328     if (csvFile.open(QFile::WriteOnly | QFile::Truncate)) {
 329         QTextStream csvStream(&csvFile);
 330         quint32 baseTime = 0;
 331         quint32 currentFlight = 0;
 332         csvStream << "Flight" << '\t' << "Flight Time" << '\t' << "Entry" << '\t' << "Data" << '\n';
 333         foreach(ExtendedDebugLogEntry * entry, m_logEntries) {
 334             if (m_adjustExportedTimestamps && entry->getFlight() != currentFlight) {
 335                 currentFlight = entry->getFlight();
 336                 baseTime = entry->getFlightTime();
 337             }
 338             entry->toCSV(&csvStream, baseTime);
 339         }
 340         csvStream.flush();
 341         csvFile.flush();
 342         csvFile.close();
 343     }
 344 }
 345
 346 void FlightLogManager::exportToXML(QString fileName)
 347 {
 348     QFile xmlFile(fileName);
 349
 350     if (xmlFile.open(QFile::WriteOnly | QFile::Truncate)) {
 351         QXmlStreamWriter xmlWriter(&xmlFile);
 352         xmlWriter.setAutoFormatting(true);
 353         xmlWriter.setAutoFormattingIndent(4);
 354
 355         xmlWriter.writeStartDocument("1.0", true);
 356         xmlWriter.writeStartElement("logs");
 357         xmlWriter.writeComment("This file was created by the flight log export in OpenPilot GCS.");
 358
 359         quint32 baseTime = 0;
 360         quint32 currentFlight = 0;
 361         foreach(ExtendedDebugLogEntry * entry, m_logEntries) {
 362             if (m_adjustExportedTimestamps && entry->getFlight() != currentFlight) {
 363                 currentFlight = entry->getFlight();
 364                 baseTime = entry->getFlightTime();
 365             }
 366             entry->toXML(&xmlWriter, baseTime);
 367         }
 368         xmlWriter.writeEndElement();
 369         xmlWriter.writeEndDocument();
 370         xmlFile.flush();
 371         xmlFile.close();
 372     }
 373 }
 374
 375 void FlightLogManager::exportLogs()
 376 {
 377     if (m_logEntries.isEmpty()) {
 378         return;
 379     }
 380
 381     setDisableControls(true);
 382     QApplication::setOverrideCursor(Qt::WaitCursor);
 383
 384     QString oplFilter = tr("OpenPilot Log file %1").arg("(*.opl)");
 385     QString csvFilter = tr("Text file %1").arg("(*.csv)");
 386     QString xmlFilter = tr("XML file %1").arg("(*.xml)");
 387
 388     QString selectedFilter = csvFilter;
 389
 390     QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save Log Entries"), QDir::homePath(),
 391                                                     QString("%1;;%2;;%3").arg(oplFilter, csvFilter, xmlFilter), &selectedFilter);
 392     if (!fileName.isEmpty()) {
 393         if (selectedFilter == oplFilter) {
 394             if (!fileName.endsWith(".opl")) {
 395                 fileName.append(".opl");
 396             }
 397             exportToOPL(fileName);
 398         } else if (selectedFilter == csvFilter) {
 399             if (!fileName.endsWith(".csv")) {
 400                 fileName.append(".csv");
 401             }
 402             exportToCSV(fileName);
 403         } else if (selectedFilter == xmlFilter) {
 404             if (!fileName.endsWith(".xml")) {
 405                 fileName.append(".xml");
 406             }
 407             exportToXML(fileName);
 408         }
 409     }
 410
 411     QApplication::restoreOverrideCursor();
 412     setDisableControls(false);
 413 }
 414
 415 void FlightLogManager::cancelExportLogs()
 416 {
 417     m_cancelDownload = true;
 418 }
 419
 420 void FlightLogManager::loadSettings()
 421 {
 422     QString xmlFilter = tr("XML file %1").arg("(*.xml)");
 423     QString fileName  = QFileDialog::getOpenFileName(NULL, tr("Load Log Settings"), QDir::homePath(), QString("%1").arg(xmlFilter));
 424
 425     if (!fileName.isEmpty()) {
 426         if (!fileName.endsWith(".xml")) {
 427             fileName.append(".xml");
 428         }
 429         QFile xmlFile(fileName);
 430         QString errorString;
 431         if (xmlFile.open(QFile::ReadOnly)) {
 432             QXmlStreamReader xmlReader(&xmlFile);
 433             while (xmlReader.readNextStartElement() && xmlReader.name() == "settings") {
 434                 bool ok;
 435
 436                 int version = xmlReader.attributes().value("version").toInt(&ok);
 437                 if (!ok || version != LOG_SETTINGS_FILE_VERSION) {
 438                     errorString = tr("The file has the wrong version or could not parse version information.");
 439                     break;
 440                 }
 441
 442                 setLoggingEnabled(xmlReader.attributes().value("enabled").toInt(&ok));
 443                 if (!ok) {
 444                     errorString = tr("Could not parse enabled attribute.");
 445                     break;
 446                 }
 447
 448                 while (xmlReader.readNextStartElement()) {
 449                     if (xmlReader.name() == "setting") {
 450                         QString name = xmlReader.attributes().value("name").toString();
 451                         int level    = xmlReader.attributes().value("level").toInt(&ok);
 452                         if (ok) {
 453                             int period = xmlReader.attributes().value("period").toInt(&ok);
 454                             if (ok && updateLogWrapper(name, level, period)) {} else {
 455                                 errorString = tr("Could not parse period attribute, or object with name '%1' could not be found.").arg(name);
 456                                 break;
 457                             }
 458                         } else {
 459                             errorString = tr("Could not parse level attribute on setting '%1'").arg(name);
 460                             break;
 461                         }
 462                     }
 463                     xmlReader.skipCurrentElement();
 464                 }
 465                 xmlReader.skipCurrentElement();
 466             }
 467             if (!xmlReader.atEnd() && (xmlReader.hasError() || !errorString.isEmpty())) {
 468                 QMessageBox::warning(NULL, tr("Settings file corrupt."),
 469                                      tr("The file loaded is not in the correct format.\nPlease check the file.\n%1")
 470                                      .arg(xmlReader.hasError() ? xmlReader.errorString() : errorString),
 471                                      QMessageBox::Ok);
 472             }
 473         }
 474         xmlFile.close();
 475     }
 476 }
 477
 478 void FlightLogManager::saveSettings()
 479 {
 480     QString xmlFilter = tr("XML file %1").arg("(*.xml)");
 481     QString fileName  = QFileDialog::getSaveFileName(NULL, tr("Save Log Settings"),
 482                                                      QDir::homePath(), QString("%1").arg(xmlFilter));
 483
 484     if (!fileName.isEmpty()) {
 485         if (!fileName.endsWith(".xml")) {
 486             fileName.append(".xml");
 487         }
 488         QFile xmlFile(fileName);
 489
 490         if (xmlFile.open(QFile::WriteOnly | QFile::Truncate)) {
 491             QXmlStreamWriter xmlWriter(&xmlFile);
 492             xmlWriter.setAutoFormatting(true);
 493             xmlWriter.setAutoFormattingIndent(4);
 494
 495             xmlWriter.writeStartDocument("1.0", true);
 496             xmlWriter.writeComment("This file was created by the flight log settings function in OpenPilot GCS.");
 497             xmlWriter.writeStartElement("settings");
 498             xmlWriter.writeAttribute("version", QString::number(LOG_SETTINGS_FILE_VERSION));
 499             xmlWriter.writeAttribute("enabled", QString::number(m_loggingEnabled));
 500             foreach(UAVOLogSettingsWrapper * wrapper, m_uavoEntries) {
 501                 xmlWriter.writeStartElement("setting");
 502                 xmlWriter.writeAttribute("name", wrapper->name());
 503                 xmlWriter.writeAttribute("level", QString::number(wrapper->setting()));
 504                 xmlWriter.writeAttribute("period", QString::number(wrapper->period()));
 505                 xmlWriter.writeEndElement();
 506             }
 507             xmlWriter.writeEndElement();
 508             xmlWriter.writeEndDocument();
 509             xmlFile.flush();
 510             xmlFile.close();
 511         }
 512     }
 513 }
 514
 515 void FlightLogManager::resetSettings(bool clear)
 516 {
 517     setLoggingEnabled(clear ? 0 : m_flightLogSettings->getLoggingEnabled());
 518     foreach(UAVOLogSettingsWrapper * wrapper, m_uavoEntries) {
 519         wrapper->reset(clear);
 520     }
 521 }
 522
 523 void FlightLogManager::saveSettingsToBoard()
 524 {
 525     m_flightLogSettings->setLoggingEnabled(m_loggingEnabled);
 526     m_flightLogSettings->updated();
 527     saveUAVObjectToFlash(m_flightLogSettings);
 528
 529     foreach(UAVOLogSettingsWrapper * wrapper, m_uavoEntries) {
 530         if (wrapper->dirty()) {
 531             UAVObject::Metadata meta = wrapper->object()->getMetadata();
 532             wrapper->object()->SetLoggingUpdateMode(meta, wrapper->settingAsUpdateMode());
 533             meta.loggingUpdatePeriod = wrapper->period();
 534
 535             // As metadata are set up to update via telemetry on change
 536             // this call will send the update to the board.
 537             wrapper->object()->setMetadata(meta);
 538
 539             if (saveUAVObjectToFlash(wrapper->object()->getMetaObject())) {
 540                 wrapper->setDirty(false);
 541             }
 542         }
 543     }
 544 }
 545
 546 bool FlightLogManager::saveUAVObjectToFlash(UAVObject *object)
 547 {
 548     m_objectUtilManager->saveObjectToSD(object);
 549     return true;
 550 }
 551
 552 void FlightLogManager::updateFlightEntries(quint16 currentFlight)
 553 {
 554     Q_UNUSED(currentFlight);
 555
 556     int flights = m_flightLogStatus->getFlight();
 557     if (m_flightEntries.count() == 0 || (m_flightEntries.count() - 1 != flights)) {
 558         m_flightEntries.clear();
 559
 560         m_flightEntries << tr("All");
 561         for (int i = 0; i <= flights; i++) {
 562             m_flightEntries << QString::number(i + 1);
 563         }
 564
 565         emit flightEntriesChanged();
 566     }
 567 }
 568
 569 void FlightLogManager::setupUAVOWrappers()
 570 {
 571     foreach(QList<UAVObject *> objectList, m_objectManager->getObjects()) {
 572         UAVObject *object = objectList.at(0);
 573
 574         if (!object->isMetaDataObject() && !object->isSettingsObject()) {
 575             UAVOLogSettingsWrapper *wrapper = new UAVOLogSettingsWrapper(qobject_cast<UAVDataObject *>(object));
 576             m_uavoEntries.append(wrapper);
 577             m_uavoEntriesHash[wrapper->name()] = wrapper;
 578         }
 579     }
 580     emit uavoEntriesChanged();
 581 }
 582
 583 void FlightLogManager::setupLogSettings()
 584 {
 585     // Corresponds to:
 586     // typedef enum {
 587     // UPDATEMODE_MANUAL    = 0,  /** Manually update object, by calling the updated() function */
 588     // UPDATEMODE_PERIODIC  = 1, /** Automatically update object at periodic intervals */
 589     // UPDATEMODE_ONCHANGE  = 2, /** Only update object when its data changes */
 590     // UPDATEMODE_THROTTLED = 3 /** Object is updated on change, but not more often than the interval time */
 591     // } UpdateMode;
 592
 593     m_logSettings << tr("Disabled") << tr("Periodically") << tr("When updated") << tr("Throttled");
 594 }
 595
 596 void FlightLogManager::setupLogStatuses()
 597 {
 598     m_logStatuses << tr("Never") << tr("Only when Armed") << tr("Always");
 599 }
 600
 601 void FlightLogManager::connectionStatusChanged()
 602 {
 603     if (m_telemtryManager->isConnected()) {
 604         ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
 605         UAVObjectUtilManager *utilMngr     = pm->getObject<UAVObjectUtilManager>();
 606         setBoardConnected(utilMngr->getBoardModel() == 0x0903);
 607     } else {
 608         setBoardConnected(false);
 609     }
 610     if (boardConnected()) {
 611         resetSettings(false);
 612     }
 613 }
 614
 615 bool FlightLogManager::updateLogWrapper(QString name, int level, int period)
 616 {
 617     UAVOLogSettingsWrapper *wrapper = m_uavoEntriesHash[name];
 618
 619     if (wrapper) {
 620         wrapper->setSetting(level);
 621         wrapper->setPeriod(period);
 622         qDebug() << "Wrapper" << name << ", level" << level << ", period" << period;
 623         return true;
 624     }
 625     return false;
 626 }
 627
 628 ExtendedDebugLogEntry::ExtendedDebugLogEntry() : DebugLogEntry(),
 629     m_object(0)
 630 {}
 631
 632 ExtendedDebugLogEntry::~ExtendedDebugLogEntry()
 633 {
 634     if (m_object) {
 635         delete m_object;
 636         m_object = 0;
 637     }
 638 }
 639
 640 QString ExtendedDebugLogEntry::getLogString()
 641 {
 642     if (getType() == DebugLogEntry::TYPE_TEXT) {
 643         return QString((const char *)getData().Data);
 644     } else if (getType() == DebugLogEntry::TYPE_UAVOBJECT || getType() == DebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 645         return m_object->toString().replace("\n", " ").replace("\t", " ");
 646     } else {
 647         return "";
 648     }
 649 }
 650
 651 void ExtendedDebugLogEntry::toXML(QXmlStreamWriter *xmlWriter, quint32 baseTime)
 652 {
 653     xmlWriter->writeStartElement("entry");
 654     xmlWriter->writeAttribute("flight", QString::number(getFlight() + 1));
 655     xmlWriter->writeAttribute("flighttime", QString::number(getFlightTime() - baseTime));
 656     xmlWriter->writeAttribute("entry", QString::number(getEntry()));
 657     if (getType() == DebugLogEntry::TYPE_TEXT) {
 658         xmlWriter->writeAttribute("type", "text");
 659         xmlWriter->writeTextElement("message", QString((const char *)getData().Data));
 660     } else if (getType() == DebugLogEntry::TYPE_UAVOBJECT || getType() == DebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 661         xmlWriter->writeAttribute("type", "uavobject");
 662         m_object->toXML(xmlWriter);
 663     }
 664     xmlWriter->writeEndElement(); // entry
 665 }
 666
 667 void ExtendedDebugLogEntry::toCSV(QTextStream *csvStream, quint32 baseTime)
 668 {
 669     QString data;
 670
 671     if (getType() == DebugLogEntry::TYPE_TEXT) {
 672         data = QString((const char *)getData().Data);
 673     } else if (getType() == DebugLogEntry::TYPE_UAVOBJECT || getType() == DebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 674         data = m_object->toString().replace("\n", "").replace("\t", "");
 675     }
 676     *csvStream << QString::number(getFlight() + 1) << '\t' << QString::number(getFlightTime() - baseTime) << '\t' << QString::number(getEntry()) << '\t' << data << '\n';
 677 }
 678
 679 void ExtendedDebugLogEntry::setData(const DebugLogEntry::DataFields &data, UAVObjectManager *objectManager)
 680 {
 681     DebugLogEntry::setData(data);
 682
 683     if (getType() == DebugLogEntry::TYPE_UAVOBJECT || getType() == DebugLogEntry::TYPE_MULTIPLEUAVOBJECTS) {
 684         UAVDataObject *object = (UAVDataObject *)objectManager->getObject(getObjectID(), getInstanceID());
 685         Q_ASSERT(object);
 686         m_object = object->clone(getInstanceID());
 687         m_object->unpack(getData().Data);
 688     }
 689 }
 690
 691
 692 UAVOLogSettingsWrapper::UAVOLogSettingsWrapper() : QObject()
 693 {}
 694
 695 UAVOLogSettingsWrapper::UAVOLogSettingsWrapper(UAVDataObject *object) : QObject(),
 696     m_object(object), m_setting(DISABLED), m_period(0), m_dirty(0)
 697 {
 698     reset(false);
 699 }
 700
 701 UAVOLogSettingsWrapper::~UAVOLogSettingsWrapper()
 702 {}
 703
 704 void UAVOLogSettingsWrapper::reset(bool clear)
 705 {
 706     setSetting(m_object->GetLoggingUpdateMode(m_object->getMetadata()));
 707     setPeriod(m_object->getMetadata().loggingUpdatePeriod);
 708     if (clear) {
 709         int oldSetting = setting();
 710         int oldPeriod  = period();
 711         setSetting(0);
 712         setPeriod(0);
 713         setDirty(oldSetting != setting() || oldPeriod != period());
 714     } else {
 715         setDirty(false);
 716     }
 717 }
 718
 719 UAVObject::UpdateMode UAVOLogSettingsWrapper::settingAsUpdateMode()
 720 {
 721     switch (m_setting) {
 722     case 0:
 723         return UAVObject::UPDATEMODE_MANUAL;
 724
 725     case 1:
 726         return UAVObject::UPDATEMODE_PERIODIC;
 727
 728     case 2:
 729         return UAVObject::UPDATEMODE_ONCHANGE;
 730
 731     case 3:
 732         return UAVObject::UPDATEMODE_THROTTLED;
 733
 734     default:
 735         return UAVObject::UPDATEMODE_MANUAL;
 736     }
 737 }