DebugConsole.cc 27.5 KB
Newer Older
pixhawk's avatar
pixhawk committed
1 2
/*=====================================================================

lm's avatar
lm committed
3
QGroundControl Open Source Ground Control Station
pixhawk's avatar
pixhawk committed
4

lm's avatar
lm committed
5
(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
pixhawk's avatar
pixhawk committed
6

lm's avatar
lm committed
7
This file is part of the QGROUNDCONTROL project
pixhawk's avatar
pixhawk committed
8

lm's avatar
lm committed
9
    QGROUNDCONTROL is free software: you can redistribute it and/or modify
pixhawk's avatar
pixhawk committed
10 11 12 13
    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.

lm's avatar
lm committed
14
    QGROUNDCONTROL is distributed in the hope that it will be useful,
pixhawk's avatar
pixhawk committed
15 16 17 18 19
    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
lm's avatar
lm committed
20
    along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
pixhawk's avatar
pixhawk committed
21 22 23 24 25

======================================================================*/

/**
 * @file
lm's avatar
lm committed
26
 *   @brief Implementation of DebugConsole
pixhawk's avatar
pixhawk committed
27 28 29 30 31
 *
 *   @author Lorenz Meier <mavteam@student.ethz.ch>
 *
 */
#include <QPainter>
lm's avatar
lm committed
32
#include <QSettings>
pixhawk's avatar
pixhawk committed
33 34 35 36

#include "DebugConsole.h"
#include "ui_DebugConsole.h"
#include "LinkManager.h"
37
#include "UASManager.h"
pixhawk's avatar
pixhawk committed
38
#include "protocol.h"
39
#include "QGC.h"
pixhawk's avatar
pixhawk committed
40 41 42 43

#include <QDebug>

DebugConsole::DebugConsole(QWidget *parent) :
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
    QWidget(parent),
    currLink(NULL),
    holdOn(false),
    convertToAscii(true),
    filterMAVLINK(false),
    autoHold(true),
    bytesToIgnore(0),
    lastByte(-1),
    sentBytes(),
    holdBuffer(),
    lineBuffer(""),
    lineBufferTimer(),
    snapShotTimer(),
    snapShotInterval(500),
    snapShotBytes(0),
    dataRate(0.0f),
    lowpassDataRate(0.0f),
61
    dataRateThreshold(400),
62 63
    commandIndex(0),
    m_ui(new Ui::DebugConsole)
pixhawk's avatar
pixhawk committed
64 65 66
{
    // Setup basic user interface
    m_ui->setupUi(this);
pixhawk's avatar
pixhawk committed
67 68
    // Hide sent text field - it is only useful after send has been hit
    m_ui->sentText->setVisible(false);
69
    // Hide auto-send checkbox
70
    //m_ui->specialCheckBox->setVisible(false);
pixhawk's avatar
pixhawk committed
71
    // Make text area not editable
lm's avatar
lm committed
72
    m_ui->receiveText->setReadOnly(false);
pixhawk's avatar
pixhawk committed
73 74 75 76 77 78 79 80 81 82
    // Limit to 500 lines
    m_ui->receiveText->setMaximumBlockCount(500);
    // Allow to wrap everywhere
    m_ui->receiveText->setWordWrapMode(QTextOption::WrapAnywhere);

    // Enable 10 Hz output
    //connect(&lineBufferTimer, SIGNAL(timeout()), this, SLOT(showData()));
    //lineBufferTimer.setInterval(100); // 100 Hz
    //lineBufferTimer.start();

83 84
    loadSettings();

pixhawk's avatar
pixhawk committed
85 86 87 88
    // Enable traffic measurements
    connect(&snapShotTimer, SIGNAL(timeout()), this, SLOT(updateTrafficMeasurements()));
    snapShotTimer.setInterval(snapShotInterval);
    snapShotTimer.start();
89 90
    // Update measurements the first time
    updateTrafficMeasurements();
pixhawk's avatar
pixhawk committed
91 92 93

    // Get a list of all existing links
    links = QList<LinkInterface*>();
94
    foreach (LinkInterface* link, LinkManager::instance()->getLinks()) {
pixhawk's avatar
pixhawk committed
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
        addLink(link);
    }

    // Connect to link manager to get notified about new links
    connect(LinkManager::instance(), SIGNAL(newLink(LinkInterface*)), this, SLOT(addLink(LinkInterface*)));
    // Connect link combo box
    connect(m_ui->linkComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(linkSelected(int)));
    // Connect send button
    connect(m_ui->transmitButton, SIGNAL(clicked()), this, SLOT(sendBytes()));
    // Connect HEX conversion and MAVLINK filter checkboxes
    connect(m_ui->mavlinkCheckBox, SIGNAL(clicked(bool)), this, SLOT(MAVLINKfilterEnabled(bool)));
    connect(m_ui->hexCheckBox, SIGNAL(clicked(bool)), this, SLOT(hexModeEnabled(bool)));
    connect(m_ui->holdCheckBox, SIGNAL(clicked(bool)), this, SLOT(setAutoHold(bool)));
    // Connect hold button
    connect(m_ui->holdButton, SIGNAL(toggled(bool)), this, SLOT(hold(bool)));
110 111
    // Connect connect button
    connect(m_ui->connectButton, SIGNAL(clicked()), this, SLOT(handleConnectButton()));
112
    // Connect the special chars combo box
113
    connect(m_ui->addSymbolButton, SIGNAL(clicked()), this, SLOT(appendSpecialSymbol()));
114 115
    // Connect Checkbox
    connect(m_ui->specialComboBox, SIGNAL(highlighted(QString)), this, SLOT(specialSymbolSelected(QString)));
116 117
    // Allow to send via return
    connect(m_ui->sendText, SIGNAL(returnPressed()), this, SLOT(sendBytes()));
pixhawk's avatar
pixhawk committed
118 119
}

