def _set_channel_input_frequency_max(self, index, value):
value = float(value)
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate:
self._set_channel_bw_limit(index, value < 20e6)
self._channel_input_frequency_max[index] = value
self._set_cache_valid(index=index)
def _set_channel_offset(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = float(value)
if not self._driver_operation_simulate:
self._write("%s:OFST %.5e" % (self._channel_command_name[index], value))
self._channel_offset[index] = value
self._set_cache_valid(index=index)
def _measurement_fetch_waveform_measurement(self, index, measurement_function, ref_channel = None):
index = ivi.get_index(self._channel_name, index)
if measurement_function not in MeasurementFunctionMapping:
raise ivi.ValueNotSupportedException()
measurement_function = MeasurementFunctionMapping[measurement_function]
if not self._driver_operation_simulate:
# Look for a measurement slot to use (preferrably one available or already measuring what we want so as not to require overriding an existing measurement)
selected_slot = None
must_configure = True
for slot, value in self._measurement_slots.items():
# If a slot is already configured for our exact measurement, use it and stop looking
if value == (self._channel_name[index], measurement_function):
selected_slot = slot
must_configure = False
break
# If a slot is available (not configured), we might use it, but keep looking for better
elif value is None:
selected_slot = slot
# If nothing better is found, we'll just have to use this one anyway...
elif selected_slot is None:
selected_slot = slot
# Configure the measurement slot if it wasn't already just as we need
if must_configure:
self._write("MDSP ON")
self._write("MINMAX OFF")
self._measurement_slots[selected_slot] = (self._channel_name[index], measurement_function)
self._write("DIRM %s" % selected_slot)
self._write("MSEL %s, %s" % self._measurement_slots[selected_slot])
# Wait half a second so the measurement has at least a small chance to be computed
time.sleep(0.5)
value = float(self._ask("MSR%s?" % selected_slot).split(',')[0])
if value == 9.91e37:
return float('NaN')
return value
return 0
def _set_channel_enabled(self, index, value):
value = bool(value)
index = ivi.get_index(self._channel_command_name, index)
if not self._driver_operation_simulate:
self._write("%s:TRA %s" % (self._channel_command_name[index], self._bool_to_onoff(value)))
self._channel_enabled[index] = value
self._set_cache_valid(index=index)
def _set_channel_input_frequency_max(self, index, value):
value = float(value)
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate:
self._set_channel_bw_limit(index, value < 20e6)
self._channel_input_frequency_max[index] = value
self._set_cache_valid(index=index)
def _get_channel_coupling(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
self._channel_coupling[index] = VerticalCouplingReverseMapping[
self._ask("%s:CPL?" % self._channel_command_name[index])]
self._set_cache_valid(index=index)
return self._channel_coupling[index]
def _set_channel_offset(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = float(value)
if not self._driver_operation_simulate:
self._write("%s:OFST %.5e" %
(self._channel_command_name[index], value))
self._channel_offset[index] = value
self._set_cache_valid(index=index)
def _set_channel_scale(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = float(value)
if not self._driver_operation_simulate:
self._write("%s:VDIV %.5e" % (self._channel_command_name[index], value))
# Coercion algorithm not implemented in driver, so not caching the value
self._set_cache_valid(False, index=index)
self._set_cache_valid(False, "channel_range", index)
def _set_channel_probe_attenuation(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = int(value)
if not self._driver_operation_simulate:
self._write("%s:PROBE manual,%d" % (self._channel_command_name[index], value))
self._channel_probe_attenuation[index] = value
self._set_cache_valid(False, "channel_probe_attenuation_auto", index)
self._set_cache_valid(index=index)
def _set_channel_enabled(self, index, value):
value = bool(value)
index = ivi.get_index(self._channel_command_name, index)
if not self._driver_operation_simulate:
self._write("%s:TRA %s" % (self._channel_command_name[index],
self._bool_to_onoff(value)))
self._channel_enabled[index] = value
self._set_cache_valid(index=index)
def _get_channel_scale(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
self._channel_scale[index] = float(self._ask("%s:VDIV?" % self._channel_command_name[index]))
self._channel_range[index] = self._channel_scale[index] * self._vertical_divisions
self._set_cache_valid(index=index)
self._set_cache_valid(True, "channel_range", index)
return self._channel_scale[index]
def _get_channel_offset(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
self._channel_offset[index] = float(
self._ask("%s:OFST?" % self._channel_command_name[index]))
self._set_cache_valid(index=index)
return self._channel_offset[index]
def _set_channel_coupling(self, index, value):
index = ivi.get_index(self._channel_name, index)
if value not in VerticalCouplingMapping:
raise ivi.ValueNotSupportedException()
if not self._driver_operation_simulate:
self._write("%s:CPL %s" % (self._channel_command_name[index], VerticalCouplingMapping[value]))
self._channel_coupling[index] = value
self._set_cache_valid(False, "channel_input_impedance", index)
self._set_cache_valid(index=index)
def _get_channel_bw_limit(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
value = self._ask("%s:BWL?" % self._channel_command_name[index]).lower()
if value == 'full':
value = False
self._channel_bw_limit[index] = value
self._set_cache_valid(index=index)
return self._channel_bw_limit[index]
def _set_channel_scale(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = float(value)
if not self._driver_operation_simulate:
self._write("%s:VDIV %.5e" %
(self._channel_command_name[index], value))
# Coercion algorithm not implemented in driver, so not caching the value
self._set_cache_valid(False, index=index)
self._set_cache_valid(False, "channel_range", index)
def _get_channel_input_impedance(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
if self._ask("%s:CPL?" % self._channel_command_name[index]).count("50") > 0:
self._channel_input_impedance[index] = 50
else:
self._channel_input_impedance[index] = 1000000
self._set_cache_valid(index=index)
return self._channel_input_impedance[index]
def _get_channel_enabled(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
self._channel_enabled[index] = (self._ask(
"%s:TRA?" %
self._channel_command_name[index]).lower() == ('on'))
self._set_cache_valid(index=index)
return self._channel_enabled[index]
def _set_channel_probe_attenuation(self, index, value):
index = ivi.get_index(self._channel_name, index)
value = int(value)
if not self._driver_operation_simulate:
self._write("%s:PROBE manual,%d" %
(self._channel_command_name[index], value))
self._channel_probe_attenuation[index] = value
self._set_cache_valid(False, "channel_probe_attenuation_auto", index)
self._set_cache_valid(index=index)
def _get_channel_probe_attenuation_auto(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
self._channel_probe_attenuation_auto[index] = (self._ask(
"%s:PROBE?" % self._channel_command_name[index]).split(
',')[0].lower() == 'auto')
self._set_cache_valid(index=index)
return self._channel_probe_attenuation_auto[index]
def _set_channel_coupling(self, index, value):
index = ivi.get_index(self._channel_name, index)
if value not in VerticalCouplingMapping:
raise ivi.ValueNotSupportedException()
if not self._driver_operation_simulate:
self._write("%s:CPL %s" % (self._channel_command_name[index],
VerticalCouplingMapping[value]))
self._channel_coupling[index] = value
self._set_cache_valid(False, "channel_input_impedance", index)
self._set_cache_valid(index=index)
def _get_channel_bw_limit(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
value = self._ask("%s:BWL?" %
self._channel_command_name[index]).lower()
if value == 'full':
value = False
self._channel_bw_limit[index] = value
self._set_cache_valid(index=index)
return self._channel_bw_limit[index]
def _get_channel_input_impedance(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
if self._ask("%s:CPL?" %
self._channel_command_name[index]).count("50") > 0:
self._channel_input_impedance[index] = 50
else:
self._channel_input_impedance[index] = 1000000
self._set_cache_valid(index=index)
return self._channel_input_impedance[index]
def _set_channel_probe_attenuation_auto(self, index, value):
index = ivi.get_index(self._channel_name, index)
if bool(value):
value = 'auto'
else:
value = 'manual'
if not self._driver_operation_simulate:
self._write("%s:PROBE %s,1" % (self._channel_command_name[index], value))
self._channel_probe_attenuation_auto[index] = value
self._set_cache_valid(False, "channel_probe_attenuation", index)
self._set_cache_valid(index=index)
def _get_channel_scale(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(
index=index):
self._channel_scale[index] = float(
self._ask("%s:VDIV?" % self._channel_command_name[index]))
self._channel_range[
index] = self._channel_scale[index] * self._vertical_divisions
self._set_cache_valid(index=index)
self._set_cache_valid(True, "channel_range", index)
return self._channel_scale[index]
def _set_channel_probe_attenuation_auto(self, index, value):
index = ivi.get_index(self._channel_name, index)
if bool(value):
value = 'auto'
else:
value = 'manual'
if not self._driver_operation_simulate:
self._write("%s:PROBE %s,1" %
(self._channel_command_name[index], value))
self._channel_probe_attenuation_auto[index] = value
self._set_cache_valid(False, "channel_probe_attenuation", index)
self._set_cache_valid(index=index)
def _set_channel_input_impedance(self, index, value):
value = float(value)
index = ivi.get_index(self._channel_name, index)
if not (value == 1000000 or (value == 50 and self._channel_coupling[index] == 'dc')):
raise Exception('Invalid impedance selection')
if not self._driver_operation_simulate:
if self._channel_coupling[index] == 'dc':
if value == 1000000:
self._write("%s:CPL DC1M" % self._channel_command_name[index])
elif value == 50:
self._write("%s:CPL DC50" % self._channel_command_name[index])
self._channel_input_impedance[index] = value
self._set_cache_valid(index=index)
def _set_channel_bw_limit(self, index, value):
index = ivi.get_index(self._channel_name, index)
if type(value) == bool:
if value:
value = '20m'
else:
value = 'full'
if value.lower() not in ['full', '20m', '100m']:
raise ivi.ValueNotSupportedException()
if not self._driver_operation_simulate:
self._write("%s:BWL %s" % (self._channel_command_name[index], value))
self._channel_bw_limit[index] = value
self._set_cache_valid(index=index)
def _set_channel_bw_limit(self, index, value):
index = ivi.get_index(self._channel_name, index)
if type(value) == bool:
if value:
value = '20m'
else:
value = 'full'
if value.lower() not in ['full', '20m', '100m']:
raise ivi.ValueNotSupportedException()
if not self._driver_operation_simulate:
self._write("%s:BWL %s" %
(self._channel_command_name[index], value))
self._channel_bw_limit[index] = value
self._set_cache_valid(index=index)
def _measurement_fetch_waveform(self, index):
index = ivi.get_index(self._channel_name, index)
if self._driver_operation_simulate:
return list()
self._write("DTFORM WORD")
self._write("DTBORD H/L")
self._write("DTSTART 0")
self._write("DTPOINTS 500K")
self._write("WAVESRC %s" % self._channel_name[index])
# Read preamble
pre = self._ask("DTINF?").split(',')
points = int(pre[2 + 4 * self._channel_count +
5].split('=')[1].lstrip())
xincrement = self._suffixed_string_to_float(
pre[2 + 4 * self._channel_count +
2].split('=')[1].lstrip().rstrip('s'))
tdiv = self._suffixed_string_to_float(
pre[2 + 4 * self._channel_count +
2].split('=')[1].lstrip().rstrip('s'))
trigdelay = self._suffixed_string_to_float(
pre[2 + 4 * self._channel_count +
3].split('=')[1].lstrip().rstrip('s'))
xorigin = -(tdiv * self._horizontal_divisions / 2 + trigdelay)
yincrement = self._suffixed_string_to_float(
pre[2 + 4 * index + 2].split('=')[1].lstrip().rstrip('V'))
yorigin = self._suffixed_string_to_float(
pre[2 + 4 * index + 3].split('=')[1].lstrip().rstrip('V'))
# Probe ratio is not taken into account in the info from DTINF, so do it ourselves (dirty, the ratio might have changed since acquisition...)
yincrement /= self._get_channel_probe_attenuation(index)
yorigin /= self._get_channel_probe_attenuation(index)
self._write("DTWAVE?")
# Read waveform data
raw_data = self._read_ieee_block()
# Split out points and convert to time and voltage pairs
data = list()
for i in range(points):
x = (i * xincrement) + xorigin
# Convert big-endian unsigned word to Python integer
yval = struct.unpack(">H", raw_data[i * 2:i * 2 + 2])[0]
y = (yval * yincrement) + yorigin
data.append((x, y))
return data
def _set_channel_input_impedance(self, index, value):
value = float(value)
index = ivi.get_index(self._channel_name, index)
if not (value == 1000000 or
(value == 50 and self._channel_coupling[index] == 'dc')):
raise Exception('Invalid impedance selection')
if not self._driver_operation_simulate:
if self._channel_coupling[index] == 'dc':
if value == 1000000:
self._write("%s:CPL DC1M" %
self._channel_command_name[index])
elif value == 50:
self._write("%s:CPL DC50" %
self._channel_command_name[index])
self._channel_input_impedance[index] = value
self._set_cache_valid(index=index)
def _measurement_fetch_waveform(self, index):
index = ivi.get_index(self._channel_name, index)
if self._driver_operation_simulate:
return list()
self._write("DTFORM WORD")
self._write("DTBORD H/L")
self._write("DTSTART 0")
self._write("DTPOINTS 500K")
self._write("WAVESRC %s" % self._channel_name[index])
# Read preamble
pre = self._ask("DTINF?").split(',')
points = int(pre[2+4*self._channel_count+5].split('=')[1].lstrip())
xincrement = self._suffixed_string_to_float(pre[2+4*self._channel_count+2].split('=')[1].lstrip().rstrip('s'))
tdiv = self._suffixed_string_to_float(pre[2+4*self._channel_count+2].split('=')[1].lstrip().rstrip('s'))
trigdelay = self._suffixed_string_to_float(pre[2+4*self._channel_count+3].split('=')[1].lstrip().rstrip('s'))
xorigin = - (tdiv * self._horizontal_divisions / 2 + trigdelay)
yincrement = self._suffixed_string_to_float(pre[2+4*index+2].split('=')[1].lstrip().rstrip('V'))
yorigin = self._suffixed_string_to_float(pre[2+4*index+3].split('=')[1].lstrip().rstrip('V'))
# Probe ratio is not taken into account in the info from DTINF, so do it ourselves (dirty, the ratio might have changed since acquisition...)
yincrement /= self._get_channel_probe_attenuation(index)
yorigin /= self._get_channel_probe_attenuation(index)
self._write("DTWAVE?")
# Read waveform data
raw_data = self._read_ieee_block()
# Split out points and convert to time and voltage pairs
data = list()
for i in range(points):
x = (i * xincrement) + xorigin
# Convert big-endian unsigned word to Python integer
yval = struct.unpack(">H", raw_data[i*2:i*2+2])[0]
y = (yval * yincrement) + yorigin
data.append((x, y))
return data
def _measurement_fetch_waveform_measurement(self,
index,
measurement_function,
ref_channel=None):
index = ivi.get_index(self._channel_name, index)
if measurement_function not in MeasurementFunctionMapping:
raise ivi.ValueNotSupportedException()
measurement_function = MeasurementFunctionMapping[measurement_function]
if not self._driver_operation_simulate:
# Look for a measurement slot to use (preferrably one available or already measuring what we want so as not to require overriding an existing measurement)
selected_slot = None
must_configure = True
for slot, value in self._measurement_slots.items():
# If a slot is already configured for our exact measurement, use it and stop looking
if value == (self._channel_name[index], measurement_function):
selected_slot = slot
must_configure = False
break
# If a slot is available (not configured), we might use it, but keep looking for better
elif value is None:
selected_slot = slot
# If nothing better is found, we'll just have to use this one anyway...
elif selected_slot is None:
selected_slot = slot
# Configure the measurement slot if it wasn't already just as we need
if must_configure:
self._write("MDSP ON")
self._write("MINMAX OFF")
self._measurement_slots[selected_slot] = (
self._channel_name[index], measurement_function)
self._write("DIRM %s" % selected_slot)
self._write("MSEL %s, %s" %
self._measurement_slots[selected_slot])
# Wait half a second so the measurement has at least a small chance to be computed
time.sleep(0.5)
value = float(self._ask("MSR%s?" % selected_slot).split(',')[0])
if value == 9.91e37:
return float('NaN')
return value
return 0
def _get_channel_enabled(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
self._channel_enabled[index] = (self._ask("%s:TRA?" % self._channel_command_name[index]).lower() == ('on'))
self._set_cache_valid(index=index)
return self._channel_enabled[index]
def _get_channel_probe_attenuation_auto(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
self._channel_probe_attenuation_auto[index] = (self._ask("%s:PROBE?" % self._channel_command_name[index]).split(',')[0].lower() == 'auto')
self._set_cache_valid(index=index)
return self._channel_probe_attenuation_auto[index]
def _get_channel_input_frequency_max(self, index):
index = ivi.get_index(self._channel_name, index)
return self._channel_input_frequency_max[index]
def _get_channel_coupling(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
self._channel_coupling[index] = VerticalCouplingReverseMapping[self._ask("%s:CPL?" % self._channel_command_name[index])]
self._set_cache_valid(index=index)
return self._channel_coupling[index]
def _get_channel_range(self, index):
index = ivi.get_index(self._channel_name, index)
self._get_channel_scale(index)
return self._channel_range[index]
def _get_channel_offset(self, index):
index = ivi.get_index(self._channel_name, index)
if not self._driver_operation_simulate and not self._get_cache_valid(index=index):
self._channel_offset[index] = float(self._ask("%s:OFST?" % self._channel_command_name[index]))
self._set_cache_valid(index=index)
return self._channel_offset[index]
def _get_channel_range(self, index):
index = ivi.get_index(self._channel_name, index)
self._get_channel_scale(index)
return self._channel_range[index]
def _get_channel_input_frequency_max(self, index):
index = ivi.get_index(self._channel_name, index)
return self._channel_input_frequency_max[index]
