def test_lakeshore475_control_slope_limit(): """ Get / set slope limit, unitful and not. """ with expected_protocol( ik.lakeshore.Lakeshore475, [ "CPARAM?", "UNIT?", "CPARAM?", "UNIT?", "UNIT?", "CPARAM 1.0,10.0,42.0,42.0", "CPARAM?", "UNIT?", "UNIT?", "CPARAM 1.0,10.0,42.0,42.0", ], [ "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", # teslas "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", # teslas "2", "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", "2" ], ) as lsh: assert lsh.control_slope_limit == u.Quantity(100.0, u.V / u.min) lsh.control_slope_limit = u.Quantity(42000.0, u.mV / u.min) lsh.control_slope_limit = 42.0
def test_apt_mc_motion_timeout(init_kdc101): """Set and get motion timeout.""" with expected_protocol(ik.thorlabs.APTMotorController, [init_kdc101[0]], [init_kdc101[1]], sep="") as apt: apt.channel[0].motion_timeout = u.Quantity(100, u.s) assert apt.channel[0].motion_timeout == u.Quantity(100, u.s)
def test_power(): with expected_protocol(ik.phasematrix.PhaseMatrixFSW0020, [ "0D.", "03{:04X}.".format( int(u.Quantity(10, u.dBm).to(u.cBm).magnitude)) ], ["-064"]) as inst: assert inst.power == u.Quantity(-10, u.dBm) inst.power = u.Quantity(10, u.dBm)
def test_tc200_temperature_set(): with expected_protocol( ik.thorlabs.TC200, ["tset?", "tmax?", "tset=40"], ["tset?", "30 C", "> tmax?", "250", "> tset=40", "> "], sep="\r") as tc: assert tc.temperature_set == u.Quantity(30.0, u.degC) tc.temperature_set = u.Quantity(40, u.degC)
def test_visacomm_timeout(visa_inst): """Set / Get timeout of VISA communicator.""" comm = VisaCommunicator(visa_inst) comm.timeout = 3 assert comm.timeout == u.Quantity(3, u.s) comm.timeout = u.Quantity(40000, u.ms) assert comm.timeout == u.Quantity(40, u.s)
def test_srsdg645_holdoff(): """ SRSDG645: Set / get hold off. """ with expected_protocol(ik.srs.SRSDG645, ["HOLD?", "HOLD 0", "HOLD 0.01"], ["+0.001001000000"]) as ddg: assert u.Quantity(1001, u.us) == ddg.holdoff ddg.holdoff = 0 ddg.holdoff = u.Quantity(10, u.ms) # unitful hold off
def test_srsdg645_burst_period(): """ SRSDG645: Checks getting/setting of enabling T0 output on first in burst mode. """ with expected_protocol(ik.srs.SRSDG645, ["BURP?", "BURP 13", "BURP 0.1"], ["100E-9"]) as ddg: unit_eq(ddg.burst_period, u.Quantity(100, "ns").to(u.sec)) ddg.burst_period = u.Quantity(13, "s") ddg.burst_period = 0.1
def test_channel_power_getter(): with expected_protocol( ik.holzworth.HS9000, [":ATTACH?", ":CH1:PWR?", ":CH1:PWR:MIN?", ":CH1:PWR:MAX?"], [":CH1:CH2:FOO", "0", "-100", "20"], sep="\n") as hs: channel = hs.channel[0] assert channel.power == u.Quantity(0, u.dBm) assert channel.power_min == u.Quantity(-100, u.dBm) assert channel.power_max == u.Quantity(20, u.dBm)
def test_srsdg645_burst_delay(): """ SRSDG645: Checks getting/setting of enabling T0 output on first in burst mode. """ with expected_protocol(ik.srs.SRSDG645, ["BURD?", "BURD 42", "BURD 0.1"], ["0"]) as ddg: unit_eq(ddg.burst_delay, u.Quantity(0, "s")) ddg.burst_delay = u.Quantity(42, "s") ddg.burst_delay = 0.1
def test_unitful_property_sendcmd_query(mock_inst): """Assert that unitful_property calls sendcmd, query of parent class.""" # getter assert mock_inst.unitful_property == u.Quantity(42, u.K) mock_inst.spy_query.assert_called() # setter value = 13 mock_inst.unitful_property = u.Quantity(value, u.K) assert mock_inst._sendcmd == f"42 {value:e}" mock_inst.spy_sendcmd.assert_called()
def test_srsdg645_trigger_rate(): """ SRSDG645: Set / get trigger rate. """ with expected_protocol(ik.srs.SRSDG645, ["TRAT?", "TRAT 10000", "TRAT 1000"], ["+1000.000000"]) as ddg: assert ddg.trigger_rate == u.Quantity(1000, u.Hz) ddg.trigger_rate = 10000 ddg.trigger_rate = u.Quantity(1000, u.Hz) # unitful send
def test_yaml_quantity_tag(): yaml_data = StringIO(u""" a: b: !Q 37 tesla c: !Q 41.2 inches d: !Q 98 """) data = yaml.load(yaml_data, Loader=yaml.Loader) assert data['a']['b'] == u.Quantity(37, 'tesla') assert data['a']['c'] == u.Quantity(41.2, 'inches') assert data['a']['d'] == 98
def test_channel_offset(channel, val_read, val_unitless, val_millivolt): """Get / set offset.""" val_read = u.Quantity(val_read, u.V) val_unitful = u.Quantity(val_millivolt, u.mV) with expected_protocol(ik.tektronix.TekAWG2000, [ f"FG:CH{channel+1}:OFFS?", f"FG:CH{channel+1}:OFFS {val_unitless}", f"FG:CH{channel+1}:OFFS {val_unitful.to(u.V).magnitude}" ], [f"{val_read.magnitude}"]) as inst: assert inst.channel[channel].offset == val_read inst.channel[channel].offset = val_unitless inst.channel[channel].offset = val_unitful
def test_channel_frequency(channel, val_read, val_unitless, val_kilohertz): """Get / set offset.""" val_read = u.Quantity(val_read, u.Hz) val_unitful = u.Quantity(val_kilohertz, u.kHz) with expected_protocol(ik.tektronix.TekAWG2000, [ f"FG:FREQ?", f"FG:FREQ {val_unitless}HZ", f"FG:FREQ {val_unitful.to(u.Hz).magnitude}HZ" ], [f"{val_read.magnitude}"]) as inst: assert inst.channel[channel].frequency == val_read inst.channel[channel].frequency = val_unitless inst.channel[channel].frequency = val_unitful
def test_srsdg645_channel_delay(): """ SRSDG645: Get / set delay. """ with expected_protocol( ik.srs.SRSDG645, ["DLAY?2", "DLAY 3,2,60", "DLAY 5,4,10"], ["0,42"], ) as ddg: ref, t = ddg.channel["A"].delay assert ref == ddg.Channels.T0 assert abs((t - u.Quantity(42, "s")).magnitude) < 1e5 ddg.channel["B"].delay = (ddg.channel["A"], u.Quantity(1, "minute")) ddg.channel["D"].delay = (ddg.channel["C"], 10)
def test_get_log_point_with_unit(): """Get a log point and include a unit query.""" channel = ch_names[0] unit = ik.srs.SRSCTC100._UNIT_NAMES[ch_units[0]] values = (13, 42) which = "first" values_out = (u.Quantity(float(values[0]), u.ms), u.Quantity(float(values[1]), unit)) with expected_protocol(ik.srs.SRSCTC100, [ch_names_query, f"getLog.xy {channel}, {which}"], [ch_names_str, f"{values[0]},{values[1]}"]) as inst: with inst._error_checking_disabled(): assert (inst.channel[channel].get_log_point( which=which, units=unit) == values_out)
def test_lakeshore475_field_get_control_params(): """ Get field control parameters. """ with expected_protocol( ik.lakeshore.Lakeshore475, ["CPARAM?", "UNIT?"], [ "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2" # teslas ], ) as lsh: current_params = lsh.field_control_params assert current_params == (1.0, 10.0, u.Quantity(42.0, u.tesla / u.min), u.Quantity(100.0, u.volt / u.min))
def test_current(): """Get / Set current of instrument.""" # values to set for test value_unitless = 0.8 value_unitful = u.Quantity(50, u.mA) with expected_protocol( ik.yokogawa.Yokogawa7651, [ "F5;\nE;", # set current mode f"SA{value_unitless};", "E;", # trigger "F5;\nE;", # set current mode f"SA{value_unitful.to(u.A).magnitude};", "E;" # trigger ], [ ] ) as yok: # query with pytest.raises(NotImplementedError) as exc_info: print(f"current is: {yok.current}") exc_msg = exc_info.value.args[0] assert exc_msg == "This instrument does not support querying the " \ "output current setting." # set first current, then current mode yok.current = value_unitless yok.current = value_unitful
def available_scales(self): """Get available scales from connected device. :return: Scales currently available on device. :rtype: :class:`Blu.Scale` Example: >>> import instruments as ik >>> inst = ik.gentec_eo.Blu.open_serial('/dev/ttyACM0') >>> inst.available_scales [<Scale.max100milli: '22'>, <Scale.max300milli: '23'>, <Scale.max1: '24'>, <Scale.max3: '25'>, <Scale.max10: '26'>, <Scale.max30: '27'>, <Scale.max100: '28'>] """ # set no terminator and a 1 second timeout _terminator = self.terminator self.terminator = "" _timeout = self.timeout self.timeout = u.Quantity(1, u.s) try: # get the response resp = self._no_ack_query("*DVS").split('\r\n') finally: # set back terminator and 3 second timeout self.terminator = _terminator self.timeout = _timeout # prepare return retlist = [] # init return list of enums for line in resp: if len(line) > 0: # account for empty lines index = line[line.find("[") + 1:line.find("]")] retlist.append(self.Scale(index)) return retlist
def test_channel_voltage(): """Get / Set voltage of channel.""" # values to set for test value_unitless = 5. value_unitful = u.Quantity(500, u.mV) with expected_protocol( ik.yokogawa.Yokogawa7651, [ "F1;\nE;", # set voltage mode f"SA{value_unitless};", "E;", # trigger "F1;\nE;", # set voltage mode f"SA{value_unitful.to(u.volt).magnitude};", "E;" # trigger ], [ ] ) as yok: # query with pytest.raises(NotImplementedError) as exc_info: print(f"Voltage is: {yok.channel[0].voltage}") exc_msg = exc_info.value.args[0] assert exc_msg == "This instrument does not support querying the " \ "output voltage setting." # set first current, then voltage mode yok.channel[0].voltage = value_unitless yok.channel[0].voltage = value_unitful
def temperature_set(self, newval): # the set temperature is always in celsius newval = convert_temperature(newval, u.degC) if newval < u.Quantity(20.0, u.degC) or newval > self.max_temperature: raise ValueError("Temperature set is out of range.") out_query = "tset={}".format(newval.magnitude) self.sendcmd(out_query)
def test_keithley195_input_range(init, statusword, range): """Get / set input range. Set unitful and w/o units. """ mode = ik.keithley.Keithley195.Mode(int(statusword.decode()[5])) index = ik.keithley.Keithley195.ValidRange[mode.name].value.index(range) # new statusword new_statusword = list(statusword.decode()) new_statusword[6] = str(index + 1) new_statusword = "".join(new_statusword) # units units = ik.keithley.keithley195.UNITS2[mode] with expected_protocol( ik.keithley.Keithley195, [ init, "U0DX", f"R{index + 1}DX", "U0DX", f"R{index + 1}DX", "U0DX", # query "U0DX" ], [statusword, statusword, new_statusword, new_statusword], sep="\n") as mul: mul.input_range = range mul.input_range = u.Quantity(range, units) assert mul.input_range == range * units
def test_apt_mc_position_encoder(init_kdc101): """Get unitful position of encoder, in counts.""" with expected_protocol( ik.thorlabs.APTMotorController, [ init_kdc101[0], ThorLabsPacket( # read position message_id=ThorLabsCommands.MOT_REQ_ENCCOUNTER, param1=0x01, param2=0x00, dest=0x50, source=0x01, data=None).pack() ], [ init_kdc101[1], ThorLabsPacket(message_id=ThorLabsCommands.MOT_GET_ENCCOUNTER, param1=None, param2=None, dest=0x50, source=0x01, data=struct.pack('<Hl', 0x01, -20000)).pack() ], sep="") as apt: assert apt.channel[0].position_encoder == u.Quantity(-20000, 'counts')
def test_apt_sgr_max_travel(init_ksg101): value = 10000 with expected_protocol( ik.thorlabs.APTPiezoStage, [ init_ksg101[0], ThorLabsPacket( # read state message_id=ThorLabsCommands.PZ_REQ_MAXTRAVEL, param1=0x01, param2=0x00, dest=0x50, source=0x01, data=None).pack() ], [ init_ksg101[1], ThorLabsPacket(message_id=ThorLabsCommands.PZ_GET_MAXTRAVEL, param1=None, param2=None, dest=0x50, source=0x01, data=struct.pack('<HH', 0x01, value)).pack() ], sep="") as apt: assert apt.channel[0].max_travel == value * u.Quantity(100, 'nm')
def test_maui_time_div(init): """Get / Set time per division.""" with expected_protocol( ik.teledyne.MAUI, [ init, 'TDIV?', 'TDIV 0.001' ], [ '1' ], sep="\n" ) as osc: assert osc.time_div == u.Quantity(1, u.s) osc.time_div = u.Quantity(1, u.ms)
def quantity_constructor(loader, node): """ Constructs a `u.Quantity` instance from a PyYAML node tagged as ``!Q``. """ # Follows the example of http://stackoverflow.com/a/43081967/267841. value = loader.construct_scalar(node) return u.Quantity(*split_unit_str(value))
def std_dev(self): """ Gets the standard deviation for the specified channel as determined by the statistics gathering. :type: `~pint.Quantity` """ return u.Quantity(float(self._get('SD')), self.units)
def average(self): """ Gets the average measurement for the specified channel as determined by the statistics gathering. :type: `~pint.Quantity` """ return u.Quantity(float(self._get('average')), self.units)
def test_lcc25_voltage2(): with expected_protocol(ik.thorlabs.LCC25, [ "volt2?", "volt2=10.0", ], ["volt2?", "20", ">volt2=10.0", ">"], sep="\r") as lcc: unit_eq(lcc.voltage2, u.Quantity(20, "V")) lcc.voltage2 = 10.0
def test_channel_power_setter(): with expected_protocol(ik.holzworth.HS9000, [ ":ATTACH?", ":CH1:PWR:MIN?", ":CH1:PWR:MAX?", ":CH1:PWR {:e}".format(0) ], [":CH1:CH2:FOO", "-100", "20"], sep="\n") as hs: channel = hs.channel[0] channel.power = u.Quantity(0, u.dBm)