120 121 122 123 124 125
void DebugConsole::hideEvent(QHideEvent* event)
{
    Q_UNUSED(event);
    storeSettings();
}

pixhawk's avatar
pixhawk committed
126 127
DebugConsole::~DebugConsole()
{
lm's avatar
lm committed
128
    storeSettings();
pixhawk's avatar
pixhawk committed
129 130 131
    delete m_ui;
}

lm's avatar
lm committed
132 133 134 135 136 137 138 139 140
void DebugConsole::loadSettings()
{
    // Load defaults from settings
    QSettings settings;
    settings.sync();
    settings.beginGroup("QGC_DEBUG_CONSOLE");
    m_ui->specialComboBox->setCurrentIndex(settings.value("SPECIAL_SYMBOL", m_ui->specialComboBox->currentIndex()).toInt());
    m_ui->specialCheckBox->setChecked(settings.value("SPECIAL_SYMBOL_CHECKBOX_STATE", m_ui->specialCheckBox->isChecked()).toBool());
    hexModeEnabled(settings.value("HEX_MODE_ENABLED", m_ui->hexCheckBox->isChecked()).toBool());
141 142
    MAVLINKfilterEnabled(settings.value("MAVLINK_FILTER_ENABLED", filterMAVLINK).toBool());
    setAutoHold(settings.value("AUTO_HOLD_ENABLED", autoHold).toBool());
lm's avatar
lm committed
143 144
    settings.endGroup();

145 146 147 148 149 150
//    // Update visibility settings
//    if (m_ui->specialCheckBox->isChecked())
//    {
//        m_ui->specialCheckBox->setVisible(true);
//        m_ui->addSymbolButton->setVisible(false);
//    }
lm's avatar
lm committed
151 152 153 154 155 156 157 158 159 160
}

void DebugConsole::storeSettings()
{
    // Store settings
    QSettings settings;
    settings.beginGroup("QGC_DEBUG_CONSOLE");
    settings.setValue("SPECIAL_SYMBOL", m_ui->specialComboBox->currentIndex());
    settings.setValue("SPECIAL_SYMBOL_CHECKBOX_STATE", m_ui->specialCheckBox->isChecked());
    settings.setValue("HEX_MODE_ENABLED", m_ui->hexCheckBox->isChecked());
161 162
    settings.setValue("MAVLINK_FILTER_ENABLED", filterMAVLINK);
    settings.setValue("AUTO_HOLD_ENABLED", autoHold);
lm's avatar
lm committed
163 164 165 166 167
    settings.endGroup();
    settings.sync();
    //qDebug() << "Storing settings!";
}

pixhawk's avatar
pixhawk committed
168 169 170
/**
 * Add a link to the debug console output
 */
pixhawk's avatar
pixhawk committed
171 172 173 174
void DebugConsole::addLink(LinkInterface* link)
{
    // Add link to link list
    links.insert(link->getId(), link);
pixhawk's avatar
pixhawk committed
175

pixhawk's avatar
pixhawk committed
176 177 178
    m_ui->linkComboBox->insertItem(link->getId(), link->getName());
    // Set new item as current
    m_ui->linkComboBox->setCurrentIndex(qMax(0, links.size() - 1));
179
    linkSelected(m_ui->linkComboBox->currentIndex());
pixhawk's avatar
pixhawk committed
180 181 182

    // Register for name changes
    connect(link, SIGNAL(nameChanged(QString)), this, SLOT(updateLinkName(QString)));
183
    connect(link, SIGNAL(deleteLink(LinkInterface* const)), this, SLOT(removeLink(LinkInterface* const)));
184 185
}

