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

pixhawk's avatar
pixhawk committed
10 11
#include <QList>
#include <QApplication>
12
#include <QDebug>
13
#include <QSignalSpy>
dogmaphobic's avatar
dogmaphobic committed
14

Gus Grubba's avatar
Gus Grubba committed
15
#ifndef NO_SERIAL_LINK
Don Gagne's avatar
Don Gagne committed
16
#include "QGCSerialPortInfo.h"
dogmaphobic's avatar
dogmaphobic committed
17
#endif
18

19
#include "LinkManager.h"
20
#include "QGCApplication.h"
Don Gagne's avatar
Don Gagne committed
21 22
#include "UDPLink.h"
#include "TCPLink.h"
23
#include "SettingsManager.h"
24
#include "LogReplayLink.h"
dogmaphobic's avatar
dogmaphobic committed
25
#ifdef QGC_ENABLE_BLUETOOTH
dogmaphobic's avatar
dogmaphobic committed
26 27
#include "BluetoothLink.h"
#endif
28

Don Gagne's avatar
Don Gagne committed
29
#ifndef __mobile__
DonLakeFlyer's avatar
DonLakeFlyer committed
30
#include "GPSManager.h"
31
#include "PositionManager.h"
Don Gagne's avatar
Don Gagne committed
32 33
#endif

Don Gagne's avatar
Don Gagne committed
34
QGC_LOGGING_CATEGORY(LinkManagerLog, "LinkManagerLog")
Don Gagne's avatar
Don Gagne committed
35 36
QGC_LOGGING_CATEGORY(LinkManagerVerboseLog, "LinkManagerVerboseLog")

Don Gagne's avatar
Don Gagne committed
37
const char* LinkManager::_defaultUPDLinkName =       "UDP Link (AutoConnect)";
38

39 40 41 42 43 44 45 46
const int LinkManager::_autoconnectUpdateTimerMSecs =   1000;
#ifdef Q_OS_WIN
// Have to manually let the bootloader go by on Windows to get a working connect
const int LinkManager::_autoconnectConnectDelayMSecs =  6000;
#else
const int LinkManager::_autoconnectConnectDelayMSecs =  1000;
#endif

47 48
LinkManager::LinkManager(QGCApplication* app, QGCToolbox* toolbox)
    : QGCTool(app, toolbox)
49 50 51
    , _configUpdateSuspended(false)
    , _configurationsLoaded(false)
    , _connectionsSuspended(false)
52
    , _mavlinkChannelsUsedBitMask(1)    // We never use channel 0 to avoid sequence numbering problems
53 54
    , _autoConnectSettings(nullptr)
    , _mavlinkProtocol(nullptr)
55
#ifndef __mobile__
56
#ifndef NO_SERIAL_LINK
57
    , _nmeaPort(nullptr)
58
#endif
59
#endif
pixhawk's avatar
pixhawk committed
60
{
Don Gagne's avatar
Don Gagne committed
61 62 63 64
    qmlRegisterUncreatableType<LinkManager>         ("QGroundControl", 1, 0, "LinkManager",         "Reference only");
    qmlRegisterUncreatableType<LinkConfiguration>   ("QGroundControl", 1, 0, "LinkConfiguration",   "Reference only");
    qmlRegisterUncreatableType<LinkInterface>       ("QGroundControl", 1, 0, "LinkInterface",       "Reference only");

Gus Grubba's avatar
Gus Grubba committed
65
#ifndef NO_SERIAL_LINK
Don Gagne's avatar
Don Gagne committed
66 67 68
    _activeLinkCheckTimer.setInterval(_activeLinkCheckTimeoutMSecs);
    _activeLinkCheckTimer.setSingleShot(false);
    connect(&_activeLinkCheckTimer, &QTimer::timeout, this, &LinkManager::_activeLinkCheck);
Don Gagne's avatar
Don Gagne committed
69
#endif
pixhawk's avatar
pixhawk committed
70 71 72 73
}

LinkManager::~LinkManager()
{
74
#ifndef __mobile__
75
#ifndef NO_SERIAL_LINK
76
    delete _nmeaPort;
77
#endif
78
#endif
pixhawk's avatar
pixhawk committed
79 80
}

81 82
void LinkManager::setToolbox(QGCToolbox *toolbox)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
83
    QGCTool::setToolbox(toolbox);
84

DonLakeFlyer's avatar
DonLakeFlyer committed
85 86
    _autoConnectSettings = toolbox->settingsManager()->autoConnectSettings();
    _mavlinkProtocol = _toolbox->mavlinkProtocol();
87

88
    connect(_mavlinkProtocol, &MAVLinkProtocol::messageReceived, this, &LinkManager::_mavlinkMessageReceived);
89

Don Gagne's avatar
Don Gagne committed
90
    connect(&_portListTimer, &QTimer::timeout, this, &LinkManager::_updateAutoConnectLinks);
91
    _portListTimer.start(_autoconnectUpdateTimerMSecs); // timeout must be long enough to get past bootloader on second pass
92

93 94
}

Don Gagne's avatar
Don Gagne committed
95 96 97 98 99 100 101 102 103 104
// This should only be used by Qml code
void LinkManager::createConnectedLink(LinkConfiguration* config)
{
    for(int i = 0; i < _sharedConfigurations.count(); i++) {
        SharedLinkConfigurationPointer& sharedConf = _sharedConfigurations[i];
        if (sharedConf->name() == config->name())
            createConnectedLink(sharedConf);
    }
}

