bec/csaxs_bec
0
0
Fork 1
Code Issues 13 Pull Requests 4 Actions Packages Projects Releases Wiki Activity

refactor(mcs-card): refactor mcs card integration

Browse Source
This commit is contained in:
appel_c
2025-07-16 14:32:52 +02:00
parent 3cda1c74b4
commit 256adb14d4
5 changed files with 768 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
csaxs_bec/device_configs/ddg_test.yaml
View File

@@ -30,8 +30,6 @@ samx:
- 50
tolerance: 0.01
update_frequency: 400
deviceTags:
- user motors
enabled: true
readOnly: false
@@ -39,7 +37,15 @@ bpm4i:
readoutPriority: monitored
deviceClass: ophyd_devices.SimMonitor
deviceConfig:
deviceTags:
- beamline
enabled: true
readOnly: false
readOnly: false
mcs:
description: Mcs scalar card for transmission readout
deviceClass: csaxs_bec.devices.epics.mcs_card.mcs_card_csaxs.MCSCardCSAXS
deviceConfig:
prefix: 'X12SA-MCS:'
onFailure: raise
enabled: true
readoutPriority: monitored
softwareTrigger: false

1
csaxs_bec/devices/epics/mcs_card/__init__.py Normal file
View File

@@ -0,0 +1 @@
from .mcs_card import MCSCard

335
csaxs_bec/devices/epics/mcs_card/mcs_card.py Normal file
View File

