def setUp(self):
self._ioc = IOCRegister.get_running("refl")
self.ca = ChannelAccess(default_timeout=30,
device_prefix=DEVICE_PREFIX)
self.ca_galil = ChannelAccess(default_timeout=30, device_prefix="MOT")
self.ca_cs = ChannelAccess(default_timeout=30, device_prefix="CS")
self.ca_no_prefix = ChannelAccess()
self.ca_cs.set_pv_value("MOT:STOP:ALL", 1)
self.ca_cs.assert_that_pv_is("MOT:MOVING", 0, timeout=60)
self.ca.set_pv_value("BL:MODE:SP", "NR")
self.ca.set_pv_value("PARAM:S1:SP", 0)
self.ca.set_pv_value("PARAM:S3:SP", 0)
self.ca.set_pv_value("PARAM:SMANGLE:SP", 0)
self.ca.set_pv_value("PARAM:SMOFFSET:SP", 0)
self.ca.set_pv_value("PARAM:SMINBEAM:SP", "OUT")
self.ca.set_pv_value("PARAM:THETA:SP", 0)
self.ca.set_pv_value("PARAM:DET_POS:SP", 0)
self.ca.set_pv_value("PARAM:DET_ANG:SP", 0)
self.ca.set_pv_value("PARAM:DET_LONG:SP", 0)
self.ca.set_pv_value("PARAM:S3INBEAM:SP", "IN")
self.ca.set_pv_value("PARAM:CHOICE:SP", "MTR0205")
self.ca_galil.set_pv_value("MTR0207", 0)
self.ca.set_pv_value("PARAM:NOTINMODE:SP", 0)
self.ca.set_pv_value("BL:MODE:SP", "NR")
self.ca.set_pv_value("BL:MOVE", 1)
self.ca_galil.assert_that_pv_is("MTR0105", 0.0)
self.ca_cs.assert_that_pv_is("MOT:MOVING", 0, timeout=60)
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.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._ioc = IOCRegister.get_running("GALIL_01")
ca_mot = ChannelAccess()
ca_mot.assert_that_pv_exists("MOT:MTR0103", timeout=30)
ca_mot.assert_setting_setpoint_sets_readback(DEFAULT_MOTOR_RESOLUTION,
set_point_pv="MOT:MTR0103.MRES", readback_pv="MOT:MTR0103.MRES", )
self.ca = ChannelAccess(device_prefix=PREFIX)
self.ca.assert_that_pv_exists("VEL:SP", timeout=30)
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 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._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(
"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(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_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(
"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.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(
"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(
"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 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 test_WHEN_heater_association_is_set_THEN_pv_updates(
self, _, parent_card, associated_card):
card_pv_prefix = get_card_pv_prefix(parent_card)
with ManagerMode(ChannelAccess()):
self.ca.assert_setting_setpoint_sets_readback(
associated_card, "{}:HTRCHAN".format(card_pv_prefix))
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(
"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("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(
_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("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(
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 _get_channel_access(self):
"""
:return (ChannelAccess): the channel access component
"""
if self.ca is None:
self.ca = ChannelAccess(device_prefix=self._prefix)
return self.ca
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 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("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._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._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(
"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)