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 *)