186
void DebugConsole::removeLink(LinkInterface* const linkInterface)
187
{
188
    //LinkInterface* linkInterface = dynamic_cast<LinkInterface*>(link);
189
    // Add link to link list
190
    if (links.contains(linkInterface)) {
191 192 193 194 195 196
        int linkIndex = links.indexOf(linkInterface);

        links.removeAt(linkIndex);

        m_ui->linkComboBox->removeItem(linkIndex);
    }
197
    if (linkInterface == currLink) currLink = NULL;
pixhawk's avatar
pixhawk committed
198 199 200 201 202
}

void DebugConsole::linkSelected(int linkId)
{
    // Disconnect
203
    if (currLink) {
pixhawk's avatar
pixhawk committed
204
        disconnect(currLink, SIGNAL(bytesReceived(LinkInterface*,QByteArray)), this, SLOT(receiveBytes(LinkInterface*, QByteArray)));
205
        disconnect(currLink, SIGNAL(connected(bool)), this, SLOT(setConnectionState(bool)));
pixhawk's avatar
pixhawk committed
206 207 208 209 210 211 212
    }
    // Clear data
    m_ui->receiveText->clear();

    // Connect new link
    currLink = links[linkId];
    connect(currLink, SIGNAL(bytesReceived(LinkInterface*,QByteArray)), this, SLOT(receiveBytes(LinkInterface*, QByteArray)));
213 214
    connect(currLink, SIGNAL(connected(bool)), this, SLOT(setConnectionState(bool)));
    setConnectionState(currLink->isConnected());
pixhawk's avatar
pixhawk committed
215 216 217 218 219 220 221
}

/**
 * @param name new name for this link - the link is determined to the sender to this slot by QObject::sender()
 */
void DebugConsole::updateLinkName(QString name)
{
222
	// Set name if signal came from a link
pixhawk's avatar
pixhawk committed
223
    LinkInterface* link = qobject_cast<LinkInterface*>(sender());
224 225 226 227 228 229
	//if (link != NULL) m_ui->linkComboBox->setItemText(link->getId(), name);
	if((link != NULL) && (links.contains(link)))
	{
		const qint16 &linkIndex(links.indexOf(link));
		m_ui->linkComboBox->setItemText(linkIndex,name);
	}
pixhawk's avatar
pixhawk committed
230 231 232 233 234
}

void DebugConsole::setAutoHold(bool hold)
{
    // Disable current hold if hold had been enabled
235
    if (autoHold && holdOn && !hold) {
pixhawk's avatar
pixhawk committed
236 237 238
        this->hold(false);
        m_ui->holdButton->setChecked(false);
    }
239
    // Set auto hold checkbox
240
    if (m_ui->holdCheckBox->isChecked() != hold) {
241 242
        m_ui->holdCheckBox->setChecked(hold);
    }
243 244 245 246 247 248 249 250 251 252 253

    if (!hold)
    {
        // Warn user about not activated hold
        m_ui->receiveText->appendHtml(QString("<font color=\"%1\">%2</font>\n").arg(QColor(Qt::red).name(), tr("WARNING: You have NOT enabled auto-hold (stops updating the console if huge amounts of serial data arrive). Updating the console consumes significant CPU load, so if you receive more than about 5 KB/s of serial data, make sure to enable auto-hold if not using the console.")));
    }
    else
    {
        m_ui->receiveText->clear();
    }

pixhawk's avatar
pixhawk committed
254 255 256 257
    // Set new state
    autoHold = hold;
}

258 259 260 261
/**
 * Prints the message in the UAS color
 */
void DebugConsole::receiveTextMessage(int id, int component, int severity, QString text)
262
{
263
    Q_UNUSED(severity);
264 265 266 267 268 269 270 271 272 273 274 275 276
    if (isVisible())
    {
        QString name = UASManager::instance()->getUASForId(id)->getUASName();
        QString comp;
        // Get a human readable name if possible
        switch (component) {
            // TODO: To be completed
        case MAV_COMP_ID_IMU:
            comp = tr("IMU");
            break;
        case MAV_COMP_ID_MAPPER:
            comp = tr("MAPPER");
            break;
lm's avatar
lm committed
277 278
        case MAV_COMP_ID_MISSIONPLANNER:
            comp = tr("MISSION");
279 280 281 282 283 284 285 286
            break;
        case MAV_COMP_ID_SYSTEM_CONTROL:
            comp = tr("SYS-CONTROL");
            break;
        default:
            comp = QString::number(component);
            break;
        }
pixhawk's avatar
pixhawk committed
287

288
        m_ui->receiveText->appendHtml(QString("<font color=\"%1\">(%2:%3) %4</font>\n").arg(UASManager::instance()->getUASForId(id)->getColor().name(), name, comp, text));
289 290
        // Ensure text area scrolls correctly
        m_ui->receiveText->ensureCursorVisible();
291
    }
292 293
}

