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")