remove todo()! to avoid potential panic

machines/src/analog_input_test_machine/act.rs

@@ -26,7 +26,8 @@ impl MachineAct for AnalogInputTestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 

machines/src/aquapath1/act.rs

@@ -60,7 +60,8 @@ impl MachineAct for AquaPathV1 {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/buffer1/act.rs

@@ -48,7 +48,8 @@ impl MachineAct for BufferV1 {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/digital_input_test_machine/act.rs

@@ -40,7 +40,8 @@ impl MachineAct for DigitalInputTestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/extruder1/act.rs

@@ -76,7 +76,8 @@ impl MachineAct for ExtruderV2 {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/extruder2/act.rs

@@ -79,7 +79,8 @@ impl MachineAct for ExtruderV3 {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/ip20_test_machine/act.rs

@@ -52,7 +52,8 @@ impl MachineAct for IP20TestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/laser/act.rs

@@ -34,6 +34,23 @@ impl MachineAct for LaserMachine {
             self.emit_state();
         }
 
+        if now.duration_since(self.last_machine_send) > Duration::from_millis(1)
+        {
+            for machine in self.connected_machines.iter()
+            {
+                use crate::LiveValues;
+
+                let values = LiveValues::Laser(self.get_live_values());
+
+                if machine.connection.len() <= 5
+                {
+                    _ = machine.connection.try_send(MachineMessage::ReceiveLiveValues(values));
+                }
+            }
+
+            self.last_machine_send = now;
+        }
+
         // more than 33ms have passed since last emit (30 "fps" target)
         if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
             self.emit_live_values();
@@ -60,12 +77,22 @@ impl MachineAct for LaserMachine {
                 use crate::MachineApi;
                 let _res = self.api_mutate(value);
             }
-            MachineMessage::ConnectToMachine(_machine_connection) =>
-                /*Doesnt connect to any Machine so do nothing*/
-                {}
-            MachineMessage::DisconnectMachine(_machine_connection) =>
-                /*Doesnt connect to any Machine so do nothing*/
-                {}
+            MachineMessage::ConnectToMachine(machine_connection) =>
+            {   
+                if self.connected_machines.len() >= Self::MAX_CONNECTIONS
+                {
+                    tracing::debug!("Not adding machine connection. Max capacity reached!");
+                    return;
+                }
+
+                self.connected_machines.push(machine_connection);
+            }
+            MachineMessage::DisconnectMachine(machine_connection) =>
+            {
+                self.connected_machines
+                    .retain(|machine| 
+                        machine.ident != machine_connection.ident);
+            }
             MachineMessage::RequestValues(sender) => {
                 sender
                     .send_blocking(MachineValues {
@@ -79,6 +106,7 @@ impl MachineAct for LaserMachine {
 
                 ()
             }
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/laser/mod.rs

@@ -3,7 +3,7 @@ use crate::{
     MACHINE_LASER_V1, VENDOR_QITECH,
     machine_identification::{MachineIdentification, MachineIdentificationUnique},
 };
-use crate::{Machine, MachineMessage};
+use crate::{Machine, MachineConnection, MachineMessage};
 use api::{LaserEvents, LaserMachineNamespace, LaserState, LiveValuesEvent, StateEvent};
 use control_core::socketio::namespace::NamespaceCacheingLogic;
 use smol::{
@@ -14,6 +14,7 @@ use socketioxide::extract::SocketRef;
 use units::Length;
 
 use crate::AsyncThreadMessage;
+use std::os::unix::raw::uid_t;
 use std::{sync::Arc, time::Instant};
 use units::length::millimeter;
 
@@ -53,6 +54,11 @@ pub struct LaserMachine {
     /// This way we can signal to the client that the first state emission is a default state
     emitted_default_state: bool,
     did_change_state: bool,
+    
+    /// last time we sent live values to connected machines
+    last_machine_send:  Instant,
+
+    connected_machines: Vec<MachineConnection>,
 }
 
 impl Machine for LaserMachine {
@@ -97,6 +103,8 @@ impl LaserMachine {
         machine: MACHINE_LASER_V1,
     };
 
+    pub const MAX_CONNECTIONS: usize = 2;
+
     pub fn get_live_values(&self) -> LiveValuesEvent {
         let diameter = self.diameter.get::<millimeter>();
         let x_diameter = self.x_diameter.map(|x| x.get::<millimeter>());

machines/src/laser/new.rs

@@ -55,6 +55,8 @@ impl MachineNewTrait for LaserMachine {
             higher_tolerance: Length::new::<millimeter>(0.05),
             in_tolerance: true,
             did_change_state: true,
+            last_machine_send: Instant::now(),
+            connected_machines: Vec::new(),
         };
 
         Ok(laser_machine)

machines/src/lib.rs

@@ -38,6 +38,10 @@ pub mod wago_ai_test_machine;
 pub mod wago_do_test_machine;
 pub mod wago_power;
 pub mod winder2;
+mod live_values;
+
+pub use live_values::LiveValues;
+// pub use live_values::
 
 pub const VENDOR_QITECH: u16 = 0x0001;
 pub const MACHINE_WINDER_V1: u16 = 0x0002;
@@ -307,6 +311,7 @@ pub enum MachineMessage {
     ConnectToMachine(MachineConnection),
     DisconnectMachine(MachineConnection),
     RequestValues(Sender<MachineValues>),
+    ReceiveLiveValues(LiveValues)
 }
 
 pub trait MachineApi {
@@ -552,6 +557,7 @@ where
                     .expect("Failed to send values");
                 sender.close();
             }
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/live_values.rs

@@ -0,0 +1,7 @@
+use crate::laser::api::LiveValuesEvent as LaserLiveValues;
+
+#[derive(Debug, Clone)]
+pub enum LiveValues
+{
+    Laser(LaserLiveValues)
+}

machines/src/mock/act.rs

@@ -67,7 +67,8 @@ impl MachineAct for MockMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/test_machine/act.rs

@@ -40,7 +40,8 @@ impl MachineAct for TestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/test_machine_stepper/act.rs

@@ -27,7 +27,8 @@ impl MachineAct for TestMachineStepper {
             }
             MachineMessage::ConnectToMachine(_machine_connection) => {}
             MachineMessage::DisconnectMachine(_machine_connection) => {}
-            MachineMessage::RequestValues(_sender) => {}
+            MachineMessage::RequestValues(_sender) => {},
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/wago_8ch_dio_test_machine/act.rs

@@ -40,7 +40,8 @@ impl MachineAct for Wago8chDigitalIOTestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/wago_ai_test_machine/act.rs

@@ -24,7 +24,8 @@ impl MachineAct for WagoAiTestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 

machines/src/wago_do_test_machine/act.rs

@@ -40,7 +40,8 @@ impl MachineAct for WagoDOTestMachine {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(_) => {},
         }
     }
 }

machines/src/winder2/act.rs

@@ -7,12 +7,18 @@ use std::time::{Duration, Instant};
 
 #[cfg(not(feature = "mock-machine"))]
 impl MachineAct for Winder2 {
-    fn act(&mut self, now: Instant) {
-        let machine_message = self.api_receiver.try_recv();
-        match machine_message {
-            Ok(machine_message) => self.act_machine_message(machine_message),
-            Err(_e) => (),
-        };
+    fn act(&mut self, now: Instant) 
+    {
+        // handle up to 5 requests to not run into sync issues        
+        for _ in 0..5 
+        {
+            match self.api_receiver.try_recv() 
+            {
+                Ok(msg) => self.act_machine_message(msg),
+                Err(_) => break,
+            }
+        }
+
         // sync the spool speed
         self.sync_spool_speed(now);
 
@@ -71,7 +77,19 @@ impl MachineAct for Winder2 {
                     })
                     .expect("Failed to send values");
                 sender.close();
-            }
+            },
+            MachineMessage::ReceiveLiveValues(any_live_values) => 
+            {
+                use crate::LiveValues::Laser;
+
+                #[allow(irrefutable_let_patterns)]
+                if let Laser(live_values) = any_live_values 
+                {
+                    _ = live_values;
+
+                    // TODO: use data to regulate speed. But not idea how, when what?
+                }
+            },
         }
     }
 }