def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"julabo", "JULABO_01")
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
self.ca.assert_that_pv_exists("TEMP", timeout=30)
# Turn off circulate
self.ca.set_pv_value("MODE:SP", 0)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
EMULATOR, DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=30)
self._lewis.backdoor_set_on_device("connected", True)
self._lewis.backdoor_run_function_on_device("reset")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"ieg", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=20)
self.ca.assert_that_pv_exists("DISABLE", timeout=30)
def set_up_connections(device):
_lewis, _ioc = get_running_lewis_and_ioc(device, device)
_lewis.backdoor_set_on_device('connected', True)
_lewis.backdoor_set_on_device("is_giving_errors", False)
return _lewis, _ioc, ChannelAccess(device_prefix=device)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"itc503", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=20)
self.ca.assert_that_pv_exists("DISABLE")
self._make_device_scan_faster()
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"keithley_2400", DEVICE_PREFIX)
self._lewis.backdoor_set_on_device("random_output", False)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(IOCS[0]["emulator"], DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX, default_timeout=25)
if not IOCRegister.uses_rec_sim:
self._lewis.backdoor_run_function_on_device("reset")
self._lewis.backdoor_set_on_device("connected", True)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(EMULATOR_NAME, DEVICE_PREFIX)
# Some changes happen on the order of HEATER_WAIT_TIME seconds. Use a significantly longer timeout
# to capture a few heater wait times plus some time for PVs to update.
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX, default_timeout=HEATER_WAIT_TIME*10)
# Wait for some critical pvs to be connected.
for pv in ["MAGNET:FIELD:PERSISTENT", "FIELD", "FIELD:SP:RBV", "HEATER:STATUS"]:
self.ca.assert_that_pv_exists(pv)
# Ensure in the correct mode
self.ca.set_pv_value("CONTROL:SP", "Remote & Unlocked")
self.ca.set_pv_value("ACTIVITY:SP", "To Setpoint")
# Don't run reset as the sudden change of state confuses the IOC's state machine. No matter what the initial
# state of the device the SNL should be able to deal with it.
# self._lewis.backdoor_run_function_on_device("reset")
self.ca.set_pv_value("HEATER:WAITTIME", HEATER_WAIT_TIME)
self.ca.set_pv_value("FIELD:RATE:SP", 10)
# self.ca.assert_that_pv_is_number("FIELD:RATE:SP", 10)
self.ca.process_pv("FIELD:SP")
# Wait for statemachine to reach "at field" state before every test.
self.ca.assert_that_pv_is("STATEMACHINE", "At field")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"smrtmon", IOC_PREFIX)
self.ca = ChannelAccess(device_prefix=IOC_PREFIX)
self._lewis.backdoor_run_function_on_device("reset_values")
self.ca.assert_that_pv_alarm_is_not("STAT",
ChannelAccess.Alarms.INVALID)
def _setup_lewis_and_channel_access(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
EMULATOR_DEVICE, DEVICE)
self.ca = ChannelAccess(device_prefix=PREFIX)
self.ca.assert_that_pv_exists(RBV_PV, timeout=30)
self.ca.assert_that_pv_exists("CAL:SEL", timeout=10)
self._lewis.backdoor_set_on_device("address", ADDRESS)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc("hlg", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
self._lewis.backdoor_set_on_device("verbosity", 1)
self._lewis.backdoor_set_on_device("prefix", 1)
self._set_level(0)
def setUp(self):
self.NUMBER_OF_CHANNELS = self.get_number_of_channels()
self.CHANNELS = range(self.NUMBER_OF_CHANNELS)
self.SCALING_FACTOR = self.get_scaling_factor()
self.low_alarm_limit, self.high_alarm_limit = self.get_alarm_limits()
# Alarm limits are in scaled units, these are normalised to 'device units' for clarity in the tests.
self.low_alarm_limit /= self.SCALING_FACTOR
self.high_alarm_limit /= self.SCALING_FACTOR
self._lewis, self._ioc = get_running_lewis_and_ioc(
"moxa12xx", self.get_device_prefix())
self.ca = ChannelAccess(device_prefix=self.get_device_prefix())
# Sends a backdoor command to the device to reset all input registers (IRs) to 0
reset_value = 0
self._lewis.backdoor_run_function_on_device(
"set_ir",
(self.get_starting_reg_addr(), [reset_value] *
self.get_registers_per_channel() * self.NUMBER_OF_CHANNELS))
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"lakeshore460", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix="LKSH460_01",
default_timeout=30,
default_wait_time=0.0)
self.ca.assert_that_pv_exists("IDN")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"keithley_2700", DEVICE_PREFIX)
self.ca = ChannelAccess(default_timeout=30,
device_prefix=DEVICE_PREFIX)
self.ca.assert_that_pv_exists("IDN")
if not IOCRegister.uses_rec_sim:
self._lewis.backdoor_set_on_device("simulate_readings", False)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc("moxa12xx", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
# Sends a backdoor command to the device to set a discrete input (DI) value
self._lewis.backdoor_run_function_on_device("set_di", (0, [False]*16))
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
DEVICE_NAME, DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=30)
self._lewis.backdoor_run_function_on_device("reset")
self.ca.set_pv_value("AUTOONOFF", "Disabled")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc("skf_mb350_chopper", DEVICE_PREFIX)
self.ca = ChannelAccess(20, device_prefix=DEVICE_PREFIX)
self.ca.assert_that_pv_exists("FREQ", timeout=30)
# Wait for emulator to be connected, signified by "STAT:OK"
self.ca.assert_that_pv_is("STAT:OK", "OK")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
_EMULATOR_NAME, DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=30)
self._lewis.backdoor_set_on_device("connected", True)
self._lewis.backdoor_set_on_device("corrupted_messages", False)
def setUpClass(cls):
cls.emulator, cls._ioc = get_running_lewis_and_ioc(EMULATOR_NAME, DEVICE_PREFIX)
cls.ca = ChannelAccess(device_prefix=None)
for i in range(1, 3):
cls.ca.set_pv_value("AXES_{}:BENABLE".format(i), 1)
cls.ca.set_pv_value("AXES_{}:FOVERRIDE".format(i), 100)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"amint2l", DEVICE_PREFIX)
self.assertIsNotNone(self._lewis)
self.assertIsNotNone(self._ioc)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
self._lewis.backdoor_set_on_device('connected', True)
self._lewis.backdoor_set_on_device("address", ADDRESS)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc("ilm200", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX, default_wait_time=0.0)
self.ca.assert_that_pv_exists("VERSION", timeout=30)
self._lewis.backdoor_set_on_device("cycle", False)
self._lewis.backdoor_run_function_on_device("set_cryo_type", (1, Ilm200ChannelTypes.NITROGEN))
self._lewis.backdoor_run_function_on_device("set_cryo_type", (2, Ilm200ChannelTypes.HELIUM))
self._lewis.backdoor_run_function_on_device("set_cryo_type", (3, Ilm200ChannelTypes.HELIUM_CONT))
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"mercuryitc", DEVICE_PREFIX)
self._lewis.backdoor_set_on_device("connected", True)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=20)
card_pv_prefix = get_card_pv_prefix(TEMP_CARDS[0])
self.ca.assert_setting_setpoint_sets_readback(
"OFF",
readback_pv="{}:SPC".format(card_pv_prefix),
expected_alarm=self.ca.Alarms.MAJOR)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"dh2000", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
self._lewis.backdoor_set_on_device("shutter_is_open", False)
self._lewis.backdoor_set_on_device("interlock_is_triggered", False)
self._lewis.backdoor_set_on_device("is_connected", True)
self.ca.assert_that_pv_is("SHUTTER:A", "Closed")
self.ca.assert_that_pv_is("INTERLOCK", "OK")
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"gemorc", DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX,
default_timeout=DEFAULT_TIMEOUT)
self.ca.assert_that_pv_exists("ID", timeout=30)
self.reset_ioc()
if not IOCRegister.uses_rec_sim:
self.reset_emulator()
self.check_init_state(False, False, True, False)
self.ca.assert_that_pv_is_number("CYCLES", 0)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc("rknps", PREFIX)
self.ca = ChannelAccess(device_prefix=PREFIX, default_timeout=60)
self._lewis.backdoor_set_on_device("connected", True)
self.current_readback_factor = 1000
self.id_prefixes = [ID + ":" for ID in IDS]
for id_prefix in self.id_prefixes:
self.ca.assert_that_pv_exists("{}ADDRESS".format(id_prefix),
timeout=30)
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"tpgx6x", self.get_prefix())
self.ca = ChannelAccess(20, device_prefix=self.get_prefix())
self.ca.assert_that_pv_exists("1:PRESSURE")
# Reset and error flags and alarms
self._set_error(ErrorFlags.NO_ERROR, 1)
self._set_error(ErrorFlags.NO_ERROR, 2)
# The amount of channels you expect for the device
self.channels = 2
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"instron_stress_rig", DEVICE_PREFIX)
self.ca = ChannelAccess(15, device_prefix=DEVICE_PREFIX)
self.ca.assert_that_pv_exists("CHANNEL", timeout=30)
# Can't use lewis backdoor commands in recsim
# All of the below commands apply to devsim only.
if not IOCRegister.uses_rec_sim:
# Reinitialize the emulator state
self._lewis.backdoor_command(["device", "reset"])
self._lewis.backdoor_set_on_device("status", 7680)
for index, chan_type2 in enumerate((3, 2, 4)):
self._lewis.backdoor_command([
"device", "set_channel_param",
str(index + 1), "channel_type",
str(chan_type2)
])
self.ca.assert_that_pv_is("CHANNEL:SP.ZRST", "Position")
self._change_channel("Position")
# Ensure the rig is stopped
self._lewis.backdoor_command(["device", "movement_type", "0"])
self.ca.assert_that_pv_is("GOING", "NO")
# Ensure stress area and strain length are sensible values (i.e. not zero)
self._lewis.backdoor_command(
["device", "set_channel_param", "2", "area", "10"])
self._lewis.backdoor_command(
["device", "set_channel_param", "3", "length", "10"])
self.ca.assert_that_pv_is_number("STRESS:AREA",
10,
tolerance=0.001)
self.ca.assert_that_pv_is_number("STRAIN:LENGTH",
10,
tolerance=0.001)
# Ensure that all the scales are sensible values (i.e. not zero)
for index, channel in enumerate(POS_STRESS_STRAIN, 1):
self._lewis.backdoor_command(
["device", "set_channel_param",
str(index), "scale", "10"])
self.ca.assert_that_pv_is_number(channel + ":SCALE",
10,
tolerance=0.001)
# Always set the waveform generator to run for lots of cycles so it only stops if we want it to
self.ca.set_pv_value(quart_prefixed("CYCLE:SP"), LOTS_OF_CYCLES)
def setUp(self):
_, self._ioc = get_running_lewis_and_ioc(None, ZF_DEVICE_PREFIX)
timeout = 20
self.zfcntrl_ca = ChannelAccess(device_prefix=ZF_DEVICE_PREFIX,
default_timeout=timeout)
self.magnetometer_ca = ChannelAccess(
device_prefix=MAGNETOMETER_DEVICE_PREFIX, default_timeout=timeout)
self.x_psu_ca = ChannelAccess(default_timeout=timeout,
device_prefix=X_KEPCO_DEVICE_PREFIX)
self.y_psu_ca = ChannelAccess(default_timeout=timeout,
device_prefix=Y_KEPCO_DEVICE_PREFIX)
self.z_psu_ca = ChannelAccess(default_timeout=timeout,
device_prefix=Z_KEPCO_DEVICE_PREFIX)
self._wait_for_all_iocs_up()
self.zfcntrl_ca.set_pv_value("TOLERANCE",
STABILITY_TOLERANCE,
sleep_after_set=0)
self.zfcntrl_ca.set_pv_value("STATEMACHINE:LOOP_DELAY",
LOOP_DELAY_MS,
sleep_after_set=0)
self._set_autofeedback(False)
# Set the magnetometer calibration to the 3x3 identity matrix
for x, y in itertools.product(range(1, 3 + 1), range(1, 3 + 1)):
self.magnetometer_ca.set_pv_value("SENSORMATRIX:{}{}".format(x, y),
1 if x == y else 0,
sleep_after_set=0)
self._set_simulated_measured_fields(ZERO_FIELD, overload=False)
self._set_user_setpoints(ZERO_FIELD)
self._set_simulated_power_supply_currents(ZERO_FIELD,
wait_for_update=True)
self._set_scaling_factors(1, 1, 1, 1)
self._set_output_limits(
lower_limits={
"X": DEFAULT_LOW_OUTPUT_LIMIT,
"Y": DEFAULT_LOW_OUTPUT_LIMIT,
"Z": DEFAULT_LOW_OUTPUT_LIMIT
},
upper_limits={
"X": DEFAULT_HIGH_OUTPUT_LIMIT,
"Y": DEFAULT_HIGH_OUTPUT_LIMIT,
"Z": DEFAULT_HIGH_OUTPUT_LIMIT
},
)
self._assert_at_setpoint(AtSetpointStatuses.NA)
self._assert_status(Statuses.NO_ERROR)
def reset_emulator():
""" Resets the device"""
lewis, ioc = get_running_lewis_and_ioc("ngpspsu", DEVICE_PREFIX)
ca = ChannelAccess(20, device_prefix=DEVICE_PREFIX)
_reset_device(ca)
ca.assert_that_pv_is("STAT:POWER", "OFF")
_reset_error(ca)
ca.assert_that_pv_is("ERROR", "No error")
_connect_device(lewis)
return lewis, ioc, ca
def setUp(self):
self._lewis, self._ioc = get_running_lewis_and_ioc(
"fermichopper", self._get_device_prefix())
self.ca = ChannelAccess(device_prefix=self._get_device_prefix(),
default_timeout=30)
self.ca.assert_that_pv_exists("SPEED")
self.ca.set_pv_value("DELAY:SP", 0)
self.ca.set_pv_value("GATEWIDTH:SP", 0)
self.ca.assert_that_pv_is_number("DELAY:SP:RBV", 0)
self.ca.assert_that_pv_is_number("GATEWIDTH", 0)
if not IOCRegister.uses_rec_sim:
self._lewis.backdoor_run_function_on_device("reset")
