bec-widgets 0.83.1__py3-none-any.whl → 0.84.0__py3-none-any.whl

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import time
 from collections import defaultdict
 from typing import Any, Literal, Optional
@@ -7,8 +8,8 @@ from typing import Any, Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import messages
+from bec_lib.device import ReadoutPriority
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.scan_data import ScanData
 from pydantic import Field, ValidationError
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
@@ -27,18 +28,26 @@ from bec_widgets.widgets.figure.plots.waveform.waveform_curve import (
 class Waveform1DConfig(SubplotConfig):
     color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
         "plasma", description="The color palette of the figure widget."
-    )  # TODO can be extended to all colormaps from current pyqtgraph session
+    )
     curves: dict[str, CurveConfig] = Field(
         {}, description="The list of curves to be added to the 1D waveform widget."
     )
 
 
 class BECWaveform(BECPlotBase):
+    READOUT_PRIORITY_HANDLER = {
+        ReadoutPriority.ON_REQUEST: "on_request",
+        ReadoutPriority.BASELINE: "baseline",
+        ReadoutPriority.MONITORED: "monitored",
+        ReadoutPriority.ASYNC: "async",
+        ReadoutPriority.CONTINUOUS: "continuous",
+    }
     USER_ACCESS = [
         "_rpc_id",
         "_config_dict",
         "plot",
         "add_dap",
+        "set_x",
         "get_dap_params",
         "remove_curve",
         "scan_history",
@@ -56,10 +65,13 @@ class BECWaveform(BECPlotBase):
         "set_grid",
         "lock_aspect_ratio",
         "remove",
+        "clear_all",
         "set_legend_label_size",
     ]
     scan_signal_update = pyqtSignal()
+    async_signal_update = pyqtSignal()
     dap_params_update = pyqtSignal(dict)
