Add relocking

CHANGELOG.md

@@ -7,17 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+* Added loss of lock detection and automatic relocking by @bleykauf in https://github.com/linien-org/linien/pull/403
+
 ### Changed
 * Color settings are now named by @bleykauf in https://github.com/linien-org/linien/pull/426
+* Replaced parameters `autolock_running`, `autolock_failed`, `autolock_locked`, `autolock_retrying` with `autolock_status`
+
+### Deprecated
+* Unused parameters `autolock_initial_sweep_amplitude`, `autolock_watching`, `autolock_preparing` were removed.
+* Removed parameters `autolock_selection` and `optimization_selection` that were only used by the GUI.
+* Deprecated `exposed_start_lock`, use `exposed_start_manual_lock` instead.
+* Deprecated parameter `automatic_mode`, use `autolock_mode_preference` instead.
 
 ### Fixed
 * Corrected scripting examples by @kongmunist in https://github.com/linien-org/linien/pull/428
 
+## [2.1.0] - 2024-08-15
+
+
 ## [2.1.0]
 
 ### Added
 * Show differences when local and remote parameters do not match by @bleykauf in https://github.com/linien-org/linien/pull/400
 * Show voltage on the x-axis when sweeping by @bleykauf in https://github.com/linien-org/linien/pull/404
+* Added loss-of-lock detection and automatic relocking by @bleykauf in https://github.com/linien-org/linien/pull/403
 
 ### Changed
 * Switched to Tableau color scheme and make colors consistent, i.e. signals have the same color while sweeping and when locked. By @bleykauf in https://github.com/linien-org/linien/pull/419.
@@ -177,9 +191,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 * The parameters that deal with the sweep / ramp have been renamed:
-    * "center" is now "sweep_center"
-    * "ramp_amplitude", "ramp_speed" and * * "autolock_initial_ramp_amplitude" are now "sweep_amplitude" and * "sweep_speed" and "autolock_initial_sweep_amplitude", respectively
-        There is a new boolean parameter "sweep_pause".
+    * `center` is now `sweep_center`
+    * `ramp_amplitude`, `ramp_speed` and `autolock_initial_ramp_amplitude` are now `sweep_amplitude` and `sweep_speed` and `autolock_initial_sweep_amplitude`, respectively
+    * There is a new boolean parameter `sweep_pause`.
 
 
 ## [0.4.3] - 2021-06-22

README.md

@@ -23,8 +23,8 @@ Features
     automatically lock to it. This algorithm is built to be noise and jitter tolerant.
 -   **IQ demodulation**: Optimize demodulation phase in an instant
 -   **Noise analysis**: Record power spectral density (PSD) of the error signal for analyzing noise of the locked laser and for optimizing PID parameters