pixhawk's avatar
pixhawk committed
294 295 296 297 298 299 300
void DebugConsole::updateTrafficMeasurements()
{
    lowpassDataRate = lowpassDataRate * 0.9f + (0.1f * ((float)snapShotBytes / (float)snapShotInterval) * 1000.0f);
    dataRate = ((float)snapShotBytes / (float)snapShotInterval) * 1000.0f;
    snapShotBytes = 0;

    // Check if limit has been exceeded
301
    if ((lowpassDataRate > dataRateThreshold) && autoHold) {
pixhawk's avatar
pixhawk committed
302 303 304 305 306 307 308 309 310
        // Enable auto-old
        m_ui->holdButton->setChecked(true);
        hold(true);
    }

    QString speed;
    speed = speed.sprintf("%04.1f kB/s", dataRate/1000.0f);
    m_ui->speedLabel->setText(speed);

311
    if (holdOn) {
pixhawk's avatar
pixhawk committed
312 313 314 315 316 317 318 319 320 321
        //repaint();
    }
}

//QPainter painter(m_ui->receiveText);
//painter.setRenderHint(QPainter::HighQualityAntialiasing);
//painter.translate((this->vwidth/2.0+xCenterOffset)*scalingFactor, (this->vheight/2.0+yCenterOffset)*scalingFactor);

void DebugConsole::paintEvent(QPaintEvent *event)
{
322
    Q_UNUSED(event);
pixhawk's avatar
pixhawk committed
323
    // Update bandwidth
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
//    if (holdOn)
//    {
//        //qDebug() << "Data rate:" << dataRate/1000.0f << "kB/s";
//        QString rate("data rate: %1");
//        rate.arg(dataRate);
//        QPainter painter(this);
//        painter.setRenderHint(QPainter::HighQualityAntialiasing);
//        painter.translate(width()/5.0f, height()/5.0f);



//        //QFont font("Bitstream Vera Sans");
//        QFont font = painter.font();
//        font.setPixelSize((int)(60.0f));

//        QFontMetrics metrics = QFontMetrics(font);
//        int border = qMax(4, metrics.leading());
//        QRect rect = metrics.boundingRect(0, 0, width() - 2*border, int(height()*0.125),
//                                          Qt::AlignLeft | Qt::TextWordWrap, rate);
//        painter.setPen(QColor(255, 50, 50));
//        painter.setRenderHint(QPainter::TextAntialiasing);
//        painter.drawText(QRect(QPoint(static_cast<int>(width()/5.0f), static_cast<int>(height()/5.0f)), QPoint(static_cast<int>(width() - width()/5.0f), static_cast<int>(height() - height()/5.0f))), rate);
//        //Qt::AlignRight | Qt::TextWordWrap
//    }
pixhawk's avatar
pixhawk committed
348 349 350 351 352
}

