diff --git a/Cargo.toml b/Cargo.toml index 8f7f726..9d9ea61 100644 --- a/Cargo.toml +++ b/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" \ No newline at end of file +notify = "8.1.0" +get_if_addrs = "0.5" + diff --git a/README.md b/README.md index 1d48356..beea897 100644 --- a/README.md +++ b/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 +``` + diff --git a/src/sync_logic.rs b/src/sync_logic.rs index 9e38c95..10e8d25 100644 --- a/src/sync_logic.rs +++ b/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, + /// Stores the last up-to-20 timecode Δ measurements in ms. + pub clock_delta_history: VecDeque, 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 } @@ -202,5 +228,4 @@ mod tests { assert_eq!(state.offset_history.len(), 20); assert_eq!(*state.offset_history.front().unwrap(), 5); // 0-4 are pushed out assert_eq!(*state.offset_history.back().unwrap(), 24); - } -} \ No newline at end of file + } \ No newline at end of file diff --git a/src/ui.rs b/src/ui.rs index 68dd064..63cdab2 100644 --- a/src/ui.rs +++ b/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>, serial_port: String, offset: Arc>, ) { 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 = VecDeque::with_capacity(10); + // Tracks when we first detected out-of-sync + let mut out_of_sync_since: Option = 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 = 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); + } + } + } _ => {} } }