hantekdsocontrol.h

// SPDX-License-Identifier: GPL-2.0+

#pragma once

#define NOMINMAX // disable windows.h min/max global methods
#include <limits>

#include "controlsettings.h"
#include "controlspecification.h"
#include "dsosamples.h"
#include "errorcodes.h"
#include "states.h"
#include "utils/printutils.h"

#include "hantekprotocol/bulkStructs.h"
#include "hantekprotocol/controlStructs.h"
#include "hantekprotocol/definitions.h"

#include <vector>

#include <QMutex>
#include <QStringList>
#include <QThread>
#include <QTimer>

class USBDevice;

class HantekDsoControl : public QObject {
    Q_OBJECT

  public:
    HantekDsoControl(USBDevice *device);

    ~HantekDsoControl();

    void run();

    unsigned getChannelCount() const;

    const Dso::ControlSettings *getDeviceSettings() const;

    const std::vector<unsigned> &getAvailableRecordLengths() const;

    double getMinSamplerate() const;

    double getMaxSamplerate() const;

    bool isSampling() const;

    const USBDevice *getDevice() const;

    int getConnectionSpeed() const;

    int getPacketSize() const;

    const DSOsamples &getLastSamples();

    Dso::ErrorCode stringCommand(const QString &commandString);

    void addCommand(BulkCommand *newCommand, bool pending = true);
    template <class T> T *modifyCommand(Hantek::BulkCode code) {
        command[(uint8_t)code]->pending = true;
        return static_cast<T *>(command[(uint8_t)code]);
    }
    const BulkCommand *getCommand(Hantek::BulkCode code) const;

    void addCommand(ControlCommand *newCommand, bool pending = true);
    template <class T> T *modifyCommand(Hantek::ControlCode code) {
        control[(uint8_t)code]->pending = true;
        return static_cast<T *>(control[(uint8_t)code]);
    }
    const ControlCommand *getCommand(Hantek::ControlCode code) const;

  private:
    bool isRollMode() const;
    bool isFastRate() const;
    unsigned getRecordLength() const;

    Dso::ErrorCode retrieveChannelLevelData();

    double getBestSamplerate(double samplerate, bool fastRate = false, bool maximum = false,
                             unsigned *downsampler = 0) const;

    unsigned getSampleCount() const;

    void updateInterval();

    static unsigned calculateTriggerPoint(unsigned value);

    std::pair<int, unsigned> getCaptureState() const;

    std::vector<unsigned char> getSamples(unsigned &expectedSampleCount) const;

    void convertRawDataToSamples(const std::vector<unsigned char> &rawData);

    unsigned updateRecordLength(RecordLengthID size);

    unsigned updateSamplerate(unsigned downsampler, bool fastRate);

    void restoreTargets();

    void updateSamplerateLimits();

  private:
    BulkCommand *command[255] = {0};
    BulkCommand *firstBulkCommand = nullptr;
    ControlCommand *control[255] = {0};
    ControlCommand *firstControlCommand = nullptr;

    // Communication with device
    USBDevice *device;     
    bool sampling = false; 

    // Device setup
    const Dso::ControlSpecification *specification; 
    Dso::ControlSettings controlsettings;           

    // Results
    DSOsamples result;
    unsigned expectedSampleCount = 0; 

    // State of the communication thread
    int captureState = Hantek::CAPTURE_WAITING;
    Hantek::RollState rollState = Hantek::RollState::STARTSAMPLING;
    bool _samplingStarted = false;
    Dso::TriggerMode lastTriggerMode = (Dso::TriggerMode)-1;
    int cycleCounter = 0;
    int startCycle = 0;
    int cycleTime = 0;

    int bulkCommand(const std::vector<unsigned char> *command, int attempts = HANTEK_ATTEMPTS) const;

  public slots:
    void enableSampling(bool enabled);

    Dso::ErrorCode setRecordLength(unsigned size);
    Dso::ErrorCode setSamplerate(double samplerate = 0.0);
    Dso::ErrorCode setRecordTime(double duration = 0.0);

    Dso::ErrorCode setChannelUsed(ChannelID channel, bool used);
    Dso::ErrorCode setCoupling(ChannelID channel, Dso::Coupling coupling);
    Dso::ErrorCode setGain(ChannelID channel, double gain);
    Dso::ErrorCode setOffset(ChannelID channel, const double offset);

    Dso::ErrorCode setTriggerMode(Dso::TriggerMode mode);
    Dso::ErrorCode setTriggerSource(bool special, unsigned id);
    Dso::ErrorCode setTriggerLevel(ChannelID channel, double level);
    Dso::ErrorCode setTriggerSlope(Dso::Slope slope);
    Dso::ErrorCode setPretriggerPosition(double position);
    void forceTrigger();

  signals:
    void samplingStatusChanged(bool enabled); 
    void statusMessage(const QString &message, int timeout); 
    void samplesAvailable(const DSOsamples *samples);        

    void availableRecordLengthsChanged(const std::vector<unsigned> &recordLengths); 

    void samplerateLimitsChanged(double minimum, double maximum);
    void samplerateSet(int mode, QList<double> sampleSteps);

    void recordLengthChanged(unsigned long duration); 
    void recordTimeChanged(double duration);          
    void samplerateChanged(double samplerate);        

    void communicationError() const;
};

Q_DECLARE_METATYPE(DSOsamples *)