clean this code up a bit

satrs-example/src/interface/udp.rs

@@ -10,6 +10,8 @@ use satrs::{
     pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
 };
 
+use crate::pus::HandlingStatus;
+
 pub trait UdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
@@ -81,27 +83,32 @@ impl<
     > UdpTmtcServer<TcSender, TmHandler, SendError>
 {
     pub fn periodic_operation(&mut self) {
-        while self.poll_tc_server() {}
+        loop {
+            if self.poll_tc_server() == HandlingStatus::Empty {
+                break;
+            }
+        }
         if let Some(recv_addr) = self.udp_tc_server.last_sender() {
             self.tm_handler
                 .send_tm_to_udp_client(&self.udp_tc_server.socket, &recv_addr);
         }
     }
 
-    fn poll_tc_server(&mut self) -> bool {
+    fn poll_tc_server(&mut self) -> HandlingStatus {
         match self.udp_tc_server.try_recv_tc() {
-            Ok(_) => true,
+            Ok(_) => HandlingStatus::HandledOne,
-            Err(e) => match e {
+            Err(e) => {
-                ReceiveResult::Io(e) => {
+                match e {
-                    warn!("IO error {e}");
+                    ReceiveResult::NothingReceived => (),
-                    false
+                    ReceiveResult::Io(e) => {
+                        warn!("IO error {e}");
+                    }
+                    ReceiveResult::Send(send_error) => {
+                        warn!("send error {send_error:?}");
+                    }
                 }
-                ReceiveResult::NothingReceived => false,
+                HandlingStatus::Empty
-                ReceiveResult::Send(send_error) => {
+            }
-                    warn!("send error {send_error:?}");
-                    false
-                }
-            },
         }
     }
 }

satrs-example/src/pus/mod.rs

@@ -14,7 +14,6 @@ use satrs::queue::{GenericReceiveError, GenericSendError};
 use satrs::request::{Apid, GenericMessage, MessageMetadata};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusServiceId;
-use satrs::tmtc::tc_helper::StoreAndSendError;
 use satrs::ComponentId;
 use satrs_example::config::components::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
@@ -80,7 +79,7 @@ impl<TmSender: EcssTmSenderCore> PusTcDistributor<TmSender> {
         tc_in_memory: TcInMemory,
         service: u8,
         pus_tc: &PusTcReader,
-    ) -> Result<PusPacketHandlerResult, StoreAndSendError> {
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
         let init_token = self.verif_reporter.add_tc(pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
@@ -90,38 +89,26 @@ impl<TmSender: EcssTmSenderCore> PusTcDistributor<TmSender> {
         let service = PusServiceId::try_from(service);
         match service {
             Ok(standard_service) => match standard_service {
-                PusServiceId::Test => self
+                PusServiceId::Test => self.pus_router.test_tc_sender.send(EcssTcAndToken {
-                    .pus_router
+                    tc_in_memory,
-                    .test_tc_sender
+                    token: Some(accepted_token.into()),
-                    .send(EcssTcAndToken {
+                })?,
+                PusServiceId::Housekeeping => {
+                    self.pus_router.hk_tc_sender.send(EcssTcAndToken {
                         tc_in_memory,
                         token: Some(accepted_token.into()),
-                    })
+                    })?
-                    .map_err(|_| GenericSendError::RxDisconnected)?,
+                }
-                PusServiceId::Housekeeping => self
+                PusServiceId::Event => self.pus_router.event_tc_sender.send(EcssTcAndToken {
-                    .pus_router
+                    tc_in_memory,
-                    .hk_tc_sender
+                    token: Some(accepted_token.into()),
-                    .send(EcssTcAndToken {
+                })?,
+                PusServiceId::Scheduling => {
+                    self.pus_router.sched_tc_sender.send(EcssTcAndToken {
                         tc_in_memory,
                         token: Some(accepted_token.into()),
-                    })
+                    })?
-                    .map_err(|_| GenericSendError::RxDisconnected)?,
+                }
-                PusServiceId::Event => self
-                    .pus_router
-                    .event_tc_sender
-                    .send(EcssTcAndToken {
-                        tc_in_memory,
-                        token: Some(accepted_token.into()),
-                    })
-                    .map_err(|_| GenericSendError::RxDisconnected)?,
-                PusServiceId::Scheduling => self
-                    .pus_router
-                    .sched_tc_sender
-                    .send(EcssTcAndToken {
-                        tc_in_memory,
-                        token: Some(accepted_token.into()),
-                    })
-                    .map_err(|_| GenericSendError::RxDisconnected)?,
                 _ => {
                     let result = self.verif_reporter.start_failure(
                         &self.tm_sender,