105
LinkInterface* LinkManager::createConnectedLink(SharedLinkConfigurationPointer& config, bool isPX4Flow)
106
{
107
    if (!config) {
108 109
        qWarning() << "LinkManager::createConnectedLink called with nullptr config";
        return nullptr;
110 111
    }

112
    LinkInterface* pLink = nullptr;
113
    switch(config->type()) {
Gus Grubba's avatar
Gus Grubba committed
114
#ifndef NO_SERIAL_LINK
DonLakeFlyer's avatar
DonLakeFlyer committed
115 116
    case LinkConfiguration::TypeSerial:
    {
117
        auto* serialConfig = qobject_cast<SerialConfiguration*>(config.data());
DonLakeFlyer's avatar
DonLakeFlyer committed
118
        if (serialConfig) {
119
            pLink = new SerialLink(config, isPX4Flow);
DonLakeFlyer's avatar
DonLakeFlyer committed
120
            if (serialConfig->usbDirect()) {
121
                _activeLinkCheckList.append(qobject_cast<SerialLink*>(pLink));
DonLakeFlyer's avatar
DonLakeFlyer committed
122 123
                if (!_activeLinkCheckTimer.isActive()) {
                    _activeLinkCheckTimer.start();
Don Gagne's avatar
Don Gagne committed
124 125 126
                }
            }
        }
DonLakeFlyer's avatar
DonLakeFlyer committed
127
    }
Don Gagne's avatar
Don Gagne committed
128
        break;
DonLakeFlyer's avatar
DonLakeFlyer committed
129 130
#else
    Q_UNUSED(isPX4Flow)
dogmaphobic's avatar
dogmaphobic committed
131
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
132 133 134 135 136 137
    case LinkConfiguration::TypeUdp:
        pLink = new UDPLink(config);
        break;
    case LinkConfiguration::TypeTcp:
        pLink = new TCPLink(config);
        break;
dogmaphobic's avatar
dogmaphobic committed
138
#ifdef QGC_ENABLE_BLUETOOTH
DonLakeFlyer's avatar
DonLakeFlyer committed
139 140 141
    case LinkConfiguration::TypeBluetooth:
        pLink = new BluetoothLink(config);
        break;
dogmaphobic's avatar
dogmaphobic committed
142
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
143 144 145
    case LinkConfiguration::TypeLogReplay:
        pLink = new LogReplayLink(config);
        break;
146
#ifdef QT_DEBUG
DonLakeFlyer's avatar
DonLakeFlyer committed
147 148 149
    case LinkConfiguration::TypeMock:
        pLink = new MockLink(config);
        break;
150
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
151 152
    case LinkConfiguration::TypeLast:
        break;
153
    }
154
    if (pLink) {
155 156
        _addLink(pLink);
        connectLink(pLink);
157 158 159 160
    }
    return pLink;
}

Don Gagne's avatar
Don Gagne committed
161
LinkInterface* LinkManager::createConnectedLink(const QString& name)
162
{
DonLakeFlyer's avatar
DonLakeFlyer committed
163 164 165 166 167 168 169 170 171
    if (name.isEmpty()) {
        qWarning() << "Internal error";
    } else {
        for(int i = 0; i < _sharedConfigurations.count(); i++) {
            SharedLinkConfigurationPointer& conf = _sharedConfigurations[i];
            if (conf->name() == name) {
                return createConnectedLink(conf);
            }
        }
172
    }
173
    return nullptr;
174 175
}

176
void LinkManager::_addLink(LinkInterface* link)
pixhawk's avatar
pixhawk committed
177
{
Don Gagne's avatar
Don Gagne committed
178
    if (thread() != QThread::currentThread()) {
179
        qWarning() << "_addLink called from incorrect thread";
Don Gagne's avatar
Don Gagne committed
180 181
        return;
    }
182

Don Gagne's avatar
Don Gagne committed
183 184 185
    if (!link) {
        return;
    }
186

187
    if (!containsLink(link)) {
188 189 190 191
        int mavlinkChannel = _reserveMavlinkChannel();
        if (mavlinkChannel != 0) {
            link->_setMavlinkChannel(mavlinkChannel);
        } else {
192
            qWarning() << "Ran out of mavlink channels";
193
            return;
194 195
        }

196
        _sharedLinks.append(SharedLinkInterfacePointer(link));
197 198
        emit newLink(link);
    }
199

Don Gagne's avatar
Don Gagne committed
200 201
    connect(link, &LinkInterface::communicationError,   _app,               &QGCApplication::criticalMessageBoxOnMainThread);
    connect(link, &LinkInterface::bytesReceived,        _mavlinkProtocol,   &MAVLinkProtocol::receiveBytes);
202
    connect(link, &LinkInterface::bytesSent,            _mavlinkProtocol,   &MAVLinkProtocol::logSentBytes);
203

204
    _mavlinkProtocol->resetMetadataForLink(link);
205
    _mavlinkProtocol->setVersion(_mavlinkProtocol->getCurrentVersion());
206

207 208 209 210 211 212
    connect(link, &LinkInterface::connected,            this, &LinkManager::_linkConnected);
    connect(link, &LinkInterface::disconnected,         this, &LinkManager::_linkDisconnected);

    // This connection is queued since it will cloe the link. So we want the link emitter to return otherwise we would
    // close the link our from under itself.
    connect(link, &LinkInterface::connectionRemoved,    this, &LinkManager::_linkConnectionRemoved, Qt::QueuedConnection);
213
}
pixhawk's avatar
pixhawk committed
214

Don Gagne's avatar
Don Gagne committed
215
void LinkManager::disconnectAll(void)
pixhawk's avatar
pixhawk committed
216
{
Don Gagne's avatar
Don Gagne committed
217
    // Walk list in reverse order to preserve indices during delete
218 219
    for (int i=_sharedLinks.count()-1; i>=0; i--) {
        disconnectLink(_sharedLinks[i].data());
220
    }
pixhawk's avatar
pixhawk committed
221 222 223 224
}

bool LinkManager::connectLink(LinkInterface* link)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
225 226 227 228 229 230 231
    if (link) {
        if (_connectionsSuspendedMsg()) {
            return false;
        }
        return link->_connect();
    } else {
        qWarning() << "Internal error";
232 233
        return false;
    }
pixhawk's avatar
pixhawk committed
234 235
}

Don Gagne's avatar
Don Gagne committed
236
void LinkManager::disconnectLink(LinkInterface* link)
pixhawk's avatar
pixhawk committed
237
{
238
    if (!link || !containsLink(link)) {
239 240
        return;
    }
Don Gagne's avatar
Don Gagne committed
241

Don Gagne's avatar
Don Gagne committed
242
    link->_disconnect();
243

Don Gagne's avatar
Don Gagne committed
244
    LinkConfiguration* config = link->getLinkConfiguration();
245 246 247 248 249
    for (int i=0; i<_sharedAutoconnectConfigurations.count(); i++) {
        if (_sharedAutoconnectConfigurations[i].data() == config) {
            qCDebug(LinkManagerLog) << "Removing disconnected autoconnect config" << config->name();
            _sharedAutoconnectConfigurations.removeAt(i);
            break;
250
        }
251
    }
252

Don Gagne's avatar
Don Gagne committed
253
    _deleteLink(link);
pixhawk's avatar
pixhawk committed
254 255
}

