add draft for thermostat usage guide

Cargo.lock

@@ -92,26 +92,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
-[[package]]
-name = "const_format"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
-dependencies = [
- "const_format_proc_macros",
-]
-
-[[package]]
-name = "const_format_proc_macros"
-version = "0.2.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
 [[package]]
 name = "cortex-m"
 version = "0.7.7"
@@ -471,7 +451,6 @@ dependencies = [
  "bare-metal 1.0.0",
  "bit_field",
  "byteorder",
- "const_format",
  "cortex-m",
  "cortex-m-log",
  "cortex-m-rt",
@@ -1062,12 +1041,6 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
-[[package]]
-name = "unicode-xid"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
-
 [[package]]
 name = "uom"
 version = "0.30.0"

Cargo.toml

@@ -38,7 +38,6 @@ sfkv = "0.1"
 bit_field = "0.10"
 crc = "3.0.1"
 byteorder = { version = "1", default-features = false }
-const_format = "0.2.34"
 [features]
 semihosting = ["cortex-m-log/semihosting"]
 RTT = []

README.md

@@ -70,10 +70,16 @@ openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program target/thumbv
 ```
 
 ## Erasing Flash Settings
-The flash settings are stored in the last flash sector(ID: 11) of bank 0 of stm32f405. You can erase it with JTAG/SWD adapter. You may find it useful if you have set network settings incorrectly.
+The flash settings are stored in the last flash sector(ID: 11) of bank 0 of stm32f405. You can erase it with JTAG/SWD adapter or by putting the device in Dfu mode. You may find it useful if you have set network settings incorrectly.
 
 With JTAG/SWD adapter connected, issue the following command:
 
 ```shell
 openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "flash init; init; halt; flash erase_sector 0 11 last; reset; exit"
 ```
+
+With STM32 in DFU Mode, connect the USB Type C cable and then issue the following command:
+
+```
+dfu-util -a 0 -s 0x080E0000:leave -D erase_flash_settings.bin
+```

build.rs

@@ -1,4 +1,4 @@
-use std::{env, fs::File, io::Write, path::PathBuf, process::Command};
+use std::{env, fs::File, io::Write, path::PathBuf};
 
 fn main() {
     // Put the linker script somewhere the linker can find it
@@ -12,34 +12,4 @@ fn main() {
     // Only re-run the build script when memory.x is changed,
     // instead of when any part of the source code changes.
     println!("cargo:rerun-if-changed=memory.x");
-
-    let revision = env::var("BUILD_REVISION");
-    match revision {
-        Ok(r) => {
-            // Skip if the environment variable is already set
-            println!("cargo:rustc-env=BUILD_REVISION={}", r);
-        }
-        Err(_) => {
-            let output = Command::new("git")
-                .args(&["rev-parse", "--short=7", "HEAD"])
-                .output()
-                .expect("Failed to execute git command");
-            
-            let dirty = !Command::new("git")
-                .args(&["status", "-s"])
-                .output()
-                .expect("Failed to execute git command").stdout.is_empty();
-            
-            let build_revision: String;
-            if dirty {
-                build_revision = String::from_utf8(output.stdout)
-                    .expect("Invalid UTF-8 sequence") + "-dirty";
-            } else {
-                build_revision = String::from_utf8(output.stdout)
-                    .expect("Invalid UTF-8 sequence");
-            }
-            
-            println!("cargo:rustc-env=BUILD_REVISION={}", build_revision.trim());
-        }
-    };
 }

docs/thermostat.md

@@ -0,0 +1,56 @@
+# Thermostat
+Kirdy incorporates a single channel thermostat circuitry like Sinara-hw [Thermostat](https://github.com/sinara-hw/Thermostat) with improved noise. It can deliver more than 9W of cooling/heating power with better than +-1mK temperature stability.
+
+## Power Input
+If you use Kirdy with a PoE (IEEE 802.3af Class 3) PSE, Kirdy may experience power failure due to power limit. If you need more power on Thermostat, you can plug in additional Power supply on the 12V power Jack(Recommend: 12V 2A). Although the TEC Driver has a very high 165 degree thermal shutdown threshold, it is highly recommended to provide active cooling to the TEC Driving Circuitry.
+
+## Control Mode
+Like Sinara-hw [Thermostat](https://github.com/sinara-hw/Thermostat), they both share the same control mode and algorithm, namely constant  Current Control Mode
+
+### Constant Current Control Mode
+You can drive a constant current to the load. The end user to connect an external control loop. If end user wants to use it with an external control loop, it is recommended to retrieve reports via the ActiveReportMode instead of polling status report for better consistency and higher maximum update rate.
+
+### PID Control Mode
+Thermostat uses the [PID algorithm](https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw) derived by Quartiq. The included Pid Autotune Algorithm can already achieve the specified +-1mK stability.
+
+During autotuning, Theremstat drives a user-specified step current into the load to calculate the pid parameters. Improper usage can damage the connected device.
+
+#### Important Notes
+1. Configure all the protection mechanisms correctly before running the pid autotune algorithm. 
+2. Supervise the PID autotune process.
+3. PID Autotune algorithm sometimes can produce unstable PID parameters. Do evaluate the PID performance after autotune is completed
+4. For best performance, you should do the autotune with Kirdy installed in the environment that it is gonna be used.
+5. If you are using the GUI, you need to set a high enough polling rate for PID autotune to function correctly. 
+
+#### Usage Guide
+
+You can run pid autotune via the standalone auto
+
+1. Target Temperature
+- Set it to the intended operating temperature for the connected device to operate in. You can still change temperature setpoint afterwards.
+2. Test Current
+- Set it to the maximum recommended operating current specified on the TEC/Resistive load.
+3. Update Rate
+- This can be set by configuring the filter settings in the Temperature ADC. High Update Rate can yield faster loop response with temperature regulation noise as the trade-off. Higher update rate can be useful if the load is actively cooled.
+4. Temperature Swing
+- Lower value can damp the control loop response.
+5. Lookback Period
+- Larger value can damp the control loop response. Do note that the larger lookback period also increases the autotune completion time.
+
+You can give your system a try with the following parameters.
+1. Target Temperature: (User-Specified)
+2. Test Current: (User-Specified)
+3. Update Rate: 16.67Hz (Sinc5Sinc1 Filter with 50Hz and 60Hz Rejection)
+4. Temperature Swing: 0 Degree
+5. Lookback Period: 5s
+
+Once autotune is successful, you can improve its stability by increasing the lookback period.
+
+#### Troubleshooting
+If you obtain unstable PID parameters, 
+1. Check if the polling rate is close to the PID update rate. If not, increase the polling rate
+2. Increase the lookback period and try again.
+
+If the autotune does not finish running or faikls, you should 
+1. Check if the thermostat has a hard time heating or cooling the connected device to the targe temperature. If yes, you should consider adjust the target temperature accordingly.
+2. Check if the polling rate is close to the PID update rate. If not, increase the polling rate.

flake.nix

@@ -39,7 +39,6 @@
         nativeBuildInputs = [ pkgs.llvm ];
 
         buildPhase = ''
-          export BUILD_REVISION=${toString (self.shortRev or self.dirtyShortRev or "unknown")}
           cargo build --release --bin kirdy
         '';
 
@@ -57,13 +56,12 @@
 
       pglive = pkgs.python3Packages.buildPythonPackage rec {
         pname = "pglive";
-        version = "0.8.0";
+        version = "0.7.2";
         format = "pyproject";
         src = pkgs.fetchPypi {
           inherit pname version;
-          hash = "sha256-2aECN/3zlsYRv7Ja8OlrnqlqqSCvJ08S2TaMYoMPst8=";
+          hash = "sha256-jqj8X6H1N5mJQ4OrY5ANqRB0YJByqg/bNneEALWmH1A=";
         };
-        patches = ./patches/pg_live_range_width.patch;
         buildInputs = [ pkgs.python3Packages.poetry-core ];
         propagatedBuildInputs = with pkgs.python3Packages; [ pyqtgraph numpy ];
       };

patches/pg_live_range_width.patch

@@ -1,89 +0,0 @@
-diff --git a/pglive/sources/live_axis_range.py b/pglive/sources/live_axis_range.py
-index cd3a7fc..276c7b6 100755
---- a/pglive/sources/live_axis_range.py
-+++ b/pglive/sources/live_axis_range.py
-@@ -13,6 +13,10 @@ class LiveAxisRange:
-         offset_top: float = 0.0,
-         offset_bottom: float = 0.0,
-         fixed_range: Optional[List[float]] = None,
-+        x_range_width: Optional[float] = None,
-+        x_bound: Optional[List[float]] = None,
-+        y_range_width: Optional[float] = None,
-+        y_bound: Optional[List[float]] = None,
-     ) -> None:
-         self.roll_on_tick = roll_on_tick
-         self.offset_left = offset_left
-@@ -24,6 +28,10 @@ class LiveAxisRange:
-         self.crop_top_offset_to_data = False
-         self.crop_bottom_offset_to_data = False
-         self.fixed_range = fixed_range
-+        self.x_range_width = x_range_width
-+        self.x_bound = x_bound
-+        self.y_range_width = y_range_width
-+        self.y_bound = y_bound
-         self.x_range: Dict[str, List[float]] = {}
-         self.y_range: Dict[str, List[float]] = {}
-         self.final_x_range = [0.0, 0.0]
-@@ -65,11 +73,12 @@ class LiveAxisRange:
-                 final_range[0] = x_range[0]
-             if final_range[1] < x_range[1]:
-                 final_range[1] = x_range[1]
--        if final_range[0] == final_range[1]:
-+        if final_range[0] == final_range[1] and self.x_range_width is not None:
-             # Pyqtgraph ViewBox.setRange doesn't like same value for min and max,
-             # therefore in that case we must set some range
-             final_range[0] -= 0.4
-             final_range[1] += 0.4
-+        final_range = self._update_range_width(self.x_bound, self.x_range_width, final_range)
-         if self.final_x_range != final_range:
-             self.final_x_range = final_range
-         return self.final_x_range
-@@ -88,7 +97,7 @@ class LiveAxisRange:
-                 final_range[1] = x_range[1]
-         if final_range is None:
-             final_range = [0, 0]
--        if final_range[0] == final_range[1]:
-+        if final_range[0] == final_range[1] and self.x_range_width is None:
-             # Pyqtgraph ViewBox.setRange doesn't like same value for min and max,
-             # therefore in that case we must set some range
-             final_range[0] -= 0.4
-@@ -132,11 +141,13 @@ class LiveAxisRange:
-                 final_range[0] = y_range[0]
-             if final_range[1] < y_range[1]:
-                 final_range[1] = y_range[1]
--        if final_range[0] == final_range[1]:
-+        
-+        if final_range[0] == final_range[1] and self.y_range_width is None:
-             # Pyqtgraph ViewBox.setRange doesn't like same value for min and max,
-             # therefore in that case we must set some range
-             final_range[0] -= 0.4
-             final_range[1] += 0.4
-+        final_range = self._update_range_width(self.y_bound, self.y_range_width, final_range)
-         if self.final_y_range != final_range:
-             self.final_y_range = final_range
-         return self.final_y_range
-@@ -199,6 +210,24 @@ class LiveAxisRange:
-         else:
-             return None
- 
-+    def _update_range_width(self, bound, range_width, final_range):
-+        if range_width is not None:
-+            if abs(final_range[0] - final_range[1]) < range_width:
-+                center_pt = (final_range[0] + final_range[1]) / 2
-+                final_range[0] = center_pt - range_width / 2
-+                final_range[1] = center_pt + range_width / 2
-+
-+        if bound is not None:
-+            final_range_width = abs(final_range[0] - final_range[1])
-+            bound_width = abs(bound[0] - bound[1])
-+            if bound_width < final_range_width:
-+                final_range = bound
-+            if final_range[0] <= bound[0]:
-+                final_range = [bound[0], bound[0] + final_range_width]
-+            elif final_range[1] >= bound[1]:
-+                final_range = [bound[0] - final_range_width, bound[1]]
-+        return final_range
-+
-     def ignore_connector(self, data_connector, flag: bool) -> None:
-         if not flag:
-             self.ignored_data_connectors.append(data_connector.__hash__())

pykirdy/asyncio_exmaple.py

@@ -11,6 +11,14 @@ async def enter_dfu_mode(kirdy: Kirdy):
     """
     await kirdy.device.dfu()
 
+async def active_report(kirdy: Kirdy):
+    """
+        Configure Kirdy to actively report status to connected socket
+        Press Ctrl + C to exit active report mode
+    """
+    async for data in kirdy.report_mode():
+        pp(data)
+
 async def device_cfg(kirdy: Kirdy):
     """
         Configure Kirdy's network and board specific transconductance settings.
@@ -24,7 +32,7 @@ async def device_cfg(kirdy: Kirdy):
     # Network Settings will be updated on next reboot.
     await kirdy.device.set_ip_settings(
         addr="192.168.1.128",
-        port=1550,
+        port=1337,
         prefix_len=24,
         gateway="192.168.1.1"
     )
@@ -115,10 +123,11 @@ async def ld_thermostat_cfg(kirdy: Kirdy):
 
 async def main():
     kirdy = Kirdy()
-    kirdy.start_session(host='192.168.1.134', port=1550)
+    kirdy.start_session(host='192.168.1.128', port=1337)
     await kirdy.wait_until_connected()
 
     await ld_thermostat_cfg(kirdy)
+    # await active_report(kirdy)
     # await device_cfg(kirdy)
     # await enter_dfu_mode(kirdy)
 

pykirdy/driver/kirdy.py

@@ -20,16 +20,13 @@ class State(StrEnum):
     connected = "connected"
 
 class CmdList:
-    class tec_set_i(StrEnum, settings=NoAlias):
-        _target = "tec_set_i"
-        tec_set_i = _dt.f32
     class device(StrEnum, settings=NoAlias):
         _target = "device_cmd"
         SetIPSettings = _dt.ip_settings
         SetPdFinGain = _dt.f32
         SetPdTransconductance = _dt.f32
+        SetActiveReportMode = _dt.bool
         GetHwRev = _dt.none
-        GetFirmwareRev = _dt.none
         GetStatusReport = _dt.none
         GetSettingsSummary = _dt.none
         Dfu = _dt.none
@@ -80,7 +77,7 @@ class CmdList:
 class FilterConfig:
     class Sinc5Sinc1With50hz60HzRejection(StrEnum):
         f27sps = "F27SPS"
-        f25sps = "F25SPS"
+        f21sps = "F21SPS"
         f20sps = "F20SPS"
         f16sps = "F16SPS"
         _odr_type = "sinc5sinc1postfilter"
@@ -172,15 +169,19 @@ class FilterConfig:
         def _filter_type(self):
             return "Sinc3WithFineODR"
 
-class KirdyCmdError(Exception):
+class InvalidDataType(Exception):
+    pass
+
+class InvalidCmd(Exception):
     pass
 
 class Device:
-    def __init__(self, send_cmd_handler):
+    def __init__(self, send_cmd_handler, send_raw_cmd_handler):
         self._cmd = CmdList.device
         self._send_cmd = send_cmd_handler
+        self._send_raw_cmd = send_raw_cmd_handler
 
-    async def set_ip_settings(self, addr="192.168.1.128", port=1550, prefix_len=24, gateway="192.168.1.1"):
+    async def set_ip_settings(self, addr="192.168.1.128", port=1337, prefix_len=24, gateway="192.168.1.1"):
         """
             Upon command execution, the ip settings are saved into flash and are effective upon next reboot.
         """
@@ -196,17 +197,25 @@ class Device:
         if not(isinstance(port, int) and isinstance(prefix_len, int)):
             raise InvalidDataType
         
-        return await self._send_cmd(
-            self._cmd._target,
-            self._cmd.SetIPSettings,
+        return await self._send_raw_cmd(
             {
-                "addr": [int(x) for x in addr],
-                "port": port,
-                "prefix_len": prefix_len,
-                "gateway": [int(x) for x in gateway],
+                "device_cmd": "SetIPSettings",
+                "ip_settings": {
+                    "addr": [int(x) for x in addr],
+                    "port": port,
+                    "prefix_len": prefix_len,
+                    "gateway": [int(x) for x in gateway],
+                }
             }
         )
 
+    async def set_active_report_mode(self, on):
+        """
+            Set active report to be on. If it is on, Kirdy will send status report
+            to the client socket according to the temperature polling rate set.
+        """
+        return await self._send_cmd(self._cmd._target, self._cmd.SetActiveReportMode, on)
+
     async def set_pd_mon_fin_gain(self, gain):
         """
             Configure the photodiode monitor final analog front-end stage gain.
@@ -235,24 +244,6 @@ class Device:
         """
         return await self._send_cmd(self._cmd._target, self._cmd.GetHwRev, msg_type="HwRev")
 
-    async def get_firmware_rev(self):
-        """
-            Get firmware revision of the connected Kirdy.
-
-            If the firmware was built from a dirty repo:
-            {
-                'msg_type': 'FirmwareRev', 
-                'firmware_rev': "c8e9826-dirty"
-            }
-
-            If the firmware was built from a clean repo:
-            {
-                'msg_type': 'FirmwareRev', 
-                'firmware_rev': "c8e9826"
-            }
-        """
-        return await self._send_cmd(self._cmd._target, self._cmd.GetFirmwareRev, msg_type="FirmwareRev")
-
     async def get_status_report(self, sig=None):
         """
             Get status of all peripherals in a json object.
@@ -471,10 +462,10 @@ class Laser:
         return await self._send_cmd(self._cmd._target, self._cmd.ClearAlarm)
 
 class Thermostat:
-    def __init__(self, send_cmd_handler):
+    def __init__(self, send_cmd_handler, send_raw_cmd_handler):
         self._cmd = CmdList.thermostat
-        self.tec_set_i_cmd = CmdList.tec_set_i
         self._send_cmd = send_cmd_handler
+        self._send_raw_cmd = send_raw_cmd_handler
 
     async def set_power_on(self, on):
         """
@@ -516,12 +507,17 @@ class Thermostat:
 
     async def set_tec_i_out(self, i_out):
         """
-            Set Tec Output Current (Settable Range: -3.0 - 3.0)
+            Set Tec Output Current (Settable Range: 0.0 - 3.0)
             This cmd is only effective in constant current control mode 
             or your newly set value will be overwritten by PID Controller Output
                 - i_out: A
         """
-        return await self._send_cmd(self.tec_set_i_cmd._target, self.tec_set_i_cmd.tec_set_i, i_out)
+        if isinstance(i_out, float):
+            return await self._send_raw_cmd({"tec_set_i": i_out})
+        elif isinstance(i_out, int):
+            return await self._send_raw_cmd({"tec_set_i": float(i_out)})
+        else:
+            raise InvalidDataType
 
     async def set_constant_current_control_mode(self):
         """
@@ -630,35 +626,30 @@ class Thermostat:
             performs differently under different kinds of workload. Please verify the polling rate with
             the timestamp.
         """
+        cmd = {}
+        cmd[self._cmd._target] = self._cmd.ConfigTempAdcFilter.name
         if hasattr(filter_config, 'rate'):
-            return await self._send_cmd(
-                self._cmd._target, 
-                self._cmd.ConfigTempAdcFilter, 
-                { 
-                    "filter_type": filter_config._filter_type(),
-                    filter_config._odr_type: filter_config.rate,
-                }
-            )
+            cmd[self._cmd.ConfigTempAdcFilter] = { 
+                "filter_type": filter_config._filter_type(),
+                filter_config._odr_type: filter_config.rate,
+            }
         else:
-            return await self._send_cmd(
-                self._cmd._target, 
-                self._cmd.ConfigTempAdcFilter, 
-                { 
-                    "filter_type": filter_config._filter_type(),
-                    filter_config._odr_type: filter_config,
-                }
-            )
+            cmd[self._cmd.ConfigTempAdcFilter] = { 
+                "filter_type": filter_config._filter_type(),
+                filter_config._odr_type: filter_config,
+            }
+
+        return await self._send_raw_cmd(cmd)
 
     async def get_poll_interval(self):
         return await self._send_cmd(self._cmd._target, self._cmd.GetPollInterval, msg_type="Interval")
 
 class Kirdy:
     def __init__(self):
-        self.device = Device(self._send_cmd)
+        self.device = Device(self._send_cmd, self._send_raw_cmd)
         self.laser = Laser(self._send_cmd)
-        self.thermostat = Thermostat(self._send_cmd)
+        self.thermostat = Thermostat(self._send_cmd, self._send_raw_cmd)
         self.hw_rev = None
-        self.firmware_rev = None
 
         self._task_queue, self._int_msg_queue, self._report_queue = None, None, None
         self._timeout = 5.0
@@ -666,6 +657,7 @@ class Kirdy:
         self._event_loop = None
         
         self._msg_queue_get_report = False
+        self._report_mode_on = False
         self._state = State.disconnected
 
         self.read_response_task, self.handler_task = None, None
@@ -675,19 +667,15 @@ class Kirdy:
         self._report_sig = None # Dict
         self._connected_sig = None # Bool
         self._err_msg_sig = None # Str
-        self._warning_msg_sig = None # Str
         
         self.connected_event = None
 
     def get_hw_rev(self):
         return self.hw_rev
 
-    def get_firmware_rev(self):
-        return self.firmware_rev
-
     def set_report_sig(self, sig):
         """
-            Connect a PyQt Signal to the status report output(dict). This should be configured before the session is started.
+            Connect a PyQt Signal to the active report output(dict). This should be configured before the session is started.
         """
         self._report_sig = sig
 
@@ -704,14 +692,8 @@ class Kirdy:
             Emit a error message to a PyQt Signal(str) when a cmd fails to execute
         """
         self._err_msg_sig = sig
-    
-    def set_warning_msg_sig(self, sig):
-        """
-            Emit a warning message to a PyQt Signal(str) when a cmd fails to execute
-        """
-        self._warning_msg_sig = sig
 
-    def start_session(self, host='192.168.1.128', port=1550):
+    def start_session(self, host='192.168.1.128', port=1337):
         """
             Start Kirdy Connection Session.
             In case of disconnection, all the queued tasks are cleared and the handler task retries TCP connection indefinitely.
@@ -767,17 +749,40 @@ class Kirdy:
         if not(self.connected()):
             await self.connected_event.wait()
 
+    async def report_mode(self):
+        """
+            Enable and retrieve active report from Kirdy
+        """
+        if self.connected():
+            self._report_mode_on = True
+            await self.device.set_active_report_mode(True)
+            report = None
+
+            while self._report_mode_on:
+                report = await self._report_queue.get()
+                if not(isinstance(report, dict)):
+                    self.stop_active_report()
+                else:
+                    yield report
+            
+            if isinstance(report, dict):
+                await self.device.set_active_report_mode(False)
+        else:
+            raise ConnectionError
+
+    def stop_report_mode(self):
+        self._report_mode_on = False
+
     def task_dispatcher(self, awaitable_fn):
         """
             Enqueue a task to be handled by the handler.
         """
         if self.connected():
-            if self._task_queue.full():
-                awaitable_fn.close()
-                return False
-            else:
+            try:
                 self._task_queue.put_nowait(lambda: awaitable_fn)
                 return True
+            except asyncio.queues.QueueFull:
+                return False
         else:
             raise ConnectionError
 
@@ -803,7 +808,6 @@ class Kirdy:
     async def _handler(self):
         try:
             self._state = State.disconnected
-            self.read_response_task = None
             first_con = True
             task = None
             while True:
@@ -818,12 +822,6 @@ class Kirdy:
                         hw_rev = await self.device.get_hw_rev()
                         self.hw_rev = hw_rev["hw_rev"]
 
-                        try:
-                            firmware_rev = await self.device.get_firmware_rev()
-                            self.firmware_rev = firmware_rev["firmware_rev"]
-                        except:
-                            self.firmware_rev = "Unknown"
-
                         if self._connected_sig is not None:
                             self._connected_sig.emit(True)
                         self.connected_event.set()
@@ -848,7 +846,6 @@ class Kirdy:
                         logging.warning("Connection to Kirdy is dropped.")
                         first_con = True
                         self.read_response_task.cancel()
-                        await self.read_response_task
 
                         # State Transition
                         self._state = State.disconnected
@@ -862,7 +859,10 @@ class Kirdy:
     async def _read_response_handler(self):
         try:
             while True:
-                response = await self._read_response()
+                if self._report_mode_on:
+                    response = await asyncio.wait_for(self._read_response(), self._timeout)
+                else:
+                    response = await self._read_response()
 
                 if response["msg_type"] == 'HardReset':
                     logging.warn("Kirdy is being hard reset.")
@@ -879,7 +879,7 @@ class Kirdy:
                     else:
                         self._report_sig.emit(response)
                 else:
-                    if self._msg_queue_get_report and response["msg_type"] == 'Report':
+                    if self._msg_queue_get_report:
                         self._msg_queue_get_report = False
                     self._int_msg_queue.put_nowait_overwrite(response)
         except asyncio.exceptions.CancelledError:
@@ -891,6 +891,9 @@ class Kirdy:
             logging.warn("Read Response Handler experienced an error. Exiting.", exc_info=True)
             self._task_queue.put_nowait_overwrite(exec)
             self._int_msg_queue.put_nowait_overwrite(exec)
+        if self._report_mode_on:
+            self._report_mode_on = False
+            self._report_queue.put_nowait_overwrite(TimeoutError)
 
     async def _stop_handler(self):
         for task in asyncio.all_tasks():
@@ -900,8 +903,7 @@ class Kirdy:
     async def __coninit(self, timeout):
         def _put_nowait_overwrite(self, item):
             if self.full():
-                awaitable_fn = self.get_nowait()
-                awaitable_fn.close()
+                self.get_nowait()
             self.put_nowait(item)
         asyncio.Queue.put_nowait_overwrite = _put_nowait_overwrite
 
@@ -928,34 +930,43 @@ class Kirdy:
         return json.loads(response[0])
     
     def _response_handling(self, msg, msg_type, sig=None):
-        if msg["msg_type"] == msg_type:
+        if msg["msg_type"] in ["InvalidCmd", "InvalidDatatype"]:
+            raise InvalidCmd
+        elif msg["msg_type"] == msg_type:
             if sig is not None:
                 sig.emit(msg)
-        elif msg["msg_type"] == "Warning":
-            logging.warn(f"{msg['msg_type']}:{msg['msg']}")
-            if self._warning_msg_sig is not None:
-                self._warning_msg_sig.emit(f"{msg['msg_type']}:{str(msg['msg'])}")
         else:
             logging.warn(f"Commands fail to execute. {msg['msg_type']}:{msg['msg']}")
-            if self._err_msg_sig is not None:
-                self._err_msg_sig.emit(f"{msg['msg_type']}:{str(msg['msg'])}")
-            else:
-                raise KirdyCmdError(f"{msg['msg_type']}:{str(msg['msg'])}")
+            if self._err_msg_sig is not None and msg['msg'] is not None:
+                self._err_msg_sig.emit(msg['msg'])
         return msg
 
+    async def _send_raw_cmd(self, cmd, msg_type="Acknowledge", sig=None):
+        if self.connected():
+            async with self._lock:
+                self._writer.write(bytes(json.dumps(cmd), "UTF-8"))
+                await self._writer.drain()
+                msg = await asyncio.wait_for(self._int_msg_queue.get(), self._timeout)
+            return self._response_handling(msg, msg_type, sig)
+        else:
+            raise ConnectionError
+
     async def _send_cmd(self, target, cmd, data=None, msg_type="Acknowledge", sig=None):
         cmd_dict = {}
+        cmd_dict[target] = cmd.name
 
-        if target == "tec_set_i":
-            cmd_dict[target] = float(data)
-        else:
-            cmd_dict[target] = cmd.name
-            if cmd != 'None':
-                if cmd == _dt.bool:
-                    data = bool(data)
-                elif isinstance(data, int):
-                    data = float(data)
+        if cmd == _dt.f32:
+            if isinstance(data, float):
                 cmd_dict[cmd] = data
+            elif isinstance(data, int):
+                cmd_dict[cmd] = float(data)
+        elif cmd == _dt.bool:
+            if isinstance(data, bool):
+                cmd_dict[cmd] = data
+            else:
+                raise InvalidDataType
+        elif cmd == "None":
+            pass
 
         if msg_type == 'Report':
             self._msg_queue_get_report = True

pykirdy/kirdy_qt.py

@@ -25,6 +25,10 @@ from collections import deque
 from datetime import datetime, timezone, timedelta
 from time import time
 from typing import Any, Optional, List
+from ui.ui_conn_settings_form import Ui_Conn_Settings_Form
+from ui.ui_config_pd_mon_form import Ui_Cfg_Pd_Mon_Form
+from ui.ui_update_network_settings_form import Ui_Update_Network_Settings_Form
+from ui.ui_config_adc_filter_form import Ui_Cfg_Adc_Filter_Form
 from dateutil import tz
 import math
 import socket
@@ -72,7 +76,6 @@ class Kirdy(QObject):
     setting_update_sig = pyqtSignal(dict)
     report_update_sig = pyqtSignal(dict)
     cmd_fail_sig = pyqtSignal(str)
-    cmd_warning_sig = pyqtSignal(str)
 
     def __init__(self, parent, kirdy, _poll_interval):
         super().__init__(parent)
@@ -85,7 +88,6 @@ class Kirdy(QObject):
         self._noti_info_box.setIcon(QtWidgets.QMessageBox.Icon.Information)
 
         self._kirdy.set_err_msg_sig(self.cmd_fail_sig)
-        self._kirdy.set_warning_msg_sig(self.cmd_warning_sig)
         self._poll_report_timer = QtCore.QTimer()
         self._poll_report_timer.timeout.connect(self.polling_event)
 
@@ -117,8 +119,8 @@ class Kirdy(QObject):
         success = True
         success &= self._kirdy.task_dispatcher(self._kirdy.device.get_status_report(sig=self.report_update_sig))
         if not(success):
-            self._noti_info_box.setWindowTitle(" ")
-            self._noti_info_box.setText(f"Polling rate is too high. Kirdy cannot handle {1/(self._poll_interval)} Hz polling rate. Reset to default polling rate ({1/self._default_poll_interval} Hz)")
+            self._noti_info_box.setWindowTitle("Polling rate is too high")
+            self._noti_info_box.setText(f"Kirdy cannot handle {1/(self._poll_interval)} Hz polling rate. Reset to default polling rate ({1/self._default_poll_interval} Hz)")
             self._noti_info_box.show()
 
             self.set_update_s(self._default_poll_interval)
@@ -151,9 +153,6 @@ class Kirdy(QObject):
     def get_hw_rev(self):
         return self._kirdy.get_hw_rev()
 
-    def get_firmware_rev(self):
-        return self._kirdy.get_firmware_rev()
-
 class Graphs:
     def __init__(self, ld_i_set_graph, pd_mon_pwr_graph, tec_i_graph, tec_temp_graph, max_samples=1000):
         self.graphs = [ld_i_set_graph, pd_mon_pwr_graph, tec_i_graph, tec_temp_graph]
@@ -196,40 +195,34 @@ class Graphs:
         ld_i_set_axis.showLabel()
         ld_i_set_graph.setAxisItems({'left': ld_i_set_axis})
         ld_i_set_graph.addItem(self._ld_i_set_plot)
-        ld_i_set_graph.y_range_controller = LiveAxisRange(fixed_range=[0.0, 0.4])
-        self.ld_i_set_connector = DataConnector(self._ld_i_set_plot, plot_rate=10.0, update_rate=10.0, max_points=self.max_samples)
+        self.ld_i_set_connector = DataConnector(self._ld_i_set_plot, max_points=self.max_samples)
         self.connectors += [self.ld_i_set_connector]
 
         pd_mon_pwr_axis = LiveAxis('left', text="Power", units="W")
         pd_mon_pwr_axis.showLabel()
-        # Laser Diode Power Reading Graph Range Width: 5mW
-        pd_mon_pwr_graph.y_range_controller = LiveAxisRange(y_range_width=0.005, y_bound=[0.0, float("inf")])
         pd_mon_pwr_graph.setAxisItems({'left': pd_mon_pwr_axis})
         pd_mon_pwr_graph.addItem(self._pd_mon_pwr_plot)
-        self.pd_mon_pwr_connector = DataConnector(self._pd_mon_pwr_plot, plot_rate=10.0, update_rate=10.0, max_points=self.max_samples)
+        self.pd_mon_pwr_connector = DataConnector(self._pd_mon_pwr_plot, max_points=self.max_samples)
         self.connectors += [self.pd_mon_pwr_connector]
 
         tec_temp_axis = LiveAxis('left', text="Temperature", units="℃")
         tec_temp_axis.showLabel()
-        # TEC Temperature Reading Graph Range Width: 2.5mK
-        tec_temp_graph.y_range_controller = LiveAxisRange(y_range_width=0.0025)
         tec_temp_graph.setAxisItems({'left': tec_temp_axis})
         tec_temp_graph.addItem(self._tec_setpoint_plot)
         tec_temp_graph.addItem(self._tec_temp_plot)
-        self.tec_setpoint_connector = DataConnector(self._tec_setpoint_plot, plot_rate=10.0, update_rate=10.0, max_points=2)
-        self.tec_temp_connector = DataConnector(self._tec_temp_plot, plot_rate=10.0, update_rate=10.0, max_points=self.max_samples)
+        self.tec_setpoint_connector = DataConnector(self._tec_setpoint_plot, max_points=1)
+        self.tec_temp_connector = DataConnector(self._tec_temp_plot, max_points=self.max_samples)
         self.connectors += [self.tec_temp_connector, self.tec_setpoint_connector]
 
         tec_i_axis = LiveAxis('left', text="Current", units="A")
         tec_i_axis.showLabel()
         tec_i_graph.setAxisItems({'left': tec_i_axis})
         tec_i_graph.addLegend(brush=(50, 50, 200, 150))
+        tec_i_graph.y_range_controller = LiveAxisRange(fixed_range=[-1.0, 1.0])
         tec_i_graph.addItem(self._tec_i_target_plot)
         tec_i_graph.addItem(self._tec_i_measure_plot)
-        # TEC Output Current Reading Graph Range Width: 50mA
-        tec_i_graph.y_range_controller = LiveAxisRange(y_range_width=0.05)
-        self.tec_i_target_connector = DataConnector(self._tec_i_target_plot, plot_rate=10.0, update_rate=10.0, max_points=self.max_samples)
-        self.tec_i_measure_connector = DataConnector(self._tec_i_measure_plot, plot_rate=10.0, update_rate=10.0, max_points=self.max_samples)
+        self.tec_i_target_connector = DataConnector(self._tec_i_target_plot, max_points=self.max_samples)
+        self.tec_i_measure_connector = DataConnector(self._tec_i_measure_plot, max_points=self.max_samples)
         self.connectors += [self.tec_i_target_connector, self.tec_i_measure_connector]
     
     def set_max_samples(self, max_samples):
@@ -267,9 +260,9 @@ class Graphs:
 
             self.tec_temp_connector.cb_append_data_point(tec_temp, ts)
             if self._temp_setpoint_line.isVisible():
-                self.tec_setpoint_connector.cb_set_data([self._temp_setpoint_line.value(), self._temp_setpoint_line.value()], [ts, ts])
+                self.tec_setpoint_connector.cb_append_data_point(self._temp_setpoint_line.value(), ts)
             else:
-                self.tec_setpoint_connector.cb_set_data([tec_temp, tec_temp], [ts, ts])
+                self.tec_setpoint_connector.cb_append_data_point(tec_temp, ts)
             if tec_i_measure is not None:
                 self.tec_i_measure_connector.cb_append_data_point(tec_i_measure, ts)
             self.tec_i_target_connector.cb_append_data_point(tec_i_set, ts)
@@ -326,11 +319,10 @@ class MutexParameter(pTypes.ListParameter):
 
 registerParameterType('mutex', MutexParameter)
 
-class UpdateNetSettingsForm(QtWidgets.QDialog):
+class UpdateNetSettingsForm(QtWidgets.QDialog, Ui_Update_Network_Settings_Form):
     def __init__(self):
         super().__init__()
-        ui_file_path = importlib.resources.files("ui").joinpath("update_network_settings_form.ui")
-        uic.loadUi(ui_file_path, self)
+        self.setupUi(self)
     
     def get_net_settings(self):
         try:
@@ -348,17 +340,15 @@ class UpdateNetSettingsForm(QtWidgets.QDialog):
         except (OSError, ValueError):
             return None
 
-class CfgPdMonForm(QtWidgets.QDialog):
+class CfgPdMonForm(QtWidgets.QDialog, Ui_Cfg_Pd_Mon_Form):
     def __init__(self):
         super().__init__()
-        ui_file_path = importlib.resources.files("ui").joinpath("config_pd_mon_form.ui")
-        uic.loadUi(ui_file_path, self)
+        self.setupUi(self)
 
-class ConnSettingsForm(QtWidgets.QDialog):
+class ConnSettingsForm(QtWidgets.QDialog, Ui_Conn_Settings_Form):
     def __init__(self):
         super().__init__()
-        ui_file_path = importlib.resources.files("ui").joinpath("conn_settings_form.ui")
-        uic.loadUi(ui_file_path, self)
+        self.setupUi(self)
 
     def get_net_settings(self):
         try:
@@ -372,11 +362,10 @@ class ConnSettingsForm(QtWidgets.QDialog):
         except (OSError, ValueError):
             return None
 
-class ConfigAdcFilterForm(QtWidgets.QDialog):
+class ConfigAdcFilterForm(QtWidgets.QDialog, Ui_Cfg_Adc_Filter_Form):
     def __init__(self):
         super().__init__()
-        ui_file_path = importlib.resources.files("ui").joinpath("config_adc_filter_form.ui")
-        uic.loadUi(ui_file_path, self)
+        self.setupUi(self)
         self.filter_type_cbox.addItems(['Sinc5Sinc1With50hz60HzRejection', 'Sinc5Sinc1', 'Sinc3', 'Sinc3WithFineODR'])
         self.fine_filter_sampling_rate_spinbox.setVisible(False)
         self.fine_filter_sampling_rate_spinbox.setMinimum(FilterConfig.Sinc3WithFineODR.lower_limit)
@@ -409,13 +398,19 @@ class MainWindow(QtWidgets.QMainWindow):
     """The maximum number of sample points to store."""
     DEFAULT_MAX_SAMPLES = 1000
     DEFAULT_IP_ADDR = '192.168.1.128'
-    DEFAULT_PORT = 1550
+    DEFAULT_PORT = 1337
+
+    LASER_DIODE_STATUS = [
+        {'name': 'Status', 'title': 'Status:    Power Off', 'expanded': True, 'type': 'group', 'children': [
+            {'name': 'Color', 'title': '', 'type': 'color', 'value': 'w', 'readonly': True, "compactHeight": False},
+        ]}
+    ]
 
     LASER_DIODE_PARAMETERS = [
         {'name': 'Readings', 'expanded': True, 'type': 'group', 'children': [
-            {'name': 'LD Current Set', 'type': 'float', 'unit': 'mA', 'readonly': True, "compactHeight": False},
-            {'name': 'PD Current', 'type': 'float', 'unit': 'uA', 'readonly': True, "compactHeight": False},
-            {'name': 'PD Power', 'type': 'float', 'unit': 'mW', 'readonly': True, "compactHeight": False},
+            {'name': 'LD Current Set', 'type': 'float', 'suffix': 'A', 'siPrefix': True, 'readonly': True, "compactHeight": False},
+            {'name': 'PD Current', 'type': 'float', 'suffix': 'A', 'siPrefix': True, 'readonly': True, "compactHeight": False},
+            {'name': 'PD Power', 'type': 'float', 'suffix': 'W', 'siPrefix': True, 'readonly': True, "compactHeight": False},
             {'name': 'LF Mod Termination (50 Ohm)', 'type': 'list', 'limits': ['On', 'Off'], 'readonly': True, "compactHeight": False}
         ]},
         {'name': 'Output Config', 'expanded': True, 'type': 'group', 'children': [
@@ -435,17 +430,23 @@ class MainWindow(QtWidgets.QMainWindow):
         ]},
     ]
 
+    THERMOSTAT_STATUS = [
+         {'name': 'Status', 'title': 'Status:    Power Off', 'expanded': True, 'type': 'group', 'children': [
+            {'name': 'Color', 'title': '', 'type': 'color', 'value': 'w', 'readonly': True, "compactHeight": False},
+        ]}
+    ]
+
     THERMOSTAT_PARAMETERS = [
         {'name': 'Readings', 'expanded': True, 'type': 'group', 'children': [
-            {'name': 'Temperature', 'type': 'float', 'unit': '℃', 'format': '{value:.4f}', 'readonly': True, "compactHeight": False},
-            {'name': 'Current through TEC', 'type': 'float', 'unit': 'mA', 'decimals': 6, 'readonly': True, "compactHeight": False},
+            {'name': 'Temperature', 'type': 'float', 'format': '{value:.4f} ℃', 'readonly': True, "compactHeight": False},
+            {'name': 'Current through TEC', 'type': 'float', 'suffix': 'A', 'siPrefix': True, 'decimals': 6, 'readonly': True, "compactHeight": False},
         ]},
         {'name': 'Output Config', 'expanded': True, 'type': 'group', 'children': [
             {'name': 'Control Method', 'type': 'mutex', 'limits': ['Constant Current', 'Temperature PID'],
                 'target_action_pair': [['thermostat', 'set_constant_current_control_mode'], ['thermostat', 'set_pid_control_mode']], 'children': [
                 {'name': 'Set Current', 'type': 'float', 'value': 0, 'step': 1, 'limits': (-3000, 3000), 'triggerOnShow': True, 'decimals': 6,
                     'unit': 'mA', 'lock': False, 'target': 'thermostat', 'action': 'set_tec_i_out', "compactHeight": False},
-                {'name': 'Set Temperature', 'type': 'float', 'value': 25, 'step': 0.0001, 'limits': (-273.15, 300), 'format': '{value:.4f}',
+                {'name': 'Set Temperature', 'type': 'float', 'value': 25, 'step': 0.0001, 'limits': (-273, 300), 'format': '{value:.4f}',
                     'unit': '℃', 'lock': False, 'target': 'thermostat', 'action': 'set_temperature_setpoint', "compactHeight": False},
             ]},
             {'name': 'Limits', 'expanded': False, 'type': 'group', 'children': [
@@ -459,9 +460,9 @@ class MainWindow(QtWidgets.QMainWindow):
             {'name': 'Default Power On', 'type': 'bool', 'value': False, 'lock': False, 'target': 'thermostat', 'action': 'set_default_pwr_on'},
         ]},
         {'name': 'Temperature Monitor Config', 'expanded': False, 'type': 'group', 'children': [
-            {'name': 'Upper Limit', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273.15, 300),
+            {'name': 'Upper Limit', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273, 300),
                 'unit': '℃', 'lock': False, 'target': 'thermostat', 'action': 'set_temp_mon_upper_limit', "compactHeight": False},
-            {'name': 'Lower Limit', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273.15, 300),
+            {'name': 'Lower Limit', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273, 300),
                 'unit': '℃', 'lock': False, 'target': 'thermostat', 'action': 'set_temp_mon_lower_limit', "compactHeight": False},
         ]},
         {'name': 'Temperature ADC Filter Settings', 'expanded': False, 'type': 'group', 'children': [
@@ -471,7 +472,7 @@ class MainWindow(QtWidgets.QMainWindow):
             {'name': 'Configure ADC Filter', 'type': 'action'},
         ]},
         {'name': 'Thermistor Settings','expanded': False, 'type': 'group', 'children': [
-            {'name': 'T₀', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273.15, 300),
+            {'name': 'T₀', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6, 'limits': (-273, 300),
                 'unit': '℃', 'lock': False, 'target': 'thermostat', 'action': 'set_sh_t0', "compactHeight": False},
             {'name': 'R₀', 'type': 'float', 'value': 0, 'step': 1, 'decimals': 6,
                 'unit': 'kΩ', 'lock': False, 'target': 'thermostat', 'action': 'set_sh_r0', "compactHeight": False},
@@ -483,14 +484,14 @@ class MainWindow(QtWidgets.QMainWindow):
             {'name': 'Ki', 'type': 'float', 'step': 0.1, 'decimals': 16, 'unit': 'Hz', 'lock': False, 'target': 'thermostat', 'action': 'set_pid_ki', "compactHeight": False},
             {'name': 'Kd', 'type': 'float', 'step': 0.1, 'decimals': 16, 'unit': 's', 'lock': False, 'target': 'thermostat', 'action': 'set_pid_kd', "compactHeight": False},
             {'name': "PID Output Clamping", 'expanded': True, 'type': 'group', 'children': [
-                {'name': 'Minimum', 'type': 'float', 'step': 1, 'limits': (-3000, 3000), 'decimals': 6, 
+                {'name': 'Minimum', 'type': 'float', 'step': 1, 'limits': (-1000, 1000), 'decimals': 6, 
                     'unit': 'mA', 'lock': False, 'target': 'thermostat', 'action': 'set_pid_output_min', "compactHeight": False},
-                {'name': 'Maximum', 'type': 'float', 'step': 1, 'limits': (-3000, 3000), 'decimals': 6,
+                {'name': 'Maximum', 'type': 'float', 'step': 1, 'limits': (-1000, 1000), 'decimals': 6,
                     'unit': 'mA', 'lock': False, 'target': 'thermostat', 'action': 'set_pid_output_max', "compactHeight": False},
             ]},
             {'name': 'PID Auto Tune', 'expanded': False, 'type': 'group', 'children': [
                 {'name': 'Target Temperature', 'type': 'float', 'value': 20.0, 'step': 0.1, 'unit': '℃', 'format': '{value:.4f}', "compactHeight": False},
-                {'name': 'Test Current', 'type': 'float', 'value': 1000, 'decimals': 6, 'step': 100, 'limits': (-3000, 3000), 'unit': 'mA', "compactHeight": False},
+                {'name': 'Test Current', 'type': 'float', 'value': 1000, 'decimals': 6, 'step': 100, 'limits': (-1000, 1000), 'unit': 'mA', "compactHeight": False},
                 {'name': 'Temperature Swing', 'type': 'float', 'value': 0.0, 'step': 0.0001, 'prefix': '±', 'unit': '℃', 'format': '{value:.4f}', "compactHeight": False},
                 {'name': 'Lookback', 'type': 'float', 'value': 5.0, 'step': 0.1, 'unit': 's', 'format': '{value:.4f}', "compactHeight": False},
                 {'name': 'Run', 'type': 'action', 'tip': 'Run'},
@@ -558,11 +559,15 @@ class MainWindow(QtWidgets.QMainWindow):
             else:
                 _traverse(param_tree)
 
+        _add_unit_to_title(self.LASER_DIODE_STATUS)
         _add_unit_to_title(self.LASER_DIODE_PARAMETERS)
+        _add_unit_to_title(self.THERMOSTAT_STATUS)
         _add_unit_to_title(self.THERMOSTAT_PARAMETERS)
 
         self.params = [
+            Parameter.create(name=f"Laser Diode Status", type='group', value=0, children=self.LASER_DIODE_STATUS),
             Parameter.create(name=f"Laser Diode Parameters", type='group', value=1, children=self.LASER_DIODE_PARAMETERS),
+            Parameter.create(name=f"Thermostat Status", type='group', value=2, children=self.THERMOSTAT_STATUS),
             Parameter.create(name=f"Thermostat Parameters", type='group', value=3, children=self.THERMOSTAT_PARAMETERS),
         ]
         self._set_param_tree()
@@ -582,8 +587,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.kirdy_handler.setting_update_sig.connect(self.update_thermostat_ctrl_panel_settings)
         self.kirdy_handler.report_update_sig.connect(self.update_ld_ctrl_panel_readings)
         self.kirdy_handler.report_update_sig.connect(self.update_thermostat_ctrl_panel_readings)
-        self.kirdy_handler.cmd_fail_sig.connect(self.show_err_cmd_msg)
-        self.kirdy_handler.cmd_warning_sig.connect(self.show_warning_cmd_msg)
+        self.kirdy_handler.cmd_fail_sig.connect(self.cmd_cannot_execute)
 
         self.graphs = Graphs(self.ld_i_set_graph, self.pd_mon_pwr_graph, self.tec_i_graph, self.tec_temp_graph, max_samples=self.max_samples)
         self.kirdy_handler.report_update_sig.connect(self.graphs.plot_append)
@@ -595,14 +599,11 @@ class MainWindow(QtWidgets.QMainWindow):
         @pyqtSlot(bool)
         def about_kirdy(_):
             hw_rev = self.kirdy_handler.get_hw_rev()
-            firmware_rev = self.kirdy_handler.get_firmware_rev()
             QtWidgets.QMessageBox.about(
                 self,
                 "About Kirdy",
                 f"""
-                <h2>Sinara 1550 Kirdy</h2>
-                Hardware Revision: v{hw_rev["major"]}.{hw_rev["minor"]}<br>
-                Firmware Revision: {firmware_rev}<br>
+                <h1>Sinara 1550 Kirdy v{hw_rev["major"]}.{hw_rev["minor"]}</h1>
                 """
             )
         self.menu_action_about_kirdy.triggered.connect(about_kirdy)
@@ -635,8 +636,8 @@ class MainWindow(QtWidgets.QMainWindow):
         def save_settings(_):
             self.kirdy.task_dispatcher(self.kirdy.device.save_current_settings_to_flash())
             saved = QtWidgets.QMessageBox(self)
-            saved.setWindowTitle(" ")
-            saved.setText(f"Config saved. Laser diode and thermostat configs have been saved into flash.")
+            saved.setWindowTitle("Config saved")
+            saved.setText(f"Laser diode and thermostat configs have been saved into flash.")
             saved.setIcon(QtWidgets.QMessageBox.Icon.Information)
             saved.show()
         self.menu_action_save.triggered.connect(save_settings)
@@ -645,20 +646,21 @@ class MainWindow(QtWidgets.QMainWindow):
         def load_settings(_):
             self.kirdy.task_dispatcher(self.kirdy.device.restore_settings_from_flash())
             loaded = QtWidgets.QMessageBox(self)
-            loaded.setWindowTitle(" ")
-            loaded.setText(f"Config loaded. Laser Diode and Thermostat configs have been loaded from flash.")
+            loaded.setWindowTitle("Config loaded")
+            loaded.setText(f"Laser Diode and Thermostat configs have been loaded from flash.")
             loaded.setIcon(QtWidgets.QMessageBox.Icon.Information)
             loaded.show()
         self.menu_action_load.triggered.connect(load_settings)
 
         @pyqtSlot(bool)
         def show_update_net_settings_form(_):
+            self.update_net_settings_form.retranslateUi(self.update_net_settings_form)
             self.update_net_settings_form.show()
         self.menu_action_update_net_settings.triggered.connect(show_update_net_settings_form)
 
     def update_pd_mon_form_readings(self, ld_settings):
-        pwr_unit = self.params[0].child('Photodiode Monitor Config', 'LD Power Limit').opts.get("unit", None)
-        self.params[0].child('Photodiode Monitor Config', 'LD Power Limit').setOpts(limits= (0, siConvert(ld_settings["ld_pwr_limit"]["max"], pwr_unit)))
+        pwr_unit = self.params[1].child('Photodiode Monitor Config', 'LD Power Limit').opts.get("unit", None)
+        self.params[1].child('Photodiode Monitor Config', 'LD Power Limit').setOpts(limits= (0, siConvert(ld_settings["ld_pwr_limit"]["max"], pwr_unit)))
         self.cfg_pd_mon_form.settable_pwr_range_display_lbl.setText(f" 0 - {siConvert(ld_settings['ld_pwr_limit']['max'], pwr_unit):.4f}")
         self.cfg_pd_mon_form.cfg_pwr_limit_spinbox.setMaximum(siConvert(ld_settings['ld_pwr_limit']['max'], pwr_unit))
 
@@ -790,19 +792,19 @@ class MainWindow(QtWidgets.QMainWindow):
             self.kirdy.task_dispatcher(self.kirdy.laser.set_ld_pwr_limit(settings['laser']['ld_pwr_limit']['max']))
         self.cfg_pd_mon_form.apply_pwr_limit_max_btn.clicked.connect(apply_ld_pwr_limit_max)
     
-        ld_pwr_limit_unit = self.params[0].child('Photodiode Monitor Config', 'LD Power Limit').opts["unit"]
+        ld_pwr_limit_unit = self.params[1].child('Photodiode Monitor Config', 'LD Power Limit').opts["unit"]
         ld_pwr_limit_text = self.cfg_pd_mon_form.cfg_pwr_limit_lbl.text()
         self.cfg_pd_mon_form.cfg_pwr_limit_lbl.setText(ld_pwr_limit_text.replace(":", f" ({ld_pwr_limit_unit}):"))
         self.cfg_pd_mon_form.cfg_pwr_limit_spinbox.unit = ld_pwr_limit_unit
         settable_pwr_limit_text = self.cfg_pd_mon_form.settable_pwr_range_lbl.text()
         self.cfg_pd_mon_form.settable_pwr_range_lbl.setText(settable_pwr_limit_text.replace(":", f" ({ld_pwr_limit_unit}):"))
 
-        pd_responsitivity_unit = self.params[0].child('Photodiode Monitor Config', 'Responsitivity').opts["unit"]
+        pd_responsitivity_unit = self.params[1].child('Photodiode Monitor Config', 'Responsitivity').opts["unit"]
         pd_responsitivity_text = self.cfg_pd_mon_form.cfg_responsitivity_lbl.text()
         self.cfg_pd_mon_form.cfg_responsitivity_lbl.setText(pd_responsitivity_text.replace(":", f" ({pd_responsitivity_unit}):"))
         self.cfg_pd_mon_form.cfg_responsitivity_spinbox.unit = pd_responsitivity_unit
 
-        pd_dark_current_unit = self.params[0].child('Photodiode Monitor Config', 'Dark Current').opts["unit"]
+        pd_dark_current_unit = self.params[1].child('Photodiode Monitor Config', 'Dark Current').opts["unit"]
         pd_dark_current_text = self.cfg_pd_mon_form.cfg_dark_current_lbl.text()
         self.cfg_pd_mon_form.cfg_dark_current_lbl.setText(pd_dark_current_text.replace(":", f" ({pd_dark_current_unit}):"))
         self.cfg_pd_mon_form.cfg_dark_current_spinbox.unit = pd_dark_current_unit
@@ -815,23 +817,26 @@ class MainWindow(QtWidgets.QMainWindow):
         self.cfg_adc_filter_form.apply_btn.clicked.connect(apply_adc_filter_settings)
 
     def _set_param_tree(self):
-        self.ld_status.setStyleSheet("border: 3px solid #A1A1A1;") # Light Gray
-        self.tec_status.setStyleSheet("border: 3px solid #A1A1A1;") # Light Gray
+        status = self.ld_status
+        status.setHeaderHidden(True)
+        status.setParameters(self.params[0], showTop=False)
 
         tree = self.ld_tree
         tree.setHeaderHidden(True)
-        tree.setParameters(self.params[0], showTop=False)
-        self.params[0].sigTreeStateChanged.connect(self.send_command)
-
-        tree = self.tec_tree
-        tree.setHeaderHidden(True)
         tree.setParameters(self.params[1], showTop=False)
         self.params[1].sigTreeStateChanged.connect(self.send_command)
 
-        self.prev_autotuner_state = None
+        status = self.tec_status
+        status.setHeaderHidden(True)
+        status.setParameters(self.params[2], showTop=False)
+
+        tree = self.tec_tree
+        tree.setHeaderHidden(True)
+        tree.setParameters(self.params[3], showTop=False)
+        self.params[3].sigTreeStateChanged.connect(self.send_command)
+
         @asyncSlot()
         async def autotune(param):
-            self.prev_autotuner_state = None
             match self.autotuner.state():
                 case PIDAutotuneState.STATE_OFF:
                     settings = await self.kirdy.device.get_settings_summary()
@@ -841,7 +846,6 @@ class MainWindow(QtWidgets.QMainWindow):
                         param.parent().child('Temperature Swing').value(),
                         1.0 / settings['thermostat']['temp_adc_settings']['rate'],
                         param.parent().child('Lookback').value())
-                    print(param.parent().child('Lookback').value())
                     self.autotuner.setReady()
                     param.setOpts(title="Stop")
                     self.kirdy.task_dispatcher(self.kirdy.thermostat.set_constant_current_control_mode())
@@ -857,20 +861,20 @@ class MainWindow(QtWidgets.QMainWindow):
                     self.background_task_lbl.setText("Ready.")
                     self.loading_spinner.stop()
                     self.loading_spinner.hide()
-        self.params[1].child('PID Config', 'PID Auto Tune', 'Run').sigActivated.connect(autotune)
+        self.params[3].child('PID Config', 'PID Auto Tune', 'Run').sigActivated.connect(autotune)
 
         @pyqtSlot()
         def show_pd_mon_cfg_form(param):
-            ld_pwr_limit = self.params[0].child('Photodiode Monitor Config', 'LD Power Limit').value()
-            pd_responsitivity = self.params[0].child('Photodiode Monitor Config', 'Responsitivity').value()
-            pd_dark_current = self.params[0].child('Photodiode Monitor Config', 'Dark Current').value()
+            ld_pwr_limit = self.params[1].child('Photodiode Monitor Config', 'LD Power Limit').value()
+            pd_responsitivity = self.params[1].child('Photodiode Monitor Config', 'Responsitivity').value()
+            pd_dark_current = self.params[1].child('Photodiode Monitor Config', 'Dark Current').value()
 
             self.cfg_pd_mon_form.cfg_responsitivity_spinbox.setValue(pd_responsitivity)
             self.cfg_pd_mon_form.cfg_pwr_limit_spinbox.setValue(ld_pwr_limit)
             self.cfg_pd_mon_form.cfg_dark_current_spinbox.setValue(pd_dark_current)
 
             self.cfg_pd_mon_form.show()
-        self.params[0].child('Photodiode Monitor Config', 'Configure Photodiode Monitor').sigActivated.connect(show_pd_mon_cfg_form)
+        self.params[1].child('Photodiode Monitor Config', 'Configure Photodiode Monitor').sigActivated.connect(show_pd_mon_cfg_form)
 
         @asyncSlot()
         async def show_adc_filter_cfg_form(param):
@@ -887,58 +891,48 @@ class MainWindow(QtWidgets.QMainWindow):
                 self.cfg_adc_filter_form.filter_sampling_rate_cbox.setCurrentIndex(self.cfg_adc_filter_form.filter_sampling_rate_cbox.findText(filter_rate))
             self.cfg_adc_filter_form.show()
             
-        self.params[1].child('Temperature ADC Filter Settings', 'Configure ADC Filter').sigActivated.connect(show_adc_filter_cfg_form)
+        self.params[3].child('Temperature ADC Filter Settings', 'Configure ADC Filter').sigActivated.connect(show_adc_filter_cfg_form)
 
     @pyqtSlot(str)
-    def show_err_cmd_msg(self, kirdy_msg):
-        self.info_box.setWindowTitle(" ")
-        self.info_box.setText(f"Command fails to execute. {kirdy_msg}")
+    def cmd_cannot_execute(self, kirdy_msg):
+        self.info_box.setText(kirdy_msg)
+        self.info_box.setWindowTitle("Command fails to execute")
         self.info_box.show()
 
-    @pyqtSlot(str)
-    def show_warning_cmd_msg(self, kirdy_msg):
-        self.info_box.setWindowTitle(" ")
-        self.info_box.setText(f"Command executed but has warning message. {kirdy_msg}")
-        self.info_box.show()
+    @pyqtSlot(dict)
+    def autotune_tick(self, report):
+        match self.autotuner.state():
+            case PIDAutotuneState.STATE_READY | PIDAutotuneState.STATE_RELAY_STEP_UP | PIDAutotuneState.STATE_RELAY_STEP_DOWN:
+                self.autotuner.run(report['thermostat']['temperature'], report['ts']/1000)
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_tec_i_out(self.autotuner.output()))
+            case PIDAutotuneState.STATE_SUCCEEDED:
+                kp, ki, kd = self.autotuner.get_tec_pid()
+                self.autotuner.setOff()
+                self.params[3].child('PID Config', 'PID Auto Tune', 'Run').setOpts(title="Run")
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_kp(kp))
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_ki(ki))
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_kd(kd))
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_control_mode())
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_temperature_setpoint(self.params[3].child('PID Config', 'PID Auto Tune', 'Target Temperature').value()))
+                self.kirdy_handler.report_update_sig.disconnect(self.autotune_tick)
+                self.background_task_lbl.setText("Ready.")
+                self.loading_spinner.stop()
+                self.loading_spinner.hide()
+                self.info_box.setWindowTitle("PID AutoTune Success")
+                self.info_box.setText("PID Config has been loaded to Thermostat.\nRegulating temperature.")
+                self.info_box.show()
 
-
-    @asyncSlot(dict)
-    async def autotune_tick(self, report):
-        self.autotuner.run(report['thermostat']['temperature'], report['ts']/1000)
-        if self.prev_autotuner_state != self.autotuner.state():
-            match self.autotuner.state():
-                case PIDAutotuneState.STATE_READY | PIDAutotuneState.STATE_RELAY_STEP_UP | PIDAutotuneState.STATE_RELAY_STEP_DOWN:
-                    await self.kirdy.thermostat.set_tec_i_out(self.autotuner.output())
-                    self.prev_autotuner_state = self.autotuner.state()
-                case PIDAutotuneState.STATE_SUCCEEDED:
-                    kp, ki, kd = self.autotuner.get_tec_pid()
-                    self.autotuner.setOff()
-                    self.params[1].child('PID Config', 'PID Auto Tune', 'Run').setOpts(title="Run")
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_kp(kp))
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_ki(ki))
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_kd(kd))
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_pid_control_mode())
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_temperature_setpoint(self.params[1].child('PID Config', 'PID Auto Tune', 'Target Temperature').value()))
-                    self.kirdy_handler.report_update_sig.disconnect(self.autotune_tick)
-                    self.background_task_lbl.setText("Ready.")
-                    self.loading_spinner.stop()
-                    self.loading_spinner.hide()
-                    self.info_box.setWindowTitle(" ")
-                    self.info_box.setText("PID AutoTune Success: PID Config has been loaded to Thermostat.\nRegulating temperature.")
-                    self.info_box.show()
-                    self.prev_autotuner_state = None
-                case PIDAutotuneState.STATE_FAILED:
-                    self.autotuner.setOff()
-                    self.params[1].child('PID Config', 'PID Auto Tune', 'Run').setOpts(title="Run")
-                    self.kirdy.task_dispatcher(self.kirdy.thermostat.set_tec_i_out(0.0))
-                    self.kirdy_handler.report_update_sig.disconnect(self.autotune_tick)
-                    self.background_task_lbl.setText("Ready.")
-                    self.loading_spinner.stop()
-                    self.loading_spinner.hide()
-                    self.info_box.setWindowTitle(" ")
-                    self.info_box.setText("PID Autotune failed.")
-                    self.info_box.show()
-                    self.prev_autotuner_state = None
+            case PIDAutotuneState.STATE_FAILED:
+                self.autotuner.setOff()
+                self.params[3].child('PID Config', 'PID Auto Tune', 'Run').setOpts(title="Run")
+                self.kirdy.task_dispatcher(self.kirdy.thermostat.set_tec_i_out(0.0))
+                self.kirdy_handler.report_update_sig.disconnect(self.autotune_tick)
+                self.background_task_lbl.setText("Ready.")
+                self.loading_spinner.stop()
+                self.loading_spinner.hide()
+                self.info_box.setWindowTitle("PID Autotune Failed")
+                self.info_box.setText("PID Autotune is failed.")
+                self.info_box.show()
 
     @pyqtSlot(bool)
     def _on_connection_changed(self, result):
@@ -1009,17 +1003,17 @@ class MainWindow(QtWidgets.QMainWindow):
     def update_ld_ctrl_panel_settings(self, settings):
         try:
             settings = settings['laser']
-            with QSignalBlocker(self.params[0]):
-                self.params[0].child('Output Config', 'LD Current Set').setValuewithLock(settings["ld_drive_current"]['value'])
-                self.params[0].child('Output Config', 'LD Terminals Short').setValuewithLock(settings["ld_terms_short"])
-                self.params[0].child('Output Config', 'Default Power On').setValuewithLock(settings["default_pwr_on"])
-                self.params[0].child('Photodiode Monitor Config', 'LD Power Limit').setValuewithLock(settings["ld_pwr_limit"]["value"])
+            with QSignalBlocker(self.params[1]):
+                self.params[1].child('Output Config', 'LD Current Set').setValuewithLock(settings["ld_drive_current"]['value'])
+                self.params[1].child('Output Config', 'LD Terminals Short').setValuewithLock(settings["ld_terms_short"])
+                self.params[1].child('Output Config', 'Default Power On').setValuewithLock(settings["default_pwr_on"])
+                self.params[1].child('Photodiode Monitor Config', 'LD Power Limit').setValuewithLock(settings["ld_pwr_limit"]["value"])
                 self.update_pd_mon_form_readings(settings)
                 if settings["pd_mon_params"]["responsitivity"] is not None:
-                    self.params[0].child('Photodiode Monitor Config', 'Responsitivity').setValuewithLock(settings["pd_mon_params"]["responsitivity"])
+                    self.params[1].child('Photodiode Monitor Config', 'Responsitivity').setValuewithLock(settings["pd_mon_params"]["responsitivity"])
                 else:
-                    self.params[0].child('Photodiode Monitor Config', 'Responsitivity').setValuewithLock(0)
-                self.params[0].child('Photodiode Monitor Config', 'Dark Current').setValuewithLock(settings["pd_mon_params"]["i_dark"])
+                    self.params[1].child('Photodiode Monitor Config', 'Responsitivity').setValuewithLock(0)
+                self.params[1].child('Photodiode Monitor Config', 'Dark Current').setValuewithLock(settings["pd_mon_params"]["i_dark"])
         except Exception as e:
             logging.error(f"Params tree cannot be updated. Data:{settings}", exc_info=True)
 
@@ -1029,24 +1023,20 @@ class MainWindow(QtWidgets.QMainWindow):
             report = report['laser']
             with QSignalBlocker(self.params[0]):
                 if report['pwr_excursion']:
-                    self.ld_status.setStyleSheet("border: 3px solid red;")
-                    self.ld_status.setText('     Status:    OverPower Alarm')
+                    self.params[0].child('Status', 'Color').setValuewithLock('r')
+                    self.params[0].child('Status').setOpts(title='Status:    OverPower Alarm')
                 else:
-                    if report['pwr_on']:
-                        self.ld_status.setStyleSheet("border: 3px solid #44E62C;") # Light Green
-                        self.ld_status.setText('     Status:    Power On')
-                    else:
-                        self.ld_status.setStyleSheet("border: 3px solid #A1A1A1;") # Light Gray
-                        self.ld_status.setText('     Status:    Power Off')
+                    self.params[0].child('Status', 'Color').setValuewithLock('g' if report['pwr_on'] else 'w')
+                    self.params[0].child('Status').setOpts(title='Status:    Power On' if report['pwr_on'] else 'Status:    Power Off')
                 
-            with QSignalBlocker(self.params[0]):
-                self.params[0].child('Readings', 'LD Current Set').setValuewithLock(report["ld_i_set"])
-                self.params[0].child('Readings', 'PD Current').setValuewithLock(report["pd_i"])
+            with QSignalBlocker(self.params[1]):
+                self.params[1].child('Readings', 'LD Current Set').setValuewithLock(report["ld_i_set"])
+                self.params[1].child('Readings', 'PD Current').setValuewithLock(report["pd_i"])
                 if report["pd_pwr"] is not None:
-                    self.params[0].child('Readings', 'PD Power').setValuewithLock(report["pd_pwr"])
+                    self.params[1].child('Readings', 'PD Power').setValuewithLock(report["pd_pwr"])
                 else:
-                    self.params[0].child('Readings', 'PD Power').setValuewithLock(0)
-                self.params[0].child('Readings', 'LF Mod Termination (50 Ohm)').setValuewithLock(report["term_50ohm"])
+                    self.params[1].child('Readings', 'PD Power').setValuewithLock(0)
+                self.params[1].child('Readings', 'LF Mod Termination (50 Ohm)').setValuewithLock(report["term_50ohm"])
         except Exception as e:
             logging.error(f"Params tree cannot be updated. Data:{report}", exc_info=True)
 
@@ -1054,29 +1044,29 @@ class MainWindow(QtWidgets.QMainWindow):
     def update_thermostat_ctrl_panel_settings(self, settings):
         try:
             settings = settings['thermostat']
-            with QSignalBlocker(self.params[1]):
-                self.params[1].child('Output Config', 'Control Method').setValuewithLock("Temperature PID" if settings["pid_engaged"] else "Constant Current")
-                self.params[1].child('Output Config', 'Control Method', 'Set Current').setValuewithLock(settings["tec_settings"]['i_set']['value'])
-                self.params[1].child('Output Config', 'Control Method', 'Set Temperature').setValuewithLock(float(settings["temperature_setpoint"]))
-                self.params[1].child('Output Config', 'Limits', 'Max Cooling Current').setValuewithLock(settings["tec_settings"]['max_i_pos']['value'])
-                self.params[1].child('Output Config', 'Limits', 'Max Heating Current').setValuewithLock(settings["tec_settings"]['max_i_neg']['value'])
-                self.params[1].child('Output Config', 'Limits', 'Max Voltage Difference').setValuewithLock(settings["tec_settings"]['max_v']['value'])
-                self.params[1].child('Output Config', 'Default Power On').setValuewithLock(settings["default_pwr_on"])
+            with QSignalBlocker(self.params[3]):
+                self.params[3].child('Output Config', 'Control Method').setValuewithLock("Temperature PID" if settings["pid_engaged"] else "Constant Current")
+                self.params[3].child('Output Config', 'Control Method', 'Set Current').setValuewithLock(settings["tec_settings"]['i_set']['value'])
+                self.params[3].child('Output Config', 'Control Method', 'Set Temperature').setValuewithLock(float(settings["temperature_setpoint"]))
+                self.params[3].child('Output Config', 'Limits', 'Max Cooling Current').setValuewithLock(settings["tec_settings"]['max_i_pos']['value'])
+                self.params[3].child('Output Config', 'Limits', 'Max Heating Current').setValuewithLock(settings["tec_settings"]['max_i_neg']['value'])
+                self.params[3].child('Output Config', 'Limits', 'Max Voltage Difference').setValuewithLock(settings["tec_settings"]['max_v']['value'])
+                self.params[3].child('Output Config', 'Default Power On').setValuewithLock(settings["default_pwr_on"])
                 filter_type = settings['temp_adc_settings']['filter_type']
                 filter_rate = settings['temp_adc_settings'][getattr(getattr(FilterConfig, filter_type), "_odr_type")]
                 self.update_adc_filter_form_readings(filter_type, filter_rate)
-                self.params[1].child('Temperature ADC Filter Settings', 'Filter Type').setValue(filter_type)
-                self.params[1].child('Temperature ADC Filter Settings', 'Sampling Rate').setValue(settings['temp_adc_settings']['rate'])
-                self.params[1].child('Temperature Monitor Config', 'Upper Limit').setValuewithLock(settings["temp_mon_settings"]['upper_limit'])
-                self.params[1].child('Temperature Monitor Config', 'Lower Limit').setValuewithLock(settings["temp_mon_settings"]['lower_limit'])
-                self.params[1].child('PID Config', 'Kp').setValuewithLock(settings["pid_params"]['kp'])
-                self.params[1].child('PID Config', 'Ki').setValuewithLock(settings["pid_params"]['ki'])
-                self.params[1].child('PID Config', 'Kd').setValuewithLock(settings["pid_params"]['kd'])
-                self.params[1].child('PID Config', 'PID Output Clamping', 'Minimum').setValuewithLock(settings["pid_params"]['output_min'])
-                self.params[1].child('PID Config', 'PID Output Clamping', 'Maximum').setValuewithLock(settings["pid_params"]['output_max'])
-                self.params[1].child('Thermistor Settings', 'T₀').setValuewithLock(settings["thermistor_params"]['t0'])
-                self.params[1].child('Thermistor Settings', 'R₀').setValuewithLock(settings["thermistor_params"]['r0'])
-                self.params[1].child('Thermistor Settings', 'B').setValuewithLock(settings["thermistor_params"]['b'])
+                self.params[3].child('Temperature ADC Filter Settings', 'Filter Type').setValue(filter_type)
+                self.params[3].child('Temperature ADC Filter Settings', 'Sampling Rate').setValue(settings['temp_adc_settings']['rate'])
+                self.params[3].child('Temperature Monitor Config', 'Upper Limit').setValuewithLock(settings["temp_mon_settings"]['upper_limit'])
+                self.params[3].child('Temperature Monitor Config', 'Lower Limit').setValuewithLock(settings["temp_mon_settings"]['lower_limit'])
+                self.params[3].child('PID Config', 'Kp').setValuewithLock(settings["pid_params"]['kp'])
+                self.params[3].child('PID Config', 'Ki').setValuewithLock(settings["pid_params"]['ki'])
+                self.params[3].child('PID Config', 'Kd').setValuewithLock(settings["pid_params"]['kd'])
+                self.params[3].child('PID Config', 'PID Output Clamping', 'Minimum').setValuewithLock(settings["pid_params"]['output_min'])
+                self.params[3].child('PID Config', 'PID Output Clamping', 'Maximum').setValuewithLock(settings["pid_params"]['output_max'])
+                self.params[3].child('Thermistor Settings', 'T₀').setValuewithLock(settings["thermistor_params"]['t0'])
+                self.params[3].child('Thermistor Settings', 'R₀').setValuewithLock(settings["thermistor_params"]['r0'])
+                self.params[3].child('Thermistor Settings', 'B').setValuewithLock(settings["thermistor_params"]['b'])
                 self.graphs.set_temp_setpoint_line(temp=round(settings["temperature_setpoint"], 4))
                 self.graphs.set_temp_setpoint_line(visible=settings['pid_engaged'])
         except Exception as e:
@@ -1085,26 +1075,24 @@ class MainWindow(QtWidgets.QMainWindow):
     @pyqtSlot(dict)
     def update_thermostat_ctrl_panel_readings(self, report):
         try:
-            report = report['thermostat'] 
-            if report['temp_mon_status']['over_temp_alarm']:
-                self.tec_status.setStyleSheet("border: 3px solid red;")
-                self.tec_status.setText('     Status:    OverTemperature Alarm')
-            else:
-                if report['pwr_on']:
-                    self.tec_status.setStyleSheet("border: 3px solid #44E62C;") # Light Green
-                    self.tec_status.setText('     Status:    Power On')
-                else:
-                    self.tec_status.setStyleSheet("border: 3px solid #A1A1A1;") # Light Gray
-                    self.tec_status.setText('     Status:    Power Off')
+            report = report['thermostat']
+            with QSignalBlocker(self.params[2]): 
+                if report['temp_mon_status']['over_temp_alarm']:
+                    self.params[2].child('Status', 'Color').setValuewithLock('r')
+                    self.params[2].child('Status').setOpts(title='Status:    OverTemperature Alarm')
 
-            with QSignalBlocker(self.params[1]):
-                if report["temperature"] == None:
-                    self.params[1].child('Readings', 'Temperature').setValuewithLock(-273.15)
                 else:
-                    self.params[1].child('Readings', 'Temperature').setValuewithLock(report["temperature"])
-                self.params[1].child('Readings', 'Current through TEC').setValuewithLock(report["tec_i"])
+                    self.params[2].child('Status', 'Color').setValuewithLock('g' if report['pwr_on'] else 'w')
+                    self.params[2].child('Status').setOpts(title='Status:    Power On' if report['pwr_on'] else 'Status:    Power Off')
+
+            with QSignalBlocker(self.params[3]):
+                if report["temperature"] == None:
+                    self.params[3].child('Readings', 'Temperature').setValuewithLock(-273.15)
+                else:
+                    self.params[3].child('Readings', 'Temperature').setValuewithLock(report["temperature"])
+                self.params[3].child('Readings', 'Current through TEC').setValuewithLock(report["tec_i"])
                 rate = 1 / (report['interval']['ms'] / 1e3 + report['interval']['us'] / 1e6)
-                self.params[1].child('Temperature ADC Filter Settings', 'Recorded Sampling Rate').setValue(rate)
+                self.params[3].child('Temperature ADC Filter Settings', 'Recorded Sampling Rate').setValue(rate)
             self.cfg_adc_filter_form.recorded_sampling_rate_reading_lbl.setText(f"{rate:.2f}")
         except Exception as e:
             logging.error(f"Params tree cannot be updated. Data:{report}", exc_info=True)

pykirdy/ui/config_adc_filter_form.ui

@@ -41,14 +41,14 @@
       <item>
        <widget class="QLabel" name="label_4">
         <property name="text">
-         <string>Values</string>
+         <string>Value</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QLabel" name="label_5">
         <property name="text">
-         <string>Current Settings</string>
+         <string>Readings</string>
         </property>
        </widget>
       </item>

pykirdy/ui/config_pd_mon_form.ui

@@ -134,14 +134,14 @@
         <item>
          <widget class="QLabel" name="label_2">
           <property name="text">
-           <string> Values</string>
+           <string> Value</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="label">
           <property name="text">
-           <string>Current Settings</string>
+           <string>Reading</string>
           </property>
          </widget>
         </item>
@@ -293,14 +293,14 @@
         <item>
          <widget class="QLabel" name="label_3">
           <property name="text">
-           <string> Values</string>
+           <string> Value</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QLabel" name="label_4">
           <property name="text">
-           <string>Current Settings</string>
+           <string>Reading</string>
           </property>
          </widget>
         </item>
@@ -395,7 +395,7 @@
         <item>
          <widget class="QPushButton" name="apply_pwr_limit_max_btn">
           <property name="text">
-           <string>Apply Max Pwr Limit</string>
+           <string>Apply Max</string>
           </property>
          </widget>
         </item>

pykirdy/ui/conn_settings_form.ui

@@ -258,7 +258,7 @@
        </size>
       </property>
       <property name="text">
-       <string>1550</string>
+       <string>1337</string>
       </property>
       <property name="maxLength">
        <number>5</number>

pykirdy/ui/kirdy_qt.ui

@@ -78,11 +78,10 @@
              <font>
               <pointsize>14</pointsize>
               <bold>true</bold>
-              <underline>false</underline>
              </font>
             </property>
             <property name="text">
-             <string>  Laser Diode  </string>
+             <string>  Laser Diode</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
@@ -93,27 +92,23 @@
            </widget>
           </item>
           <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_3">
-            <item>
-             <widget class="QLabel" name="ld_status">
-              <property name="enabled">
-               <bool>false</bool>
-              </property>
-              <property name="font">
-               <font>
-                <pointsize>12</pointsize>
-                <bold>true</bold>
-               </font>
-              </property>
-              <property name="styleSheet">
-               <string notr="true"/>
-              </property>
-              <property name="text">
-               <string>     Status:    Power Off</string>
-              </property>
-             </widget>
-            </item>
-           </layout>
+           <widget class="ParameterTree" name="ld_status" native="true">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>57</height>
+             </size>
+            </property>
+           </widget>
           </item>
           <item>
            <widget class="ParameterTree" name="ld_tree" native="true">
@@ -171,11 +166,10 @@
              <font>
               <pointsize>14</pointsize>
               <bold>true</bold>
-              <underline>false</underline>
              </font>
             </property>
             <property name="text">
-             <string>  Thermostat  </string>
+             <string>  Thermostat</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
@@ -186,27 +180,23 @@
            </widget>
           </item>
           <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_5">
-            <item>
-             <widget class="QLabel" name="tec_status">
-              <property name="enabled">
-               <bool>false</bool>
-              </property>
-              <property name="font">
-               <font>
-                <pointsize>12</pointsize>
-                <bold>true</bold>
-               </font>
-              </property>
-              <property name="styleSheet">
-               <string notr="true"/>
-              </property>
-              <property name="text">
-               <string>     Status:    Power Off</string>
-              </property>
-             </widget>
-            </item>
-           </layout>
+           <widget class="ParameterTree" name="tec_status" native="true">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>57</height>
+             </size>
+            </property>
+           </widget>
           </item>
           <item>
            <widget class="ParameterTree" name="tec_tree" native="true">

pykirdy/ui/mainwindow.qss

@@ -3,5 +3,4 @@ ParameterTree:disabled { color: gray }
 QToolButton:disabled { color: gray }
 QDoubleSpinBox:disabled { color: gray }
 QCheckBox:disabled { color: gray }
-QMenu:disabled { color: gray }
-QLabel:disabled { color: gray }
+QMenu:disabled { color: gray }

pykirdy/ui/ui_config_adc_filter_form.py

@@ -0,0 +1,131 @@
+# Form implementation generated from reading ui file 'config_adc_filter_form.ui'
+#
+# Created by: PyQt6 UI code generator 6.6.0
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic6 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+
+class Ui_Cfg_Adc_Filter_Form(object):
+    def setupUi(self, Cfg_Adc_Filter_Form):
+        Cfg_Adc_Filter_Form.setObjectName("Cfg_Adc_Filter_Form")
+        Cfg_Adc_Filter_Form.resize(786, 303)
+        self.verticalLayoutWidget = QtWidgets.QWidget(parent=Cfg_Adc_Filter_Form)
+        self.verticalLayoutWidget.setGeometry(QtCore.QRect(20, 20, 731, 251))
+        self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
+        self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
+        self.verticalLayout.setContentsMargins(0, 0, 0, 0)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.horizontalLayout = QtWidgets.QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.horizontalLayout.addItem(spacerItem)
+        self.label_4 = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.label_4.setObjectName("label_4")
+        self.horizontalLayout.addWidget(self.label_4)
+        self.label_5 = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.label_5.setObjectName("label_5")
+        self.horizontalLayout.addWidget(self.label_5)
+        self.horizontalLayout.setStretch(0, 3)
+        self.horizontalLayout.setStretch(1, 4)
+        self.horizontalLayout.setStretch(2, 4)
+        self.verticalLayout.addLayout(self.horizontalLayout)
+        self.filter_type_layout = QtWidgets.QHBoxLayout()
+        self.filter_type_layout.setObjectName("filter_type_layout")
+        self.filter_type_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.filter_type_lbl.setObjectName("filter_type_lbl")
+        self.filter_type_layout.addWidget(self.filter_type_lbl)
+        self.filter_type_cbox = QtWidgets.QComboBox(parent=self.verticalLayoutWidget)
+        self.filter_type_cbox.setEditable(False)
+        self.filter_type_cbox.setObjectName("filter_type_cbox")
+        self.filter_type_layout.addWidget(self.filter_type_cbox)
+        self.filter_type_reading_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.filter_type_reading_lbl.setObjectName("filter_type_reading_lbl")
+        self.filter_type_layout.addWidget(self.filter_type_reading_lbl)
+        self.filter_type_layout.setStretch(0, 3)
+        self.filter_type_layout.setStretch(1, 4)
+        self.filter_type_layout.setStretch(2, 4)
+        self.verticalLayout.addLayout(self.filter_type_layout)
+        self.filter_sampling_rate_layout = QtWidgets.QHBoxLayout()
+        self.filter_sampling_rate_layout.setObjectName("filter_sampling_rate_layout")
+        self.filter_sampling_rate_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.filter_sampling_rate_lbl.setObjectName("filter_sampling_rate_lbl")
+        self.filter_sampling_rate_layout.addWidget(self.filter_sampling_rate_lbl)
+        self.filter_sampling_rate_cbox = QtWidgets.QComboBox(parent=self.verticalLayoutWidget)
+        self.filter_sampling_rate_cbox.setObjectName("filter_sampling_rate_cbox")
+        self.filter_sampling_rate_layout.addWidget(self.filter_sampling_rate_cbox)
+        self.fine_filter_sampling_rate_spinbox = QtWidgets.QDoubleSpinBox(parent=self.verticalLayoutWidget)
+        self.fine_filter_sampling_rate_spinbox.setMaximum(1000.0)
+        self.fine_filter_sampling_rate_spinbox.setProperty("value", 16.67)
+        self.fine_filter_sampling_rate_spinbox.setObjectName("fine_filter_sampling_rate_spinbox")
+        self.filter_sampling_rate_layout.addWidget(self.fine_filter_sampling_rate_spinbox)
+        self.filter_sampling_rate_reading_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.filter_sampling_rate_reading_lbl.setObjectName("filter_sampling_rate_reading_lbl")
+        self.filter_sampling_rate_layout.addWidget(self.filter_sampling_rate_reading_lbl)
+        self.filter_sampling_rate_layout.setStretch(0, 3)
+        self.filter_sampling_rate_layout.setStretch(1, 4)
+        self.filter_sampling_rate_layout.setStretch(2, 4)
+        self.filter_sampling_rate_layout.setStretch(3, 4)
+        self.verticalLayout.addLayout(self.filter_sampling_rate_layout)
+        self.recorded_sampling_rate_layout = QtWidgets.QHBoxLayout()
+        self.recorded_sampling_rate_layout.setObjectName("recorded_sampling_rate_layout")
+        self.recorded_sampling_rate_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.recorded_sampling_rate_lbl.setObjectName("recorded_sampling_rate_lbl")
+        self.recorded_sampling_rate_layout.addWidget(self.recorded_sampling_rate_lbl)
+        spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.recorded_sampling_rate_layout.addItem(spacerItem1)
+        self.recorded_sampling_rate_reading_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget)
+        self.recorded_sampling_rate_reading_lbl.setObjectName("recorded_sampling_rate_reading_lbl")
+        self.recorded_sampling_rate_layout.addWidget(self.recorded_sampling_rate_reading_lbl)
+        self.recorded_sampling_rate_layout.setStretch(0, 3)
+        self.recorded_sampling_rate_layout.setStretch(1, 4)
+        self.recorded_sampling_rate_layout.setStretch(2, 4)
+        self.verticalLayout.addLayout(self.recorded_sampling_rate_layout)
+        self.apply_btn_layout = QtWidgets.QHBoxLayout()
+        self.apply_btn_layout.setObjectName("apply_btn_layout")
+        spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.apply_btn_layout.addItem(spacerItem2)
+        self.apply_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget)
+        self.apply_btn.setObjectName("apply_btn")
+        self.apply_btn_layout.addWidget(self.apply_btn)
+        spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.apply_btn_layout.addItem(spacerItem3)
+        self.close_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget)
+        self.close_btn.setObjectName("close_btn")
+        self.apply_btn_layout.addWidget(self.close_btn)
+        self.apply_btn_layout.setStretch(0, 3)
+        self.apply_btn_layout.setStretch(1, 2)
+        self.apply_btn_layout.setStretch(2, 3)
+        self.apply_btn_layout.setStretch(3, 2)
+        self.verticalLayout.addLayout(self.apply_btn_layout)
+
+        self.retranslateUi(Cfg_Adc_Filter_Form)
+        self.close_btn.clicked.connect(Cfg_Adc_Filter_Form.accept) # type: ignore
+        QtCore.QMetaObject.connectSlotsByName(Cfg_Adc_Filter_Form)
+
+    def retranslateUi(self, Cfg_Adc_Filter_Form):
+        _translate = QtCore.QCoreApplication.translate
+        Cfg_Adc_Filter_Form.setWindowTitle(_translate("Cfg_Adc_Filter_Form", "Config Temperature ADC Filter"))
+        self.label_4.setText(_translate("Cfg_Adc_Filter_Form", "Value"))
+        self.label_5.setText(_translate("Cfg_Adc_Filter_Form", "Readings"))
+        self.filter_type_lbl.setText(_translate("Cfg_Adc_Filter_Form", "Filter Type"))
+        self.filter_type_reading_lbl.setText(_translate("Cfg_Adc_Filter_Form", "Sinc5Sinc1With50hz60HzRejection"))
+        self.filter_sampling_rate_lbl.setText(_translate("Cfg_Adc_Filter_Form", "Filter Sampling Rate"))
+        self.filter_sampling_rate_reading_lbl.setText(_translate("Cfg_Adc_Filter_Form", "F16SPS"))
+        self.recorded_sampling_rate_lbl.setText(_translate("Cfg_Adc_Filter_Form", "Recorded Sampling Rate"))
+        self.recorded_sampling_rate_reading_lbl.setText(_translate("Cfg_Adc_Filter_Form", "16.67"))
+        self.apply_btn.setText(_translate("Cfg_Adc_Filter_Form", "Apply"))
+        self.close_btn.setText(_translate("Cfg_Adc_Filter_Form", "Close"))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    Cfg_Adc_Filter_Form = QtWidgets.QDialog()
+    ui = Ui_Cfg_Adc_Filter_Form()
+    ui.setupUi(Cfg_Adc_Filter_Form)
+    Cfg_Adc_Filter_Form.show()
+    sys.exit(app.exec())

pykirdy/ui/ui_config_pd_mon_form.py

@@ -0,0 +1,295 @@
+# Form implementation generated from reading ui file 'config_pd_mon_form.ui'
+#
+# Created by: PyQt6 UI code generator 6.6.0
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic6 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+
+class Ui_Cfg_Pd_Mon_Form(object):
+    def setupUi(self, Cfg_Pd_Mon_Form):
+        Cfg_Pd_Mon_Form.setObjectName("Cfg_Pd_Mon_Form")
+        Cfg_Pd_Mon_Form.resize(500, 520)
+        Cfg_Pd_Mon_Form.setMinimumSize(QtCore.QSize(500, 520))
+        Cfg_Pd_Mon_Form.setMaximumSize(QtCore.QSize(500, 520))
+        self.verticalLayoutWidget_2 = QtWidgets.QWidget(parent=Cfg_Pd_Mon_Form)
+        self.verticalLayoutWidget_2.setGeometry(QtCore.QRect(10, 10, 481, 500))
+        self.verticalLayoutWidget_2.setObjectName("verticalLayoutWidget_2")
+        self.cfg_pd_mon_form_layout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget_2)
+        self.cfg_pd_mon_form_layout.setContentsMargins(0, 0, 0, 0)
+        self.cfg_pd_mon_form_layout.setObjectName("cfg_pd_mon_form_layout")
+        self.title_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(22)
+        self.title_lbl.setFont(font)
+        self.title_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.title_lbl.setObjectName("title_lbl")
+        self.cfg_pd_mon_form_layout.addWidget(self.title_lbl)
+        self.pwr_off_layout = QtWidgets.QHBoxLayout()
+        self.pwr_off_layout.setSizeConstraint(QtWidgets.QLayout.SizeConstraint.SetDefaultConstraint)
+        self.pwr_off_layout.setSpacing(12)
+        self.pwr_off_layout.setObjectName("pwr_off_layout")
+        self.pwr_off_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(14)
+        self.pwr_off_lbl.setFont(font)
+        self.pwr_off_lbl.setObjectName("pwr_off_lbl")
+        self.pwr_off_layout.addWidget(self.pwr_off_lbl)
+        self.pwr_off_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.pwr_off_btn.setObjectName("pwr_off_btn")
+        self.pwr_off_layout.addWidget(self.pwr_off_btn)
+        self.pwr_off_layout.setStretch(0, 5)
+        self.pwr_off_layout.setStretch(1, 4)
+        self.cfg_pd_mon_form_layout.addLayout(self.pwr_off_layout)
+        self.rst_ld_pwr_limit_layout = QtWidgets.QHBoxLayout()
+        self.rst_ld_pwr_limit_layout.setObjectName("rst_ld_pwr_limit_layout")
+        self.rst_ld_pwr_limit_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(14)
+        self.rst_ld_pwr_limit_lbl.setFont(font)
+        self.rst_ld_pwr_limit_lbl.setObjectName("rst_ld_pwr_limit_lbl")
+        self.rst_ld_pwr_limit_layout.addWidget(self.rst_ld_pwr_limit_lbl)
+        self.rst_ld_pwr_limit_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.rst_ld_pwr_limit_btn.setObjectName("rst_ld_pwr_limit_btn")
+        self.rst_ld_pwr_limit_layout.addWidget(self.rst_ld_pwr_limit_btn)
+        self.rst_ld_pwr_limit_layout.setStretch(0, 5)
+        self.rst_ld_pwr_limit_layout.setStretch(1, 4)
+        self.cfg_pd_mon_form_layout.addLayout(self.rst_ld_pwr_limit_layout)
+        self.cfg_pd_params_layout = QtWidgets.QVBoxLayout()
+        self.cfg_pd_params_layout.setObjectName("cfg_pd_params_layout")
+        self.cfg_pd_params_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(14)
+        self.cfg_pd_params_lbl.setFont(font)
+        self.cfg_pd_params_lbl.setObjectName("cfg_pd_params_lbl")
+        self.cfg_pd_params_layout.addWidget(self.cfg_pd_params_lbl)
+        self.horizontalLayout = QtWidgets.QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.horizontalLayout.addItem(spacerItem)
+        self.label_2 = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.label_2.setObjectName("label_2")
+        self.horizontalLayout.addWidget(self.label_2)
+        self.label = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.label.setObjectName("label")
+        self.horizontalLayout.addWidget(self.label)
+        self.horizontalLayout.setStretch(0, 5)
+        self.horizontalLayout.setStretch(1, 2)
+        self.horizontalLayout.setStretch(2, 2)
+        self.cfg_pd_params_layout.addLayout(self.horizontalLayout)
+        self.cfg_responsitivity_layout = QtWidgets.QHBoxLayout()
+        self.cfg_responsitivity_layout.setObjectName("cfg_responsitivity_layout")
+        self.cfg_responsitivity_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.cfg_responsitivity_lbl.sizePolicy().hasHeightForWidth())
+        self.cfg_responsitivity_lbl.setSizePolicy(sizePolicy)
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.cfg_responsitivity_lbl.setFont(font)
+        self.cfg_responsitivity_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.cfg_responsitivity_lbl.setObjectName("cfg_responsitivity_lbl")
+        self.cfg_responsitivity_layout.addWidget(self.cfg_responsitivity_lbl)
+        self.cfg_responsitivity_spinbox = QtWidgets.QDoubleSpinBox(parent=self.verticalLayoutWidget_2)
+        self.cfg_responsitivity_spinbox.setSuffix("")
+        self.cfg_responsitivity_spinbox.setDecimals(4)
+        self.cfg_responsitivity_spinbox.setMaximum(1000.0)
+        self.cfg_responsitivity_spinbox.setSingleStep(0.001)
+        self.cfg_responsitivity_spinbox.setObjectName("cfg_responsitivity_spinbox")
+        self.cfg_responsitivity_layout.addWidget(self.cfg_responsitivity_spinbox)
+        self.cfg_responsitivity_reading = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.cfg_responsitivity_reading.sizePolicy().hasHeightForWidth())
+        self.cfg_responsitivity_reading.setSizePolicy(sizePolicy)
+        self.cfg_responsitivity_reading.setObjectName("cfg_responsitivity_reading")
+        self.cfg_responsitivity_layout.addWidget(self.cfg_responsitivity_reading)
+        self.cfg_responsitivity_layout.setStretch(0, 5)
+        self.cfg_responsitivity_layout.setStretch(1, 2)
+        self.cfg_responsitivity_layout.setStretch(2, 2)
+        self.cfg_pd_params_layout.addLayout(self.cfg_responsitivity_layout)
+        self.cfg_dark_current_layout = QtWidgets.QHBoxLayout()
+        self.cfg_dark_current_layout.setObjectName("cfg_dark_current_layout")
+        self.cfg_dark_current_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.cfg_dark_current_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.cfg_dark_current_lbl.setObjectName("cfg_dark_current_lbl")
+        self.cfg_dark_current_layout.addWidget(self.cfg_dark_current_lbl)
+        self.cfg_dark_current_spinbox = QtWidgets.QDoubleSpinBox(parent=self.verticalLayoutWidget_2)
+        self.cfg_dark_current_spinbox.setDecimals(4)
+        self.cfg_dark_current_spinbox.setSingleStep(0.001)
+        self.cfg_dark_current_spinbox.setObjectName("cfg_dark_current_spinbox")
+        self.cfg_dark_current_layout.addWidget(self.cfg_dark_current_spinbox)
+        self.cfg_dark_current_reading = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.cfg_dark_current_reading.setObjectName("cfg_dark_current_reading")
+        self.cfg_dark_current_layout.addWidget(self.cfg_dark_current_reading)
+        self.cfg_dark_current_layout.setStretch(0, 5)
+        self.cfg_dark_current_layout.setStretch(1, 2)
+        self.cfg_dark_current_layout.setStretch(2, 2)
+        self.cfg_pd_params_layout.addLayout(self.cfg_dark_current_layout)
+        self.apply_pd_params_layout = QtWidgets.QHBoxLayout()
+        self.apply_pd_params_layout.setSpacing(12)
+        self.apply_pd_params_layout.setObjectName("apply_pd_params_layout")
+        spacerItem1 = QtWidgets.QSpacerItem(10, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.apply_pd_params_layout.addItem(spacerItem1)
+        self.apply_pd_params_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.apply_pd_params_btn.setObjectName("apply_pd_params_btn")
+        self.apply_pd_params_layout.addWidget(self.apply_pd_params_btn)
+        self.apply_pd_params_layout.setStretch(0, 5)
+        self.apply_pd_params_layout.setStretch(1, 4)
+        self.cfg_pd_params_layout.addLayout(self.apply_pd_params_layout)
+        self.cfg_pd_mon_form_layout.addLayout(self.cfg_pd_params_layout)
+        self.cfg_pwr_limit_layout = QtWidgets.QVBoxLayout()
+        self.cfg_pwr_limit_layout.setObjectName("cfg_pwr_limit_layout")
+        self.cfg_pd_pwr_limit_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(14)
+        self.cfg_pd_pwr_limit_lbl.setFont(font)
+        self.cfg_pd_pwr_limit_lbl.setObjectName("cfg_pd_pwr_limit_lbl")
+        self.cfg_pwr_limit_layout.addWidget(self.cfg_pd_pwr_limit_lbl)
+        self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
+        self.horizontalLayout_2.setObjectName("horizontalLayout_2")
+        spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.horizontalLayout_2.addItem(spacerItem2)
+        self.label_3 = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.label_3.setObjectName("label_3")
+        self.horizontalLayout_2.addWidget(self.label_3)
+        self.label_4 = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.label_4.setObjectName("label_4")
+        self.horizontalLayout_2.addWidget(self.label_4)
+        self.horizontalLayout_2.setStretch(0, 5)
+        self.horizontalLayout_2.setStretch(1, 2)
+        self.horizontalLayout_2.setStretch(2, 2)
+        self.cfg_pwr_limit_layout.addLayout(self.horizontalLayout_2)
+        self.pwr_limit_layout = QtWidgets.QHBoxLayout()
+        self.pwr_limit_layout.setObjectName("pwr_limit_layout")
+        self.cfg_pwr_limit_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.cfg_pwr_limit_lbl.setFont(font)
+        self.cfg_pwr_limit_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.cfg_pwr_limit_lbl.setObjectName("cfg_pwr_limit_lbl")
+        self.pwr_limit_layout.addWidget(self.cfg_pwr_limit_lbl)
+        self.cfg_pwr_limit_spinbox = QtWidgets.QDoubleSpinBox(parent=self.verticalLayoutWidget_2)
+        self.cfg_pwr_limit_spinbox.setDecimals(4)
+        self.cfg_pwr_limit_spinbox.setSingleStep(0.001)
+        self.cfg_pwr_limit_spinbox.setObjectName("cfg_pwr_limit_spinbox")
+        self.pwr_limit_layout.addWidget(self.cfg_pwr_limit_spinbox)
+        self.cfg_pwr_limit_reading = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.cfg_pwr_limit_reading.setObjectName("cfg_pwr_limit_reading")
+        self.pwr_limit_layout.addWidget(self.cfg_pwr_limit_reading)
+        self.pwr_limit_layout.setStretch(0, 5)
+        self.pwr_limit_layout.setStretch(1, 2)
+        self.pwr_limit_layout.setStretch(2, 2)
+        self.cfg_pwr_limit_layout.addLayout(self.pwr_limit_layout)
+        self.settable_pwr_range_layout = QtWidgets.QHBoxLayout()
+        self.settable_pwr_range_layout.setSpacing(12)
+        self.settable_pwr_range_layout.setObjectName("settable_pwr_range_layout")
+        self.settable_pwr_range_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.settable_pwr_range_lbl.setFont(font)
+        self.settable_pwr_range_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.settable_pwr_range_lbl.setObjectName("settable_pwr_range_lbl")
+        self.settable_pwr_range_layout.addWidget(self.settable_pwr_range_lbl)
+        self.settable_pwr_range_display_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        self.settable_pwr_range_display_lbl.setMinimumSize(QtCore.QSize(0, 28))
+        self.settable_pwr_range_display_lbl.setObjectName("settable_pwr_range_display_lbl")
+        self.settable_pwr_range_layout.addWidget(self.settable_pwr_range_display_lbl)
+        self.settable_pwr_range_layout.setStretch(0, 5)
+        self.settable_pwr_range_layout.setStretch(1, 4)
+        self.cfg_pwr_limit_layout.addLayout(self.settable_pwr_range_layout)
+        self.apply_pwr_limit_layout = QtWidgets.QHBoxLayout()
+        self.apply_pwr_limit_layout.setObjectName("apply_pwr_limit_layout")
+        spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.apply_pwr_limit_layout.addItem(spacerItem3)
+        self.apply_pwr_limit_max_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.apply_pwr_limit_max_btn.setObjectName("apply_pwr_limit_max_btn")
+        self.apply_pwr_limit_layout.addWidget(self.apply_pwr_limit_max_btn)
+        self.apply_pwr_limit_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.apply_pwr_limit_btn.setObjectName("apply_pwr_limit_btn")
+        self.apply_pwr_limit_layout.addWidget(self.apply_pwr_limit_btn)
+        self.apply_pwr_limit_layout.setStretch(0, 2)
+        self.apply_pwr_limit_layout.setStretch(1, 3)
+        self.apply_pwr_limit_layout.setStretch(2, 4)
+        self.cfg_pwr_limit_layout.addLayout(self.apply_pwr_limit_layout)
+        self.cfg_pd_mon_form_layout.addLayout(self.cfg_pwr_limit_layout)
+        self.pwr_on_layout = QtWidgets.QHBoxLayout()
+        self.pwr_on_layout.setSpacing(12)
+        self.pwr_on_layout.setObjectName("pwr_on_layout")
+        self.pwr_on_lbl = QtWidgets.QLabel(parent=self.verticalLayoutWidget_2)
+        font = QtGui.QFont()
+        font.setPointSize(14)
+        self.pwr_on_lbl.setFont(font)
+        self.pwr_on_lbl.setObjectName("pwr_on_lbl")
+        self.pwr_on_layout.addWidget(self.pwr_on_lbl)
+        self.pwr_on_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.pwr_on_btn.setObjectName("pwr_on_btn")
+        self.pwr_on_layout.addWidget(self.pwr_on_btn)
+        self.pwr_on_layout.setStretch(0, 5)
+        self.pwr_on_layout.setStretch(1, 4)
+        self.cfg_pd_mon_form_layout.addLayout(self.pwr_on_layout)
+        self.close_btn_layout = QtWidgets.QHBoxLayout()
+        self.close_btn_layout.setSpacing(12)
+        self.close_btn_layout.setObjectName("close_btn_layout")
+        spacerItem4 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.close_btn_layout.addItem(spacerItem4)
+        self.close_btn = QtWidgets.QPushButton(parent=self.verticalLayoutWidget_2)
+        self.close_btn.setObjectName("close_btn")
+        self.close_btn_layout.addWidget(self.close_btn)
+        self.close_btn_layout.setStretch(0, 5)
+        self.close_btn_layout.setStretch(1, 4)
+        self.cfg_pd_mon_form_layout.addLayout(self.close_btn_layout)
+        self.cfg_pd_mon_form_layout.setStretch(1, 2)
+        self.cfg_pd_mon_form_layout.setStretch(2, 2)
+        self.cfg_pd_mon_form_layout.setStretch(3, 2)
+        self.cfg_pd_mon_form_layout.setStretch(4, 2)
+        self.cfg_pd_mon_form_layout.setStretch(5, 2)
+        self.cfg_pd_mon_form_layout.setStretch(6, 1)
+
+        self.retranslateUi(Cfg_Pd_Mon_Form)
+        self.close_btn.clicked.connect(Cfg_Pd_Mon_Form.accept) # type: ignore
+        QtCore.QMetaObject.connectSlotsByName(Cfg_Pd_Mon_Form)
+
+    def retranslateUi(self, Cfg_Pd_Mon_Form):
+        _translate = QtCore.QCoreApplication.translate
+        Cfg_Pd_Mon_Form.setWindowTitle(_translate("Cfg_Pd_Mon_Form", "config_pd_mon_form"))
+        self.title_lbl.setText(_translate("Cfg_Pd_Mon_Form", "Configure Photodiode Monitor"))
+        self.pwr_off_lbl.setText(_translate("Cfg_Pd_Mon_Form", "  Step 1: Turn off Laser Power"))
+        self.pwr_off_btn.setText(_translate("Cfg_Pd_Mon_Form", "Power Off"))
+        self.rst_ld_pwr_limit_lbl.setText(_translate("Cfg_Pd_Mon_Form", "  Step 2: Reset Ld Pwr Limit to 0"))
+        self.rst_ld_pwr_limit_btn.setText(_translate("Cfg_Pd_Mon_Form", "Reset Ld Pwr Limit"))
+        self.cfg_pd_params_lbl.setText(_translate("Cfg_Pd_Mon_Form", "  Step 3: Configure Photodiode Parameters"))
+        self.label_2.setText(_translate("Cfg_Pd_Mon_Form", " Value"))
+        self.label.setText(_translate("Cfg_Pd_Mon_Form", "Reading"))
+        self.cfg_responsitivity_lbl.setText(_translate("Cfg_Pd_Mon_Form", "Responsitivity: "))
+        self.cfg_responsitivity_reading.setText(_translate("Cfg_Pd_Mon_Form", "0.0000"))
+        self.cfg_dark_current_lbl.setText(_translate("Cfg_Pd_Mon_Form", "Dark Current: "))
+        self.cfg_dark_current_reading.setText(_translate("Cfg_Pd_Mon_Form", "0.0000"))
+        self.apply_pd_params_btn.setText(_translate("Cfg_Pd_Mon_Form", "Apply"))
+        self.cfg_pd_pwr_limit_lbl.setText(_translate("Cfg_Pd_Mon_Form", "  Step 4: Configure Laser Diode Power Limit"))
+        self.label_3.setText(_translate("Cfg_Pd_Mon_Form", " Value"))
+        self.label_4.setText(_translate("Cfg_Pd_Mon_Form", "Reading"))
+        self.cfg_pwr_limit_lbl.setText(_translate("Cfg_Pd_Mon_Form", "Power Limit:"))
+        self.cfg_pwr_limit_reading.setText(_translate("Cfg_Pd_Mon_Form", "0.0000"))
+        self.settable_pwr_range_lbl.setText(_translate("Cfg_Pd_Mon_Form", "Settable Power Range:"))
+        self.settable_pwr_range_display_lbl.setText(_translate("Cfg_Pd_Mon_Form", "( Power Range )"))
+        self.apply_pwr_limit_max_btn.setText(_translate("Cfg_Pd_Mon_Form", "Apply Max"))
+        self.apply_pwr_limit_btn.setText(_translate("Cfg_Pd_Mon_Form", "Apply"))
+        self.pwr_on_lbl.setText(_translate("Cfg_Pd_Mon_Form", "  Step 5: Turn On Laser Power"))
+        self.pwr_on_btn.setText(_translate("Cfg_Pd_Mon_Form", "Clear Alarm and Power On"))
+        self.close_btn.setText(_translate("Cfg_Pd_Mon_Form", "Close"))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    Cfg_Pd_Mon_Form = QtWidgets.QDialog()
+    ui = Ui_Cfg_Pd_Mon_Form()
+    ui.setupUi(Cfg_Pd_Mon_Form)
+    Cfg_Pd_Mon_Form.show()
+    sys.exit(app.exec())

pykirdy/ui/ui_conn_settings_form.py

@@ -0,0 +1,161 @@
+# Form implementation generated from reading ui file 'conn_settings_form.ui'
+#
+# Created by: PyQt6 UI code generator 6.6.0
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic6 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+
+class Ui_Conn_Settings_Form(object):
+    def setupUi(self, Conn_Settings_Form):
+        Conn_Settings_Form.setObjectName("Conn_Settings_Form")
+        Conn_Settings_Form.resize(415, 145)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(Conn_Settings_Form.sizePolicy().hasHeightForWidth())
+        Conn_Settings_Form.setSizePolicy(sizePolicy)
+        Conn_Settings_Form.setMinimumSize(QtCore.QSize(415, 145))
+        Conn_Settings_Form.setMaximumSize(QtCore.QSize(415, 145))
+        self.horizontalLayoutWidget = QtWidgets.QWidget(parent=Conn_Settings_Form)
+        self.horizontalLayoutWidget.setGeometry(QtCore.QRect(20, 10, 371, 41))
+        self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
+        self.ip_addr_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget)
+        self.ip_addr_layout.setContentsMargins(0, 0, 0, 0)
+        self.ip_addr_layout.setObjectName("ip_addr_layout")
+        self.ip_addr_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.ip_addr_label.sizePolicy().hasHeightForWidth())
+        self.ip_addr_label.setSizePolicy(sizePolicy)
+        self.ip_addr_label.setMaximumSize(QtCore.QSize(120, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.ip_addr_label.setFont(font)
+        self.ip_addr_label.setLayoutDirection(QtCore.Qt.LayoutDirection.LeftToRight)
+        self.ip_addr_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.ip_addr_label.setObjectName("ip_addr_label")
+        self.ip_addr_layout.addWidget(self.ip_addr_label)
+        self.addr_in_0 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_0.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_0.setMaxLength(3)
+        self.addr_in_0.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_0.setObjectName("addr_in_0")
+        self.ip_addr_layout.addWidget(self.addr_in_0)
+        self.dot_0_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_0_label.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_0_label.setFont(font)
+        self.dot_0_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_0_label.setObjectName("dot_0_label")
+        self.ip_addr_layout.addWidget(self.dot_0_label)
+        self.addr_in_1 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_1.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_1.setMaxLength(3)
+        self.addr_in_1.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_1.setObjectName("addr_in_1")
+        self.ip_addr_layout.addWidget(self.addr_in_1)
+        self.dot_1_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_1_label.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_1_label.setFont(font)
+        self.dot_1_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_1_label.setObjectName("dot_1_label")
+        self.ip_addr_layout.addWidget(self.dot_1_label)
+        self.addr_in_2 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_2.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_2.setMaxLength(3)
+        self.addr_in_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_2.setObjectName("addr_in_2")
+        self.ip_addr_layout.addWidget(self.addr_in_2)
+        self.dot_2_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_2_label.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_2_label.setFont(font)
+        self.dot_2_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_2_label.setObjectName("dot_2_label")
+        self.ip_addr_layout.addWidget(self.dot_2_label)
+        self.addr_in_3 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_3.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_3.setMaxLength(3)
+        self.addr_in_3.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_3.setObjectName("addr_in_3")
+        self.ip_addr_layout.addWidget(self.addr_in_3)
+        self.horizontalLayoutWidget_2 = QtWidgets.QWidget(parent=Conn_Settings_Form)
+        self.horizontalLayoutWidget_2.setGeometry(QtCore.QRect(20, 50, 371, 41))
+        self.horizontalLayoutWidget_2.setObjectName("horizontalLayoutWidget_2")
+        self.port_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget_2)
+        self.port_layout.setContentsMargins(0, 0, 0, 0)
+        self.port_layout.setObjectName("port_layout")
+        self.port_no_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_2)
+        self.port_no_label.setMaximumSize(QtCore.QSize(97, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.port_no_label.setFont(font)
+        self.port_no_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.port_no_label.setObjectName("port_no_label")
+        self.port_layout.addWidget(self.port_no_label)
+        self.port_in = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_2)
+        self.port_in.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.port_in.setMaxLength(5)
+        self.port_in.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.port_in.setObjectName("port_in")
+        self.port_layout.addWidget(self.port_in)
+        spacerItem = QtWidgets.QSpacerItem(50, 20, QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.port_layout.addItem(spacerItem)
+        self.port_layout.setStretch(0, 3)
+        self.port_layout.setStretch(2, 6)
+        self.horizontalLayoutWidget_4 = QtWidgets.QWidget(parent=Conn_Settings_Form)
+        self.horizontalLayoutWidget_4.setGeometry(QtCore.QRect(20, 90, 371, 47))
+        self.horizontalLayoutWidget_4.setObjectName("horizontalLayoutWidget_4")
+        self.buttons_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget_4)
+        self.buttons_layout.setContentsMargins(0, 0, 0, 0)
+        self.buttons_layout.setObjectName("buttons_layout")
+        spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.buttons_layout.addItem(spacerItem1)
+        self.connect_btn = QtWidgets.QPushButton(parent=self.horizontalLayoutWidget_4)
+        self.connect_btn.setObjectName("connect_btn")
+        self.buttons_layout.addWidget(self.connect_btn)
+        self.cancel_btn = QtWidgets.QPushButton(parent=self.horizontalLayoutWidget_4)
+        self.cancel_btn.setObjectName("cancel_btn")
+        self.buttons_layout.addWidget(self.cancel_btn)
+
+        self.retranslateUi(Conn_Settings_Form)
+        self.cancel_btn.clicked.connect(Conn_Settings_Form.reject) # type: ignore
+        self.connect_btn.clicked.connect(Conn_Settings_Form.accept) # type: ignore
+        QtCore.QMetaObject.connectSlotsByName(Conn_Settings_Form)
+        Conn_Settings_Form.setTabOrder(self.addr_in_0, self.addr_in_1)
+        Conn_Settings_Form.setTabOrder(self.addr_in_1, self.addr_in_2)
+        Conn_Settings_Form.setTabOrder(self.addr_in_2, self.addr_in_3)
+        Conn_Settings_Form.setTabOrder(self.addr_in_3, self.port_in)
+        Conn_Settings_Form.setTabOrder(self.port_in, self.connect_btn)
+        Conn_Settings_Form.setTabOrder(self.connect_btn, self.cancel_btn)
+
+    def retranslateUi(self, Conn_Settings_Form):
+        _translate = QtCore.QCoreApplication.translate
+        Conn_Settings_Form.setWindowTitle(_translate("Conn_Settings_Form", "Connection Settings"))
+        self.ip_addr_label.setText(_translate("Conn_Settings_Form", "IP Address:"))
+        self.addr_in_0.setText(_translate("Conn_Settings_Form", "192"))
+        self.dot_0_label.setText(_translate("Conn_Settings_Form", "."))
+        self.addr_in_1.setText(_translate("Conn_Settings_Form", "168"))
+        self.dot_1_label.setText(_translate("Conn_Settings_Form", "."))
+        self.addr_in_2.setText(_translate("Conn_Settings_Form", "1"))
+        self.dot_2_label.setText(_translate("Conn_Settings_Form", "."))
+        self.addr_in_3.setText(_translate("Conn_Settings_Form", "128"))
+        self.port_no_label.setText(_translate("Conn_Settings_Form", "Port:"))
+        self.port_in.setText(_translate("Conn_Settings_Form", "1337"))
+        self.connect_btn.setText(_translate("Conn_Settings_Form", "Connect"))
+        self.cancel_btn.setText(_translate("Conn_Settings_Form", "Cancel"))

pykirdy/ui/ui_update_network_settings_form.py

@@ -0,0 +1,264 @@
+# Form implementation generated from reading ui file 'update_network_settings_form.ui'
+#
+# Created by: PyQt6 UI code generator 6.6.0
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic6 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+
+class Ui_Update_Network_Settings_Form(object):
+    def setupUi(self, Update_Network_Settings_Form):
+        Update_Network_Settings_Form.setObjectName("Update_Network_Settings_Form")
+        Update_Network_Settings_Form.resize(415, 180)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(Update_Network_Settings_Form.sizePolicy().hasHeightForWidth())
+        Update_Network_Settings_Form.setSizePolicy(sizePolicy)
+        Update_Network_Settings_Form.setMinimumSize(QtCore.QSize(415, 180))
+        Update_Network_Settings_Form.setMaximumSize(QtCore.QSize(415, 180))
+        self.horizontalLayoutWidget = QtWidgets.QWidget(parent=Update_Network_Settings_Form)
+        self.horizontalLayoutWidget.setGeometry(QtCore.QRect(20, 10, 371, 41))
+        self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
+        self.ip_addr_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget)
+        self.ip_addr_layout.setContentsMargins(0, 0, 0, 0)
+        self.ip_addr_layout.setObjectName("ip_addr_layout")
+        self.ip_addr_label = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.ip_addr_label.sizePolicy().hasHeightForWidth())
+        self.ip_addr_label.setSizePolicy(sizePolicy)
+        self.ip_addr_label.setMaximumSize(QtCore.QSize(120, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.ip_addr_label.setFont(font)
+        self.ip_addr_label.setLayoutDirection(QtCore.Qt.LayoutDirection.LeftToRight)
+        self.ip_addr_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.ip_addr_label.setObjectName("ip_addr_label")
+        self.ip_addr_layout.addWidget(self.ip_addr_label)
+        self.addr_in_0 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_0.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_0.setMaxLength(3)
+        self.addr_in_0.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_0.setObjectName("addr_in_0")
+        self.ip_addr_layout.addWidget(self.addr_in_0)
+        self.dot_0_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_0_lbl.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_0_lbl.setFont(font)
+        self.dot_0_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_0_lbl.setObjectName("dot_0_lbl")
+        self.ip_addr_layout.addWidget(self.dot_0_lbl)
+        self.addr_in_1 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_1.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_1.setMaxLength(3)
+        self.addr_in_1.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_1.setObjectName("addr_in_1")
+        self.ip_addr_layout.addWidget(self.addr_in_1)
+        self.dot_1_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_1_lbl.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_1_lbl.setFont(font)
+        self.dot_1_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_1_lbl.setObjectName("dot_1_lbl")
+        self.ip_addr_layout.addWidget(self.dot_1_lbl)
+        self.addr_in_2 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_2.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_2.setMaxLength(3)
+        self.addr_in_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_2.setObjectName("addr_in_2")
+        self.ip_addr_layout.addWidget(self.addr_in_2)
+        self.dot_2_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget)
+        self.dot_2_lbl.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_2_lbl.setFont(font)
+        self.dot_2_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_2_lbl.setObjectName("dot_2_lbl")
+        self.ip_addr_layout.addWidget(self.dot_2_lbl)
+        self.addr_in_3 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget)
+        self.addr_in_3.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.addr_in_3.setMaxLength(3)
+        self.addr_in_3.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.addr_in_3.setObjectName("addr_in_3")
+        self.ip_addr_layout.addWidget(self.addr_in_3)
+        self.horizontalLayoutWidget_4 = QtWidgets.QWidget(parent=Update_Network_Settings_Form)
+        self.horizontalLayoutWidget_4.setGeometry(QtCore.QRect(20, 130, 371, 47))
+        self.horizontalLayoutWidget_4.setObjectName("horizontalLayoutWidget_4")
+        self.buttons_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget_4)
+        self.buttons_layout.setContentsMargins(0, 0, 0, 0)
+        self.buttons_layout.setObjectName("buttons_layout")
+        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.buttons_layout.addItem(spacerItem)
+        self.update_btn = QtWidgets.QPushButton(parent=self.horizontalLayoutWidget_4)
+        self.update_btn.setObjectName("update_btn")
+        self.buttons_layout.addWidget(self.update_btn)
+        self.cancel_btn = QtWidgets.QPushButton(parent=self.horizontalLayoutWidget_4)
+        self.cancel_btn.setObjectName("cancel_btn")
+        self.buttons_layout.addWidget(self.cancel_btn)
+        self.horizontalLayoutWidget_3 = QtWidgets.QWidget(parent=Update_Network_Settings_Form)
+        self.horizontalLayoutWidget_3.setGeometry(QtCore.QRect(20, 90, 371, 41))
+        self.horizontalLayoutWidget_3.setObjectName("horizontalLayoutWidget_3")
+        self.port_layout_2 = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget_3)
+        self.port_layout_2.setContentsMargins(0, 0, 0, 0)
+        self.port_layout_2.setSpacing(6)
+        self.port_layout_2.setObjectName("port_layout_2")
+        self.prefix_len_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_3)
+        self.prefix_len_lbl.setMaximumSize(QtCore.QSize(98, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.prefix_len_lbl.setFont(font)
+        self.prefix_len_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.prefix_len_lbl.setObjectName("prefix_len_lbl")
+        self.port_layout_2.addWidget(self.prefix_len_lbl)
+        self.prefix_len_in = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_3)
+        self.prefix_len_in.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.prefix_len_in.setMaxLength(2)
+        self.prefix_len_in.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.prefix_len_in.setObjectName("prefix_len_in")
+        self.port_layout_2.addWidget(self.prefix_len_in)
+        self.port_no_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_3)
+        self.port_no_lbl.setMinimumSize(QtCore.QSize(82, 0))
+        self.port_no_lbl.setMaximumSize(QtCore.QSize(50, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.port_no_lbl.setFont(font)
+        self.port_no_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.port_no_lbl.setObjectName("port_no_lbl")
+        self.port_layout_2.addWidget(self.port_no_lbl)
+        self.port_in = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_3)
+        self.port_in.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.port_in.setMaxLength(5)
+        self.port_in.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.port_in.setObjectName("port_in")
+        self.port_layout_2.addWidget(self.port_in)
+        spacerItem1 = QtWidgets.QSpacerItem(20, 20, QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Minimum)
+        self.port_layout_2.addItem(spacerItem1)
+        self.horizontalLayoutWidget_5 = QtWidgets.QWidget(parent=Update_Network_Settings_Form)
+        self.horizontalLayoutWidget_5.setGeometry(QtCore.QRect(20, 50, 371, 41))
+        self.horizontalLayoutWidget_5.setObjectName("horizontalLayoutWidget_5")
+        self.gateway_layout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget_5)
+        self.gateway_layout.setContentsMargins(0, 0, 0, 0)
+        self.gateway_layout.setObjectName("gateway_layout")
+        self.gateway_lbl = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_5)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.gateway_lbl.sizePolicy().hasHeightForWidth())
+        self.gateway_lbl.setSizePolicy(sizePolicy)
+        self.gateway_lbl.setMaximumSize(QtCore.QSize(120, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        self.gateway_lbl.setFont(font)
+        self.gateway_lbl.setLayoutDirection(QtCore.Qt.LayoutDirection.LeftToRight)
+        self.gateway_lbl.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight|QtCore.Qt.AlignmentFlag.AlignTrailing|QtCore.Qt.AlignmentFlag.AlignVCenter)
+        self.gateway_lbl.setObjectName("gateway_lbl")
+        self.gateway_layout.addWidget(self.gateway_lbl)
+        self.gateway_in_0 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_5)
+        self.gateway_in_0.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.gateway_in_0.setMaxLength(3)
+        self.gateway_in_0.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.gateway_in_0.setObjectName("gateway_in_0")
+        self.gateway_layout.addWidget(self.gateway_in_0)
+        self.dot_0_lbl_2 = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_5)
+        self.dot_0_lbl_2.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_0_lbl_2.setFont(font)
+        self.dot_0_lbl_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_0_lbl_2.setObjectName("dot_0_lbl_2")
+        self.gateway_layout.addWidget(self.dot_0_lbl_2)
+        self.gateway_in_1 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_5)
+        self.gateway_in_1.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.gateway_in_1.setMaxLength(3)
+        self.gateway_in_1.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.gateway_in_1.setObjectName("gateway_in_1")
+        self.gateway_layout.addWidget(self.gateway_in_1)
+        self.dot_1_lbl_2 = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_5)
+        self.dot_1_lbl_2.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_1_lbl_2.setFont(font)
+        self.dot_1_lbl_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_1_lbl_2.setObjectName("dot_1_lbl_2")
+        self.gateway_layout.addWidget(self.dot_1_lbl_2)
+        self.gateway_in_2 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_5)
+        self.gateway_in_2.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.gateway_in_2.setMaxLength(3)
+        self.gateway_in_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.gateway_in_2.setObjectName("gateway_in_2")
+        self.gateway_layout.addWidget(self.gateway_in_2)
+        self.dot_2_lbl_2 = QtWidgets.QLabel(parent=self.horizontalLayoutWidget_5)
+        self.dot_2_lbl_2.setMaximumSize(QtCore.QSize(10, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(False)
+        font.setKerning(True)
+        self.dot_2_lbl_2.setFont(font)
+        self.dot_2_lbl_2.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.dot_2_lbl_2.setObjectName("dot_2_lbl_2")
+        self.gateway_layout.addWidget(self.dot_2_lbl_2)
+        self.gateway_in_3 = QtWidgets.QLineEdit(parent=self.horizontalLayoutWidget_5)
+        self.gateway_in_3.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.gateway_in_3.setMaxLength(3)
+        self.gateway_in_3.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.gateway_in_3.setObjectName("gateway_in_3")
+        self.gateway_layout.addWidget(self.gateway_in_3)
+
+        self.retranslateUi(Update_Network_Settings_Form)
+        self.cancel_btn.clicked.connect(Update_Network_Settings_Form.reject) # type: ignore
+        self.update_btn.clicked.connect(Update_Network_Settings_Form.accept) # type: ignore
+        QtCore.QMetaObject.connectSlotsByName(Update_Network_Settings_Form)
+        Update_Network_Settings_Form.setTabOrder(self.addr_in_0, self.addr_in_1)
+        Update_Network_Settings_Form.setTabOrder(self.addr_in_1, self.addr_in_2)
+        Update_Network_Settings_Form.setTabOrder(self.addr_in_2, self.addr_in_3)
+        Update_Network_Settings_Form.setTabOrder(self.addr_in_3, self.gateway_in_0)
+        Update_Network_Settings_Form.setTabOrder(self.gateway_in_0, self.gateway_in_1)
+        Update_Network_Settings_Form.setTabOrder(self.gateway_in_1, self.gateway_in_2)
+        Update_Network_Settings_Form.setTabOrder(self.gateway_in_2, self.gateway_in_3)
+        Update_Network_Settings_Form.setTabOrder(self.gateway_in_3, self.prefix_len_in)
+        Update_Network_Settings_Form.setTabOrder(self.prefix_len_in, self.port_in)
+        Update_Network_Settings_Form.setTabOrder(self.port_in, self.update_btn)
+        Update_Network_Settings_Form.setTabOrder(self.update_btn, self.cancel_btn)
+
+    def retranslateUi(self, Update_Network_Settings_Form):
+        _translate = QtCore.QCoreApplication.translate
+        Update_Network_Settings_Form.setWindowTitle(_translate("Update_Network_Settings_Form", "Update Network Settings"))
+        self.ip_addr_label.setText(_translate("Update_Network_Settings_Form", "IP Address:"))
+        self.addr_in_0.setText(_translate("Update_Network_Settings_Form", "192"))
+        self.dot_0_lbl.setText(_translate("Update_Network_Settings_Form", "."))
+        self.addr_in_1.setText(_translate("Update_Network_Settings_Form", "168"))
+        self.dot_1_lbl.setText(_translate("Update_Network_Settings_Form", "."))
+        self.addr_in_2.setText(_translate("Update_Network_Settings_Form", "1"))
+        self.dot_2_lbl.setText(_translate("Update_Network_Settings_Form", "."))
+        self.addr_in_3.setText(_translate("Update_Network_Settings_Form", "128"))
+        self.update_btn.setText(_translate("Update_Network_Settings_Form", "Update"))
+        self.cancel_btn.setText(_translate("Update_Network_Settings_Form", "Cancel"))
+        self.prefix_len_lbl.setText(_translate("Update_Network_Settings_Form", "Prefix Length:"))
+        self.prefix_len_in.setText(_translate("Update_Network_Settings_Form", "24"))
+        self.port_no_lbl.setText(_translate("Update_Network_Settings_Form", "Port:"))
+        self.port_in.setText(_translate("Update_Network_Settings_Form", "1337"))
+        self.gateway_lbl.setText(_translate("Update_Network_Settings_Form", "Gateway:"))
+        self.gateway_in_0.setText(_translate("Update_Network_Settings_Form", "192"))
+        self.dot_0_lbl_2.setText(_translate("Update_Network_Settings_Form", "."))
+        self.gateway_in_1.setText(_translate("Update_Network_Settings_Form", "168"))
+        self.dot_1_lbl_2.setText(_translate("Update_Network_Settings_Form", "."))
+        self.gateway_in_2.setText(_translate("Update_Network_Settings_Form", "1"))
+        self.dot_2_lbl_2.setText(_translate("Update_Network_Settings_Form", "."))
+        self.gateway_in_3.setText(_translate("Update_Network_Settings_Form", "1"))

pykirdy/ui/update_network_settings_form.ui

@@ -349,7 +349,7 @@
        </size>
       </property>
       <property name="text">
-       <string>1550</string>
+       <string>1337</string>
       </property>
       <property name="maxLength">
        <number>5</number>

src/device/boot.rs

@@ -71,6 +71,7 @@ pub fn bootup(
     let current_source = LdCtrl::new(current_source_phy);
     let mut laser = LdDrive::new(current_source, perif.ADC3, perif.TIM2.counter(&clocks), pd_mon_phy);
     laser.setup();
+    laser.ld_open();
     laser.ld_set_i(ElectricCurrent::new::<ampere>(0.0));
     laser.set_pd_i_limit(ElectricCurrent::new::<milliampere>(2.5));
     laser.set_pd_mon_calibrated_vdda(thermostat.get_calibrated_vdda());

src/laser_diode/laser_diode.rs

@@ -99,33 +99,22 @@ impl LdDrive {
             Settings::DAC_OUT_V_MAX,
         );
         LdCurrentOutCtrlTimer::reset();
-        self.ctrl.ld_short_enable();
+        self.ld_short();
     }
 
     pub fn ld_short(&mut self) {
-        if LdPwrExcProtector::get_status().pwr_engaged {
-            self.ctrl.ld_short_enable();
-        }
+        self.ctrl.ld_short_enable();
         self.settings.ld_terms_short = true;
     }
 
     pub fn ld_open(&mut self) {
-        if LdPwrExcProtector::get_status().pwr_engaged {
-            self.ctrl.ld_short_disable();
-        }
+        self.ctrl.ld_short_disable();
         self.settings.ld_terms_short = false;
     }
 
     pub fn power_up(&mut self) {
         let prev_i_set = self.settings.ld_drive_current;
         LdCurrentOutCtrlTimer::reset();
-
-        if self.settings.ld_terms_short {
-            self.ctrl.ld_short_enable();
-        } else {
-            self.ctrl.ld_short_disable();
-        }
-
         let _ = self.ctrl.set_i(
             ElectricCurrent::new::<milliampere>(0.0),
             Settings::LD_DRIVE_TRANSIMPEDANCE,
@@ -143,8 +132,6 @@ impl LdDrive {
     pub fn power_down(&mut self) {
         LdPwrExcProtector::pwr_off();
         self.settings.pwr_on = false;
-        // Short the laser diode terminals at power off state for electrical protection
-        self.ctrl.ld_short_enable();
     }
 
     pub fn get_pd_i(&mut self) -> ElectricCurrent {
@@ -161,10 +148,13 @@ impl LdDrive {
         )
     }
 
-    pub fn ld_set_i(&mut self, i: ElectricCurrent) -> bool {
-        self.settings.ld_drive_current = i.min(Settings::LD_CURRENT_MAX).max(ElectricCurrent::zero());
+    pub fn ld_set_i(&mut self, i: ElectricCurrent) {
+        self.settings.ld_drive_current = i.min(Settings::LD_CURRENT_MAX);
         LdCurrentOutCtrlTimer::set_target_i_and_listen_irq(self.settings.ld_drive_current, self.ctrl.get_i_set());
-        self.settings.ld_drive_current != i
+    }
+
+    pub fn poll_pd_mon_v(&mut self) -> ElectricPotential {
+        LdPwrExcProtector::poll_pd_mon_v()
     }
 
     pub fn poll_and_update_output_current(&mut self) -> ElectricCurrent {

src/laser_diode/ld_current_out_ctrl_timer.rs

@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use fugit::{HertzU32, TimerDurationU32};
+use fugit::{KilohertzU32, TimerDurationU32};
 use log::debug;
 use stm32f4xx_hal::{pac::{interrupt, Interrupt, TIM2},
                     timer::{Counter, Event},
@@ -20,7 +20,7 @@ pub const FREQ: u32 = 1000000;
 /// This timer notifies the main loop to set the correct output current so that ld output current can ramp up/down slowly.
 ///     The current output slope is guaranteed to be larger but not necessarily equal to than the preset value.
 impl LdCurrentOutCtrlTimer {
-    const TIME_STEP: TimerDurationU32<FREQ> = TimerDurationU32::from_rate(HertzU32::from_raw(250));
+    const TIME_STEP_MS: TimerDurationU32<FREQ> = TimerDurationU32::from_rate(KilohertzU32::from_raw(1));
     const STEP_SIZE: ElectricCurrent = ElectricCurrent {
         dimension: PhantomData,
         units: PhantomData,
@@ -28,7 +28,7 @@ impl LdCurrentOutCtrlTimer {
     };
 
     pub fn setup(mut tim2: Counter<TIM2, FREQ>) {
-        tim2.start(LdCurrentOutCtrlTimer::TIME_STEP).unwrap();
+        tim2.start(LdCurrentOutCtrlTimer::TIME_STEP_MS).unwrap();
         unsafe {
             cortex_m::peripheral::NVIC::unmask(Interrupt::TIM2);
         }

src/laser_diode/ld_pwr_exc_protector.rs

@@ -46,11 +46,8 @@ pub struct LdPwrExcProtector {
     alarm_status: Status,
     calibrated_vdda: u32,
     offset: u32,
-    trigger_threshold: u16,
-    iir_y1: u32,
-    iir_y2: u32,
-    iir_x1: u32,
-    iir_x2: u32,
+    prev_samples: [u16; 32],
+    ptr: u16,
 }
 
 impl LdPwrExcProtector {
@@ -94,9 +91,8 @@ impl LdPwrExcProtector {
                 .res()
                 .twelve_bit()
                 // Set Analog Watchdog to guard Single Regular Channel
-                // Disable Analog Watchdog
                 .awden()
-                .disabled()
+                .enabled()
                 .awdsgl()
                 .single_channel()
                 .jawden()
@@ -104,9 +100,9 @@ impl LdPwrExcProtector {
                 // Disable Analog Watchdog Interrupt
                 .awdie()
                 .disabled()
-                // Enable End of Conversion Interrupt
-                .eocie()
-                .enabled()
+                // Set Analog Watchdog to monitor Pd Mon Pin
+                .awdch()
+                .variant(PD_MON_ADC_CH_ID)
         });
         pac_adc.cr2.write(|w| {
             w
@@ -134,6 +130,11 @@ impl LdPwrExcProtector {
         pac_adc.smpr1.write(|w| unsafe { w.bits(0xFFFF) });
         pac_adc.smpr2.write(|w| unsafe { w.bits(0xFFFF) });
 
+        // Set the higher threshold to be max value initially
+        pac_adc.htr.write(|w| w.ht().variant(MAX_SAMPLE));
+        // Set the lower threshold to be min value initially
+        pac_adc.ltr.write(|w| w.lt().variant(0));
+
         // SWStart should only be set when ADON = 1. Otherwise no conversion is launched.
         pac_adc.cr2.modify(|_, w| w.swstart().set_bit());
 
@@ -146,11 +147,8 @@ impl LdPwrExcProtector {
                 alarm_status: Status::default(),
                 calibrated_vdda: 3300,
                 offset: offset,
-                iir_y1: 0,
-                iir_y2: 0,
-                iir_x1: 0,
-                iir_x2: 0,
-                trigger_threshold: MAX_SAMPLE,
+                prev_samples: [0; 32],
+                ptr: 0,
             });
         }
     }
@@ -159,10 +157,10 @@ impl LdPwrExcProtector {
         unsafe { LD_PWR_EXC_PROTECTOR.as_mut() }
     }
 
-    fn convert_sample_to_volt(sample: u32) -> ElectricPotential {
+    fn convert_sample_to_volt(sample: u16) -> ElectricPotential {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
             return ElectricPotential::new::<millivolt>(
-                (((sample as i32 - wdg.offset as i32).max(0) as u32 * wdg.calibrated_vdda) / u32::from(MAX_SAMPLE))
+                (((i32::from(sample) - wdg.offset as i32).max(0) as u32 * wdg.calibrated_vdda) / u32::from(MAX_SAMPLE))
                     as f32,
             );
         }
@@ -176,7 +174,7 @@ impl LdPwrExcProtector {
                 .ceil() as u32)
                 + wdg.offset;
             if code <= MAX_SAMPLE as u32 {
-                wdg.trigger_threshold = code as u16;
+                wdg.pac.htr.write(|w| unsafe { w.bits(code) });
                 return true;
             }
         }
@@ -189,37 +187,27 @@ impl LdPwrExcProtector {
         }
     }
 
-    pub fn irq_handler() {
+    pub fn poll_pd_mon_v() -> ElectricPotential {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
             if wdg.pac.sr.read().eoc().bit() {
-                // Sampling Frequency: PCLK2(84MHz) / 8 / ( 12 + 480 ) = 21.3kHz
-                // Second Order Section IIR Filter designed with scipy
-                // Filter Type: Butterworth Low Pass Filter
-                // Coefficient Width: 20bit
-                // Cutoff Frequency(-3dB): 500Hz
-                let sample = wdg.pac.dr.read().data().bits();
-                const A1: u32 = 1879535; // Negative Coefficient
-                const A2: u32 = 851509;
-                const B0: u32 = 5137;
-                const B1: u32 = 10275;
-                const B2: u32 = 5137;
+                wdg.prev_samples[wdg.ptr as usize] = wdg.pac.dr.read().data().bits();
+                wdg.ptr = (wdg.ptr + 1) % 32 as u16;
 
-                let y: u32 = (B0 * sample as u32 + B1 * wdg.iir_x1 + B2 * wdg.iir_x2 + A1 * wdg.iir_y1 - A2 * wdg.iir_y2) >> 20;
-                wdg.iir_y2 = wdg.iir_y1;
-                wdg.iir_y1 = y;
-                wdg.iir_x2 = wdg.iir_x1;
-                wdg.iir_x1 = sample as u32;
-
-                wdg.alarm_status.v = LdPwrExcProtector::convert_sample_to_volt(y);
-                if y > wdg.trigger_threshold as u32 {
-                    LdPwrExcProtector::pwr_excursion_handler();
+                let mut samples: u32 = 0;
+                for idx in 0..32 {
+                    samples += wdg.prev_samples[idx] as u32;
                 }
+                samples = samples >> 5;
+                wdg.alarm_status.v = LdPwrExcProtector::convert_sample_to_volt(samples as u16);
             }
+            return wdg.alarm_status.v;
         }
+        ElectricPotential::zero()
     }
 
     pub fn get_status() -> Status {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
+            LdPwrExcProtector::poll_pd_mon_v();
             return wdg.alarm_status.clone();
         }
         Status::default()
@@ -240,6 +228,9 @@ impl LdPwrExcProtector {
                 wdg.alarm_status = Status::default();
                 LdPwrExcProtector::clear_interrupt_bit();
                 LdPwrExcProtector::pwr_on();
+                // Interrupt should be enabled after power on to tackle the following edge case:
+                //      Pd_Mon pin voltage has already exceed threshold before LD Power is on.
+                LdPwrExcProtector::enable_watchdog_interrupt();
             }
         }
     }
@@ -251,6 +242,18 @@ impl LdPwrExcProtector {
         }
     }
 
+    fn enable_watchdog_interrupt() {
+        if let Some(ref mut wdg) = LdPwrExcProtector::get() {
+            wdg.pac.cr1.modify(|_, w| w.awdie().set_bit());
+        }
+    }
+
+    fn disable_watchdog_interrupt() {
+        if let Some(ref mut wdg) = LdPwrExcProtector::get() {
+            wdg.pac.cr1.modify(|_, w| w.awdie().clear_bit());
+        }
+    }
+
     fn clear_interrupt_bit() {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
             wdg.pac.sr.modify(|_, w| w.awd().clear_bit());
@@ -268,14 +271,16 @@ impl LdPwrExcProtector {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
             wdg.alarm_status.pwr_engaged = false;
             wdg.phy.pwr_en_ch0.set_low();
+            LdPwrExcProtector::disable_watchdog_interrupt();
         }
     }
 
     fn pwr_excursion_handler() {
         if let Some(ref mut wdg) = LdPwrExcProtector::get() {
+            let sample = wdg.pac.dr.read().data().bits();
             LdPwrExcProtector::pwr_off();
             wdg.alarm_status.pwr_excursion = true;
-            wdg.alarm_status.v_tripped = LdPwrExcProtector::convert_sample_to_volt(wdg.iir_y1);
+            wdg.alarm_status.v_tripped = LdPwrExcProtector::convert_sample_to_volt(sample);
         }
     }
 }
@@ -283,7 +288,9 @@ impl LdPwrExcProtector {
 #[interrupt]
 fn ADC() {
     cortex_m::interrupt::free(|_| {
-        LdPwrExcProtector::irq_handler();
+        LdPwrExcProtector::pwr_excursion_handler();
+        // Disable interrupt to avoid getting stuck in infinite loop
+        LdPwrExcProtector::disable_watchdog_interrupt();
         LdPwrExcProtector::clear_interrupt_bit();
     })
 }

src/main.rs

@@ -77,6 +77,7 @@ fn main() -> ! {
         },
     };
 
+    let mut active_report: [bool; net::net::NUM_OF_SOCKETS] = [false; net::net::NUM_OF_SOCKETS];
 
     let mut state = State::default();
 
@@ -87,7 +88,9 @@ fn main() -> ! {
     loop {
         wd.feed();
 
-        net::net::eth_poll_link_status_and_update_link_speed();
+        if net::net::eth_poll_link_status_and_update_link_speed() {
+            active_report = [false; net::net::NUM_OF_SOCKETS];
+        }
 
         match state {
             State::LoadFlashSettings => {
@@ -152,6 +155,7 @@ fn main() -> ! {
             }
             State::MainLoop => {
                 laser.poll_and_update_output_current();
+                laser.poll_pd_mon_v();
 
                 net::net::eth_update_iface_poll_timer();
 
@@ -161,7 +165,24 @@ fn main() -> ! {
                         laser.power_down();
                         thermostat.power_down();
                     }
-                    thermostat.process_tec_readings();
+
+                    net::net::for_each(|mut socket, id| {
+                        if net::net::eth_is_socket_active(socket, true) && net::net::eth_is_socket_connected(socket) {
+                            if active_report[id] {
+                                if net::net::eth_can_sock_send(socket) {
+                                    net::cmd_handler::send_status_report(
+                                        eth_data_buffer,
+                                        &mut laser,
+                                        &mut thermostat,
+                                        &mut socket,
+                                    );
+                                }
+                            }
+                        } else {
+                            active_report[id] = false;
+                        }
+                    });
+
                     thermostat.start_tec_readings_conversion();
                 }
 
@@ -186,6 +207,7 @@ fn main() -> ! {
                                     &mut thermostat,
                                     &mut state,
                                     &mut device_settings,
+                                    &mut active_report[id],
                                 );
                             }
                         }

src/net/cmd_handler.rs

@@ -1,4 +1,4 @@
-use core::{fmt::Debug, marker::PhantomData, env};
+use core::{fmt::Debug, marker::PhantomData};
 
 use log::{debug, info};
 use miniconf::{JsonCoreSlash, Tree};
@@ -9,7 +9,6 @@ use uom::si::{electric_current::{ampere, ElectricCurrent},
               electrical_conductance::{siemens, ElectricalConductance},
               electrical_resistance::{ohm, ElectricalResistance},
               power::{watt, Power}};
-use const_format::concatcp;
 
 use crate::{device::{dfu, hw_rev::HWRev, sys_timer},
             laser_diode::{laser_diode::{LdDrive, LdSettingsSummary, StatusReport as LdStatusReport},
@@ -28,13 +27,11 @@ pub enum ResponseEnum {
     Settings,
     Report,
     HwRev,
-    FirmwareRev,
     Interval,
     Acknowledge,
     InvalidDatatype,
     InvalidSettings,
     InvalidCmd,
-    Warning,
     HardReset,
     Dfu,
     ConnectionClose,
@@ -63,34 +60,13 @@ pub struct ResponseObj<'a> {
     json: Response<'a>,
 }
 
-#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
-pub struct FirmwareRevType<'a> {
-    msg_type: ResponseEnum,
-    firmware_rev: Option<&'a str>,
-}
-
-impl Default for FirmwareRevType<'static> {
-    fn default() -> Self {
-        FirmwareRevType {
-            msg_type: ResponseEnum::Reserved,
-            firmware_rev: None,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Copy, Clone, Debug, Tree)]
-pub struct FirmwareRevObj<'a> {
-    #[serde(borrow)]
-    json: FirmwareRevType<'a>,
-}
-
 #[derive(Deserialize, Serialize, Copy, Clone, Default, Debug)]
 enum DeviceCmd {
     #[default]
     Reserved,
     GetHwRev,
-    GetFirmwareRev,
     SetIPSettings,
+    SetActiveReportMode,
     SetPdFinGain,
     SetPdTransconductance,
     GetStatusReport,
@@ -165,11 +141,6 @@ const ERR_MSG_MISSING_POSTFILTER: &str = "Required field \"PostFilter\" does not
 const ERR_MSG_MISSING_SINC3FINEODR: &str = "Required field \"sinc3fineodr\" does not exist";
 const ERR_MSG_INVALID_PDMON_SETTINGS: &str = "Invalid PD Mon Parameter Setting(s)";
 const ERR_MSG_INVALID_LD_PWR_LIMIT_SETTING: &str = "Invalid LD Power Limit Setting";
-const ERR_MSG_CMD_NOT_FOUND: &str = "Command Not Found";
-
-const WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE: &str = "Value set is out of range and clamped to the hardware limit";
-const WARN_MGS_TEMP_SETPOINT_IS_CLAMPED_BY_TEMP_MON_LIMIT: &str = "Value set is out of temperature monitor range and clamped to the temperature monitor limit";
-const WARN_MSG_TEMP_VALUE_IS_BELOW_ABOSOLUTE_ZERO: &str = "Value set is below absolute zero and clamped to absolute zero(-273.15 Degree)";
 
 #[derive(Deserialize, Serialize, Copy, Clone, Debug, Default, Tree)]
 pub struct CmdJsonObj {
@@ -288,20 +259,6 @@ pub fn send_status_report(
     net::eth_send(buffer, num_bytes, *socket);
 }
 
-pub fn send_firmware_rev(buffer: &mut [u8], socket: &mut SocketHandle){
-    let response = FirmwareRevObj {
-        json: FirmwareRevType {
-            msg_type: ResponseEnum::FirmwareRev,
-            firmware_rev: Some(env!("BUILD_REVISION")),
-        },
-    };
-
-    let mut num_bytes = response.get_json("/json", buffer).unwrap();
-    buffer[num_bytes] = b'\n';
-    num_bytes += 1;
-    net::eth_send(buffer, num_bytes, *socket);
-}
-
 pub fn send_hw_rev(buffer: &mut [u8], hw_rev_o: &mut HWRev, socket: &mut SocketHandle) {
     let hw_rev = HwRevObj {
         json: HwRevType {
@@ -351,22 +308,15 @@ pub fn execute_cmd(
     thermostat: &mut Thermostat,
     state: &mut State,
     device_settings: &mut DeviceSettings,
+    active_report: &mut bool,
 ) {
     let mut cmd = TecSetICmd {
         json: TecSetICmdJson::default(),
     };
     match cmd.set_json("/json", &buffer[0..buffer_size]) {
         Ok(_) => {
-            if !thermostat.set_i(ElectricCurrent::new::<ampere>(cmd.json.tec_set_i)) {
-                send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-            } else {
-                send_response(
-                    buffer, 
-                    ResponseEnum::Warning,
-                    Some(concatcp!("tec_set_i: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)), 
-                    socket
-                );
-            }
+            thermostat.set_i(ElectricCurrent::new::<ampere>(cmd.json.tec_set_i));
+            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
             return;
         }
         Err(_) => { /* Do Nothing */ }
@@ -384,10 +334,6 @@ pub fn execute_cmd(
             info!("############ Thermostat Command Received {:?}", cmd.json.thermostat_cmd);
             info!("############ Device Command Received {:?}", cmd.json.device_cmd);
 
-            if cmd.json.laser_diode_cmd.is_none() && cmd.json.thermostat_cmd.is_none() && cmd.json.device_cmd.is_none() {
-                send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_CMD_NOT_FOUND), socket);
-            }
-
             match cmd.json.device_cmd {
                 Some(DeviceCmd::SetIPSettings) => match cmd.json.ip_settings {
                     Some(val) => {
@@ -412,6 +358,20 @@ pub fn execute_cmd(
                     net::eth_poll_iface();
                     *state = State::PrepareForDfu;
                 }
+                Some(DeviceCmd::SetActiveReportMode) => match cmd.json.data_bool {
+                    Some(val) => {
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        *active_report = val;
+                    }
+                    None => {
+                        send_response(
+                            buffer,
+                            ResponseEnum::InvalidDatatype,
+                            Some(ERR_MSG_MISSING_DATA_BOOL),
+                            socket,
+                        );
+                    }
+                },
                 Some(DeviceCmd::SetPdFinGain) => match cmd.json.data_f32 {
                     Some(val) => {
                         send_response(buffer, ResponseEnum::Acknowledge, None, socket);
@@ -451,9 +411,6 @@ pub fn execute_cmd(
                 Some(DeviceCmd::GetHwRev) => {
                     send_hw_rev(buffer, hw_rev, socket);
                 }
-                Some(DeviceCmd::GetFirmwareRev) => {
-                    send_firmware_rev(buffer, socket);
-                }
                 Some(DeviceCmd::GetStatusReport) => {
                     send_status_report(buffer, laser, thermostat, socket);
                 }
@@ -475,7 +432,8 @@ pub fn execute_cmd(
                 }
                 None => { /* Do Nothing */ }
                 _ => {
-                    send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_CMD_NOT_FOUND), socket);
+                    send_response(buffer, ResponseEnum::InvalidCmd, None, socket);
+                    debug!("Unimplemented Command")
                 }
             }
 
@@ -512,16 +470,8 @@ pub fn execute_cmd(
                 }
                 Some(LdCmdEnum::SetI) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !laser.ld_set_i(ElectricCurrent::new::<ampere>(val)) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer,
-                                ResponseEnum::Warning,
-                                Some(concatcp!("Laser Cmd SetI: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)),
-                                socket,
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        laser.ld_set_i(ElectricCurrent::new::<ampere>(val));
                     }
                     None => {
                         send_response(
@@ -606,7 +556,8 @@ pub fn execute_cmd(
                 }
                 None => { /* Do Nothing*/ }
                 _ => {
-                    send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_CMD_NOT_FOUND), socket);
+                    send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_MISSING_DATA_F32), socket);
+                    info!("Unimplemented Command")
                 }
             }
 
@@ -635,16 +586,8 @@ pub fn execute_cmd(
                 }
                 Some(ThermostatCmdEnum::SetTecMaxV) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_max_v(ElectricPotential::new::<volt>(val)) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTecMaxV: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_max_v(ElectricPotential::new::<volt>(val));
                     }
                     None => {
                         send_response(
@@ -657,16 +600,8 @@ pub fn execute_cmd(
                 },
                 Some(ThermostatCmdEnum::SetTecMaxIPos) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_max_i_pos(ElectricCurrent::new::<ampere>(val)) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTecMaxIPos: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_max_i_pos(ElectricCurrent::new::<ampere>(val));
                     }
                     None => {
                         send_response(
@@ -679,16 +614,8 @@ pub fn execute_cmd(
                 },
                 Some(ThermostatCmdEnum::SetTecMaxINeg) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_max_i_neg(ElectricCurrent::new::<ampere>(val)) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTecMaxINeg: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_max_i_neg(ElectricCurrent::new::<ampere>(val));
                     }
                     None => {
                         send_response(
@@ -701,16 +628,8 @@ pub fn execute_cmd(
                 },
                 Some(ThermostatCmdEnum::SetTecIOut) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_i(ElectricCurrent::new::<ampere>(val)) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTecIOut: ", WARN_MSG_VALUE_SET_IS_OUT_OF_RANGE)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_i(ElectricCurrent::new::<ampere>(val));
                     }
                     None => {
                         send_response(
@@ -723,16 +642,8 @@ pub fn execute_cmd(
                 },
                 Some(ThermostatCmdEnum::SetTemperatureSetpoint) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_temperature_setpoint(val) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTemperatureSetpoint: ", WARN_MGS_TEMP_SETPOINT_IS_CLAMPED_BY_TEMP_MON_LIMIT)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_temperature_setpoint(val);
                     }
                     None => {
                         send_response(
@@ -898,16 +809,8 @@ pub fn execute_cmd(
                 }
                 Some(ThermostatCmdEnum::SetTempMonUpperLimit) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_temp_mon_upper_limit(val) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTempMonUpperLimit: ", WARN_MSG_TEMP_VALUE_IS_BELOW_ABOSOLUTE_ZERO)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_temp_mon_upper_limit(val);
                     }
                     None => {
                         send_response(
@@ -920,16 +823,8 @@ pub fn execute_cmd(
                 },
                 Some(ThermostatCmdEnum::SetTempMonLowerLimit) => match cmd.json.data_f32 {
                     Some(val) => {
-                        if !thermostat.set_temp_mon_lower_limit(val) {
-                            send_response(buffer, ResponseEnum::Acknowledge, None, socket);
-                        } else {
-                            send_response(
-                                buffer, 
-                                ResponseEnum::Warning, 
-                                Some(concatcp!("Thermostat Cmd SetTempMonLowerLimit: ", WARN_MSG_TEMP_VALUE_IS_BELOW_ABOSOLUTE_ZERO)), 
-                                socket
-                            );
-                        }
+                        send_response(buffer, ResponseEnum::Acknowledge, None, socket);
+                        thermostat.set_temp_mon_lower_limit(val);
                     }
                     None => {
                         send_response(
@@ -988,13 +883,13 @@ pub fn execute_cmd(
                 },
                 None => { /* Do Nothing*/ }
                 _ => {
-                    send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_CMD_NOT_FOUND), socket);
+                    send_response(buffer, ResponseEnum::InvalidCmd, None, socket);
                 }
             }
         }
         Err(_) => {
             info!("cmd_recv: {:?}", buffer);
-            send_response(buffer, ResponseEnum::InvalidCmd, Some(ERR_MSG_CMD_NOT_FOUND), socket);
+            send_response(buffer, ResponseEnum::InvalidCmd, None, socket);
         }
     }
 }

src/net/net.rs

@@ -30,7 +30,7 @@ impl Default for IpSettings {
     fn default() -> Self {
         IpSettings {
             addr: [192, 168, 1, 128],
-            port: 1550,
+            port: 1337,
             prefix_len: 24,
             gateway: [192, 168, 1, 1],
         }

src/thermostat/ad7172/mod.rs

@@ -148,10 +148,10 @@ impl fmt::Display for RefSource {
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 #[repr(u8)]
 pub enum PostFilter {
-    /// 27.27 SPS, 47 dB rejection, 36.7 ms settling
+    /// 27 SPS, 47 dB rejection, 36.7 ms settling
     F27SPS = 0b010,
-    /// 25 SPS, 62 dB rejection, 40 ms settling
-    F25SPS = 0b011,
+    /// 21.25 SPS, 62 dB rejection, 40 ms settling
+    F21SPS = 0b011,
     /// 20 SPS, 86 dB rejection, 50 ms settling
     F20SPS = 0b101,
     /// 16.67 SPS, 92 dB rejection, 60 ms settling
@@ -162,7 +162,7 @@ pub enum PostFilter {
 impl PostFilter {
     pub const VALID_VALUES: &'static [Self] = &[
         PostFilter::F27SPS,
-        PostFilter::F25SPS,
+        PostFilter::F21SPS,
         PostFilter::F20SPS,
         PostFilter::F16SPS,
     ];
@@ -182,8 +182,8 @@ impl PostFilter {
     /// Samples per Second
     pub fn output_rate(&self) -> Option<f32> {
         match self {
-            PostFilter::F27SPS => Some(27.27),
-            PostFilter::F25SPS => Some(25.0),
+            PostFilter::F27SPS => Some(27.0),
+            PostFilter::F21SPS => Some(21.25),
             PostFilter::F20SPS => Some(20.0),
             PostFilter::F16SPS => Some(16.67),
             PostFilter::Invalid => None,
@@ -195,7 +195,7 @@ impl From<u8> for PostFilter {
     fn from(x: u8) -> Self {
         match x {
             0b010 => PostFilter::F27SPS,
-            0b011 => PostFilter::F25SPS,
+            0b011 => PostFilter::F21SPS,
             0b101 => PostFilter::F20SPS,
             0b110 => PostFilter::F16SPS,
             _ => PostFilter::Invalid,

src/thermostat/max1968.rs

@@ -78,8 +78,6 @@ pub struct MAX1968 {
     pub pins_adc: Adc<ADC1>,
     pub dma_adc: DMA_Transfer<Stream2<DMA2>, 1, Adc<ADC2>, PeripheralToMemory, &'static mut [u16; 16]>,
     pub dac_out_range: ElectricPotential,
-    vtec_volt_iir: u16,
-    itec_volt_iir: u16,
     prev_vtec_volt: ElectricPotential,
     prev_itec_volt: ElectricPotential,
 }
@@ -245,8 +243,6 @@ impl MAX1968 {
             pins_adc: pins_adc1,
             dma_adc: dma_adc,
             dac_out_range: dac_out_range,
-            vtec_volt_iir: 1861, // VTEC value centers at 1.5V
-            itec_volt_iir: 1861, // ITEC value centers at 1.5V
             prev_vtec_volt: ElectricPotential::new::<millivolt>(0.0),
             prev_itec_volt: ElectricPotential::new::<millivolt>(0.0),
         }
@@ -265,10 +261,6 @@ impl MAX1968 {
     }
 
     pub fn get_tec_readings(&mut self) -> (ElectricPotential, ElectricPotential) {
-        (self.prev_vtec_volt, self.prev_itec_volt)
-    }
-
-    pub fn cal_tec_readings(&mut self) -> (ElectricPotential, ElectricPotential) {
         if unsafe { DMA_TRANSFER_COMPLETE } {
             let buffer: &[u16; 16];
             unsafe {
@@ -284,20 +276,18 @@ impl MAX1968 {
                 itec += *data;
             }
             itec = itec >> 3;
-            self.itec_volt_iir = (7 * self.itec_volt_iir + itec) >> 3;
 
             let mut vtec: u16 = 0;
             for data in buffer.into_iter().skip(1).step_by(2) {
                 vtec += *data;
             }
             vtec = vtec >> 3;
-            self.vtec_volt_iir = (7 * self.vtec_volt_iir + vtec) >> 3;
 
             unsafe {
                 ADC2_LOCAL_BUFFER = *buffer;
             }
-            self.prev_vtec_volt = ElectricPotential::new::<millivolt>(sample_to_millivolts(self.vtec_volt_iir) as f32);
-            self.prev_itec_volt = ElectricPotential::new::<millivolt>(sample_to_millivolts(self.itec_volt_iir) as f32);
+            self.prev_vtec_volt = ElectricPotential::new::<millivolt>(sample_to_millivolts(vtec) as f32);
+            self.prev_itec_volt = ElectricPotential::new::<millivolt>(sample_to_millivolts(itec) as f32);
         }
         (self.prev_vtec_volt, self.prev_itec_volt)
     }

src/thermostat/temp_mon.rs

@@ -67,20 +67,18 @@ impl TempMon {
     const OVER_TEMP_COUNT_LIMIT: u32 = 25;
     const TEMP_STABLE_COUNT_LIMIT: u32 = 100;
 
-    pub fn set_upper_limit(&mut self, upper_limit: f32) -> bool {
-        self.upper_limit = upper_limit.max(-273.15);
+    pub fn set_upper_limit(&mut self, upper_limit: f32) {
+        self.upper_limit = upper_limit;
         self.is_limit_changed = true;
-        self.upper_limit != upper_limit
     }
 
     pub fn get_upper_limit(&mut self) -> f32 {
         self.upper_limit
     }
 
-    pub fn set_lower_limit(&mut self, lower_limit: f32) -> bool {
-        self.lower_limit = lower_limit.max(-273.15);
+    pub fn set_lower_limit(&mut self, lower_limit: f32) {
+        self.lower_limit = lower_limit;
         self.is_limit_changed = true;
-        self.lower_limit != lower_limit
     }
 
     pub fn get_lower_limit(&mut self) -> f32 {

src/thermostat/thermostat.rs

@@ -2,7 +2,6 @@ use core::{f32::NAN, marker::PhantomData};
 
 use log::debug;
 use miniconf::Tree;
-use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 use uom::si::{electric_current::ampere,
               electric_potential::volt,
@@ -158,10 +157,6 @@ impl Thermostat {
         self.max1968.dma_adc_start_conversion();
     }
 
-    pub fn process_tec_readings(&mut self) {
-        self.max1968.cal_tec_readings();
-    }
-
     fn tec_setup(&mut self) {
         self.power_down();
 
@@ -262,46 +257,42 @@ impl Thermostat {
         self.tec_settings.default_pwr_on = pwr_on;
     }
 
-    pub fn set_i(&mut self, i_tec: ElectricCurrent) -> bool {
-        let i_tec_set = i_tec.max(-TecSettings::MAX_I_NEG_CURRENT).min(TecSettings::MAX_I_POS_CURRENT);
-        let voltage = i_tec_set * 10.0 * R_SENSE + self.tec_settings.center_pt;
+    pub fn set_i(&mut self, i_tec: ElectricCurrent) -> ElectricCurrent {
+        let voltage = i_tec * 10.0 * R_SENSE + self.tec_settings.center_pt;
         let _voltage = self.max1968.set_dac(voltage, self.max1968.dac_out_range);
 
-        self.tec_settings.i_set = i_tec_set;
-        i_tec_set != i_tec
+        self.tec_settings.i_set = i_tec;
+        self.tec_settings.i_set
     }
 
-    pub fn set_max_v(&mut self, max_v: ElectricPotential) -> bool {
-        let max_v_set = max_v.min(TecSettings::MAX_V_MAX).max(ElectricPotential::zero());
-        let duty = (max_v_set / TecSettings::MAX_V_DUTY_TO_VOLTAGE_RATE).get::<ratio>();
+    pub fn set_max_v(&mut self, max_v: ElectricPotential) -> ElectricPotential {
+        let duty = (max_v / TecSettings::MAX_V_DUTY_TO_VOLTAGE_RATE).get::<ratio>();
         let _duty = self
             .max1968
             .set_pwm(PwmPinsEnum::MaxV, duty as f64, TecSettings::MAX_V_DUTY_MAX);
 
-        self.tec_settings.max_v_set = max_v_set;
-        max_v_set != max_v
+        self.tec_settings.max_v_set = max_v;
+        self.tec_settings.max_v_set
     }
 
-    pub fn set_max_i_pos(&mut self, max_i_pos: ElectricCurrent) -> bool {
-        let max_i_pos_set = max_i_pos.min(TecSettings::MAX_I_POS_CURRENT).max(ElectricCurrent::zero());
-        let duty = (max_i_pos_set / TecSettings::MAX_I_POS_NEG_DUTY_TO_CURRENT_RATE).get::<ratio>();
+    pub fn set_max_i_pos(&mut self, max_i_pos: ElectricCurrent) -> ElectricCurrent {
+        let duty = (max_i_pos / TecSettings::MAX_I_POS_NEG_DUTY_TO_CURRENT_RATE).get::<ratio>();
         let _duty = self
             .max1968
             .set_pwm(PwmPinsEnum::MaxPosI, duty as f64, TecSettings::MAX_I_POS_DUTY_MAX);
 
-        self.tec_settings.max_i_pos_set = max_i_pos_set;
-        max_i_pos_set != max_i_pos
+        self.tec_settings.max_i_pos_set = max_i_pos;
+        self.tec_settings.max_i_pos_set
     }
 
-    pub fn set_max_i_neg(&mut self, max_i_neg: ElectricCurrent) -> bool {
-        let max_i_neg_set = max_i_neg.min(TecSettings::MAX_I_NEG_CURRENT).max(ElectricCurrent::zero());
-        let duty = (max_i_neg_set / TecSettings::MAX_I_POS_NEG_DUTY_TO_CURRENT_RATE).get::<ratio>();
+    pub fn set_max_i_neg(&mut self, max_i_neg: ElectricCurrent) -> ElectricCurrent {
+        let duty = (max_i_neg / TecSettings::MAX_I_POS_NEG_DUTY_TO_CURRENT_RATE).get::<ratio>();
         let _duty = self
             .max1968
             .set_pwm(PwmPinsEnum::MaxNegI, duty as f64, TecSettings::MAX_I_NEG_DUTY_MAX);
 
-        self.tec_settings.max_i_neg_set = max_i_neg_set;
-        max_i_neg_set != max_i_neg
+        self.tec_settings.max_i_neg_set = max_i_neg;
+        self.tec_settings.max_i_neg_set
     }
 
     #[allow(unused)]
@@ -478,19 +469,12 @@ impl Thermostat {
         self.pid_ctrl_ch0.set_sh_t0(t0);
     }
 
-    pub fn set_temperature_setpoint(&mut self, t: f32) -> bool {
-        let clamped = if self.temp_mon.get_upper_limit() < t || 
-            self.temp_mon.get_lower_limit() > t {
-                true 
-            } else {
-                false
-            };
+    pub fn set_temperature_setpoint(&mut self, t: f32) {
         let t = t
             .min(self.temp_mon.get_upper_limit())
             .max(self.temp_mon.get_lower_limit());
         self.pid_ctrl_ch0.set_pid_setpoint(t);
         self.temp_mon.set_setpoint(t);
-        clamped
     }
 
     pub fn apply_temp_mon_settings(&mut self, settings: TempMonSettings) {
@@ -500,12 +484,12 @@ impl Thermostat {
             .set_lower_limit(settings.lower_limit);
     }
 
-    pub fn set_temp_mon_upper_limit(&mut self, t: f32) -> bool {
-        self.temp_mon.set_upper_limit(t)
+    pub fn set_temp_mon_upper_limit(&mut self, t: f32) {
+        self.temp_mon.set_upper_limit(t);
     }
 
-    pub fn set_temp_mon_lower_limit(&mut self, t: f32) -> bool {
-        self.temp_mon.set_lower_limit(t)
+    pub fn set_temp_mon_lower_limit(&mut self, t: f32) {
+        self.temp_mon.set_lower_limit(t);
     }
 
     pub fn set_temp_adc_sinc5_sinc1_filter(&mut self, index: u8, odr: ad7172::SingleChODR) {