@@ -0,0 +1,335 @@
"""
EPICS SIS38XX Multichannel Scaler (MCS) Interface
This module provides an interface to the SIS3801/SIS3820 multichannel scaler (MCS) cards via EPICS.
It focuses on the implementation for the SIS3820 model, as input/output modes differ between SIS3801
and SIS3820. It supports both MCS and scaler record operations, enabling configuration and control of
acquisition parameters such as dwell time, channel advance mode, and input/output settings.
The module facilitates data acquisition by managing FIFO buffers and simulating conventional
MCS behavior through memory buffers.
At cSAXS, the SIS3820 model is used, which supports 32 channels.
References:
- EPICS SIS3801 and SIS3820 Drivers: https://millenia.cars.aps.anl.gov/software/epics/mcaStruck.html
"""
from __future__ import annotations
import enum
from ophyd import Component as Cpt
from ophyd import DynamicDeviceComponent, EpicsSignal, EpicsSignalRO, Kind
class CHANNELADVANCE(int, enum.Enum):
"""Channel advance pixel mode for MCS card."""
INTERNAL = 0
EXTERNAL = 1
class ACQUIRING(int, enum.Enum):
"""Acquisition status for MCS card."""
DONE = 0
ACQUIRING = 1
class READMODE(int, enum.Enum):
"""Read mode for MCS channels."""
PASSIVE = 0
EVENT = 1
IO_INTR = 2
FREQ_0_1HZ = 3
FREQ_0_2HZ = 4
FREQ_0_5HZ = 5
FREQ_1HZ = 6
FREQ_2HZ = 7
FREQ_5HZ = 8
FREQ_10HZ = 9
FREQ_100HZ = 10
class CHANNEL1SOURCE(int, enum.Enum):
"""Source for first counter pulses."""
INTERNAL_CLOCK = 0
EXTERNAL = 1
class POLARITY(int, enum.Enum):
"""Polarity of input_polarity/output_polarity for MCS card."""
NORMAL = 0
INVERTED = 1
class ACQUIREMODE(int, enum.Enum):
"""Acquire mode for the card. Allowed modes are Scaler and MCS."""
MCS = 0
SCALER = 1
class MODELS(int, enum.Enum):
SIS3801 = 0
SIS3820 = 1
class INPUTMODE(int, enum.Enum):
"""SIS3820 input mode definitions, in total there are 8 modes (0-7).
Each mode defines the function of external inputs 1-4.
Note: SIS3820 has extended input modes compared to SIS3801.
Please check the EPICS documentation for details on the specific input modes supported by SIS3801.
"""
MODE_0 = 0
MODE_1 = 1
MODE_2 = 2
MODE_3 = 3
MODE_4 = 4
MODE_5 = 5
MODE_6 = 6
MODE_7 = 7
def describe(self) -> str:
"""Return a description of the input mode."""
descriptions = {
self.MODE_0: "Inputs 1-4: No function (default idle mode)",
self.MODE_1: "Inputs 1-4: Next pulse, User bit 1, User bit 2, Inhibit next pulse",
self.MODE_2: "Inputs 1-4: Next pulse, User bit 1, Inhibit counting, Inhibit next pulse",
self.MODE_3: "Inputs 1-4: Next pulse, User bit 1, User bit 2, Inhibit counting",
self.MODE_4: "Inputs 1-4: Inhibit counting channels 1-8, 9-16, 17-24, 25-32",
self.MODE_5: "Inputs 1-4: Next pulse, HISCAL_START, No function, No function",
self.MODE_6: "Inputs 1-4: Next pulse, Inhibit counting, Clear counters, User bit 1",
self.MODE_7: "Inputs 1-4: Encoder A, Encoder B, Encoder I, Inhibit counting",
}
return descriptions.get(self, "Unknown input mode")
class OUTPUTMODE(int, enum.Enum):
"""SIS3820 output mode definitions, in total there are 4 modes (0-3).
Each mode configures output signals 5-8.
Note: SIS3820 supports 4 output modes (0-3), SIS3801 supports only Mode 0 with differen functionality.
Please check the EPICS documentation for details on the specific output modes supported by SIS3801.
"""
MODE_0 = 0
MODE_1 = 1
MODE_2 = 2
MODE_3 = 3
def describe(self) -> str:
"""Return a description of the output mode."""
descriptions = {
self.MODE_0: "Outputs 5-8: LNE/CIP, SDRAM empty, SDRAM threshold, User LED",
self.MODE_1: "Outputs 5-8: LNE/CIP, Enabled, 50 MHz, User LED",
self.MODE_2: "Outputs 5-8: LNE/CIP, 10 MHz (20ns), 10 MHz (20ns), User LED",
self.MODE_3: "Outputs 5-8: LNE/CIP, 10 MHz (20ns), MUX OUT channel, User LED (requires firmware ≥ 0x10A)",
}
return descriptions.get(self, "Unknown output mode")
def _create_mca_channels(num_channels: int) -> dict[str, tuple]:
"""
Create a dictionary of MCA channel definitions for the DynamicDeviceComponent.
Starts from channel 1 to num_channels.
Args:
num_channels (int): The number of MCA channels to create.
"""
mcs_channels = {}
for i in range(1, num_channels + 1):
mcs_channels[f"mca{i}"] = (
EpicsSignalRO,
f"MCA{i}",
{"kind": Kind.omitted, "auto_monitor": True, "doc": f"MCA channel {i}."},
)
return mcs_channels
class MCSCard:
"""
Ophyd implementation for the interface to the SIS3801/SIS3820 multichannel scaler (MCS) cards via EPICS.
This class provides signals to expose EPICS PVs of the MCS card. More details can be found in the
documentation of the EPICS drivers for SIS3801 and SIS3820.
References:
- EPICS SIS3801 and SIS3820 Drivers: https://millenia.cars.aps.anl.gov/software/epics/mcaStruck.html
"""
snl_connected = Cpt(
EpicsSignalRO,
"SNL_Connected",
kind=Kind.omitted,
doc="Indicates whether the SNL program has connected to all PVs.",
)
erase_all = Cpt(
EpicsSignal,
"EraseAll",
kind=Kind.omitted,
doc="Erases all mca or waveform records, setting elapsed times and counts in all channels to 0.",
)
erase_start = Cpt(
EpicsSignal,
"EraseStart",
kind=Kind.omitted,
doc="Erases all mca or waveform records and starts acquisition.",
)
start_all = Cpt(
EpicsSignal,
"StartAll",
kind=Kind.omitted,
doc="Starts or resumes acquisition without erasing first.",
)
acquiring = Cpt(
EpicsSignalRO,
"Acquiring",
kind=Kind.omitted,
doc="Acquiring (=1) when acquisition is in progress and Done (=0) when acquisition is complete.",
)
stop_all = Cpt(EpicsSignal, "StopAll", kind=Kind.omitted, doc="Stops acquisition.")
preset_real = Cpt(
EpicsSignal,
"PresetReal",
kind=Kind.omitted,
doc="Preset real time. If non-zero then acquisition will stop when this time is reached.",
)
elapsed_real = Cpt(
EpicsSignalRO,
"ElapsedReal",
kind=Kind.omitted,
doc="Elapsed time since acquisition started.",
)
read_all = Cpt(
EpicsSignal,
"ReadAll",
kind=Kind.omitted,
doc="Forces a read of all mca or waveform records from the hardware. This record can be set to periodically process to update the records during acquisition. Note that even if this record has SCAN=Passive the mca or waveform records will always process once when acquisition completes.",
)
num_use_all = Cpt(
EpicsSignal,
"NUseAll",
kind=Kind.omitted,
doc="The number of channels to use for the mca or waveform records. Acquisition will automatically stop when the number of channel advances reaches this value.",
)
dwell = Cpt(
EpicsSignal,
"Dwell",
kind=Kind.omitted,
doc="The dwell time per channel when using internal channel advance mode.",
)
channel_advance = Cpt(
EpicsSignal,
"ChannelAdvance",
kind=Kind.omitted,
doc="The channel advance mode. Choices are 'Internal' (count for a preset time per channel) or 'External' (advance on external hardware channel advance signal).",
)
count_on_start = Cpt(
EpicsSignal,
"CountOnStart",
kind=Kind.omitted,
doc="Flag controlling whether the module begins counting immediately when acquisition starts. This record only applies in External channel advance mode. If No (=0) then counting does not start in channel 0 until receipt of the first external channel advance pulse. If Yes (=1) then counting in channel 0 starts immediately when acquisition starts, without waiting for the first external channel advance pulse.",
)
software_channel_advance = Cpt(
EpicsSignal,
"SoftwareChannelAdvance",
kind=Kind.omitted,
doc="Processing this record causes a channel advance to occur immediately, without waiting for the current dwell time to be reached or the next external channel advance pulse to arrive.",
)
channel1_source = Cpt(
EpicsSignal,
"Channel1Source",
kind=Kind.omitted,
doc="Controls the source of pulses into the first counter. The choices are 'Int. clock' which selects the internal clock, and 'External' which selects the external pulse input to counter 1.",
)
prescale = Cpt(
EpicsSignal,
"Prescale",
kind=Kind.omitted,
doc="The prescale factor for external channel advance pulses. If the prescale factor is N then N external channel advance pulses must be received before a channel advance will occur.",
)
enable_client_wait = Cpt(
EpicsSignal,
"EnableClientWait",
kind=Kind.omitted,
doc="Flag to force acquisition to wait until a client clears the ClientWait busy record before proceeding to the next acquisition. This can be useful with the scan record.",
)
client_wait = Cpt(
EpicsSignal,
"ClientWait",
kind=Kind.omitted,
doc="Flag that will be set to 1 when acquisition completes, and which a client must set back to 0 to allow acquisition to proceed. This only has an effect if EnableClientWait is 1.",
)
acquire_mode = Cpt(
EpicsSignal,
"AcquireMode",
kind=Kind.omitted,
doc="The current acquisition mode (MCS=0 or Scaler=1). This record is used to turn off the scaler record Autocount in MCS mode.",
)
mux_output = Cpt(
EpicsSignal,
"MUXOutput",
kind=Kind.omitted,
doc="Value of 0-32 used to select which input signal is routed to output signal 7 on the SIS3820 in output mode 3.",
)
user_led = Cpt(
EpicsSignal,
"UserLED",
kind=Kind.omitted,
doc="Toggles the user LED and also output signal 8 on the SIS3820.",
)
input_mode = Cpt(
EpicsSignal,
"InputMode",
kind=Kind.omitted,
doc="The input mode. Supported input modes vary for SIS3801 and SIS3820.",
)
input_polarity = Cpt(
EpicsSignal,
"InputPolarity",
kind=Kind.omitted,
doc="The polarity of the input control signals on the SIS3820. Choices are Normal and Inverted.",
)
output_mode = Cpt(
EpicsSignal,
"OutputMode",
kind=Kind.omitted,
doc="The output mode. Supported output modes vary for SIS3801 and SIS3820.",
)
output_polarity = Cpt(
EpicsSignal,
"OutputPolarity",
kind=Kind.omitted,
doc="The polarity of the output control signals on the SIS3820. Choices are Normal and Inverted.",
)
model = Cpt(
EpicsSignalRO,
"Model",
kind=Kind.omitted,
doc="The scaler model. Values are 'SIS3801' and 'SIS3820'.",
)
firmware = Cpt(EpicsSignalRO, "Firmware", kind=Kind.omitted, doc="The firmware version.")
max_channels = Cpt(
EpicsSignalRO, "MaxChannels", kind=Kind.omitted, doc="The maximum number of channels."
)
# Relevant counters
current_channel = Cpt(
EpicsSignalRO,
"CurrentChannel",
kind=Kind.omitted,
auto_monitor=True,
doc="The current channel number, i.e. the number of channel advances that have occurred minus 1.",
)
counters = DynamicDeviceComponent(
_create_mca_channels(32),
kind=Kind.omitted,
doc="Sub-device with the mca counters 1-32 for SIS3820.",
)