256
void LinkManager::_deleteLink(LinkInterface* link)
257
{
Don Gagne's avatar
Don Gagne committed
258 259 260 261 262 263 264 265
    if (thread() != QThread::currentThread()) {
        qWarning() << "_deleteLink called from incorrect thread";
        return;
    }

    if (!link) {
        return;
    }
266

267
    // Free up the mavlink channel associated with this link
268
    _freeMavlinkChannel(link->mavlinkChannel());
269

270 271 272 273 274 275
    for (int i=0; i<_sharedLinks.count(); i++) {
        if (_sharedLinks[i].data() == link) {
            _sharedLinks.removeAt(i);
            break;
        }
    }
276

Don Gagne's avatar
Don Gagne committed
277
    // Emit removal of link
278
    emit linkDeleted(link);
pixhawk's avatar
pixhawk committed
279 280
}

281 282 283 284 285 286 287 288
SharedLinkInterfacePointer LinkManager::sharedLinkInterfacePointerForLink(LinkInterface* link)
{
    for (int i=0; i<_sharedLinks.count(); i++) {
        if (_sharedLinks[i].data() == link) {
            return _sharedLinks[i];
        }
    }

289 290
    qWarning() << "LinkManager::sharedLinkInterfaceForLink returning nullptr";
    return SharedLinkInterfacePointer(nullptr);
291 292
}

293 294 295 296 297
/// @brief If all new connections should be suspended a message is displayed to the user and true
///         is returned;
bool LinkManager::_connectionsSuspendedMsg(void)
{
    if (_connectionsSuspended) {
298
        qgcApp()->showMessage(tr("Connect not allowed: %1").arg(_connectionsSuspendedReason));
299 300 301 302 303 304 305 306 307 308 309
        return true;
    } else {
        return false;
    }
}

void LinkManager::setConnectionsSuspended(QString reason)
{
    _connectionsSuspended = true;
    _connectionsSuspendedReason = reason;
}
310

311 312 313 314 315 316 317 318 319
void LinkManager::_linkConnected(void)
{
    emit linkConnected((LinkInterface*)sender());
}

void LinkManager::_linkDisconnected(void)
{
    emit linkDisconnected((LinkInterface*)sender());
}
320

321 322 323 324 325 326
void LinkManager::_linkConnectionRemoved(LinkInterface* link)
{
    // Link has been removed from system, disconnect it automatically
    disconnectLink(link);
}

327 328 329 330 331 332 333 334 335
void LinkManager::suspendConfigurationUpdates(bool suspend)
{
    _configUpdateSuspended = suspend;
}

void LinkManager::saveLinkConfigurationList()
{
    QSettings settings;
    settings.remove(LinkConfiguration::settingsRoot());
336
    int trueCount = 0;
337 338
    for (int i = 0; i < _sharedConfigurations.count(); i++) {
        SharedLinkConfigurationPointer linkConfig = _sharedConfigurations[i];
Don Gagne's avatar
Don Gagne committed
339
        if (linkConfig) {
340
            if (!linkConfig->isDynamic()) {
Don Gagne's avatar
Don Gagne committed
341
                QString root = LinkConfiguration::settingsRoot();
342
                root += QString("/Link%1").arg(trueCount++);
Don Gagne's avatar
Don Gagne committed
343 344
                settings.setValue(root + "/name", linkConfig->name());
                settings.setValue(root + "/type", linkConfig->type());
345
                settings.setValue(root + "/auto", linkConfig->isAutoConnect());
346
                settings.setValue(root + "/high_latency", linkConfig->isHighLatency());
Don Gagne's avatar
Don Gagne committed
347 348 349 350
                // Have the instance save its own values
                linkConfig->saveSettings(settings, root);
            }
        } else {
351
            qWarning() << "Internal error for link configuration in LinkManager";
dogmaphobic's avatar
dogmaphobic committed
352
        }
353
    }
dogmaphobic's avatar
dogmaphobic committed
354
    QString root(LinkConfiguration::settingsRoot());
355 356
    settings.setValue(root + "/count", trueCount);
    emit linkConfigurationsChanged();
357 358 359 360
}

void LinkManager::loadLinkConfigurationList()
{
361
    bool linksChanged = false;
362 363 364 365 366 367 368 369 370
    QSettings settings;
    // Is the group even there?
    if(settings.contains(LinkConfiguration::settingsRoot() + "/count")) {
        // Find out how many configurations we have
        int count = settings.value(LinkConfiguration::settingsRoot() + "/count").toInt();
        for(int i = 0; i < count; i++) {
            QString root(LinkConfiguration::settingsRoot());
            root += QString("/Link%1").arg(i);
            if(settings.contains(root + "/type")) {
371 372
                LinkConfiguration::LinkType type = static_cast<LinkConfiguration::LinkType>(settings.value(root + "/type").toInt());
                if(type < LinkConfiguration::TypeLast) {
373 374 375
                    if(settings.contains(root + "/name")) {
                        QString name = settings.value(root + "/name").toString();
                        if(!name.isEmpty()) {
376
                            LinkConfiguration* pLink = nullptr;
377
                            bool autoConnect = settings.value(root + "/auto").toBool();
378
                            bool highLatency = settings.value(root + "/high_latency").toBool();
379
                            switch(type) {
Gus Grubba's avatar
Gus Grubba committed
380
#ifndef NO_SERIAL_LINK
DonLakeFlyer's avatar
DonLakeFlyer committed
381
                            case LinkConfiguration::TypeSerial:
382
                                pLink = new SerialConfiguration(name);
DonLakeFlyer's avatar
DonLakeFlyer committed
383
                                break;
dogmaphobic's avatar
dogmaphobic committed
384
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
385
                            case LinkConfiguration::TypeUdp:
386
                                pLink = new UDPConfiguration(name);
DonLakeFlyer's avatar
DonLakeFlyer committed
387 388
                                break;
                            case LinkConfiguration::TypeTcp:
389
                                pLink = new TCPConfiguration(name);
DonLakeFlyer's avatar
DonLakeFlyer committed
390
                                break;
dogmaphobic's avatar
dogmaphobic committed
391
#ifdef QGC_ENABLE_BLUETOOTH
DonLakeFlyer's avatar
DonLakeFlyer committed
392
                            case LinkConfiguration::TypeBluetooth:
393
                                pLink = new BluetoothConfiguration(name);
DonLakeFlyer's avatar
DonLakeFlyer committed
394
                                break;
dogmaphobic's avatar
dogmaphobic committed
395
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
396
                            case LinkConfiguration::TypeLogReplay:
397
                                pLink = new LogReplayLinkConfiguration(name);
DonLakeFlyer's avatar
DonLakeFlyer committed
398
                                break;
399
#ifdef QT_DEBUG
DonLakeFlyer's avatar
DonLakeFlyer committed
400
                            case LinkConfiguration::TypeMock:
401
                                pLink = new MockConfiguration(name);
402
                                break;
403
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
404 405
                            case LinkConfiguration::TypeLast:
                                break;
406 407
                            }
                            if(pLink) {
408 409
                                //-- Have the instance load its own values
                                pLink->setAutoConnect(autoConnect);
410
                                pLink->setHighLatency(highLatency);
411
                                pLink->loadSettings(settings, root);
412
                                addConfiguration(pLink);
413
                                linksChanged = true;
414 415
                            }
                        } else {
416
                            qWarning() << "Link Configuration" << root << "has an empty name." ;
417 418
                        }
                    } else {
419
                        qWarning() << "Link Configuration" << root << "has no name." ;
420 421
                    }
                } else {
422
                    qWarning() << "Link Configuration" << root << "an invalid type: " << type;
423 424
                }
            } else {
425
                qWarning() << "Link Configuration" << root << "has no type." ;
426 427 428
            }
        }
    }
429 430

    if(linksChanged) {
431
        emit linkConfigurationsChanged();
432 433
    }
    // Enable automatic Serial PX4/3DR Radio hunting
434 435 436
    _configurationsLoaded = true;
}

