Merge pull request #5 from Johnr24/withmergeresolve

Withmergeresolve

Cargo.toml

@@ -10,4 +10,6 @@ crossterm   = "0.29"
 regex       = "1.11"
 serde       = { version = "1.0", features = ["derive"] }
 serde_json  = "1.0"
-notify      = "8.1.0"
+notify      = "8.1.0"
+get_if_addrs = "0.5"
+

README.md

@@ -12,9 +12,9 @@ Inspired by the TimeTurner in the Harry Potter series, this project synchronises
 - Debian Bookworm (64-bit recommended)
 - Teensy 4.0 - https://thepihut.com/products/teensy-4-0-headers
 - Audio Adapter Board for Teensy 4.0 (Rev D) - https://thepihut.com/products/audio-adapter-board-for-teensy-4-0
-- Ethernet connection (recommended for stable NTP broadcast)
+- Ethernet connection (recommended for <1ms sync NTP broadcast)
 - Optional: LTC generator for input testing - Windows/Mac App - https://timecodesync.com/generator/
-
+- NetTime: Software to sync Windows OS to custom NTP servers - https://www.timesynctool.com/
 ---
 
 ## 🛠️ Software Features
@@ -41,3 +41,27 @@ Clone and run the installer:
 wget https://raw.githubusercontent.com/cjfranko/NTP-Timeturner/master/setup.sh
 chmod +x setup.sh
 ./setup.sh