102
csaxs_bec/devices/epics/mcs_card/mcs_card_csaxs.py Normal file
View File

@@ -0,0 +1,102 @@
"""Module for the MCSCard CSAXS implementation."""
from ophyd import Component as Cpt
from ophyd_devices import CompareStatus, ProgressSignal
from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
from csaxs_bec.devices.epics.mcs_card.mcs_card import (
ACQUIREMODE,
ACQUIRING,
CHANNEL1SOURCE,
CHANNELADVANCE,
INPUTMODE,
OUTPUTMODE,
POLARITY,
READMODE,
MCSCard,
)
class MCSCardCSAXS(PSIDeviceBase, MCSCard):
"""
Implementation of the MCSCard SIS3820 for CSAXS, prefix 'X12SA-MCS:'.
The basic functionality is inherited from the MCSCard class.
"""
progress: ProgressSignal = Cpt(ProgressSignal, "progress")
def __init__(self, *args, **kwargs):
"""
Initialize the MCSCardCSAXS with the given arguments and keyword arguments.
"""
super().__init__(*args, **kwargs)
self._pv_timeout = 2
def on_connected(self):
"""
Called when the device is connected.
"""
self.channel_advance.set(CHANNELADVANCE.EXTERNAL).wait(timeout=self._pv_timeout)
self.channel_advance.set(CHANNEL1SOURCE.EXTERNAL).wait(
timeout=self._pv_timeout
) # Check if this is correct, or internal clock
self.user_led.set(0).wait(timeout=self._pv_timeout)
# Only channel 1-5 are connected so far, adjust if more are needed
self.mux_output.set(5).wait(timeout=self._pv_timeout)
self.input_mode.set(INPUTMODE.MODE_3).wait(timeout=self._pv_timeout)
self.input_polarity.set(POLARITY.NORMAL).wait(timeout=self._pv_timeout)
self.output_mode.set(OUTPUTMODE.MODE_2).wait(
timeout=self._pv_timeout
) # To be checked due to cabling of time counter
self.output_polarity.set(POLARITY.INVERTED).wait(
timeout=self._pv_timeout
) # To be checked and tested!
self.count_on_start.set(0).wait(timeout=self._pv_timeout)
# Subscribe the progress signal
self.current_channel.subscribe(self._progress_update, run=False)
# Set appropriate read mode
self.read_mode.set(READMODE.PASSIVE).wait(timeout=self._pv_timeout)
def _progress_update(self, value, **kwargs) -> None:
"""Callback for progress updates from ophyd subscription on current_channel."""
frames_per_trigger = self.scan_info.msg.scan_parameters.get("frames_per_trigger", 1)
channel_advance = frames_per_trigger + 1
self.progress.put(value, max_value=channel_advance, done=bool(value == channel_advance))
def on_stage(self) -> None:
"""
Called when the device is staged.
"""
self.erase_all.set(1).wait(timeout=self._pv_timeout)
triggers = self.scan_info.msg.scan_parameters.get("frames_per_trigger", 1)
self.preset_real.set(0).wait(timeout=self._pv_timeout)
self.num_use_all.set(triggers).wait(timeout=self._pv_timeout)
def on_unstage(self) -> None:
"""
Called when the device is unstaged.
"""
self.erase_all.set(0).wait(timeout=self._pv_timeout)
def on_pre_scan(self) -> None:
"""
Called before the scan starts.
"""
self.erase_start.put(1)
def on_complete(self) -> CompareStatus:
"""On scan completion."""
# Check if we should get a signal based on updates from the MCA channels
status = CompareStatus(self.acquiring, ACQUIRING.DONE)
self.cancel_on_stop(status)
return status
def on_stop(self) -> None:
"""
Called when the scan is stopped.
"""
self.stop_all.put(1)
# Reset the progress signal
# self.progress.put(0, done=True)