Gus Grubba's avatar
Gus Grubba committed
437
#ifndef NO_SERIAL_LINK
Don Gagne's avatar
Don Gagne committed
438
SerialConfiguration* LinkManager::_autoconnectConfigurationsContainsPort(const QString& portName)
439 440
{
    QString searchPort = portName.trimmed();
Don Gagne's avatar
Don Gagne committed
441

442 443
    for (int i=0; i<_sharedAutoconnectConfigurations.count(); i++) {
        SerialConfiguration* serialConfig = qobject_cast<SerialConfiguration*>(_sharedAutoconnectConfigurations[i].data());
Don Gagne's avatar
Don Gagne committed
444

445 446 447
        if (serialConfig) {
            if (serialConfig->portName() == searchPort) {
                return serialConfig;
448
            }
Don Gagne's avatar
Don Gagne committed
449 450
        } else {
            qWarning() << "Internal error";
451 452
        }
    }
453
    return nullptr;
454
}
dogmaphobic's avatar
dogmaphobic committed
455
#endif
456

Don Gagne's avatar
Don Gagne committed
457
void LinkManager::_updateAutoConnectLinks(void)
458
{
Don Gagne's avatar
Don Gagne committed
459
    if (_connectionsSuspended || qgcApp()->runningUnitTests()) {
460 461
        return;
    }
Don Gagne's avatar
Don Gagne committed
462 463
    // Re-add UDP if we need to
    bool foundUDP = false;
464
    for (int i = 0; i < _sharedLinks.count(); i++) {
465
        LinkConfiguration* linkConfig = _sharedLinks[i]->getLinkConfiguration();
Don Gagne's avatar
Don Gagne committed
466 467 468 469 470
        if (linkConfig->type() == LinkConfiguration::TypeUdp && linkConfig->name() == _defaultUPDLinkName) {
            foundUDP = true;
            break;
        }
    }
471
    if (!foundUDP && _autoConnectSettings->autoConnectUDP()->rawValue().toBool()) {
Don Gagne's avatar
Don Gagne committed
472
        qCDebug(LinkManagerLog) << "New auto-connect UDP port added";
473
        //-- Default UDPConfiguration is set up for autoconnect
Don Gagne's avatar
Don Gagne committed
474
        UDPConfiguration* udpConfig = new UDPConfiguration(_defaultUPDLinkName);
DonLakeFlyer's avatar
DonLakeFlyer committed
475
        udpConfig->setDynamic(true);
476 477
        SharedLinkConfigurationPointer config = addConfiguration(udpConfig);
        createConnectedLink(config);
478
        emit linkConfigurationsChanged();
Don Gagne's avatar
Don Gagne committed
479
    }
480
#ifndef __mobile__
481
#ifndef NO_SERIAL_LINK
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
    // check to see if nmea gps is configured for UDP input, if so, set it up to connect
    if (_autoConnectSettings->autoConnectNmeaPort()->cookedValueString() == "UDP Port") {
        if (_nmeaSocket.localPort() != _autoConnectSettings->nmeaUdpPort()->rawValue().toUInt()
                || _nmeaSocket.state() != UdpIODevice::BoundState) {
            qCDebug(LinkManagerLog) << "Changing port for UDP NMEA stream";
            _nmeaSocket.close();
            _nmeaSocket.bind(QHostAddress::AnyIPv4, _autoConnectSettings->nmeaUdpPort()->rawValue().toUInt());
            _toolbox->qgcPositionManager()->setNmeaSourceDevice(&_nmeaSocket);
        }
        //close serial port
        if (_nmeaPort) {
            _nmeaPort->close();
            delete _nmeaPort;
            _nmeaPort = nullptr;
            _nmeaDeviceName = "";
        }
    } else {
        _nmeaSocket.close();
    }
#endif
502
#endif
Don Gagne's avatar
Don Gagne committed
503

Gus Grubba's avatar
Gus Grubba committed
504
#ifndef NO_SERIAL_LINK
dogmaphobic's avatar
dogmaphobic committed
505
    QStringList currentPorts;
506 507 508 509 510
    QList<QGCSerialPortInfo> portList;
#ifdef __android__
    // Android builds only support a single serial connection. Repeatedly calling availablePorts after that one serial
    // port is connected leaks file handles due to a bug somewhere in android serial code. In order to work around that
    // bug after we connect the first serial port we stop probing for additional ports.
511
    if (!_sharedAutoconnectConfigurations.count()) {
512 513
        portList = QGCSerialPortInfo::availablePorts();
    }
514 515
#else
    portList = QGCSerialPortInfo::availablePorts();
516
#endif
Don Gagne's avatar
Don Gagne committed
517

518
    // Iterate Comm Ports
519
    for (const QGCSerialPortInfo& portInfo: portList) {
Don Gagne's avatar
Don Gagne committed
520 521 522 523 524 525 526 527 528
        qCDebug(LinkManagerVerboseLog) << "-----------------------------------------------------";
        qCDebug(LinkManagerVerboseLog) << "portName:          " << portInfo.portName();
        qCDebug(LinkManagerVerboseLog) << "systemLocation:    " << portInfo.systemLocation();
        qCDebug(LinkManagerVerboseLog) << "description:       " << portInfo.description();
        qCDebug(LinkManagerVerboseLog) << "manufacturer:      " << portInfo.manufacturer();
        qCDebug(LinkManagerVerboseLog) << "serialNumber:      " << portInfo.serialNumber();
        qCDebug(LinkManagerVerboseLog) << "vendorIdentifier:  " << portInfo.vendorIdentifier();
        qCDebug(LinkManagerVerboseLog) << "productIdentifier: " << portInfo.productIdentifier();

dogmaphobic's avatar
dogmaphobic committed
529 530
        // Save port name
        currentPorts << portInfo.systemLocation();
Don Gagne's avatar
Don Gagne committed
531

532 533
        QGCSerialPortInfo::BoardType_t boardType;
        QString boardName;
Don Gagne's avatar
Don Gagne committed
534

535
#ifndef NO_SERIAL_LINK
536
#ifndef __mobile__
537
        // check to see if nmea gps is configured for current Serial port, if so, set it up to connect
538 539 540 541 542 543
        if (portInfo.systemLocation().trimmed() == _autoConnectSettings->autoConnectNmeaPort()->cookedValueString()) {
            if (portInfo.systemLocation().trimmed() != _nmeaDeviceName) {
                _nmeaDeviceName = portInfo.systemLocation().trimmed();
                qCDebug(LinkManagerLog) << "Configuring nmea port" << _nmeaDeviceName;
                QSerialPort* newPort = new QSerialPort(portInfo);
                _nmeaBaud = _autoConnectSettings->autoConnectNmeaBaud()->cookedValue().toUInt();
544
                newPort->setBaudRate(static_cast<qint32>(_nmeaBaud));
545 546 547 548 549 550 551 552 553
                qCDebug(LinkManagerLog) << "Configuring nmea baudrate" << _nmeaBaud;
                // This will stop polling old device if previously set
                _toolbox->qgcPositionManager()->setNmeaSourceDevice(newPort);
                if (_nmeaPort) {
                    delete _nmeaPort;
                }
                _nmeaPort = newPort;
            } else if (_autoConnectSettings->autoConnectNmeaBaud()->cookedValue().toUInt() != _nmeaBaud) {
                _nmeaBaud = _autoConnectSettings->autoConnectNmeaBaud()->cookedValue().toUInt();
554
                _nmeaPort->setBaudRate(static_cast<qint32>(_nmeaBaud));
555 556
                qCDebug(LinkManagerLog) << "Configuring nmea baudrate" << _nmeaBaud;
            }
557
        } else
558
#endif
559 560
#endif
        if (portInfo.getBoardInfo(boardType, boardName)) {
Don Gagne's avatar
Don Gagne committed
561 562
            if (portInfo.isBootloader()) {
                // Don't connect to bootloader
563
                qCDebug(LinkManagerLog) << "Waiting for bootloader to finish" << portInfo.systemLocation();
Don Gagne's avatar
Don Gagne committed
564 565
                continue;
            }
566
            if (_autoconnectConfigurationsContainsPort(portInfo.systemLocation()) || _autoConnectRTKPort == portInfo.systemLocation()) {
567 568 569 570 571 572
                qCDebug(LinkManagerVerboseLog) << "Skipping existing autoconnect" << portInfo.systemLocation();
            } else if (!_autoconnectWaitList.contains(portInfo.systemLocation())) {
                // We don't connect to the port the first time we see it. The ability to correctly detect whether we
                // are in the bootloader is flaky from a cross-platform standpoint. So by putting it on a wait list
                // and only connect on the second pass we leave enough time for the board to boot up.
                qCDebug(LinkManagerLog) << "Waiting for next autoconnect pass" << portInfo.systemLocation();
573 574
                _autoconnectWaitList[portInfo.systemLocation()] = 1;
            } else if (++_autoconnectWaitList[portInfo.systemLocation()] * _autoconnectUpdateTimerMSecs > _autoconnectConnectDelayMSecs) {
575
                SerialConfiguration* pSerialConfig = nullptr;
576
                _autoconnectWaitList.remove(portInfo.systemLocation());
Don Gagne's avatar
Don Gagne committed
577
                switch (boardType) {
578
                case QGCSerialPortInfo::BoardTypePixhawk:
579
                    if (_autoConnectSettings->autoConnectPixhawk()->rawValue().toBool()) {
580
                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
581 582 583
                        pSerialConfig->setUsbDirect(true);
                    }
                    break;
Don Gagne's avatar
Don Gagne committed
584
                case QGCSerialPortInfo::BoardTypePX4Flow:
585
                    if (_autoConnectSettings->autoConnectPX4Flow()->rawValue().toBool()) {
586
                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
Don Gagne's avatar
Don Gagne committed
587
                    }
Don Gagne's avatar
Don Gagne committed
588
                    break;
589
                case QGCSerialPortInfo::BoardTypeSiKRadio:
590
                    if (_autoConnectSettings->autoConnectSiKRadio()->rawValue().toBool()) {
591
                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
Don Gagne's avatar
Don Gagne committed
592 593
                    }
                    break;
594
                case QGCSerialPortInfo::BoardTypeOpenPilot:
595
                    if (_autoConnectSettings->autoConnectLibrePilot()->rawValue().toBool()) {
596
                        pSerialConfig = new SerialConfiguration(tr("%1 on %2 (AutoConnect)").arg(boardName).arg(portInfo.portName().trimmed()));
597 598
                    }
                    break;
Don Gagne's avatar
Don Gagne committed
599 600
#ifndef __mobile__
                case QGCSerialPortInfo::BoardTypeRTKGPS:
601
                    if (_autoConnectSettings->autoConnectRTKGPS()->rawValue().toBool() && !_toolbox->gpsManager()->connected()) {
602 603
                        qCDebug(LinkManagerLog) << "RTK GPS auto-connected" << portInfo.portName().trimmed();
                        _autoConnectRTKPort = portInfo.systemLocation();
604
                        _toolbox->gpsManager()->connectGPS(portInfo.systemLocation(), boardName);
Don Gagne's avatar
Don Gagne committed
605 606 607
                    }
                    break;
#endif
Don Gagne's avatar
Don Gagne committed
608 609
                default:
                    qWarning() << "Internal error";
Don Gagne's avatar
Don Gagne committed
610
                    continue;
dogmaphobic's avatar
dogmaphobic committed
611
                }
Don Gagne's avatar
Don Gagne committed
612 613
                if (pSerialConfig) {
                    qCDebug(LinkManagerLog) << "New auto-connect port added: " << pSerialConfig->name() << portInfo.systemLocation();
614
                    pSerialConfig->setBaud(boardType == QGCSerialPortInfo::BoardTypeSiKRadio ? 57600 : 115200);
Don Gagne's avatar
Don Gagne committed
615 616
                    pSerialConfig->setDynamic(true);
                    pSerialConfig->setPortName(portInfo.systemLocation());
617
                    _sharedAutoconnectConfigurations.append(SharedLinkConfigurationPointer(pSerialConfig));
618
                    createConnectedLink(_sharedAutoconnectConfigurations.last(), boardType == QGCSerialPortInfo::BoardTypePX4Flow);
Don Gagne's avatar
Don Gagne committed
619
                }
dogmaphobic's avatar
dogmaphobic committed
620 621 622
            }
        }
    }
Don Gagne's avatar
Don Gagne committed
623

624 625 626
#ifndef __android__
    // Android builds only support a single serial connection. Repeatedly calling availablePorts after that one serial
    // port is connected leaks file handles due to a bug somewhere in android serial code. In order to work around that
627
    // bug after we connect the first serial port we stop probing for additional ports. That means we must rely on
628 629 630
    // the port disconnecting itself when the radio is pulled to signal communication list as opposed to automatically
    // closing the Link.

dogmaphobic's avatar
dogmaphobic committed
631 632
    // Now we go through the current configuration list and make sure any dynamic config has gone away
    QList<LinkConfiguration*>  _confToDelete;
633 634 635 636 637 638 639
    for (int i=0; i<_sharedAutoconnectConfigurations.count(); i++) {
        SerialConfiguration* serialConfig = qobject_cast<SerialConfiguration*>(_sharedAutoconnectConfigurations[i].data());
        if (serialConfig) {
            if (!currentPorts.contains(serialConfig->portName())) {
                if (serialConfig->link()) {
                    if (serialConfig->link()->isConnected()) {
                        if (serialConfig->link()->active()) {
640 641 642 643 644 645
                            // We don't remove links which are still connected which have been active with a vehicle on them
                            // even though at this point the cable may have been pulled. Instead we wait for the user to
                            // Disconnect. Once the user disconnects, the link will be removed.
                            continue;
                        }
                    }
Don Gagne's avatar
Don Gagne committed
646
                }
647
                _confToDelete.append(serialConfig);
dogmaphobic's avatar
dogmaphobic committed
648
            }
Don Gagne's avatar
Don Gagne committed
649 650
        } else {
            qWarning() << "Internal error";
dogmaphobic's avatar
dogmaphobic committed
651 652
        }
    }
Don Gagne's avatar
Don Gagne committed
653

Don Gagne's avatar
Don Gagne committed
654
    // Now remove all configs that are gone
655
    for (LinkConfiguration* pDeleteConfig: _confToDelete) {
Don Gagne's avatar
Don Gagne committed
656
        qCDebug(LinkManagerLog) << "Removing unused autoconnect config" << pDeleteConfig->name();
Don Gagne's avatar
Don Gagne committed
657 658 659
        if (pDeleteConfig->link()) {
            disconnectLink(pDeleteConfig->link());
        }
660 661 662 663 664 665
        for (int i=0; i<_sharedAutoconnectConfigurations.count(); i++) {
            if (_sharedAutoconnectConfigurations[i].data() == pDeleteConfig) {
                _sharedAutoconnectConfigurations.removeAt(i);
                break;
            }
        }
666
    }
667 668

    // Check for RTK GPS connection gone
669
#if !defined(__mobile__)
670 671 672 673 674
    if (!_autoConnectRTKPort.isEmpty() && !currentPorts.contains(_autoConnectRTKPort)) {
        qCDebug(LinkManagerLog) << "RTK GPS disconnected" << _autoConnectRTKPort;
        _toolbox->gpsManager()->disconnectGPS();
        _autoConnectRTKPort.clear();
    }
675
#endif
676

677
#endif
Gus Grubba's avatar
Gus Grubba committed
678
#endif // NO_SERIAL_LINK
679 680
}

