Move all control command structs back to controlstructs. Move control functional…

…ity from usb device into hantekdsocontrol. Remove fixed HANTEK_CHANNELS definitions. We allow an arbitray number of channels, depending on the device.

Move all control command structs back to controlstructs. Move control functional…
…ity from usb device into hantekdsocontrol. Remove fixed HANTEK_CHANNELS definitions. We allow an arbitray number of channels, depending on the device.
David Graeff · David Gräff
1 parent dcd2a3c4
Showing 24 changed files with 300 additions and 336 deletions
openhantek/src/hantekdso/controlsettings.cpp
openhantek/src/hantekdso/controlsettings.h
openhantek/src/hantekdso/controlspecification.cpp
openhantek/src/hantekdso/controlspecification.h
openhantek/src/hantekdso/enums.cpp
openhantek/src/hantekdso/enums.h
openhantek/src/hantekdso/hantekdsocontrol.cpp
openhantek/src/hantekdso/hantekdsocontrol.h
openhantek/src/hantekdso/models/modelDSO2090.cpp
openhantek/src/hantekdso/models/modelDSO2150.cpp
openhantek/src/hantekdso/models/modelDSO2250.cpp
openhantek/src/hantekdso/models/modelDSO5200.cpp
openhantek/src/hantekdso/models/modelDSO6022.cpp
openhantek/src/hantekprotocol/bulkStructs.h
openhantek/src/hantekprotocol/controlStructs.cpp
openhantek/src/hantekprotocol/controlStructs.h
openhantek/src/hantekprotocol/definitions.h
openhantek/src/hantekprotocol/types.h
openhantek/src/usb/controlbegin.cpp
openhantek/src/usb/controlbegin.h
 #include "controlsettings.h"
+#include "hantekprotocol/definitions.h"
 namespace Dso {
@@ -7,13 +8,12 @@ ControlSettings::ControlSettings(ControlSamplerateLimits* limits, size_t channel
     samplerate.limits = limits;
     trigger.level.resize(channelCount);
     voltage.resize(channelCount);
-    for (ChannelID channel = 0; channel < channelCount; ++channel) {
-        trigger.level[channel] = 0.0;
-        voltage[channel].gain = 0;
-        voltage[channel].offset = 0.0;
-        voltage[channel].offsetReal = 0.0;
-        voltage[channel].used = false;
-    }
+    offsetLimit = new Hantek::OffsetsPerGainStep[channelCount];
+}
+
+ControlSettings::~ControlSettings()
+{
+    delete [] offsetLimit;
 }
 }
 #pragma once
-#include "controlspecification.h"
 #include "enums.h"
