def __init__(self, name, config, config_filepath):
self.i = 0
super().__init__(name, config, config_filepath)
self.recording = False
self.temps = collections.deque(maxlen=500)
self.set_temp = 0
self.row = []
#time.sleep(30)
# initialize clients
self._heater_client = gpiozero.DigitalOutputDevice(pin=18) #yaqc.Client(38455)
self._heater_client.value = 0
self._temp_client = yaqc.Client(39001)
self._temp_client.measure(loop=True)
self._pressure_client_a = yaqc.Client(39100)
#self._pressure_client_a.set_state(gain=2, size=16)
self._pressure_client_a.measure(loop=True)
self._pressure_client_b = yaqc.Client(39101)
#self._pressure_client_b.set_state(gain=2, size=16)
self._pressure_client_b.measure(loop=True)
self._pressure_client_c = yaqc.Client(39102)
#self._pressure_client_c.set_state(gain=2, size=16)
self._pressure_client_c.measure(loop=True)
# begin looping
self._pid = PID(Kp=0.2, Ki=0.001, Kd=0.01, setpoint=0, proportional_on_measurement=True)
self._loop.create_task(self._runner())
def __init__(self, *args, **kwargs):
self._yaqd_port = kwargs.pop("yaqd_port")
super().__init__(*args, **kwargs)
# open control
self.ctrl = yaqc.Client(self._yaqd_port)
# import some information from control
id_dict = self.ctrl.id()
self.serial_number = id_dict["serial"]
self.position.write(self.ctrl.get_position())
# recorded
self.recorded[self.name] = [
self.position, self.native_units, 1.0, "m", False
]
self.limits.write(*self.ctrl.get_limits())
self.wait_until_still()
self.grating = pc.Combo(
name="Grating",
allowed_values=self.ctrl.get_turret_options(),
display=True,
set_method="set_turret",
)
self.exposed.append(self.grating)
# finish
self.initialized.write(True)
self.initialized_signal.emit()
def __init__(self, *args, **kwargs):
self.yaqd_port = kwargs["yaqd_port"]
self.yaqd_host = kwargs.get("yaqd_host", "127.0.0.1")
self.motor = yaqc.Client(self.yaqd_port, host=self.yaqd_host)
self.motor_units = self.motor.get_units()
self.native_units = kwargs.get("native_units", "deg")
self.native_per_motor = float(
wt.units.convert(1, self.motor_units, self.native_units))
hw.Driver.__init__(self, *args, **kwargs)
id_ = self.motor.id()
if id_["model"] is not None:
self.hardware.model = id_["model"]
elif id_["kind"].startswith("fake"):
self.hardware.model = "fake"
else:
self.hardware.model = id_["kind"]
self.factor = self.hardware.factor
self.factor.write(kwargs["factor"])
self.motor_limits = self.hardware.motor_limits
self.motor_limits.write(*self.motor.get_limits())
self.motor_position = self.hardware.motor_position
self.zero_position = self.hardware.zero_position
self.set_zero(self.zero_position.read(self.motor_units))
self.recorded["_".join([self.name, "zero"])] = [
self.zero_position,
"deg",
0,
self.label.read(),
True,
]
def __init__(self, *args, **kwargs):
self.yaqd_port = kwargs["yaqd_port"]
self.yaqd_host = kwargs.get("yaqd_host", "127.0.0.1")
self.motor = yaqc.Client(self.yaqd_port, host=self.yaqd_host)
self.motor_units = self.motor.get_units()
if self.motor_units == "mm":
self.motor_units = "mm_delay"
self.native_units = kwargs.get("native_units", "ps")
self.native_per_motor = float(wt.units.convert(1, self.motor_units, self.native_units))
hw.Driver.__init__(self, *args, **kwargs)
id_ = self.motor.id()
if id_["model"] is not None:
self.hardware.model = id_["model"]
elif id_["kind"].startswith("fake"):
self.hardware.model = "fake"
else:
self.hardware.model = id_["kind"]
self.factor = self.hardware.factor
self.factor.write(kwargs["factor"])
self.motor_limits = self.hardware.motor_limits
self.motor_limits.write(*self.motor.get_limits())
self.motor_position = self.hardware.motor_position
self.zero_position = self.hardware.zero_position
self.set_zero(self.zero_position.read(self.motor_units))
self.update_recorded()
def __init__(self, *args, **kwargs):
self.yaqd_port = kwargs["yaqd_port"]
self.yaqd_host = kwargs.get("yaqd_host", "127.0.0.1")
self.client = yaqc.Client(self.yaqd_port, host=self.yaqd_host)
self.motor_positions = {
k: pc.Number(name=k, decimals=6, display=True) for k in self.client.get_setable_names()
}
hw.Driver.__init__(self, *args, **kwargs)
self.shutter_port = kwargs.get("shutter_yaqd_port")
if self.shutter_port:
self.shutter_position = pc.Bool(name="Shutter", display=True, set_method="set_shutter")
self.shutter = yaqc.Client(self.shutter_port)
self.shutter.set_identifier("closed")
self.exposed += [self.shutter_position]
self.curve = attune.Instrument(**self.client.get_instrument())
self.load_curve()
self.get_motor_positions()
self.get_position()
def __init__(self, *args, **kwargs):
self.yaqd_port = kwargs["yaqd_port"]
self.yaqd_host = kwargs.get("yaqd_host", "127.0.0.1")
self.client = yaqc.Client(self.yaqd_port, host=self.yaqd_host)
self.client.register_connection_callback(
signals.updated_attune_store.emit)
signals.updated_attune_store.connect(self.on_updated_attune_store)
self.motor_positions = {
k: pc.Number(name=k, decimals=6, display=True)
for k in self.client.get_setable_names()
}
hw.Driver.__init__(self, *args, **kwargs)
self.shutter_port = kwargs.get("shutter_yaqd_port")
if self.shutter_port:
self.shutter_position = pc.Bool(name="Shutter",
display=True,
set_method="set_shutter")
self.shutter = yaqc.Client(self.shutter_port)
self.shutter.set_identifier("closed")
self.exposed += [self.shutter_position]
self.on_updated_attune_store()
def __init__(self, sensor, yaqd_port):
super().__init__()
self.client = yaqc.Client(yaqd_port)
# attributes
self.name = self.client.id()["name"]
self.enqueued = sensor.enqueued
self.busy = sensor.busy
self.freerun = sensor.freerun
self.data = sensor.data
self.shape = sensor.shape
self.measure_time = sensor.measure_time
self.thread = sensor.thread
def initialize(self, *args, **kwargs):
# open control
self.ctrl = yaqc.Client(self._yaqd_port)
# import some information from control
id_dict = self.ctrl.id()
self.serial_number = id_dict["serial"]
self.position.write(self.ctrl.get_position())
# recorded
self.recorded[self.name] = [
self.position, self.native_units, 1.0, "m", False
]
self.wait_until_still()
# finish
self.initialized.write(True)
self.initialized_signal.emit()
def __init__(self, *args, **kwargs):
self.yaqd_port = kwargs["yaqd_port"]
self.yaqd_host = kwargs.get("yaqd_host", "127.0.0.1")
self.motor = yaqc.Client(self.yaqd_port, host=self.yaqd_host)
self.native_units = self.motor.get_units()
hw.Driver.__init__(self, *args, **kwargs)
id_ = self.motor.id()
if id_["model"] is not None:
self.hardware.model = id_["model"]
elif id_["kind"].startswith("fake"):
self.hardware.model = "fake"
else:
self.hardware.model = id_["kind"]
self.update_recorded()
self.busy.write(self.is_busy())
def __init__(self, app):
super().__init__()
# self.start_time = wt.kit.TimeStamp()
self.app = app
self.__version__ = __version__
# title
title = "Gas Uptake Reactor Control"
title += " | version %s" % self.__version__
title += " | Python %i.%i" % (sys.version_info[0], sys.version_info[1])
self.setWindowTitle(title)
#
self.data = np.full((14, 10000), np.nan)
self.recording = False
self.client = yaqc.Client(39000)
self.record_started = time.time()
#
self._begin_poll_loop()
def __init__(self, name, config, config_filepath):
super().__init__(name, config, config_filepath)
self._channel_names = ["ingaas"]
self._channel_units = {"ingaas": None}
self._channel_shapes = {"ingaas": (256, )}
self._channel_mappings = {"ingaas": ["wavelengths"]}
self._mapping_units = {"wavelengths": "nm"}
self._spec_position = self._config["spectrometer_position"]
if isinstance(self._spec_position, str):
host, port = self._spec_position.split(":")
import yaqc # type: ignore
self._spec_client = yaqc.Client(int(port), host=host)
else:
self._spec_client = None
self._mappings["wavelengths"] = self._gen_mappings()
self._ser = serial.Serial()
self._ser.baudrate = self._config["baud_rate"] # must be 57600
self._ser.port = self._config["serial_port"]
self._ser.open()
def _load_google_drive(self):
g.google_drive_enabled.write(
self.config.get("google_drive", {}).get("enable", False))
if g.google_drive_enabled.read():
g.google_drive_control.write(
yaqc.Client(self.config["google_drive"]["port"]))
import numpy as np
import matplotlib.pyplot as plt
import yaqc
ingaas = yaqc.Client(38989)
fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2)
t = np.arange(-2.0, 2.0, 0.001)
(l, ) = ax.plot(t, np.zeros_like(t), lw=2)
def submit():
try:
ingaas.measure()
l.set_xdata(ingaas.get_mappings()["wavelengths"])
l.set_ydata(ingaas.get_measured()["ingaas"])
except ConnectionError:
pass
ax.relim()
ax.autoscale_view()
plt.draw()
timer = fig.canvas.new_timer(interval=200)
@timer.add_callback
def update():
submit()
