scopedevice.h

Go to the documentation of this file.

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

#pragma once

#include <QMutex>
#include <QObject>
#include <QReadWriteLock>
#include <QStringList>

#ifdef Q_OS_FREEBSD
#include <libusb.h>
#else
#include <libusb-1.0/libusb.h>
#endif
#include <memory>

#include "models/modelDEMO.h"
#include "usbdevicedefinitions.h"

class DSOModel;

typedef uint64_t UniqueUSBid;


const QString libUsbErrorString( int error );


class ScopeDevice : public QObject {
    Q_OBJECT

  public:
    explicit ScopeDevice( DSOModel *model, libusb_device *device, unsigned findIteration = 0 );
    explicit ScopeDevice();
    ScopeDevice( const ScopeDevice & ) = delete;
    ~ScopeDevice();
    bool connectDevice( QString &errorMessage );
    void disconnectFromDevice();

    bool isConnected();

    bool isRealHW() const { return realHW; }
    bool isDemoDevice() const { return !realHW; }

    void stopSampling() { stopTransfer = true; }

    bool hasStopped() {
        bool stopped = stopTransfer;
        stopTransfer = false;
        return stopped;
    }

    bool needsFirmware();

    inline unsigned int getFwVersion() const { return descriptor.bcdDevice; }

    inline const QString getSerialNumber() const { return serialNumber; }


    QString readUSBdescriptor( libusb_device_handle *handle, uint8_t index );

    inline void setFindIteration( unsigned iteration ) { findIteration = iteration; }
    inline unsigned getFindIteration() const { return findIteration; }

    int bulkReadMulti( unsigned char *data, unsigned length, bool captureSmallBlocks, unsigned &received,
                       int attempts = HANTEK_ATTEMPTS_MULTI );

    int controlTransfer( unsigned char type, unsigned char request, unsigned char *data, unsigned int length, int value, int index,
                         int attempts = HANTEK_ATTEMPTS );

    template < class T > inline int controlWrite( const T *command ) {
        return controlTransfer( LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, uint8_t( command->code ),
                                const_cast< unsigned char * >( command->data() ), unsigned( command->size() ), command->value, 0,
                                HANTEK_ATTEMPTS );
    }

    template < class T > inline int controlRead( const T *command ) {
        return controlTransfer( LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, uint8_t( command->code ),
                                const_cast< unsigned char * >( command->data() ), unsigned( command->size() ), command->value, 0,
                                HANTEK_ATTEMPTS );
    }

    inline libusb_device *getUSBDevice() const { return device; }

    inline UniqueUSBid getUniqueUSBDeviceID() const { return uniqueUSBdeviceID; }
    static UniqueUSBid computeUSBdeviceID( libusb_device *device );

    inline const DSOModel *getModel() const { return model; }
    inline void overwriteInPacketLength( unsigned len ) { inPacketLength = len; }

  protected:
    int claimInterface( const libusb_interface_descriptor *interfaceDescriptor );

    // Device model data
    DSOModel *model;

    // Libusb specific variables
    struct libusb_device_descriptor descriptor;
    libusb_device *device; 
    libusb_device_handle *handle = nullptr;
    unsigned findIteration;
    const UniqueUSBid uniqueUSBdeviceID;
    int nInterface;
    unsigned outPacketLength; 
    unsigned inPacketLength;  

  private:
    int bulkTransfer( unsigned char endpoint, const unsigned char *data, unsigned int length, int attempts = HANTEK_ATTEMPTS,
                      unsigned int timeout = HANTEK_TIMEOUT );

    inline int bulkWrite( const unsigned char *data, unsigned int length, int attempts = HANTEK_ATTEMPTS ) {
        return bulkTransfer( HANTEK_EP_OUT, data, length, attempts );
    }

    template < class T > inline int bulkRead( const T *command, int attempts = HANTEK_ATTEMPTS ) {
        return bulkTransfer( HANTEK_EP_IN, command->data(), command->size(), attempts );
    }

    bool realHW = true;
    bool stopTransfer = false;
    bool disconnected = true;
    QString serialNumber = "0000";

  signals:
    void deviceDisconnected(); 
};

extern unsigned verboseLevel;