void DebugConsole::receiveBytes(LinkInterface* link, QByteArray bytes)
{
    snapShotBytes += bytes.size();
lm's avatar
lm committed
353 354 355
    int len = bytes.size();
    int lastSpace = 0;
    if ((this->bytesToIgnore > 260) || (this->bytesToIgnore < -2)) this->bytesToIgnore = 0;
356
    // Only add data from current link
lm's avatar
lm committed
357 358
    if (link == currLink && !holdOn)
    {
pixhawk's avatar
pixhawk committed
359
        // Parse all bytes
lm's avatar
lm committed
360 361
        for (int j = 0; j < len; j++)
        {
pixhawk's avatar
pixhawk committed
362
            unsigned char byte = bytes.at(j);
lm's avatar
lm committed
363
            // Filter MAVLink (http://qgroundcontrol.org/mavlink/) messages out of the stream.
lm's avatar
lm committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
            if (filterMAVLINK)
            {
                if (this->bytesToIgnore > 0)
                {
                    if ( (j + this->bytesToIgnore) < len )
                        j += this->bytesToIgnore - 1, this->bytesToIgnore = 1;
                    else
                        this->bytesToIgnore -= (len - j - 1), j = len - 1;
                } else
                if (this->bytesToIgnore == -2)
                {   // Payload plus header - but we got STX already
                    this->bytesToIgnore = static_cast<unsigned int>(byte) + MAVLINK_NUM_NON_PAYLOAD_BYTES - 1;
                    if ( (j + this->bytesToIgnore) < len )
                        j += this->bytesToIgnore - 1, this->bytesToIgnore = 1;
                    else
                        this->bytesToIgnore -= (len - j - 1), j = len - 1;
                } else
pixhawk's avatar
pixhawk committed
381
                // Filtering is done by setting an ignore counter based on the MAVLINK packet length
lm's avatar
lm committed
382 383 384 385 386 387 388 389 390
                if (static_cast<unsigned char>(byte) == MAVLINK_STX)
                {
                    this->bytesToIgnore = -1;
                } else
                    this->bytesToIgnore = 0;
            } else this->bytesToIgnore = 0;

            if ( (this->bytesToIgnore <= 0) && (this->bytesToIgnore != -1) )
            {
pixhawk's avatar
pixhawk committed
391 392
                QString str;
                // Convert to ASCII for readability
lm's avatar
lm committed
393 394 395 396 397 398 399 400 401
                if (convertToAscii)
                {
                    if ((byte <= 32) || (byte > 126))
                    {
                        switch (byte)
                        {
                            case (unsigned char)'\n':   // Accept line feed
                                if (lastByte != '\r')   // Do not break line again for CR+LF
                                    str.append(byte);   // only break line for single LF or CR bytes
402
                            break;
lm's avatar
lm committed
403 404 405 406 407
                            case (unsigned char)' ':    // space of any type means don't add another on hex output
                            case (unsigned char)'\t':   // Accept tab
                            case (unsigned char)'\r':   // Catch and carriage return
                                str.append(byte);
                                lastSpace = 1;
pixhawk's avatar
pixhawk committed
408
                            break;
lm's avatar
lm committed
409 410 411 412 413 414 415 416
                            default:                    // Append replacement character (box) if char is not ASCII
//                                str.append(QChar(QChar::ReplacementCharacter));
                                QString str2;
                                if ( lastSpace == 1)
                                    str2.sprintf("0x%02x ", byte);
                                else str2.sprintf(" 0x%02x ", byte);
                                str.append(str2);
                                lastSpace = 1;
pixhawk's avatar
pixhawk committed
417
                            break;
lm's avatar
lm committed
418
                        }
pixhawk's avatar
pixhawk committed
419
                    }
lm's avatar
lm committed
420 421 422 423 424 425 426 427
                    else
                    {
                        str.append(byte);           // Append original character
                        lastSpace = 0;
                    }
                }
                else
                {
pixhawk's avatar
pixhawk committed
428 429 430 431 432
                    QString str2;
                    str2.sprintf("%02x ", byte);
                    str.append(str2);
                }
                lineBuffer.append(str);
433
                lastByte = byte;
lm's avatar
lm committed
434 435 436 437
            }
            else
            {
                if (filterMAVLINK) this->bytesToIgnore--;
pixhawk's avatar
pixhawk committed
438
                // Constrain bytes to positive range
lm's avatar
lm committed
439
//                bytesToIgnore = qMax(0, bytesToIgnore);
pixhawk's avatar
pixhawk committed
440 441 442
            }

        }
443
        if (lineBuffer.length() > 0) {
444 445 446 447 448 449
            if (isVisible())
            {
                m_ui->receiveText->insertPlainText(lineBuffer);
                // Ensure text area scrolls correctly
                m_ui->receiveText->ensureCursorVisible();
            }
450 451
            lineBuffer.clear();
        }
lm's avatar
lm committed
452 453 454
    }
    else if (link == currLink && holdOn)
    {
pixhawk's avatar
pixhawk committed
455
        holdBuffer.append(bytes);
lm's avatar
lm committed
456 457
        if (holdBuffer.size() > 8192)
            holdBuffer.remove(0, 4096); // drop old stuff
pixhawk's avatar
pixhawk committed
458 459 460
    }
}

