From 836fe67ec68602f0e27579fc6e56783a4596e676 Mon Sep 17 00:00:00 2001
From: ToBinio <tobias.frischmann@proton.me>
Date: Mon, 13 Jul 2026 08:21:52 +0200
Subject: [PATCH] retry registration

---
 firmware/src/communication.rs | 23 ++++++++++++++++++-----
 firmware/src/tpc.rs           | 16 ++++++++++++----
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/firmware/src/communication.rs b/firmware/src/communication.rs
index 059f1c1..a4189d7 100644
--- a/firmware/src/communication.rs
+++ b/firmware/src/communication.rs
@@ -2,6 +2,7 @@ use embassy_net::Stack;
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::channel::{Channel, Receiver, Sender};
 
+use embassy_time::{Duration, Timer};
 use log::{info, warn};
 
 use esp_backtrace as _;
@@ -24,16 +25,27 @@ pub async fn listen_register_events(
         receiver.receive().await;
         info!("Register event received");
 
-        register_at_server(stack.clone(), event_sender.clone()).await;
+        loop {
+            let succesfull = register_at_server(stack.clone(), event_sender.clone()).await;
+            if succesfull {
+                break;
+            }
+
+            Timer::after(Duration::from_millis(10_000)).await;
+            info!("Retrying registration...");
+        }
     }
 }
 
-async fn register_at_server(stack: Stack<'static>, event_sender: UpdateEventSender) {
+async fn register_at_server(stack: Stack<'static>, event_sender: UpdateEventSender) -> bool {
     let mut rx_buffer = [0; 256];
     let mut tx_buffer = [0; 256];
     let mut buf = [0u8; 256];
 
-    let mut socket = PacketSocket::connect(stack.clone(), &mut rx_buffer, &mut tx_buffer).await;
+    let Ok(mut socket) = PacketSocket::connect(stack.clone(), &mut rx_buffer, &mut tx_buffer).await
+    else {
+        return false;
+    };
 
     Packet::send(
         &mut socket,
@@ -48,7 +60,7 @@ async fn register_at_server(stack: Stack<'static>, event_sender: UpdateEventSend
 
     let Some(Packet::Ok) = Packet::read(&mut socket, &mut buf).await else {
         info!("Failed to register");
-        return;
+        return false;
     };
 
     loop {
@@ -62,7 +74,7 @@ async fn register_at_server(stack: Stack<'static>, event_sender: UpdateEventSend
             }
             None => {
                 warn!("unexpected packet: {:?}", packet);
-                return;
+                return false;
             }
         }
 
@@ -70,6 +82,7 @@ async fn register_at_server(stack: Stack<'static>, event_sender: UpdateEventSend
     }
 
     info!("Registered successfully");
+    true
 }
 
 #[embassy_executor::task]
diff --git a/firmware/src/tpc.rs b/firmware/src/tpc.rs
index 8e91eba..db125a4 100644
--- a/firmware/src/tpc.rs
+++ b/firmware/src/tpc.rs
@@ -12,6 +12,11 @@ use smoltcp::wire::Ipv4Address;
 
 pub struct PacketSocket<'a>(TcpSocket<'a>);
 
+#[derive(Debug)]
+pub enum ConnectionEror {
+    FailedToConnect,
+}
+
 impl<'a> PacketSocket<'a> {
     pub async fn bind(
         stack: Stack<'static>,
@@ -33,17 +38,20 @@ impl<'a> PacketSocket<'a> {
         stack: Stack<'static>,
         rx_buffer: &'a mut [u8],
         tx_buffer: &'a mut [u8],
-    ) -> Self {
+    ) -> Result<Self, ConnectionEror> {
         let mut stream = TcpSocket::new(stack, rx_buffer, tx_buffer);
-        stream
+        if let Err(err) = stream
             .connect(IpEndpoint::new(
                 IpAddress::Ipv4(Ipv4Address::from_str(env!("SERVER_IP")).unwrap()),
                 1234,
             ))
             .await
-            .unwrap();
+        {
+            warn!("Failed to Connect to Server - {}", err);
+            return Err(ConnectionEror::FailedToConnect);
+        }
 
-        PacketSocket(stream)
+        Ok(PacketSocket(stream))
     }
 }
 
-- 
2.51.2