hantekdsocontrol.h

Go to the documentation of this file.

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

#pragma once

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

#include "controlsettings.h"
#include "scopesettings.h"
#include "controlspecification.h"
#include "dsosamples.h"
#include "errorcodes.h"
#include "states.h"
#include "viewconstants.h"
#include "utils/printutils.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:
    explicit HantekDsoControl( USBDevice *device );

    ~HantekDsoControl();

    void run();

    double getSamplerate() const { return controlsettings.samplerate.current; }

    unsigned getSamplesize() const { return SAMPLESIZE_USED; }

    bool isSampling() const { return sampling; }

    const USBDevice *getDevice() const { return device; }


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

    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 ) ] );
    }

    bool hasCommand(Hantek::ControlCode code) { return ( control[uint8_t(code)] != nullptr ); }

    const ControlCommand *getCommand(Hantek::ControlCode code) const { return control[ uint8_t( code ) ]; }

// Attic for no more used public procedures
#if 0
    unsigned getChannelCount() const { return specification->channels; }

    const Dso::ControlSettings *getDeviceSettings() const { return &controlsettings; }

    const std::vector<unsigned> &getAvailableRecordLengths() const {
        return controlsettings.samplerate.limits->recordLengths;
    }

    double getMinSamplerate() const {
        //printf( "getMinSamplerate\n" );
        return (double)specification->samplerate.single.base / specification->samplerate.single.maxDownsampler;
    }

    double getMaxSamplerate() const {
        //printf( "channelCount %d\n", controlsettings.channelCount );
        if (controlsettings.channelCount <= 1) {
            return specification->samplerate.multi.max;
        } else {
            return specification->samplerate.single.max;
        }
    }

    int getConnectionSpeed() const {
        ControlGetSpeed response;
        int errorCode = device->controlRead(&response);
        if (errorCode < 0) return errorCode;
        return response.getSpeed();
    }

    int getPacketSize() const {
        const int s = getConnectionSpeed();
        if (s == CONNECTION_FULLSPEED)
            return 64;
        else if (s == CONNECTION_HIGHSPEED)
            return 512;
        else if (s > CONNECTION_HIGHSPEED) {
            qWarning() << "Unknown USB speed. Please correct source code in USBDevice::getPacketSize()";
            throw new std::runtime_error("Unknown USB speed");
        } else if (s < 0)
            return s;
        return 0;
    }

    const DSOsamples &getLastSamples() { return result; }
#endif

  private:
    bool isFastRate() const {
        return controlsettings.voltage[0].used && !controlsettings.voltage[1].used;
    }

    unsigned getRecordLength() const;

    void setDownsampling( unsigned downsampling ) { downsamplingNumber = downsampling; }

    Dso::ErrorCode retrieveChannelLevelData();

    unsigned getSampleCount() const {
        return isFastRate() ? getRecordLength() : getRecordLength() * specification->channels;
    }

    void updateInterval();

    static unsigned calculateTriggerPoint(unsigned value);

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

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

    unsigned updateSamplerate(unsigned downsampler, bool fastRate);

    void restoreTargets();

    void updateSamplerateLimits();

    unsigned searchTriggerPoint( Dso::Slope dsoSlope, unsigned int startPos = 0 );

    Dso::Slope mirrorSlope( Dso::Slope slope ) {
        return ( slope == Dso::Slope::Positive ? Dso::Slope::Negative : Dso::Slope::Positive );
    }

    unsigned softwareTrigger();

    bool triggering();

    ControlCommand *control[255] = { nullptr };
    ControlCommand *firstControlCommand = nullptr;

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

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

    // Results
    unsigned downsamplingNumber = 1;        
    DSOsamples result;
    unsigned expectedSampleCount = 0; 
    bool samplingStarted = false;
    int acquireInterval = 0;
    int displayInterval = 0;
    bool channelSetupChanged = false;
    unsigned triggeredPositionRaw = 0; // not triggered

  public slots:
    void enableSampling(bool enabled);

    Dso::ErrorCode setSamplerate(double samplerate = 0.0);

    Dso::ErrorCode setRecordTime(double duration = 0.0);

    Dso::ErrorCode setChannelUsed(ChannelID channel, bool used);

    Dso::ErrorCode setChannelInverted(ChannelID channel, bool inverted);

    Dso::ErrorCode setProbe(ChannelID channel, double probeAttn);

    Dso::ErrorCode setGain(ChannelID channel, double gain);

    Dso::ErrorCode setCoupling(ChannelID channel, Dso::Coupling coupling);

    Dso::ErrorCode setTriggerMode(Dso::TriggerMode mode);

    Dso::ErrorCode setTriggerSource(ChannelID channel, bool smooth);

    Dso::ErrorCode setTriggerLevel(ChannelID channel, double level);

    Dso::ErrorCode setTriggerSlope(Dso::Slope slope);

    Dso::ErrorCode setTriggerOffset (double position);

    Dso::ErrorCode setCalFreq(double calfreq = 0.0);

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

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

    void recordTimeChanged(double duration);          
    void samplerateChanged(double samplerate);        

    void communicationError() const;
};

Q_DECLARE_METATYPE(DSOsamples *)