461 462 463
QByteArray DebugConsole::symbolNameToBytes(const QString& text)
{
    QByteArray b;
464
    if (text.contains("CR+LF")) {
465
        b.append(static_cast<char>(0x0D));
466
        b.append(static_cast<char>(0x0A));
467
    } else if (text.contains("LF")) {
468
        b.append(static_cast<char>(0x0A));
469
    } else if (text.contains("FF")) {
470
        b.append(static_cast<char>(0x0C));
471
    } else if (text.contains("CR")) {
472
        b.append(static_cast<char>(0x0D));
473
    } else if (text.contains("TAB")) {
474
        b.append(static_cast<char>(0x09));
475
    } else if (text.contains("NUL")) {
476
        b.append(static_cast<char>(0x00));
477
    } else if (text.contains("ESC")) {
478
        b.append(static_cast<char>(0x1B));
479
    } else if (text.contains("~")) {
480
        b.append(static_cast<char>(0x7E));
481
    } else if (text.contains("<Space>")) {
482 483 484 485 486
        b.append(static_cast<char>(0x20));
    }
    return b;
}

487 488 489
QString DebugConsole::bytesToSymbolNames(const QByteArray& b)
{
    QString text;
490
    if (b.size() > 1 && b.contains(0x0D) && b.contains(0x0A)) {
491
        text = "<CR+LF>";
492
    } else if (b.contains(0x0A)) {
493
        text = "<LF>";
494
    } else if (b.contains(0x0C)) {
495
        text = "<FF>";
496
    } else if (b.contains(0x0D)) {
497
        text = "<CR>";
498
    } else if (b.contains(0x09)) {
499
        text = "<TAB>";
500
    } else if (b.contains((char)0x00)) {
501
        text == "<NUL>";
502
    } else if (b.contains(0x1B)) {
503
        text = "<ESC>";
504
    } else if (b.contains(0x7E)) {
505
        text = "<~>";
506
    } else if (b.contains(0x20)) {
507
        text = "<Space>";
508
    } else {
509 510 511 512 513
        text.append(b);
    }
    return text;
}

514 515 516
void DebugConsole::specialSymbolSelected(const QString& text)
{
    Q_UNUSED(text);
517
    //m_ui->specialCheckBox->setVisible(true);
518 519
}

520 521 522 523 524
void DebugConsole::appendSpecialSymbol(const QString& text)
{
    QString line = m_ui->sendText->text();
    QByteArray symbols = symbolNameToBytes(text);
    // The text is appended to the enter field
525
    if (convertToAscii) {
526
        line.append(symbols);
527
    } else {
528

529
        for (int i = 0; i < symbols.size(); i++) {
530 531 532 533 534 535 536
            QString add(" 0x%1");
            line.append(add.arg(static_cast<char>(symbols.at(i)), 2, 16, QChar('0')));
        }
    }
    m_ui->sendText->setText(line);
}

537 538 539 540 541
void DebugConsole::appendSpecialSymbol()
{
    appendSpecialSymbol(m_ui->specialComboBox->currentText());
}

