GPSCommandChannel.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <span>
#include <variant>
#include <vector>
 
#include <QtCore/QByteArrayView>
#include <QtCore/QString>
 
#include "GPSCommand.h"
#include "GPSDeadline.h"
#include "GPSFamilyProtocol.h"
#include "GPSProtocolEvent.h"
 
class GPSCommandChannel;
class GPSDecodeContext;
class GPSProtocolRuntime;
class GPSStreamDemux;
 
enum class [[nodiscard]] GPSBaudStatus
{
    Configured,
    Unsupported,
    Cancelled,
    Error
};
 
enum class GPSBaudProbe
{
    Found,
    TryNext,
    Stop,
};
 
struct GPSBaudDetection
{
    bool found = false;
    unsigned baud = 0;
    bool linkFailed = false;
    std::vector<unsigned> probed{};
};
 
[[nodiscard]] QString gpsRateList(std::span<const unsigned> rates);
 
using GPSBaudProbeFunction = std::function<GPSBaudProbe()>;
 
class [[nodiscard]] GPSDeadlineScope
{
public:
    GPSDeadlineScope(GPSCommandChannel& channel, std::chrono::milliseconds timeout);
    GPSDeadlineScope(GPSCommandChannel& channel, GPSDeadline deadline);
    ~GPSDeadlineScope();
 
    Q_DISABLE_COPY(GPSDeadlineScope)
 
private:
    void _limitUntil(uint64_t untilUs);
 
    GPSCommandChannel& _channel;
    GPSDeadline _previous;
};
 
class GPSCommandChannel
{
public:
    static constexpr size_t READ_CHUNK_SIZE = 150;
    static constexpr std::chrono::milliseconds SERVICE_TIMEOUT{5000};
 
    Q_DISABLE_COPY(GPSCommandChannel)
 
    // Clock and deadlines
 
    [[nodiscard]] uint64_t nowUs() const;
 
    [[nodiscard]] GPSDeadline operationDeadline() const { return _operationDeadline; }
 
    [[nodiscard]] GPSDeadline commandDeadline() const { return _commandDeadline; }
 
    [[nodiscard]] GPSDeadlineScope deadlineScope(std::chrono::milliseconds timeout) { return {*this, timeout}; }
 
    [[nodiscard]] GPSDeadlineScope deadlineScope(GPSDeadline deadline) { return {*this, deadline}; }
 
    // Sticky failure
 
    [[nodiscard]] bool failed() const { return _error != GPSProtocolError::None; }
 
    [[nodiscard]] GPSProtocolError error() const { return _error; }
 
    [[nodiscard]] const QString& errorDetail() const { return _errorDetail; }
 
    void setErrorDetail(const QString& detail) { _errorDetail = detail; }
 
    void failControl(GPSProtocolError failure = GPSProtocolError::Protocol);
 
    void failControl(const QString& detail);
 
    void failSequence(const GPSCommandSequence::Result& result);
 
    void failNoAnswer(std::span<const unsigned> rates);
 
    [[nodiscard]] GPSCommandOutcome failureOutcome() const;
 
    // Command evidence
 
    void beginCommand(GPSConfigurationStep step);
 
    GPSConfigurationEvidence completeCommand(GPSCommandOutcome outcome);
 
    void finishCommand(GPSCommandOutcome outcome) { (void) completeCommand(outcome); }
 
    [[nodiscard]] const GPSConfigurationEvidence& currentCommand() const { return _command; }
 
    // Blocking operations
 
    int read(std::span<uint8_t> buffer, std::chrono::milliseconds timeout);
 
    bool write(QByteArrayView bytes);
 
    bool setBaudrate(unsigned baudrate);
 
    void wait(std::chrono::microseconds duration);
 
    // Commands
 
    bool writeCommand(GPSConfigurationStep step, QByteArrayView bytes);
 
    GPSConfigurationEvidence awaitReply(GPSReplyPoll reply);
 
    GPSConfigurationEvidence transact(GPSConfigurationStep step, QByteArrayView bytes)
    {
        return _transact(std::move(step), bytes, std::monostate{});
    }
 
    GPSConfigurationEvidence transact(GPSConfigurationStep step, QByteArrayView bytes, GPSTextMatcher reply)
    {
        return _transact(std::move(step), bytes, std::move(reply));
    }
 
    GPSConfigurationEvidence transact(GPSConfigurationStep step, QByteArrayView bytes, GPSFrameMatcher reply)
    {
        return _transact(std::move(step), bytes, std::move(reply));
    }
 
    GPSConfigurationEvidence transact(const GPSCommandSequence::Command& command);
 
    GPSCommandSequence::Result runSequence(const GPSCommandSequence& sequence);
 
    [[nodiscard]] bool runRequired(const GPSCommandSequence& sequence);
 
    GPSBaudDetection detectBaud(std::span<const unsigned> candidates, unsigned baud, GPSBaudProbeFunction probe);
 
    // Receiving
 
    GPSReceiveUpdates receiveCycle(std::chrono::milliseconds timeout);
 
    void receiveFor(std::chrono::milliseconds duration);
 
    bool receiveUntil(std::function<bool()> done, std::chrono::milliseconds duration);
 
    void serviceControls();
 
    // Decoding without I/O
 
    GPSReceiveUpdates flush();
 
    [[nodiscard]] GPSStreamDemux& stream();
 
    [[nodiscard]] GPSDecodeContext& context();
 
    [[nodiscard]] GPSLogCategory logCategory() const;
 
private:
    friend class GPSDeadlineScope;
    friend class GPSDecodeContext;
    friend class GPSProtocolRuntime;
 
    using ReplyMatcher = std::variant<std::monostate, GPSRawAckMatcher*, GPSTextMatcher, GPSFrameMatcher>;
 
    explicit GPSCommandChannel(GPSProtocolRuntime& runtime);
 
    [[nodiscard]] bool _replyPending() const { return _reply == GPSCommandOutcome::Pending; }
 
    void _resolveReply(GPSCommandOutcome outcome)
    {
        if (_replyPending()) {
            _reply = outcome;
        }
    }
 
    [[nodiscard]] GPSConfigurationEvidence _failedAttempt(GPSConfigurationStep step) const;
 
    GPSBaudStatus _setBaudrate(unsigned baudrate);
 
    GPSReceiveUpdates _readAndDecode(std::chrono::milliseconds timeout);
 
    [[nodiscard]] QString _commandFailure(const QByteArray& label, GPSCommandOutcome outcome) const;
    void _describeFailure();
    GPSConfigurationEvidence _transact(GPSConfigurationStep step, QByteArrayView bytes, ReplyMatcher matcher);
    void _clearReply();
    void _resetError();
    void _offerText(std::string_view reply);
    void _offerFrame(const GPSFrame& frame);
    void _offerRaw(std::span<const uint8_t> bytes);
 
    GPSProtocolRuntime& _runtime;
    GPSProtocolError _error = GPSProtocolError::None;
    QString _errorDetail;
    GPSDeadline _operationDeadline;
    bool _commandCompleted = true;
    GPSConfigurationEvidence _command;
    GPSDeadline _commandDeadline;
    std::optional<GPSCommandOutcome> _reply;
    ReplyMatcher _replyMatcher;
    unsigned _detectedBaud = 0;
    bool _servicingControls = false;
};