Don Gagne's avatar
Don Gagne committed
681 682
void LinkManager::shutdown(void)
{
683
    setConnectionsSuspended(tr("Shutdown"));
Don Gagne's avatar
Don Gagne committed
684
    disconnectAll();
Don Gagne's avatar
Don Gagne committed
685 686
}

687 688 689 690 691 692
QStringList LinkManager::linkTypeStrings(void) const
{
    //-- Must follow same order as enum LinkType in LinkConfiguration.h
    static QStringList list;
    if(!list.size())
    {
Gus Grubba's avatar
Gus Grubba committed
693
#ifndef NO_SERIAL_LINK
694 695 696 697
        list += tr("Serial");
#endif
        list += tr("UDP");
        list += tr("TCP");
dogmaphobic's avatar
dogmaphobic committed
698
#ifdef QGC_ENABLE_BLUETOOTH
dogmaphobic's avatar
dogmaphobic committed
699 700
        list += "Bluetooth";
#endif
dogmaphobic's avatar
dogmaphobic committed
701
#ifdef QT_DEBUG
702
        list += tr("Mock Link");
dogmaphobic's avatar
dogmaphobic committed
703 704
#endif
#ifndef __mobile__
705
        list += tr("Log Replay");
dogmaphobic's avatar
dogmaphobic committed
706
#endif
707
        if (list.size() != static_cast<int>(LinkConfiguration::TypeLast)) {
DonLakeFlyer's avatar
DonLakeFlyer committed
708 709
            qWarning() << "Internal error";
        }
710 711 712 713
    }
    return list;
}

