Merge branch 'develop'

Author: Samuel Hoermann

pyproject.toml

@@ -10,7 +10,7 @@ packages = ["src/ADScopeControl"]
 
 [project]
 name = "PyADScopeControl"
-version = "1.1.8"
+version = "1.2.0"
 authors = [
   { name="Christoph Schmidt", email="cschmidt.fs@gmail.com" },
 ]

src/ADScopeControl/controller/BaseADScopeController.py

@@ -12,6 +12,7 @@
 from numpy import ndarray
 
 from ADScopeControl.controller.mp_AD2Capture.MPCaptDevice import MPCaptDevice
+from ADScopeControl.controller.sweepHelpers import ramp
 from ADScopeControl.model.AD2ScopeModel import AD2ScopeModel
 from ADScopeControl.model.AD2Constants import AD2Constants
 
@@ -315,6 +316,9 @@ def create_dataframe(self):
                          columns=['Amplitude']))
 
         self.set_recorded_data_time_axis()
+        self.model.capturing_information.recorded_samples_df = self.model.supervisor_information.process_capture(
+            self.model.capturing_information.recorded_samples_df
+        )
 
     def stop_capture(self):
         self.start_capture_flag.value = 0

src/ADScopeControl/controller/sweepHelpers.py

@@ -0,0 +1,56 @@
+import numpy as np
+from numpy import ndarray
+
+def ramp(
+        t: ndarray, 
+        distance: float, 
+        speed: float, 
+        acceleration: float, 
+        deceleration: float = None
+        ) -> ndarray:
+    if deceleration is None: 
+        deceleration = acceleration
+    assert acceleration > 0
+    assert deceleration > 0
+
+    distanceSign = np.sign(distance)
+    absDistance = np.abs(distance)
+
+    # Calculate distance covered during acceleration
+    timeToSpeed = speed / acceleration
+    distanceAcceleration = 0.5 * speed * timeToSpeed
+
+    # Calculate distance covered during deceleration
+    timeToBreak = speed / deceleration
+    distanceDeceleration = 0.5 * speed * timeToBreak
+
+    # Calculate distance covered during constant speed
+    distanceAtSpeed = absDistance - distanceAcceleration - distanceDeceleration
+    assert distanceAtSpeed >= 0 # TODO: if smaller than zero, sweep is incomplete and
+    # no constant speed is possible -> calculate when to switch to deceleration
+    timeAtSpeed = distanceAtSpeed / speed
+
+    # Calculate total time
+    totalTime = timeToSpeed + timeAtSpeed + timeToBreak
+
+    # conform measured time array to expected sweep duration
+    dt = t[-1] - t[0]
+    assert dt > 0
+    _t = (t - t[0]) * totalTime / dt
+
+    # Create masks
+    accMsk = _t  < timeToSpeed
+    spdMsk = (_t >= timeToSpeed) & (_t < timeToSpeed + timeAtSpeed)
+    decMsk = _t >= (timeToSpeed + timeAtSpeed)
+
+    # Query time values
+    netAccTimes = _t[accMsk]
+    netDecTimes = _t[decMsk] - timeToSpeed - timeAtSpeed
+    netAtSpeedTimes = _t[spdMsk] - timeToSpeed
+
+    # Query distance values
+    return distanceSign * np.r_[
+        netAccTimes**2 / 2 * acceleration,
+        distanceAcceleration + netAtSpeedTimes * speed,
+        distanceAcceleration + distanceAtSpeed + speed * netDecTimes - 0.5 * deceleration * netDecTimes ** 2,
+    ]

src/ADScopeControl/model/AD2ScopeModel.py

@@ -121,7 +121,7 @@ def dwf_version(self) -> str:
         return self._dwf_version
 
     @dwf_version.setter
-    def dwf_version(self, value: Array or str):
+    def dwf_version(self, value: Array | str):
         if not isinstance(value, str):
             self._dwf_version = str(value.value.decode('UTF-8'))
         else:

src/ADScopeControl/model/submodels/AD2CaptDeviceSupervisorModel.py

@@ -28,12 +28,6 @@ def __init__(self):
         self._supervisor: object = None
         self._supervisor_model: object = None
 