+#include "hantekprotocol/types.h"
+
+namespace Hantek {
+struct OffsetsPerGainStep;
+}
 namespace Dso {
 struct ControlSamplerateLimits;
-//////////////////////////////////////////////////////////////////////////////
-/// \struct ControlSettingsSamplerateTarget                   hantek/control.h
 /// \brief Stores the target samplerate settings of the device.
 struct ControlSettingsSamplerateTarget {
     double samplerate; ///< The target samplerate set via setSamplerate
@@ -16,8 +18,6 @@ struct ControlSettingsSamplerateTarget {
     enum SamplerrateSet { Duration, Samplerrate } samplerateSet;
 };
-//////////////////////////////////////////////////////////////////////////////
-/// \struct ControlSettingsSamplerate                         hantek/control.h
 /// \brief Stores the current samplerate settings of the device.
 struct ControlSettingsSamplerate {
     ControlSettingsSamplerateTarget target; ///< The target samplerate values
@@ -26,39 +26,35 @@ struct ControlSettingsSamplerate {
     double current = 1e8;                   ///< The current samplerate
 };
-//////////////////////////////////////////////////////////////////////////////
-/// \struct ControlSettingsTrigger                            hantek/control.h
 /// \brief Stores the current trigger settings of the device.
 struct ControlSettingsTrigger {
-    std::vector<double> level;                        ///< The trigger level for each channel in V
-    double position = 0.0;                            ///< The current pretrigger position
-    unsigned int point = 0;                           ///< The trigger position in Hantek coding
+    std::vector<double> level;                                   ///< The trigger level for each channel in V
+    double position = 0.0;                                       ///< The current pretrigger position
+    unsigned int point = 0;                                      ///< The trigger position in Hantek coding
     Dso::TriggerMode mode = Dso::TriggerMode::HARDWARE_SOFTWARE; ///< The trigger mode
-    Dso::Slope slope = Dso::Slope::Positive;          ///< The trigger slope
-    bool special = false;                             ///< true, if the trigger source is special
-    unsigned int source = 0;                          ///< The trigger source
+    Dso::Slope slope = Dso::Slope::Positive;                     ///< The trigger slope
+    bool special = false;                                        ///< true, if the trigger source is special
+    unsigned int source = 0;                                     ///< The trigger source
 };
-//////////////////////////////////////////////////////////////////////////////
-/// \struct ControlSettingsVoltage                            hantek/control.h
 /// \brief Stores the current amplification settings of the device.
 struct ControlSettingsVoltage {
-    double offset;     ///< The screen offset for each channel
-    double offsetReal; ///< The real offset for each channel (Due to quantization)
-    unsigned gain;     ///< The gain id
-    bool used;         ///< true, if the channel is used
+    double offset = 0.0;     ///< The screen offset for each channel
+    double offsetReal = 0.0; ///< The real offset for each channel (Due to quantization)
+    unsigned gain = 0;       ///< The gain id
+    bool used = false;       ///< true, if the channel is used
 };
-//////////////////////////////////////////////////////////////////////////////
-/// \struct ControlSettings                                   hantek/control.h
 /// \brief Stores the current settings of the device.
 struct ControlSettings {
     ControlSettings(ControlSamplerateLimits *limits, size_t channelCount);
+    ~ControlSettings();
     ControlSettingsSamplerate samplerate;        ///< The samplerate settings
     std::vector<ControlSettingsVoltage> voltage; ///< The amplification settings
     ControlSettingsTrigger trigger;              ///< The trigger settings
     RecordLengthID recordLengthId = 1;           ///< The id in the record length array
     unsigned usedChannels = 0;                   ///< Number of activated channels
     unsigned swSampleMargin = 2000;              ///< Software trigger, sample margin
+    Hantek::OffsetsPerGainStep *offsetLimit;     ///< Calibration data for the channel offsets
 };
 }
+#include "controlspecification.h"
+
+Dso::ControlSpecification::ControlSpecification(unsigned channels) : channels(channels), cmdGetLimits(channels)
+{
+    voltageLimit.resize(channels);
+}
@@ -4,8 +4,7 @@
 #include "enums.h"
 #include "hantekprotocol/bulkcode.h"
-#include "hantekprotocol/controlcode.h"
-#include "hantekprotocol/controlvalue.h"
+#include "hantekprotocol/controlStructs.h"
 #include "hantekprotocol/definitions.h"
 #include <QList>
@@ -13,22 +12,6 @@ namespace Dso {
 using namespace Hantek;
-/// \brief Stores the bulk command codes used for this device.
-struct ControlSpecificationCommandsBulk {
-    BulkCode setChannels = BulkCode::INVALID;     ///< Command for setting used channels
-    BulkCode setSamplerate = BulkCode::INVALID;   ///< Command for samplerate settings
-    BulkCode setGain = BulkCode::SETGAIN;         ///< Command for gain settings (Usually in combination with
-                                                  /// CONTROL_SETRELAYS)
-    BulkCode setRecordLength = BulkCode::INVALID; ///< Command for buffer settings
-    BulkCode setTrigger = BulkCode::INVALID;      ///< Command for trigger settings
-    BulkCode setPretrigger = BulkCode::INVALID;   ///< Command for pretrigger settings
-};
-
-/// \brief Stores the command codes used for this device.
-struct ControlSpecificationCommands {
-    ControlSpecificationCommandsBulk bulk; ///< The used bulk commands
-};
-
 /// \brief Stores the samplerate limits for calculations.
 struct ControlSamplerateLimits {
     double base;                         ///< The base for sample rate calculations
@@ -62,32 +45,47 @@ struct SpecialTriggerChannel {
 /// \brief Stores the specifications of the currently connected device.
 struct ControlSpecification {
-    ChannelID channels = HANTEK_CHANNELS;
+    ControlSpecification(unsigned channels);
+    const ChannelID channels;
     // Interface
-    ControlSpecificationCommands command; ///< The commands for this device
+    BulkCode cmdSetChannels = BulkCode::INVALID;             ///< Command for setting used channels
+    BulkCode cmdSetSamplerate = BulkCode::INVALID;           ///< Command for samplerate settings
+    BulkCode cmdSetRecordLength = BulkCode::INVALID;         ///< Command for buffer settings
+    BulkCode cmdSetTrigger = BulkCode::INVALID;              ///< Command for trigger settings
+    BulkCode cmdSetPretrigger = BulkCode::INVALID;           ///< Command for pretrigger settings
+    BulkCode cmdForceTrigger = BulkCode::FORCETRIGGER;       ///< Command for forcing a trigger event
+    BulkCode cmdCaptureStart = BulkCode::STARTSAMPLING;      ///< Command for starting the sampling
+    BulkCode cmdTriggerEnabled = BulkCode::ENABLETRIGGER;    ///< Command for enabling the trigger
+    BulkCode cmdGetData = BulkCode::GETDATA;                 ///< Command for retrieve sample data
+    BulkCode cmdGetCaptureState = BulkCode::GETCAPTURESTATE; ///< Command for retrieve the capture state
+    BulkCode cmdSetGain = BulkCode::SETGAIN;                    ///< Command for setting the gain
+
+    ControlBeginCommand beginCommandControl;
+    ControlGetLimits cmdGetLimits;
     // Limits
     ControlSpecificationSamplerate samplerate;  ///< The samplerate specifications
     std::vector<RecordLengthID> bufferDividers; ///< Samplerate dividers for record lengths
     unsigned char sampleSize;                   ///< Number of bits per sample
+    /// For devices that support only fixed sample rates (isFixedSamplerateDevice=true)
+    std::vector<FixedSampleRate> fixedSampleRates;
+
     // Calibration
+
     /// The sample values at the top of the screen
-    std::vector<unsigned short> voltageLimit[HANTEK_CHANNELS];
-    /// Calibration data for the channel offsets
-    OffsetsPerGainStep offsetLimit[HANTEK_CHANNELS];
+    typedef std::vector<unsigned short> VoltageLimit;
+    std::vector<VoltageLimit> voltageLimit; // Per channel
     /// Gain levels
     std::vector<ControlSpecificationGainLevel> gain;
-    /// For devices that support only fixed sample rates (isFixedSamplerateDevice=true)
-    std::vector<FixedSampleRate> fixedSampleRates;
-
+    // Features
     std::vector<SpecialTriggerChannel> specialTriggerChannels;
     std::vector<Coupling> couplings = {Dso::Coupling::DC, Dso::Coupling::AC};
-    std::vector<TriggerMode> triggerModes = {TriggerMode::HARDWARE_SOFTWARE, TriggerMode::WAIT_FORCE, TriggerMode::SINGLE};
-
+    std::vector<TriggerMode> triggerModes = {TriggerMode::HARDWARE_SOFTWARE, TriggerMode::WAIT_FORCE,
+                                             TriggerMode::SINGLE};
     bool isFixedSamplerateDevice = false;
     bool isSoftwareTriggerDevice = false;
     bool useControlNoBulk = false;
@@ -4,5 +4,4 @@ namespace Dso {
     Enum<Dso::TriggerMode, Dso::TriggerMode::HARDWARE_SOFTWARE, Dso::TriggerMode::SINGLE> TriggerModeEnum;
     Enum<Dso::Slope, Dso::Slope::Positive, Dso::Slope::Negative> SlopeEnum;
     Enum<Dso::GraphFormat, Dso::GraphFormat::TY, Dso::GraphFormat::XY> GraphFormatEnum;
-    Enum<Dso::ChannelMode, Dso::ChannelMode::Voltage, Dso::ChannelMode::Spectrum> ChannelModeEnum;
 }
@@ -9,8 +9,6 @@ enum class ChannelMode {
     Voltage, ///< Standard voltage view
     Spectrum ///< Spectrum view
 };
-constexpr int ChannelModes = 2;
-extern Enum<Dso::ChannelMode, Dso::ChannelMode::Voltage, Dso::ChannelMode::Spectrum> ChannelModeEnum;
 /// \enum GraphFormat
 /// \brief The possible viewing formats for the graphs on the scope.
@@ -49,7 +49,7 @@ void HantekDsoControl::stopSampling() {
     emit samplingStopped();
 }
-USBDevice *HantekDsoControl::getDevice() { return device; }
+const USBDevice *HantekDsoControl::getDevice() const { return device; }
 const DSOsamples &HantekDsoControl::getLastSamples() { return result; }
@@ -58,9 +58,7 @@ HantekDsoControl::HantekDsoControl(USBDevice *device)
       controlsettings(&(specification.samplerate.single), specification.channels) {
     if (device == nullptr) throw new std::runtime_error("No usb device for HantekDsoControl");
-    if (specification.useControlNoBulk) {
-        device->setEnableBulkTransfer(false);
-    }
+    qRegisterMetaType<DSOsamples *>();
     if (specification.fixedUSBinLength)
     device->overwriteInPacketLength(specification.fixedUSBinLength);
@@ -84,6 +82,17 @@ HantekDsoControl::~HantekDsoControl() {
     }
 }
+int HantekDsoControl::bulkCommand(const DataArray<unsigned char> *command, int attempts) const {
+    if (specification.useControlNoBulk) return LIBUSB_SUCCESS;
+
+    // Send BeginCommand control command
+    int errorCode = device->controlWrite(&specification.beginCommandControl);
+    if (errorCode < 0) return errorCode;
+
+    // Send bulk command
+    return device->bulkWrite(command->data(), command->getSize(), attempts);
+}
+
 unsigned HantekDsoControl::getChannelCount() { return specification.channels; }
 const ControlSettings *HantekDsoControl::getDeviceSettings() const { return &controlsettings; }
@@ -107,7 +116,7 @@ void HantekDsoControl::updateInterval() {
     // Check the current oscilloscope state everytime 25% of the time the buffer
     // should be refilled
     if (isRollMode())
-        cycleTime = (int)((double)device->getPacketSize() / (isFastRate() ? 1 : specification.channels) /
+        cycleTime = (int)((double)getPacketSize() / (isFastRate() ? 1 : specification.channels) /
                           controlsettings.samplerate.current * 250);
     else
         cycleTime = (int)((double)getRecordLength() / controlsettings.samplerate.current * 250);
@@ -130,16 +139,16 @@ unsigned HantekDsoControl::getRecordLength() const {
 Dso::ErrorCode HantekDsoControl::retrieveChannelLevelData() {
     // Get channel level data
-    ControlGetLimits c(2);
-    int errorCode =
-        device->controlRead(&c);
+    int errorCode = device->controlRead(&specification.cmdGetLimits);
     if (errorCode < 0) {
         qWarning() << tr("Couldn't get channel level data from oscilloscope");
         emit statusMessage(tr("Couldn't get channel level data from oscilloscope"), 0);
         emit communicationError();
         return Dso::ErrorCode::CONNECTION;
     }
-    memcpy(specification.offsetLimit,c.offsetLimit,sizeof(specification.offsetLimit));
+
+    memcpy(controlsettings.offsetLimit, specification.cmdGetLimits.offsetLimit,
+           sizeof(OffsetsPerGainStep)*specification.channels);
     return Dso::ErrorCode::NONE;
 }
@@ -159,14 +168,14 @@ std::pair&lt;int, unsigned&gt; HantekDsoControl::getCaptureState() const {
     if (!specification.supportsCaptureState) return std::make_pair(CAPTURE_READY, 0);
-    errorCode = device->bulkCommand(getCommand(BulkCode::GETCAPTURESTATE), 1);
+    errorCode = bulkCommand(getCommand(BulkCode::GETCAPTURESTATE), 1);
     if (errorCode < 0) {
         qWarning() << "Getting capture state failed: " << libUsbErrorString(errorCode);
         return std::make_pair(CAPTURE_ERROR, 0);
     }
     BulkResponseGetCaptureState response;
-    errorCode = device->bulkRead(response.data(), response.getSize());
+    errorCode = device->bulkRead(&response);
     if (errorCode < 0) {
         qWarning() << "Getting capture state failed: " << libUsbErrorString(errorCode);
         return std::make_pair(CAPTURE_ERROR, 0);
@@ -179,7 +188,7 @@ std::vector&lt;unsigned char&gt; HantekDsoControl::getSamples(unsigned &amp;previousSample
     int errorCode;
     if (!specification.useControlNoBulk) {
         // Request data
-        errorCode = device->bulkCommand(getCommand(BulkCode::GETDATA), 1);
+        errorCode = bulkCommand(getCommand(BulkCode::GETDATA), 1);
     } else {
         errorCode = device->controlWrite(getCommand(ControlCode::CONTROL_ACQUIIRE_HARD_DATA));
     }
@@ -345,7 +354,7 @@ double HantekDsoControl::getBestSamplerate(double samplerate, bool fastRate, boo
         bestDownsampler = 0.0;
         bestSamplerate = limits->max / specification.bufferDividers[controlsettings.recordLengthId];
     } else {
-        switch (specification.command.bulk.setSamplerate) {
+        switch (specification.cmdSetSamplerate) {
         case BulkCode::SETTRIGGERANDSAMPLERATE:
             // DSO-2090 supports the downsampling factors 1, 2, 4 and 5 using
             // valueFast or all even values above using valueSlow
@@ -410,7 +419,7 @@ double HantekDsoControl::getBestSamplerate(double samplerate, bool fastRate, boo
 unsigned HantekDsoControl::getSampleCount() const {
     if (isRollMode()) {
         // TODO handle libusb error
-        return device->getPacketSize();
+        return getPacketSize();
     } else {
         if (isFastRate())
             return getRecordLength();
@@ -422,20 +431,20 @@ unsigned HantekDsoControl::getSampleCount() const {
 unsigned HantekDsoControl::updateRecordLength(RecordLengthID index) {
     if (index >= controlsettings.samplerate.limits->recordLengths.size()) return 0;
-    switch (specification.command.bulk.setRecordLength) {
+    switch (specification.cmdSetRecordLength) {
     case BulkCode::SETTRIGGERANDSAMPLERATE:
         modifyCommand<BulkSetTriggerAndSamplerate>(BulkCode::SETTRIGGERANDSAMPLERATE)->setRecordLength(index);
         break;
     case BulkCode::DSETBUFFER:
-        if (specification.command.bulk.setPretrigger == BulkCode::FSETBUFFER) {
+        if (specification.cmdSetPretrigger == BulkCode::FSETBUFFER) {
             modifyCommand<BulkSetRecordLength2250>(BulkCode::DSETBUFFER)->setRecordLength(index);
         } else {
             // SetBuffer5200 bulk command for record length
             BulkSetBuffer5200 *commandSetBuffer5200 = modifyCommand<BulkSetBuffer5200>(BulkCode::DSETBUFFER);
-            commandSetBuffer5200->setUsedPre(DTriggerPositionUsed::DTRIGGERPOSITION_ON);
-            commandSetBuffer5200->setUsedPost(DTriggerPositionUsed::DTRIGGERPOSITION_ON);
+            commandSetBuffer5200->setUsedPre(DTriggerPositionUsed::ON);
+            commandSetBuffer5200->setUsedPost(DTriggerPositionUsed::ON);
             commandSetBuffer5200->setRecordLength(index);
         }
@@ -466,7 +475,7 @@ unsigned HantekDsoControl::updateSamplerate(unsigned downsampler, bool fastRate)
     ControlSamplerateLimits *limits = fastRate ? &specification.samplerate.multi : &specification.samplerate.single;
     // Set the calculated samplerate
-    switch (specification.command.bulk.setSamplerate) {
+    switch (specification.cmdSetSamplerate) {
     case BulkCode::SETTRIGGERANDSAMPLERATE: {
         short int downsamplerValue = 0;
         unsigned char samplerateId = 0;
@@ -720,14 +729,14 @@ Dso::ErrorCode HantekDsoControl::setChannelUsed(ChannelID channel, bool used) {
             usedChannels = UsedChannels::USED_CH1CH2;
         } else {
             // DSO-2250 uses a different value for channel 2
-            if (specification.command.bulk.setChannels == BulkCode::BSETCHANNELS)
+            if (specification.cmdSetChannels == BulkCode::BSETCHANNELS)
                 usedChannels = UsedChannels::BUSED_CH2;
             else
                 usedChannels = UsedChannels::USED_CH2;
         }
     }
-    switch (specification.command.bulk.setChannels) {
+    switch (specification.cmdSetChannels) {
     case BulkCode::SETTRIGGERANDSAMPLERATE: {
         // SetTriggerAndSamplerate bulk command for trigger source
         modifyCommand<BulkSetTriggerAndSamplerate>(BulkCode::SETTRIGGERANDSAMPLERATE)
@@ -813,7 +822,7 @@ Dso::ErrorCode HantekDsoControl::setOffset(ChannelID channel, const double offse
     if (channel >= specification.channels) return Dso::ErrorCode::PARAMETER;
     if (specification.supportsOffset) {
-        Offset &channelOffLimit = specification.offsetLimit[channel].step[controlsettings.voltage[channel].gain];
+        Offset &channelOffLimit = controlsettings.offsetLimit[channel].step[controlsettings.voltage[channel].gain];
         // Calculate the offset value
         // The range is given by the calibration data (convert from big endian)
         unsigned short int minimum = ((unsigned short int)*((unsigned char *)&(channelOffLimit.start)) << 8) +
@@ -851,7 +860,7 @@ Dso::ErrorCode HantekDsoControl::setTriggerSource(bool special, unsigned id) {
     int hardwareID = special ? specification.specialTriggerChannels[id].hardwareID : (int)id;
-    switch (specification.command.bulk.setTrigger) {
+    switch (specification.cmdSetTrigger) {
     case BulkCode::SETTRIGGERANDSAMPLERATE:
         // SetTriggerAndSamplerate bulk command for trigger source
         modifyCommand<BulkSetTriggerAndSamplerate>(BulkCode::SETTRIGGERANDSAMPLERATE)->setTriggerSource(1 - hardwareID);
@@ -898,7 +907,7 @@ Dso::ErrorCode HantekDsoControl::setTriggerLevel(ChannelID channel, double level
     // Calculate the trigger level value
     unsigned short minimum, maximum;
     if (specification.sampleSize > 8) {
-        Offset &offsetLimit = specification.offsetLimit[channel].step[controlsettings.voltage[channel].gain];
+        Offset &offsetLimit = controlsettings.offsetLimit[channel].step[controlsettings.voltage[channel].gain];
         // The range is the same as used for the offsets for 10 bit models
         minimum = ((unsigned short)*((unsigned char *)&(offsetLimit.start)) << 8) +
                   *((unsigned char *)&(offsetLimit.start) + 1);
@@ -931,7 +940,7 @@ Dso::ErrorCode HantekDsoControl::setTriggerLevel(ChannelID channel, double level
 Dso::ErrorCode HantekDsoControl::setTriggerSlope(Dso::Slope slope) {
     if (!device->isConnected()) return Dso::ErrorCode::CONNECTION;
-    switch (specification.command.bulk.setTrigger) {
+    switch (specification.cmdSetTrigger) {
     case BulkCode::SETTRIGGERANDSAMPLERATE: {
         // SetTriggerAndSamplerate bulk command for trigger slope
         modifyCommand<BulkSetTriggerAndSamplerate>(BulkCode::SETTRIGGERANDSAMPLERATE)->setTriggerSlope((uint8_t)slope);
@@ -966,7 +975,7 @@ Dso::ErrorCode HantekDsoControl::setPretriggerPosition(double position) {
     // Fast rate mode uses both channels
     if (isFastRate()) positionSamples /= specification.channels;
-    switch (specification.command.bulk.setPretrigger) {
+    switch (specification.cmdSetPretrigger) {
     case BulkCode::SETTRIGGERANDSAMPLERATE: {
         // Calculate the position value (Start point depending on record length)
         unsigned triggerPosition = isRollMode() ? 0x1 : 0x7ffff - recordLength + (unsigned)positionSamples;
@@ -1057,21 +1066,21 @@ void HantekDsoControl::run() {
     int errorCode = 0;
     // Send all pending bulk commands
-    BulkCommand *bulkCommand = firstBulkCommand;
-    while (bulkCommand) {
-        if (bulkCommand->pending) {
+    BulkCommand *command = firstBulkCommand;
+    while (command) {
+        if (command->pending) {
             timestampDebug(
-                QString("Sending bulk command:%1").arg(hexDump(bulkCommand->data(), bulkCommand->getSize())));
+                QString("Sending bulk command:%1").arg(hexDump(command->data(), command->getSize())));
-            errorCode = device->bulkCommand(bulkCommand);
+            errorCode = bulkCommand(command);
             if (errorCode < 0) {
                 qWarning() << "Sending bulk command failed: " << libUsbErrorString(errorCode);
                 emit communicationError();
                 return;
             } else
-                bulkCommand->pending = false;
+                command->pending = false;
         }
-        bulkCommand = bulkCommand->next;
+        command = command->next;
     }
     // Send all pending control commands
@@ -1079,8 +1088,8 @@ void HantekDsoControl::run() {
     while (controlCommand) {
         if (controlCommand->pending) {
             timestampDebug(QString("Sending control command %1:%2")
-                               .arg(QString::number(control[cIndex], 16),
-                                    hexDump(this->control[control]->data(), this->control[control]->getSize())));
+                               .arg(QString::number(controlCommand->code, 16),
+                                    hexDump(controlCommand->data(), controlCommand->getSize())));
             errorCode = device->controlWrite(controlCommand);
             if (errorCode < 0) {
@@ -1114,7 +1123,7 @@ void HantekDsoControl::run() {
             // Sampling hasn't started, update the expected sample count
             expectedSampleCount = this->getSampleCount();
-            errorCode = device->bulkCommand(getCommand(BulkCode::STARTSAMPLING));
+            errorCode = bulkCommand(getCommand(BulkCode::STARTSAMPLING));
             if (errorCode < 0) {
                 if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                     emit communicationError();
@@ -1130,7 +1139,7 @@ void HantekDsoControl::run() {
             break;
         case RollState::ENABLETRIGGER:
-            errorCode = device->bulkCommand(getCommand(BulkCode::ENABLETRIGGER));
+            errorCode = bulkCommand(getCommand(BulkCode::ENABLETRIGGER));
             if (errorCode < 0) {
                 if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                     emit communicationError();
@@ -1144,7 +1153,7 @@ void HantekDsoControl::run() {
             break;
         case RollState::FORCETRIGGER:
-            errorCode = device->bulkCommand(getCommand(BulkCode::FORCETRIGGER));
+            errorCode = bulkCommand(getCommand(BulkCode::FORCETRIGGER));
             if (errorCode < 0) {
                 if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                     emit communicationError();
@@ -1161,7 +1170,7 @@ void HantekDsoControl::run() {
             std::vector<unsigned char> rawData = this->getSamples(expectedSampleCount);
             if (this->_samplingStarted) {
                 convertRawDataToSamples(rawData);
-                emit samplesAvailable();
+                emit samplesAvailable(&result);
             }
         }
@@ -1202,7 +1211,7 @@ void HantekDsoControl::run() {
             std::vector<unsigned char> rawData = this->getSamples(expectedSampleCount);
             if (this->_samplingStarted) {
                 convertRawDataToSamples(rawData);
-                emit samplesAvailable();
+                emit samplesAvailable(&result);
             }
         }
@@ -1216,10 +1225,16 @@ void HantekDsoControl::run() {
             // Start next capture if necessary by leaving out the break statement
             if (!this->sampling) break;
-#if __has_cpp_attribute(fallthrough) // Make compiler happy
-            else
-                [[fallthrough]];
+#if __has_cpp_attribute(clang::fallthrough)
+#define FALLTHROUGH [[clang::fallthrough]];
+#elif __has_cpp_attribute(fallthrough)
+#define FALLTHROUGH [[fallthrough]];
+#else
+#define FALLTHROUGH
 #endif
+            else {
+                FALLTHROUGH
+            }
         case CAPTURE_WAITING:
             // Sampling hasn't started, update the expected sample count
             expectedSampleCount = this->getSampleCount();
@@ -1230,7 +1245,7 @@ void HantekDsoControl::run() {
                 if (this->cycleCounter == this->startCycle && !isRollMode()) {
                     // Buffer refilled completely since start of sampling, enable the
                     // trigger now
-                    errorCode = device->bulkCommand(getCommand(BulkCode::ENABLETRIGGER));
+                    errorCode = bulkCommand(getCommand(BulkCode::ENABLETRIGGER));
                     if (errorCode < 0) {
                         if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                             emit communicationError();
@@ -1243,7 +1258,7 @@ void HantekDsoControl::run() {
                 } else if (cycleCounter >= 8 + this->startCycle &&
                            controlsettings.trigger.mode == Dso::TriggerMode::WAIT_FORCE) {
                     // Force triggering
-                    errorCode = device->bulkCommand(getCommand(BulkCode::FORCETRIGGER));
+                    errorCode = bulkCommand(getCommand(BulkCode::FORCETRIGGER));
                     if (errorCode < 0) {
                         if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                             emit communicationError();
@@ -1259,7 +1274,7 @@ void HantekDsoControl::run() {
             }
             // Start capturing
-            errorCode = device->bulkCommand(getCommand(BulkCode::STARTSAMPLING));
+            errorCode = bulkCommand(getCommand(BulkCode::STARTSAMPLING));
             if (errorCode < 0) {
                 if (errorCode == LIBUSB_ERROR_NO_DEVICE) {
                     emit communicationError();
@@ -1290,3 +1305,27 @@ void HantekDsoControl::run() {
     QTimer::singleShot(cycleTime, this, SLOT(run()));
 #endif
 }
+
+
+int HantekDsoControl::getConnectionSpeed() const {
+    int errorCode;
+    ControlGetSpeed response;
+    errorCode = device->controlRead(&response);
+    if (errorCode < 0) return errorCode;
+
+    return response.getSpeed();
+}
+
+int HantekDsoControl::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;
+}
@@ -5,16 +5,16 @@
 #define NOMINMAX // disable windows.h min/max global methods
 #include <limits>
-#include "errorcodes.h"
+#include "controlsettings.h"
+#include "controlspecification.h"
 #include "dsosamples.h"
+#include "errorcodes.h"
 #include "states.h"
-#include "controlspecification.h"
-#include "controlsettings.h"
 #include "utils/printutils.h"
-#include "hantekprotocol/definitions.h"
 #include "hantekprotocol/bulkStructs.h"
 #include "hantekprotocol/controlStructs.h"
+#include "hantekprotocol/definitions.h"
 #include <vector>
@@ -71,7 +71,15 @@ class HantekDsoControl : public QObject {
     double getMaxSamplerate();
     /// Return the associated usb device.
-    USBDevice *getDevice();
+    const USBDevice *getDevice() const;
+
+    /// \brief Gets the speed of the connection.
+    /// \return The ::ConnectionSpeed of the USB connection.
+    int getConnectionSpeed() const;
+
+    /// \brief Gets the maximum size of one packet transmitted via bulk transfer.
+    /// \return The maximum packet size in bytes, negative libusb error code on error.
+    int getPacketSize() const;
     /// Return the last sample set
     const DSOsamples &getLastSamples();
@@ -89,19 +97,20 @@ class HantekDsoControl : public QObject {
     /// \return See ::Dso::ErrorCode.
     Dso::ErrorCode stringCommand(const QString &commandString);
-    void addCommand(BulkCommand* newCommand, bool pending = true);
-    template<class T> T* modifyCommand(Hantek::BulkCode code) {
+    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]);
+        return static_cast<T *>(command[(uint8_t)code]);
     }
-    const BulkCommand* getCommand(Hantek::BulkCode code) const;
+    const BulkCommand *getCommand(Hantek::BulkCode code) const;
-    void addCommand(ControlCommand* newCommand, bool pending = true);
-    template<class T> T* modifyCommand(Hantek::ControlCode code) {
+    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]);
+        return static_cast<T *>(control[(uint8_t)code]);
     }
-    const ControlCommand* getCommand(Hantek::ControlCode code) const;
+    const ControlCommand *getCommand(Hantek::ControlCode code) const;
+
   private:
     bool isRollMode() const;
     bool isFastRate() const;
@@ -164,9 +173,9 @@ class HantekDsoControl : public QObject {
   private:
     /// Pointers to bulk/control commands
     BulkCommand *command[255] = {0};
-    BulkCommand* firstBulkCommand = nullptr;
+    BulkCommand *firstBulkCommand = nullptr;
     ControlCommand *control[255] = {0};
-    ControlCommand* firstControlCommand = nullptr;
+    ControlCommand *firstControlCommand = nullptr;
     // Communication with device
     USBDevice *device;     ///< The USB device for the oscilloscope
@@ -190,6 +199,12 @@ class HantekDsoControl : public QObject {
     int startCycle = 0;
     int cycleTime = 0;
+    /// \brief Send a bulk command to the oscilloscope.
+    /// \param command The command, that should be sent.
+    /// \param attempts The number of attempts, that are done on timeouts.
+    /// \return Number of sent bytes on success, libusb error code on error.
+    int bulkCommand(const DataArray<unsigned char> *command, int attempts = HANTEK_ATTEMPTS) const;
+
   public slots:
     void startSampling();
     void stopSampling();
@@ -258,7 +273,7 @@ class HantekDsoControl : public QObject {
     void samplingStarted();                                  ///< The oscilloscope started sampling/waiting for trigger
     void samplingStopped();                                  ///< The oscilloscope stopped sampling/waiting for trigger
     void statusMessage(const QString &message, int timeout); ///< Status message about the oscilloscope
-    void samplesAvailable();                                 ///< New sample data is available
+    void samplesAvailable(const DSOsamples *samples);        ///< New sample data is available
     void availableRecordLengthsChanged(const std::vector<unsigned> &recordLengths); ///< The available record
                                                                                     /// lengths, empty list for
@@ -271,3 +286,5 @@ class HantekDsoControl : public QObject {
     void communicationError() const;
 };
+
+Q_DECLARE_METATYPE(DSOsamples *)
@@ -5,12 +5,13 @@
 using namespace Hantek;
-ModelDSO2090::ModelDSO2090() : DSOModel(ID, 0x04b5, 0x2090, 0x04b4, 0x2090, "dso2090x86", "DSO-2090", Dso::ControlSpecification()) {
-    specification.command.bulk.setRecordLength = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setChannels = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setSamplerate = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setTrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setPretrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
+ModelDSO2090::ModelDSO2090() : DSOModel(ID, 0x04b5, 0x2090, 0x04b4, 0x2090, "dso2090x86", "DSO-2090",
+                                        Dso::ControlSpecification(2)) {
+    specification.cmdSetRecordLength = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetChannels = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetSamplerate = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetTrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetPretrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
     specification.samplerate.single.base = 50e6;
     specification.samplerate.single.max = 50e6;
@@ -5,12 +5,13 @@
 using namespace Hantek;
-ModelDSO2150::ModelDSO2150() : DSOModel(ID, 0x04b5, 0x2150, 0x04b4, 0x2150, "dso2150x86", "DSO-2150", Dso::ControlSpecification()) {
-    specification.command.bulk.setRecordLength = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setChannels = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setSamplerate = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setTrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
-    specification.command.bulk.setPretrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
+ModelDSO2150::ModelDSO2150() : DSOModel(ID, 0x04b5, 0x2150, 0x04b4, 0x2150, "dso2150x86", "DSO-2150",
+                                        Dso::ControlSpecification(2)) {
+    specification.cmdSetRecordLength = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetChannels = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetSamplerate = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetTrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
+    specification.cmdSetPretrigger = BulkCode::SETTRIGGERANDSAMPLERATE;
     specification.samplerate.single.base = 50e6;
     specification.samplerate.single.max = 75e6;
@@ -5,12 +5,13 @@
 using namespace Hantek;
-ModelDSO2250::ModelDSO2250() : DSOModel(ID, 0x04b5, 0x2250, 0x04b4, 0x2250, "dso2250x86", "DSO-2250", Dso::ControlSpecification()) {
-    specification.command.bulk.setRecordLength = BulkCode::DSETBUFFER;
-    specification.command.bulk.setChannels = BulkCode::BSETCHANNELS;
-    specification.command.bulk.setSamplerate = BulkCode::ESETTRIGGERORSAMPLERATE;
-    specification.command.bulk.setTrigger = BulkCode::CSETTRIGGERORSAMPLERATE;
-    specification.command.bulk.setPretrigger = BulkCode::FSETBUFFER;
+ModelDSO2250::ModelDSO2250() : DSOModel(ID, 0x04b5, 0x2250, 0x04b4, 0x2250, "dso2250x86", "DSO-2250",
+                                        Dso::ControlSpecification(2)) {
+    specification.cmdSetRecordLength = BulkCode::DSETBUFFER;
+    specification.cmdSetChannels = BulkCode::BSETCHANNELS;
+    specification.cmdSetSamplerate = BulkCode::ESETTRIGGERORSAMPLERATE;
+    specification.cmdSetTrigger = BulkCode::CSETTRIGGERORSAMPLERATE;
+    specification.cmdSetPretrigger = BulkCode::FSETBUFFER;
     specification.samplerate.single.base = 100e6;
     specification.samplerate.single.max = 100e6;
@@ -5,12 +5,13 @@
 using namespace Hantek;
-ModelDSO5200::ModelDSO5200() : DSOModel(ID, 0x04b5, 0x5200, 0x04b4, 0x5200, "dso5200x86", "DSO-5200", Dso::ControlSpecification()) {
-    specification.command.bulk.setRecordLength = BulkCode::DSETBUFFER;
-    specification.command.bulk.setChannels = BulkCode::ESETTRIGGERORSAMPLERATE;
-    specification.command.bulk.setSamplerate = BulkCode::CSETTRIGGERORSAMPLERATE;
-    specification.command.bulk.setTrigger = BulkCode::ESETTRIGGERORSAMPLERATE;
-    specification.command.bulk.setPretrigger = BulkCode::ESETTRIGGERORSAMPLERATE;
+ModelDSO5200::ModelDSO5200() : DSOModel(ID, 0x04b5, 0x5200, 0x04b4, 0x5200, "dso5200x86", "DSO-5200",
+                                        Dso::ControlSpecification(2)) {
+    specification.cmdSetRecordLength = BulkCode::DSETBUFFER;
+    specification.cmdSetChannels = BulkCode::ESETTRIGGERORSAMPLERATE;
+    specification.cmdSetSamplerate = BulkCode::CSETTRIGGERORSAMPLERATE;
+    specification.cmdSetTrigger = BulkCode::ESETTRIGGERORSAMPLERATE;
+    specification.cmdSetPretrigger = BulkCode::ESETTRIGGERORSAMPLERATE;
     specification.samplerate.single.base = 100e6;
     specification.samplerate.single.max = 125e6;
@@ -5,7 +5,8 @@
 using namespace Hantek;
-ModelDSO6022BE::ModelDSO6022BE() : DSOModel(ID, 0x04b5, 0x6022, 0x04b4, 0x6022, "dso6022be", "DSO-6022BE", Dso::ControlSpecification()) {
+ModelDSO6022BE::ModelDSO6022BE() : DSOModel(ID, 0x04b5, 0x6022, 0x04b4, 0x6022, "dso6022be", "DSO-6022BE",
+                                            Dso::ControlSpecification(2)) {
     // 6022xx do not support any bulk commands
     specification.useControlNoBulk = true;
     specification.isSoftwareTriggerDevice = true;
@@ -7,6 +7,7 @@
 #include <QString>
+#include "types.h"
 #include "definitions.h"
 #include "states.h"
 #include "usb/bulkcommand.h"
@@ -190,8 +191,8 @@ class BulkSetRecordLength2250 : public BulkCommand {
 class BulkSetBuffer5200 : public BulkCommand {
   public:
     BulkSetBuffer5200();
-    BulkSetBuffer5200(uint16_t triggerPositionPre, uint16_t triggerPositionPost, DTriggerPositionUsed usedPre = DTriggerPositionUsed::DTRIGGERPOSITION_OFF,
-                      DTriggerPositionUsed usedPost = DTriggerPositionUsed::DTRIGGERPOSITION_OFF, uint8_t recordLength = 0);
+    BulkSetBuffer5200(uint16_t triggerPositionPre, uint16_t triggerPositionPost, DTriggerPositionUsed usedPre = DTriggerPositionUsed::OFF,
+                      DTriggerPositionUsed usedPost = DTriggerPositionUsed::OFF, uint8_t recordLength = 0);
     uint16_t getTriggerPositionPre();
     void setTriggerPositionPre(uint16_t value);
@@ -4,12 +4,24 @@
 #include "controlStructs.h"
 #include "controlvalue.h"
+#include "definitions.h"
 namespace Hantek {
+ControlBeginCommand::ControlBeginCommand(BulkIndex index)
+    : ControlCommand(Hantek::ControlCode::CONTROL_BEGINCOMMAND, 10) {
+    array[0] = 0x0f;
+    array[1] = (uint8_t)index;
+}
+
+ControlGetSpeed::ControlGetSpeed() : ControlCommand(Hantek::ControlCode::CONTROL_GETSPEED, 10) {}
+
+ConnectionSpeed ControlGetSpeed::getSpeed() { return (ConnectionSpeed)this->array[0]; }
+
 ControlSetOffset::ControlSetOffset() : ControlCommand(ControlCode::CONTROL_SETOFFSET, 17) {}
-ControlSetOffset::ControlSetOffset(uint16_t channel1, uint16_t channel2, uint16_t trigger) : ControlCommand(ControlCode::CONTROL_SETOFFSET, 17) {
+ControlSetOffset::ControlSetOffset(uint16_t channel1, uint16_t channel2, uint16_t trigger)
+    : ControlCommand(ControlCode::CONTROL_SETOFFSET, 17) {
     this->setChannel(0, channel1);
     this->setChannel(1, channel2);
     this->setTrigger(trigger);
@@ -41,7 +53,7 @@ void ControlSetOffset::setTrigger(uint16_t level) {
 ControlSetRelays::ControlSetRelays(bool ch1Below1V, bool ch1Below100mV, bool ch1CouplingDC, bool ch2Below1V,
                                    bool ch2Below100mV, bool ch2CouplingDC, bool triggerExt)
-    : ControlCommand(ControlCode::CONTROL_SETRELAYS,17) {
+    : ControlCommand(ControlCode::CONTROL_SETRELAYS, 17) {
     this->setBelow1V(0, ch1Below1V);
     this->setBelow100mV(0, ch1Below100mV);
     this->setCoupling(0, ch1CouplingDC);
@@ -97,27 +109,31 @@ bool ControlSetRelays::getTrigger() { return (this-&gt;array[7] &amp; 0x01) == 0x00; }
 void ControlSetRelays::setTrigger(bool ext) { this->array[7] = ext ? 0xfe : 0x01; }
-ControlSetVoltDIV_CH1::ControlSetVoltDIV_CH1() : ControlCommand(ControlCode::CONTROL_SETVOLTDIV_CH1,1) { this->setDiv(5); }
+ControlSetVoltDIV_CH1::ControlSetVoltDIV_CH1() : ControlCommand(ControlCode::CONTROL_SETVOLTDIV_CH1, 1) {
+    this->setDiv(5);
+}
 void ControlSetVoltDIV_CH1::setDiv(uint8_t val) { this->array[0] = val; }
-ControlSetVoltDIV_CH2::ControlSetVoltDIV_CH2() : ControlCommand(ControlCode::CONTROL_SETVOLTDIV_CH2,1) { this->setDiv(5); }
+ControlSetVoltDIV_CH2::ControlSetVoltDIV_CH2() : ControlCommand(ControlCode::CONTROL_SETVOLTDIV_CH2, 1) {
+    this->setDiv(5);
+}
 void ControlSetVoltDIV_CH2::setDiv(uint8_t val) { this->array[0] = val; }
-ControlSetTimeDIV::ControlSetTimeDIV() : ControlCommand(ControlCode::CONTROL_SETTIMEDIV,1) { this->setDiv(1); }
+ControlSetTimeDIV::ControlSetTimeDIV() : ControlCommand(ControlCode::CONTROL_SETTIMEDIV, 1) { this->setDiv(1); }
 void ControlSetTimeDIV::setDiv(uint8_t val) { this->array[0] = val; }
-ControlAcquireHardData::ControlAcquireHardData() : ControlCommand(ControlCode::CONTROL_ACQUIIRE_HARD_DATA,1) { this->array[0] = 0x01; }
+ControlAcquireHardData::ControlAcquireHardData() : ControlCommand(ControlCode::CONTROL_ACQUIIRE_HARD_DATA, 1) {
+    this->array[0] = 0x01;
+}
-ControlGetLimits::ControlGetLimits(unsigned channels) : ControlCommand(ControlCode::CONTROL_VALUE,1), offsetLimit(new OffsetsPerGainStep[channels]) {
+ControlGetLimits::ControlGetLimits(unsigned channels)
+    : ControlCommand(ControlCode::CONTROL_VALUE, 1), offsetLimit(new OffsetsPerGainStep[channels]) {
     value = (uint8_t)ControlValue::VALUE_OFFSETLIMITS;
     array[0] = 0x01;
 }
-ControlGetLimits::~ControlGetLimits()
-{
-    delete [] offsetLimit;
-}
+ControlGetLimits::~ControlGetLimits() { delete[] offsetLimit; }
 }
 #pragma once
-#include "definitions.h"
+#include "types.h"
 #include "usb/usbdevicedefinitions.h"
 #include "usb/controlcommand.h"
 #include "controlcode.h"
 namespace Hantek {
+struct OffsetsPerGainStep;
+
+/// \enum BulkIndex
+/// \brief Can be set by CONTROL_BEGINCOMMAND, maybe it allows multiple commands
+/// at the same time?
+enum BulkIndex {
+    COMMANDINDEX_0 = 0x03, ///< Used most of the time
+    COMMANDINDEX_1 = 0x0a,
+    COMMANDINDEX_2 = 0x09,
+    COMMANDINDEX_3 = 0x01, ///< Used for ::BulkCode::SETTRIGGERANDSAMPLERATE sometimes
+    COMMANDINDEX_4 = 0x02,
+    COMMANDINDEX_5 = 0x08
+};
+
+/// \class ControlBeginCommand
+class ControlBeginCommand : public ControlCommand {
+  public:
+    /// \brief Sets the command index to the given value.
+    /// \param index The CommandIndex for the command.
+    ControlBeginCommand(BulkIndex index = COMMANDINDEX_0);
+};
+
+/// \brief The CONTROL_GETSPEED parser.
+class ControlGetSpeed : public ControlCommand {
+  public:
+    ControlGetSpeed();
+    /// \brief Gets the speed of the connection.
+    /// \return The speed level of the USB connection.
+    ConnectionSpeed getSpeed();
+};
 struct ControlSetOffset : public ControlCommand {
     ControlSetOffset();
@@ -7,10 +7,6 @@
 #include <stdint.h>
 #define HANTEK_GAIN_STEPS 9
-#define HANTEK_CHANNELS 2         ///< Number of physical channels
-
-typedef unsigned RecordLengthID;
-typedef unsigned ChannelID;
 namespace Hantek {
 /// \enum UsedChannels
@@ -31,8 +27,8 @@ enum class UsedChannels : uint8_t {
 /// \enum DTriggerPositionUsed                                  hantek/types.h
 /// \brief The trigger position states for the 0x0d command.
 enum class DTriggerPositionUsed: uint8_t {
-    DTRIGGERPOSITION_OFF = 0, ///< Used for Roll mode
-    DTRIGGERPOSITION_ON = 7   ///< Used for normal operation
+    OFF = 0, ///< Used for Roll mode
+    ON = 7   ///< Used for normal operation
 };
 #pragma pack(push, 1)
+// SPDX-License-Identifier: GPL-2.0+
+
+#pragma once
+
+typedef unsigned RecordLengthID;
+typedef unsigned ChannelID;
-#include "controlbegin.h"
-#include "hantekprotocol/controlcode.h"
-
-ControlBeginCommand::ControlBeginCommand(BulkIndex index) : ControlCommand(Hantek::ControlCode::CONTROL_BEGINCOMMAND, 10) {
-    array[0] = 0x0f;
-    array[1] = (uint8_t)index;
-}
-
-// SPDX-License-Identifier: GPL-2.0+
-
-#pragma once
-#include "controlcommand.h"
-#include <inttypes.h>
-
-/// \enum BulkIndex
-/// \brief Can be set by CONTROL_BEGINCOMMAND, maybe it allows multiple commands
-/// at the same time?
-enum BulkIndex {
-    COMMANDINDEX_0 = 0x03, ///< Used most of the time
-    COMMANDINDEX_1 = 0x0a,
-    COMMANDINDEX_2 = 0x09,
-    COMMANDINDEX_3 = 0x01, ///< Used for ::BulkCode::SETTRIGGERANDSAMPLERATE sometimes
-    COMMANDINDEX_4 = 0x02,
-    COMMANDINDEX_5 = 0x08
-};
-
-/// \class ControlBeginCommand
-class ControlBeginCommand : public ControlCommand {
-  public:
-    /// \brief Sets the command index to the given value.
-    /// \param index The CommandIndex for the command.
-    ControlBeginCommand(BulkIndex index = COMMANDINDEX_0);
-};
-#include "controlgetspeed.h"
-#include "hantekprotocol/controlcode.h"
-
-ControlGetSpeed::ControlGetSpeed() : ControlCommand(Hantek::ControlCode::CONTROL_GETSPEED, 10) {}
-
-ConnectionSpeed ControlGetSpeed::getSpeed() { return (ConnectionSpeed)this->array[0]; }
-
-// SPDX-License-Identifier: GPL-2.0+
-
-#pragma once
-#include "controlcommand.h"
-#include "usbdevicedefinitions.h"
-
-/// \brief The CONTROL_GETSPEED parser.
-class ControlGetSpeed : public ControlCommand {
-  public:
-    ControlGetSpeed();
-    /// \brief Gets the speed of the connection.
-    /// \return The speed level of the USB connection.
-    ConnectionSpeed getSpeed();
-};
@@ -6,20 +6,19 @@
 #include "usbdevice.h"
-#include "hantekprotocol/controlStructs.h"
 #include "hantekprotocol/bulkStructs.h"
-#include "controlgetspeed.h"
+#include "hantekprotocol/controlStructs.h"
 #include "models.h"
 #include "utils/printutils.h"
 UniqueUSBid USBDevice::computeUSBdeviceID(libusb_device *device) {
-    UniqueUSBid v=0;
-    libusb_get_port_numbers(device, (uint8_t*)&v, sizeof(v));
+    UniqueUSBid v = 0;
+    libusb_get_port_numbers(device, (uint8_t *)&v, sizeof(v));
     return v;
 }
-USBDevice::USBDevice(DSOModel *model, libusb_device *device, unsigned findIteration) :
-    model(model), device(device), findIteration(findIteration), uniqueUSBdeviceID(computeUSBdeviceID(device)) {
+USBDevice::USBDevice(DSOModel *model, libusb_device *device, unsigned findIteration)
+    : model(model), device(device), findIteration(findIteration), uniqueUSBdeviceID(computeUSBdeviceID(device)) {
     libusb_ref_device(device);
     libusb_get_device_descriptor(device, &descriptor);
 }
@@ -115,15 +114,9 @@ bool USBDevice::needsFirmware() {
     return this->descriptor.idProduct != model->productID || this->descriptor.idVendor != model->vendorID;
 }
-void USBDevice::setFindIteration(unsigned iteration)
-{
-    findIteration = iteration;
-}
+void USBDevice::setFindIteration(unsigned iteration) { findIteration = iteration; }
-unsigned USBDevice::getFindIteration() const
-{
-    return findIteration;
-}
+unsigned USBDevice::getFindIteration() const { return findIteration; }
 int USBDevice::bulkTransfer(unsigned char endpoint, const unsigned char *data, unsigned int length, int attempts,
                             unsigned int timeout) {
@@ -132,7 +125,8 @@ int USBDevice::bulkTransfer(unsigned char endpoint, const unsigned char *data, u
     int errorCode = LIBUSB_ERROR_TIMEOUT;
     int transferred = 0;
     for (int attempt = 0; (attempt < attempts || attempts == -1) && errorCode == LIBUSB_ERROR_TIMEOUT; ++attempt)
-        errorCode = libusb_bulk_transfer(this->handle, endpoint, (unsigned char*) data, (int)length, &transferred, timeout);
+        errorCode =
+            libusb_bulk_transfer(this->handle, endpoint, (unsigned char *)data, (int)length, &transferred, timeout);
     if (errorCode == LIBUSB_ERROR_NO_DEVICE) disconnectFromDevice();
     if (errorCode < 0)
@@ -142,55 +136,27 @@ int USBDevice::bulkTransfer(unsigned char endpoint, const unsigned char *data, u
 }
 int USBDevice::bulkWrite(const unsigned char *data, unsigned int length, int attempts) {
-    if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-
-    int errorCode = this->getConnectionSpeed();
-    if (errorCode < 0) return errorCode;
-
-    return this->bulkTransfer(HANTEK_EP_OUT, data, length, attempts);
+    return bulkTransfer(HANTEK_EP_OUT, data, length, attempts);
 }
-int USBDevice::bulkRead(unsigned char *data, unsigned int length, int attempts) {
-    if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-
-    int errorCode = this->getConnectionSpeed();
-    if (errorCode < 0) return errorCode;
-
-    return this->bulkTransfer(HANTEK_EP_IN, data, length, attempts);
-}
-
-int USBDevice::bulkCommand(const DataArray<unsigned char> *command, int attempts) {
-    if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-
-    if (!allowBulkTransfer) return LIBUSB_SUCCESS;
-
-    // Send BeginCommand control command
-    int errorCode = this->controlWrite(&beginCommandControl);
-    if (errorCode < 0) return errorCode;
-
-    // Send bulk command
-    return this->bulkWrite(command->data(), command->getSize(), attempts);
+int USBDevice::bulkRead(const DataArray<unsigned char> *command, int attempts) {
+    return bulkTransfer(HANTEK_EP_IN, command->data(), command->getSize(), attempts);
 }
 int USBDevice::bulkReadMulti(unsigned char *data, unsigned length, int attempts) {
     if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-    int errorCode = 0;
-
-    errorCode = this->getConnectionSpeed();
-    if (errorCode < 0) return errorCode;
-
-    errorCode = this->inPacketLength;
+    int errorCode = this->inPacketLength;
     unsigned int packet, received = 0;
     for (packet = 0; received < length && errorCode == this->inPacketLength; ++packet) {
         errorCode = this->bulkTransfer(HANTEK_EP_IN, data + packet * this->inPacketLength,
                                        qMin(length - received, (unsigned int)this->inPacketLength), attempts,
                                        HANTEK_TIMEOUT_MULTI);
-        if (errorCode > 0) received += errorCode;
+        if (errorCode > 0) received += (unsigned)errorCode;
     }
     if (received > 0)
-        return received;
+        return (int)received;
     else
         return errorCode;
 }
@@ -207,51 +173,23 @@ int USBDevice::controlTransfer(unsigned char type, unsigned char request, unsign
     return errorCode;
 }
-int USBDevice::controlWrite(const ControlCommand* command) {
+int USBDevice::controlWrite(const ControlCommand *command) {
     if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-    // std::cout << "control" << (int)request << " l:"<<length<<" d:"<<(int)data[0] << std::endl;
-    return this->controlTransfer(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
-                                 (uint8_t)command->code, command->data(), command->getSize(), command->value, 0, HANTEK_ATTEMPTS);
+    return controlTransfer(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, (uint8_t)command->code, command->data(),
+                           command->getSize(), command->value, 0, HANTEK_ATTEMPTS);
 }
 int USBDevice::controlRead(const ControlCommand *command) {
     if (!this->handle) return LIBUSB_ERROR_NO_DEVICE;
-    return this->controlTransfer(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
-                                 (uint8_t)command->code, command->data(), command->getSize(), command->value, 0, HANTEK_ATTEMPTS);
-}
-
-int USBDevice::getConnectionSpeed() {
-    int errorCode;
-    ControlGetSpeed response;
-    errorCode = this->controlRead(&response);
-    if (errorCode < 0) return errorCode;
-
-    return response.getSpeed();
-}
-
-int USBDevice::getPacketSize() {
-    const int s = this->getConnectionSpeed();
-    if (s == CONNECTION_FULLSPEED)
-        return 64;
-    else if (s == CONNECTION_HIGHSPEED)
-        return 512;
-    else if (s > CONNECTION_HIGHSPEED) {
-        std::cerr << "Unknown USB speed. Please correct source code in USBDevice::getPacketSize()" << std::endl;
-        throw new std::runtime_error("Unknown USB speed");
-    } else if (s<0) return s;
-    return 0;
+    return controlTransfer(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, (uint8_t)command->code, command->data(),
+                           command->getSize(), command->value, 0, HANTEK_ATTEMPTS);
 }
 libusb_device *USBDevice::getRawDevice() const { return device; }
-unsigned long USBDevice::getUniqueUSBDeviceID() const
-{
-    return uniqueUSBdeviceID;
-}
-
-const DSOModel* USBDevice::getModel() const { return model; }
+unsigned long USBDevice::getUniqueUSBDeviceID() const { return uniqueUSBdeviceID; }
-void USBDevice::setEnableBulkTransfer(bool enable) { allowBulkTransfer = enable; }
+const DSOModel *USBDevice::getModel() const { return model; }
 void USBDevice::overwriteInPacketLength(int len) { inPacketLength = len; }
@@ -8,7 +8,7 @@
 #include <memory>
 #include "usbdevicedefinitions.h"
-#include "controlbegin.h"
+#include "dataarray.h"
 class DSOModel;
 class ControlCommand;
@@ -65,13 +65,7 @@ class USBDevice : public QObject {
     /// \param length The length of the packet.
     /// \param attempts The number of attempts, that are done on timeouts.
     /// \return Number of received bytes on success, libusb error code on error.
-    int bulkRead(unsigned char *data, unsigned int length, int attempts = HANTEK_ATTEMPTS);
-
-    /// \brief Send a bulk command to the oscilloscope.
-    /// \param command The command, that should be sent.
-    /// \param attempts The number of attempts, that are done on timeouts.
-    /// \return Number of sent bytes on success, libusb error code on error.
-    int bulkCommand(const DataArray<unsigned char> *command, int attempts = HANTEK_ATTEMPTS);
+    int bulkRead(const DataArray<unsigned char> *command, int attempts = HANTEK_ATTEMPTS);
     /// \brief Multi packet bulk read from the oscilloscope.
     /// \param data Buffer for the sent/recieved data.
@@ -93,33 +87,15 @@ class USBDevice : public QObject {
                         int index, int attempts = HANTEK_ATTEMPTS);
     /// \brief Control write to the oscilloscope.
-    /// \param request The request field of the packet.
-    /// \param data Buffer for the sent/recieved data.
-    /// \param length The length field of the packet.
-    /// \param value The value field of the packet.
-    /// \param index The index field of the packet.
-    /// \param attempts The number of attempts, that are done on timeouts.
+    /// \param command Buffer for the sent/recieved data.
     /// \return Number of sent bytes on success, libusb error code on error.
     int controlWrite(const ControlCommand *command);
     /// \brief Control read to the oscilloscope.
-    /// \param request The request field of the packet.
-    /// \param data Buffer for the sent/recieved data.
-    /// \param length The length field of the packet.
-    /// \param value The value field of the packet.
-    /// \param index The index field of the packet.
-    /// \param attempts The number of attempts, that are done on timeouts.
+    /// \param command Buffer for the sent/recieved data.
     /// \return Number of received bytes on success, libusb error code on error.
     int controlRead(const ControlCommand *command);
-    /// \brief Gets the speed of the connection.
-    /// \return The ::ConnectionSpeed of the USB connection.
-    int getConnectionSpeed();
-
-    /// \brief Gets the maximum size of one packet transmitted via bulk transfer.
-    /// \return The maximum packet size in bytes, negative libusb error code on error.
-    int getPacketSize();
-
     /**
      * @return Returns the raw libusb device
      */
@@ -141,13 +117,11 @@ class USBDevice : public QObject {
     /// \brief Get the oscilloscope model.
     /// \return The ::Model of the connected Hantek DSO.
     const DSOModel *getModel() const;
-    void setEnableBulkTransfer(bool enable);
     void overwriteInPacketLength(int len);
   protected:
     int claimInterface(const libusb_interface_descriptor *interfaceDescriptor, int endpointOut, int endPointIn);
-    // Command buffers
-    ControlBeginCommand beginCommandControl;
+    // Device model data
     DSOModel* model;
     // Libusb specific variables
@@ -159,7 +133,6 @@ class USBDevice : public QObject {
     int interface;
     int outPacketLength; ///< Packet length for the OUT endpoint
     int inPacketLength;  ///< Packet length for the IN endpoint
-    bool allowBulkTransfer = true;
   signals:
     void deviceDisconnected(); ///< The device has been disconnected
 };