714
void LinkManager::_updateSerialPorts()
715
{
716 717
    _commPortList.clear();
    _commPortDisplayList.clear();
Gus Grubba's avatar
Gus Grubba committed
718
#ifndef NO_SERIAL_LINK
719
    QList<QSerialPortInfo> portList = QSerialPortInfo::availablePorts();
720
    for (const QSerialPortInfo &info: portList)
721
    {
722 723 724
        QString port = info.systemLocation().trimmed();
        _commPortList += port;
        _commPortDisplayList += SerialConfiguration::cleanPortDisplayname(port);
725 726
    }
#endif
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
}

QStringList LinkManager::serialPortStrings(void)
{
    if(!_commPortDisplayList.size())
    {
        _updateSerialPorts();
    }
    return _commPortDisplayList;
}

QStringList LinkManager::serialPorts(void)
{
    if(!_commPortList.size())
    {
        _updateSerialPorts();
    }
744 745 746 747 748
    return _commPortList;
}

QStringList LinkManager::serialBaudRates(void)
{
Gus Grubba's avatar
Gus Grubba committed
749
#ifdef NO_SERIAL_LINK
750 751 752 753 754 755
    QStringList foo;
    return foo;
#else
    return SerialConfiguration::supportedBaudRates();
#endif
}
756 757 758