-        self._wl_sweep_start: float = 0.0
-        self._wl_sweep_stop: float = 0.0
-        self._velocity: float = 0.0
-        self._acceleration: float = 0.0
-        self._deceleration: float = 0.0
-
     # ==================================================================================================================
     # Connected Device Information
     # ==================================================================================================================
@@ -75,43 +69,9 @@ def supervisor_model(self, value: object):
         self._supervisor_model = value
         self.signals.supervisor_model_changed.emit()
 
-    @property
-    def sweep_start_wavelength(self) -> float:
-        return self._wl_sweep_start
-
-    @sweep_start_wavelength.setter
-    def sweep_start_wavelength(self, value: float):
-        self._wl_sweep_start = value
-
-
-    @property
-    def sweep_stop_wavelength(self) -> float:
-        return self._wl_sweep_stop
-
-    @sweep_stop_wavelength.setter
-    def sweep_stop_wavelength(self, value: float):
-        self._wl_sweep_stop = value
-
-    @property
-    def velocity(self) -> float:
-        return self._velocity
-
-    @velocity.setter
-    def velocity(self, value: float):
-        self._velocity = value
-
-    @property
-    def acceleration(self) -> float:
-        return self._acceleration
-
-    @acceleration.setter
-    def acceleration(self, value: float):
-        self._acceleration = value
-
-    @property
-    def deceleration(self) -> float:
-        return self._deceleration
-
-    @deceleration.setter
-    def deceleration(self, value: float):
-        self._deceleration = value
+    def process_capture(self, data):
+        try:
+            data = self.supervisor.process_capture(data)
+        except Exception as e:
+            self.logger.error(f"Error while processing capture by supervisor: {e}")
+        return data

src/ADScopeControl/view/AD2CaptDeviceView.py

@@ -6,7 +6,7 @@
 import pyqtgraph as pg
 from PySide6.QtCore import QTimer
 from PySide6.QtGui import QAction, QIcon, QPixmap
-from PySide6.QtWidgets import QMainWindow, QStatusBar, QMenu, QToolButton, QMessageBox
+from PySide6.QtWidgets import QMainWindow, QStatusBar, QMenu, QToolButton, QMessageBox, QFileDialog
 from WidgetCollection.Dialogs import AboutDialog
 
 from pyqtgraph.dockarea import DockArea, Dock
@@ -25,7 +25,31 @@
 # get the version of the current module, given in the pyproject.toml
 
 
+def downsample_data(data, num_points):
+    """
+    Downsample the data by selecting points at equal intervals.
 
+    Args:
+        data (list): The original data list.
+        num_points (int): The desired number of data points.
+
+    Returns:
+        list: The downsampled data list.
+    """
+    if num_points >= len(data):
+        return data
+
+    interval = len(data) // num_points
+    downsampled_data = [data[i * interval] for i in range(num_points)]
+
+    # If the length of the data is not exactly divisible by the interval,
+    # append the last point to the downsampled data.
+    if len(data) % num_points != 0:
+        downsampled_data.append(data[-1])
+
+    return downsampled_data
+
+previewDataPoints = 10000
 
 class ControlWindow(QMainWindow):
 
@@ -78,11 +102,11 @@ def __init__(self, model: AD2ScopeModel, controller: BaseADScopeController):
 
         # Timer for periodically updating the plot
         self.capture_update_timer = QTimer()
-        self.capture_update_timer.setInterval(10)
+        self.capture_update_timer.setInterval(50)
         self.capture_update_timer.timeout.connect(self._on_capture_update_plot)
 
         self.stream_update_timer = QTimer()
-        self.stream_update_timer.setInterval(40)
+        self.stream_update_timer.setInterval(50)
         self.stream_update_timer.timeout.connect(self._on_stream_update_timer_timeout)
 
         self.autostop_capture = QTimer()
@@ -112,6 +136,11 @@ def _init_menu_bar(self):
 
         self.file_menu.addSeparator()
 
+        self.act_save_data = QAction('Save Data', self)
+        self.act_save_data.triggered.connect(self.save_data)
+        self.act_save_data.setShortcut('Ctrl+S')
+        self.file_menu.addAction(self.act_save_data)
+
         self.act_view_data = QAction('View Data', self)
         self.act_view_data.triggered.connect(self.view_data)
         self.act_view_data.setShortcut('Ctrl+Alt+S')
