hantekdsocontrol.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
#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 "mathchannel.h"
#include "scopesettings.h"
#include "triggering.h"
#include "utils/printutils.h"
#include "viewconstants.h"
 
#include "hantekprotocol/controlStructs.h"
#include "hantekprotocol/definitions.h"
 
#include "dsomodel.h"
 
#include <vector>
 
#include <QSettings>
#include <QThread>
 
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, int verboseLevel );

    ~HantekDsoControl() override;

    void stateMachine();
 
    void stopStateMachine() { stateMachineRunning = false; }
 
    double getSamplerate() const { return controlsettings.samplerate.current; }
 
    unsigned getSamplesize() const {
        if ( controlsettings.trigger.mode == Dso::TriggerMode::ROLL )
            return SAMPLESIZE_ROLL;
        else
            return SAMPLESIZE;
    }
 
    bool isSamplingUI() const { return samplingUI; }

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

    void prepareForShutdown();
 
  private:
    std::unique_ptr< MathChannel > mathChannel;
    std::unique_ptr< Triggering > triggering;
    bool singleChannel = false;
    int 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; }
    bool replaceCalibrationEEPROM = false;
    Dso::ErrorCode getCalibrationValues();
    Dso::ErrorCode getCalibrationFromEEPROM();
    Dso::ErrorCode updateCalibrationValues( bool useEEPROM = false );
    Dso::ErrorCode writeCalibrationToEEPROM();

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

    void convertRawDataToSamples();

    void restoreTargets();

    void updateSamplerateLimits();
 
    void controlSetSamplerate( uint8_t sampleIndex );

    ControlCommand *control[ 255 ] = { nullptr };
    ControlCommand *firstControlCommand = nullptr;
 
    // Communication with device
    ScopeDevice *scopeDevice;  
    bool deviceNotConnected(); 
    bool samplingUI = 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 calibrationHasChanged = false;
    std::unique_ptr< QSettings > calibrationSettings;
    double offsetCorrection[ HANTEK_GAIN_STEPS ][ HANTEK_CHANNEL_NUMBER ];
    double gainCorrection[ HANTEK_GAIN_STEPS ][ HANTEK_CHANNEL_NUMBER ];
    bool capturing = false;
    bool samplingStarted = false;
    bool stateMachineRunning = false;
    int acquireInterval = 0;
    int displayInterval = 0;
    unsigned activeChannels = 2;
    bool refresh = false; // parameter changed -> new raw to result conversion and trigger search needed
    void requestRefresh( bool active = true ) { refresh = active; }
    bool refreshNeeded() {
        bool changed = refresh;
        refresh = false;
        return changed;
    }
    Raw raw;
    unsigned debugLevel = 0;
 
#define dprintf( level, fmt, ... )               \
    do {                                         \
        if ( debugLevel & level )                \
            fprintf( stderr, fmt, __VA_ARGS__ ); \
    } while ( 0 )
 
  public slots:
    void enableSamplingUI( bool enabled = true );

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

    void calibrateOffset( bool enable );
 
  signals:
    void showSamplingStatus( 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;
 
    void liveCalibrationError() const; // live calibration stopped due to noise or big offset
};
 
Q_DECLARE_METATYPE( DSOsamples * )