--   **Lock detection**: Linien is capable of detecting loss of lock (temporarily disabled, use [v0.3.2](https://github.com/linien-org/linien/releases/tag/v0.3.2) if you rely in this feature
--   **Automatic relocking**: if lock is lost, it relocks autonomously (temporarily disabled, use [v0.3.2](https://github.com/linien-org/linien/releases/tag/v0.3.2) if you rely in this feature)
+-   **Lock detection**: Linien is capable of detecting loss of lock
+-   **Automatic relocking**: if lock is lost, it relocks autonomously
 -   **Machine learning** is used to tune the spectroscopy parameters in order to optimize the signal
 -   **Remote-controllable**: the client libraries can be used to control or monitor the spectroscopy lock with Python.
 -   **Combined FMS+MTS**: Linien supports dual-channel spectroscopy that can be
@@ -256,7 +256,7 @@ print(c.parameters.modulation_frequency.value / MHz)
 c.parameters.modulation_amplitude.value = 1 * Vpp
 # in the line above, we set a parameter. This is not written directly to the
 # FPGA, though. In order to do this, we have to call write_registers():
-c.connection.root.write_registers()
+c.connection.root.exposed_write_registers()
 
 # additionally set ANALOG_OUT_1 to 1.2 volts DC (you can use this to control other devices of your experiment)
 c.parameters.analog_out_1.value = 1.2 / ANALOG_OUT_V
@@ -272,7 +272,7 @@ c.parameters.gpio_n_out.value = 0b11110000 # 4 on, 4 off
 c.parameters.gpio_p_out.value = 0b01010101 # 4 on, 4 off
 
 # again, we have to call write_registers in order to write the data to the FPGA
-c.connection.root.write_registers()
+c.connection.root.exposed_write_registers()
 
 # it is also possible to set up a callback function that is called whenever a
 # parameter changes (remember to call `check_for_changed_parameters()` periodically)
@@ -317,7 +317,7 @@ plt.show()
 
 For a full list of parameters that can be controlled or accessed have a
 look at
-[parameters.py](https://github.com/linien-org/linien/blob/master/linien-server/linien_server/parameters.py). Remember that changed parameters are not written to the FPGA unless `c.connection.root.write_registers()` is called.
+[parameters.py](https://github.com/linien-org/linien/blob/master/linien-server/linien_server/parameters.py). Remember that changed parameters are not written to the FPGA unless `c.connection.root.exposed_write_registers()` is called.
 
 ### Run the autolock
 
@@ -329,7 +329,7 @@ import numpy as np
 
 from linien_client.connection import LinienClient
 from linien_client.device import Device
-from linien_common.common import AutolockMode
+from linien_common.enums import AutolockMode
 
 from matplotlib import pyplot as plt
 from time import sleep
@@ -499,8 +499,13 @@ Copyright © 2014-2015 Robert Jördens\
 Copyright © 2018-2022 Benjamin Wiegand\
 Copyright © 2021-2024 Bastian Leykauf\
 Copyright © 2022 Christian Freier\
+<<<<<<< HEAD
+Copyright © 2023-2024 Doron Behar
+
+=======
 Copyright © 2023-2024 Doron Behar\
 Copyright © 2024 Andy Kong
+>>>>>>> develop
 
 Linien is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
 

gateware/linien_module.py

@@ -15,7 +15,7 @@
 # You should have received a copy of the GNU General Public License
 # along with Linien.  If not, see <http://www.gnu.org/licenses/>.
 
-from linien_common.common import OutputChannel
+from linien_common.enums import OutputChannel
 from migen import (
     Array,
     Cat,
@@ -38,6 +38,7 @@
 from .logic.limit import LimitCSR
 from .logic.modulate import Modulate
 from .logic.pid import PID
+from .logic.relocking import RelockWatcher
 from .logic.sweep import SweepCSR
 from .lowlevel.analog import PitayaAnalog
 from .lowlevel.crg import CRG
@@ -90,6 +91,7 @@ def init_submodules(self, width, signal_width):
         self.submodules.limit_fast2 = LimitCSR(width=width, guard=5)
         self.submodules.pid = PID(width=signal_width)
         self.submodules.autolock = FPGAAutolock(width=width, max_delay=8191)
+        self.submodules.relock_watcher = RelockWatcher(width=width)
 
     def connect_pid(self):
         # pid is not started directly by `request_lock` signal. Instead, `request_lock`
@@ -163,6 +165,7 @@ def __init__(self, platform):
             width, signal_width, coeff_width, chain_factor_bits, platform
         )
         self.connect_everything(width, signal_width, coeff_width, chain_factor_bits)
+        self.connect_relock_watcher()
 
     def init_submodules(
         self, width, signal_width, coeff_width, chain_factor_bits, platform
@@ -411,6 +414,16 @@ def connect_everything(self, width, signal_width, coeff_width, chain_factor_bits
             self.logic.limit_fast2.x.eq(fast_outs[1]),
         ]
 
+    def connect_relock_watcher(self):
+        self.comb += [
+            self.logic.relock_watcher.locked.eq(
+                self.logic.autolock.lock_running.status
+            ),
+            self.logic.relock_watcher.error_signal.eq(self.logic.pid.input),
+            self.logic.relock_watcher.monitor_signal.eq(self.fast_b.adc),
+            self.logic.relock_watcher.control_signal.eq(self.logic.pid.pid_out),
+        ]
+
 
 class DummyID(Module, AutoCSR):
     def __init__(self):

gateware/logic/autolock.py

@@ -15,7 +15,8 @@
 # You should have received a copy of the GNU General Public License
 # along with Linien.  If not, see <http://www.gnu.org/licenses/>.
 
-from linien_common.common import AUTOLOCK_MAX_N_INSTRUCTIONS, AutolockMode
+from linien_common.common import AUTOLOCK_MAX_N_INSTRUCTIONS
+from linien_common.enums import AutolockMode
 from migen import Array, If, Module, Signal, bits_for
 from misoc.interconnect.csr import AutoCSR, CSRStatus, CSRStorage
 
@@ -70,7 +71,7 @@ def __init__(self, width=14, N_points=16383, max_delay=16383):
 
 class SimpleAutolock(Module, AutoCSR):
     """
-    The operation of fast autolock is simple: wait until the sweep has reached a certain
+    The operation of this autolock is simple: wait until the sweep has reached a certain
     point and turn on the lock. This method is well suited for systems with not too much
     jitter.
     """
@@ -118,8 +119,8 @@ def __init__(self, width=14, N_points=16383, max_delay=16383):
         peak_height_bit, x_data_length_bit = self.init_csr(N_points)
         self.init_inout_signals(width)
 
-        # is the autolock actively trying to detect peaks? This is set to true
-        # if lock is requested and once the sweep is at start
+        # Is the autolock actively trying to detect peaks? This is set to true if lock
+        # is requested and once the sweep is at start.
         watching = Signal()
 
         # the following signals are property of the peak that the autolock is trying to

gateware/logic/relocking.py

@@ -0,0 +1,84 @@
+# This file is part of Linien and based on redpid.
+#
+# Copyright (C) 2016-2024 Linien Authors (https://github.com/linien-org/linien#license)
+
+#
+# Linien is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Linien is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Linien.  If not, see <http://www.gnu.org/licenses/>.
+
+from migen import If, Module, Signal
+from misoc.interconnect.csr import AutoCSR, CSRStatus, CSRStorage
+
+
+class RelockWatcher(Module, AutoCSR):
+    def __init__(self, width=14, coeff_width=14):
+        self.locked = Signal()
+        self.should_watch = Signal()
+
+        self.error_signal = Signal((width, True))
+        self.control_signal = Signal((width, True))
+        self.monitor_signal = Signal((width, True))
+
+        self.lock_lost = CSRStatus()
+
+        channels = (
+            ("control", self.control_signal),
+            ("error", self.error_signal),
+            ("monitor", self.monitor_signal),
+        )
+        lock_lost_signal = Signal()
+        for channel_name, channel in channels:
+            channel_watcher = RelockWatcherChannel(width)
+            setattr(self.submodules, channel_name, channel_watcher)
+            should_watch_name = "should_watch_" + channel_name
+            should_watch_csr = CSRStorage(width, name=should_watch_name)
+            setattr(self, should_watch_name, should_watch_csr)
+            min_name = "min_" + channel_name
+            min_csr = CSRStorage(width, name=min_name)
+            setattr(self, min_name, min_csr)
+            max_name = "max_" + channel_name
+            max_csr = CSRStorage(width, name=max_name)
+            setattr(self, max_name, max_csr)
+
+            self.comb += [
+                channel_watcher.input.eq(channel),
+                channel_watcher.locked.eq(self.locked),
+                channel_watcher.should_watch.eq(should_watch_csr.storage),
+                channel_watcher.min.eq(min_csr.storage),
+                channel_watcher.max.eq(max_csr.storage),
+            ]
+
+            lock_lost_signal |= channel_watcher.lock_lost
+
+        self.comb += [self.lock_lost.status.eq(lock_lost_signal)]
+
+
+class RelockWatcherChannel(Module):
+    def __init__(self, width):
+        self.locked = Signal()
+        self.lock_lost = Signal()
+
+        self.should_watch = Signal()
+        self.min = Signal((width, True))
+        self.max = Signal((width, True))
+        self.input = Signal((width, True))
+
+        self.sync += [
+            If(
+                self.locked & self.should_watch,
+                If(
+                    (self.input > self.max) | (self.input < self.min),
+                    self.lock_lost.eq(1),
+                ),
+            ).Else(self.lock_lost.eq(0))
+        ]

linien-client/linien_client/__init__.py

@@ -17,25 +17,7 @@
 
 import importlib.metadata
 import logging
-from logging.handlers import RotatingFileHandler
-
-from linien_common.config import LOG_FILE_PATH
 
 __version__ = importlib.metadata.version("linien-client")  # noqa: F401
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-file_handler = RotatingFileHandler(str(LOG_FILE_PATH), maxBytes=1000000, backupCount=10)
-file_handler.setLevel(logging.DEBUG)
-file_formatter = logging.Formatter(
-    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-file_handler.setFormatter(file_formatter)
-logger.addHandler(file_handler)
-
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.DEBUG)
-console_formatter = logging.Formatter("%(name)-30s %(levelname)-8s %(message)s")
-console_handler.setFormatter(console_formatter)
-logger.addHandler(console_handler)

linien-client/linien_client/connection.py

@@ -36,7 +36,6 @@
 from .remote_parameters import RemoteParameters
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
 
 class ServiceWithAuth(rpyc.Service):

linien-client/linien_client/deploy.py

@@ -30,7 +30,6 @@
 from .device import Device
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
 
 def read_remote_version(
@@ -50,7 +49,7 @@ def read_remote_version(
         connect_kwargs={"password": device.password},
     ) as conn:
         result = conn.run(
-            'python3 -c "import linien_server; print(linien_server.__version__);"',
+            'python3 -c "import linien_server;"',
             out_stream=out_stream,
             err_stream=out_stream,
             warn=True,

linien-client/linien_client/device.py

@@ -26,7 +26,6 @@
 from linien_common.config import SERVER_PORT, USER_DATA_PATH
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
 
 def generate_random_key():

linien-client/linien_client/remote_parameters.py

@@ -66,13 +66,13 @@ def add_callback(self, callback: Callable, call_immediately: bool = False):
         Register a callback function that is called whenever the parameter changes.
         """
 
-        if self.name not in self.parent._callbacks and not self.use_cache:
+        if self.name not in self.parent.callbacks and not self.use_cache:
             # Make sure that the server knows that we want to be notified about changes.
             # Parameters that use the cache are already registered, see `__init__`.
             self.parent._listeners_pending_remote_registration.append(self.name)
 
-        self.parent._callbacks.setdefault(self.name, [])
-        self.parent._callbacks[self.name].append(callback)
+        self.parent.callbacks.setdefault(self.name, [])
+        self.parent.callbacks[self.name].append(callback)
 
         if call_immediately:
             callback(self.value)
@@ -106,7 +106,7 @@ def __init__(self, remote: LinienControlService, uuid: str, use_cache: bool):
         self._async_listener_registering: Union[AsyncResult, None] = None
 
         self._listeners_pending_remote_registration: List[str] = []
-        self._callbacks: Dict[str, List[Callable]] = {}
+        self.callbacks: Dict[str, List[Callable]] = {}
 
         # mimic functionality of `parameters.Parameters`:
         all_parameters = self.remote.exposed_init_parameter_sync(self.uuid)
@@ -201,8 +201,8 @@ def check_for_changed_parameters(self) -> None:
 
             # Iterate over all changed parameters and call their callback functions.
             for param_name, value in queue:
-                if param_name in self._callbacks:
-                    for callback in self._callbacks[param_name]:
+                if param_name in self.callbacks:
+                    for callback in self.callbacks[param_name]:
                         callback(value)
 
         if (

linien-common/linien_common/__init__.py

@@ -1,25 +1,7 @@
 import logging
-from logging.handlers import RotatingFileHandler
 
 import importlib_metadata
 
-from .config import LOG_FILE_PATH
-
 __version__ = importlib_metadata.version("linien-common")  # noqa: F401
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-file_handler = RotatingFileHandler(str(LOG_FILE_PATH), maxBytes=1000000, backupCount=10)
-file_handler.setLevel(logging.DEBUG)
-file_formatter = logging.Formatter(
-    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-file_handler.setFormatter(file_formatter)
-logger.addHandler(file_handler)
-
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.DEBUG)
-console_formatter = logging.Formatter("%(name)-30s %(levelname)-8s %(message)s")
-console_handler.setFormatter(console_formatter)
-logger.addHandler(console_handler)