eculocate

commit 22095e44dcc4ec3f4e5c24188cc443556131c993
parent f5a1064264171d17698935a914f5fb01a6ca60e1
Author: Daniel Barlow <dan@telent.net>
Date:   Thu,  1 Jan 2026 00:41:13 +0000

add state machine to track if we're probing/announcing/etc

note that probing is not actually implemented yet, nor is handling
probe responses if any are received

Diffstat:
M
ecu-esp32/src/wifi.rs
 | 
71
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------

1 file changed, 59 insertions(+), 12 deletions(-)
diff --git a/ecu-esp32/src/wifi.rs b/ecu-esp32/src/wifi.rs
@@ -19,7 +19,7 @@ use embassy_net::{
     Stack
 };
 
-use embassy_time::{Duration, Timer};
+use embassy_time::{Duration, Timer, Instant};
 use esp_alloc as _;
 use esp_backtrace as _;
 use esp_hal::{
@@ -66,9 +66,16 @@ const MDNS_ENDPOINT: IpEndpoint = IpEndpoint::new(MDNS_IP, MDNS_PORT);
 
 const CACHE_FLUSH : u16 = 1<<15;
 
+enum MdnsResponderState {
+    Probing(Instant, usize),
+    Announcing(Instant, usize),
+    Running
+}
+
 struct MdnsResponder<'a> {
     sock : UdpSocket<'a>,
     database : DnsDatabase,
+    state : MdnsResponderState
 }
 
 impl<'a> MdnsResponder<'a> {
@@ -96,15 +103,49 @@ impl<'a> MdnsResponder<'a> {
 	Self {
 	    sock,
 	    database: DnsDatabase::create(my_address, None),
+	    state: MdnsResponderState::Probing(Instant::now(), 0)
 	}
     }
 
+    async fn advance_state(&mut self) {
+	match self.state {
+	    MdnsResponderState::Probing(next_when, number_sent) => {
+		let ts = Instant::now();
+		if next_when < ts {
+		    if number_sent >= 3 {
+			self.state = MdnsResponderState::Announcing(ts, 0);
+		    } else {
+			self.send_probe().await;
+			self.state = MdnsResponderState::Probing(ts + Duration::from_millis(250), number_sent + 1);
+		    }
+		}
+	    },
+	    MdnsResponderState::Announcing(next_when, number_sent) => {
+		let ts = Instant::now();
+		if next_when < ts {
+		    if number_sent > 6 {
+			self.state = MdnsResponderState::Running;
+		    } else {
+			self.advertise().await;
+			self.state = MdnsResponderState::Announcing(ts + Duration::from_millis(1000), number_sent + 1);
+		    }
+		}
+	    },
+	    MdnsResponderState::Running => ()
+	}
+    }
+
+    async fn send_probe(&self) {
+	info!("pretend to send probe at {}", Instant::now().as_millis());
+    }
+
     async fn advertise(&self) {
-	let db = &self.database;
-	self.send_response(0, MDNS_ENDPOINT, None, db.advertised()).await;
+	info!("advertise at {}", Instant::now().as_millis());
+	self.send_response(0, MDNS_ENDPOINT, None, self.database.advertised()).await;
     }
 
-    fn may_recv(&self) -> bool {
+    async fn may_recv(&mut self) -> bool {
+	self.advance_state().await;
 	self.sock.may_recv()
     }
 
@@ -209,7 +250,8 @@ impl<'a> MdnsResponder<'a> {
 	}
     }
 
-    async fn process_packet(&self) {
+    async fn process_packet(&mut self) {
+	self.advance_state().await;
 	let mut questions = [Question::default(); 64];
 	let mut answers = [ResourceRecord::default(); 64];
 	let mut authorities = [ResourceRecord::default(); 64];
@@ -229,7 +271,14 @@ impl<'a> MdnsResponder<'a> {
 
 	    match message {
 		Result::Ok(message) => {
-		    self.send_responses(&message, &meta).await;
+		    match self.state {
+			MdnsResponderState::Probing(_,_) => {
+			    info!("probing. not responding to queries");
+			},
+			_ => {
+			    self.send_responses(&message, &meta).await;
+			}
+		    }
 		},
 		Result::Err(err) => {
 		    log::error!("parsing dns message from {:?} : {:?}",
@@ -491,7 +540,7 @@ pub async fn start_wifi(spawner: &Spawner,
     println!("Waiting to get IP address...");
     loop {
         if let Some(config) = stack.config_v4() {
-            println!("Got IP: {}", config.address);
+            println!("Got IP address: {}", config.address);
 	    my_address = config.address.address().octets();
             break;
         }
@@ -503,7 +552,7 @@ pub async fn start_wifi(spawner: &Spawner,
     let mut rx_meta = [PacketMetadata::EMPTY; 512];
     let mut tx_meta = [PacketMetadata::EMPTY; 512];
 
-    let mdns_responder = MdnsResponder::new(
+    let mut mdns_responder = MdnsResponder::new(
 	stack,
 	&mut rx_meta,
 	&mut rx_buffer,
@@ -511,14 +560,12 @@ pub async fn start_wifi(spawner: &Spawner,
 	&mut tx_buffer,
 	my_address);
 
-    mdns_responder.advertise().await;
-
     loop {
-        if mdns_responder.may_recv() {
+        if mdns_responder.may_recv().await {
 	    mdns_responder.process_packet().await;
         }
 
-        Timer::after(Duration::from_millis(80)).await;
+        Timer::after(Duration::from_millis(50)).await;
     }
 
     // _ = stack.leave_multicast_group(MDNS_IP);