SerialPortManager.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
 
#include <QtCore/QElapsedTimer>
#include <QtCore/QHash>
#include <QtCore/QMap>
#include <QtCore/QObject>
#include <QtCore/QSet>
#include <QtCore/QStringList>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "QGCSerialPortInfo.h"
 
class SerialPortManager : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("Managed by QGroundControl")
 
    Q_PROPERTY(QStringList serialPorts READ serialPorts NOTIFY serialPortsChanged)
    Q_PROPERTY(QStringList serialBaudRates READ supportedBaudRates CONSTANT)
 
public:
    struct Port
    {
        QString systemLocation;
        QString portName;
        QGCSerialPortInfo::BoardType_t boardType = QGCSerialPortInfo::BoardTypeUnknown;
        QString boardName;
        bool bootloader = false;
        QString physicalDeviceId = {};
        QString description = {};
        QString displayName = {};
    };
 
    struct Reservation
    {
        QString systemLocation;
    };
 
    using ReservationPtr = std::shared_ptr<const Reservation>;
    using Enumerator = std::function<QList<Port>()>;
 
#ifdef Q_OS_WIN
    // Allow the bootloader to finish before opening a new Windows device.
    static constexpr std::chrono::milliseconds NEW_PORT_SETTLE_DELAY{6000};
#else
    static constexpr std::chrono::milliseconds NEW_PORT_SETTLE_DELAY{1000};
#endif
 
    explicit SerialPortManager(QObject* parent = nullptr, Enumerator enumerator = {});
    static SerialPortManager* instance();
 
    static bool isPrimaryInterface(const Port& port, QSet<QString>& seenDevices);
 
    QList<Port> availablePorts();
    void rescan();
    QString displayName(const QString& systemLocation);
 
    QStringList serialPorts() const { return _serialPorts; }
 
    static QStringList supportedBaudRates();
    ReservationPtr reservePort(const QString& systemLocation);
    bool canReservePort(const QString& systemLocation) const;
    bool isPortReserved(const QString& systemLocation) const;
    bool anyPortReserved() const;
 
    ReservationPtr excludeFromAutoConnect(const QString& systemLocation);
    bool canAutoConnectPort(const QString& systemLocation) const;
    bool isAutoConnectExcluded(const QString& systemLocation) const;
 
    void setSinglePortOnly(bool enabled) { _singlePortOnly = enabled; }
 
signals:
    void serialPortsChanged();
    void portsEnumerated(const QStringList& availablePorts);
 
private:
    static QList<Port> _enumeratePorts();
    Enumerator _enumerator;
    QList<Port> _ports;
    QStringList _serialPorts;
    QElapsedTimer _scanTimer;
    QHash<QString, std::weak_ptr<const Reservation>> _reservations;
    QHash<QString, std::weak_ptr<const Reservation>> _autoConnectExclusions;
    bool _singlePortOnly = false;
};
 
class SerialPortSettleTracker
{
    friend class LinkManagerTest;
    friend class SerialAutoConnectTest;
 
public:
    bool settled(const QString& port, quint64 nowUs)
    {
        const auto it = _deadlinesUs.constFind(port);
        if (it == _deadlinesUs.cend()) {
            _deadlinesUs.insert(port, nowUs + std::chrono::duration_cast<std::chrono::microseconds>(
                                                  SerialPortManager::NEW_PORT_SETTLE_DELAY)
                                                  .count());
            return false;
        }
        return nowUs >= *it;
    }
 
    bool contains(const QString& port) const { return _deadlinesUs.contains(port); }
 
    bool isEmpty() const { return _deadlinesUs.isEmpty(); }
 
    void remove(const QString& port) { _deadlinesUs.remove(port); }
 
    template <typename Predicate>
    void removeIf(Predicate forget)
    {
        _deadlinesUs.removeIf([&forget](const auto& it) { return forget(it.key()); });
    }
 
    void clear() { _deadlinesUs.clear(); }
 
private:
    QMap<QString, quint64> _deadlinesUs;
};