319
csaxs_bec/devices/epics/mcs_card/mcs_csaxs_old.py Normal file
View File

@@ -0,0 +1,319 @@
import enum
import threading
from collections import defaultdict
import numpy as np
from bec_lib import bec_logger, messages
from bec_lib.endpoints import MessageEndpoints
from ophyd import Component as Cpt
from ophyd import Device, EpicsSignal, EpicsSignalRO
from ophyd_devices.interfaces.base_classes.psi_detector_base import (
CustomDetectorMixin,
PSIDetectorBase,
)
from ophyd_devices.utils import bec_utils
logger = bec_logger.logger
class MCSError(Exception):
"""Base class for exceptions in this module."""
class MCSTimeoutError(MCSError):
"""Raise when MCS card runs into a timeout"""
class TriggerSource(int, enum.Enum):
"""Trigger source for mcs card - see manual for more information"""
MODE0 = 0
MODE1 = 1
MODE2 = 2
MODE3 = 3
MODE4 = 4
MODE5 = 5
MODE6 = 6
class ChannelAdvance(int, enum.Enum):
"""Channel advance pixel mode for mcs card - see manual for more information"""
INTERNAL = 0
EXTERNAL = 1
class ReadoutMode(int, enum.Enum):
"""Readout mode for mcs card - see manual for more information"""
PASSIVE = 0
EVENT = 1
IO_INTR = 2
FREQ_0_1HZ = 3
FREQ_0_2HZ = 4
FREQ_0_5HZ = 5
FREQ_1HZ = 6
FREQ_2HZ = 7
FREQ_5HZ = 8
FREQ_10HZ = 9
FREQ_100HZ = 10
class MCSSetup(CustomDetectorMixin):
"""Setup mixin class for the MCS card"""
def __init__(self, *args, parent: Device = None, **kwargs) -> None:
super().__init__(*args, parent=parent, **kwargs)
self._lock = threading.RLock()
self._stream_ttl = 1800
self.acquisition_done = False
self.counter = 0
self.n_points = 0
self.mca_names = [
signal for signal in self.parent.component_names if signal.startswith("mca")
]
self.mca_data = defaultdict(lambda: [])
def on_init(self) -> None:
"""Init sequence for the detector"""
self.initialize_detector()
self.initialize_detector_backend()
def initialize_detector(self) -> None:
"""Initialize d etector"""
# External trigger for pixel advance
self.parent.channel_advance.set(ChannelAdvance.EXTERNAL)
# Use internal clock for channel 1
self.parent.channel1_source.set(ChannelAdvance.INTERNAL)
self.parent.user_led.set(0)
# Set number of channels to 5
self.parent.mux_output.set(5)
# Trigger Mode used for cSAXS
self.parent.input_mode.set(TriggerSource.MODE3)
# specify polarity of trigger signals
self.parent.input_polarity.set(0)
self.parent.output_polarity.set(1)
# do not start counting on start
self.parent.count_on_start.set(0)
self.stop_detector()
def initialize_detector_backend(self) -> None:
"""Initialize detector backend"""
for mca in self.mca_names:
signal = getattr(self.parent, mca)
signal.subscribe(self._on_mca_data, run=False)
self.parent.current_channel.subscribe(self._progress_update, run=False)
def _progress_update(self, value, **kwargs) -> None:
"""Progress update on the scan"""
num_lines = self.parent.num_lines.get()
max_value = self.parent.scaninfo.num_points
# self.counter seems to be a deprecated variable from a former implementation of the mcs card
# pylint: disable=protected-access
self.parent._run_subs(
sub_type=self.parent.SUB_PROGRESS,
value=self.counter * int(self.parent.scaninfo.num_points / num_lines) + value,
max_value=max_value,
# TODO check if that is correct with
done=bool(max_value == value), # == self.counter),
)
def _on_mca_data(self, *args, obj=None, value=None, **kwargs) -> None:
"""Callback function for scan progress"""
with self._lock:
if not isinstance(value, (list, np.ndarray)):
return
self.mca_data[obj.attr_name] = value
if len(self.mca_names) != len(self.mca_data):
return
self.acquisition_done = True
self._send_data_to_bec()
self.mca_data = defaultdict(lambda: [])
def _send_data_to_bec(self) -> None:
"""Sends bundled data to BEC"""
if self.parent.scaninfo.scan_msg is None:
return
metadata = self.parent.scaninfo.scan_msg.metadata
metadata.update({"async_update": "append", "num_lines": self.parent.num_lines.get()})
msg = messages.DeviceMessage(
signals=dict(self.mca_data), metadata=self.parent.scaninfo.scan_msg.metadata
)
self.parent.connector.xadd(
topic=MessageEndpoints.device_async_readback(
scan_id=self.parent.scaninfo.scan_id, device=self.parent.name
),
msg={"data": msg},
expire=self._stream_ttl,
)
def on_stage(self) -> None:
"""Stage detector"""
self.prepare_detector()
self.prepare_detector_backend()
def prepare_detector(self) -> None:
"""Prepare detector for scan"""
self.set_acquisition_params()
self.parent.input_mode.set(TriggerSource.MODE3)
def set_acquisition_params(self) -> None:
"""Set acquisition parameters for scan"""
if self.parent.scaninfo.scan_type == "step":
self.n_points = int(self.parent.scaninfo.frames_per_trigger) * int(
self.parent.scaninfo.num_points
)
elif self.parent.scaninfo.scan_type == "fly":
self.n_points = int(self.parent.scaninfo.num_points) # / int(self.num_lines.get()))
else:
raise MCSError(f"Scantype {self.parent.scaninfo} not implemented for MCS card")
if self.n_points > 10000:
raise MCSError(
f"Requested number of points N={self.n_points} exceeds hardware limit of mcs card"
" 10000 (N-1)"
)
self.parent.num_use_all.set(self.n_points)
self.parent.preset_real.set(0)
def prepare_detector_backend(self) -> None:
"""Prepare detector backend for scan"""
self.parent.erase_all.set(1)
self.parent.read_mode.set(ReadoutMode.EVENT)
def arm_acquisition(self) -> None:
"""Arm detector for acquisition"""
self.counter = 0
self.parent.erase_start.set(1)
def on_unstage(self) -> None:
"""Unstage detector"""
pass
def on_complete(self) -> None:
"""Complete detector"""
self.finished(timeout=self.parent.TIMEOUT_FOR_SIGNALS)
def finished(self, timeout: int = 5) -> None:
"""Check if acquisition is finished, if not successful, rais MCSTimeoutError"""
signal_conditions = [
(lambda: self.acquisition_done, True),
(self.parent.acquiring.get, 0), # Considering making a enum.Int class for this state
]
if not self.wait_for_signals(
signal_conditions=signal_conditions,
timeout=timeout,
check_stopped=True,
all_signals=True,
):
total_frames = self.counter * int(
self.parent.scaninfo.num_points / self.parent.num_lines.get()
) + max(self.parent.current_channel.get(), 0)
raise MCSTimeoutError(
f"Reached timeout with mcs in state {self.parent.acquiring.get()} and"
f" {total_frames} frames arriving at the mcs card"
)
def on_stop(self) -> None:
"""Stop detector"""
self.stop_detector()
self.stop_detector_backend()
def stop_detector(self) -> None:
"""Stop detector"""
self.parent.stop_all.set(1)
def stop_detector_backend(self) -> None:
"""Stop acquisition of data"""
self.acquisition_done = True
class SIS38XX(Device):
"""SIS38XX card for access to EPICs PVs at cSAXS beamline"""
class MCScSAXS(PSIDetectorBase):
"""MCS card for cSAXS for implementation at cSAXS beamline"""
USER_ACCESS = []
SUB_PROGRESS = "progress"
SUB_VALUE = "value"
_default_sub = SUB_VALUE
# specify Setup class
custom_prepare_cls = MCSSetup
# specify minimum readout time for detector
MIN_READOUT = 0
TIMEOUT_FOR_SIGNALS = 5
# PV access to SISS38XX card
# Acquisition
erase_all = Cpt(EpicsSignal, "EraseAll")
erase_start = Cpt(EpicsSignal, "EraseStart") # ,trigger_value=1
start_all = Cpt(EpicsSignal, "StartAll")
stop_all = Cpt(EpicsSignal, "StopAll")
acquiring = Cpt(EpicsSignal, "Acquiring")
preset_real = Cpt(EpicsSignal, "PresetReal")
elapsed_real = Cpt(EpicsSignal, "ElapsedReal")
read_mode = Cpt(EpicsSignal, "ReadAll.SCAN")
read_all = Cpt(EpicsSignal, "DoReadAll.VAL") # ,trigger_value=1
num_use_all = Cpt(EpicsSignal, "NuseAll")
current_channel = Cpt(EpicsSignal, "CurrentChannel")
dwell = Cpt(EpicsSignal, "Dwell")
channel_advance = Cpt(EpicsSignal, "ChannelAdvance")
count_on_start = Cpt(EpicsSignal, "CountOnStart")
software_channel_advance = Cpt(EpicsSignal, "SoftwareChannelAdvance")
channel1_source = Cpt(EpicsSignal, "Channel1Source")
prescale = Cpt(EpicsSignal, "Prescale")
enable_client_wait = Cpt(EpicsSignal, "EnableClientWait")
client_wait = Cpt(EpicsSignal, "ClientWait")
acquire_mode = Cpt(EpicsSignal, "AcquireMode")
mux_output = Cpt(EpicsSignal, "MUXOutput")
user_led = Cpt(EpicsSignal, "UserLED")
input_mode = Cpt(EpicsSignal, "InputMode")
input_polarity = Cpt(EpicsSignal, "InputPolarity")
output_mode = Cpt(EpicsSignal, "OutputMode")
output_polarity = Cpt(EpicsSignal, "OutputPolarity")
model = Cpt(EpicsSignalRO, "Model", string=True)
firmware = Cpt(EpicsSignalRO, "Firmware")
max_channels = Cpt(EpicsSignalRO, "MaxChannels")
# PV access to MCA signals
mca1 = Cpt(EpicsSignalRO, "mca1.VAL", auto_monitor=True)
mca3 = Cpt(EpicsSignalRO, "mca3.VAL", auto_monitor=True)
mca4 = Cpt(EpicsSignalRO, "mca4.VAL", auto_monitor=True)
current_channel = Cpt(EpicsSignalRO, "CurrentChannel", auto_monitor=True)
# Custom signal readout from device config
num_lines = Cpt(
bec_utils.ConfigSignal, name="num_lines", kind="config", config_storage_name="mcs_config"
)
def __init__(
self,
prefix="",
*,
name,
kind=None,
parent=None,
device_manager=None,
mcs_config=None,
**kwargs,
):
self.mcs_config = {f"{name}_num_lines": 1}
if mcs_config is not None:
# pylint: disable=expression-not-assigned
[self.mcs_config.update({f"{name}_{key}": value}) for key, value in mcs_config.items()]
super().__init__(
prefix=prefix,
name=name,
kind=kind,
parent=parent,
device_manager=device_manager,
**kwargs,
)
# Automatically connect to test environmenr if directly invoked
if __name__ == "__main__":
mcs = MCScSAXS(name="mcs", prefix="X12SA-MCS:", sim_mode=True)