+```
+
+---
+## 🕰️ Chrony NTP 
+```bash
+chronyc sources | Checks Source
+chronyc tracking | NTP Tracking
+sudo nano /etc/chrony/chrony.conf | Default Chrony Conf File
+
+Add to top:
+# Serve the system clock as a reference at stratum 10
+server 127.127.1.0
+allow 127.0.0.0/8
+local stratum 10
+
+Add to bottom:
+# Allow LAN clients
+allow 0.0.0.0/0
+
+# comment out:
+pool 2.debian.pool.ntp.org iburst
+sourcedir /run/chrony-dhcp
+```
+

src/sync_logic.rs

@@ -1,6 +1,4 @@
-// src/sync_logic.rs
-
-use chrono::{DateTime, Local, Timelike, Utc};
+use chrono::{DateTime, Local, Timelike, Utc};
 use regex::Captures;
 use std::collections::VecDeque;
 
@@ -43,6 +41,8 @@ pub struct LtcState {
     pub free_count: u32,
     /// Stores the last up-to-20 raw offset measurements in ms.
     pub offset_history: VecDeque<i64>,
+    /// Stores the last up-to-20 timecode Δ measurements in ms.
+    pub clock_delta_history: VecDeque<i64>,
     pub last_match_status: String,
     pub last_match_check: i64,
 }
@@ -54,12 +54,13 @@ impl LtcState {
             lock_count: 0,
             free_count: 0,
             offset_history: VecDeque::with_capacity(20),
+            clock_delta_history: VecDeque::with_capacity(20),
             last_match_status: "UNKNOWN".into(),
             last_match_check: 0,
         }
     }
 
-    /// Record one measured offset in ms, maintaining a sliding window of up to 20 samples.
+    /// Record one measured jitter offset in ms.
     pub fn record_offset(&mut self, offset_ms: i64) {
         if self.offset_history.len() == 20 {
             self.offset_history.pop_front();
@@ -67,12 +68,25 @@ impl LtcState {
         self.offset_history.push_back(offset_ms);
     }
 
-    /// Clear all stored offset measurements (e.g. on FREE-run).
+    /// Record one timecode Δ in ms.
+    pub fn record_clock_delta(&mut self, delta_ms: i64) {
+        if self.clock_delta_history.len() == 20 {
+            self.clock_delta_history.pop_front();
+        }
+        self.clock_delta_history.push_back(delta_ms);
+    }
+
+    /// Clear all stored jitter measurements.
     pub fn clear_offsets(&mut self) {
         self.offset_history.clear();
     }
 
-    /// Update LOCK/FREE counts, clear offsets on FREE, and refresh timecode-match every 5 s.
+    /// Clear all stored timecode Δ measurements.
+    pub fn clear_clock_deltas(&mut self) {
+        self.clock_delta_history.clear();
+    }
+
+    /// Update LOCK/FREE counts and timecode-match status every 5 s.
     pub fn update(&mut self, frame: LtcFrame) {
         match frame.status.as_str() {
             "LOCK" => {
@@ -81,36 +95,38 @@ impl LtcState {
             "FREE" => {
                 self.free_count += 1;
                 self.clear_offsets();
+                self.clear_clock_deltas();
                 self.last_match_status = "UNKNOWN".into();
             }
             _ => {}
         }
 
-        // Every 5 seconds, recompute whether HH:MM:SS matches local time
+        // Recompute timecode-match every 5 seconds
         let now_secs = Utc::now().timestamp();
         if now_secs - self.last_match_check >= 5 {
-            self.last_match_status = if frame.matches_system_time() {
-                "IN SYNC".into()
+            self.last_match_status = if let Some(frame) = &self.latest {
+                if frame.matches_system_time() { "IN SYNC" } else { "OUT OF SYNC" }
             } else {
-                "OUT OF SYNC".into()
-            };
+                "UNKNOWN"
+            }
+            .into();
             self.last_match_check = now_secs;
         }
 
         self.latest = Some(frame);
     }
 
-    /// Average jitter over the stored history, in milliseconds.
+    /// Average jitter over stored history, in ms.
     pub fn average_jitter(&self) -> i64 {
         if self.offset_history.is_empty() {
             0
         } else {
             let sum: i64 = self.offset_history.iter().sum();
-            sum / (self.offset_history.len() as i64)
+            sum / self.offset_history.len() as i64
         }
     }
 
-    /// Convert that average jitter into frames (rounded).
+    /// Convert average jitter into frames (rounded).
     pub fn average_frames(&self) -> i64 {
         if let Some(frame) = &self.latest {
             let ms_per_frame = 1000.0 / frame.frame_rate;
@@ -120,17 +136,27 @@ impl LtcState {
         }
     }
 
+    /// Average timecode Δ over stored history, in ms.
+    pub fn average_clock_delta(&self) -> i64 {
+        if self.clock_delta_history.is_empty() {
+            0
+        } else {
+            let sum: i64 = self.clock_delta_history.iter().sum();
+            sum / self.clock_delta_history.len() as i64
+        }
+    }
+
     /// Percentage of samples seen in LOCK state versus total.
     pub fn lock_ratio(&self) -> f64 {
         let total = self.lock_count + self.free_count;
         if total == 0 {
             0.0
         } else {
-            (self.lock_count as f64 / total as f64) * 100.0
+            self.lock_count as f64 / total as f64 * 100.0
         }
     }
 
-    /// Get the last computed timecode‐match status ("IN SYNC", "OUT OF SYNC", or "UNKNOWN").
+    /// Get timecode-match status.
     pub fn timecode_match(&self) -> &str {
         &self.last_match_status
     }
@@ -203,4 +229,4 @@ mod tests {
         assert_eq!(*state.offset_history.front().unwrap(), 5); // 0-4 are pushed out
         assert_eq!(*state.offset_history.back().unwrap(), 24);
     }
-}
+}

src/ui.rs

@@ -5,10 +5,10 @@ use std::{
     process::{self, Command},
     sync::{Arc, Mutex},
     thread,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
-use chrono::{Local, Timelike, Utc};
+use chrono::{Local, Timelike, Utc, NaiveTime, Duration as ChronoDuration, TimeZone};
 use crossterm::{
     cursor::{Hide, MoveTo, Show},
     event::{poll, read, Event, KeyCode},
@@ -17,191 +17,329 @@ use crossterm::{
     terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
 };
 
+use get_if_addrs::get_if_addrs;
+use std::collections::VecDeque;
 use crate::sync_logic::LtcState;
 
-/// Launch the TUI; reads `offset` live from the file-watcher.
+/// Check if the ntpd service is active
+fn ntp_service_active() -> bool {
+    if let Ok(output) = Command::new("systemctl").args(&["is-active", "ntpd"]).output() {
+        output.status.success() && String::from_utf8_lossy(&output.stdout).trim() == "active"
+    } else {
+        false
+    }
+}
+
+/// Toggle the ntpd service (start if `start` is true, stop otherwise)
+fn ntp_service_toggle(start: bool) {
+    let action = if start { "start" } else { "stop" };
+    let _ = Command::new("systemctl").args(&[action, "ntpd"]).status();
+}
+
+/// Launch the full-featured TUI; reads `offset` live and performs auto-sync if out of sync.
 pub fn start_ui(
     state: Arc<Mutex<LtcState>>,
     serial_port: String,
     offset: Arc<Mutex<i64>>,
 ) {
     let mut stdout = stdout();
-    execute!(stdout, EnterAlternateScreen).unwrap();
+    // Enter alternate screen and hide cursor
+    execute!(stdout, EnterAlternateScreen, Hide).unwrap();
     terminal::enable_raw_mode().unwrap();
 
+    // Recent log of messages (last 10)
+    let mut logs: VecDeque<String> = VecDeque::with_capacity(10);
+    // Tracks when we first detected out-of-sync
+    let mut out_of_sync_since: Option<Instant> = None;
+
+    // For caching the timecode delta display once per second
+    let mut last_delta_update = Instant::now() - Duration::from_secs(1);
+    let mut cached_delta_ms: i64 = 0;
+    let mut cached_delta_frames: i64 = 0;
+
     loop {
-        // 1️⃣ Read current hardware offset
+        // 1️⃣ Read hardware offset from watcher
         let hw_offset_ms = *offset.lock().unwrap();
 
-        // 2️⃣ Measure & record jitter only when LOCKED; clear on FREE
+        // 2️⃣ Check NTP service status and gather network interfaces
+        let ntp_active = ntp_service_active();
+        let interfaces: Vec<String> = get_if_addrs()
+            .unwrap_or_default()
+            .into_iter()
+            .filter(|ifa| !ifa.is_loopback())
+            .map(|ifa| ifa.ip().to_string())
+            .collect();
+
+        // 3️⃣ Measure & record jitter and Timecode Δ when LOCKED; clear on FREE
         {
             let mut st = state.lock().unwrap();
-            if let Some(frame) = &st.latest {
+            if let Some(frame) = st.latest.clone() {
                 if frame.status == "LOCK" {
+                    // Jitter in ms
                     let now = Utc::now();
                     let raw = (now - frame.timestamp).num_milliseconds();
                     let measured = raw - hw_offset_ms;
                     st.record_offset(measured);
+
+                    // Timecode delta: how far system clock differs from LTC
+                    let local = Local::now();
+                    let sub_ms = ((frame.frames as f64 / frame.frame_rate) * 1000.0).round() as i64;
+                    let base_time = NaiveTime::from_hms_opt(
+                        frame.hours,
+                        frame.minutes,
+                        frame.seconds,
+                    ).unwrap_or(local.time());
+                    let offset_dt = local.date_naive().and_time(base_time)
+                        + ChronoDuration::milliseconds(sub_ms);
+                    let ltc_dt = Local.from_local_datetime(&offset_dt)
+                        .single()
+                        .unwrap_or(local);
+                    let delta_ms = local.signed_duration_since(ltc_dt).num_milliseconds();
+                    st.record_clock_delta(delta_ms);
                 } else {
                     st.clear_offsets();
+                    st.clear_clock_deltas();
                 }
             }
         }
 
-        // 3️⃣ Draw static UI
+        // 4️⃣ Compute averages & statuses
+        let (avg_ms, avg_frames, status_str, lock_ratio, avg_delta) = {
+            let st = state.lock().unwrap();
+            (
+                st.average_jitter(),
+                st.average_frames(),
+                st.timecode_match().to_string(),
+                st.lock_ratio(),
+                st.average_clock_delta(),
+            )
+        };
+
+        // 5️⃣ Update cached delta once per second
+        if last_delta_update.elapsed() >= Duration::from_secs(1) {
+            cached_delta_ms = avg_delta;
+            // Recompute frames equivalent
+            if let Ok(st2) = state.lock() {
+                if let Some(frame) = &st2.latest {
+                    let ms_pf = 1000.0 / frame.frame_rate;
+                    cached_delta_frames = (cached_delta_ms as f64 / ms_pf).round() as i64;
+                }
+            }
+            last_delta_update = Instant::now();
+        }
+
+        // 6️⃣ Auto-sync if "OUT OF SYNC" or Δ >10ms for 5s
+        if status_str == "OUT OF SYNC" || cached_delta_ms.abs() > 10 {
+            if let Some(start) = out_of_sync_since {
+                if start.elapsed() >= Duration::from_secs(5) {
+                    // Perform sync to LTC
+                    if let Ok(stl) = state.lock() {
+                        if let Some(frame) = &stl.latest {
+                            let local_now = Local::now();
+                            let sub_ms = ((frame.frames as f64 / frame.frame_rate) * 1000.0)
+                                .round() as i64;
+                            let base_time = NaiveTime::from_hms_opt(
+                                frame.hours,
+                                frame.minutes,
+                                frame.seconds,
+                            ).unwrap_or(local_now.time());
+                            let offset_dt = local_now.date_naive().and_time(base_time)
+                                + ChronoDuration::milliseconds(sub_ms);
+                            let ltc_dt = Local.from_local_datetime(&offset_dt)
+                                .single()
+                                .unwrap_or(local_now);
+                            let ts = format!("{:02}:{:02}:{:02}.{:03}",
+                                ltc_dt.hour(),
+                                ltc_dt.minute(),
+                                ltc_dt.second(),
+                                ltc_dt.timestamp_subsec_millis()
+                            );
+                            let res = Command::new("sudo")
+                                .arg("date")
+                                .arg("-s")
+                                .arg(&ts)
+                                .status();
+                            let msg = if res.as_ref().map_or(false, |s| s.success()) {
+                                format!("🔄 Auto-synced to LTC: {}", ts)
+                            } else {
+                                "❌ Auto-sync failed".into()
+                            };
+                            if logs.len() == 10 {
+                                logs.pop_front();
+                            }
+                            logs.push_back(msg);
+                        }
+                    }
+                    out_of_sync_since = None;
+                }
+            } else {
+                out_of_sync_since = Some(Instant::now());
+            }
+        } else {
+            out_of_sync_since = None;
+        }
+
+        // 7️⃣ Draw static UI header
         queue!(
             stdout,
-            MoveTo(0, 0),
-            Clear(ClearType::All),
-            Hide,
+            MoveTo(0, 0), Clear(ClearType::All),
             MoveTo(2, 1), Print("NTP Timeturner v2 - Rust Port"),
             MoveTo(2, 2), Print(format!("Using Serial Port: {}", serial_port)),
+            MoveTo(2, 3), Print(format!("NTP Server       : {}", if ntp_active { "ACTIVE" } else { "INACTIVE" })),
+            MoveTo(2, 4), Print(format!("Interfaces       : {}", interfaces.join(", "))),
         )
         .unwrap();
 
+        // 8️⃣ Draw LTC and System Clock
         if let Ok(st) = state.lock() {
             if let Some(frame) = &st.latest {
                 queue!(
                     stdout,
-                    MoveTo(2, 4), Print(format!("LTC Status   : {}", frame.status)),
-                    MoveTo(2, 5), Print(format!(
-                        "LTC Timecode : {:02}:{:02}:{:02}:{:02}",
+                    MoveTo(2, 6), Print(format!("LTC Status       : {}", frame.status)),
+                    MoveTo(2, 7), Print(format!(
+                        "LTC Timecode     : {:02}:{:02}:{:02}:{:02}",
                         frame.hours, frame.minutes, frame.seconds, frame.frames
                     )),
-                    MoveTo(2, 6), Print(format!("Frame Rate   : {:.2}fps", frame.frame_rate)),
+                    MoveTo(2, 8), Print(format!("Frame Rate       : {:.2}fps", frame.frame_rate)),
                 )
                 .unwrap();
             } else {
                 queue!(
                     stdout,
-                    MoveTo(2, 4), Print("LTC Status   : (waiting)"),
-                    MoveTo(2, 5), Print("LTC Timecode : …"),
-                    MoveTo(2, 6), Print("Frame Rate   : …"),
+                    MoveTo(2, 6), Print("LTC Status       : (waiting)"),
+                    MoveTo(2, 7), Print("LTC Timecode     : …"),
+                    MoveTo(2, 8), Print("Frame Rate       : …"),
                 )
                 .unwrap();
             }
-
             let now_local = Local::now();
-            let sys_str = format!(
-                "{:02}:{:02}:{:02}.{:03}",
-                now_local.hour(),
-                now_local.minute(),
-                now_local.second(),
-                now_local.timestamp_subsec_millis()
+            let sys_ts = format!("{:02}:{:02}:{:02}.{:03}",
+                now_local.hour(), now_local.minute(), now_local.second(), now_local.timestamp_subsec_millis()
             );
-            queue!(
-                stdout,
-                MoveTo(2, 7),
-                Print(format!("System Clock : {}", sys_str))
-            )
-            .unwrap();
+            queue!(stdout, MoveTo(2, 9), Print(format!("System Clock     : {}", sys_ts))).unwrap();
         }
 
-        // Footer
+        // 9️⃣ Overlay metrics in new order
+        // Timecode Δ line
+        let dcol = if cached_delta_ms.abs() < 20 {
+            Color::Green
+        } else if cached_delta_ms.abs() < 100 {
+            Color::Yellow
+        } else {
+            Color::Red
+        };
         queue!(
             stdout,
-            MoveTo(2, 12),
-            Print("[S] Set system clock to LTC    [Q] Quit")
+            MoveTo(2, 11), SetForegroundColor(dcol),
+            Print(format!("Timecode Δ       : {:+} ms ({:+} frames)", cached_delta_ms, cached_delta_frames)),
+            ResetColor,
         )
         .unwrap();
 
-        stdout.flush().unwrap();
+        // Sync Status line
+        let scol = if status_str == "IN SYNC" {
+            Color::Green
+        } else {
+            Color::Red
+        };
+        queue!(
+            stdout,
+            MoveTo(2, 12), SetForegroundColor(scol),
+            Print(format!("Sync Status      : {}", status_str)),
+            ResetColor,
+        )
+        .unwrap();
 
-        // 4️⃣ Overlay Sync Jitter / Status / Ratio
-        if let Ok(st) = state.lock() {
-            let avg_ms     = st.average_jitter();
-            let avg_frames = st.average_frames();
-            let (jcol, jtxt) = if avg_ms.abs() < 10 {
-                (Color::Green, format!("{:+} ms ({:+} frames)", avg_ms, avg_frames))
-            } else if avg_ms.abs() < 40 {
-                (Color::Yellow, format!("{:+} ms ({:+} frames)", avg_ms, avg_frames))
-            } else {
-                (Color::Red, format!("{:+} ms ({:+} frames)", avg_ms, avg_frames))
-            };
-            queue!(
-                stdout,
-                MoveTo(2, 8),
-                SetForegroundColor(jcol),
-                Print("Sync Jitter  : "),
-                Print(jtxt),
-                ResetColor,
-            )
-            .ok();
+        // Sync Jitter line
+        let jstatus = if avg_ms.abs() < 10 {
+            "GOOD"
+        } else if avg_ms.abs() < 40 {
+            "AVERAGE"
+        } else {
+            "BAD"
+        };
+        let jcol = if jstatus == "GOOD" {
+            Color::Green
+        } else if jstatus == "AVERAGE" {
+            Color::Yellow
+        } else {
+            Color::Red
+        };
+        queue!(
+            stdout,
+            MoveTo(2, 13), SetForegroundColor(jcol),
+            Print(format!("Sync Jitter      : {}", jstatus)),
+            ResetColor,
+        )
+        .unwrap();
 
-            let status = st.timecode_match();
-            let scol = if status == "IN SYNC" { Color::Green } else { Color::Red };
-            queue!(
-                stdout,
-                MoveTo(2, 9),
-                SetForegroundColor(scol),
-                Print(format!("Sync Status  : {}", status)),
-                ResetColor,
-            )
-            .ok();
+        // Lock Ratio line
+        queue!(stdout,
+            MoveTo(2, 14), Print(format!("Lock Ratio       : {:.1}% LOCK", lock_ratio)),
+        )
+        .unwrap();
 
-            let ratio = st.lock_ratio();
-            queue!(
-                stdout,
-                MoveTo(2, 10),
-                Print(format!("Lock Ratio   : {:.1}% LOCK", ratio)),
-            )
-            .ok();
-
-            stdout.flush().ok();
+        // 10️⃣ Footer and logs
+        queue!(stdout,
+            MoveTo(2, 16), Print("[S] Set system clock to LTC    [Q] Quit"),
+        )
+        .unwrap();
+        for (i, log_msg) in logs.iter().enumerate() {
+            queue!(stdout, MoveTo(2, 18 + i as u16), Print(log_msg)).unwrap();
         }
 
-        // 5️⃣ Handle keypress
-        if poll(Duration::from_millis(0)).unwrap() {
+        stdout.flush().unwrap();
+
+        // 11️⃣ Handle manual sync and quit keys
+        if poll(Duration::from_millis(50)).unwrap() {
             if let Event::Key(evt) = read().unwrap() {
                 match evt.code {
-                    KeyCode::Char(c) if c.eq_ignore_ascii_case(&'s') => {
-                        // SYNC now
-                        if let Ok(st) = state.lock() {
-                            if let Some(frame) = &st.latest {
-                                // compute ms from frames
-                                let ms_from_frames =
-                                    ((frame.frames as f64 / frame.frame_rate) * 1000.0).round() as i64;
-                                // total microseconds
-                                let total_us = (ms_from_frames + hw_offset_ms) * 1000;
-                                // build date string "HH:MM:SS.mmm"
-                                let ts = format!(
-                                    "{:02}:{:02}:{:02}.{:03}",
-                                    frame.hours,
-                                    frame.minutes,
-                                    frame.seconds,
-                                    ((total_us / 1000) % 1000)
-                                );
-                                // run `sudo date -s "HH:MM:SS.mmm"`
-                                let status = Command::new("sudo")
-                                    .arg("date")
-                                    .arg("-s")
-                                    .arg(&ts)
-                                    .status();
-                                let msg = if let Ok(s) = status {
-                                    if s.success() {
-                                        format!("✔ Synced to LTC: {}", ts)
-                                    } else {
-                                        format!("❌ date cmd failed")
-                                    }
-                                } else {
-                                    format!("❌ failed to spawn date")
-                                };
-                                // print confirmation at row 14
-                                queue!(
-                                    stdout,
-                                    MoveTo(2, 14),
-                                    Print(msg),
-                                )
-                                .ok();
-                                stdout.flush().ok();
-                            }
-                        }
-                    }
                     KeyCode::Char(c) if c.eq_ignore_ascii_case(&'q') => {
                         execute!(stdout, Show, LeaveAlternateScreen).unwrap();
                         terminal::disable_raw_mode().unwrap();
                         process::exit(0);
                     }
+                    KeyCode::Char(c) if c.eq_ignore_ascii_case(&'s') => {
+                        if let Ok(stlock) = state.lock() {
+                            if let Some(frame) = &stlock.latest {
+                                let local_now = Local::now();
+                                let sub_ms = ((frame.frames as f64 / frame.frame_rate) * 1000.0)
+                                    .round() as i64;
+                                let base_time = NaiveTime::from_hms_opt(
+                                    frame.hours,
+                                    frame.minutes,
+                                    frame.seconds,
+                                )
+                                .unwrap_or(local_now.time());
+                                let offset_dt = local_now.date_naive().and_time(base_time)
+                                    + ChronoDuration::milliseconds(sub_ms);
+                                let ltc_dt = Local.from_local_datetime(&offset_dt)
+                                    .single()
+                                    .unwrap_or(local_now);
+                                let ts = format!(
+                                    "{:02}:{:02}:{:02}.{:03}",
+                                    ltc_dt.hour(),
+                                    ltc_dt.minute(),
+                                    ltc_dt.second(),
+                                    ltc_dt.timestamp_subsec_millis(),
+                                );
+                                let res = Command::new("sudo")
+                                    .arg("date")
+                                    .arg("-s")
+                                    .arg(&ts)
+                                    .status();
+                                let msg = if res.as_ref().map_or(false, |s| s.success()) {
+                                    format!("✔ Synced exactly to LTC: {}", ts)
+                                } else {
+                                    "❌ date cmd failed".into()
+                                };
+                                if logs.len() == 10 {
+                                    logs.pop_front();
+                                }
+                                logs.push_back(msg);
+                            }
+                        }
+                    }
                     _ => {}
                 }
             }