pixhawk's avatar
pixhawk committed
542 543
void DebugConsole::sendBytes()
{
lm's avatar
lm committed
544 545 546 547 548 549
    // FIXME This store settings should be removed
    // once all threading issues have been resolved
    // since its called in the destructor, which
    // is absolutely sufficient
    storeSettings();

lm's avatar
lm committed
550 551 552 553 554 555
    // Store command history
    commandHistory.append(m_ui->sendText->text());
    // Since text was just sent, we're at position commandHistory.length()
    // which is the current text
    commandIndex = commandHistory.length();

556
    if (!m_ui->sentText->isVisible()) {
pixhawk's avatar
pixhawk committed
557 558 559
        m_ui->sentText->setVisible(true);
    }

560
    if (!currLink->isConnected()) {
561 562 563 564
        m_ui->sentText->setText(tr("Nothing sent. The link %1 is unconnected. Please connect first.").arg(currLink->getName()));
        return;
    }

565 566 567
    QString transmitUnconverted = m_ui->sendText->text();
    QByteArray specialSymbol;

568
    // Append special symbol if checkbox is checked
569
    if (m_ui->specialCheckBox->isChecked()) {
570 571 572 573
        // Get auto-add special symbols
        specialSymbol = symbolNameToBytes(m_ui->specialComboBox->currentText());

        // Convert them if needed
574
        if (!convertToAscii) {
575
            QString specialSymbolConverted;
576
            for (int i = 0; i < specialSymbol.length(); i++) {
577 578 579 580 581 582
                QString add(" 0x%1");
                specialSymbolConverted.append(add.arg(static_cast<char>(specialSymbol.at(i)), 2, 16, QChar('0')));
            }
            specialSymbol.clear();
            specialSymbol.append(specialSymbolConverted);
        }
583 584
    }

pixhawk's avatar
pixhawk committed
585 586 587
    QByteArray transmit;
    QString feedback;
    bool ok = true;
588
    if (convertToAscii) {
pixhawk's avatar
pixhawk committed
589
        // ASCII text is not converted
590 591 592 593 594 595 596
        transmit = transmitUnconverted.toLatin1();
        // Auto-add special symbol handling
        transmit.append(specialSymbol);

        QString translated;

        // Replace every occurence of a special symbol with its text name
597
        for (int i = 0; i < transmit.size(); ++i) {
598 599 600 601 602 603
            QByteArray specialChar;
            specialChar.append(transmit.at(i));
            translated.append(bytesToSymbolNames(specialChar));
        }

        feedback.append(translated);
604
    } else {
pixhawk's avatar
pixhawk committed
605
        // HEX symbols are converted to bytes
606 607
        QString str = transmitUnconverted.toLatin1();
        str.append(specialSymbol);
pixhawk's avatar
pixhawk committed
608 609 610 611
        str.remove(' ');
        str.remove("0x");
        str.simplified();
        int bufferIndex = 0;
612 613
        if ((str.size() % 2) == 0) {
            for (int i = 0; i < str.size(); i=i+2) {
pixhawk's avatar
pixhawk committed
614 615 616 617 618 619 620
                bool okByte;
                QString strBuf = QString(str.at(i));
                strBuf.append(str.at(i+1));
                unsigned char hex = strBuf.toInt(&okByte, 16);
                ok = (ok && okByte);
                transmit[bufferIndex++] = hex;

621
                if (okByte) {
pixhawk's avatar
pixhawk committed
622 623 624 625 626
                    // Feedback
                    //feedback.append("0x");
                    feedback.append(str.at(i).toUpper());
                    feedback.append(str.at(i+1).toUpper());
                    feedback.append(" ");
627
                } else {
pixhawk's avatar
pixhawk committed
628 629 630
                    feedback = tr("HEX format error near \"") + strBuf + "\"";
                }
            }
631
        } else {
pixhawk's avatar
pixhawk committed
632 633 634 635 636 637
            ok = false;
            feedback = tr("HEX values have to be in pairs, e.g. AA or AA 05");
        }
    }

    // Transmit ASCII or HEX formatted text, only if more than one symbol
638
    if (ok && m_ui->sendText->text().toLatin1().size() > 0) {
pixhawk's avatar
pixhawk committed
639
        // Transmit only if conversion succeeded
640 641 642 643 644 645 646 647 648 649
        //        int transmitted =
        currLink->writeBytes(transmit, transmit.size());
        //        if (transmit.size() == transmitted)
        //        {
        m_ui->sentText->setText(tr("Sent: ") + feedback);
        //        }
        //        else
        //        {
        //            m_ui->sentText->setText(tr("Error during sending: Transmitted only %1 bytes instead of %2.").arg(transmitted, transmit.size()));
        //        }
650
    } else if (m_ui->sendText->text().toLatin1().size() > 0) {
pixhawk's avatar
pixhawk committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664
        // Conversion failed, display error message
        m_ui->sentText->setText(tr("Not sent: ") + feedback);
    }

    // Select text to easy follow-up input from user
    m_ui->sendText->selectAll();
    m_ui->sendText->setFocus(Qt::OtherFocusReason);
}

/**
 * @param mode true to convert all in and output to/from HEX, false to send and receive ASCII values
 */
void DebugConsole::hexModeEnabled(bool mode)
{
665
    if (convertToAscii == mode) {
lm's avatar
lm committed
666
        convertToAscii = !mode;
667
        if (m_ui->hexCheckBox->isChecked() != mode) {
lm's avatar
lm committed
668 669 670 671 672 673 674
            m_ui->hexCheckBox->setChecked(mode);
        }
        m_ui->receiveText->clear();
        m_ui->sendText->clear();
        m_ui->sentText->clear();
        commandHistory.clear();
    }
pixhawk's avatar
pixhawk committed
675 676 677 678 679 680 681
}

/**
 * @param filter true to ignore all MAVLINK raw data in output, false, to display all incoming data
 */
void DebugConsole::MAVLINKfilterEnabled(bool filter)
{
682
    if (filterMAVLINK != filter) {
lm's avatar
lm committed
683
        filterMAVLINK = filter;
lm's avatar
lm committed
684
        this->bytesToIgnore = 0;
685
        if (m_ui->mavlinkCheckBox->isChecked() != filter) {
lm's avatar
lm committed
686 687 688
            m_ui->mavlinkCheckBox->setChecked(filter);
        }
    }
pixhawk's avatar
pixhawk committed
689 690 691 692 693 694
}
/**
 * @param hold Freeze the input and thus any scrolling
 */