+    autorange_signal = pyqtSignal()
 
     def __init__(
         self,
@@ -78,20 +90,31 @@ class BECWaveform(BECPlotBase):
         self._curves_data = defaultdict(dict)
         self.old_scan_id = None
         self.scan_id = None
+        self.scan_item = None
+        self._x_axis_mode = {
+            "name": None,
+            "entry": None,
+            "readout_priority": None,
+            "label_suffix": "",
+        }
 
         # Scan segment update proxy
         self.proxy_update_plot = pg.SignalProxy(
-            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
+            self.scan_signal_update, rateLimit=25, slot=self._update_scan_curves
         )
-
         self.proxy_update_dap = pg.SignalProxy(
             self.scan_signal_update, rateLimit=25, slot=self.refresh_dap
         )
+        self.async_signal_update.connect(self.replot_async_curve)
+        self.autorange_signal.connect(self.auto_range)
+
         # Get bec shortcuts dev, scans, queue, scan_storage, dap
         self.get_bec_shortcuts()
 
         # Connect dispatcher signals
         self.bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        # TODO disabled -> scan_status is SET_AND_PUBLISH -> do not work in combination with autoupdate from CLI
+        # self.bec_dispatcher.connect_slot(self.on_scan_status, MessageEndpoints.scan_status())
 
         self.entry_validator = EntryValidator(self.dev)
 
@@ -139,6 +162,41 @@ class BECWaveform(BECPlotBase):
         for curve in self.curves:
             curve.config.parent_id = new_gui_id
 
+    ###################################
+    # Waveform Properties
+    ###################################
+
+    @property
+    def curves(self) -> list[BECCurve]:
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+        return self._curves
+
+    @curves.setter
+    def curves(self, value: list[BECCurve]):
+        self._curves = value
+
+    @property
+    def x_axis_mode(self) -> dict:
+        """
+        Get the x axis mode of the plot widget.
+
+        Returns:
+            dict: The x axis mode.
+        """
+        return self._x_axis_mode
+
+    @x_axis_mode.setter
+    def x_axis_mode(self, value: dict):
+        self._x_axis_mode = value
+
+    ###################################
+    # Adding and Removing Curves
+    ###################################
+
     def add_curve_by_config(self, curve_config: CurveConfig | dict) -> BECCurve:
         """
         Add a curve to the plot widget by its configuration.
@@ -173,19 +231,6 @@ class BECWaveform(BECPlotBase):
                 else:
                     return curves[curve_id].config
 
-    @property
-    def curves(self) -> list[BECCurve]:
-        """
-        Get the curves of the plot widget as a list
-        Returns:
-            list: List of curves.
-        """
-        return self._curves
-
-    @curves.setter
-    def curves(self, value: list[BECCurve]):
-        self._curves = value
-
     def get_curve(self, identifier) -> BECCurve:
         """
         Get the curve by its index or ID.
@@ -208,8 +253,9 @@ class BECWaveform(BECPlotBase):
 
     def plot(
         self,
-        x: list | np.ndarray | None = None,
+        arg1: list | np.ndarray | str | None = None,
         y: list | np.ndarray | None = None,
+        x: list | np.ndarray | None = None,
         x_name: str | None = None,
         y_name: str | None = None,
         z_name: str | None = None,
@@ -225,10 +271,16 @@ class BECWaveform(BECPlotBase):
     ) -> BECCurve:
         """
         Plot a curve to the plot widget.
+
         Args:
-            x(list | np.ndarray): Custom x data to plot.
+            arg1(list | np.ndarray | str | None): First argument which can be x data, y data, or y_name.
             y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
+            x(list | np.ndarray): Custom y data to plot.
+            x_name(str): Name of the x signal.
+                - "best_effort": Use the best effort signal.
+                - "timestamp": Use the timestamp signal.
+                - "index": Use the index signal.
+                - Custom signal name of device from BEC.
             y_name(str): The name of the device for the y-axis.
             z_name(str): The name of the device for the z-axis.
             x_entry(str): The name of the entry for the x-axis.
@@ -238,30 +290,136 @@ class BECWaveform(BECPlotBase):
             color_map_z(str): The color map to use for the z-axis.
             label(str): The label of the curve.
             validate(bool): If True, validate the device names and entries.
-            dap(str): The dap model to use for the curve. If not specified, none will be added.
+            dap(str): The dap model to use for the curve, only available for sync devices. If not specified, none will be added.
 
         Returns:
             BECCurve: The curve object.
         """
-
         if x is not None and y is not None:
             return self.add_curve_custom(x=x, y=y, label=label, color=color, **kwargs)
-        else:
-            if dap:
-                self.add_dap(x_name=x_name, y_name=y_name, dap=dap)
-            return self.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                z_name=z_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                z_entry=z_entry,
-                color=color,
-                color_map_z=color_map_z,
-                label=label,
-                validate_bec=validate,
-                **kwargs,
+
+        if isinstance(arg1, str):
+            y_name = arg1
+        elif isinstance(arg1, list):
+            if isinstance(y, list):
+                return self.add_curve_custom(x=arg1, y=y, label=label, color=color, **kwargs)
+            if y is None:
+                x = np.arange(len(arg1))
+                return self.add_curve_custom(x=x, y=arg1, label=label, color=color, **kwargs)
+        elif isinstance(arg1, np.ndarray) and y is None:
+            if arg1.ndim == 1:
+                x = np.arange(arg1.size)
+                return self.add_curve_custom(x=x, y=arg1, label=label, color=color, **kwargs)
+            if arg1.ndim == 2:
+                x = arg1[:, 0]
+                y = arg1[:, 1]
+                return self.add_curve_custom(x=x, y=y, label=label, color=color, **kwargs)
+        if y_name is None:
+            raise ValueError("y_name must be provided.")
+        if dap:
+            self.add_dap(x_name=x_name, y_name=y_name, dap=dap)
+        curve = self.add_curve_bec(
+            x_name=x_name,
+            y_name=y_name,
+            z_name=z_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            z_entry=z_entry,
+            color=color,
+            color_map_z=color_map_z,
+            label=label,
+            validate_bec=validate,
+            **kwargs,
+        )
+        self.scan_signal_update.emit()
+        self.async_signal_update.emit()
+
+        return curve
+
+    def set_x(self, x_name: str, x_entry: str | None = None):
+        """
+        Change the x axis of the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+                - "best_effort": Use the best effort signal.
+                - "timestamp": Use the timestamp signal.
+                - "index": Use the index signal.
+                - Custom signal name of device from BEC.
+            x_entry(str): Entry of the x signal.
+        """
+        curve_configs = self.config.curves
+        curve_ids = list(curve_configs.keys())
+        curve_configs = list(curve_configs.values())
+        self.set_auto_range(True, "xy")
+
+        x_entry, _, _ = self._validate_signal_entries(
+            x_name, None, None, x_entry, None, None, validate_bec=True
+        )
+
+        readout_priority_x = None
+        if x_name not in ["best_effort", "timestamp", "index"]:
+            readout_priority_x = self._get_device_readout_priority(x_name)
+
+        self.x_axis_mode = {
+            "name": x_name,
+            "entry": x_entry,
+            readout_priority_x: readout_priority_x,
+        }
+
+        if len(self.curves) > 0:
+            # validate all curves
+            for curve in self.curves:
+                self._validate_x_axis_behaviour(curve.config.signals.y.name, x_name, x_entry, False)
+            self._switch_x_axis_item(
+                f"{x_name}-{x_entry}"
+                if x_name not in ["best_effort", "timestamp", "index"]
+                else x_name
             )
+            for curve_id, curve_config in zip(curve_ids, curve_configs):
+                if curve_config.signals.x:
+                    curve_config.signals.x.name = x_name
+                    curve_config.signals.x.entry = x_entry
+                self.remove_curve(curve_id)
+                self.add_curve_by_config(curve_config)
+
+            self.async_signal_update.emit()
+            self.scan_signal_update.emit()
+        # self.autorange_timer.start(200)
+
+    @pyqtSlot()
+    def auto_range(self):
+        self.plot_item.autoRange()
+
+    def set_auto_range(self, enabled: bool, axis: str = "xy"):
+        """
+        Set the auto range of the plot widget.
+
+        Args:
+            enabled(bool): If True, enable the auto range.
+            axis(str, optional): The axis to enable the auto range.
+                - "xy": Enable auto range for both x and y axis.
+                - "x": Enable auto range for x axis.
+                - "y": Enable auto range for y axis.
+        """
+        self.plot_item.enableAutoRange(axis, enabled)
+
+    @pyqtSlot()
+    def auto_range(self):
+        self.plot_item.autoRange()
+
+    def set_auto_range(self, enabled: bool, axis: str = "xy"):
+        """
+        Set the auto range of the plot widget.
+
+        Args:
+            enabled(bool): If True, enable the auto range.
+            axis(str, optional): The axis to enable the auto range.
+                - "xy": Enable auto range for both x and y axis.
+                - "x": Enable auto range for x axis.
+                - "y": Enable auto range for y axis.
+        """
+        self.plot_item.enableAutoRange(axis, enabled)
 
     def add_curve_custom(
         self,
@@ -317,20 +475,20 @@ class BECWaveform(BECPlotBase):
         )
         return curve
 
-    def add_curve_scan(
+    def add_curve_bec(
         self,
-        x_name: str,
-        y_name: str,
-        z_name: Optional[str] = None,
-        x_entry: Optional[str] = None,
-        y_entry: Optional[str] = None,
-        z_entry: Optional[str] = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
+        x_name: str | None = None,
+        y_name: str | None = None,
+        z_name: str | None = None,
+        x_entry: str | None = None,
+        y_entry: str | None = None,
+        z_entry: str | None = None,
+        color: str | None = None,
+        color_map_z: str | None = "plasma",
+        label: str | None = None,
         validate_bec: bool = True,
-        source: str = "scan_segment",
-        dap: Optional[str] = None,
+        dap: str | None = None,
+        source: str | None = None,
         **kwargs,
     ) -> BECCurve:
         """
@@ -346,28 +504,50 @@ class BECWaveform(BECPlotBase):
             color(str, optional): Color of the curve. Defaults to None.
             color_map_z(str): The color map to use for the z-axis.
             label(str, optional): Label of the curve. Defaults to None.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+            dap(str, optional): The dap model to use for the curve. Defaults to None.
             **kwargs: Additional keyword arguments for the curve configuration.
 
         Returns:
             BECCurve: The curve object.
         """
-        # Check if curve already exists
-        curve_source = source
+        # 1. Check - y_name must be provided
+        if y_name is None:
+            raise ValueError("y_name must be provided.")
+
+        # 2. Check - check if there is already a x axis signal
+        if x_name is None:
+            mode = self.x_axis_mode["name"]
+            x_name = mode if mode is not None else "best_effort"
+            self.x_axis_mode["name"] = x_name
 
-        # Get entry if not provided and validate
+        # 3. Check - Get entry if not provided and validate
         x_entry, y_entry, z_entry = self._validate_signal_entries(
             x_name, y_name, z_name, x_entry, y_entry, z_entry, validate_bec
         )
 
+        # 4. Check - get source of the device
+        if source is None:
+            if validate_bec is True:
+                source = self._validate_device_source_compatibity(y_name)
+            else:
+                source = "scan_segment"
+
         if z_name is not None and z_entry is not None:
             label = label or f"{z_name}-{z_entry}"
         else:
             label = label or f"{y_name}-{y_entry}"
 
+        # 5. Check - Check if curve already exists
         curve_exits = self._check_curve_id(label, self._curves_data)
         if curve_exits:
             raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
 
+        # Validate or define x axis behaviour and compatibility with y_name readoutPriority
+        if validate_bec is True:
+            self._validate_x_axis_behaviour(y_name, x_name, x_entry)
+
+        # Create color if not specified
         color = (
             color
             or Colors.golden_angle_color(
@@ -382,27 +562,29 @@ class BECWaveform(BECPlotBase):
             label=label,
             color=color,
             color_map_z=color_map_z,
-            source=curve_source,
+            source=source,
             signals=Signal(
-                source=curve_source,
-                x=SignalData(name=x_name, entry=x_entry),
+                source=source,
+                x=SignalData(name=x_name, entry=x_entry) if x_name else None,
                 y=SignalData(name=y_name, entry=y_entry),
                 z=SignalData(name=z_name, entry=z_entry) if z_name else None,
                 dap=dap,
             ),
             **kwargs,
         )
-        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+
+        curve = self._add_curve_object(name=label, source=source, config=curve_config)
         return curve
 
     def add_dap(
         self,
-        x_name: str,
-        y_name: str,
+        x_name: str | None = None,
+        y_name: str | None = None,
         x_entry: Optional[str] = None,
         y_entry: Optional[str] = None,
         color: Optional[str] = None,
         dap: str = "GaussianModel",
+        validate_bec: bool = True,
         **kwargs,
     ) -> BECCurve:
         """
@@ -417,16 +599,31 @@ class BECWaveform(BECPlotBase):
             color_map_z(str): The color map to use for the z-axis.
             label(str, optional): Label of the curve. Defaults to None.
             dap(str): The dap model to use for the curve.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
             **kwargs: Additional keyword arguments for the curve configuration.
 
         Returns:
             BECCurve: The curve object.
         """
-        x_entry, y_entry, _ = self._validate_signal_entries(
-            x_name, y_name, None, x_entry, y_entry, None
-        )
+        if x_name is None:
+            x_name = self.x_axis_mode["name"]
+            x_entry = self.x_axis_mode["entry"]
+            if x_name == "timestamp" or x_name == "index":
+                raise ValueError(
+                    f"Cannot use x axis '{x_name}' for DAP curve. Please provide a custom x axis signal or switch to 'best_effort' signal mode."
+                )
+
+        if self.x_axis_mode["readout_priority"] == "async":
+            raise ValueError(
+                f"Async signals cannot be fitted at the moment. Please switch to 'monitored' or 'baseline' signals."
+            )
+
+        if validate_bec is True:
+            x_entry, y_entry, _ = self._validate_signal_entries(
+                x_name, y_name, None, x_entry, y_entry, None
+            )
         label = f"{y_name}-{y_entry}-{dap}"
-        curve = self.add_curve_scan(
+        curve = self.add_curve_bec(
             x_name=x_name,
             y_name=y_name,
             x_entry=x_entry,
@@ -444,6 +641,7 @@ class BECWaveform(BECPlotBase):
         self.refresh_dap()
         return curve
 
+    @pyqtSlot()
     def get_dap_params(self) -> dict:
         """
         Get the DAP parameters of all DAP curves.
@@ -484,10 +682,118 @@ class BECWaveform(BECPlotBase):
         self.set_legend_label_size()
         return curve
 
+    def _validate_device_source_compatibity(self, name: str):
+        readout_priority_y = self._get_device_readout_priority(name)
+        if readout_priority_y == "monitored" or readout_priority_y == "baseline":
+            source = "scan_segment"
+        elif readout_priority_y == "async":
+            source = "async"
+        else:
+            raise ValueError(
+                f"Readout priority '{readout_priority_y}' of device '{name}' is not supported for y signal."
+            )
+        return source
+
+    def _validate_x_axis_behaviour(
+        self, y_name: str, x_name: str | None = None, x_entry: str | None = None, auto_switch=True
+    ) -> None:
+        """
+        Validate the x axis behaviour and consistency for the plot item.
+
+        Args:
+            source(str): Source of updating device. Can be either "scan_segment" or "async".
+            x_name(str): Name of the x signal.
+                - "best_effort": Use the best effort signal.
+                - "timestamp": Use the timestamp signal.
+                - "index": Use the index signal.
+                - Custom signal name of device from BEC.
+            x_entry(str): Entry of the x signal.
+        """
+
+        readout_priority_y = self._get_device_readout_priority(y_name)
+
+        # Check if the x axis behaviour is already set
+        if self._x_axis_mode["name"] is not None:
+            # Case 1: The same x axis signal is used, check if source is compatible with the device
+            if x_name != self._x_axis_mode["name"] and x_entry != self._x_axis_mode["entry"]:
+                # A different x axis signal is used, raise an exception
+                raise ValueError(
+                    f"All curves must have the same x axis.\n"
+                    f" Current valid x axis: '{self._x_axis_mode['name']}'\n"
+                    f" Attempted to add curve with x axis: '{x_name}'\n"
+                    f"If you want to change the x-axis of the curve, please remove previous curves or change the x axis of the plot widget with '.set_x({x_name})'."
+                )
+
+        # If x_axis_mode["name"] is None, determine the mode based on x_name
+        # With async the best effort is always "index"
+        # Setting mode to either "best_effort", "timestamp", "index", or a custom one
+        if x_name is None and readout_priority_y == "async":
+            x_name = "index"
+            x_entry = "index"
+        if x_name in ["best_effort", "timestamp", "index"]:
+            self._x_axis_mode["name"] = x_name
+            self._x_axis_mode["entry"] = x_entry
+        else:
+            self._x_axis_mode["name"] = x_name
+            self._x_axis_mode["entry"] = x_entry
+            if readout_priority_y == "async":
+                raise ValueError(
+                    f"Async devices '{y_name}' cannot be used with custom x signal '{x_name}-{x_entry}'.\n"
+                    f"Please use mode 'best_effort', 'timestamp', or 'index' signal for x axis."
+                    f"You can change the x axis mode with '.set_x(mode)'"
+                )
+
+        if auto_switch is True:
+            # Switch the x axis mode accordingly
+            self._switch_x_axis_item(
+                f"{x_name}-{x_entry}"
+                if x_name not in ["best_effort", "timestamp", "index"]
+                else x_name
+            )
+
+    def _get_device_readout_priority(self, name: str):
+        """
+        Get the type of device from the entry_validator.
+
+        Args:
+            name(str): Name of the device.
+            entry(str): Entry of the device.
+
+        Returns:
+            str: Type of the device.
+        """
+        return self.READOUT_PRIORITY_HANDLER[self.dev[name].readout_priority]
+
+    def _switch_x_axis_item(self, mode: str):
+        """
+        Switch the x-axis mode between timestamp, index, the best effort and custom signal.
+
+        Args:
+            mode(str): Mode of the x-axis.
+                - "timestamp": Use the timestamp signal.
+                - "index": Use the index signal.
+                - "best_effort": Use the best effort signal.
+                - Custom signal name of device from BEC.
+        """
+        current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
+        date_axis = pg.graphicsItems.DateAxisItem.DateAxisItem(orientation="bottom")
+        default_axis = pg.AxisItem(orientation="bottom")
+        self._x_axis_mode["label_suffix"] = f" [{mode}]"
+
+        if mode == "timestamp":
+            self.plot_item.setAxisItems({"bottom": date_axis})
+            self.plot_item.setLabel("bottom", f"{current_label}{self._x_axis_mode['label_suffix']}")
+        elif mode == "index":
+            self.plot_item.setAxisItems({"bottom": default_axis})
+            self.plot_item.setLabel("bottom", f"{current_label}{self._x_axis_mode['label_suffix']}")
+        else:
+            self.plot_item.setAxisItems({"bottom": default_axis})
+            self.plot_item.setLabel("bottom", f"{current_label}{self._x_axis_mode['label_suffix']}")
+
     def _validate_signal_entries(
         self,
-        x_name: str,
-        y_name: str,
+        x_name: str | None,
+        y_name: str | None,
         z_name: str | None,
         x_entry: str | None,
         y_entry: str | None,
@@ -510,8 +816,16 @@ class BECWaveform(BECPlotBase):
             tuple[str,str,str|None]: Validated x, y, z entries.
         """
         if validate_bec:
-            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
-            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+            if x_name is None:
+                x_name = "best_effort"
+                x_entry = "best_effort"
+            if x_name:
+                if x_name == "index" or x_name == "timestamp" or x_name == "best_effort":
+                    x_entry = x_name
+                else:
+                    x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            if y_name:
+                y_entry = self.entry_validator.validate_signal(y_name, y_entry)
             if z_name:
                 z_entry = self.entry_validator.validate_signal(z_name, z_entry)
         else:
@@ -593,30 +907,57 @@ class BECWaveform(BECPlotBase):
         else:
             raise IndexError(f"Curve order {N} out of range.")
 
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg: dict, metadata: dict):
+    @pyqtSlot(dict)
+    def on_scan_status(self, msg):
         """
-        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+        Handle the scan status message.
 
         Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
+            msg(dict): Message received with scan status.
         """
+
         current_scan_id = msg.get("scan_id", None)
         if current_scan_id is None:
             return
 
         if current_scan_id != self.scan_id:
+            self.set_auto_range(True, "xy")
             self.old_scan_id = self.scan_id
             self.scan_id = current_scan_id
-            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
-                self.scan_id
-            )  # TODO do scan access through BECFigure
-            self.setup_dap(self.old_scan_id, self.scan_id)
+            self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)
+            if self._curves_data["DAP"]:
+                self.setup_dap(self.old_scan_id, self.scan_id)
+            if self._curves_data["async"]:
+                for curve_id, curve in self._curves_data["async"].items():
+                    self.setup_async(curve.config.signals.y.name)
 
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, msg: dict, metadata: dict):
+        """
+        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+        Used only for triggering scan segment update from the BECClient scan storage.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+        self.on_scan_status(msg)
         self.scan_signal_update.emit()
+        # self.autorange_timer.start(100)
+
+    def set_x_label(self, label: str, size: int = None):
+        """
+        Set the label of the x-axis.
+
+        Args:
+            label(str): Label of the x-axis.
+            size(int): Font size of the label.
+        """
+        super().set_x_label(label, size)
+        current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
+        self.plot_item.setLabel("bottom", f"{current_label}{self._x_axis_mode['label_suffix']}")
 
-    def setup_dap(self, old_scan_id, new_scan_id):
+    def setup_dap(self, old_scan_id: str | None, new_scan_id: str | None):
         """
         Setup DAP for the new scan.
 
@@ -626,21 +967,61 @@ class BECWaveform(BECPlotBase):
 
         """
         self.bec_dispatcher.disconnect_slot(
-            self.update_dap, MessageEndpoints.dap_response(old_scan_id)
+            self.update_dap, MessageEndpoints.dap_response(f"{old_scan_id}-{self.gui_id}")
         )
         if len(self._curves_data["DAP"]) > 0:
             self.bec_dispatcher.connect_slot(
-                self.update_dap, MessageEndpoints.dap_response(new_scan_id)
+                self.update_dap, MessageEndpoints.dap_response(f"{new_scan_id}-{self.gui_id}")
+            )
+
+    @pyqtSlot(str)
+    def setup_async(self, device: str):
+        self.bec_dispatcher.disconnect_slot(
+            self.on_async_readback, MessageEndpoints.device_async_readback(self.old_scan_id, device)
+        )
+        try:
+            self._curves_data["async"][f"{device}-{device}"].clear_data()
+        except KeyError:
+            pass
+        if len(self._curves_data["async"]) > 0:
+            self.bec_dispatcher.connect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_readback(self.scan_id, device),
+                from_start=True,
             )
 
+    @pyqtSlot()
     def refresh_dap(self):
         """
         Refresh the DAP curves with the latest data from the DAP model MessageEndpoints.dap_response().
         """
         for curve_id, curve in self._curves_data["DAP"].items():
-            x_name = curve.config.signals.x.name
+            if len(self._curves_data["async"]) > 0:
+                curve.remove()
+                raise ValueError(
+                    f"Cannot refresh DAP curve '{curve_id}' while async curves are present. Removing {curve_id} from display."
+                )
+            if self._x_axis_mode["name"] == "best_effort":
+                try:
+                    x_name = self.scan_item.status_message.info["scan_report_devices"][0]
+                    x_entry = self.entry_validator.validate_signal(x_name, None)
+                except AttributeError:
+                    return
+            elif curve.config.signals.x is not None:
+                x_name = curve.config.signals.x.name
+                x_entry = curve.config.signals.x.entry
+                if (
+                    x_name == "timestamp" or x_name == "index"
+                ):  # timestamp and index not supported by DAP
+                    return
+                try:  # to prevent DAP update if the x axis is not the same as the current scan
+                    current_x_names = self.scan_item.status_message.info["scan_report_devices"]
+                    if x_name not in current_x_names:
+                        return
+                except AttributeError:
+                    return
+
             y_name = curve.config.signals.y.name
-            x_entry = curve.config.signals.x.entry
             y_entry = curve.config.signals.y.entry
             model_name = curve.config.signals.dap
             model = getattr(self.dap, model_name)
@@ -654,7 +1035,7 @@ class BECWaveform(BECPlotBase):
                     "class_args": model._plugin_info["class_args"],
                     "class_kwargs": model._plugin_info["class_kwargs"],
                 },
-                metadata={"RID": self.scan_id},
+                metadata={"RID": f"{self.scan_id}-{self.gui_id}"},
             )
             self.client.connector.set_and_publish(MessageEndpoints.dap_request(), msg)
 
@@ -676,32 +1057,96 @@ class BECWaveform(BECPlotBase):
                     self.dap_params_update.emit(curve.dap_params)
                 break
 
-    def _update_scan_segment_plot(self):
-        """Update the plot with the data from the scan segment."""
-        data = self.scan_segment_data.data
-        self._update_scan_curves(data)
-
-    def _update_scan_curves(self, data: ScanData):
+    @pyqtSlot(dict, dict)
+    def on_async_readback(self, msg, metadata):
         """
-        Update the scan curves with the data from the scan segment.
+        Get async data readback.
 
         Args:
-            data(ScanData): Data from the scan segment.
+            msg(dict): Message with the async data.
+            metadata(dict): Metadata of the message.
+        """
+        instruction = metadata.get("async_update")
+        for curve_id, curve in self._curves_data["async"].items():
+            y_name = curve.config.signals.y.name
+            y_entry = curve.config.signals.y.entry
+            x_name = self._x_axis_mode["name"]
+            for device, async_data in msg["signals"].items():
+                if device == y_entry:
+                    data_plot = async_data["value"]
+                    if instruction == "extend":
+                        x_data, y_data = curve.get_data()
+                        if y_data is not None:
+                            new_data = np.hstack((y_data, data_plot))
+                        else:
+                            new_data = data_plot
+                        if x_name == "timestamp":
+                            if x_data is not None:
+                                x_data = np.hstack((x_data, async_data["timestamp"]))
+                            else:
+                                x_data = async_data["timestamp"]
+                            curve.setData(x_data, new_data)
+                        else:
+                            curve.setData(new_data)
+                    elif instruction == "replace":
+                        if x_name == "timestamp":
+                            x_data = async_data["timestamp"]
+                            curve.setData(x_data, data_plot)
+                        else:
+                            curve.setData(data_plot)
+
+    @pyqtSlot()
+    def replot_async_curve(self):
+        try:
+            data = self.scan_item.async_data
+        except AttributeError:
+            return
+        for curve_id, curve in self._curves_data["async"].items():
+            y_name = curve.config.signals.y.name
+            y_entry = curve.config.signals.y.entry
+            x_name = None
+
+            if curve.config.signals.x:
+                x_name = curve.config.signals.x.name
+
+            if x_name == "timestamp":
+                data_x = data[y_name][y_entry]["timestamp"]
+            else:
+                data_x = None
+            data_y = data[y_name][y_entry]["value"]
+
+            if data_x is None:
+                curve.setData(data_y)
+            else:
+                curve.setData(data_x, data_y)
+
+    @pyqtSlot()
+    def _update_scan_curves(self):
+        """
+        Update the scan curves with the data from the scan segment.
         """
+        try:
+            data = self.scan_item.data
+        except AttributeError:
+            return
+
         data_x = None
         data_y = None
         data_z = None
+
         for curve_id, curve in self._curves_data["scan_segment"].items():
-            x_name = curve.config.signals.x.name
-            x_entry = curve.config.signals.x.entry
+
             y_name = curve.config.signals.y.name
             y_entry = curve.config.signals.y.entry
             if curve.config.signals.z:
                 z_name = curve.config.signals.z.name
                 z_entry = curve.config.signals.z.entry
 
+            data_x = self._get_x_data(curve, y_name, y_entry)
+            if len(data) == 0:  # case if the data is empty because motor is not scanned
+                return
+
             try:
-                data_x = data[x_name][x_entry].val
                 data_y = data[y_name][y_entry].val
                 if curve.config.signals.z:
                     data_z = data[z_name][z_entry].val
@@ -714,9 +1159,107 @@ class BECWaveform(BECPlotBase):
                     curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
                 except:
                     return
+            if data_x is None:
+                curve.setData(data_y)
             else:
                 curve.setData(data_x, data_y)
 
+    def _get_x_data(self, curve: BECCurve, y_name: str, y_entry: str) -> list | np.ndarray | None:
+        """
+        Get the x data for the curve with the decision logic based on the curve configuration:
+            - If x is called 'timestamp', use the timestamp data from the scan item.
+            - If x is called 'index', use the rolling index.
+            - If x is a custom signal, use the data from the scan item.
+            - If x is not specified, use the first device from the scan report.
+
+        Args:
+            curve(BECCurve): The curve object.
+
+        Returns:
+            list|np.ndarray|None: X data for the curve.
+        """
+        x_data = None
+        if self._x_axis_mode["name"] == "timestamp":
+            timestamps = self.scan_item.data[y_name][y_entry].timestamps
+
+            x_data = timestamps
+            print(x_data)
+            return x_data
+        if self._x_axis_mode["name"] == "index":
+            x_data = None
+            return x_data
+
+        if self._x_axis_mode["name"] is None or self._x_axis_mode["name"] == "best_effort":
+            if len(self._curves_data["async"]) > 0:
+                x_data = None
+                self._x_axis_mode["label_suffix"] = f" [auto: index]"
+                current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
+                self.plot_item.setLabel(
+                    "bottom", f"{current_label}{self._x_axis_mode['label_suffix']}"
+                )
+                return x_data
+            else:
+                x_name = self.scan_item.status_message.info["scan_report_devices"][0]
+                x_entry = self.entry_validator.validate_signal(x_name, None)
+                x_data = self.scan_item.data[x_name][x_entry].val
+                self._x_axis_mode["label_suffix"] = f" [auto: {x_name}-{x_entry}]"
+                current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
+                self.plot_item.setLabel(
+                    "bottom", f"{current_label}{self._x_axis_mode['label_suffix']}"
+                )
+
+        else:
+            x_name = curve.config.signals.x.name
+            x_entry = curve.config.signals.x.entry
+            try:
+                x_data = self.scan_item.data[x_name][x_entry].val
+            except TypeError:
+                x_data = []
+        return x_data
+
+    # def _get_x_data(self, curve: BECCurve, y_name: str, y_entry: str) -> list | np.ndarray | None:
+    #     """
+    #     Get the x data for the curve with the decision logic based on the curve configuration:
+    #         - If x is called 'timestamp', use the timestamp data from the scan item.
+    #         - If x is called 'index', use the rolling index.
+    #         - If x is a custom signal, use the data from the scan item.
+    #         - If x is not specified, use the first device from the scan report.
+    #
+    #     Args:
+    #         curve(BECCurve): The curve object.
+    #
+    #     Returns:
+    #         list|np.ndarray|None: X data for the curve.
+    #     """
+    #     x_data = None
+    #     if curve.config.signals.x is not None:
+    #         if curve.config.signals.x.name == "timestamp":
+    #             timestamps = self.scan_item.data[y_name][y_entry].timestamps
+    #             x_data = self.convert_timestamps(timestamps)
+    #         elif curve.config.signals.x.name == "index":
+    #             x_data = None
+    #         else:
+    #             x_name = curve.config.signals.x.name
+    #             x_entry = curve.config.signals.x.entry
+    #             try:
+    #                 x_data = self.scan_item.data[x_name][x_entry].val
+    #             except TypeError:
+    #                 x_data = []
+    #     else:
+    #         if len(self._curves_data["async"]) > 0:
+    #             x_data = None
+    #         else:
+    #             x_name = self.scan_item.status_message.info["scan_report_devices"][0]
+    #             x_entry = self.entry_validator.validate_signal(x_name, None)
+    #             x_data = self.scan_item.data[x_name][x_entry].val
+    #             self._x_axis_mode["label_suffix"] = f" [auto: {x_name}-{x_entry}]"
+    #             current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
+    #             self.plot_item.setLabel(
+    #                 "bottom", f"{current_label}{self._x_axis_mode['label_suffix']}"
+    #             )
+    #
+    #     return x_data
+
     def _make_z_gradient(self, data_z: list | np.ndarray, colormap: str) -> list | None:
         """
         Make a gradient color for the z values.
@@ -765,8 +1308,9 @@ class BECWaveform(BECPlotBase):
             self.scan_id = scan_id
 
         self.setup_dap(self.old_scan_id, self.scan_id)
-        data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
-        self._update_scan_curves(data)
+        self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)
+        self.scan_signal_update.emit()
+        self.async_signal_update.emit()
 
     def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
         """
@@ -808,12 +1352,25 @@ class BECWaveform(BECPlotBase):
             return combined_data
         return data
 
+    def clear_all(self):
+        curves_data = self._curves_data
+        sources = list(curves_data.keys())
+        for source in sources:
+            curve_ids_to_remove = list(curves_data[source].keys())
+            for curve_id in curve_ids_to_remove:
+                self.remove_curve(curve_id)
+
     def cleanup(self):
         """Cleanup the widget connection from BECDispatcher."""
         self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
         self.bec_dispatcher.disconnect_slot(
             self.update_dap, MessageEndpoints.dap_response(self.scan_id)
         )
+        for curve_id, curve in self._curves_data["async"].items():
+            self.bec_dispatcher.disconnect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_readback(self.scan_id, curve_id),
+            )
         for curve in self.curves:
             curve.cleanup()
         super().cleanup()