@@ -130,6 +159,15 @@ def _init_menu_bar(self):
         self._ui.menu_file.setMenu(self.file_menu)
         self._ui.menu_file.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
 
+    def save_data(self):
+        self.controller.create_dataframe()
+
+        # Create a file dialog to save the dataframe
+        file_path, _ = QFileDialog.getSaveFileName(self, "Save Data", "", "CSV Files (*.csv)")
+        if file_path:
+            self.model.capturing_information.recorded_samples_df.to_csv(file_path)
+            self.status_bar.showMessage(f"Data saved to {file_path}")
+
     def view_data(self):
         self.controller.create_dataframe()
         pdview(self.model.capturing_information.recorded_samples_df)
@@ -146,7 +184,7 @@ def _init_UI_live_plot(self):
         self.scope_original = pg.PlotWidget(title="AD2 Acquisition")
         self.scope_original.plotItem.showGrid(x=True, y=True, alpha=1)
         d1.addWidget(self.scope_original)
-        self.scope_original.setYRange(-1.5, 1.5, padding=0)
+        #self.scope_original.setYRange(-1.5, 1.5, padding=0)
 
         self.scope_captured = pg.PlotWidget(title="Captured Data")
         self.scope_captured.plotItem.showGrid(x=True, y=True, alpha=1)
@@ -211,36 +249,17 @@ def _connect_signals(self):
         # Supervision Information
         self.model.supervisor_information.signals.supervisor_name_changed.connect(self._on_supervisor_name_changed)
         self.model.supervisor_information.signals.supervised_changed.connect(self._on_supervised_changed)
-        self.model.supervisor_information.signals.supervisor_model_changed.connect(self._on_supervised_model_changed)
-
-
 
     # ==================================================================================================================
     # Slots
     # ==================================================================================================================
-    def _on_supervisor_sweep_start_wavelength_changed(self, sweep_start_wavelength):
-        print(f"Sweep Start Wavelength: {sweep_start_wavelength}")
-
-    def _on_supervisor_sweep_end_wavelength_changed(self, sweep_end_wavelength):
-        print(f"Sweep End Wavelength: {sweep_end_wavelength}")
-
 
     def _on_supervisor_name_changed(self, supervisor_name):
         self.supervisor_info.supervisor_name = supervisor_name
 
     def _on_supervised_changed(self, supervised):
         self.supervisor_info.supervised = supervised
 
-    def _on_supervised_model_changed(self):
-       self.model.supervisor_information.supervisor_model.signals.sweep_start_wavelength_changed.connect(
-           self._on_supervisor_sweep_start_wavelength_changed
-       )
-
-       self.model.supervisor_information.supervisor_model.signals.sweep_stop_wavelength_changed.connect(
-           self._on_supervisor_sweep_end_wavelength_changed
-
-       )
-
     def _on_dwf_version_changed(self, dwf_version):
         """
             Gets called if the DWF version changes. Updates the UI.
@@ -432,9 +451,16 @@ def _on_capture_update_plot(self):
         if len(self.model.capturing_information.recorded_samples) > 0:
             self.scope_captured.clear()
             # print(self.ad2device.recorded_samples)
-            d = self.model.capturing_information.recorded_samples_preview
 
-            self.scope_captured.plot(d, pen=pg.mkPen(width=1))
+            # Downsample the data
+            downsampled_data = downsample_data(
+                self.model.capturing_information.recorded_samples, 
+                previewDataPoints
+            )
+
+            # Plot the downsampled data
+            self.scope_captured.plot(downsampled_data, pen=pg.mkPen(width=1))
+
             # print(f"Length: {len(self.controller.recorded_sample_stream)}")
 
         #if len(self.controller.status_dqueue) > 0:
@@ -449,8 +475,12 @@ def _on_stream_update_timer_timeout(self):
         # print(self.ad2device.recorded_samples)
 
         self.scope_original.plot(
-            np.array(self.controller.streaming_dqueue),  # [::100],
-            pen=pg.mkPen(width=1))
+            downsample_data(
+                np.array(self.controller.streaming_dqueue),
+                previewDataPoints
+            ),
+            pen=pg.mkPen(width=1)
+        )
         # self._ui.lcd_unconsumed_stream.display(self.model.capturing_information.unconsumed_stream_samples)
 
     # ============== Connected Device Information