From ed9bb18ed21bbbf66771d0ef3efed9f4e94c81ec Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 15:56:20 +0100
Subject: [PATCH 01/26] Create build.yml

---
 .github/workflows/build.yml | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 .github/workflows/build.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 0000000..1de662a
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,34 @@
+jobs:
+  release:
+    name: Release - ${{ matrix.platform.os-name }}
+    strategy:
+      matrix:
+        platform:
+          - os-name: Linux-x86_64
+            runs-on: ubuntu-20.04
+            target: x86_64-unknown-linux-musl
+          - os-name: Linux-arm
+            runs-on: ubuntu-20.04
+            target: arm-unknown-linux-musleabi
+          - os-name: Linux-i686
+            runs-on: ubuntu-20.04
+            target: i686-unknown-linux-musl
+          - os-name: Linux-aarch64
+            runs-on: ubuntu-20.04
+            target: aarch64-unknown-linux-musl
+    runs-on: ${{ matrix.platform.runs-on }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Build binary
+        uses: houseabsolute/actions-rust-cross@v0
+        with:
+          command: ${{ matrix.platform.command }}
+          target: ${{ matrix.platform.target }}
+          args: "--locked --release"
+          strip: true
+      - name: Publish artifacts and release
+        uses: houseabsolute/actions-rust-release@v0
+        with:
+          executable-name: taptap
+          target: ${{ matrix.platform.target }}

From 8ea59905dfc898ad5c7c80a5695777ce5ecb4566 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 16:14:30 +0100
Subject: [PATCH 02/26] Update build.yml

---
 .github/workflows/build.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1de662a..3b08e61 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,7 +1,19 @@
+name: "Build"
+
+on:
+  push:
+    branches:
+      - "main"
+    tags-ignore:
+      - "**"
+  pull_request:
+  workflow_dispatch:
+
 jobs:
   release:
     name: Release - ${{ matrix.platform.os-name }}
     strategy:
+      fail-fast: false
       matrix:
         platform:
           - os-name: Linux-x86_64

From 84bf12979153f1845a1e5c2bce28aa7f30137e11 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 16:23:14 +0100
Subject: [PATCH 03/26] Create Changes.md

---
 Changes.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 Changes.md

diff --git a/Changes.md b/Changes.md
new file mode 100644
index 0000000..0bacec7
--- /dev/null
+++ b/Changes.md
@@ -0,0 +1 @@
+Initial build for 0.1.1

From 18a24b3d19f30847925d3e0640ce53ee8621918d Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 16:46:25 +0100
Subject: [PATCH 04/26] Update build.yml

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3b08e61..bf41b75 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,7 +8,7 @@ on:
       - "**"
   pull_request:
   workflow_dispatch:
-
+  release:
 jobs:
   release:
     name: Release - ${{ matrix.platform.os-name }}

From ae6514cf1c0b27295972bea602bf7a87468991a6 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 17:00:37 +0100
Subject: [PATCH 05/26] Update build.yml

---
 .github/workflows/build.yml | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index bf41b75..0f1126a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -4,11 +4,9 @@ on:
   push:
     branches:
       - "main"
-    tags-ignore:
-      - "**"
-  pull_request:
+    tags:
+    - 'v*'
   workflow_dispatch:
-  release:
 jobs:
   release:
     name: Release - ${{ matrix.platform.os-name }}

From 8fb614a6d8b64f474431dceb3b56d5a379e09300 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Thu, 6 Mar 2025 23:32:19 +0100
Subject: [PATCH 06/26] Update build.yml rust-cross action

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 0f1126a..e02abac 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -31,7 +31,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
       - name: Build binary
-        uses: houseabsolute/actions-rust-cross@v0
+        uses: houseabsolute/actions-rust-cross@v1
         with:
           command: ${{ matrix.platform.command }}
           target: ${{ matrix.platform.target }}

From 5d967ee22b2841f1e553cf6a2b35b1893086ab3f Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Thu, 6 Mar 2025 23:35:27 +0100
Subject: [PATCH 07/26] Update build.yml

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e02abac..eac3e13 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -29,7 +29,7 @@ jobs:
     runs-on: ${{ matrix.platform.runs-on }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Build binary
         uses: houseabsolute/actions-rust-cross@v1
         with:

From 73109d53bb1e28e8532574c092da33b94a613c5e Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Thu, 6 Mar 2025 23:41:59 +0100
Subject: [PATCH 08/26] Update build.yml

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index eac3e13..d13dad2 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -33,7 +33,7 @@ jobs:
       - name: Build binary
         uses: houseabsolute/actions-rust-cross@v1
         with:
-          command: ${{ matrix.platform.command }}
+          command: "build"
           target: ${{ matrix.platform.target }}
           args: "--locked --release"
           strip: true

From 265d6827a2029cb2821514529b3b2cc7e92b92fe Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 7 Mar 2025 00:13:15 +0100
Subject: [PATCH 09/26] Update main.rs

---
 src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index f72c394..c433edb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -53,7 +53,7 @@ enum Commands {
 }
 
 #[derive(Args, Debug, Clone)]
-#[group(required = true, multiple = false)]
+#[group(required = true, multiple = true)]
 struct Source {
     /// The name of the serial port (try `taptap list-serial-ports`)
     #[arg(long, group = "mode", value_name = "SERIAL-PORT")]

From a55ca72d750d7f774055b23b7e830c1567f75840 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Wed, 19 Mar 2025 18:15:06 +0100
Subject: [PATCH 10/26] Update build.yml

added arm7
---
 .github/workflows/build.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d13dad2..3c7c73e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -20,6 +20,9 @@ jobs:
           - os-name: Linux-arm
             runs-on: ubuntu-20.04
             target: arm-unknown-linux-musleabi
+          - os-name: Linux-arm
+            runs-on: ubuntu-20.04
+            target: armv7-unknown-linux-musleabihf
           - os-name: Linux-i686
             runs-on: ubuntu-20.04
             target: i686-unknown-linux-musl

From 9bc04a39bffb60a3ef49251f53473d888b667595 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Wed, 19 Mar 2025 18:18:46 +0100
Subject: [PATCH 11/26] Update build.yml

changed arm target to armhf
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3c7c73e..b8618f2 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,7 +19,7 @@ jobs:
             target: x86_64-unknown-linux-musl
           - os-name: Linux-arm
             runs-on: ubuntu-20.04
-            target: arm-unknown-linux-musleabi
+            target: arm-unknown-linux-musleabihf
           - os-name: Linux-arm
             runs-on: ubuntu-20.04
             target: armv7-unknown-linux-musleabihf

From 407e7a27747e4af26e9809cf4bf0a98d6ff3fa6e Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sun, 1 Jun 2025 17:29:29 +0200
Subject: [PATCH 12/26] add GNU build targets

add GNU build targets
---
 .github/workflows/build.yml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b8618f2..612190c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -14,18 +14,33 @@ jobs:
       fail-fast: false
       matrix:
         platform:
+          - os-name: Linux-x86_64
+            runs-on: ubuntu-20.04
+            target: x86_64-unknown-linux-gnu
           - os-name: Linux-x86_64
             runs-on: ubuntu-20.04
             target: x86_64-unknown-linux-musl
+          - os-name: Linux-arm
+            runs-on: ubuntu-20.04
+            target: arm-unknown-linux-gnueabihf
           - os-name: Linux-arm
             runs-on: ubuntu-20.04
             target: arm-unknown-linux-musleabihf
+          - os-name: Linux-arm
+            runs-on: ubuntu-20.04
+            target: armv7-unknown-linux-gnueabihf
           - os-name: Linux-arm
             runs-on: ubuntu-20.04
             target: armv7-unknown-linux-musleabihf
+          - os-name: Linux-i686
+            runs-on: ubuntu-20.04
+            target: i686-unknown-linux-gnu
           - os-name: Linux-i686
             runs-on: ubuntu-20.04
             target: i686-unknown-linux-musl
+          - os-name: Linux-aarch64
+            runs-on: ubuntu-20.04
+            target: aarch64-unknown-linux-gnu
           - os-name: Linux-aarch64
             runs-on: ubuntu-20.04
             target: aarch64-unknown-linux-musl

From f57c2978d1cbf8d2431cc10777cffad08b3d1da2 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sun, 1 Jun 2025 17:31:08 +0200
Subject: [PATCH 13/26] update runner to Ubuntu 22.04

---
 .github/workflows/build.yml | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 612190c..ee3b500 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,34 +15,34 @@ jobs:
       matrix:
         platform:
           - os-name: Linux-x86_64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
           - os-name: Linux-x86_64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: x86_64-unknown-linux-musl
           - os-name: Linux-arm
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: arm-unknown-linux-gnueabihf
           - os-name: Linux-arm
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: arm-unknown-linux-musleabihf
           - os-name: Linux-arm
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: armv7-unknown-linux-gnueabihf
           - os-name: Linux-arm
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: armv7-unknown-linux-musleabihf
           - os-name: Linux-i686
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: i686-unknown-linux-gnu
           - os-name: Linux-i686
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: i686-unknown-linux-musl
           - os-name: Linux-aarch64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: aarch64-unknown-linux-gnu
           - os-name: Linux-aarch64
-            runs-on: ubuntu-20.04
+            runs-on: ubuntu-22.04
             target: aarch64-unknown-linux-musl
     runs-on: ${{ matrix.platform.runs-on }}
     steps:

From 76c3faf2ac32f631574bc4fd9123d65dae49af97 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sun, 1 Jun 2025 17:37:54 +0200
Subject: [PATCH 14/26] Update build.yml

---
 .github/workflows/build.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ee3b500..7cd5673 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -48,6 +48,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libudev-dev
       - name: Build binary
         uses: houseabsolute/actions-rust-cross@v1
         with:

From c06db7950977b79fb0f8a15e3094ccfe25d0ea50 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sun, 1 Jun 2025 18:12:54 +0200
Subject: [PATCH 15/26] Update build.yml

---
 .github/workflows/build.yml | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 7cd5673..a1a1209 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -14,33 +14,18 @@ jobs:
       fail-fast: false
       matrix:
         platform:
-          - os-name: Linux-x86_64
-            runs-on: ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
           - os-name: Linux-x86_64
             runs-on: ubuntu-22.04
             target: x86_64-unknown-linux-musl
-          - os-name: Linux-arm
-            runs-on: ubuntu-22.04
-            target: arm-unknown-linux-gnueabihf
           - os-name: Linux-arm
             runs-on: ubuntu-22.04
             target: arm-unknown-linux-musleabihf
-          - os-name: Linux-arm
-            runs-on: ubuntu-22.04
-            target: armv7-unknown-linux-gnueabihf
           - os-name: Linux-arm
             runs-on: ubuntu-22.04
             target: armv7-unknown-linux-musleabihf
-          - os-name: Linux-i686
-            runs-on: ubuntu-22.04
-            target: i686-unknown-linux-gnu
           - os-name: Linux-i686
             runs-on: ubuntu-22.04
             target: i686-unknown-linux-musl
-          - os-name: Linux-aarch64
-            runs-on: ubuntu-22.04
-            target: aarch64-unknown-linux-gnu
           - os-name: Linux-aarch64
             runs-on: ubuntu-22.04
             target: aarch64-unknown-linux-musl

From 2585f51610e9de8d43bcf42f4dd9d222cf648296 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Wed, 22 Oct 2025 22:53:52 +0200
Subject: [PATCH 16/26] Reconnect logic

* implemented TCP keep alives

* reconnect logic implementation

* updated README for new  features

* read code de-duplication into function
---
 Cargo.lock                  |  17 ++-
 Cargo.toml                  |   1 +
 README.md                   |  28 ++--
 src/config.rs               |  39 +++++-
 src/gateway/physical/tcp.rs |  51 ++++++-
 src/gateway/transport.rs    |   2 +-
 src/main.rs                 | 256 ++++++++++++++++++++++--------------
 7 files changed, 277 insertions(+), 117 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 77d1006..d779e1f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "adler"
@@ -300,9 +300,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libudev"
@@ -553,6 +553,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -584,6 +594,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serialport",
+ "socket2",
  "thiserror",
  "zerocopy",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 6a5e22a..ad2d4df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,7 @@ libc = "0.2.155"
 zerocopy = { version = "0.8.0-alpha.16", features = ["derive"] }
 flate2 = "1.0"
 log = "0.4.22"
+socket2 = { version = "0.5.10", features = ["all"] }
 
 # Optional library features
 serialport = { version = "4.4", optional = true }
diff --git a/README.md b/README.md
index 35a206d..b1c690a 100644
--- a/README.md
+++ b/README.md
@@ -105,19 +105,29 @@ etc. It is a fast way to get started for some users, but consider wiring in a se
 
 ```console
 % taptap
-Usage: taptap <COMMAND>
+Usage: taptap <COMMAND> <OPTION>
 
 Commands:
-  observe            Observe the system, extracting data as it runs
-  list-serial-ports  List `--serial` ports
-  peek-bytes         Peek at the raw data flowing at the gateway physical layer
-  peek-frames        Peek at the assembled frames at the gateway link layer
-  peek-activity      Peek at the gateway transport and PV application layer activity
-  help               Print this message or the help of the given subcommand(s)
+  observe               Observe the system, extracting data as it runs
+  list-serial-ports     List `--serial` ports
+  peek-bytes            Peek at the raw data flowing at the gateway physical layer
+  peek-frames           Peek at the assembled frames at the gateway link layer
+  peek-activity         Peek at the gateway transport and PV application layer activity
+  help                  Print this message or the help of the given subcommand(s)
+  
 
 Options:
-  -h, --help     Print help
-  -V, --version  Print version
+  --serial              The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
+  --tcp                 The IP or hostname of the device which is providing Modbus-over-TCP service (mutually exclusive to --serial)
+  --reconnect_timeout   The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
+  --reconnect-retry     The number of times to retry reconnecting before giving up (default is 0, i.e. infinite retries)
+  --reconnect-delay     The delay between reconnect attempts in seconds (default is 5s)
+  --port                If --tcp is specified, the port to which to connect (default is 502)
+  --keepalive_idle      If --tcp is specified, the idle time in seconds before TCP keepalive probes are sent (default is 30s)
+  --keepalive_interval  If --tcp is specified, the interval between individual TCP keepalive probes in seconds (default is 10s)
+  --keepalive_count     If --tcp is specified, the number of unacknowledged TCP keepalive probes before the connection is considered dead (default is 5)
+  -h, --help            Print help
+  -V, --version         Print version
 
 % taptap observe --tcp 172.21.3.44
 {"gateway":{"id":4609},"node":{"id":116},"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.6,"voltage_out":30.2,"current":6.94,"dc_dc_duty_cycle":1.0,"temperature":26.8,"rssi":132}
diff --git a/src/config.rs b/src/config.rs
index 102a2eb..aea1980 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -25,7 +25,13 @@ impl SourceConfig {
                     ConnectionMode::ReadOnly => true,
                 };
 
-                let conn = gateway::physical::tcp::Connection::connect(addr, readonly)?;
+                let keepalive = TcpKeepaliveConfig {
+                    idle: std::time::Duration::from_secs(config.keepalive_idle),
+                    interval: std::time::Duration::from_secs(config.keepalive_interval),
+                    count: config.keepalive_count,
+                };
+
+                let conn = gateway::physical::tcp::Connection::connect(addr, readonly, keepalive)?;
                 Ok(Box::new(conn))
             }
         }
@@ -49,6 +55,12 @@ pub struct TcpConnectionConfig {
     #[serde(default = "default_port")]
     pub port: u16,
     pub mode: ConnectionMode,
+    #[serde(default = "default_keepalive_idle")]
+    pub keepalive_idle: u64,
+    #[serde(default = "default_keepalive_interval")]
+    pub keepalive_interval: u64,
+    #[serde(default = "default_keepalive_count")]
+    pub keepalive_count: u32,
 }
 impl From<TcpConnectionConfig> for SourceConfig {
     fn from(value: TcpConnectionConfig) -> Self {
@@ -56,8 +68,31 @@ impl From<TcpConnectionConfig> for SourceConfig {
     }
 }
 
+/// Configuration options for TCP keepalive.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct TcpKeepaliveConfig {
+    /// Idle time before keepalive probes are sent.
+    pub idle: std::time::Duration,
+    /// Interval between individual keepalive probes.
+    pub interval: std::time::Duration,
+    /// Number of unacknowledged probes before the connection is considered dead.
+    pub count: u32,
+}
+
 fn default_port() -> u16 {
-    7160
+    502
+}
+
+fn default_keepalive_idle() -> u64 {
+    30
+}
+
+fn default_keepalive_interval() -> u64 {
+    10
+}
+
+fn default_keepalive_count() -> u32 {
+    5
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Default, Serialize, Deserialize, JsonSchema)]
diff --git a/src/gateway/physical/tcp.rs b/src/gateway/physical/tcp.rs
index 4cbfcc7..e7248fa 100644
--- a/src/gateway/physical/tcp.rs
+++ b/src/gateway/physical/tcp.rs
@@ -1,3 +1,4 @@
+use crate::config::TcpKeepaliveConfig;
 use std::io::{Read, Write};
 use std::net::{TcpStream, ToSocketAddrs};
 
@@ -9,10 +10,19 @@ pub struct Connection {
 }
 
 impl Connection {
-    pub fn connect<A: ToSocketAddrs>(addr: A, readonly: bool) -> Result<Self, std::io::Error> {
+    pub fn connect<A: ToSocketAddrs>(
+        addr: A,
+        readonly: bool,
+        keepalive: TcpKeepaliveConfig,
+    ) -> Result<Self, std::io::Error> {
         let socket = TcpStream::connect(addr)?;
 
-        Ok(Self { socket, readonly })
+        enable_keepalive(&socket, keepalive)?;
+
+        Ok(Self {
+            socket,
+            readonly,
+        })
     }
 }
 
@@ -41,3 +51,40 @@ impl Write for Connection {
         }
     }
 }
+
+/// Enable TCP keepalive and configure its parameters as supported by the platform.
+fn enable_keepalive(socket: &TcpStream, cfg: TcpKeepaliveConfig) -> std::io::Result<()> {
+    //use std::os::unix::prelude::AsRawFd;
+    use socket2::{Socket, TcpKeepalive};
+
+    let sock = Socket::from(socket.try_clone()?);
+
+    let mut keepalive = TcpKeepalive::new();
+
+    //if let Some(idle) = cfg.idle {
+    //    keepalive = keepalive.with_time(idle);
+    //}
+    keepalive = keepalive.with_time(cfg.idle);
+    //if let Some(interval) = cfg.interval {
+    //    keepalive = keepalive.with_interval(interval);
+    //}
+    keepalive = keepalive.with_interval(cfg.interval);
+    // Note: .with_retries() is not available on all platforms.
+    #[cfg(any(
+        target_os = "linux",
+        target_os = "android",
+        target_os = "windows",
+        target_os = "macos",
+        target_os = "ios"
+    ))]
+    if true {
+        keepalive = keepalive.with_retries(cfg.count);
+    }
+    //if let Some(count) = cfg.count {
+    //    keepalive = keepalive.with_retries(count);
+    //}
+
+    sock.set_tcp_keepalive(&keepalive)?;
+
+    Ok(())
+}
diff --git a/src/gateway/transport.rs b/src/gateway/transport.rs
index cf93e16..9c3afe0 100644
--- a/src/gateway/transport.rs
+++ b/src/gateway/transport.rs
@@ -105,7 +105,7 @@ impl ReceiveResponse {
     pub fn read_from_bytes(
         bytes: &[u8],
         packet_number: u16,
-    ) -> Result<(Self, pv::network::ReceivedPackets), InvalidReceiveResponse> {
+    ) -> Result<(Self, pv::network::ReceivedPackets<'_>), InvalidReceiveResponse> {
         // Ensure we have at least a minimal length
         if bytes.len() < 2 {
             return Err(InvalidReceiveResponse::TooShort(5));
diff --git a/src/main.rs b/src/main.rs
index c433edb..29c08e5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,9 +2,10 @@ use clap::{Args, Parser, Subcommand};
 use log::LevelFilter;
 use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
-use std::io::{Read, Write};
+use std::io::{ErrorKind, Read, Write};
 use std::process::exit;
-use taptap::gateway::physical::Connection;
+use std::thread::sleep;
+use std::time::{Duration, Instant};
 use taptap::gateway::{physical, Frame, GatewayID};
 use taptap::pv::application::{NodeTableResponseEntry, PowerReport, TopologyReport};
 use taptap::pv::network::{NodeAddress, ReceivedPacketHeader};
@@ -55,29 +56,150 @@ enum Commands {
 #[derive(Args, Debug, Clone)]
 #[group(required = true, multiple = true)]
 struct Source {
-    /// The name of the serial port (try `taptap list-serial-ports`)
+    /// The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
     #[arg(long, group = "mode", value_name = "SERIAL-PORT")]
     #[cfg(feature = "serialport")]
     serial: Option<String>,
 
-    /// The IP or hostname which is providing serial-over-TCP service
+    /// The IP or hostname of the device which is providing Modbus-over-TCP service
     #[arg(long, group = "mode", value_name = "DESTINATION")]
     tcp: Option<String>,
 
-    // If --tcp is specified, the port to which to connect
-    #[arg(long, requires = "tcp", default_value_t = 7160)]
+    /// The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
+    #[arg(long, default_value = Some("0"))]
+    reconnect_timeout: u64,
+
+    /// The number of times to retry reconnecting before giving up (default is 0, i.e. infinite retries)
+    #[arg(long, default_value = Some("0"))]
+    reconnect_retry: u32,
+
+    /// The delay between reconnect attempts in seconds (default is 5s)
+    #[arg(long, default_value = Some("5"))]
+    reconnect_delay: u64,
+
+    /// If --tcp is specified, the port to which to connect (default is 502)
+    #[arg(long, requires = "tcp", default_value = Some("502"))]
     port: u16,
+
+    /// If --tcp is specified, the idle time in seconds before keepalive probes are sent (default is 30s)
+    #[arg(long, requires = "tcp", default_value = Some("30"))]
+    keepalive_idle: u64,
+
+    /// If --tcp is specified, the interval between individual keepalive probes in seconds (default is 10s)
+    #[arg(long, requires = "tcp", default_value = Some("10"))]
+    keepalive_interval: u64,
+
+    /// If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead (default is 5)
+    #[arg(long, requires = "tcp", default_value = Some("5"))]
+    keepalive_count: u32,
 }
 
 impl Source {
-    fn open(&self) -> Box<dyn physical::Connection> {
-        let src = config::SourceConfig::from(self.clone());
-        match src.open() {
-            Ok(s) => s,
-            Err(e) => {
-                log::error!("error opening source: {}", e);
-                exit(2);
+    fn read<F>(&self, mut callback: F)
+    where
+        F: FnMut(&[u8]),
+    {
+        let source = config::SourceConfig::from(self.clone());
+        let reconnect_timeout = Duration::from_secs(self.reconnect_timeout);
+        let reconnect_delay = Duration::from_secs(self.reconnect_delay);
+        let mut reconnect_retry = 0;
+
+        loop {
+            let mut buffer = [0u8; 1024];
+            let mut conn;
+
+            log::info!("opening source connection...");
+            match source.open() {
+                Ok(s) => {
+                    conn = s;
+                    log::info!("source opened, entering read loop");
+                }
+                Err(e) => {
+                    log::error!("error opening source: {}", e);
+                    reconnect_retry += 1;
+                    if self.reconnect_retry != 0 && reconnect_retry > self.reconnect_retry {
+                        log::warn!(
+                            "maximum reconnect retries ({}) exceeded, exiting",
+                            self.reconnect_retry.to_string()
+                        );
+                        exit(2);
+                    } else {
+                        log::info!(
+                            "reconnect retry {}/{}",
+                            reconnect_retry,
+                            if self.reconnect_retry == 0 {
+                                "∞".to_string()
+                            } else {
+                                self.reconnect_retry.to_string()
+                            }
+                        );
+                        log::info!("reconnecting in {:?}...", reconnect_delay);
+                        sleep(reconnect_delay);
+                        continue;
+                    }
+                }
+            };
+
+            let mut last_received = Instant::now();
+
+            loop {
+                let slice;
+                match conn.read(&mut buffer) {
+                    Ok(n) => {
+                        if n == 0 {
+                            log::warn!("connection closed by peer, will reconnect");
+                            break; // outer loop will reopen
+                        }
+                        last_received = Instant::now();
+                        reconnect_retry = 0;
+                        slice = &buffer[..n];
+                    }
+                    Err(e) => match e.kind() {
+                        ErrorKind::TimedOut | ErrorKind::WouldBlock => {
+                            if self.reconnect_timeout == 0
+                                || last_received.elapsed() < reconnect_timeout
+                            {
+                                // temporary, continue reading
+                                continue;
+                            } else {
+                                log::warn!(
+                                    "no data for {:?}, reconnecting (idle timeout)",
+                                    reconnect_timeout
+                                );
+                                reconnect_retry += 1;
+                                if self.reconnect_retry != 0
+                                    && reconnect_retry > self.reconnect_retry
+                                {
+                                    log::warn!(
+                                        "maximum reconnect retries ({}) exceeded, exiting",
+                                        self.reconnect_retry
+                                    );
+                                    exit(3);
+                                } else {
+                                    log::info!(
+                                        "reconnect retry {}/{}",
+                                        reconnect_retry,
+                                        if self.reconnect_retry == 0 {
+                                            "∞".to_string()
+                                        } else {
+                                            self.reconnect_retry.to_string()
+                                        }
+                                    );
+                                }
+                                break;
+                            }
+                        }
+                        ErrorKind::Interrupted => continue,
+                        _ => {
+                            log::error!("error reading: {}, will reconnect", e);
+                            break;
+                        }
+                    },
+                };
+                callback(slice);
             }
+            log::info!("reconnecting in {:?}...", reconnect_delay);
+            sleep(reconnect_delay);
         }
     }
 }
@@ -94,6 +216,9 @@ impl From<Source> for config::SourceConfig {
                 hostname: name,
                 port: value.port,
                 mode: config::ConnectionMode::ReadOnly,
+                keepalive_idle: value.keepalive_idle,
+                keepalive_interval: value.keepalive_interval,
+                keepalive_count: value.keepalive_count,
             }
             .into(),
             _ => {
@@ -113,54 +238,34 @@ fn main() {
 
     match cli.command {
         Commands::PeekBytes { source, raw } => {
-            let source = source.open();
             peek_bytes(source, raw);
         }
 
         Commands::PeekFrames { source } => {
-            let source = source.open();
             peek_frames(source);
         }
 
         Commands::PeekActivity { source } => {
-            let source = source.open();
             peek_activity(source);
         }
 
+        Commands::Observe { source } => observe(source),
+
         #[cfg(feature = "serialport")]
         Commands::ListSerialPorts => {
             list_serial_ports();
         }
-
-        Commands::Observe { source } => {
-            let source = source.open();
-            observe(source)
-        }
     }
 }
 
-fn peek_bytes(mut conn: Box<dyn physical::Connection>, raw: bool) {
-    let mut buffer = [0u8; 1024];
-    let mut last_was_7e = false;
-
-    loop {
-        let slice = match conn.read(&mut buffer) {
-            Ok(n) => &buffer[0..n],
-            Err(e) => {
-                log::error!("error reading: {}", e);
-                exit(1);
-            }
-        };
-
-        if slice.is_empty() {
-            return;
-        }
-
+fn peek_bytes(source: Source, raw: bool) {
+    source.read(|slice| {
         let mut out = std::io::stdout().lock();
         if raw {
             out.write_all(slice).unwrap();
         } else {
             let mut formatted = Vec::with_capacity(4 * slice.len());
+            let mut last_was_7e = false;
             for byte in slice {
                 let sep = if last_was_7e && *byte == 0x08 {
                     '\n'
@@ -170,43 +275,24 @@ fn peek_bytes(mut conn: Box<dyn physical::Connection>, raw: bool) {
                 write!(&mut formatted, "{:02X}{}", byte, sep).unwrap();
                 last_was_7e = *byte == 0x7e;
             }
-
             out.write_all(formatted.as_slice()).unwrap();
         }
         out.flush().unwrap();
-    }
+    });
 }
 
-fn peek_frames(mut conn: Box<dyn physical::Connection>) {
-    let mut buffer = [0u8; 1024];
-
+fn peek_frames(source: Source) {
     struct Sink;
     impl taptap::gateway::link::Sink for Sink {
         fn frame(&mut self, frame: Frame) {
             println!("{:?}", frame);
         }
     }
-
     let mut rx = taptap::gateway::link::Receiver::new(Sink);
-
-    loop {
-        let slice = match conn.read(&mut buffer) {
-            Ok(n) => &buffer[0..n],
-            Err(e) => {
-                log::error!("error reading: {}", e);
-                exit(1);
-            }
-        };
-
-        if slice.is_empty() {
-            return;
-        }
-
-        rx.extend_from_slice(slice);
-    }
+    source.read(|slice| rx.extend_from_slice(slice));
 }
 
-fn peek_activity(mut conn: Box<dyn physical::Connection>) {
+fn peek_activity(source: Source) {
     #[derive(Default)]
     struct Sink {
         slot_counters: BTreeMap<GatewayID, SlotCounter>,
@@ -361,23 +447,17 @@ fn peek_activity(mut conn: Box<dyn physical::Connection>) {
         pv::application::Receiver::new(Sink::default()),
     ));
 
-    let mut buffer = [0u8; 1024];
-    loop {
-        let slice = match conn.read(&mut buffer) {
-            Ok(n) => &buffer[0..n],
-            Err(e) => {
-                log::error!("error reading: {}", e);
-                exit(1);
-            }
-        };
-
-        if slice.is_empty() {
-            return;
-        }
+    source.read(|slice| rx.extend_from_slice(slice));
+}
 
-        rx.extend_from_slice(slice);
-    }
+fn observe(source: Source) {
+    let observer = taptap::observer::Observer::default();
+    let mut rx = gateway::link::Receiver::new(gateway::transport::Receiver::new(
+        pv::application::Receiver::new(observer),
+    ));
+    source.read(|slice| rx.extend_from_slice(slice));
 }
+
 #[cfg(feature = "serialport")]
 fn list_serial_ports() {
     use serialport::SerialPortType;
@@ -420,27 +500,3 @@ fn list_serial_ports() {
         }
     }
 }
-
-fn observe(mut conn: Box<dyn Connection>) {
-    let observer = taptap::observer::Observer::default();
-    let mut rx = gateway::link::Receiver::new(gateway::transport::Receiver::new(
-        pv::application::Receiver::new(observer),
-    ));
-
-    let mut buffer = [0u8; 1024];
-    loop {
-        let slice = match conn.read(&mut buffer) {
-            Ok(n) => &buffer[0..n],
-            Err(e) => {
-                log::error!("error reading: {}", e);
-                exit(1);
-            }
-        };
-
-        if slice.is_empty() {
-            return;
-        }
-
-        rx.extend_from_slice(slice);
-    }
-}

From 30c1cdfc24af81ec3ac3e2a309c2fb4fc5619749 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Wed, 22 Oct 2025 23:00:51 +0200
Subject: [PATCH 17/26] Fix README typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b1c690a..e1f065c 100644
--- a/README.md
+++ b/README.md
@@ -119,7 +119,7 @@ Commands:
 Options:
   --serial              The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
   --tcp                 The IP or hostname of the device which is providing Modbus-over-TCP service (mutually exclusive to --serial)
-  --reconnect_timeout   The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
+  --reconnect-timeout   The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
   --reconnect-retry     The number of times to retry reconnecting before giving up (default is 0, i.e. infinite retries)
   --reconnect-delay     The delay between reconnect attempts in seconds (default is 5s)
   --port                If --tcp is specified, the port to which to connect (default is 502)

From 281590ee4351bc29f442d674dd6b075dd3f05f2f Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 11:52:04 +0200
Subject: [PATCH 18/26] cli arguments improvement (#3)

* implemented TCP keep alives

* refactored TCP keepalive patch

* updated Cargo.lock

* fix keepalive retries compilation

* compilation fixes

* fix unused code

* fix arguments comments

* updated Help and README

* initial reconnect logic implementation

* compilation fixes, reformated

* updated README for new reconnect feature
unified buffer read
added reconnect logging

* reconnect logic de-duplication into function

* implement retry mechanism on connection open fail

* README typo fix

* improved cli arguments dependencies

* arg dependencies
---
 src/main.rs | 49 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 29c08e5..583715b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,6 +22,7 @@ struct Cli {
 
 #[derive(Subcommand, Debug, Clone)]
 enum Commands {
+    /// List the serial ports available on this system
     #[cfg(feature = "serialport")]
     ListSerialPorts,
 
@@ -54,43 +55,53 @@ enum Commands {
 }
 
 #[derive(Args, Debug, Clone)]
-#[group(required = true, multiple = true)]
+#[group(id="mode", required = true, multiple = true, args=&["serial", "tcp"])]
 struct Source {
     /// The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
-    #[arg(long, group = "mode", value_name = "SERIAL-PORT")]
+    #[arg(
+        long,
+        required = true,
+        conflicts_with = "tcp",
+        value_name = "SERIAL-PORT"
+    )]
     #[cfg(feature = "serialport")]
     serial: Option<String>,
 
     /// The IP or hostname of the device which is providing Modbus-over-TCP service
-    #[arg(long, group = "mode", value_name = "DESTINATION")]
+    #[arg(
+        long,
+        required = true,
+        conflicts_with = "serial",
+        value_name = "DESTINATION"
+    )]
     tcp: Option<String>,
 
-    /// The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
-    #[arg(long, default_value = Some("0"))]
+    /// If --tcp is specified, the port to which to connect
+    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "PORT NUMBER", default_value = Some("502"))]
+    port: u16,
+
+    /// The time after which connection is re-established if no data is received in seconds (0 for no timeout)
+    #[arg(long, required = false, value_name = "SECONDS", default_value = Some("0"))]
     reconnect_timeout: u64,
 
-    /// The number of times to retry reconnecting before giving up (default is 0, i.e. infinite retries)
-    #[arg(long, default_value = Some("0"))]
+    /// The number of times to retry reconnecting before giving up (0 for infinite retries)
+    #[arg(long, required = false, value_name = "INT", default_value = Some("0"))]
     reconnect_retry: u32,
 
-    /// The delay between reconnect attempts in seconds (default is 5s)
-    #[arg(long, default_value = Some("5"))]
+    /// The delay between reconnect attempts in seconds
+    #[arg(long, required = false, value_name = "SECONDS", default_value = Some("5"))]
     reconnect_delay: u64,
 
-    /// If --tcp is specified, the port to which to connect (default is 502)
-    #[arg(long, requires = "tcp", default_value = Some("502"))]
-    port: u16,
-
-    /// If --tcp is specified, the idle time in seconds before keepalive probes are sent (default is 30s)
-    #[arg(long, requires = "tcp", default_value = Some("30"))]
+    /// If --tcp is specified, the idle time in seconds before keepalive probes are sent
+    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("30"))]
     keepalive_idle: u64,
 
-    /// If --tcp is specified, the interval between individual keepalive probes in seconds (default is 10s)
-    #[arg(long, requires = "tcp", default_value = Some("10"))]
+    /// If --tcp is specified, the interval between individual keepalive probes in seconds
+    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("10"))]
     keepalive_interval: u64,
 
-    /// If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead (default is 5)
-    #[arg(long, requires = "tcp", default_value = Some("5"))]
+    /// If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead
+    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("5"))]
     keepalive_count: u32,
 }
 

From 901e832bac034df2a63d4b6f14550379c82433e1 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 12:19:57 +0200
Subject: [PATCH 19/26] added formatted CHANGELOG.md updated Cargo.toml

---
 CHANGELOG.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 Cargo.toml   | 10 +++++-----
 Changes.md   |  1 -
 3 files changed, 55 insertions(+), 6 deletions(-)
 create mode 100644 CHANGELOG.md
 delete mode 100644 Changes.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..df6a85e
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+### Fixed
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+## [0.1.2] - 2025-10-24
+
+### Added
+
+- this Changelog.md file
+- implementation of reconnect logic for both serial and tcp connections
+- implementation of the TCP keepalive probing mechanism
+
+### Fixed
+
+- Rust compilation warnings
+- duplication of main.rs code
+
+### Changed
+
+- updated Cargo deps
+- cli arguments dependencies and exclusions
+- README to reflects new cli arguments
+
+
+## [0.1.1] - 2025-03-25
+
+### Added
+
+- initial build chain implementation
+
+### Fixed
+
+- fixed cli argument ---port can be used together with ---tcp
+
+
diff --git a/Cargo.toml b/Cargo.toml
index ad2d4df..057b62c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "taptap"
 description = "An implementation of the Tigo TAP protocol"
-authors = ["Will Glynn"]
-repository = "https://github.com/willglynn/taptap"
-keywords = ["solar"]
+authors = ["Will Glynn", "LiTinOveWeedle"]
+repository = "https://github.com/litinoveweedle/taptap"
+keywords = ["solar", "Tigo"]
 readme = "README.md"
-version = "0.1.1"
-edition = "2021"
+version = "0.1.2"
+edition = "2025"
 license = "MIT"
 
 [features]
diff --git a/Changes.md b/Changes.md
deleted file mode 100644
index 0bacec7..0000000
--- a/Changes.md
+++ /dev/null
@@ -1 +0,0 @@
-Initial build for 0.1.1

From afd65efba93d0f0da3e5bc32745cd0d6fc151f8e Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 12:22:19 +0200
Subject: [PATCH 20/26] updated Cargo.lock

---
 Cargo.lock | 555 ++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 384 insertions(+), 171 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d779e1f..5740769 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,10 +3,10 @@
 version = 4
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aho-corasick"
@@ -17,12 +17,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -34,9 +28,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.15"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -49,43 +43,44 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.8"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.5"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.1"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.4"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
- "windows-sys",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bitflags"
@@ -95,48 +90,51 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "bumpalo"
-version = "3.16.0"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "cc"
-version = "1.1.6"
+version = "1.2.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
+checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-targets",
+ "windows-link",
 ]
 
 [[package]]
 name = "clap"
-version = "4.5.13"
+version = "4.5.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fbb260a053428790f3de475e304ff84cdbc4face759ea7a3e64c1edd938a7fc"
+checksum = "0c2cfd7bf8a6017ddaa4e32ffe7403d547790db06bd171c1c53926faab501623"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -144,9 +142,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.13"
+version = "4.5.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64b17d7ea74e9f833c7dbf2cbe4fb12ff26783eda4782a8975b72f895c9b4d99"
+checksum = "0a4c05b9e80c5ccd3a7ef080ad7b6ba7d6fc00a985b8b157197075677c82c7a0"
 dependencies = [
  "anstream",
  "anstyle",
@@ -156,9 +154,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.13"
+version = "4.5.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -168,42 +166,52 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.2"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "colorchoice"
-version = "1.0.2"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "core-foundation"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
+checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.17"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "env_filter"
-version = "0.1.2"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
 dependencies = [
  "log",
  "regex",
@@ -211,22 +219,28 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.11.5"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
 dependencies = [
  "anstream",
  "anstyle",
  "env_filter",
- "humantime",
+ "jiff",
  "log",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
 [[package]]
 name = "flate2"
-version = "1.0.31"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f211bbe8e69bbd0cfdea405084f128ae8b4aaa6b0b522fc8f2b009084797920"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -238,22 +252,17 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
  "windows-core",
 ]
@@ -279,30 +288,55 @@ dependencies = [
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jiff"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
 [[package]]
 name = "libudev"
@@ -326,32 +360,33 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "mach2"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.4"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "adler",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
@@ -376,48 +411,69 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "ref-cast"
-version = "1.0.23"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
 dependencies = [
  "ref-cast-impl",
 ]
 
 [[package]]
 name = "ref-cast-impl"
-version = "1.0.23"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -426,9 +482,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -438,9 +494,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -449,21 +505,27 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "ryu"
-version = "1.0.18"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
 [[package]]
 name = "schemars"
-version = "1.0.0-alpha.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec9b1e7918a904d86cb6de7147ff4da21f12ac1462c8049e12b30a8846f4699e"
+checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
 dependencies = [
  "chrono",
  "dyn-clone",
@@ -475,9 +537,9 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "1.0.0-alpha.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2730d5d2dbaf504ab238832cad00b0bdd727436583c7b05f9328e65fee2b475"
+checksum = "33d020396d1d138dc19f1165df7545479dcd58d93810dc5d646a16e55abefa80"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -493,18 +555,28 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -524,35 +596,49 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.122"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784b6203951c57ff748476b126ccb5e8e2959a5c19e5c617ab1956be3dbc68da"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
  "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "serialport"
-version = "4.4.0"
+version = "4.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de7c4f0cce25b9b3518eea99618112f9ee4549f974480c8f43d3c06f03c131a0"
+checksum = "21f60a586160667241d7702c420fc223939fb3c0bb8d3fac84f78768e8970dee"
 dependencies = [
- "bitflags 2.6.0",
+ "bitflags 2.10.0",
  "cfg-if",
+ "core-foundation",
  "core-foundation-sys",
  "io-kit-sys",
  "libudev",
  "mach2",
  "nix",
- "regex",
+ "quote",
  "scopeguard",
  "unescaper",
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -560,7 +646,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -571,9 +657,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.71"
+version = "2.0.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -595,24 +681,44 @@ dependencies = [
  "serde_json",
  "serialport",
  "socket2",
- "thiserror",
+ "thiserror 1.0.69",
  "zerocopy",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.62"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2675633b1499176c2dff06b0856a27976a8f9d436737b4cf4f312d4d91d8bbb"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.62"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20468752b09f49e909e55a5d338caa8bedf615594e9d80bc4c565d30faf798c"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -621,18 +727,18 @@ dependencies = [
 
 [[package]]
 name = "unescaper"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c878a167baa8afd137494101a688ef8c67125089ff2249284bd2b5f9bfedb815"
+checksum = "c01d12e3a56a4432a8b436f293c25f4808bdf9e9f9f98f9260bba1f1bc5a1f26"
 dependencies = [
- "thiserror",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"
 
 [[package]]
 name = "utf8parse"
@@ -642,23 +748,25 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
 dependencies = [
  "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -667,9 +775,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -677,9 +785,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -690,39 +798,70 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
-name = "winapi"
-version = "0.3.9"
+name = "windows-core"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
+name = "windows-implement"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
+name = "windows-interface"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
-name = "windows-core"
-version = "0.52.0"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-targets",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
@@ -731,7 +870,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
 ]
 
 [[package]]
@@ -740,14 +888,31 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
 ]
 
 [[package]]
@@ -756,62 +921,110 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
 [[package]]
 name = "zerocopy"
-version = "0.8.0-alpha.16"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5fe242a39bc4f8b8d808be6314c0f0e5e499a902c44e704f3c86a89f7a7c64"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.0-alpha.16"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76fc519c421ad48c6c8ba02cee449398d54276c839887f9f3562d1862b43b91c"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",

From 0894c449e547d54e25ebd42b6577d0e9d520e4c6 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 12:25:16 +0200
Subject: [PATCH 21/26] bump cargo package release version

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5740769..7570e88 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -668,7 +668,7 @@ dependencies = [
 
 [[package]]
 name = "taptap"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "chrono",
  "clap",
diff --git a/Cargo.toml b/Cargo.toml
index 057b62c..219199d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ repository = "https://github.com/litinoveweedle/taptap"
 keywords = ["solar", "Tigo"]
 readme = "README.md"
 version = "0.1.2"
-edition = "2025"
+edition = "2021"
 license = "MIT"
 
 [features]

From 617ee67c34ff77e1e6e9a4d6a0abcb2688160b3e Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 12:31:29 +0200
Subject: [PATCH 22/26] fix release link to CHANGELOG.md

---
 .github/workflows/build.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a1a1209..4e20737 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -48,4 +48,5 @@ jobs:
         uses: houseabsolute/actions-rust-release@v0
         with:
           executable-name: taptap
+          changes-file: CHANGELOG.md
           target: ${{ matrix.platform.target }}

From 0428723404bbf019b9a57e01d0fc4a90f745ec98 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Fri, 24 Oct 2025 13:33:48 +0200
Subject: [PATCH 23/26] updated README to reflect V0.1.2 chnages set reconnect
 default timeout to 60

---
 README.md   | 30 +++++++++++++++---------------
 src/main.rs |  2 +-
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index e1f065c..a7f322b 100644
--- a/README.md
+++ b/README.md
@@ -108,24 +108,24 @@ etc. It is a fast way to get started for some users, but consider wiring in a se
 Usage: taptap <COMMAND> <OPTION>
 
 Commands:
-  observe               Observe the system, extracting data as it runs
-  list-serial-ports     List `--serial` ports
-  peek-bytes            Peek at the raw data flowing at the gateway physical layer
-  peek-frames           Peek at the assembled frames at the gateway link layer
-  peek-activity         Peek at the gateway transport and PV application layer activity
-  help                  Print this message or the help of the given subcommand(s)
+  list-serial-ports  List the serial ports available on this system
+  observe            Observe the system, extracting data as it runs
+  peek-bytes         Peek at the raw data flowing at the gateway physical layer
+  peek-frames        Peek at the assembled frames at the gateway link layer
+  peek-activity      Peek at the gateway transport and PV application layer activity
+  help               Print this message or the help of the given subcommand(s)
   
 
 Options:
-  --serial              The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
-  --tcp                 The IP or hostname of the device which is providing Modbus-over-TCP service (mutually exclusive to --serial)
-  --reconnect-timeout   The time after which connection is re-established if no data is received in seconds (default is 0s, i.e. no timeout)
-  --reconnect-retry     The number of times to retry reconnecting before giving up (default is 0, i.e. infinite retries)
-  --reconnect-delay     The delay between reconnect attempts in seconds (default is 5s)
-  --port                If --tcp is specified, the port to which to connect (default is 502)
-  --keepalive_idle      If --tcp is specified, the idle time in seconds before TCP keepalive probes are sent (default is 30s)
-  --keepalive_interval  If --tcp is specified, the interval between individual TCP keepalive probes in seconds (default is 10s)
-  --keepalive_count     If --tcp is specified, the number of unacknowledged TCP keepalive probes before the connection is considered dead (default is 5)
+      --serial <SERIAL-PORT>          The name of the serial port (try `taptap list-serial-ports`) of the Modbus-to-serial device (mutually exclusive to --tcp)
+      --tcp <DESTINATION>             The IP or hostname of the device which is providing Modbus-over-TCP service
+      --port <PORT NUMBER>            If --tcp is specified, the port to which to connect [default: 502]
+      --reconnect-timeout <SECONDS>   The time after which connection is re-established if no data is received in seconds (0 for no timeout) [default: 0]
+      --reconnect-retry <INT>         The number of times to retry reconnecting before giving up (0 for infinite retries) [default: 0]
+      --reconnect-delay <SECONDS>     The delay between reconnect attempts in seconds [default: 5]
+      --keepalive-idle <SECONDS>      If --tcp is specified, the idle time in seconds before keepalive probes are sent [default: 30]
+      --keepalive-interval <SECONDS>  If --tcp is specified, the interval between individual keepalive probes in seconds [default: 10]
+      --keepalive-count <SECONDS>     If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead [default: 5]
   -h, --help            Print help
   -V, --version         Print version
 
diff --git a/src/main.rs b/src/main.rs
index 583715b..ea92acb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -81,7 +81,7 @@ struct Source {
     port: u16,
 
     /// The time after which connection is re-established if no data is received in seconds (0 for no timeout)
-    #[arg(long, required = false, value_name = "SECONDS", default_value = Some("0"))]
+    #[arg(long, required = false, value_name = "SECONDS", default_value = Some("60"))]
     reconnect_timeout: u64,
 
     /// The number of times to retry reconnecting before giving up (0 for infinite retries)

From 407c5119931961fd663879902dd57557ef343aa3 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sat, 25 Oct 2025 21:18:42 +0200
Subject: [PATCH 24/26] Note table response fix + persistent storage
 implementation (#4)

* fix invalid NodeTableResponse struct

* added infrastructure event in observe mode - to output in JSON gateway and node details (addresses, barcodes, versions etc.)

* added persistent storage

* Updated README to reflect implementation
---
 README.md                        |  44 +++++--
 src/main.rs                      |  13 +-
 src/observer.rs                  | 204 +++++++++++++++++++++++--------
 src/observer/event.rs            |  26 ++--
 src/observer/persistent_state.rs | 165 +++++++++++++++++++++++++
 src/pv/application/node_table.rs |   1 +
 6 files changed, 374 insertions(+), 79 deletions(-)
 create mode 100644 src/observer/persistent_state.rs

diff --git a/README.md b/README.md
index a7f322b..3d6c042 100644
--- a/README.md
+++ b/README.md
@@ -128,18 +128,40 @@ Options:
       --keepalive-count <SECONDS>     If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead [default: 5]
   -h, --help            Print help
   -V, --version         Print version
+```
+
+## Usage
 
+Most useful for PV panels monitoring is `observe` subcommand. As of this version, the `observe` emits `taptap::observer::Event`s to standard output:
+
+```
 % taptap observe --tcp 172.21.3.44
-{"gateway":{"id":4609},"node":{"id":116},"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.6,"voltage_out":30.2,"current":6.94,"dc_dc_duty_cycle":1.0,"temperature":26.8,"rssi":132}
-{"gateway":{"id":4609},"node":{"id":116},"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.75,"voltage_out":30.4,"current":6.895,"dc_dc_duty_cycle":1.0,"temperature":26.8,"rssi":132}
-{"gateway":{"id":4609},"node":{"id":82},"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.55,"voltage_out":30.2,"current":6.845,"dc_dc_duty_cycle":1.0,"temperature":29.3,"rssi":147}
-{"gateway":{"id":4609},"node":{"id":82},"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.95,"voltage_out":30.6,"current":6.765,"dc_dc_duty_cycle":1.0,"temperature":29.3,"rssi":147}
-{"gateway":{"id":4609},"node":{"id":19},"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.35,"voltage_out":29.9,"current":6.865,"dc_dc_duty_cycle":1.0,"temperature":28.7,"rssi":147}
-{"gateway":{"id":4609},"node":{"id":19},"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":29.85,"voltage_out":29.4,"current":7.005,"dc_dc_duty_cycle":1.0,"temperature":28.7,"rssi":147}
-{"gateway":{"id":4609},"node":{"id":121},"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":29.8,"voltage_out":21.9,"current":5.25,"dc_dc_duty_cycle":0.7607843137254902,"temperature":29.8,"rssi":120}
-{"gateway":{"id":4609},"node":{"id":121},"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.55,"voltage_out":22.8,"current":5.3,"dc_dc_duty_cycle":0.7725490196078432,"temperature":29.8,"rssi":120}
+
+{"event_type": "power_report", "gateway": 4609,"node":116,"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.6,"voltage_out":30.2,"current":6.94,"dc_dc_duty_cycle":1.0,"temperature":26.8,"rssi":132}
+{"event_type": "power_report", "gateway": 4609,"node":116,"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.75,"voltage_out":30.4,"current":6.895,"dc_dc_duty_cycle":1.0,"temperature":26.8,"rssi":132}
+{"event_type": "power_report", "gateway": 4609,"node":82,"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.55,"voltage_out":30.2,"current":6.845,"dc_dc_duty_cycle":1.0,"temperature":29.3,"rssi":147}
+{"event_type": "power_report", "gateway": 4609,"node":82,"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.95,"voltage_out":30.6,"current":6.765,"dc_dc_duty_cycle":1.0,"temperature":29.3,"rssi":147}
+{"event_type": "power_report", "gateway": 4609,"node":19,"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":30.35,"voltage_out":29.9,"current":6.865,"dc_dc_duty_cycle":1.0,"temperature":28.7,"rssi":147}
+{"event_type": "power_report", "gateway": 4609,"node":19,"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":29.85,"voltage_out":29.4,"current":7.005,"dc_dc_duty_cycle":1.0,"temperature":28.7,"rssi":147}
+{"event_type": "power_report", "gateway": 4609,"node":121,"timestamp":"2024-08-24T09:16:41.686961-05:00","voltage_in":29.8,"voltage_out":21.9,"current":5.25,"dc_dc_duty_cycle":0.7607843137254902,"temperature":29.8,"rssi":120}
+{"event_type": "power_report", "gateway": 4609,"node":121,"timestamp":"2024-08-24T09:17:01.691683-05:00","voltage_in":30.55,"voltage_out":22.8,"current":5.3,"dc_dc_duty_cycle":0.7725490196078432,"temperature":29.8,"rssi":120}
+```
+
+Also when frames with gateways or nodes identification are received `taptap::observer::PersistentStateReport` is emitted to tha standard output, including gateways and nodes addresses, versions and barcodes (values are redacted in the sample bellow):
+```
+% taptap observe --tcp 172.21.3.44
+
+{"event_type":"infrastructure_report",
+gateways":{"4609":{"address":"04:C0:5B:30:ZZ:ZZ:ZZ:ZZ","version":"Mgate Version UUUUUUUUUUU\r"},"4610":{"address":"04:C0:5B:30:ZZ:ZZ:ZZ:ZZ","version":""}},"nodes":{"4609":{"2":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"3":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"4":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"5":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"6":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"7":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"8":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"9":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"11":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"12":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"13":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"14":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"15":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"16":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"17":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"},"18":{"address":"04:C0:5B:40:XX:XX:XX:XX","barcode":"4-YYYYYYY"}}}}
+```
+
+## Topology Persistence
+
+As such gateway and nodes identification frames are transmitted rarely (in my experience those are not transmitted during PV panels operation during daytime, but rather after sundown when controller probably starts to execute some housekeeping actions), this version now supports storing infrastructure data in the JSON file, which is used as persistent store, ensuring that such data are not lost during restarts. At taptap start the JSON file is read and `taptap::observer::PersistentStateReport` is immediately emitted from the latest stored state. JSON file is updated immediately after any update message is received. To use persistent function you need to provide runtime argument passing JSON file path (example):
+
+```
+taptap observe --tcp 172.21.3.44 --persistent-file ./taptap.json
 ```
 
-As of this initial version, the `observe` subcommand emits `taptap::observer::Event`s to standard output as JSON rather
-than emitting metrics for InfluxDB or Prometheus, and it does not persist its own state, meaning the gateway and nodes
-are identified by their internal IDs rather than by barcode. These are the next two features to add.
+## Note
+**This version doesn't support and probably never will any messages parsing, corelation or direct database sink to store emitted messages. I like 'KISS' (Keep It Stupid, Simple) principles and I strongly prefer to have simple atomic tool to output Tigo CCA messages and than use more suitable programs for messages parsing, corelation and storing in some backend storage. Take a look into Logstash, FluentD, of if you looking for MQTT bridge you can checkout my [taptap-mqqt project](https://github.com/litinoveweedle/taptap-mqtt/)**
diff --git a/src/main.rs b/src/main.rs
index ea92acb..233090c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -30,6 +30,10 @@ enum Commands {
     Observe {
         #[command(flatten)]
         source: Source,
+
+        /// Path of the JSON file to provide persistent storage for the infrastructure topology data
+        #[arg(long, required = false, value_name = "FILE", default_value = Some(""))]
+        persistent_file: String,
     },
 
     /// Peek at the raw data flowing at the gateway physical layer
@@ -260,7 +264,10 @@ fn main() {
             peek_activity(source);
         }
 
-        Commands::Observe { source } => observe(source),
+        Commands::Observe {
+            source,
+            persistent_file,
+        } => observe(source, persistent_file),
 
         #[cfg(feature = "serialport")]
         Commands::ListSerialPorts => {
@@ -461,8 +468,8 @@ fn peek_activity(source: Source) {
     source.read(|slice| rx.extend_from_slice(slice));
 }
 
-fn observe(source: Source) {
-    let observer = taptap::observer::Observer::default();
+fn observe(source: Source, persistent_file: String) {
+    let observer = taptap::observer::Observer::new(persistent_file);
     let mut rx = gateway::link::Receiver::new(gateway::transport::Receiver::new(
         pv::application::Receiver::new(observer),
     ));
diff --git a/src/observer.rs b/src/observer.rs
index dc155ad..619e5c6 100644
--- a/src/observer.rs
+++ b/src/observer.rs
@@ -24,12 +24,18 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::path::PathBuf;
 use std::time::SystemTime;
 
 pub mod event;
 
+mod persistent_state;
+use persistent_state::{PersistentState, PersistentStateEvent};
+
 mod node_table;
-use node_table::{NodeTable, NodeTableBuilder};
+use node_table::NodeTableBuilder;
 
 mod slot_clock;
 use slot_clock::SlotClock;
@@ -37,8 +43,8 @@ use slot_clock::SlotClock;
 /// An observer, monitoring a controller interacting with one or more TAPs via an RS-485 interface.
 #[derive(Debug)]
 pub struct Observer {
+    persistent_file: String,
     persistent_state: PersistentState,
-
     enumeration_state: Option<EnumerationState>,
     captured_slot_counters: BTreeMap<GatewayID, SystemTime>,
     slot_clocks: BTreeMap<GatewayID, SlotClock>,
@@ -47,45 +53,143 @@ pub struct Observer {
 
 impl Default for Observer {
     fn default() -> Self {
-        Self::from_persistent_state(PersistentState::default())
+        Observer::new(String::new())
     }
 }
 
 impl Observer {
-    pub fn from_persistent_state(persistent_state: PersistentState) -> Self {
-        Observer {
-            persistent_state,
+    pub fn new(persistent_file: String) -> Self {
+        let mut observer = Observer {
+            persistent_file,
+            persistent_state: PersistentState::default(),
             enumeration_state: None,
             captured_slot_counters: Default::default(),
             slot_clocks: Default::default(),
             node_table_builders: Default::default(),
-        }
+        };
+        observer.read_persistent_state();
+        observer
     }
 
-    pub fn persistent_state(&self) -> &PersistentState {
-        &self.persistent_state
+    // If a persistent state JSON file exists, prefer its contents over the provided
+    // `persistent_state` argument. This allows the observer to restore previously
+    // captured infrastructure information across runs.
+    pub fn read_persistent_state(&mut self) -> () {
+        if self.persistent_file.is_empty() {
+            log::info!("persistent file is not specified, will not keep persistent state");
+            return;
+        }
+        let file_path = PathBuf::from(&self.persistent_file);
+        if !file_path.is_file() {
+            log::info!(
+                "persistent file: {} not found, starting with empty state",
+                self.persistent_file
+            );
+            return;
+        }
+        match File::open(&file_path).and_then(|mut file| {
+            let mut string = String::new();
+            file.read_to_string(&mut string)?;
+            serde_json::from_str(&string).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+        }) {
+            Ok(data) => {
+                self.persistent_state = data;
+                log::info!(
+                    "persistent state successfully loaded from persistent file {}",
+                    file_path.display()
+                );
+                // Print out infrastructure event
+                let infrastructure_event = PersistentStateEvent::from(&self.persistent_state);
+                println!("{}", serde_json::to_string(&infrastructure_event).unwrap());
+            }
+            Err(e) => {
+                log::warn!(
+                    "failed to read persistent state from {}: {}",
+                    self.persistent_file,
+                    e
+                );
+            }
+        }
     }
 
-    fn gateway(&self, id: GatewayID) -> event::Gateway {
-        let address = self.persistent_state.gateway_identities.get(&id).copied();
-        event::Gateway { id, address }
-    }
+    /// Write the current `persistent_state` to disk as JSON.
+    ///
+    /// Writes atomically by writing to a temporary file and renaming it into place.
+    pub fn write_persistent_state(&self) -> () {
+        let infrastructure_event = PersistentStateEvent::from(&self.persistent_state);
+        match serde_json::to_string(&infrastructure_event) {
+            Ok(event_str) => println!("{}", event_str),
+            Err(e) => {
+                log::error!("Failed to serialize infrastructure event: {}", e);
+            }
+        }
 
-    fn node(&self, gateway_id: GatewayID, id: NodeID) -> event::Node {
-        let address = self
-            .persistent_state
-            .gateway_node_tables
-            .get(&gateway_id)
-            .and_then(|node_table| node_table.0.get(&id))
-            .copied();
+        let file_path = PathBuf::from(&self.persistent_file);
+        let tmp_path = file_path.with_extension("tmp");
 
-        let barcode = address.map(|addr| addr.into());
+        // Serialize
+        let data = match serde_json::to_vec_pretty(&self.persistent_state) {
+            Ok(data) => data,
+            Err(e) => {
+                log::error!("Failed to serialize persistent state: {}", e);
+                return;
+            }
+        };
+
+        // Write to temporary file
+        let mut file = match File::create(&tmp_path) {
+            Ok(file) => file,
+            Err(e) => {
+                log::error!(
+                    "Failed to create temporary file {}: {}",
+                    tmp_path.display(),
+                    e
+                );
+                return;
+            }
+        };
 
-        event::Node {
-            id,
-            address,
-            barcode,
+        if let Err(e) = file.write_all(&data) {
+            log::error!(
+                "Failed to write data to temporary file {}: {}",
+                tmp_path.display(),
+                e
+            );
+            return;
         }
+
+        if let Err(e) = file.flush() {
+            log::error!(
+                "Failed to flush temporary file {}: {}",
+                tmp_path.display(),
+                e
+            );
+            return;
+        };
+
+        // Rename into place
+        if let Err(e) = std::fs::rename(&tmp_path, &file_path) {
+            log::error!(
+                "Failed to rename temporary file {} to {}: {}",
+                tmp_path.display(),
+                file_path.display(),
+                e
+            );
+            return;
+        };
+
+        // Print out infrastructure event
+        let infrastructure_event = PersistentStateEvent::from(&self.persistent_state);
+        println!("{}", serde_json::to_string(&infrastructure_event).unwrap());
+
+        log::debug!(
+            "Successfully wrote persistent state to persistent file {}",
+            file_path.display()
+        );
+    }
+
+    pub fn persistent_state(&self) -> &PersistentState {
+        &self.persistent_state
     }
 }
 
@@ -108,6 +212,7 @@ impl gateway::transport::Sink for Observer {
             self.persistent_state
                 .gateway_identities
                 .insert(gateway_id, address);
+            self.write_persistent_state();
         }
     }
 
@@ -122,6 +227,7 @@ impl gateway::transport::Sink for Observer {
             self.persistent_state
                 .gateway_versions
                 .insert(gateway_id, version);
+            self.write_persistent_state();
         }
     }
 
@@ -133,6 +239,7 @@ impl gateway::transport::Sink for Observer {
             // existing state
             self.persistent_state.gateway_identities = enumeration_state.gateway_identities;
             self.persistent_state.gateway_versions = enumeration_state.gateway_versions;
+            self.write_persistent_state();
         }
     }
 
@@ -161,24 +268,36 @@ impl gateway::transport::Sink for Observer {
     fn packet_received(
         &mut self,
         _gateway_id: GatewayID,
-        _header: &ReceivedPacketHeader,
-        _data: &[u8],
+        _packet_header: &ReceivedPacketHeader,
+        _packet_data: &[u8],
     ) {
     }
 
     fn command_executed(
         &mut self,
         _gateway_id: GatewayID,
-        _request: (PacketType, &[u8]),
-        _response: (PacketType, &[u8]),
+        _command_request: (PacketType, &[u8]),
+        _command_response: (PacketType, &[u8]),
     ) {
     }
 }
 
 impl pv::application::Sink for Observer {
-    fn string_request(&mut self, _gateway_id: GatewayID, _pv_node_id: NodeID, _request: &str) {}
+    fn string_request(
+        &mut self,
+        _gateway_id: GatewayID,
+        _pv_node_id: NodeID,
+        _string_request: &str,
+    ) {
+    }
 
-    fn string_response(&mut self, _gateway_id: GatewayID, _pv_node_id: NodeID, _response: &str) {}
+    fn string_response(
+        &mut self,
+        _gateway_id: GatewayID,
+        _pv_node_id: NodeID,
+        _string_response: &str,
+    ) {
+    }
 
     fn node_table_page(
         &mut self,
@@ -192,6 +311,7 @@ impl pv::application::Sink for Observer {
             self.persistent_state
                 .gateway_node_tables
                 .insert(gateway_id, new_table);
+            self.write_persistent_state();
         }
     }
 
@@ -206,7 +326,7 @@ impl pv::application::Sink for Observer {
     fn power_report(
         &mut self,
         gateway_id: GatewayID,
-        pv_node_id: NodeID,
+        node_id: NodeID,
         power_report: &pv::application::PowerReport,
     ) {
         let Some(slot_clock) = self.slot_clocks.get(&gateway_id) else {
@@ -218,12 +338,8 @@ impl pv::application::Sink for Observer {
             return;
         };
 
-        let Ok(event) = event::PowerReportEvent::new(
-            self.gateway(gateway_id),
-            self.node(gateway_id, pv_node_id),
-            slot_clock,
-            power_report,
-        ) else {
+        let Ok(event) = event::PowerReportEvent::new(gateway_id, node_id, slot_clock, power_report)
+        else {
             log::error!(
                 "discarding power report from gateway {:?} due to invalid slot counter: {:?}",
                 gateway_id,
@@ -236,18 +352,6 @@ impl pv::application::Sink for Observer {
     }
 }
 
-/// Persistent state of an observed network.
-///
-/// Information like hardware addresses and version numbers are exchanged infrequently. This data
-/// is captured and stored in `PersistentState`.
-#[derive(Debug, Clone, Eq, PartialEq, Default, serde::Serialize, serde::Deserialize)]
-pub struct PersistentState {
-    gateway_node_tables: BTreeMap<GatewayID, NodeTable>,
-
-    gateway_identities: BTreeMap<GatewayID, LongAddress>,
-    gateway_versions: BTreeMap<GatewayID, String>,
-}
-
 #[derive(Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
 struct EnumerationState {
     enumeration_gateway_id: GatewayID,
diff --git a/src/observer/event.rs b/src/observer/event.rs
index 954146e..a151d2d 100644
--- a/src/observer/event.rs
+++ b/src/observer/event.rs
@@ -48,12 +48,13 @@ pub struct Node {
     pub barcode: Option<Barcode>,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct PowerReportEvent {
+    pub event_type: String,
     /// The gateway through which the power report was received.
-    pub gateway: Gateway,
+    pub gateway: GatewayID,
     /// The node sending the power report.
-    pub node: Node,
+    pub node: NodeID,
     /// The time at which this measurement was taken.
     pub timestamp: DateTime<Local>,
     pub voltage_in: f64,
@@ -66,8 +67,8 @@ pub struct PowerReportEvent {
 
 impl PowerReportEvent {
     pub fn new(
-        gateway: Gateway,
-        node: Node,
+        gateway: GatewayID,
+        node: NodeID,
         slot_clock: &SlotClock,
         report: &pv::application::PowerReport,
     ) -> Result<Self, InvalidSlotNumber> {
@@ -85,6 +86,7 @@ impl PowerReportEvent {
         } as i16;
 
         Ok(Self {
+            event_type: "power_report".to_string(),
             gateway,
             node,
             timestamp: timestamp.into(),
@@ -105,16 +107,9 @@ mod tests {
 
     #[test]
     fn negative_temperature() {
-        let gateway = Gateway {
-            id: 1.try_into().unwrap(),
-            address: None,
-        };
-        let node = Node {
-            id: 1.try_into().unwrap(),
-            address: None,
-            barcode: None,
-        };
-
+        let event_type = "power_report".to_string();
+        let gateway = GatewayID::try_from(1).unwrap();
+        let node = NodeID::try_from(1).unwrap();
         let rssi = RSSI(100);
         let timestamp = SystemTime::now();
         let slot_counter = SlotCounter::from(0);
@@ -134,6 +129,7 @@ mod tests {
 
         let actual = serde_json::to_string(&power_report_event).unwrap();
         let expected = serde_json::to_string(&PowerReportEvent {
+            event_type,
             gateway,
             node,
             timestamp: timestamp.into(),
diff --git a/src/observer/persistent_state.rs b/src/observer/persistent_state.rs
new file mode 100644
index 0000000..c1afc05
--- /dev/null
+++ b/src/observer/persistent_state.rs
@@ -0,0 +1,165 @@
+use crate::barcode::Barcode;
+use crate::gateway::link::GatewayID;
+use crate::observer::node_table::NodeTable;
+use crate::pv::{LongAddress, NodeID};
+use schemars::{JsonSchema, Schema, SchemaGenerator};
+use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+
+/// Persistent state of an observed network.
+///
+/// Information like hardware addresses and version numbers are exchanged infrequently. This data
+/// is captured and stored in `PersistentState`.
+#[derive(Debug, Clone, Eq, PartialEq, Default, serde::Serialize, serde::Deserialize)]
+pub struct PersistentState {
+    pub gateway_node_tables: BTreeMap<GatewayID, NodeTable>,
+    pub gateway_identities: BTreeMap<GatewayID, LongAddress>,
+    pub gateway_versions: BTreeMap<GatewayID, String>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct PersistentStateEventGateway {
+    pub address: String,
+    pub version: String,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct PersistentStateEventNode {
+    pub address: String,
+    pub barcode: Barcode,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct PersistentStateEvent {
+    pub event_type: String,
+    pub gateways: BTreeMap<GatewayID, PersistentStateEventGateway>,
+    pub nodes: BTreeMap<GatewayID, BTreeMap<NodeID, PersistentStateEventNode>>,
+}
+
+impl From<&PersistentState> for PersistentStateEvent {
+    fn from(item: &PersistentState) -> Self {
+        let event_type = "infrastructure_report".to_string();
+        let gateways = item
+            .gateway_identities
+            .iter()
+            .map(|(gateway_id, long_address)| {
+                let version = item
+                    .gateway_versions
+                    .get(gateway_id)
+                    .cloned()
+                    .unwrap_or_default();
+                let address = format!(
+                    "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
+                    long_address.0[0],
+                    long_address.0[1],
+                    long_address.0[2],
+                    long_address.0[3],
+                    long_address.0[4],
+                    long_address.0[5],
+                    long_address.0[6],
+                    long_address.0[7]
+                );
+                (
+                    *gateway_id,
+                    PersistentStateEventGateway {
+                        address,
+                        version: version.clone(),
+                    },
+                )
+            })
+            .collect();
+
+        let nodes = item
+            .gateway_node_tables
+            .iter()
+            .map(|(gateway_id, table)| {
+                let nodes = table
+                    .0
+                    .iter()
+                    .map(|(node_id, long_address)| {
+                        let address = format!(
+                            "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
+                            long_address.0[0],
+                            long_address.0[1],
+                            long_address.0[2],
+                            long_address.0[3],
+                            long_address.0[4],
+                            long_address.0[5],
+                            long_address.0[6],
+                            long_address.0[7]
+                        );
+                        let barcode = long_address.into();
+                        (*node_id, PersistentStateEventNode { address, barcode })
+                    })
+                    .collect();
+                (*gateway_id, nodes)
+            })
+            .collect();
+
+        PersistentStateEvent {
+            event_type,
+            gateways,
+            nodes,
+        }
+    }
+}
+
+impl JsonSchema for PersistentStateEvent {
+    fn schema_name() -> Cow<'static, str> {
+        "PersistentState".into()
+    }
+
+    fn schema_id() -> Cow<'static, str> {
+        concat!(module_path!(), "::PersistentState").into()
+    }
+
+    fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+        schemars::json_schema!({
+            "required": ["event_type", "gateways", "nodes"],
+            "properties": {
+                "event_type": {
+                    "type": "string"
+                },
+                "gateways": {
+                    "type": "object",
+                    "properties": {
+                        "propertyNames": gen.subschema_for::<GatewayID>(),
+                        "additionalProperties": {
+                            "type": "object",
+                            "required": ["address", "version"],
+                            "properties": {
+                                "address": {
+                                    "type": "string",
+                                    "pattern": "^[0-9A-F]{2}(:[0-9A-F]{2}){7}$"
+                                },
+                                "version": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                },
+                "nodes": {
+                    "type": "object",
+                    "properties": {
+                        "propertyNames": gen.subschema_for::<NodeID>(),
+                        "additionalProperties": {
+                            "type": "object",
+                            "required": ["address", "version"],
+                            "properties": {
+                                "address": {
+                                    "type": "string",
+                                    "pattern": "^[0-9A-F]{2}(:[0-9A-F]{2}){7}$"
+                                },
+                                "barcode": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                },
+            }
+        })
+    }
+}
diff --git a/src/pv/application/node_table.rs b/src/pv/application/node_table.rs
index b837071..3943ef6 100644
--- a/src/pv/application/node_table.rs
+++ b/src/pv/application/node_table.rs
@@ -14,6 +14,7 @@ pub struct NodeTableRequest {
 #[derive(Debug, FromBytes, Immutable, KnownLayout, Unaligned)]
 #[repr(C)]
 pub struct NodeTableResponse {
+    pub start_at: NodeAddress,
     pub entries_count: big_endian::U16,
     pub entries: [NodeTableResponseEntry],
 }

From ba2f3ed0abf559aa680d73611cfb1b812ff84414 Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Sun, 26 Oct 2025 01:27:37 +0200
Subject: [PATCH 25/26] Release 0.2.0 (#5)

* fix invalid NodeTableResponse struct

* added infrastructure even in observe mode - to output in JSON gateway and node details (addresses, barcodes, versions etc.)

* added persistent storage

* Updated README to reflect implementation

* Minor logging changes

* Release 0.2.0
---
 CHANGELOG.md | 18 ++++++++++++++++++
 Cargo.lock   |  2 +-
 Cargo.toml   |  2 +-
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df6a85e..e37f6b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+
+## [0.2.0]
+
+### Added
+
+- infrastructure even in observe mode - to output in JSON gateway and nodes addresses, version and barcodes
+- persistent storage for infrastructure data
+
+### Fixed
+
+- invalid NodeTableResponse struct
+
+### Changed
+
+- format of the power report event message - this is breaking change
+- Updated README to reflect recent implementation 
+
+
 ## [0.1.2] - 2025-10-24
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index 7570e88..bc1665e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -668,7 +668,7 @@ dependencies = [
 
 [[package]]
 name = "taptap"
-version = "0.1.2"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "clap",
diff --git a/Cargo.toml b/Cargo.toml
index 219199d..1fa70a7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ authors = ["Will Glynn", "LiTinOveWeedle"]
 repository = "https://github.com/litinoveweedle/taptap"
 keywords = ["solar", "Tigo"]
 readme = "README.md"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 

From c18fcf8ab5b56369ab87f7c4ae52ce2155576f7d Mon Sep 17 00:00:00 2001
From: litinoveweedle <15144712+litinoveweedle@users.noreply.github.com>
Date: Tue, 28 Oct 2025 18:47:58 +0100
Subject: [PATCH 26/26] initial changes for merge to upstream

---
 Cargo.toml                  |  2 +-
 README.md                   |  3 ---
 src/gateway/physical/tcp.rs | 14 +-------------
 src/main.rs                 | 19 ++++---------------
 src/observer.rs             | 22 ++++++----------------
 src/observer/event.rs       |  8 ++------
 6 files changed, 14 insertions(+), 54 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 1fa70a7..c060564 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "taptap"
 description = "An implementation of the Tigo TAP protocol"
 authors = ["Will Glynn", "LiTinOveWeedle"]
-repository = "https://github.com/litinoveweedle/taptap"
+repository = "https://github.com/willglynn/taptap"
 keywords = ["solar", "Tigo"]
 readme = "README.md"
 version = "0.2.0"
diff --git a/README.md b/README.md
index 3d6c042..e7d0236 100644
--- a/README.md
+++ b/README.md
@@ -123,9 +123,6 @@ Options:
       --reconnect-timeout <SECONDS>   The time after which connection is re-established if no data is received in seconds (0 for no timeout) [default: 0]
       --reconnect-retry <INT>         The number of times to retry reconnecting before giving up (0 for infinite retries) [default: 0]
       --reconnect-delay <SECONDS>     The delay between reconnect attempts in seconds [default: 5]
-      --keepalive-idle <SECONDS>      If --tcp is specified, the idle time in seconds before keepalive probes are sent [default: 30]
-      --keepalive-interval <SECONDS>  If --tcp is specified, the interval between individual keepalive probes in seconds [default: 10]
-      --keepalive-count <SECONDS>     If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead [default: 5]
   -h, --help            Print help
   -V, --version         Print version
 ```
diff --git a/src/gateway/physical/tcp.rs b/src/gateway/physical/tcp.rs
index e7248fa..7489de0 100644
--- a/src/gateway/physical/tcp.rs
+++ b/src/gateway/physical/tcp.rs
@@ -19,10 +19,7 @@ impl Connection {
 
         enable_keepalive(&socket, keepalive)?;
 
-        Ok(Self {
-            socket,
-            readonly,
-        })
+        Ok(Self { socket, readonly })
     }
 }
 
@@ -61,13 +58,7 @@ fn enable_keepalive(socket: &TcpStream, cfg: TcpKeepaliveConfig) -> std::io::Res
 
     let mut keepalive = TcpKeepalive::new();
 
-    //if let Some(idle) = cfg.idle {
-    //    keepalive = keepalive.with_time(idle);
-    //}
     keepalive = keepalive.with_time(cfg.idle);
-    //if let Some(interval) = cfg.interval {
-    //    keepalive = keepalive.with_interval(interval);
-    //}
     keepalive = keepalive.with_interval(cfg.interval);
     // Note: .with_retries() is not available on all platforms.
     #[cfg(any(
@@ -80,9 +71,6 @@ fn enable_keepalive(socket: &TcpStream, cfg: TcpKeepaliveConfig) -> std::io::Res
     if true {
         keepalive = keepalive.with_retries(cfg.count);
     }
-    //if let Some(count) = cfg.count {
-    //    keepalive = keepalive.with_retries(count);
-    //}
 
     sock.set_tcp_keepalive(&keepalive)?;
 
diff --git a/src/main.rs b/src/main.rs
index 233090c..6e34923 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -95,18 +95,6 @@ struct Source {
     /// The delay between reconnect attempts in seconds
     #[arg(long, required = false, value_name = "SECONDS", default_value = Some("5"))]
     reconnect_delay: u64,
-
-    /// If --tcp is specified, the idle time in seconds before keepalive probes are sent
-    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("30"))]
-    keepalive_idle: u64,
-
-    /// If --tcp is specified, the interval between individual keepalive probes in seconds
-    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("10"))]
-    keepalive_interval: u64,
-
-    /// If --tcp is specified, the number of unacknowledged TCP probes before the connection is considered dead
-    #[arg(long, required = false, requires = "tcp", conflicts_with = "serial", value_name = "SECONDS", default_value = Some("5"))]
-    keepalive_count: u32,
 }
 
 impl Source {
@@ -231,9 +219,10 @@ impl From<Source> for config::SourceConfig {
                 hostname: name,
                 port: value.port,
                 mode: config::ConnectionMode::ReadOnly,
-                keepalive_idle: value.keepalive_idle,
-                keepalive_interval: value.keepalive_interval,
-                keepalive_count: value.keepalive_count,
+                // hardcode TCP keepalive setting here, might need tuning
+                keepalive_idle: 30,
+                keepalive_interval: 10,
+                keepalive_count: 5,
             }
             .into(),
             _ => {
diff --git a/src/observer.rs b/src/observer.rs
index 619e5c6..1288947 100644
--- a/src/observer.rs
+++ b/src/observer.rs
@@ -80,13 +80,6 @@ impl Observer {
             return;
         }
         let file_path = PathBuf::from(&self.persistent_file);
-        if !file_path.is_file() {
-            log::info!(
-                "persistent file: {} not found, starting with empty state",
-                self.persistent_file
-            );
-            return;
-        }
         match File::open(&file_path).and_then(|mut file| {
             let mut string = String::new();
             file.read_to_string(&mut string)?;
@@ -102,6 +95,12 @@ impl Observer {
                 let infrastructure_event = PersistentStateEvent::from(&self.persistent_state);
                 println!("{}", serde_json::to_string(&infrastructure_event).unwrap());
             }
+            Err(e) if e.kind() == io::ErrorKind::NotFound => {
+                log::info!(
+                    "persistent file: {} not found, starting with empty state",
+                    self.persistent_file
+                );
+            }
             Err(e) => {
                 log::warn!(
                     "failed to read persistent state from {}: {}",
@@ -158,15 +157,6 @@ impl Observer {
             return;
         }
 
-        if let Err(e) = file.flush() {
-            log::error!(
-                "Failed to flush temporary file {}: {}",
-                tmp_path.display(),
-                e
-            );
-            return;
-        };
-
         // Rename into place
         if let Err(e) = std::fs::rename(&tmp_path, &file_path) {
             log::error!(
diff --git a/src/observer/event.rs b/src/observer/event.rs
index a151d2d..92e462a 100644
--- a/src/observer/event.rs
+++ b/src/observer/event.rs
@@ -7,7 +7,7 @@ use chrono::{DateTime, Local};
 
 /// An event produced by an observer.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename = "snake_case")]
+#[serde(rename = "snake_case", tag = "type")]
 pub enum Event {
     PowerReport(PowerReportEvent),
 }
@@ -48,9 +48,8 @@ pub struct Node {
     pub barcode: Option<Barcode>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct PowerReportEvent {
-    pub event_type: String,
     /// The gateway through which the power report was received.
     pub gateway: GatewayID,
     /// The node sending the power report.
@@ -86,7 +85,6 @@ impl PowerReportEvent {
         } as i16;
 
         Ok(Self {
-            event_type: "power_report".to_string(),
             gateway,
             node,
             timestamp: timestamp.into(),
@@ -107,7 +105,6 @@ mod tests {
 
     #[test]
     fn negative_temperature() {
-        let event_type = "power_report".to_string();
         let gateway = GatewayID::try_from(1).unwrap();
         let node = NodeID::try_from(1).unwrap();
         let rssi = RSSI(100);
@@ -129,7 +126,6 @@ mod tests {
 
         let actual = serde_json::to_string(&power_report_event).unwrap();
         let expected = serde_json::to_string(&PowerReportEvent {
-            event_type,
             gateway,
             node,
             timestamp: timestamp.into(),