bool LinkManager::endConfigurationEditing(LinkConfiguration* config, LinkConfiguration* editedConfig)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
759 760 761 762 763 764 765 766 767 768 769
    if (config && editedConfig) {
        _fixUnnamed(editedConfig);
        config->copyFrom(editedConfig);
        saveLinkConfigurationList();
        // Tell link about changes (if any)
        config->updateSettings();
        // Discard temporary duplicate
        delete editedConfig;
    } else {
        qWarning() << "Internal error";
    }
770 771 772 773 774
    return true;
}

bool LinkManager::endCreateConfiguration(LinkConfiguration* config)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
775 776 777 778 779 780 781
    if (config) {
        _fixUnnamed(config);
        addConfiguration(config);
        saveLinkConfigurationList();
    } else {
        qWarning() << "Internal error";
    }
782 783 784 785 786
    return true;
}

LinkConfiguration* LinkManager::createConfiguration(int type, const QString& name)
{
Gus Grubba's avatar
Gus Grubba committed
787
#ifndef NO_SERIAL_LINK
788
    if(static_cast<LinkConfiguration::LinkType>(type) == LinkConfiguration::TypeSerial)
789
        _updateSerialPorts();
dogmaphobic's avatar
dogmaphobic committed
790
#endif
791 792 793 794 795
    return LinkConfiguration::createSettings(type, name);
}

LinkConfiguration* LinkManager::startConfigurationEditing(LinkConfiguration* config)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
796
    if (config) {
Gus Grubba's avatar
Gus Grubba committed
797
#ifndef NO_SERIAL_LINK
DonLakeFlyer's avatar
DonLakeFlyer committed
798 799
        if(config->type() == LinkConfiguration::TypeSerial)
            _updateSerialPorts();
dogmaphobic's avatar
dogmaphobic committed
800
#endif
DonLakeFlyer's avatar
DonLakeFlyer committed
801 802 803
        return LinkConfiguration::duplicateSettings(config);
    } else {
        qWarning() << "Internal error";
804
        return nullptr;
DonLakeFlyer's avatar
DonLakeFlyer committed
805
    }
806 807 808 809
}

void LinkManager::_fixUnnamed(LinkConfiguration* config)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
810 811 812 813
    if (config) {
        //-- Check for "Unnamed"
        if (config->name() == "Unnamed") {
            switch(config->type()) {
Gus Grubba's avatar
Gus Grubba committed
814
#ifndef NO_SERIAL_LINK
815 816
            case LinkConfiguration::TypeSerial: {
                QString tname = dynamic_cast<SerialConfiguration*>(config)->portName();
817
#ifdef Q_OS_WIN
818 819 820 821 822 823 824
                tname.replace("\\\\.\\", "");
#else
                tname.replace("/dev/cu.", "");
                tname.replace("/dev/", "");
#endif
                config->setName(QString("Serial Device on %1").arg(tname));
                break;
DonLakeFlyer's avatar
DonLakeFlyer committed
825
            }
826 827 828
#endif
            case LinkConfiguration::TypeUdp:
                config->setName(
829
                    QString("UDP Link on Port %1").arg(dynamic_cast<UDPConfiguration*>(config)->localPort()));
830 831
                break;
            case LinkConfiguration::TypeTcp: {
DonLakeFlyer's avatar
DonLakeFlyer committed
832 833 834
                TCPConfiguration* tconfig = dynamic_cast<TCPConfiguration*>(config);
                if(tconfig) {
                    config->setName(
835
                        QString("TCP Link %1:%2").arg(tconfig->address().toString()).arg(static_cast<int>(tconfig->port())));
836
                }
DonLakeFlyer's avatar
DonLakeFlyer committed
837
            }
838
                break;
dogmaphobic's avatar
dogmaphobic committed
839
#ifdef QGC_ENABLE_BLUETOOTH
dogmaphobic's avatar
dogmaphobic committed
840
            case LinkConfiguration::TypeBluetooth: {
DonLakeFlyer's avatar
DonLakeFlyer committed
841 842 843
                BluetoothConfiguration* tconfig = dynamic_cast<BluetoothConfiguration*>(config);
                if(tconfig) {
                    config->setName(QString("%1 (Bluetooth Device)").arg(tconfig->device().name));
dogmaphobic's avatar
dogmaphobic committed
844
                }
DonLakeFlyer's avatar
DonLakeFlyer committed
845
            }
dogmaphobic's avatar
dogmaphobic committed
846 847
                break;
#endif
848
            case LinkConfiguration::TypeLogReplay: {
DonLakeFlyer's avatar
DonLakeFlyer committed
849 850 851
                LogReplayLinkConfiguration* tconfig = dynamic_cast<LogReplayLinkConfiguration*>(config);
                if(tconfig) {
                    config->setName(QString("Log Replay %1").arg(tconfig->logFilenameShort()));
852
                }
DonLakeFlyer's avatar
DonLakeFlyer committed
853
            }
854 855 856
                break;
#ifdef QT_DEBUG
            case LinkConfiguration::TypeMock:
857
                config->setName(QString("Mock Link"));
858 859 860 861
                break;
#endif
            case LinkConfiguration::TypeLast:
                break;
DonLakeFlyer's avatar
DonLakeFlyer committed
862
            }
863
        }
DonLakeFlyer's avatar
DonLakeFlyer committed
864 865
    } else {
        qWarning() << "Internal error";
866 867 868 869 870
    }
}

