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 "controlspecification.h"
#include "dsosamples.h"
#include "errorcodes.h"
#include "scopesettings.h"
#include "utils/printutils.h"
#include "viewconstants.h"

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

#include "dsomodel.h"

#include <vector>

#include <QMutex>
#include <QReadLocker>
#include <QReadWriteLock>
#include <QStringList>
#include <QThread>
#include <QTimer>
#include <QWriteLocker>

class Capturing;
class ScopeDevice;

struct Raw {
    unsigned channels = 0;
    double samplerate = 0;
    unsigned oversampling = 0;
    unsigned gainValue[ 2 ] = { 1, 1 }; // 1,2,5,10,..
    unsigned gainIndex[ 2 ] = { 7, 7 }; // index 0..7
    unsigned tag = 0;
    bool freeRun = false;  // small buffer, no trigger
    bool valid = false;    // samples can be processed
    bool rollMode = false; // one complete buffer received, start to roll
    unsigned size = 0;
    unsigned received = 0;
    std::vector< unsigned char > data;
    mutable QReadWriteLock lock;
};


class HantekDsoControl : public QObject {
    Q_OBJECT
    friend Capturing;

  public:
    explicit HantekDsoControl( ScopeDevice *scopeDevice, const DSOModel *model, unsigned verboseLevel );

    ~HantekDsoControl();

    void stateMachine();

    void stopStateMachine() { stateMachineRunning = false; }

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

    static const unsigned SAMPLESIZE = 20000;
    static const unsigned SAMPLESIZE_ROLL = 39 * 256;
    unsigned getSamplesize() const {
        if ( controlsettings.trigger.mode == Dso::TriggerMode::ROLL )
            return SAMPLESIZE_ROLL;
        else
            return SAMPLESIZE;
    }

    bool isSampling() const { return sampling; }

    const ScopeDevice *getDevice() const { return scopeDevice; }

    const DSOModel *getModel() const { return model; }


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

    void quitSampling();

  private:
    bool singleChannel = false;
    unsigned verboseLevel = 0;
    void setSingleChannel( bool single ) { singleChannel = single; }
    bool isSingleChannel() const { return singleChannel; }
    bool triggerModeNONE() { return controlsettings.trigger.mode == Dso::TriggerMode::ROLL; }
    unsigned getRecordLength() const;
    void setDownsampling( unsigned downsampling ) { downsamplingNumber = downsampling; }
    Dso::ErrorCode retrieveChannelLevelData();

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

    unsigned grossSampleCount( unsigned net ) const { return ( ( net + 1024 ) / 1024 + 2 ) * 1024; }

    unsigned netSampleCount( unsigned gross ) const { return ( ( gross - 1024 ) / 1000 - 1 ) * 1000; }

    void updateInterval();

    static unsigned calculateTriggerPoint( unsigned value );

    // void capture( HantekDsoControl *hdc );

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

    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 searchTriggeredPosition();

    bool provideTriggeredData();

    void controlSetSamplerate( uint8_t sampleIndex );

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

    // Communication with device
    ScopeDevice *scopeDevice;  
    bool deviceNotConnected(); 
    bool sampling = false;     

    // Device setup
    const DSOModel *model;                          
    const Dso::ControlSpecification *specification; 
    Dso::ControlSettings controlsettings;           
    const DsoSettingsScope *scope = nullptr;        

    // Results
    unsigned downsamplingNumber = 1; 
    DSOsamples result;
    unsigned expectedSampleCount = 0; 
    bool capturing = false;
    bool samplingStarted = false;
    bool stateMachineRunning = false;
    int acquireInterval = 0;
    int displayInterval = 0;
    unsigned triggeredPositionRaw = 0; // not triggered
    unsigned activeChannels = 2;
    bool newTriggerParam = false; // parameter changed -> new trigger search needed
    bool triggerChanged() {
        bool changed = newTriggerParam;
        newTriggerParam = false;
        return changed;
    }

    Raw raw;

    std::vector< QString > controlNames = { "SETGAIN_CH1",    "SETGAIN_CH2", "SETSAMPLERATE", "STARTSAMPLING",
                                            "SETNUMCHANNELS", "SETCOUPLING", "SETCALFREQ" };

    unsigned debugLevel = 0;

#define dprintf( level, fmt, ... )               \
    do {                                         \
        if ( debugLevel & level )                \
            fprintf( stderr, fmt, __VA_ARGS__ ); \
    } while ( 0 )

  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( int channel );

    Dso::ErrorCode setTriggerSmooth( int smooth );

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

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

    Dso::ErrorCode setTriggerPosition( double position );

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

    void applySettings( DsoSettingsScope *scope );

    void restartSampling();

  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 samplerateChanged( double samplerate ); 

    void communicationError() const;
};

Q_DECLARE_METATYPE( DSOsamples * )