def _updateScopeSettings(self):
if self._scope:
self.cancel()
self._scope = Oscilloscope()
self._scope.setup()
self._scope.open_handle()
if (not self._scope.is_device_firmware_present):
self._scope.flash_firmware()
else:
self._scope.supports_single_channel = True
logging.info("Setting up scope!")
self._scope.set_interface(self._alternative)
logging.info("ISO" if self._scope.is_iso else "BULK", "packet size:",
self._scope.packetsize)
if self.widget.channel2CheckBox.isChecked():
self._scope.set_num_channels(2)
else:
self._scope.set_num_channels(1)
# set voltage range
voltagerange1 = self._strVoltageToID(
self.widget.channel1VoltPDivComboBox.currentText())
voltagerange2 = self._strVoltageToID(
self.widget.channel2VoltPDivComboBox.currentText())
self._scope.set_ch1_voltage_range(voltagerange1)
self._scope.set_ch2_voltage_range(voltagerange2)
self._scope.set_sample_rate(
self._str2SamplerateID(
self.widget.samplerateComboBox.currentText()))
self._blocksize = self._recordLength
self.start()
def test_set_one_channel_and_read(self):
print "Testing setting one channel and reading it."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware(mod_firmware_01)
assert scope.set_ch1_voltage_range(0xA)
assert scope.set_sample_rate(0x10)
assert scope.set_num_channels(1)
ch1_data, ch2_data = scope.read_data(0x4000)
assert ch1_data
assert not ch2_data
assert scope.close_handle()
def test_data_scaling(self):
print "Testing setting various scale facotrs and reading."
scale_factor = 0x01
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
assert scope.set_ch1_voltage_range(scale_factor)
assert scope.set_sample_rate(27)
ch1_data, _ = scope.read_data(0x100000)
ch1_data = scope.scale_read_data(ch1_data, scale_factor)
print "Max:", max(ch1_data), "(V), Min:", min(ch1_data), "(V)"
assert ch1_data
assert scope.close_handle()
def test_flash_firmware(self):
print "Testing flashing multiple firmwares."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware(stock_firmware, supports_single_channel=False)
assert scope.flash_firmware(mod_firmware_01)
assert scope.flash_firmware(stock_firmware, supports_single_channel=False)
assert scope.close_handle()
def test_set_sample_rate(self):
print "Testing setting the sample rate."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
for rate_index in scope.SAMPLE_RATES.keys():
scope.set_sample_rate(rate_index)
assert scope.close_handle()
def test_set_num_channels(self):
print "Testing setting the number of channels with modified firmware."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware(mod_firmware_01)
assert scope.set_num_channels(1)
assert scope.set_num_channels(2)
assert scope.set_num_channels(1)
assert scope.close_handle()
def test_clear_fifo(self):
print "Testing explicitly clearing the FIFO."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
assert scope.clear_fifo()
assert scope.close_handle()
def test_read_firmware(self):
print "Testing read_firmware method on scope."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
assert scope.read_firmware()
assert scope.close_handle()
def createControlPanel(self, frame):
self.device = Oscilloscope()
self.reader = None
self.ch1 = ChannelControl(self.device, frame, CONST.CH1, self.acquire)
self.ch2 = ChannelControl(self.device, frame, CONST.CH2, self.acquire)
self.tb = TimeBaseControl(self.device, frame, self.acquire)
self.reader = Reader(self.device)
def test_get_cal_values(self):
print "Testing getting calibration values."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
cal_values = scope.get_calibration_values()
assert cal_values
assert scope.close_handle()
def initialize(self):
self.sample_rate_index = 8
self.voltage_range = 0x01
self.data_points = 3 * 1024
self.trigger_level = 150
self.trigger_type = +1
self.scope = Oscilloscope()
self.scope.setup()
self.scope.open_handle()
if (not self.scope.is_device_firmware_present):
self.scope.flash_firmware()
self.scope.set_interface(1)
# choose ISO
self.scope.set_num_channels(1)
self.scope.set_sample_rate(self.sample_rate_index)
self.scope.set_ch1_voltage_range(self.voltage_range)
time.sleep(0.1)
return None
def test_set_channel_voltage_range(self):
print "Testing setting the voltage range."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
for vrange in scope.VOLTAGE_RANGES.keys():
assert scope.set_ch1_voltage_range(vrange)
assert scope.set_ch1_voltage_range(vrange)
assert scope.close_handle()
def test_read_data(self):
print "Testing reading data from the oscilloscope."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
ch1_data, _ = scope.read_data(data_size=0x400)
print ch1_data
assert ch1_data
assert scope.close_handle()
def test_find_device(self):
print "Testing finding device and flashing stock firmware."
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
assert scope.close_handle()
def test_read_many_sizes(self):
print "Testing reading many different data sizes"
scope = Oscilloscope()
assert scope.setup()
assert scope.open_handle()
assert scope.flash_firmware()
data_size = 0x400
for _ in xrange(11):
print "DATA SIZE", data_size
ch1_data, ch2_data = scope.read_data(data_size=data_size, raw=True)
print len(ch1_data)
print len(ch2_data)
assert ch1_data, ch2_data
data_size <<= 1
assert scope.close_handle()
def initialize(self):
self.sample_rate_index = 8
self.voltage_range = 0x01
self.data_points = 3 * 1024
self.trigger_level = 150
self.trigger_type = +1
self.scope = Oscilloscope()
self.scope.setup()
self.scope.open_handle()
if (not self.scope.is_device_firmware_present):
self.scope.flash_firmware()
self.scope.set_interface(1); # choose ISO
self.scope.set_num_channels(1)
self.scope.set_sample_rate(self.sample_rate_index)
self.scope.set_ch1_voltage_range(self.voltage_range)
time.sleep(0.1)
return None
sum1 += sample
count1 += 1
for sample in ch2_data[skip:]:
sum2 += sample
count2 += 1
avg1 = int(0.5 + sum1 / count1)
avg2 = int(0.5 + sum2 / count2)
return (avg1, avg2)
print("Setting up scope...")
scope = Oscilloscope()
scope.setup()
scope.open_handle()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
scope.supports_single_channel = True
scope.set_num_channels(2)
# mV/div ranges
V_div = (20, 50, 100, 200, 500, 1000, 2000, 5000)
# corresponding amplifier gain settings
gains = (10, 10, 10, 5, 2, 1, 1, 1)
# available amplifier gains
class ScopeInterface(QObject):
new_data = pyqtSignal(list)
def __init__(self, parent=None):
super(ScopeInterface, self).__init__(parent)
self.inprogress = False
def initialize(self):
self.sample_rate_index = 8
self.voltage_range = 0x01
self.data_points = 3 * 1024
self.trigger_level = 150
self.trigger_type = +1
self.scope = Oscilloscope()
self.scope.setup()
self.scope.open_handle()
if (not self.scope.is_device_firmware_present):
self.scope.flash_firmware()
self.scope.set_interface(1); # choose ISO
self.scope.set_num_channels(1)
self.scope.set_sample_rate(self.sample_rate_index)
self.scope.set_ch1_voltage_range(self.voltage_range)
time.sleep(0.1)
return None
def capture(self):
if not self.inprogress:
self.inprogress = True
self.scope.start_capture()
shutdown_event = self.scope.read_async(self.data_callback, self.data_points, outstanding_transfers=25)
print("Clearing FIFO and starting data transfer...")
def data_callback(self, ch1_data, _):
d = list(ch1_data)
i = 0
#print("got new data ", time.time(), " : ", len(d))
if self.trigger_type > 0:
while (i < len(d) - 1) and not (d[i+1] > self.trigger_level and d[i] < self.trigger_level):
i += 1
#print("Trigger at ", i)
if (i != len(d) - 1):
self.new_data.emit(d[i:])
def stop(self):
self.scope.stop_capture()
print("Stopping new transfers.")
shutdown_event.set()
print("Snooze 1")
time.sleep(1)
print("Closing handle")
self.scope.close_handle()
print("Handle closed.")
self.inprogress = False
import numpy as np
#--------------------------------------------------
# Setup
#--------------------------------------------------
voltage_range = 1 # 1 (5V), 2 (2.6V), 5 or 10
sample_rate_index = 8 # sample rate in MHz or in 10khz
sample_rate = sample_rate_index * 1000 * 10
numchannels = 1
numseconds = 0 # number of seconds to sample (use 0 for infinity)
blocksize = 100*6*1024 # should be divisible by 6*1024
alternative = 1 # choose ISO 3072 bytes per 125 us
scope = Oscilloscope()
scope.setup()
scope.open_handle()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
else:
scope.supports_single_channel = True
print("Setting up scope!")
#scope.set_interface(alternative)
print("ISO" if scope.is_iso else "BULK", "packet size:", scope.packetsize)
scope.set_num_channels(numchannels)
# set voltage range
scope.set_ch1_voltage_range(voltage_range)
# set sample rate
scope.set_sample_rate(sample_rate_index)
from struct import pack
import sys
import time
from collections import deque
from PyHT6022.LibUsbScope import Oscilloscope
voltagerange = 10 # 1 (5V), 2 (2.6V), 5 or 10
samplerate = 24 # sample rate in MHz or in 10khz
numchannels = 1
numseconds = 8 # number of seconds to sample
blocksize = 6*1024 # should be divisible by 6*1024
alternative = 1 # choose ISO 3072 bytes per 125 us
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.flash_firmware()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
else:
scope.supports_single_channel = True;
print "Setting up scope!"
scope.set_interface(alternative);
print "ISO" if scope.is_iso else "BULK", "packet size:", scope.packetsize
print scope.set_num_channels(numchannels)
# set voltage range
scope.set_ch1_voltage_range(voltagerange)
# set sample rate
#!/usr/bin/python3 # flash the firmware from hex file __author__ = 'Robert Cope' from PyHT6022.LibUsbScope import Oscilloscope from sys import argv firmware = "firmware.hex" if len( argv ) > 1: firmware = argv[ 1 ] scope = Oscilloscope() scope.setup() scope.open_handle() scope.flash_firmware_from_hex( firmware ) scope.close_handle()
count1 += 1
for sample in ch2_data[skip:]:
sum2 += sample
count2 += 1
# measured values are 0x80 binary offset -> 0V = 0x80
avg1 = sum1 / count1 - 0x80
avg2 = sum2 / count2 - 0x80
return (avg1, avg2)
print("Setting up scope...")
scope = Oscilloscope()
scope.setup()
scope.open_handle()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
scope.supports_single_channel = True
# select two channels
scope.set_num_channels(2)
# set coupling of both channels to DC
scope.set_ch1_ch2_ac_dc(scope.DC_DC)
# corresponding amplifier gain settings
gains = (10, 10, 10, 5, 2, 1, 1, 1)
running = True
current = 0
elif entry > threshold and running:
current += 1
elif entry < threshold and running:
stability.append(current)
running = False
else:
continue
return stability[1:-1]
sample_rate_index = 24
voltage_range = 0x01
data_points = 3 * 1024
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.flash_firmware()
scope.set_interface(1) # choose ISO
scope.set_num_channels(1)
scope.set_sample_rate(sample_rate_index)
scope.set_ch1_voltage_range(voltage_range)
time.sleep(1)
data = deque(maxlen=2*1024*1024)
data_extend = data.extend
def extend_callback(ch1_data, _):
global data_extend
def print_report(time_measurements, num_bytes):
rates = []
for i, t in enumerate(time_measurements[1:]):
rate = num_bytes / (t - time_measurements[i])
rates.append(rate)
print "Average: {} MB/s".format(sum(rates) / (len(rates) * 1e6))
return rates
voltage_range = 0x01
time_fxn = time.time
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.set_ch1_voltage_range(voltage_range)
for sample_rate_index in [0x30, 0x10, 0x08, 0x04, 0x01, 0x32, 0x14, 0x0A]:
scope.set_sample_rate(sample_rate_index)
_, label = scope.convert_sampling_rate_to_measurement_times(
1, sample_rate_index)
print "Sample rate: {}".format(label)
print "-" * 40
for data_points in [
0x800, 0x1000, 0x8000, 0x10000, 0x80000, 0x100000, 0x200000
]:
reader_fxn = scope.build_data_reader(raw=True)
times = []
iterations = 50
def print_report(time_measurements, num_bytes):
rates = []
for i, t in enumerate(time_measurements[1:]):
rate = num_bytes / (t - time_measurements[i])
rates.append(rate)
print "Average: {} MB/s".format(sum(rates)/(len(rates)*1e6))
return rates
voltage_range = 0x01
time_fxn = time.time
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.set_ch1_voltage_range(voltage_range)
for sample_rate_index in [0x30, 0x10, 0x08, 0x04, 0x01, 0x32, 0x14, 0x0A]:
scope.set_sample_rate(sample_rate_index)
_, label = scope.convert_sampling_rate_to_measurement_times(1, sample_rate_index)
print "Sample rate: {}".format(label)
print "-"*40
for data_points in [0x800, 0x1000, 0x8000, 0x10000, 0x80000, 0x100000, 0x200000]:
reader_fxn = scope.build_data_reader(raw=True)
times = []
times_append = times.append
times_append(time_fxn())
for _ in xrange(iterations):
numchannels = 1
blocksize = 6*1024 # should be divisible by 6*1024
alternative = 1 # choose ISO 3072 bytes per 125 us
@atexit.register
def close():
time.sleep(2)
scope.stop_capture()
scope.close_handle()
data = []
data_extend = data.append
def extend_callback(ch1_data, _):
data_extend(ch1_data)
f = open("test.out", "wb")
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.set_interface(alternative);
scope.set_num_channels(numchannels)
scope.set_ch1_voltage_range(voltage_range)
scope.set_sample_rate(samplerate)
scope.start_capture()
while True:
scope.read_async(extend_callback, blocksize, outstanding_transfers=1,raw=True)
for block in data:
f.write(block)
class Plugin(LoggerPlugin):
"""
Diese Gerät zeichnet die Daten eines Hantek6022 (und möglicherweise anderer) Oszilloskops auf.
"""
def __init__(self, *args, **kwargs):
# Plugin setup
super(Plugin, self).__init__(*args, **kwargs)
self.setDeviceName(DEVICENAME)
self.smallGUI = False
self._scope = None
self.setPerpetualTimer(self._updateT, samplerate=SAMPLERATE)
self._blocksize = 6 * 1024 # should be divisible by 6*1024
self._alternative = 1 # choose ISO 3072 bytes per 125 us
self._recordLength = 5000
self._blocksize = self._recordLength
self._yData1 = deque(maxlen=self._recordLength)
self._yData2 = deque(maxlen=self._recordLength)
self._yData1Triggered = deque(maxlen=self._recordLength)
self._yData2Triggered = deque(maxlen=self._recordLength)
self._singleTriggerFound = False
self.__capturer = Thread(target=self.__captureT)
self.__capturer.start()
# THIS IS YOUR THREAD
def _updateT(self):
if not self.widget.pauseButton.isChecked():
if self.widget.enableTriggerButton.isChecked():
yData1, yData2, stop = self.__trigger(list(self._yData1),
list(self._yData2))
else:
yData1 = self._yData1
yData2 = self._yData2
stop = False
samplerate = self._str2Samplerate(
self.widget.samplerateComboBox.currentText())
xData = [(i - len(yData1)) / samplerate
for i in range(len(yData1))]
if len(self._yData1) > 1:
self.plot(xData, yData1, dname='Hantek', sname='CH1', unit='V')
if self.widget.channel2CheckBox.isChecked():
self.plot(xData, yData2, dname='Hantek', sname='CH2', unit='V')
if stop:
self.widget.pauseButton.setChecked(True)
def __captureT(self):
#self.last_time = time.time()
shutdown_event = self._scope.read_async(self._extend_callback,
self._blocksize,
outstanding_transfers=10,
raw=True)
self._scope.start_capture()
while self.run:
self._scope.poll()
# logging.info("Stopping new transfers.")
# scope.stop_capture()
self._scope.stop_capture()
shutdown_event.set()
time.sleep(0.1)
self._scope.close_handle()
def loadGUI(self):
self.widget = QtWidgets.QWidget()
packagedir = self.getDir(__file__)
uic.loadUi(packagedir + "/Hantek6022/hantek.ui", self.widget)
# self.setCallbacks()
self.widget.reconnectButton.clicked.connect(
self.__openConnectionCallback)
self.widget.samplerateComboBox.currentTextChanged.connect(
self._updateScopeSettings)
self.widget.recordLengthSpinBox.valueChanged.connect(self.changeLength)
# self.widget.channel1CheckBox.valueChanged.connect(self.enableChannel1)
self.widget.channel1CheckBox.setEnabled(False)
self.widget.channel1ACDCComboBox.hide() # valueChanged.connect(self.)
self.widget.channel1VoltPDivComboBox.currentTextChanged.connect(
self._updateScopeSettings)
self.widget.channel2VoltPDivComboBox.currentTextChanged.connect(
self._updateScopeSettings)
self.widget.channel2CheckBox.stateChanged.connect(
self._updateScopeSettings)
self.widget.channel2ACDCComboBox.hide() # valueChanged.connect(self.)
# self.widget.pauseButton.clicked.connect(self.)
# self.widget.triggerChannelComboBox.textChanged.connect(self.)
# self.widget.triggerLevelSpinBox.valueChanged.connect(self.)
# self.widget.enableTriggerButton.clicked.connect(self.)
self._recordLength = self.widget.recordLengthSpinBox.value()
self.xData = deque(maxlen=self._recordLength)
self._yData1 = deque(maxlen=self._recordLength)
self._yData2 = deque(maxlen=self._recordLength)
self.__openConnectionCallback()
return self.widget
def __openConnectionCallback(self):
self.widget.reconnectButton.setEnabled(False)
if self.run:
self.cancel()
self.widget.reconnectButton.setText("Reconnect")
self.__base_address = ""
self.widget.reconnectButton.setEnabled(True)
else:
self._updateScopeSettings()
self.widget.reconnectButton.setText("Stop")
self.widget.reconnectButton.setEnabled(True)
def __trigger(self, data1, data2):
if not self._singleTriggerFound:
if self.widget.channel2CheckBox.isChecked(
) and self.widget.triggerChannelComboBox.currentText() == 'CH2':
triggerSignal = list(data2)
else:
triggerSignal = list(data1)
flanke = self.widget.comboBox.currentText()
triggerLevel = self.widget.triggerLevelSpinBox.value()
cutoff = 0
mean = self.widget.smoothSpinBox.value()
triggerPrepared = False
if flanke == 'Rising':
if max(triggerSignal) > triggerLevel:
for idx in range(len(triggerSignal)):
if triggerSignal[
idx] >= triggerLevel - mean and triggerSignal[
idx] <= triggerLevel:
triggerPrepared = True
elif triggerSignal[
idx] < triggerLevel - mean and triggerPrepared:
triggerPrepared = False
elif triggerSignal[
idx] > triggerLevel and triggerPrepared == True:
cutoff = idx
break
else:
if min(triggerSignal) < triggerLevel:
for idx in range(len(triggerSignal)):
if triggerSignal[
idx] <= triggerLevel + mean and triggerSignal[
idx] >= triggerLevel:
triggerPrepared = True
elif triggerSignal[
idx] > triggerLevel + mean and triggerPrepared:
triggerPrepared = False
elif triggerSignal[
idx] < triggerLevel and triggerPrepared == True:
cutoff = idx
break
stop = False
if len(data2) > cutoff:
data2 = list(data2)[cutoff:]
if len(data1) > cutoff:
data1 = list(data1)[cutoff:]
if cutoff != 0 and self.widget.checkBox.isChecked(
) and not self._singleTriggerFound:
self._singleTriggerFound = True
else:
self._singleTriggerFound = False
if self.widget.checkBox.isChecked():
self._yData1Triggered = deque(list(data1),
maxlen=self._recordLength)
self._yData2Triggered = deque(list(data2),
maxlen=self._recordLength)
else:
if len(self._yData1Triggered) < self._recordLength:
stop = False
else:
self._singleTriggerFound = False
stop = True
data1 = self._yData1Triggered
data2 = self._yData2Triggered
return data1, data2, stop
def _updateScopeSettings(self):
if self._scope:
self.cancel()
self._scope = Oscilloscope()
self._scope.setup()
self._scope.open_handle()
if (not self._scope.is_device_firmware_present):
self._scope.flash_firmware()
else:
self._scope.supports_single_channel = True
logging.info("Setting up scope!")
self._scope.set_interface(self._alternative)
logging.info("ISO" if self._scope.is_iso else "BULK", "packet size:",
self._scope.packetsize)
if self.widget.channel2CheckBox.isChecked():
self._scope.set_num_channels(2)
else:
self._scope.set_num_channels(1)
# set voltage range
voltagerange1 = self._strVoltageToID(
self.widget.channel1VoltPDivComboBox.currentText())
voltagerange2 = self._strVoltageToID(
self.widget.channel2VoltPDivComboBox.currentText())
self._scope.set_ch1_voltage_range(voltagerange1)
self._scope.set_ch2_voltage_range(voltagerange2)
self._scope.set_sample_rate(
self._str2SamplerateID(
self.widget.samplerateComboBox.currentText()))
self._blocksize = self._recordLength
self.start()
# self.widget.reconnectButton.setText("Stop")
# self.widget.reconnectButton.setEnabled(True)
def calibrate(self):
if self._scope:
self._scope.setup_dso_cal_level()
cal_level = self._scope.get_calibration_data()
self._scope.set_dso_calibration(cal_level)
def _str2SamplerateID(self, strung):
if 'MHz' in strung:
strung = strung.replace(' MHz', '')
return int(strung)
else:
strung = strung.replace(' kHz', '')
return int(int(strung) / 10)
def _str2Samplerate(self, strung):
if 'MHz' in strung:
strung = strung.replace(' MHz', '')
return int(strung) * 1000000
else:
strung = strung.replace(' kHz', '')
return int(strung) * 1000
# def __changeChannel1VoltPDiv(self, strung):
# if self._scope:
# voltagerange = self._strVoltageToID(strung)
# self._scope.set_ch1_voltage_range(voltagerange)
#
# def __changeChannel2VoltPDiv(self, strung):
# if self._scope:
# voltagerange = self._strVoltageToID(strung)
# self._scope.set_ch2_voltage_range(voltagerange)
def _enableChannel2(self, value):
if value:
self._scope.set_num_channels(2)
else:
self._scope.set_num_channels(1)
def _strVoltageToID(self, strung):
voltagerange = 1
if strung == '2.6 V':
voltagerange = 2
elif strung == '5 V':
voltagerange = 5
elif strung == '10 V':
voltagerange = 10
return voltagerange
def _extend_callback(self, ch1_data, ch2_data):
voltage_data = self._scope.scale_read_data(
ch1_data,
self._strVoltageToID(
self.widget.channel1VoltPDivComboBox.currentText()))
if len(voltage_data) > 1:
self._yData1.extend(voltage_data)
if len(self._yData1Triggered) < self._recordLength:
if len(self._yData1Triggered) + len(
voltage_data) < self._recordLength:
self._yData1Triggered.extend(voltage_data)
else:
self._yData1Triggered.extend(
voltage_data[0:self._recordLength -
len(self._yData1Triggered)])
if ch2_data != '':
voltage_data = self._scope.scale_read_data(
ch2_data,
self._strVoltageToID(
self.widget.channel1VoltPDivComboBox.currentText()))
self._yData2.extend(voltage_data)
if len(self._yData2Triggered) < self._recordLength:
if len(self._yData2Triggered) + len(
voltage_data) < self._recordLength:
self._yData2Triggered.extend(voltage_data)
else:
self._yData2Triggered.extend(
voltage_data[0:self._recordLength -
len(self._yData2Triggered)])
def changeLength(self, newlen: int = 10000):
self._recordLength = newlen
self._yData1 = deque(maxlen=self._recordLength)
self._yData2 = deque(maxlen=self._recordLength)
self._yData1Triggered = deque(maxlen=self._recordLength)
self._yData2Triggered = deque(maxlen=self._recordLength)
self._updateScopeSettings()
#!/usr/bin/python3
"""
Flash default firmware into device
ither firmare-DSO6022BE or firmware-DSO6022BL or firmware-DSO6021
depending on VID/PID
"""
from PyHT6022.LibUsbScope import Oscilloscope
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.flash_firmware()
print("FW version", hex(scope.get_fw_version()))
scope.close_handle()
#!/usr/bin/python3 from PyHT6022.LibUsbScope import Oscilloscope firmware = "dso6021-firmware.hex" VID=0x04b4 PID=0x6021 scope = Oscilloscope( VID, PID ) scope.setup() scope.open_handle() scope.flash_firmware_from_hex( firmware ) print( "FW version", hex( scope.get_fw_version() ) ) scope.close_handle()
current = 0
elif entry > threshold and running:
current += 1
elif entry < threshold and running:
stability.append(current)
running = False
else:
continue
return stability[1:-1]
sample_rate_index = 0x1E
voltage_range = 0x01
data_points = 3 * 1024
scope = Oscilloscope()
scope.setup()
scope.open_handle()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
scope.set_interface(1); # choose ISO
scope.set_num_channels(1)
scope.set_sample_rate(sample_rate_index)
scope.set_ch1_voltage_range(voltage_range)
time.sleep(1)
data = deque(maxlen=2*1024*1024)
data_extend = data.extend
def extend_callback(ch1_data, _):
from PyHT6022.LibUsbScope import Oscilloscope
import pylab
def apply_data_smoothing(data, window=1):
new_data = data[:window]
for i, point in enumerate(data[window:-window]):
new_data.append(sum(data[i-window:i+window+1])/(2*window+1))
new_data.extend(data[-window:])
return new_data
sample_rate_index = 0x04
voltage_range = 0x01
data_points = 0x2000
scope = Oscilloscope()
scope.setup()
scope.open_handle()
scope.set_sample_rate(sample_rate_index)
scope.set_ch1_voltage_range(voltage_range)
ch1_data, _ = scope.read_data(data_points)
voltage_data = scope.scale_read_data(ch1_data, voltage_range)
timing_data, _ = scope.convert_sampling_rate_to_measurement_times(data_points, sample_rate_index)
scope.close_handle()
pylab.title('Scope Visualization Example')
pylab.plot(timing_data, voltage_data, color='#009900', label='Raw Trace')
pylab.plot(timing_data, apply_data_smoothing(voltage_data, window=3), color='#0033CC', label='Smoothed Trace')
pylab.xlabel('Time (s)')
pylab.ylabel('Voltage (V)')
pylab.grid()
pylab.legend(loc='best')
#!/usr/bin/python3 __author__ = 'Robert Cope' """ """ from PyHT6022.LibUsbScope import Oscilloscope scope = Oscilloscope() scope.setup() scope.open_handle() print(hex(scope.get_fw_version())) scope.close_handle()
#!/usr/bin/python3 from PyHT6022.LibUsbScope import Oscilloscope scope = Oscilloscope() scope.setup() scope.open_handle() scope.flash_firmware() print( "FW version", hex( scope.get_fw_version() ) ) # read 1st 8 bytes eeprom = scope.read_eeprom( 0, 8 ) # print( eeprom ) # EE_SIZE = 128 # 16 KByte 24C128 EE_SIZE = 2 # 256 Byte 24C02 # clear eeprom empty = bytearray( 128 ) adr = 0 while adr < EE_SIZE * 128: print( "Erase", hex(adr) ) scope.write_eeprom( adr, empty ) adr += 128 # get the Hantek6021 id f = open( "eeprom_6021.dat", "rb" ) hantek_id = (f.read()) f.close() for b in hantek_id:
__author__ = 'Jochen Hoenicke' from PyHT6022.LibUsbScope import Oscilloscope scope = Oscilloscope() scope.setup() scope.open_handle() firmware = scope.read_firmware(length=16*1024, chunk_len=32) scope.close_handle() print firmware
__author__ = 'Jochen Hoenicke'
from PyHT6022.LibUsbScope import Oscilloscope
scope = Oscilloscope()
scope.setup()
scope.open_handle()
eeprom = scope.read_eeprom(0, 256)
scope.close_handle()
print eeprom.encode('hex')
class ScopeInterface(QObject):
new_data = pyqtSignal(list)
def __init__(self, parent=None):
super(ScopeInterface, self).__init__(parent)
self.inprogress = False
def initialize(self):
self.sample_rate_index = 8
self.voltage_range = 0x01
self.data_points = 3 * 1024
self.trigger_level = 150
self.trigger_type = +1
self.scope = Oscilloscope()
self.scope.setup()
self.scope.open_handle()
if (not self.scope.is_device_firmware_present):
self.scope.flash_firmware()
self.scope.set_interface(1)
# choose ISO
self.scope.set_num_channels(1)
self.scope.set_sample_rate(self.sample_rate_index)
self.scope.set_ch1_voltage_range(self.voltage_range)
time.sleep(0.1)
return None
def capture(self):
if not self.inprogress:
self.inprogress = True
self.scope.start_capture()
shutdown_event = self.scope.read_async(self.data_callback,
self.data_points,
outstanding_transfers=25)
print("Clearing FIFO and starting data transfer...")
def data_callback(self, ch1_data, _):
d = list(ch1_data)
i = 0
#print("got new data ", time.time(), " : ", len(d))
if self.trigger_type > 0:
while (i < len(d) - 1) and not (d[i + 1] > self.trigger_level
and d[i] < self.trigger_level):
i += 1
#print("Trigger at ", i)
if (i != len(d) - 1):
self.new_data.emit(d[i:])
def stop(self):
self.scope.stop_capture()
print("Stopping new transfers.")
shutdown_event.set()
print("Snooze 1")
time.sleep(1)
print("Closing handle")
self.scope.close_handle()
print("Handle closed.")
self.inprogress = False
from struct import pack
import sys
import time
from collections import deque
from PyHT6022.LibUsbScope import Oscilloscope
voltagerange = 10 # 1 (5V), 2 (2.6V), 5 or 10
samplerate = 24 # sample rate in MHz or in 10khz
numchannels = 1
numseconds = 8 # number of seconds to sample
blocksize = 6 * 1024 # should be divisible by 6*1024
alternative = 1 # choose ISO 3072 bytes per 125 us
scope = Oscilloscope()
scope.setup()
scope.open_handle()
if (not scope.is_device_firmware_present):
scope.flash_firmware()
else:
scope.supports_single_channel = True
print("Setting up scope!")
scope.set_interface(alternative)
print("ISO" if scope.is_iso else "BULK", "packet size:", scope.packetsize)
scope.set_num_channels(numchannels)
# set voltage range
scope.set_ch1_voltage_range(voltagerange)
# set sample rate
scope.set_sample_rate(samplerate)
#!/usr/bin/python3 __author__ = 'Jochen Hoenicke' from PyHT6022.LibUsbScope import Oscilloscope scope = Oscilloscope() scope.setup() scope.open_handle() firmware = scope.read_firmware(length=16*1024, chunk_len=32) scope.close_handle() print(firmware)
#!/usr/bin/python3 __author__ = 'Robert Cope' from PyHT6022.LibUsbScope import Oscilloscope from PyHT6022.HantekFirmware import mod_firmware_iso as Firmware scope = Oscilloscope() scope.setup() scope.open_handle() scope.flash_firmware(firmware=Firmware) scope.close_handle()
__author__ = 'Robert Cope' from PyHT6022.LibUsbScope import Oscilloscope scope = Oscilloscope() scope.setup() scope.open_handle() scope.flash_firmware() scope.close_handle()