void LinkManager::removeConfiguration(LinkConfiguration* config)
{
DonLakeFlyer's avatar
DonLakeFlyer committed
871 872 873 874 875
    if (config) {
        LinkInterface* iface = config->link();
        if(iface) {
            disconnectLink(iface);
        }
876

DonLakeFlyer's avatar
DonLakeFlyer committed
877 878 879 880 881
        _removeConfiguration(config);
        saveLinkConfigurationList();
    } else {
        qWarning() << "Internal error";
    }
882
}
883

884 885
bool LinkManager::isAutoconnectLink(LinkInterface* link)
{
886 887 888 889 890 891
    for (int i=0; i<_sharedAutoconnectConfigurations.count(); i++) {
        if (_sharedAutoconnectConfigurations[i].data() == link->getLinkConfiguration()) {
            return true;
        }
    }
    return false;
892
}
dogmaphobic's avatar
dogmaphobic committed
893 894 895 896 897

bool LinkManager::isBluetoothAvailable(void)
{
    return qgcApp()->isBluetoothAvailable();
}
Don Gagne's avatar
Don Gagne committed
898

Gus Grubba's avatar
Gus Grubba committed
899
#ifndef NO_SERIAL_LINK
Don Gagne's avatar
Don Gagne committed
900 901
void LinkManager::_activeLinkCheck(void)
{
902
    SerialLink* link = nullptr;
Don Gagne's avatar
Don Gagne committed
903 904
    bool found = false;
    if (_activeLinkCheckList.count() != 0) {
905
        link = _activeLinkCheckList.takeFirst();
906
        if (containsLink(link) && link->isConnected()) {
Don Gagne's avatar
Don Gagne committed
907 908 909 910 911 912 913 914 915
            // Make sure there is a vehicle on the link
            QmlObjectListModel* vehicles = _toolbox->multiVehicleManager()->vehicles();
            for (int i=0; i<vehicles->count(); i++) {
                Vehicle* vehicle = qobject_cast<Vehicle*>(vehicles->get(i));
                if (vehicle->containsLink(link)) {
                    found = true;
                    break;
                }
            }
916
        } else {
917
            link = nullptr;
Don Gagne's avatar
Don Gagne committed
918 919 920 921 922
        }
    }
    if (_activeLinkCheckList.count() == 0) {
        _activeLinkCheckTimer.stop();
    }
923 924 925
    if (!found && link) {
        // See if we can get an NSH prompt on this link
        bool foundNSHPrompt = false;
926
        link->writeBytesSafe("\r", 1);
927 928 929
        QSignalSpy spy(link, SIGNAL(bytesReceived(LinkInterface*, QByteArray)));
        if (spy.wait(100)) {
            QList<QVariant> arguments = spy.takeFirst();
930
            if (arguments[1].toByteArray().contains("nsh>")) {
931 932 933
                foundNSHPrompt = true;
            }
        }
934 935 936 937
        qgcApp()->showMessage(
            foundNSHPrompt ?
                tr("Please check to make sure you have an SD Card inserted in your Vehicle and try again.") :
                tr("Your Vehicle is not responding. If this continues, shutdown %1, restart the Vehicle letting it boot completely, then start %1.").arg(qgcApp()->applicationName()));
Don Gagne's avatar
Don Gagne committed
938 939
    }
}
Don Gagne's avatar
Don Gagne committed
940
#endif
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978

bool LinkManager::containsLink(LinkInterface* link)
{
    for (int i=0; i<_sharedLinks.count(); i++) {
        if (_sharedLinks[i].data() == link) {
            return true;
        }
    }
    return false;
}

SharedLinkConfigurationPointer LinkManager::addConfiguration(LinkConfiguration* config)
{
    _qmlConfigurations.append(config);
    _sharedConfigurations.append(SharedLinkConfigurationPointer(config));
    return _sharedConfigurations.last();
}

void LinkManager::_removeConfiguration(LinkConfiguration* config)
{
    _qmlConfigurations.removeOne(config);
    for (int i=0; i<_sharedConfigurations.count(); i++) {
        if (_sharedConfigurations[i].data() == config) {
            _sharedConfigurations.removeAt(i);
            return;
        }
    }
    qWarning() << "LinkManager::_removeConfiguration called with unknown config";
}

QList<LinkInterface*> LinkManager::links(void)
{
    QList<LinkInterface*> rawLinks;
    for (int i=0; i<_sharedLinks.count(); i++) {
        rawLinks.append(_sharedLinks[i].data());
    }
    return rawLinks;
}
979 980 981 982 983 984 985 986 987 988

void LinkManager::startAutoConnectedLinks(void)
{
    SharedLinkConfigurationPointer conf;
    for(int i = 0; i < _sharedConfigurations.count(); i++) {
        conf = _sharedConfigurations[i];
        if (conf->isAutoConnect())
            createConnectedLink(conf);
    }
}
989 990 991 992

int LinkManager::_reserveMavlinkChannel(void)
{
    // Find a mavlink channel to use for this link, Channel 0 is reserved for internal use.
993
    for (uint8_t mavlinkChannel = 1; mavlinkChannel < MAVLINK_COMM_NUM_BUFFERS; mavlinkChannel++) {
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
        if (!(_mavlinkChannelsUsedBitMask & 1 << mavlinkChannel)) {
            mavlink_reset_channel_status(mavlinkChannel);
            // Start the channel on Mav 1 protocol
            mavlink_status_t* mavlinkStatus = mavlink_get_channel_status(mavlinkChannel);
            mavlinkStatus->flags |= MAVLINK_STATUS_FLAG_OUT_MAVLINK1;
            _mavlinkChannelsUsedBitMask |= 1 << mavlinkChannel;
            return mavlinkChannel;
        }
    }
    return 0;   // All channels reserved
}

void LinkManager::_freeMavlinkChannel(int channel)
{
    _mavlinkChannelsUsedBitMask &= ~(1 << channel);
}
1010

1011 1012
void LinkManager::_mavlinkMessageReceived(LinkInterface* link, mavlink_message_t message) {
    link->startMavlinkMessagesTimer(message.sysid);
1013
}
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023

LogReplayLink* LinkManager::startLogReplay(const QString& logFile)
{
    LogReplayLinkConfiguration* linkConfig = new LogReplayLinkConfiguration(tr("Log Replay"));
    linkConfig->setLogFilename(logFile);
    linkConfig->setName(linkConfig->logFilenameShort());

    SharedLinkConfigurationPointer sharedConfig = addConfiguration(linkConfig);
    return qobject_cast<LogReplayLink*>(createConnectedLink(sharedConfig));
}