def setUp(self):
self.ca = ChannelAccess(default_timeout=30,
device_prefix=DEVICE_PREFIX)
self.ca_np = ChannelAccess(
default_timeout=30) # no device name prefix in PV
self._ioc = IOCRegister.get_running(DEVICE_PREFIX)
self.ca.assert_that_pv_exists("CR0:BOARD_ID")
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.ca = ChannelAccess(device_prefix="MOT", default_timeout=30)
with ManagerMode(ChannelAccess()):
self._disable_collision_avoidance()
for axis in BAFFLES_AND_DETECTORS_Z_AXES:
current_position = self.ca.get_pv_value("{}".format(axis))
new_position = self._get_axis_default_position(
"{}".format(axis))
self.ca.set_pv_value("{}:MTR.VMAX".format(axis),
TEST_SPEED,
sleep_after_set=0)
self.ca.set_pv_value("{}:MTR.VELO".format(axis),
TEST_SPEED,
sleep_after_set=0)
self.ca.set_pv_value("{}:MTR.ACCL".format(axis),
TEST_ACCELERATION,
sleep_after_set=0)
if current_position != new_position:
self.ca.set_pv_value("{}:SP".format(axis),
new_position,
sleep_after_set=0)
timeout = self._get_timeout_for_moving_to_position(
axis, new_position)
self.ca.assert_that_pv_is("{}".format(axis),
new_position,
timeout=timeout)
# re-enable collision avoidance
self._enable_collision_avoidance()
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("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(
"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(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(
"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(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(
"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_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)
class DAQmxTests(object):
"""
General tests for the DAQmx.
"""
def setUp(self):
self.emulator, self._ioc = get_running_lewis_and_ioc(
DEVICE_PREFIX, DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
def test_WHEN_emulator_disconnected_THEN_data_in_alarm_and_valid_on_reconnect(
self):
self.ca.assert_that_pv_alarm_is_not("DATA",
ChannelAccess.Alarms.INVALID)
self.emulator.disconnect_device()
self.ca.assert_that_pv_alarm_is("DATA", ChannelAccess.Alarms.INVALID)
# Check we don't get excessive numbers of messages if we stay disconnected for 15s (up to 15 messages seems
# reasonable - 1 per second on average)
with assert_log_messages(self._ioc, number_of_messages=15):
sleep(15)
# Double-check we are still in alarm
self.ca.assert_that_pv_alarm_is("DATA",
ChannelAccess.Alarms.INVALID)
self.emulator.reconnect_device()
self.ca.assert_that_pv_alarm_is_not("DATA",
ChannelAccess.Alarms.INVALID,
timeout=5)
self.ca.assert_that_pv_value_is_changing("DATA", 1)
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 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("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 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._ioc = IOCRegister.get_running(DEVICE_PREFIX)
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
self.ca.assert_that_pv_exists("DISABLE", timeout=30)
self.write_offset(0)
self.ca.set_pv_value("RANGE", 1.0, sleep_after_set=0.0)
self.write_simulated_field_values(ZERO_FIELD)
self.write_simulated_alarm_level(self.ca.Alarms.NONE)
self.ca.process_pv("TAKEDATA")
def setUp(self):
self.ca = ChannelAccess(default_timeout=5)
self.ca.assert_that_pv_exists("SAMPCHNG:SLOT")
for axis in AXES:
self.ca.assert_that_pv_exists("MOT:{}".format(axis))
# Select one of the standard slots.
self.ca.assert_setting_setpoint_sets_readback(readback_pv="SAMPCHNG:SLOT", value=SLOTS[0])
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._ioc = IOCRegister.get_running(IOC_PREFIX)
self.ca = ChannelAccess(default_timeout=20)
self.values = ["SIMPLE:VALUE1:SP", "SIMPLE:VALUE2:SP"]
for pv in self.values:
self.ca.assert_that_pv_exists(pv)
self.reset_values_to_zero()
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))
class FinsTests(unittest.TestCase):
"""
Tests for the Fins IOC.
"""
def setUp(self):
self._ioc = IOCRegister.get_running("FINS_01")
self.ca = ChannelAccess(device_prefix=DEVICE_PREFIX)
def test_GIVEN_fins_THEN_has_flow_pv(self):
self.ca.assert_that_pv_exists("BENCH:FLOW1")
class FmrTests(unittest.TestCase):
"""
Tests for the fmr IOC.
"""
def setUp(self):
self._ioc = IOCRegister.get_running(DEVICE_PREFIX)
self.ca = ChannelAccess(20, device_prefix=DEVICE_PREFIX)
def test_WHEN_ioc_is_started_THEN_PV_exists(self):
self.ca.assert_that_pv_exists("FMR:ACTIVITY", timeout=30)
def setUp(self):
self.ca = ChannelAccess(device_prefix=self.get_prefix(), default_timeout=10)
self._assert_necessary_pvs_exist()
self._set_input_pv(False) # Set it to false so that the sequencer see the change,
# probably to do with it being in RECSIM
self._set_input_pv(True)
self._assert_all_power_supplies_disabled(False)
self._set_all_power_supply_states(False)
def setUp(self):
self._ioc = IOCRegister.get_running(IOC_PREFIX)
self.ca = ChannelAccess(default_timeout=20)
for pv in [SIMPLE_VALUE_ONE, SIMPLE_VALUE_TWO]:
self.ca.assert_that_pv_exists(pv)
self.set_safe_values()
self.ca.set_pv_value(MONITORING_ON_PV, "No")
self.ca.assert_that_pv_is(MONITORING_ON_PV, "No")
class Moxa1210Tests(unittest.TestCase):
"""
Tests for the Moxa ioLogik e1210. (16x Discrete inputs)
"""
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 resetDICounter(self, channel):
"""
Reset the counters for each DI (channel)
Args:
channel (int) : The DI (channel) counter to be reset
We typically want to preserve our counter values for each channel even upon restart. For testing purposes
this function will reset the counter values to 0.
"""
self.ca.set_pv_value("CH{:01d}:DI:CNT".format(channel), 0)
@parameterized.expand([
("CH{:01d}".format(channel), channel) for channel in CHANNELS
])
def test_WHEN_DI_input_is_switched_on_THEN_only_that_channel_readback_changes_to_state_just_set(self, _, channel):
self._lewis.backdoor_run_function_on_device("set_di", (channel, (True,)))
self.ca.assert_that_pv_is("CH{:d}:DI".format(channel), "High")
# Test that all other channels are still off
for test_channel in CHANNELS:
if test_channel == channel:
continue
self.ca.assert_that_pv_is("CH{:1d}:DI".format(test_channel), "Low")
@parameterized.expand([
("CH{:01d}:DI:CNT".format(channel), channel) for channel in CHANNELS
])
def test_WHEN_di_input_is_triggered_a_number_of_times_THEN_di_counter_matches(self, channel_pv, channel):
self.resetDICounter(channel)
expected_count = 5
for i in range(expected_count):
# Toggle channel and ensure it's registered the trigger
self._lewis.backdoor_run_function_on_device("set_di", (channel, (True,)))
self._lewis.backdoor_run_function_on_device("set_di", (channel, (False,)))
self.ca.assert_that_pv_is(channel_pv, i+1, timeout=5)
self.ca.assert_that_pv_is(channel_pv, expected_count)