void DebugConsole::hold(bool hold)
{
695 696 697 698 699 700 701 702
    if (holdOn != hold) {
        // Check if we need to append bytes from the hold buffer
        if (this->holdOn && !hold) {
            // TODO No conversion is done to the bytes in the hold buffer
            m_ui->receiveText->appendPlainText(QString(holdBuffer));
            holdBuffer.clear();
            lowpassDataRate = 0.0f;
        }
pixhawk's avatar
pixhawk committed
703

704
        this->holdOn = hold;
705

706 707 708 709 710 711 712 713 714
        // Change text interaction mode
        if (hold) {
            m_ui->receiveText->setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse | Qt::LinksAccessibleByKeyboard | Qt::LinksAccessibleByMouse);
        } else {
            m_ui->receiveText->setTextInteractionFlags(Qt::NoTextInteraction);
        }
        if (m_ui->holdCheckBox->isChecked() != hold) {
            m_ui->holdCheckBox->setChecked(hold);
        }
lm's avatar
lm committed
715 716
    }
}
pixhawk's avatar
pixhawk committed
717

718 719 720 721 722
/**
 * Sets the connection state the widget shows to this state
 */
void DebugConsole::setConnectionState(bool connected)
{
723
    if(connected) {
724
        m_ui->connectButton->setText(tr("Disconn."));
725
        m_ui->receiveText->appendHtml(QString("<font color=\"%1\">%2</font>\n").arg(QGC::colorGreen.name(), tr("Link %1 is connected.").arg(currLink->getName())));
726
    } else {
727
        m_ui->connectButton->setText(tr("Connect"));
728
        m_ui->receiveText->appendHtml(QString("<font color=\"%1\">%2</font>\n").arg(QGC::colorOrange.name(), tr("Link %1 is unconnected.").arg(currLink->getName())));
729 730 731 732 733 734
    }
}

/** @brief Handle the connect button */
void DebugConsole::handleConnectButton()
{
735 736
    if (currLink) {
        if (currLink->isConnected()) {
737
            currLink->disconnect();
738
        } else {
739
            currLink->connect();
740 741 742 743
        }
    }
}

744 745
void DebugConsole::keyPressEvent(QKeyEvent * event)
{
746
    if (event->key() == Qt::Key_Up) {
747
        cycleCommandHistory(true);
748
    } else if (event->key() == Qt::Key_Down) {
749
        cycleCommandHistory(false);
750
    } else {
751 752 753 754 755 756
        QWidget::keyPressEvent(event);
    }
}

void DebugConsole::cycleCommandHistory(bool up)
{
lm's avatar
lm committed
757
    // Only cycle if there is a history
758
    if (commandHistory.length() > 0) {
lm's avatar
lm committed
759
        // Store current command if we're not in history yet
760
        if (commandIndex == commandHistory.length() && up) {
lm's avatar
lm committed
761 762
            currCommand = m_ui->sendText->text();
        }
763

764
        if (up) {
lm's avatar
lm committed
765 766
            // UP
            commandIndex--;
767
            if (commandIndex >= 0) {
lm's avatar
lm committed
768 769 770 771
                m_ui->sendText->setText(commandHistory.at(commandIndex));
            }

            // If the index
772
        } else {
lm's avatar
lm committed
773 774
            // DOWN
            commandIndex++;
775
            if (commandIndex < commandHistory.length()) {
lm's avatar
lm committed
776 777 778
                m_ui->sendText->setText(commandHistory.at(commandIndex));
            }
            // If the index is at history length, load the last current command
779

lm's avatar
lm committed
780 781 782
        }

        // Restore current command if we went out of history
783
        if (commandIndex == commandHistory.length()) {
lm's avatar
lm committed
784
            m_ui->sendText->setText(currCommand);
785 786
        }

lm's avatar
lm committed
787
        // If we are too far down or too far up, wrap around to current command
788
        if (commandIndex < 0 || commandIndex > commandHistory.length()) {
lm's avatar
lm committed
789 790 791
            commandIndex = commandHistory.length();
            m_ui->sendText->setText(currCommand);
        }
792

lm's avatar
lm committed
793 794 795
        // Bound the index
        if (commandIndex < 0) commandIndex = 0;
        if (commandIndex > commandHistory.length()) commandIndex = commandHistory.length();
796 797 798
    }
}

pixhawk's avatar
pixhawk committed
799 800 801 802 803 804 805 806 807 808 809
void DebugConsole::changeEvent(QEvent *e)
{
    QWidget::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
        m_ui->retranslateUi(this);
        break;
    default:
        break;
    }
}