def __init__(self,
agent,
port,
ip_address,
f_sample=2.5,
fake_errors=False):
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.ip_address = ip_address
self.fake_errors = fake_errors
self.port = port
self.module: Optional[Module] = None
self.f_sample = f_sample
self.initialized = False
self.take_data = False
# Registers data feeds
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('ptc_status',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, name, ip, fake_data=False, dwell_time_delay=0):
# self._acq_proc_lock is held for the duration of the acq Process.
# Tasks that require acq to not be running, at all, should use
# this lock.
self._acq_proc_lock = TimeoutLock()
# self._lock is held by the acq Process only when accessing
# the hardware but released occasionally so that (short) Tasks
# may run. Use a YieldingLock to guarantee that a waiting
# Task gets activated preferentially, even if the acq thread
# immediately tries to reacquire.
self._lock = YieldingLock(default_timeout=5)
self.name = name
self.ip = ip
self.fake_data = fake_data
self.dwell_time_delay = dwell_time_delay
self.module = None
self.thermometers = []
self.log = agent.log
self.initialized = False
self.take_data = False
self.agent = agent
# Registers temperature feeds
agg_params = {
'frame_length': 10 * 60 #[sec]
}
self.agent.register_feed('temperatures',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, sn, ip, f_sample=0.1,
threshold=0.1, window=900):
self.agent = agent
self.sn = sn
self.ip = ip
self.f_sample = f_sample
self.t_sample = 1/self.f_sample - 0.01
assert self.t_sample < 7200, \
"acq sampling freq must be such that t_sample is less than 2 hours"
self._lock = TimeoutLock()
self.log = agent.log
self.initialized = False
self.take_data = False
self.module = None
# for stability checking
self.threshold = threshold
self.window = window
self._recent_temps = None
self._static_setpoint = None
agg_params = {'frame_length': 10*60} # sec
# combined feed for thermometry and control data
self.agent.register_feed(
'temperatures',
record=True,
agg_params=agg_params,
buffer_time=1
)
def __init__(self,
agent,
num_channels=2,
fake_data=False,
port="/dev/ttyUSB0"):
print(num_channels)
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.fake_data = fake_data
self.module = None
self.port = port
self.thermometers = [
'Channel {}'.format(i + 1) for i in range(num_channels)
]
self.log = agent.log
self.initialized = False
self.take_data = False
# Registers Temperature and Voltage feeds
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('temperatures',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, ip_addr, port, mode=None, samp=2):
self.ip_addr = ip_addr
self.port = port
self.xy_stage = None
self.initialized = False
self.take_data = False
self.is_moving = False
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
if mode == 'acq':
self.auto_acq = True
else:
self.auto_acq = False
self.sampling_frequency = float(samp)
### register the position feeds
agg_params = {
'frame_length': 10 * 60, #[sec]
}
self.agent.register_feed('positions',
record=True,
agg_params=agg_params,
buffer_time=0)
def __init__(self, agent, ip=IP_DEFAULT, port=17123):
'''
Parameters
----------
ip : string
IP address
port : int
Port number
'''
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.take_data = False
self._dev = dS378(ip=ip, port=port)
self.initialized = False
agg_params = {'frame_length': 60}
self.agent.register_feed('relay',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, ip_address, active_channels, function_file,
sampling_frequency):
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.ip_address = ip_address
self.module = None
self.ljf = LabJackFunctions()
self.sampling_frequency = sampling_frequency
# Labjack channels to read
if active_channels[0] == 'T7-all':
self.chs = ['AIN{}'.format(i) for i in range(14)]
elif active_channels[0] == 'T4-all':
self.chs = ['AIN{}'.format(i) for i in range(12)]
else:
self.chs = active_channels
# Load dictionary of unit conversion functions from yaml file. Assumes
# the file is in the $OCS_CONFIG_DIR directory
if function_file == 'None':
self.functions = {}
else:
function_file_path = os.path.join(os.environ['OCS_CONFIG_DIR'],
function_file)
with open(function_file_path, 'r') as stream:
self.functions = yaml.safe_load(stream)
if self.functions is None:
self.functions = {}
self.log.info(
f"Applying conversion functions: {self.functions}")
self.initialized = False
self.take_data = False
# Register main feed. Exclude influx due to potentially high scan rate
agg_params = {'frame_length': 60, 'exclude_influx': True}
self.agent.register_feed('sensors',
record=True,
agg_params=agg_params,
buffer_time=1)
# Register downsampled feed for influx.
agg_params_downsampled = {'frame_length': 60}
self.agent.register_feed('sensors_downsampled',
record=True,
agg_params=agg_params_downsampled,
buffer_time=1)
self.agent.register_feed('registers',
record=True,
agg_params={'frame_length': 10 * 60},
buffer_time=1.)
def __init__(self, agent, ip_address, username, password):
"""
Initializes the class variables
Args:
ip_address(str): IP Address for the agent.
username(str): username credential to login to strip
password(str): password credential to login to strip
"""
self.agent = agent
self.lock = TimeoutLock()
self.ip_address = ip_address
self.user = username
self.passw = password
def __init__(self, agent, args):
self.agent: ocs_agent.OCSAgent = agent
self.log = agent.log
self.prot = None
self.protocol_lock = TimeoutLock()
self.current_session = None
if args.monitor_id is not None:
self.agent.subscribe_on_start(
self._on_session_data,
'observatory.{}.feeds.pysmurf_session_data'.format(
args.monitor_id),
)
def __init__(self, agent, ip_address, gpib_slot):
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.job = None
self.ip_address = ip_address
self.gpib_slot = gpib_slot
self.monitor = False
self.awg = None
# Registers data feeds
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('AWG', record=True, agg_params=agg_params)
def __init__(self, agent, port='/dev/ttyACM0'):
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.port = port
self.take_data = False
self.arduino = HWPSimulator(port=self.port)
self.initialized = False
agg_params = {'frame_length': 60}
self.agent.register_feed('amplitudes',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, ip_address, port, f_sample=2.5):
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.f_sample = f_sample
self.take_data = False
self.gauge = Pfeiffer(ip_address, int(port))
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('pressures',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, kikusui_ip, kikusui_port, pid_ip, pid_port,
pid_verbosity):
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self._initialized = False
self.take_data = False
self.kikusui_ip = kikusui_ip
self.kikusui_port = int(kikusui_port)
self.pid_ip = pid_ip
self.pid_port = pid_port
self._pid_verbosity = pid_verbosity > 0
self.cmd = None # Command object for PSU commanding
self.pid = None # PID object for pid controller commanding
agg_params = {'frame_length': 60}
self.agent.register_feed('hwprotation',
record=True,
agg_params=agg_params)
def __init__(self, agent_obj, port=8080):
self.active = True
self.agent = agent_obj
self.log = agent_obj.log
self.lock = TimeoutLock()
self.port = port
self.take_data = False
self.initialized = False
# For clock count to time conversion
self.rising_edge_count = 0
self.irig_time = 0
agg_params = {'frame_length': 60}
self.agent.register_feed('HWPEncoder', record=True,
agg_params=agg_params)
agg_params = {'frame_length': 60, 'exclude_influx': True}
self.agent.register_feed('HWPEncoder_full', record=True,
agg_params=agg_params)
self.parser = EncoderParser(beaglebone_port=self.port)
def __init__(self, agent, ip_address, gpib_slot):
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.job = None
self.ip_address = ip_address
self.gpib_slot = gpib_slot
self.monitor = False
self.psu = None
# Registers Temperature and Voltage feeds
agg_params = {
'frame_length': 10 * 60,
}
self.agent.register_feed('psu_output',
record=True,
agg_params=agg_params,
buffer_time=0)
def __init__(self, agent, ipaddr=IPADDR_DEFAULT):
'''
Parameters
----------
ipaddr : str
IP address of AC supply
'''
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.take_data = False
self.initialized = False
self._pcr = PCR500MA(ipaddr)
agg_params = {'frame_length': 60}
self.agent.register_feed('acsupply',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, port, f_sample=1.):
self.agent: ocs_agent.OCSAgent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.port = port
self.dev = None
self.f_sample = f_sample
self.initialized = False
self.take_data = False
# Registers Temperature and Voltage feeds
agg_params = {'frame_length': 60}
self.agent.register_feed('mag_field',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, ip_address, num_channels):
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.ip_address = ip_address
self.module = None
self.sensors = ['Channel {}'.format(i+1) for i in range(num_channels)]
self.initialized = False
self.take_data = False
# Register feed
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('Sensors',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, port="/dev/ttyUSB0", f_sample=2.5):
self.agent: ocs_agent.OCSAgent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.port = port
self.module: Optional[Module] = None
self.f_sample = f_sample
self.initialized = False
self.take_data = False
# Registers Temperature and Voltage feeds
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('temperatures',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, port=PORT_DEFAULT):
'''
Parameters
----------
port : string
Port to connect
'''
self.active = True
self.agent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.take_data = False
self._ble2 = BLE2(port=port)
self.initialized = False
agg_params = {'frame_length': 60}
self.agent.register_feed('motor',
record=True,
agg_params=agg_params,
buffer_time=1)
def __init__(self, agent, config_file):
self.agent = agent
self.lock = TimeoutLock()
self.meas_cap = meas_cap_builder(config_file)
agg_params = {
'frame_length': 60,
}
for meas, capdists in self.meas_cap.items():
self.agent.register_feed("Cap{}".format(meas.num),
record=True,
agg_params=agg_params)
for n, capdist in enumerate(capdists):
for i in range(len(capdist.avgs) + 1):
self.agent.register_feed("Dist{}_Cal{}_Intvl{}".format(meas.num, n, i),
record=True,
agg_params=agg_params)
self.initialized = False
self.take_data = False
self.f_poll = POLL_FREQUENCY
self.send_interval = self.f_poll/SEND_FREQUENCY
def __init__(self, agent, port="/dev/ttyUSB0", sample_freq=0.5):
self.active = True
self.agent: ocs_agent.OCSAgent = agent
self.log = agent.log
self.lock = TimeoutLock()
self.port = port
self.module: Optional[VantagePro2] = None
if sample_freq > 0.5:
self.log.warn("Sample frequency too fast! Setting to 0.5Hz")
sample_freq = 0.5
self.sample_freq = sample_freq
self.initialized = False
self.take_data = False
# Registers weather data feed
agg_params = {
'frame_length': 60,
}
self.agent.register_feed('weather_data',
record=True,
agg_params=agg_params)
def __init__(self, agent, acu_config='guess'):
self.lock = TimeoutLock()
self.jobs = {
'monitor': 'idle',
'broadcast': 'idle',
'control': 'idle', # shared by all motion tasks/processes
}
self.acu_config = aculib.guess_config(acu_config)
self.base_url = self.acu_config['base_url']
self.sleeptime = self.acu_config['motion_waittime']
self.udp = self.acu_config['streams']['main']
self.udp_ext = self.acu_config['streams']['ext']
self.log = agent.log
# self.data provides a place to reference data from the monitors.
# 'status' is populated by the monitor operation
# 'broadcast' is populated by the udp_monitor operation
self.data = {
'status': {
'summary': {},
'full_status': {}
},
'broadcast': {},
'uploads': {},
}
self.health_check = {'broadcast': False, 'status': False}
self.agent = agent
self.take_data = False
self.web_agent = tclient.Agent(reactor)
tclient._HTTP11ClientFactory.noisy = False
self.acu = aculib.AcuControl('guess',
backend=TwistedHttpBackend(
self.web_agent))
agent.register_process('monitor',
self.start_monitor,
lambda: self.set_job_stop('monitor'),
blocking=False,
startup=True)
agent.register_process('broadcast',
self.start_udp_monitor,
lambda: self.set_job_stop('broadcast'),
blocking=False,
startup=True)
agent.register_process('generate_scan',
self.generate_scan,
lambda: self.set_job_stop('generate_scan'),
blocking=False,
startup=False)
agg_params = {'frame_length': 60}
self.agent.register_feed('acu_status_summary',
record=True,
agg_params={
'frame_length': 60,
'exclude_influx': True
},
buffer_time=1)
self.agent.register_feed('acu_status_full',
record=True,
agg_params={
'frame_length': 60,
'exclude_influx': True
},
buffer_time=1)
self.agent.register_feed('acu_status_influx',
record=True,
agg_params={
'frame_length': 60,
'exclude_aggregator': True
},
buffer_time=1)
self.agent.register_feed('acu_udp_stream',
record=True,
agg_params={
'frame_length': 60,
'exclude_influx': True
},
buffer_time=1)
self.agent.register_feed('acu_broadcast_influx',
record=False,
agg_params={
'frame_length': 60,
'exclude_aggregator': True
},
buffer_time=1)
self.agent.register_feed('acu_health_check',
record=True,
agg_params=agg_params,
buffer_time=1)
self.agent.register_feed('acu_upload',
record=True,
agg_params=agg_params,
buffer_time=1)
self.agent.register_feed('acu_error',
record=True,
agg_params=agg_params,
buffer_time=1)
agent.register_task('go_to', self.go_to, blocking=False)
agent.register_task('run_specified_scan',
self.run_specified_scan,
locking=False)
agent.register_task('set_boresight',
self.set_boresight,
blocking=False)
agent.register_task('stop_and_clear',
self.stop_and_clear,
blocking=False)